From 6d06509293e2fe6b1743085471f0ff5268a1b351 Mon Sep 17 00:00:00 2001 From: Miodrag Milanovic Date: Sat, 12 Sep 2015 10:22:55 +0200 Subject: [PATCH] Added latest BX (nw) --- 3rdparty/bx/include/bx/allocator.h | 8 - 3rdparty/bx/include/bx/blockalloc.h | 99 --- 3rdparty/bx/include/bx/bx.h | 8 + 3rdparty/bx/include/bx/config.h | 1 + 3rdparty/bx/include/bx/fpumath.h | 97 ++- 3rdparty/bx/include/bx/handlealloc.h | 444 ++++++++++---- 3rdparty/bx/include/bx/hash.h | 58 +- 3rdparty/bx/include/bx/macros.h | 10 +- 3rdparty/bx/include/bx/os.h | 100 ++- 3rdparty/bx/include/bx/platform.h | 10 +- 3rdparty/bx/include/bx/process.h | 80 +++ 3rdparty/bx/include/bx/ringbuffer.h | 12 +- 3rdparty/bx/include/bx/string.h | 12 +- 3rdparty/bx/include/bx/thread.h | 71 ++- 3rdparty/bx/include/bx/uint32_t.h | 4 +- 3rdparty/bx/include/compat/freebsd/signal.h | 1 + 3rdparty/bx/include/compat/mingw/sal.h | 640 +++++++++++++++++++- 3rdparty/bx/include/tinystl/buffer.h | 48 +- 3rdparty/bx/include/tinystl/vector.h | 50 +- 3rdparty/bx/scripts/genie.lua | 1 - 3rdparty/bx/scripts/toolchain.lua | 57 +- 3rdparty/bx/scripts/unittest++.lua | 3 +- 3rdparty/bx/tests/handle.cpp | 79 +++ 3rdparty/bx/tests/misc.cpp | 8 + 3rdparty/bx/tests/uint32_t.cpp | 30 + 3rdparty/bx/tests/unordered_map_nonpod.cpp | 6 +- 3rdparty/bx/tests/vector_complex.cpp | 6 +- 3rdparty/bx/tests/vector_header.cpp | 2 +- 3rdparty/bx/tests/vector_nocopy.cpp | 229 +++++++ 3rdparty/bx/tests/vector_nodefault.cpp | 10 +- 3rdparty/bx/tools/bin/darwin/genie | Bin 431216 -> 418144 bytes 3rdparty/bx/tools/bin/linux/genie | Bin 392640 -> 392640 bytes 3rdparty/bx/tools/bin/windows/genie.exe | Bin 397312 -> 397824 bytes 33 files changed, 1883 insertions(+), 301 deletions(-) delete mode 100644 3rdparty/bx/include/bx/blockalloc.h create mode 100644 3rdparty/bx/include/bx/process.h create mode 100644 3rdparty/bx/include/compat/freebsd/signal.h create mode 100644 3rdparty/bx/tests/handle.cpp create mode 100644 3rdparty/bx/tests/misc.cpp create mode 100644 3rdparty/bx/tests/vector_nocopy.cpp diff --git a/3rdparty/bx/include/bx/allocator.h b/3rdparty/bx/include/bx/allocator.h index 3892c38feea..8d3e88ccdfd 100644 --- a/3rdparty/bx/include/bx/allocator.h +++ b/3rdparty/bx/include/bx/allocator.h @@ -58,14 +58,6 @@ namespace bx return un.ptr; } - /// Check if pointer is aligned. _align must be power of two. - inline bool isPtrAligned(const void* _ptr, size_t _align = BX_CONFIG_ALLOCATOR_NATURAL_ALIGNMENT) - { - union { const void* ptr; size_t addr; } un; - un.ptr = _ptr; - return 0 == (un.addr & (_align-1) ); - } - struct BX_NO_VTABLE AllocatorI { virtual ~AllocatorI() = 0; diff --git a/3rdparty/bx/include/bx/blockalloc.h b/3rdparty/bx/include/bx/blockalloc.h deleted file mode 100644 index 5bbeb1fbfbf..00000000000 --- a/3rdparty/bx/include/bx/blockalloc.h +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright 2010-2015 Branimir Karadzic. All rights reserved. - * License: http://www.opensource.org/licenses/BSD-2-Clause - */ - -#ifndef BX_BLOCKALLOC_H_HEADER_GUARD -#define BX_BLOCKALLOC_H_HEADER_GUARD - -#include "bx.h" - -namespace bx -{ - class BlockAlloc - { - public: - static const uint16_t invalidIndex = 0xffff; - static const uint32_t minElementSize = 2; - - BlockAlloc() - : m_data(NULL) - , m_num(0) - , m_size(0) - , m_numFree(0) - , m_freeIndex(invalidIndex) - { - } - - BlockAlloc(void* _data, uint16_t _num, uint16_t _size) - : m_data(_data) - , m_num(_num) - , m_size(_size) - , m_numFree(_num) - , m_freeIndex(0) - { - char* data = (char*)_data; - uint16_t* index = (uint16_t*)_data; - for (uint16_t ii = 0; ii < m_num-1; ++ii) - { - *index = ii+1; - data += m_size; - index = (uint16_t*)data; - } - *index = invalidIndex; - } - - ~BlockAlloc() - { - } - - void* alloc() - { - if (invalidIndex == m_freeIndex) - { - return NULL; - } - - void* obj = ( (char*)m_data) + m_freeIndex*m_size; - m_freeIndex = *( (uint16_t*)obj); - --m_numFree; - - return obj; - } - - void free(void* _obj) - { - uint16_t index = getIndex(_obj); - BX_CHECK(index < m_num, "index %d, m_num %d", index, m_num); - - *( (uint16_t*)_obj) = m_freeIndex; - m_freeIndex = index; - ++m_numFree; - } - - uint16_t getIndex(void* _obj) const - { - return (uint16_t)( ( (char*)_obj - (char*)m_data ) / m_size); - } - - uint16_t getNumFree() const - { - return m_numFree; - } - - void* getFromIndex(uint16_t _index) - { - return (char*)m_data + _index*m_size; - } - - private: - void* m_data; - uint16_t m_num; - uint16_t m_size; - uint16_t m_numFree; - uint16_t m_freeIndex; - }; - -} // namespace bx - -#endif // BX_BLOCKALLOC_H_HEADER_GUARD diff --git a/3rdparty/bx/include/bx/bx.h b/3rdparty/bx/include/bx/bx.h index 54206474355..48ba9701fb8 100644 --- a/3rdparty/bx/include/bx/bx.h +++ b/3rdparty/bx/include/bx/bx.h @@ -44,6 +44,14 @@ namespace bx Ty tmp = _a; _a = _b; _b = tmp; } + /// Check if pointer is aligned. _align must be power of two. + inline bool isPtrAligned(const void* _ptr, size_t _align) + { + union { const void* ptr; size_t addr; } un; + un.ptr = _ptr; + return 0 == (un.addr & (_align-1) ); + } + } // namespace bx // Annoying C++0x stuff.. diff --git a/3rdparty/bx/include/bx/config.h b/3rdparty/bx/include/bx/config.h index 6447055c4cc..9a439f98651 100644 --- a/3rdparty/bx/include/bx/config.h +++ b/3rdparty/bx/include/bx/config.h @@ -24,6 +24,7 @@ # define BX_CONFIG_CRT_FILE_READER_WRITER (0 \ || BX_PLATFORM_ANDROID \ || BX_PLATFORM_FREEBSD \ + || BX_PLATFORM_EMSCRIPTEN \ || BX_PLATFORM_IOS \ || BX_PLATFORM_LINUX \ || BX_PLATFORM_OSX \ diff --git a/3rdparty/bx/include/bx/fpumath.h b/3rdparty/bx/include/bx/fpumath.h index 37d4fec636e..0aa92c8523c 100644 --- a/3rdparty/bx/include/bx/fpumath.h +++ b/3rdparty/bx/include/bx/fpumath.h @@ -31,7 +31,7 @@ namespace bx inline float fround(float _f) { - return float(int(_f) ); + return floorf(_f + 0.5f); } inline float fmin(float _a, float _b) @@ -121,6 +121,25 @@ namespace bx return result; } + // References: + // - Bias And Gain Are Your Friend + // http://blog.demofox.org/2012/09/24/bias-and-gain-are-your-friend/ + // - http://demofox.org/biasgain.html + inline float fbias(float _time, float _bias) + { + return _time / ( ( (1.0f/_bias - 2.0f)*(1.0f - _time) ) + 1.0f); + } + + inline float fgain(float _time, float _gain) + { + if (_time < 0.5f) + { + return fbias(_time * 2.0f, _gain) * 0.5f; + } + + return fbias(_time * 2.0f - 1.0f, 1.0f - _gain) * 0.5f + 0.5f; + } + inline void vec3Move(float* __restrict _result, const float* __restrict _a) { _result[0] = _a[0]; @@ -833,6 +852,82 @@ namespace bx _result[3] = -vec3Dot(normal, _va); } + inline void calcLinearFit2D(float _result[2], const void* _points, uint32_t _stride, uint32_t _numPoints) + { + float sumX = 0.0f; + float sumY = 0.0f; + float sumXX = 0.0f; + float sumXY = 0.0f; + + const uint8_t* ptr = (const uint8_t*)_points; + for (uint32_t ii = 0; ii < _numPoints; ++ii, ptr += _stride) + { + const float* point = (const float*)ptr; + float xx = point[0]; + float yy = point[1]; + sumX += xx; + sumY += yy; + sumXX += xx*xx; + sumXY += xx*yy; + } + + // [ sum(x^2) sum(x) ] [ A ] = [ sum(x*y) ] + // [ sum(x) numPoints ] [ B ] [ sum(y) ] + + float det = (sumXX*_numPoints - sumX*sumX); + float invDet = 1.0f/det; + + _result[0] = (-sumX * sumY + _numPoints * sumXY) * invDet; + _result[1] = (sumXX * sumY - sumX * sumXY) * invDet; + } + + inline void calcLinearFit3D(float _result[3], const void* _points, uint32_t _stride, uint32_t _numPoints) + { + float sumX = 0.0f; + float sumY = 0.0f; + float sumZ = 0.0f; + float sumXX = 0.0f; + float sumXY = 0.0f; + float sumXZ = 0.0f; + float sumYY = 0.0f; + float sumYZ = 0.0f; + + const uint8_t* ptr = (const uint8_t*)_points; + for (uint32_t ii = 0; ii < _numPoints; ++ii, ptr += _stride) + { + const float* point = (const float*)ptr; + float xx = point[0]; + float yy = point[1]; + float zz = point[2]; + + sumX += xx; + sumY += yy; + sumZ += zz; + sumXX += xx*xx; + sumXY += xx*yy; + sumXZ += xx*zz; + sumYY += yy*yy; + sumYZ += yy*zz; + } + + // [ sum(x^2) sum(x*y) sum(x) ] [ A ] [ sum(x*z) ] + // [ sum(x*y) sum(y^2) sum(y) ] [ B ] = [ sum(y*z) ] + // [ sum(x) sum(y) numPoints ] [ C ] [ sum(z) ] + + float mtx[9] = + { + sumXX, sumXY, sumX, + sumXY, sumYY, sumY, + sumX, sumY, float(_numPoints), + }; + float invMtx[9]; + mtx3Inverse(invMtx, mtx); + + _result[0] = invMtx[0]*sumXZ + invMtx[1]*sumYZ + invMtx[2]*sumZ; + _result[1] = invMtx[3]*sumXZ + invMtx[4]*sumYZ + invMtx[5]*sumZ; + _result[2] = invMtx[6]*sumXZ + invMtx[7]*sumYZ + invMtx[8]*sumZ; + } + inline void rgbToHsv(float _hsv[3], const float _rgb[3]) { const float rr = _rgb[0]; diff --git a/3rdparty/bx/include/bx/handlealloc.h b/3rdparty/bx/include/bx/handlealloc.h index 41dbd4fd142..332fa1d96f1 100644 --- a/3rdparty/bx/include/bx/handlealloc.h +++ b/3rdparty/bx/include/bx/handlealloc.h @@ -11,102 +11,16 @@ namespace bx { - template - class HandleAllocT - { - public: - static const uint16_t invalid = 0xffff; - - HandleAllocT() - : m_numHandles(0) - { - for (uint16_t ii = 0; ii < MaxHandlesT; ++ii) - { - m_handles[ii] = ii; - } - } - - ~HandleAllocT() - { - } - - const uint16_t* getHandles() const - { - return m_handles; - } - - uint16_t getHandleAt(uint16_t _at) const - { - return m_handles[_at]; - } - - uint16_t getNumHandles() const - { - return m_numHandles; - } - - uint16_t getMaxHandles() const - { - return MaxHandlesT; - } - - uint16_t alloc() - { - if (m_numHandles < MaxHandlesT) - { - uint16_t index = m_numHandles; - ++m_numHandles; - - uint16_t handle = m_handles[index]; - uint16_t* sparse = &m_handles[MaxHandlesT]; - sparse[handle] = index; - return handle; - } - - return invalid; - } - - bool isValid(uint16_t _handle) - { - uint16_t* sparse = &m_handles[MaxHandlesT]; - uint16_t index = sparse[_handle]; - - return index < m_numHandles - && m_handles[index] == _handle - ; - } - - void free(uint16_t _handle) - { - BX_CHECK(0 < m_numHandles, "Freeing invalid handle %d.", _handle); - uint16_t* sparse = &m_handles[MaxHandlesT]; - uint16_t index = sparse[_handle]; - --m_numHandles; - uint16_t temp = m_handles[m_numHandles]; - m_handles[m_numHandles] = _handle; - sparse[temp] = index; - m_handles[index] = temp; - } - - private: - uint16_t m_handles[MaxHandlesT*2]; - uint16_t m_numHandles; - }; - class HandleAlloc { public: - static const uint16_t invalid = 0xffff; + static const uint16_t invalid = UINT16_MAX; - HandleAlloc(uint16_t _maxHandles, void* _handles) - : m_handles( (uint16_t*)_handles) - , m_numHandles(0) + HandleAlloc(uint16_t _maxHandles) + : m_numHandles(0) , m_maxHandles(_maxHandles) { - for (uint16_t ii = 0; ii < _maxHandles; ++ii) - { - m_handles[ii] = ii; - } + reset(); } ~HandleAlloc() @@ -115,12 +29,12 @@ namespace bx const uint16_t* getHandles() const { - return m_handles; + return getDensePtr(); } uint16_t getHandleAt(uint16_t _at) const { - return m_handles[_at]; + return getDensePtr()[_at]; } uint16_t getNumHandles() const @@ -140,8 +54,9 @@ namespace bx uint16_t index = m_numHandles; ++m_numHandles; - uint16_t handle = m_handles[index]; - uint16_t* sparse = &m_handles[m_maxHandles]; + uint16_t* dense = getDensePtr(); + uint16_t handle = dense[index]; + uint16_t* sparse = getSparsePtr(); sparse[handle] = index; return handle; } @@ -149,27 +64,53 @@ namespace bx return invalid; } - bool isValid(uint16_t _handle) + bool isValid(uint16_t _handle) const { - uint16_t* sparse = &m_handles[m_maxHandles]; - uint16_t index = sparse[_handle]; + uint16_t* dense = getDensePtr(); + uint16_t* sparse = getSparsePtr(); + uint16_t index = sparse[_handle]; - return (index < m_numHandles && m_handles[index] == _handle); + return index < m_numHandles + && dense[index] == _handle + ; } void free(uint16_t _handle) { - uint16_t* sparse = &m_handles[m_maxHandles]; + uint16_t* dense = getDensePtr(); + uint16_t* sparse = getSparsePtr(); uint16_t index = sparse[_handle]; --m_numHandles; - uint16_t temp = m_handles[m_numHandles]; - m_handles[m_numHandles] = _handle; + uint16_t temp = dense[m_numHandles]; + dense[m_numHandles] = _handle; sparse[temp] = index; - m_handles[index] = temp; + dense[index] = temp; + } + + void reset() + { + m_numHandles = 0; + uint16_t* dense = getDensePtr(); + for (uint16_t ii = 0, num = m_maxHandles; ii < num; ++ii) + { + dense[ii] = ii; + } } private: - uint16_t* m_handles; + HandleAlloc(); + + uint16_t* getDensePtr() const + { + uint8_t* ptr = (uint8_t*)reinterpret_cast(this); + return (uint16_t*)&ptr[sizeof(HandleAlloc)]; + } + + uint16_t* getSparsePtr() const + { + return &getDensePtr()[m_maxHandles]; + } + uint16_t m_numHandles; uint16_t m_maxHandles; }; @@ -177,7 +118,7 @@ namespace bx inline HandleAlloc* createHandleAlloc(AllocatorI* _allocator, uint16_t _maxHandles) { uint8_t* ptr = (uint8_t*)BX_ALLOC(_allocator, sizeof(HandleAlloc) + 2*_maxHandles*sizeof(uint16_t) ); - return ::new (ptr) HandleAlloc(_maxHandles, &ptr[sizeof(HandleAlloc)]); + return ::new (ptr) HandleAlloc(_maxHandles); } inline void destroyHandleAlloc(AllocatorI* _allocator, HandleAlloc* _handleAlloc) @@ -186,6 +127,301 @@ namespace bx BX_FREE(_allocator, _handleAlloc); } + template + class HandleAllocT : public HandleAlloc + { + public: + HandleAllocT() + : HandleAlloc(MaxHandlesT) + { + } + + ~HandleAllocT() + { + } + + private: + uint16_t m_padding[2*MaxHandlesT]; + }; + + template + class HandleListT + { + public: + static const uint16_t invalid = UINT16_MAX; + + HandleListT() + : m_front(invalid) + , m_back(invalid) + { + reset(); + } + + void pushBack(uint16_t _handle) + { + insertAfter(m_back, _handle); + } + + uint16_t popBack() + { + uint16_t last = invalid != m_back + ? m_back + : m_front + ; + + if (invalid != last) + { + remove(last); + } + + return last; + } + + void pushFront(uint16_t _handle) + { + insertBefore(m_front, _handle); + } + + uint16_t popFront() + { + uint16_t front = m_front; + + if (invalid != front) + { + remove(front); + } + + return front; + } + + uint16_t getFront() const + { + return m_front; + } + + uint16_t getBack() const + { + return m_back; + } + + uint16_t getNext(uint16_t _handle) const + { + BX_CHECK(isValid(_handle), "Invalid handle %d!", _handle); + const Link& curr = m_links[_handle]; + return curr.m_next; + } + + uint16_t getPrev(uint16_t _handle) const + { + BX_CHECK(isValid(_handle), "Invalid handle %d!", _handle); + const Link& curr = m_links[_handle]; + return curr.m_prev; + } + + void remove(uint16_t _handle) + { + BX_CHECK(isValid(_handle), "Invalid handle %d!", _handle); + Link& curr = m_links[_handle]; + + if (invalid != curr.m_prev) + { + Link& prev = m_links[curr.m_prev]; + prev.m_next = curr.m_next; + } + else + { + m_front = curr.m_next; + } + + if (invalid != curr.m_next) + { + Link& next = m_links[curr.m_next]; + next.m_prev = curr.m_prev; + } + else + { + m_back = curr.m_prev; + } + + curr.m_prev = invalid; + curr.m_next = invalid; + } + + void reset() + { + memset(m_links, 0xff, sizeof(m_links) ); + } + + private: + void insertBefore(int16_t _before, uint16_t _handle) + { + Link& curr = m_links[_handle]; + curr.m_next = _before; + + if (invalid != _before) + { + Link& link = m_links[_before]; + if (invalid != link.m_prev) + { + Link& prev = m_links[link.m_prev]; + prev.m_next = _handle; + } + + curr.m_prev = link.m_prev; + link.m_prev = _handle; + } + + updateFrontBack(_handle); + } + + void insertAfter(uint16_t _after, uint16_t _handle) + { + Link& curr = m_links[_handle]; + curr.m_prev = _after; + + if (invalid != _after) + { + Link& link = m_links[_after]; + if (invalid != link.m_next) + { + Link& next = m_links[link.m_next]; + next.m_prev = _handle; + } + + curr.m_next = link.m_next; + link.m_next = _handle; + } + + updateFrontBack(_handle); + } + + bool isValid(uint16_t _handle) const + { + return _handle < MaxHandlesT; + } + + void updateFrontBack(uint16_t _handle) + { + Link& curr = m_links[_handle]; + + if (invalid == curr.m_prev) + { + m_front = _handle; + } + + if (invalid == curr.m_next) + { + m_back = _handle; + } + } + + uint16_t m_front; + uint16_t m_back; + + struct Link + { + uint16_t m_prev; + uint16_t m_next; + }; + + Link m_links[MaxHandlesT]; + }; + + template + class HandleAllocLruT + { + public: + static const uint16_t invalid = UINT16_MAX; + + HandleAllocLruT() + { + reset(); + } + + ~HandleAllocLruT() + { + } + + const uint16_t* getHandles() const + { + return m_alloc.getHandles(); + } + + uint16_t getHandleAt(uint16_t _at) const + { + return m_alloc.getHandleAt(_at); + } + + uint16_t getNumHandles() const + { + return m_alloc.getNumHandles(); + } + + uint16_t getMaxHandles() const + { + return m_alloc.getMaxHandles(); + } + + uint16_t alloc() + { + uint16_t handle = m_alloc.alloc(); + if (invalid != handle) + { + m_list.pushFront(handle); + } + return handle; + } + + bool isValid(uint16_t _handle) const + { + return m_alloc.isValid(_handle); + } + + void free(uint16_t _handle) + { + BX_CHECK(isValid(_handle), "Invalid handle %d!", _handle); + m_list.remove(_handle); + m_alloc.free(_handle); + } + + void touch(uint16_t _handle) + { + BX_CHECK(isValid(_handle), "Invalid handle %d!", _handle); + m_list.remove(_handle); + m_list.pushFront(_handle); + } + + uint16_t getFront() const + { + return m_list.getFront(); + } + + uint16_t getBack() const + { + return m_list.getBack(); + } + + uint16_t getNext(uint16_t _handle) const + { + return m_list.getNext(_handle); + } + + uint16_t getPrev(uint16_t _handle) const + { + return m_list.getPrev(_handle); + } + + void reset() + { + m_list.reset(); + m_alloc.reset(); + } + + private: + HandleListT m_list; + HandleAllocT m_alloc; + }; + } // namespace bx #endif // BX_HANDLE_ALLOC_H_HEADER_GUARD diff --git a/3rdparty/bx/include/bx/hash.h b/3rdparty/bx/include/bx/hash.h index d41bb3793e3..d2f11731552 100644 --- a/3rdparty/bx/include/bx/hash.h +++ b/3rdparty/bx/include/bx/hash.h @@ -30,7 +30,19 @@ namespace bx void add(const void* _data, int _len) { - const uint8_t* data = (uint8_t*)_data; + if (BX_ENABLED(BX_PLATFORM_EMSCRIPTEN) + && BX_UNLIKELY(!isPtrAligned(_data, 4) ) ) + { + addUnaligned(_data, _len); + return; + } + + addAligned(_data, _len); + } + + void addAligned(const void* _data, int _len) + { + const uint8_t* data = (const uint8_t*)_data; m_size += _len; mixTail(data, _len); @@ -48,6 +60,27 @@ namespace bx mixTail(data, _len); } + void addUnaligned(const void* _data, int _len) + { + const uint8_t* data = (const uint8_t*)_data; + m_size += _len; + + mixTail(data, _len); + + while(_len >= 4) + { + uint32_t kk; + readUnaligned(data, kk); + + mmix(m_hash, kk); + + data += 4; + _len -= 4; + } + + mixTail(data, _len); + } + template void add(Ty _value) { @@ -67,6 +100,29 @@ namespace bx } private: + static void readUnaligned(const void* _data, uint32_t& _out) + { + const uint8_t* data = (const uint8_t*)_data; + if (BX_ENABLED(BX_CPU_ENDIAN_LITTLE) ) + { + _out = 0 + | data[0]<<24 + | data[1]<<16 + | data[2]<<8 + | data[3] + ; + } + else + { + _out = 0 + | data[0] + | data[1]<<8 + | data[2]<<16 + | data[3]<<24 + ; + } + } + void mixTail(const uint8_t*& _data, int& _len) { while( _len && ((_len<4) || m_count) ) diff --git a/3rdparty/bx/include/bx/macros.h b/3rdparty/bx/include/bx/macros.h index 5086b7e8d6d..279343b9715 100644 --- a/3rdparty/bx/include/bx/macros.h +++ b/3rdparty/bx/include/bx/macros.h @@ -53,6 +53,8 @@ # define BX_ALLOW_UNUSED __attribute__( (unused) ) # define BX_FORCE_INLINE __extension__ static __inline __attribute__( (__always_inline__) ) # define BX_FUNCTION __PRETTY_FUNCTION__ +# define BX_LIKELY(_x) __builtin_expect(!!(_x), 1) +# define BX_UNLIKELY(_x) __builtin_expect(!!(_x), 0) # define BX_NO_INLINE __attribute__( (noinline) ) # define BX_NO_RETURN __attribute__( (noreturn) ) # define BX_NO_VTABLE @@ -61,11 +63,7 @@ # if BX_COMPILER_CLANG && (BX_PLATFORM_OSX || BX_PLATFORM_IOS) # define BX_THREAD /* not supported right now */ # else -# if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 2) -# define BX_THREAD /* not supported right now */ -# else -# define BX_THREAD __thread -# endif // __GNUC__ <= 4.2 +# define BX_THREAD __thread # endif // BX_COMPILER_CLANG # define BX_ATTRIBUTE(_x) __attribute__( (_x) ) # if BX_COMPILER_MSVC_COMPATIBLE @@ -76,6 +74,8 @@ # define BX_ALLOW_UNUSED # define BX_FORCE_INLINE __forceinline # define BX_FUNCTION __FUNCTION__ +# define BX_LIKELY(_x) (_x) +# define BX_UNLIKELY(_x) (_x) # define BX_NO_INLINE __declspec(noinline) # define BX_NO_RETURN # define BX_NO_VTABLE __declspec(novtable) diff --git a/3rdparty/bx/include/bx/os.h b/3rdparty/bx/include/bx/os.h index 5daae404b8c..e188d57e26e 100644 --- a/3rdparty/bx/include/bx/os.h +++ b/3rdparty/bx/include/bx/os.h @@ -11,18 +11,23 @@ #if BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT # include -#elif BX_PLATFORM_ANDROID \ +# include +#elif BX_PLATFORM_ANDROID \ || BX_PLATFORM_EMSCRIPTEN \ || BX_PLATFORM_FREEBSD \ || BX_PLATFORM_IOS \ || BX_PLATFORM_LINUX \ || BX_PLATFORM_NACL \ - || BX_PLATFORM_NETBSD \ || BX_PLATFORM_OSX \ + || BX_PLATFORM_PS4 \ || BX_PLATFORM_RPI # include // sched_yield -# if BX_PLATFORM_FREEBSD || BX_PLATFORM_IOS || BX_PLATFORM_NACL || BX_PLATFORM_NETBSD || BX_PLATFORM_OSX +# if BX_PLATFORM_FREEBSD \ + || BX_PLATFORM_IOS \ + || BX_PLATFORM_NACL \ + || BX_PLATFORM_OSX \ + || BX_PLATFORM_PS4 # include // mach_port_t # endif // BX_PLATFORM_IOS || BX_PLATFORM_OSX || BX_PLATFORM_NACL @@ -30,15 +35,19 @@ # include // nanosleep # else # include // nanosleep -# include // dlopen, dlclose, dlsym +# if !BX_PLATFORM_PS4 +# include // dlopen, dlclose, dlsym +# endif // !BX_PLATFORM_PS4 # endif // BX_PLATFORM_NACL -# if BX_PLATFORM_LINUX || BX_PLATFORM_RPI +# if BX_PLATFORM_ANDROID +# include // mallinfo +# elif BX_PLATFORM_LINUX || BX_PLATFORM_RPI # include // syscall # include -# endif // BX_PLATFORM_LINUX || BX_PLATFORM_RPI - -# if BX_PLATFORM_ANDROID +# elif BX_PLATFORM_OSX +# include // mach_task_basic_info +# elif BX_PLATFORM_ANDROID # include "debug.h" // getTid is not implemented... # endif // BX_PLATFORM_ANDROID #endif // BX_PLATFORM_ @@ -94,7 +103,7 @@ namespace bx return (pid_t)::syscall(SYS_gettid); #elif BX_PLATFORM_IOS || BX_PLATFORM_OSX return (mach_port_t)::pthread_mach_thread_np(pthread_self() ); -#elif BX_PLATFORM_FREEBSD || BX_PLATFORM_NACL || BX_PLATFORM_NETBSD +#elif BX_PLATFORM_FREEBSD || BX_PLATFORM_NACL // Casting __nc_basic_thread_data*... need better way to do this. return *(uint32_t*)::pthread_self(); #else @@ -104,11 +113,60 @@ namespace bx #endif // } + inline size_t getProcessMemoryUsed() + { +#if BX_PLATFORM_ANDROID + struct mallinfo mi = mallinfo(); + return mi.uordblks; +#elif BX_PLATFORM_LINUX + FILE* file = fopen("/proc/self/statm", "r"); + if (NULL == file) + { + return 0; + } + + long pages = 0; + int items = fscanf(file, "%*s%ld", &pages); + fclose(file); + return 1 == items + ? pages * sysconf(_SC_PAGESIZE) + : 0 + ; +#elif BX_PLATFORM_OSX + mach_task_basic_info info; + mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT; + + int result = task_info(mach_task_self() + , MACH_TASK_BASIC_INFO + , (task_info_t)&info + , &infoCount + ); + if (KERN_SUCCESS != result) + { + return 0; + } + + return info.resident_size; +#elif BX_PLATFORM_WINDOWS + PROCESS_MEMORY_COUNTERS pmc; + GetProcessMemoryInfo(GetCurrentProcess() + , &pmc + , sizeof(pmc) + ); + return pmc.WorkingSetSize; +#else + return 0; +#endif // BX_PLATFORM_* + } + inline void* dlopen(const char* _filePath) { #if BX_PLATFORM_WINDOWS return (void*)::LoadLibraryA(_filePath); -#elif BX_PLATFORM_NACL || BX_PLATFORM_EMSCRIPTEN || BX_PLATFORM_WINRT +#elif BX_PLATFORM_EMSCRIPTEN \ + || BX_PLATFORM_NACL \ + || BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_filePath); return NULL; #else @@ -120,7 +178,10 @@ namespace bx { #if BX_PLATFORM_WINDOWS ::FreeLibrary( (HMODULE)_handle); -#elif BX_PLATFORM_NACL || BX_PLATFORM_EMSCRIPTEN || BX_PLATFORM_WINRT +#elif BX_PLATFORM_EMSCRIPTEN \ + || BX_PLATFORM_NACL \ + || BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_handle); #else ::dlclose(_handle); @@ -131,7 +192,10 @@ namespace bx { #if BX_PLATFORM_WINDOWS return (void*)::GetProcAddress( (HMODULE)_handle, _symbol); -#elif BX_PLATFORM_NACL || BX_PLATFORM_EMSCRIPTEN || BX_PLATFORM_WINRT +#elif BX_PLATFORM_EMSCRIPTEN \ + || BX_PLATFORM_NACL \ + || BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_handle, _symbol); return NULL; #else @@ -143,7 +207,8 @@ namespace bx { #if BX_PLATFORM_WINDOWS ::SetEnvironmentVariableA(_name, _value); -#elif BX_PLATFORM_WINRT +#elif BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_name, _value); #else ::setenv(_name, _value, 1); @@ -154,7 +219,8 @@ namespace bx { #if BX_PLATFORM_WINDOWS ::SetEnvironmentVariableA(_name, NULL); -#elif BX_PLATFORM_WINRT +#elif BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_name); #else ::unsetenv(_name); @@ -163,7 +229,8 @@ namespace bx inline int chdir(const char* _path) { -#if BX_PLATFORM_WINRT +#if BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_path); return -1; #elif BX_COMPILER_MSVC_COMPATIBLE @@ -175,7 +242,8 @@ namespace bx inline char* pwd(char* _buffer, uint32_t _size) { -#if BX_PLATFORM_WINRT +#if BX_PLATFORM_PS4 \ + || BX_PLATFORM_WINRT BX_UNUSED(_buffer, _size); return NULL; #elif BX_COMPILER_MSVC_COMPATIBLE diff --git a/3rdparty/bx/include/bx/platform.h b/3rdparty/bx/include/bx/platform.h index 962a8a6fc6d..d272a17688c 100644 --- a/3rdparty/bx/include/bx/platform.h +++ b/3rdparty/bx/include/bx/platform.h @@ -18,7 +18,6 @@ #define BX_PLATFORM_IOS 0 #define BX_PLATFORM_LINUX 0 #define BX_PLATFORM_NACL 0 -#define BX_PLATFORM_NETBSD 0 #define BX_PLATFORM_OSX 0 #define BX_PLATFORM_PS4 0 #define BX_PLATFORM_QNX 0 @@ -176,7 +175,7 @@ #elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) # undef BX_PLATFORM_OSX # define BX_PLATFORM_OSX 1 -#elif defined(EMSCRIPTEN) +#elif defined(__EMSCRIPTEN__) # undef BX_PLATFORM_EMSCRIPTEN # define BX_PLATFORM_EMSCRIPTEN 1 #elif defined(__ORBIS__) @@ -188,9 +187,6 @@ #elif defined(__FreeBSD__) # undef BX_PLATFORM_FREEBSD # define BX_PLATFORM_FREEBSD 1 -#elif defined(__NetBSD__) -# undef BX_PLATFORM_NETBSD -# define BX_PLATFORM_NETBSD 1 #else # error "BX_PLATFORM_* is not defined!" #endif // @@ -202,9 +198,9 @@ || BX_PLATFORM_IOS \ || BX_PLATFORM_LINUX \ || BX_PLATFORM_NACL \ - || BX_PLATFORM_NETBSD \ || BX_PLATFORM_OSX \ || BX_PLATFORM_QNX \ + || BX_PLATFORM_PS4 \ || BX_PLATFORM_RPI \ ) @@ -255,8 +251,6 @@ #elif BX_PLATFORM_NACL # define BX_PLATFORM_NAME "NaCl " \ BX_STRINGIZE(BX_PLATFORM_NACL) -#elif BX_PLATFORM_NETBSD -# define BX_PLATFORM_NAME "NetBSD" #elif BX_PLATFORM_OSX # define BX_PLATFORM_NAME "OSX" #elif BX_PLATFORM_PS4 diff --git a/3rdparty/bx/include/bx/process.h b/3rdparty/bx/include/bx/process.h new file mode 100644 index 00000000000..60fc24c5d9b --- /dev/null +++ b/3rdparty/bx/include/bx/process.h @@ -0,0 +1,80 @@ +/* + * Copyright 2010-2015 Branimir Karadzic. All rights reserved. + * License: http://www.opensource.org/licenses/BSD-2-Clause + */ + +#ifndef BX_PROCESS_H_HEADER_GUARD +#define BX_PROCESS_H_HEADER_GUARD + +#include "string.h" +#include "uint32_t.h" + +#if BX_PLATFORM_LINUX +# include +#endif // BX_PLATFORM_LINUX + +namespace bx +{ + /// + inline void* exec(const char* const* _argv) + { +#if BX_PLATFORM_LINUX + pid_t pid = fork(); + + if (0 == pid) + { + int result = execvp(_argv[0], const_cast(&_argv[1]) ); + BX_UNUSED(result); + return NULL; + } + + return (void*)uintptr_t(pid); +#elif BX_PLATFORM_WINDOWS + STARTUPINFO si; + memset(&si, 0, sizeof(STARTUPINFO) ); + si.cb = sizeof(STARTUPINFO); + + PROCESS_INFORMATION pi; + memset(&pi, 0, sizeof(PROCESS_INFORMATION) ); + + int32_t total = 0; + for (uint32_t ii = 0; NULL != _argv[ii]; ++ii) + { + total += (int32_t)strlen(_argv[ii]) + 1; + } + + char* temp = (char*)alloca(total); + int32_t len = 0; + for(uint32_t ii = 0; NULL != _argv[ii]; ++ii) + { + len += snprintf(&temp[len], bx::uint32_imax(0, total-len) + , "%s " + , _argv[ii] + ); + } + + bool ok = CreateProcessA(_argv[0] + , temp + , NULL + , NULL + , false + , 0 + , NULL + , NULL + , &si + , &pi + ); + if (ok) + { + return pi.hProcess; + } + + return NULL; +#else + return NULL; +#endif // BX_PLATFORM_LINUX + } + +} // namespace bx + +#endif // BX_PROCESS_H_HEADER_GUARD diff --git a/3rdparty/bx/include/bx/ringbuffer.h b/3rdparty/bx/include/bx/ringbuffer.h index 6dff4f237fc..8b24e0e7b7a 100644 --- a/3rdparty/bx/include/bx/ringbuffer.h +++ b/3rdparty/bx/include/bx/ringbuffer.h @@ -40,7 +40,7 @@ namespace bx uint32_t consume(uint32_t _size) // consumer only { const uint32_t maxSize = distance(m_read, m_current); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_read, size); @@ -53,7 +53,7 @@ namespace bx { const uint32_t dist = distance(m_write, m_read)-1; const uint32_t maxSize = uint32_sels(dist, m_size-1, dist); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_write, size); @@ -65,7 +65,7 @@ namespace bx uint32_t commit(uint32_t _size) // producer only { const uint32_t maxSize = distance(m_current, m_write); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_current, size); @@ -124,7 +124,7 @@ namespace bx uint32_t consume(uint32_t _size) // consumer only { const uint32_t maxSize = distance(m_read, m_current); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_read, size); @@ -137,7 +137,7 @@ namespace bx { const uint32_t dist = distance(m_write, m_read)-1; const uint32_t maxSize = uint32_sels(dist, m_size-1, dist); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_write, size); @@ -149,7 +149,7 @@ namespace bx uint32_t commit(uint32_t _size) // producer only { const uint32_t maxSize = distance(m_current, m_write); - const uint32_t sizeNoSign = uint32_and(_size, 0x7FFFFFFF); + const uint32_t sizeNoSign = uint32_and(_size, 0x7fffffff); const uint32_t test = uint32_sub(sizeNoSign, maxSize); const uint32_t size = uint32_sels(test, _size, maxSize); const uint32_t advance = uint32_add(m_current, size); diff --git a/3rdparty/bx/include/bx/string.h b/3rdparty/bx/include/bx/string.h index 242ae1225a8..7f9224a5a03 100644 --- a/3rdparty/bx/include/bx/string.h +++ b/3rdparty/bx/include/bx/string.h @@ -113,24 +113,24 @@ namespace bx return NULL; } - /// Find substring in string. Case insensitive. Limit search to _size. + /// Find substring in string. Case insensitive. Limit search to _max. inline const char* stristr(const char* _str, const char* _find, size_t _max) { const char* ptr = _str; - const size_t total = strlen(_str); - size_t len = _max < total ? _max : total; + size_t stringLen = strnlen(_str, _max); + const size_t findLen = strlen(_find); - for (const size_t searchLen = strlen(_find); len >= searchLen; ++ptr, --len) + for (; stringLen >= findLen; ++ptr, --stringLen) { // Find start of the string. while (tolower(*ptr) != tolower(*_find) ) { ++ptr; - --len; + --stringLen; // Search pattern lenght can't be longer than the string. - if (searchLen > len) + if (findLen > stringLen) { return NULL; } diff --git a/3rdparty/bx/include/bx/thread.h b/3rdparty/bx/include/bx/thread.h index 331aeafafa4..8b20d11a2b5 100644 --- a/3rdparty/bx/include/bx/thread.h +++ b/3rdparty/bx/include/bx/thread.h @@ -31,8 +31,9 @@ namespace bx public: Thread() -#if BX_PLATFORM_WINDOWS|BX_PLATFORM_XBOX360|BX_PLATFORM_WINRT +#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_WINRT : m_handle(INVALID_HANDLE_VALUE) + , m_threadId(UINT32_MAX) #elif BX_PLATFORM_POSIX : m_handle(0) #endif // BX_PLATFORM_ @@ -52,7 +53,7 @@ namespace bx } } - void init(ThreadFn _fn, void* _userData = NULL, uint32_t _stackSize = 0) + void init(ThreadFn _fn, void* _userData = NULL, uint32_t _stackSize = 0, const char* _name = NULL) { BX_CHECK(!m_running, "Already running!"); @@ -61,7 +62,7 @@ namespace bx m_stackSize = _stackSize; m_running = true; -#if BX_PLATFORM_WINDOWS|BX_PLATFORM_XBOX360 +#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 m_handle = CreateThread(NULL , m_stackSize , threadFunc @@ -102,12 +103,17 @@ namespace bx #endif // BX_PLATFORM_ m_sem.wait(); + + if (NULL != _name) + { + setThreadName(_name); + } } void shutdown() { BX_CHECK(m_running, "Not running!"); -#if BX_PLATFORM_WINDOWS|BX_PLATFORM_XBOX360 +#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 WaitForSingleObject(m_handle, INFINITE); GetExitCodeThread(m_handle, (DWORD*)&m_exitCode); CloseHandle(m_handle); @@ -139,14 +145,56 @@ namespace bx return m_exitCode; } + void setThreadName(const char* _name) + { +#if BX_PLATFORM_OSX || BX_PLATFORM_IOS + pthread_setname_np(_name); +#elif BX_PLATFORM_LINUX || BX_PLATFORM_FREEBSD + pthread_setname_np(m_handle, _name); +#elif BX_PLATFORM_WINDOWS && BX_COMPILER_MSVC +# pragma pack(push, 8) + struct ThreadName + { + DWORD type; + LPCSTR name; + DWORD id; + DWORD flags; + }; +# pragma pack(pop) + ThreadName tn; + tn.type = 0x1000; + tn.name = _name; + tn.id = m_threadId; + tn.flags = 0; + + __try + { + RaiseException(0x406d1388 + , 0 + , sizeof(tn)/4 + , reinterpret_cast(&tn) + ); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + } +#else + BX_UNUSED(_name); +#endif // BX_PLATFORM_ + } + private: int32_t entry() { +#if BX_PLATFORM_WINDOWS + m_threadId = ::GetCurrentThreadId(); +#endif // BX_PLATFORM_WINDOWS + m_sem.post(); return m_fn(m_userData); } -#if BX_PLATFORM_WINDOWS|BX_PLATFORM_XBOX360|BX_PLATFORM_WINRT +#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_WINRT static DWORD WINAPI threadFunc(LPVOID _arg) { Thread* thread = (Thread*)_arg; @@ -167,18 +215,19 @@ namespace bx } #endif // BX_PLATFORM_ -#if BX_PLATFORM_WINDOWS|BX_PLATFORM_XBOX360|BX_PLATFORM_WINRT +#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_WINRT HANDLE m_handle; + DWORD m_threadId; #elif BX_PLATFORM_POSIX pthread_t m_handle; #endif // BX_PLATFORM_ - ThreadFn m_fn; - void* m_userData; + ThreadFn m_fn; + void* m_userData; Semaphore m_sem; - uint32_t m_stackSize; - int32_t m_exitCode; - bool m_running; + uint32_t m_stackSize; + int32_t m_exitCode; + bool m_running; }; #if BX_PLATFORM_WINDOWS diff --git a/3rdparty/bx/include/bx/uint32_t.h b/3rdparty/bx/include/bx/uint32_t.h index 48908f6511d..22eed28a89e 100644 --- a/3rdparty/bx/include/bx/uint32_t.h +++ b/3rdparty/bx/include/bx/uint32_t.h @@ -652,8 +652,8 @@ namespace bx inline uint64_t uint64_cntlz_ref(uint64_t _val) { return _val & UINT64_C(0xffffffff00000000) - ? uint32_cntlz(uint32_t(_val>>32) ) + 32 - : uint32_cntlz(uint32_t(_val) ) + ? uint32_cntlz(uint32_t(_val>>32) ) + : uint32_cntlz(uint32_t(_val) ) + 32 ; } diff --git a/3rdparty/bx/include/compat/freebsd/signal.h b/3rdparty/bx/include/compat/freebsd/signal.h new file mode 100644 index 00000000000..fd7d90f336f --- /dev/null +++ b/3rdparty/bx/include/compat/freebsd/signal.h @@ -0,0 +1 @@ +#include diff --git a/3rdparty/bx/include/compat/mingw/sal.h b/3rdparty/bx/include/compat/mingw/sal.h index acfcbc5eb65..5fe9e5d17c9 100644 --- a/3rdparty/bx/include/compat/mingw/sal.h +++ b/3rdparty/bx/include/compat/mingw/sal.h @@ -42,7 +42,7 @@ #define __ecount(size) #define __bcount(size) -#define __in +// #define __in // Conflicts with STL. #define __in_ecount(size) #define __in_bcount(size) #define __in_z @@ -52,7 +52,7 @@ #define __in_ecount_nz(size) #define __in_bcount_nz(size) #define __in_xcount_opt(size) -#define __out +// #define __out // Conflicts with STL. #define __out_ecount(size) #define __out_bcount(size) #define __out_ecount_part(size,length) @@ -246,6 +246,642 @@ #define __control_entrypoint(category) #define __data_entrypoint(category) +#define _Always_(annos) +#define _Analysis_noreturn_ +#define _Analysis_assume_(expr) +#define _At_(target, annos) +#define _At_buffer_(target, iter, bound, annos) +#define _COM_Outptr_ +#define _COM_Outptr_opt_ +#define _COM_Outptr_opt_result_maybenull_ +#define _COM_Outptr_result_maybenull_ +#define _Check_return_ +#define _Const_ +#define _Deref2_pre_readonly_ +#define _Deref_in_bound_ +#define _Deref_in_range_(lb,ub) +#define _Deref_inout_bound_ +#define _Deref_inout_z_ +#define _Deref_inout_z_bytecap_c_(size) +#define _Deref_inout_z_cap_c_(size) +#define _Deref_opt_out_ +#define _Deref_opt_out_opt_ +#define _Deref_opt_out_opt_z_ +#define _Deref_opt_out_z_ +#define _Deref_out_ +#define _Deref_out_bound_ +#define _Deref_out_opt_ +#define _Deref_out_opt_z_ +#define _Deref_out_range_(lb,ub) +#define _Deref_out_z_ +#define _Deref_out_z_bytecap_c_(size) +#define _Deref_out_z_cap_c_(size) +#define _Deref_post_bytecap_(size) +#define _Deref_post_bytecap_c_(size) +#define _Deref_post_bytecap_x_(size) +#define _Deref_post_bytecount_(size) +#define _Deref_post_bytecount_c_(size) +#define _Deref_post_bytecount_x_(size) +#define _Deref_post_cap_(size) +#define _Deref_post_cap_c_(size) +#define _Deref_post_cap_x_(size) +#define _Deref_post_count_(size) +#define _Deref_post_count_c_(size) +#define _Deref_post_count_x_(size) +#define _Deref_post_maybenull_ +#define _Deref_post_notnull_ +#define _Deref_post_null_ +#define _Deref_post_opt_bytecap_(size) +#define _Deref_post_opt_bytecap_c_(size) +#define _Deref_post_opt_bytecap_x_(size) +#define _Deref_post_opt_bytecount_(size) +#define _Deref_post_opt_bytecount_c_(size) +#define _Deref_post_opt_bytecount_x_(size) +#define _Deref_post_opt_cap_(size) +#define _Deref_post_opt_cap_c_(size) +#define _Deref_post_opt_cap_x_(size) +#define _Deref_post_opt_count_(size) +#define _Deref_post_opt_count_c_(size) +#define _Deref_post_opt_count_x_(size) +#define _Deref_post_opt_valid_ +#define _Deref_post_opt_valid_bytecap_(size) +#define _Deref_post_opt_valid_bytecap_c_(size) +#define _Deref_post_opt_valid_bytecap_x_(size) +#define _Deref_post_opt_valid_cap_(size) +#define _Deref_post_opt_valid_cap_c_(size) +#define _Deref_post_opt_valid_cap_x_(size) +#define _Deref_post_opt_z_ +#define _Deref_post_opt_z_bytecap_(size) +#define _Deref_post_opt_z_bytecap_c_(size) +#define _Deref_post_opt_z_bytecap_x_(size) +#define _Deref_post_opt_z_cap_(size) +#define _Deref_post_opt_z_cap_c_(size) +#define _Deref_post_opt_z_cap_x_(size) +#define _Deref_post_valid_ +#define _Deref_post_valid_bytecap_(size) +#define _Deref_post_valid_bytecap_c_(size) +#define _Deref_post_valid_bytecap_x_(size) +#define _Deref_post_valid_cap_(size) +#define _Deref_post_valid_cap_c_(size) +#define _Deref_post_valid_cap_x_(size) +#define _Deref_post_z_ +#define _Deref_post_z_bytecap_(size) +#define _Deref_post_z_bytecap_c_(size) +#define _Deref_post_z_bytecap_x_(size) +#define _Deref_post_z_cap_(size) +#define _Deref_post_z_cap_c_(size) +#define _Deref_post_z_cap_x_(size) +#define _Deref_pre_bytecap_(size) +#define _Deref_pre_bytecap_c_(size) +#define _Deref_pre_bytecap_x_(size) +#define _Deref_pre_bytecount_(size) +#define _Deref_pre_bytecount_c_(size) +#define _Deref_pre_bytecount_x_(size) +#define _Deref_pre_cap_(size) +#define _Deref_pre_cap_c_(size) +#define _Deref_pre_cap_x_(size) +#define _Deref_pre_count_(size) +#define _Deref_pre_count_c_(size) +#define _Deref_pre_count_x_(size) +#define _Deref_pre_invalid_ +#define _Deref_pre_maybenull_ +#define _Deref_pre_notnull_ +#define _Deref_pre_null_ +#define _Deref_pre_opt_bytecap_(size) +#define _Deref_pre_opt_bytecap_c_(size) +#define _Deref_pre_opt_bytecap_x_(size) +#define _Deref_pre_opt_bytecount_(size) +#define _Deref_pre_opt_bytecount_c_(size) +#define _Deref_pre_opt_bytecount_x_(size) +#define _Deref_pre_opt_cap_(size) +#define _Deref_pre_opt_cap_c_(size) +#define _Deref_pre_opt_cap_x_(size) +#define _Deref_pre_opt_count_(size) +#define _Deref_pre_opt_count_c_(size) +#define _Deref_pre_opt_count_x_(size) +#define _Deref_pre_opt_valid_ +#define _Deref_pre_opt_valid_bytecap_(size) +#define _Deref_pre_opt_valid_bytecap_c_(size) +#define _Deref_pre_opt_valid_bytecap_x_(size) +#define _Deref_pre_opt_valid_cap_(size) +#define _Deref_pre_opt_valid_cap_c_(size) +#define _Deref_pre_opt_valid_cap_x_(size) +#define _Deref_pre_opt_z_ +#define _Deref_pre_opt_z_bytecap_(size) +#define _Deref_pre_opt_z_bytecap_c_(size) +#define _Deref_pre_opt_z_bytecap_x_(size) +#define _Deref_pre_opt_z_cap_(size) +#define _Deref_pre_opt_z_cap_c_(size) +#define _Deref_pre_opt_z_cap_x_(size) +#define _Deref_pre_readonly_ +#define _Deref_pre_valid_ +#define _Deref_pre_valid_bytecap_(size) +#define _Deref_pre_valid_bytecap_c_(size) +#define _Deref_pre_valid_bytecap_x_(size) +#define _Deref_pre_valid_cap_(size) +#define _Deref_pre_valid_cap_c_(size) +#define _Deref_pre_valid_cap_x_(size) +#define _Deref_pre_writeonly_ +#define _Deref_pre_z_ +#define _Deref_pre_z_bytecap_(size) +#define _Deref_pre_z_bytecap_c_(size) +#define _Deref_pre_z_bytecap_x_(size) +#define _Deref_pre_z_cap_(size) +#define _Deref_pre_z_cap_c_(size) +#define _Deref_pre_z_cap_x_(size) +#define _Deref_prepost_bytecap_(size) +#define _Deref_prepost_bytecap_x_(size) +#define _Deref_prepost_bytecount_(size) +#define _Deref_prepost_bytecount_x_(size) +#define _Deref_prepost_cap_(size) +#define _Deref_prepost_cap_x_(size) +#define _Deref_prepost_count_(size) +#define _Deref_prepost_count_x_(size) +#define _Deref_prepost_opt_bytecap_(size) +#define _Deref_prepost_opt_bytecap_x_(size) +#define _Deref_prepost_opt_bytecount_(size) +#define _Deref_prepost_opt_bytecount_x_(size) +#define _Deref_prepost_opt_cap_(size) +#define _Deref_prepost_opt_cap_x_(size) +#define _Deref_prepost_opt_count_(size) +#define _Deref_prepost_opt_count_x_(size) +#define _Deref_prepost_opt_valid_ +#define _Deref_prepost_opt_valid_bytecap_(size) +#define _Deref_prepost_opt_valid_bytecap_x_(size) +#define _Deref_prepost_opt_valid_cap_(size) +#define _Deref_prepost_opt_valid_cap_x_(size) +#define _Deref_prepost_opt_z_ +#define _Deref_prepost_opt_z_bytecap_(size) +#define _Deref_prepost_opt_z_cap_(size) +#define _Deref_prepost_valid_ +#define _Deref_prepost_valid_bytecap_(size) +#define _Deref_prepost_valid_bytecap_x_(size) +#define _Deref_prepost_valid_cap_(size) +#define _Deref_prepost_valid_cap_x_(size) +#define _Deref_prepost_z_ +#define _Deref_prepost_z_bytecap_(size) +#define _Deref_prepost_z_cap_(size) +#define _Deref_ret_bound_ +#define _Deref_ret_opt_z_ +#define _Deref_ret_range_(lb,ub) +#define _Deref_ret_z_ +#define _Field_range_(min,max) +#define _Field_size_(size) +#define _Field_size_bytes_(size) +#define _Field_size_bytes_full_(size) +#define _Field_size_bytes_full_opt_(size) +#define _Field_size_bytes_opt_(size) +#define _Field_size_bytes_part_(size, count) +#define _Field_size_bytes_part_opt_(size, count) +#define _Field_size_full_(size) +#define _Field_size_full_opt_(size) +#define _Field_size_opt_(size) +#define _Field_size_part_(size, count) +#define _Field_size_part_opt_(size, count) +#define _Field_z_ +#define _Function_class_(x) +#define _Group_(annos) +#define _In_ +#define _In_bound_ +#define _In_bytecount_(size) +#define _In_bytecount_c_(size) +#define _In_bytecount_x_(size) +#define _In_count_(size) +#define _In_count_c_(size) +#define _In_count_x_(size) +#define _In_defensive_(annotes) +#define _In_opt_ +#define _In_opt_bytecount_(size) +#define _In_opt_bytecount_c_(size) +#define _In_opt_bytecount_x_(size) +#define _In_opt_count_(size) +#define _In_opt_count_c_(size) +#define _In_opt_count_x_(size) +#define _In_opt_ptrdiff_count_(size) +#define _In_opt_z_ +#define _In_opt_z_bytecount_(size) +#define _In_opt_z_bytecount_c_(size) +#define _In_opt_z_count_(size) +#define _In_opt_z_count_c_(size) +#define _In_ptrdiff_count_(size) +#define _In_range_(lb,ub) +#define _In_reads_(size) +#define _In_reads_bytes_(size) +#define _In_reads_bytes_opt_(size) +#define _In_reads_opt_(size) +#define _In_reads_opt_z_(size) +#define _In_reads_or_z_(size) +#define _In_reads_to_ptr_(ptr) +#define _In_reads_to_ptr_opt_(ptr) +#define _In_reads_to_ptr_opt_z_(ptr) +#define _In_reads_to_ptr_z_(ptr) +#define _In_reads_z_(size) +#define _In_z_ +#define _In_z_bytecount_(size) +#define _In_z_bytecount_c_(size) +#define _In_z_count_(size) +#define _In_z_count_c_(size) +#define _Inout_ +#define _Inout_bytecap_(size) +#define _Inout_bytecap_c_(size) +#define _Inout_bytecap_x_(size) +#define _Inout_bytecount_(size) +#define _Inout_bytecount_c_(size) +#define _Inout_bytecount_x_(size) +#define _Inout_cap_(size) +#define _Inout_cap_c_(size) +#define _Inout_cap_x_(size) +#define _Inout_count_(size) +#define _Inout_count_c_(size) +#define _Inout_count_x_(size) +#define _Inout_defensive_(annotes) +#define _Inout_opt_ +#define _Inout_opt_bytecap_(size) +#define _Inout_opt_bytecap_c_(size) +#define _Inout_opt_bytecap_x_(size) +#define _Inout_opt_bytecount_(size) +#define _Inout_opt_bytecount_c_(size) +#define _Inout_opt_bytecount_x_(size) +#define _Inout_opt_cap_(size) +#define _Inout_opt_cap_c_(size) +#define _Inout_opt_cap_x_(size) +#define _Inout_opt_count_(size) +#define _Inout_opt_count_c_(size) +#define _Inout_opt_count_x_(size) +#define _Inout_opt_ptrdiff_count_(size) +#define _Inout_opt_z_ +#define _Inout_opt_z_bytecap_(size) +#define _Inout_opt_z_bytecap_c_(size) +#define _Inout_opt_z_bytecap_x_(size) +#define _Inout_opt_z_bytecount_(size) +#define _Inout_opt_z_bytecount_c_(size) +#define _Inout_opt_z_cap_(size) +#define _Inout_opt_z_cap_c_(size) +#define _Inout_opt_z_cap_x_(size) +#define _Inout_opt_z_count_(size) +#define _Inout_opt_z_count_c_(size) +#define _Inout_ptrdiff_count_(size) +#define _Inout_updates_(size) +#define _Inout_updates_all_(size) +#define _Inout_updates_all_opt_(size) +#define _Inout_updates_bytes_(size) +#define _Inout_updates_bytes_all_(size) +#define _Inout_updates_bytes_all_opt_(size) +#define _Inout_updates_bytes_opt_(size) +#define _Inout_updates_bytes_to_(size,count) +#define _Inout_updates_bytes_to_opt_(size,count) +#define _Inout_updates_opt_(size) +#define _Inout_updates_opt_z_(size) +#define _Inout_updates_to_(size,count) +#define _Inout_updates_to_opt_(size,count) +#define _Inout_updates_z_(size) +#define _Inout_z_ +#define _Inout_z_bytecap_(size) +#define _Inout_z_bytecap_c_(size) +#define _Inout_z_bytecap_x_(size) +#define _Inout_z_bytecount_(size) +#define _Inout_z_bytecount_c_(size) +#define _Inout_z_cap_(size) +#define _Inout_z_cap_c_(size) +#define _Inout_z_cap_x_(size) +#define _Inout_z_count_(size) +#define _Inout_z_count_c_(size) +#define _Interlocked_operand_ +#define _Literal_ +#define _Maybe_raises_SEH_exception +#define _Maybe_raises_SEH_exception_ +#define _Maybenull_ +#define _Maybevalid_ +#define _Must_inspect_result_ +#define _Notliteral_ +#define _Notnull_ +#define _Notref_ +#define _Notvalid_ +#define _NullNull_terminated_ +#define _Null_ +#define _Null_terminated_ +#define _On_failure_(annos) +#define _Out_ +#define _Out_bound_ +#define _Out_bytecap_(size) +#define _Out_bytecap_c_(size) +#define _Out_bytecap_post_bytecount_(cap,count) +#define _Out_bytecap_x_(size) +#define _Out_bytecapcount_(capcount) +#define _Out_bytecapcount_x_(capcount) +#define _Out_cap_(size) +#define _Out_cap_c_(size) +#define _Out_cap_m_(mult,size) +#define _Out_cap_post_count_(cap,count) +#define _Out_cap_x_(size) +#define _Out_capcount_(capcount) +#define _Out_capcount_x_(capcount) +#define _Out_defensive_(annotes) +#define _Out_opt_ +#define _Out_opt_bytecap_(size) +#define _Out_opt_bytecap_c_(size) +#define _Out_opt_bytecap_post_bytecount_(cap,count) +#define _Out_opt_bytecap_x_(size) +#define _Out_opt_bytecapcount_(capcount) +#define _Out_opt_bytecapcount_x_(capcount) +#define _Out_opt_cap_(size) +#define _Out_opt_cap_c_(size) +#define _Out_opt_cap_m_(mult,size) +#define _Out_opt_cap_post_count_(cap,count) +#define _Out_opt_cap_x_(size) +#define _Out_opt_capcount_(capcount) +#define _Out_opt_capcount_x_(capcount) +#define _Out_opt_ptrdiff_cap_(size) +#define _Out_opt_z_bytecap_(size) +#define _Out_opt_z_bytecap_c_(size) +#define _Out_opt_z_bytecap_post_bytecount_(cap,count) +#define _Out_opt_z_bytecap_x_(size) +#define _Out_opt_z_bytecapcount_(capcount) +#define _Out_opt_z_cap_(size) +#define _Out_opt_z_cap_c_(size) +#define _Out_opt_z_cap_m_(mult,size) +#define _Out_opt_z_cap_post_count_(cap,count) +#define _Out_opt_z_cap_x_(size) +#define _Out_opt_z_capcount_(capcount) +#define _Out_ptrdiff_cap_(size) +#define _Out_range_(lb,ub) +#define _Out_writes_(size) +#define _Out_writes_all_(size) +#define _Out_writes_all_opt_(size) +#define _Out_writes_bytes_(size) +#define _Out_writes_bytes_all_(size) +#define _Out_writes_bytes_all_opt_(size) +#define _Out_writes_bytes_opt_(size) +#define _Out_writes_bytes_to_(size,count) +#define _Out_writes_bytes_to_opt_(size,count) +#define _Out_writes_opt_(size) +#define _Out_writes_opt_z_(size) +#define _Out_writes_to_(size,count) +#define _Out_writes_to_opt_(size,count) +#define _Out_writes_to_ptr_(ptr) +#define _Out_writes_to_ptr_opt_(ptr) +#define _Out_writes_to_ptr_opt_z_(ptr) +#define _Out_writes_to_ptr_z_(ptr) +#define _Out_writes_z_(size) +#define _Out_z_bytecap_(size) +#define _Out_z_bytecap_c_(size) +#define _Out_z_bytecap_post_bytecount_(cap,count) +#define _Out_z_bytecap_x_(size) +#define _Out_z_bytecapcount_(capcount) +#define _Out_z_cap_(size) +#define _Out_z_cap_c_(size) +#define _Out_z_cap_m_(mult,size) +#define _Out_z_cap_post_count_(cap,count) +#define _Out_z_cap_x_(size) +#define _Out_z_capcount_(capcount) +#define _Outptr_ +#define _Outptr_opt_ +#define _Outptr_opt_result_buffer_(size) +#define _Outptr_opt_result_buffer_all_(size) +#define _Outptr_opt_result_buffer_all_maybenull_(size) +#define _Outptr_opt_result_buffer_maybenull_(size) +#define _Outptr_opt_result_buffer_to_(size, count) +#define _Outptr_opt_result_buffer_to_maybenull_(size, count) +#define _Outptr_opt_result_bytebuffer_(size) +#define _Outptr_opt_result_bytebuffer_all_(size) +#define _Outptr_opt_result_bytebuffer_all_maybenull_(size) +#define _Outptr_opt_result_bytebuffer_maybenull_(size) +#define _Outptr_opt_result_bytebuffer_to_(size, count) +#define _Outptr_opt_result_bytebuffer_to_maybenull_(size, count) +#define _Outptr_opt_result_maybenull_ +#define _Outptr_opt_result_maybenull_z_ +#define _Outptr_opt_result_nullonfailure_ +#define _Outptr_opt_result_z_ +#define _Outptr_result_buffer_(size) +#define _Outptr_result_buffer_all_(size) +#define _Outptr_result_buffer_all_maybenull_(size) +#define _Outptr_result_buffer_maybenull_(size) +#define _Outptr_result_buffer_to_(size, count) +#define _Outptr_result_buffer_to_maybenull_(size, count) +#define _Outptr_result_bytebuffer_(size) +#define _Outptr_result_bytebuffer_all_(size) +#define _Outptr_result_bytebuffer_all_maybenull_(size) +#define _Outptr_result_bytebuffer_maybenull_(size) +#define _Outptr_result_bytebuffer_to_(size, count) +#define _Outptr_result_bytebuffer_to_maybenull_(size, count) +#define _Outptr_result_maybenull_ +#define _Outptr_result_maybenull_z_ +#define _Outptr_result_nullonfailure_ +#define _Outptr_result_z_ +#define _Outref_ +#define _Outref_result_buffer_(size) +#define _Outref_result_buffer_all_(size) +#define _Outref_result_buffer_all_maybenull_(size) +#define _Outref_result_buffer_maybenull_(size) +#define _Outref_result_buffer_to_(size, count) +#define _Outref_result_buffer_to_maybenull_(size, count) +#define _Outref_result_bytebuffer_(size) +#define _Outref_result_bytebuffer_all_(size) +#define _Outref_result_bytebuffer_all_maybenull_(size) +#define _Outref_result_bytebuffer_maybenull_(size) +#define _Outref_result_bytebuffer_to_(size, count) +#define _Outref_result_bytebuffer_to_maybenull_(size, count) +#define _Outref_result_maybenull_ +#define _Outref_result_nullonfailure_ +#define _Points_to_data_ +#define _Post_ +#define _Post_bytecap_(size) +#define _Post_bytecount_(size) +#define _Post_bytecount_c_(size) +#define _Post_bytecount_x_(size) +#define _Post_cap_(size) +#define _Post_count_(size) +#define _Post_count_c_(size) +#define _Post_count_x_(size) +#define _Post_defensive_ +#define _Post_equal_to_(expr) +#define _Post_invalid_ +#define _Post_maybenull_ +#define _Post_maybez_ +#define _Post_notnull_ +#define _Post_null_ +#define _Post_ptr_invalid_ +#define _Post_readable_byte_size_(size) +#define _Post_readable_size_(size) +#define _Post_satisfies_(cond) +#define _Post_valid_ +#define _Post_writable_byte_size_(size) +#define _Post_writable_size_(size) +#define _Post_z_ +#define _Post_z_bytecount_(size) +#define _Post_z_bytecount_c_(size) +#define _Post_z_bytecount_x_(size) +#define _Post_z_count_(size) +#define _Post_z_count_c_(size) +#define _Post_z_count_x_(size) +#define _Pre_ +#define _Pre_bytecap_(size) +#define _Pre_bytecap_c_(size) +#define _Pre_bytecap_x_(size) +#define _Pre_bytecount_(size) +#define _Pre_bytecount_c_(size) +#define _Pre_bytecount_x_(size) +#define _Pre_cap_(size) +#define _Pre_cap_c_(size) +#define _Pre_cap_c_one_ +#define _Pre_cap_for_(param) +#define _Pre_cap_m_(mult,size) +#define _Pre_cap_x_(size) +#define _Pre_count_(size) +#define _Pre_count_c_(size) +#define _Pre_count_x_(size) +#define _Pre_defensive_ +#define _Pre_equal_to_(expr) +#define _Pre_invalid_ +#define _Pre_maybenull_ +#define _Pre_notnull_ +#define _Pre_null_ +#define _Pre_opt_bytecap_(size) +#define _Pre_opt_bytecap_c_(size) +#define _Pre_opt_bytecap_x_(size) +#define _Pre_opt_bytecount_(size) +#define _Pre_opt_bytecount_c_(size) +#define _Pre_opt_bytecount_x_(size) +#define _Pre_opt_cap_(size) +#define _Pre_opt_cap_c_(size) +#define _Pre_opt_cap_c_one_ +#define _Pre_opt_cap_for_(param) +#define _Pre_opt_cap_m_(mult,size) +#define _Pre_opt_cap_x_(size) +#define _Pre_opt_count_(size) +#define _Pre_opt_count_c_(size) +#define _Pre_opt_count_x_(size) +#define _Pre_opt_ptrdiff_cap_(ptr) +#define _Pre_opt_ptrdiff_count_(ptr) +#define _Pre_opt_valid_ +#define _Pre_opt_valid_bytecap_(size) +#define _Pre_opt_valid_bytecap_c_(size) +#define _Pre_opt_valid_bytecap_x_(size) +#define _Pre_opt_valid_cap_(size) +#define _Pre_opt_valid_cap_c_(size) +#define _Pre_opt_valid_cap_x_(size) +#define _Pre_opt_z_ +#define _Pre_opt_z_bytecap_(size) +#define _Pre_opt_z_bytecap_c_(size) +#define _Pre_opt_z_bytecap_x_(size) +#define _Pre_opt_z_cap_(size) +#define _Pre_opt_z_cap_c_(size) +#define _Pre_opt_z_cap_x_(size) +#define _Pre_ptrdiff_cap_(ptr) +#define _Pre_ptrdiff_count_(ptr) +#define _Pre_readable_byte_size_(size) +#define _Pre_readable_size_(size) +#define _Pre_readonly_ +#define _Pre_satisfies_(cond) +#define _Pre_valid_ +#define _Pre_valid_bytecap_(size) +#define _Pre_valid_bytecap_c_(size) +#define _Pre_valid_bytecap_x_(size) +#define _Pre_valid_cap_(size) +#define _Pre_valid_cap_c_(size) +#define _Pre_valid_cap_x_(size) +#define _Pre_writable_byte_size_(size) +#define _Pre_writable_size_(size) +#define _Pre_writeonly_ +#define _Pre_z_ +#define _Pre_z_bytecap_(size) +#define _Pre_z_bytecap_c_(size) +#define _Pre_z_bytecap_x_(size) +#define _Pre_z_cap_(size) +#define _Pre_z_cap_c_(size) +#define _Pre_z_cap_x_(size) +#define _Prepost_bytecount_(size) +#define _Prepost_bytecount_c_(size) +#define _Prepost_bytecount_x_(size) +#define _Prepost_count_(size) +#define _Prepost_count_c_(size) +#define _Prepost_count_x_(size) +#define _Prepost_opt_bytecount_(size) +#define _Prepost_opt_bytecount_c_(size) +#define _Prepost_opt_bytecount_x_(size) +#define _Prepost_opt_count_(size) +#define _Prepost_opt_count_c_(size) +#define _Prepost_opt_count_x_(size) +#define _Prepost_opt_valid_ +#define _Prepost_opt_z_ +#define _Prepost_valid_ +#define _Prepost_z_ +#define _Printf_format_string_ +#define _Raises_SEH_exception_ +#define _Readable_bytes_(size) +#define _Readable_elements_(size) +#define _Reserved_ +#define _Result_nullonfailure_ +#define _Result_zeroonfailure_ +#define _Ret_ +#define _Ret_bound_ +#define _Ret_bytecap_(size) +#define _Ret_bytecap_c_(size) +#define _Ret_bytecap_x_(size) +#define _Ret_bytecount_(size) +#define _Ret_bytecount_c_(size) +#define _Ret_bytecount_x_(size) +#define _Ret_cap_(size) +#define _Ret_cap_c_(size) +#define _Ret_cap_x_(size) +#define _Ret_count_(size) +#define _Ret_count_c_(size) +#define _Ret_count_x_(size) +#define _Ret_maybenull_ +#define _Ret_maybenull_z_ +#define _Ret_notnull_ +#define _Ret_null_ +#define _Ret_opt_ +#define _Ret_opt_bytecap_(size) +#define _Ret_opt_bytecap_c_(size) +#define _Ret_opt_bytecap_x_(size) +#define _Ret_opt_bytecount_(size) +#define _Ret_opt_bytecount_c_(size) +#define _Ret_opt_bytecount_x_(size) +#define _Ret_opt_cap_(size) +#define _Ret_opt_cap_c_(size) +#define _Ret_opt_cap_x_(size) +#define _Ret_opt_count_(size) +#define _Ret_opt_count_c_(size) +#define _Ret_opt_count_x_(size) +#define _Ret_opt_valid_ +#define _Ret_opt_z_ +#define _Ret_opt_z_bytecap_(size) +#define _Ret_opt_z_bytecount_(size) +#define _Ret_opt_z_cap_(size) +#define _Ret_opt_z_count_(size) +#define _Ret_range_(lb,ub) +#define _Ret_valid_ +#define _Ret_writes_(size) +#define _Ret_writes_bytes_(size) +#define _Ret_writes_bytes_maybenull_(size) +#define _Ret_writes_bytes_to_(size,count) +#define _Ret_writes_bytes_to_maybenull_(size,count) +#define _Ret_writes_maybenull_(size) +#define _Ret_writes_maybenull_z_(size) +#define _Ret_writes_to_(size,count) +#define _Ret_writes_to_maybenull_(size,count) +#define _Ret_writes_z_(size) +#define _Ret_z_ +#define _Ret_z_bytecap_(size) +#define _Ret_z_bytecount_(size) +#define _Ret_z_cap_(size) +#define _Ret_z_count_(size) +#define _Return_type_success_(expr) +#define _Scanf_format_string_ +#define _Scanf_s_format_string_ +#define _Struct_size_bytes_(size) +#define _Success_(expr) +#define _Unchanged_(e) +#define _Use_decl_annotations_ +#define _Valid_ +#define _When_(expr, annos) +#define _Writable_bytes_(size) +#define _Writable_elements_(size) +#define __inner_callback +#define __inner_exceptthat +#define __inner_typefix(ctype) + #ifndef __fallthrough # define __fallthrough __inner_fallthrough #endif diff --git a/3rdparty/bx/include/tinystl/buffer.h b/3rdparty/bx/include/tinystl/buffer.h index 31654c64119..5fac2291486 100644 --- a/3rdparty/bx/include/tinystl/buffer.h +++ b/3rdparty/bx/include/tinystl/buffer.h @@ -1,5 +1,5 @@ /*- - * Copyright 2012 Matthew Endsley + * Copyright 2012-1015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without @@ -54,6 +54,18 @@ namespace tinystl { buffer_destroy_range_traits(first, last, pod_traits()); } + template + static inline void buffer_fill_urange_traits(T* first, T* last, pod_traits) { + for (; first < last; ++first) + new(placeholder(), first) T(); + } + + template + static inline void buffer_fill_urange_traits(T* first, T* last, pod_traits) { + for (; first < last; ++first) + *first = T(); + } + template static inline void buffer_fill_urange_traits(T* first, T* last, const T& value, pod_traits) { for (; first < last; ++first) @@ -105,6 +117,11 @@ namespace tinystl { buffer_bmove_urange_traits(dest, first, last, pod_traits()); } + template + static inline void buffer_fill_urange(T* first, T* last) { + buffer_fill_urange_traits(first, last, pod_traits()); + } + template static inline void buffer_fill_urange(T* first, T* last, const T& value) { buffer_fill_urange_traits(first, last, value, pod_traits()); @@ -137,6 +154,15 @@ namespace tinystl { b->capacity = newfirst + capacity; } + template + static inline void buffer_resize(buffer* b, size_t size) { + buffer_reserve(b, size); + + buffer_fill_urange(b->last, b->first + size); + buffer_destroy_range(b->first + size, b->last); + b->last = b->first + size; + } + template static inline void buffer_resize(buffer* b, size_t size, const T& value) { buffer_reserve(b, size); @@ -169,22 +195,34 @@ namespace tinystl { } template - static inline void buffer_insert(buffer* b, T* where, const T* first, const T* last) { + static inline T* buffer_insert_common(buffer* b, T* where, size_t count) { const size_t offset = (size_t)(where - b->first); - const size_t newsize = (size_t)((b->last - b->first) + (last - first)); + const size_t newsize = (size_t)((b->last - b->first) + count); if (b->first + newsize > b->capacity) buffer_reserve(b, (newsize * 3) / 2); where = b->first + offset; - const size_t count = (size_t)(last - first); if (where != b->last) buffer_bmove_urange(where + count, where, b->last); + b->last = b->first + newsize; + + return where; + } + + template + static inline void buffer_insert(buffer* b, T* where, const Param* first, const Param* last) { + where = buffer_insert_common(b, where, last - first); for (; first != last; ++first, ++where) new(placeholder(), where) T(*first); + } - b->last = b->first + newsize; + template + static inline void buffer_insert(buffer* b, T* where, size_t count) { + where = buffer_insert_common(b, where, count); + for (size_t i = 0; i < count; ++i) + new(placeholder(), where) T(); } template diff --git a/3rdparty/bx/include/tinystl/vector.h b/3rdparty/bx/include/tinystl/vector.h index 3a8e28a4551..96fe1b4ef62 100644 --- a/3rdparty/bx/include/tinystl/vector.h +++ b/3rdparty/bx/include/tinystl/vector.h @@ -1,5 +1,5 @@ /*- - * Copyright 2012 Matthew Endsley + * Copyright 2012-1015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without @@ -56,6 +56,8 @@ namespace tinystl { T& operator[](size_t idx); const T& operator[](size_t idx) const; + const T& front() const; + T& front(); const T& back() const; T& back(); @@ -67,6 +69,10 @@ namespace tinystl { void push_back(const T& t); void pop_back(); + void emplace_back(); + template + void emplace_back(const Param& param); + void shrink_to_fit(); void swap(vector& other); @@ -81,9 +87,13 @@ namespace tinystl { const_iterator begin() const; const_iterator end() const; + void insert(iterator where); void insert(iterator where, const T& value); void insert(iterator where, const T* first, const T* last); + template + void emplace(iterator where, const Param& param); + iterator erase(iterator where); iterator erase(iterator first, iterator last); @@ -109,7 +119,7 @@ namespace tinystl { template inline vector::vector(size_t _size) { buffer_init(&m_buffer); - buffer_resize(&m_buffer, _size, T()); + buffer_resize(&m_buffer, _size); } template @@ -176,6 +186,16 @@ namespace tinystl { return m_buffer.first[idx]; } + template + inline const T& vector::front() const { + return m_buffer.first[0]; + } + + template + inline T& vector::front() { + return m_buffer.first[0]; + } + template inline const T& vector::back() const { return m_buffer.last[-1]; @@ -188,7 +208,7 @@ namespace tinystl { template inline void vector::resize(size_t _size) { - buffer_resize(&m_buffer, _size, T()); + buffer_resize(&m_buffer, _size); } template @@ -211,6 +231,19 @@ namespace tinystl { buffer_insert(&m_buffer, m_buffer.last, &t, &t + 1); } + template + inline void vector::emplace_back() + { + buffer_insert(&m_buffer, m_buffer.last, 1); + } + + template + template + inline void vector::emplace_back(const Param& param) + { + buffer_insert(&m_buffer, m_buffer.last, ¶m, ¶m + 1); + } + template inline void vector::pop_back() { buffer_erase(&m_buffer, m_buffer.last - 1, m_buffer.last); @@ -246,6 +279,11 @@ namespace tinystl { return m_buffer.last; } + template + inline void vector::insert(iterator where) { + buffer_insert(&m_buffer, where, 1); + } + template inline void vector::insert(iterator where, const T& value) { buffer_insert(&m_buffer, where, &value, &value + 1); @@ -275,6 +313,12 @@ namespace tinystl { inline typename vector::iterator vector::erase_unordered(iterator first, iterator last) { return buffer_erase_unordered(&m_buffer, first, last); } + + template + template + void vector::emplace(iterator where, const Param& param) { + buffer_insert(&m_buffer, where, ¶m, ¶m + 1); + } } #endif diff --git a/3rdparty/bx/scripts/genie.lua b/3rdparty/bx/scripts/genie.lua index 3f9ea26cb20..152cd4b21ef 100644 --- a/3rdparty/bx/scripts/genie.lua +++ b/3rdparty/bx/scripts/genie.lua @@ -36,7 +36,6 @@ dofile "unittest++.lua" dofile "bin2c.lua" project "bx.test" - uuid "8a653da8-23d6-11e3-acb4-887628d43830" kind "ConsoleApp" debugdir (path.join(BX_DIR, "tests")) diff --git a/3rdparty/bx/scripts/toolchain.lua b/3rdparty/bx/scripts/toolchain.lua index 0422db1105b..bb306084587 100644 --- a/3rdparty/bx/scripts/toolchain.lua +++ b/3rdparty/bx/scripts/toolchain.lua @@ -29,6 +29,7 @@ function toolchain(_buildDir, _libDir) { "nacl-arm", "Native Client - ARM" }, { "osx", "OSX" }, { "pnacl", "Native Client - PNaCl" }, + { "ps4", "PS4" }, { "qnx-arm", "QNX/Blackberry - ARM" }, { "rpi", "RaspberryPi" }, }, @@ -39,15 +40,15 @@ function toolchain(_buildDir, _libDir) value = "toolset", description = "Choose VS toolset", allowed = { - { "vs2012-clang", "Clang 3.6" }, - { "vs2013-clang", "Clang 3.6" }, + { "vs2012-clang", "Clang 3.6" }, + { "vs2013-clang", "Clang 3.6" }, { "vs2012-xp", "Visual Studio 2012 targeting XP" }, { "vs2013-xp", "Visual Studio 2013 targeting XP" }, { "vs2015-xp", "Visual Studio 2015 targeting XP" }, - { "winphone8", "Windows Phone 8.0" }, - { "winphone81", "Windows Phone 8.1" }, - { "winstore81", "Windows Store 8.1" }, - { "winstore82", "Universal Windows App" } + { "winphone8", "Windows Phone 8.0" }, + { "winphone81", "Windows Phone 8.1" }, + { "winstore81", "Windows Store 8.1" }, + { "winstore82", "Universal Windows App" }, }, } @@ -257,6 +258,19 @@ function toolchain(_buildDir, _libDir) premake.gcc.ar = naclToolchain .. "ar" location (path.join(_buildDir, "projects", _ACTION .. "-pnacl")) + elseif "ps4" == _OPTIONS["gcc"] then + + if not os.getenv("PS4_SDK_ROOT") then + print("Set PS4_SDK_ROOT enviroment variables.") + end + + ps4Toolchain = "$(PS4_SDK_ROOT)/host_tools/bin/orbis-" + + premake.gcc.cc = ps4Toolchain .. "clang" + premake.gcc.cxx = ps4Toolchain .. "clang++" + premake.gcc.ar = ps4Toolchain .. "ar" + location (path.join(_buildDir, "projects", _ACTION .. "-ps4")) + elseif "qnx-arm" == _OPTIONS["gcc"] then if not os.getenv("QNX_HOST") then @@ -799,6 +813,10 @@ function toolchain(_buildDir, _libDir) "-m64", } + configuration { "osx", "Universal" } + targetdir (path.join(_buildDir, "osx_universal/bin")) + objdir (path.join(_buildDir, "osx_universal/bin")) + configuration { "osx" } buildoptions { "-Wfatal-errors", @@ -855,6 +873,23 @@ function toolchain(_buildDir, _libDir) "--sysroot=/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator" ..iosPlatform .. ".sdk", } + configuration { "ps4" } + targetdir (path.join(_buildDir, "ps4/bin")) + objdir (path.join(_buildDir, "ps4/obj")) + libdirs { path.join(_libDir, "lib/ps4") } + includedirs { + path.join(bxDir, "include/compat/freebsd"), + "$(PS4_SDK_ROOT)/target/include", + "$(PS4_SDK_ROOT)/target/include_common", + } + buildoptions { + } + buildoptions_cpp { + "-std=c++0x", + } + linkoptions { + } + configuration { "qnx-arm" } targetdir (path.join(_buildDir, "qnx-arm/bin")) objdir (path.join(_buildDir, "qnx-arm/obj")) @@ -951,8 +986,14 @@ function strip() configuration { "asmjs" } postbuildcommands { "$(SILENT) echo Running asmjs finalize.", - "$(SILENT) $(EMSCRIPTEN)/emcc -O2 -s TOTAL_MEMORY=268435456 \"$(TARGET)\" -o \"$(TARGET)\".html" - -- ALLOW_MEMORY_GROWTH + "$(SILENT) $(EMSCRIPTEN)/emcc -O2 " +-- .. "-s EMTERPRETIFY=1 " +-- .. "-s EMTERPRETIFY_ASYNC=1 " + .. "-s TOTAL_MEMORY=268435456 " +-- .. "-s ALLOW_MEMORY_GROWTH=1 " + .. "--memory-init-file 1 " + .. "\"$(TARGET)\" -o \"$(TARGET)\".html " +-- .. "--preload-file ../../../examples/runtime@/" } configuration {} -- reset configuration diff --git a/3rdparty/bx/scripts/unittest++.lua b/3rdparty/bx/scripts/unittest++.lua index 25c8e5245ff..02fef2c695f 100644 --- a/3rdparty/bx/scripts/unittest++.lua +++ b/3rdparty/bx/scripts/unittest++.lua @@ -4,7 +4,6 @@ -- project "UnitTest++" - uuid "ab932f5c-2409-11e3-b000-887628d43830" kind "StaticLib" removeflags { @@ -16,7 +15,7 @@ project "UnitTest++" "../3rdparty/UnitTest++/src/*.h", } - configuration { "linux or osx or android-* or *nacl*" } + configuration { "linux or osx or android-* or *nacl* or ps4" } files { "../3rdparty/UnitTest++/src/Posix/**.cpp", "../3rdparty/UnitTest++/src/Posix/**.h", diff --git a/3rdparty/bx/tests/handle.cpp b/3rdparty/bx/tests/handle.cpp new file mode 100644 index 00000000000..455e7e47f01 --- /dev/null +++ b/3rdparty/bx/tests/handle.cpp @@ -0,0 +1,79 @@ +/* + * Copyright 2010-2015 Branimir Karadzic. All rights reserved. + * License: http://www.opensource.org/licenses/BSD-2-Clause + */ + +#include "test.h" +#include + +TEST(HandleListT) +{ + bx::HandleListT<32> list; + + list.pushBack(16); + CHECK(list.getFront() == 16); + CHECK(list.getBack() == 16); + + list.pushFront(7); + CHECK(list.getFront() == 7); + CHECK(list.getBack() == 16); + + uint16_t expected0[] = { 15, 31, 7, 16, 17, 11, 13 }; + list.pushBack(17); + list.pushBack(11); + list.pushBack(13); + list.pushFront(31); + list.pushFront(15); + uint16_t count = 0; + for (uint16_t it = list.getFront(); it != UINT16_MAX; it = list.getNext(it), ++count) + { + CHECK(it == expected0[count]); + } + CHECK(count == BX_COUNTOF(expected0) ); + + list.remove(17); + list.remove(31); + list.remove(16); + list.pushBack(16); + uint16_t expected1[] = { 15, 7, 11, 13, 16 }; + count = 0; + for (uint16_t it = list.getFront(); it != UINT16_MAX; it = list.getNext(it), ++count) + { + CHECK(it == expected1[count]); + } + CHECK(count == BX_COUNTOF(expected1) ); + + list.popBack(); + list.popFront(); + list.popBack(); + list.popBack(); + + CHECK(list.getFront() == 7); + CHECK(list.getBack() == 7); + + list.popBack(); + CHECK(list.getFront() == UINT16_MAX); + CHECK(list.getBack() == UINT16_MAX); +} + +TEST(HandleAllocLruT) +{ + bx::HandleAllocLruT<16> lru; + + uint16_t handle[4] = + { + lru.alloc(), + lru.alloc(), + lru.alloc(), + lru.alloc(), + }; + + lru.touch(handle[1]); + + uint16_t expected0[] = { handle[1], handle[3], handle[2], handle[0] }; + uint16_t count = 0; + for (uint16_t it = lru.getFront(); it != UINT16_MAX; it = lru.getNext(it), ++count) + { + CHECK(it == expected0[count]); + } +} diff --git a/3rdparty/bx/tests/misc.cpp b/3rdparty/bx/tests/misc.cpp new file mode 100644 index 00000000000..aec1067a022 --- /dev/null +++ b/3rdparty/bx/tests/misc.cpp @@ -0,0 +1,8 @@ +#include "test.h" +#include + +TEST(getProcessMemoryUsed) +{ + CHECK(0 != bx::getProcessMemoryUsed() ); +// DBG("bx::getProcessMemoryUsed %d", bx::getProcessMemoryUsed() ); +} diff --git a/3rdparty/bx/tests/uint32_t.cpp b/3rdparty/bx/tests/uint32_t.cpp index b232ff63ac1..553c8e23942 100644 --- a/3rdparty/bx/tests/uint32_t.cpp +++ b/3rdparty/bx/tests/uint32_t.cpp @@ -20,3 +20,33 @@ TEST(StrideAlign) CHECK(48 == bx::strideAlign16(ii+1, 12) ); } } + +TEST(uint32_cnt) +{ + CHECK( 0 == bx::uint32_cnttz(UINT32_C(1) ) ); + CHECK( 0 == bx::uint32_cnttz_ref(UINT32_C(1) ) ); + + CHECK(31 == bx::uint32_cntlz(UINT32_C(1) ) ); + CHECK(31 == bx::uint32_cntlz_ref(UINT32_C(1) ) ); + + CHECK( 0 == bx::uint64_cnttz(UINT64_C(1) ) ); + CHECK( 0 == bx::uint64_cnttz_ref(UINT64_C(1) ) ); + + CHECK(63 == bx::uint64_cntlz(UINT64_C(1) ) ); + CHECK(63 == bx::uint64_cntlz_ref(UINT64_C(1) ) ); + + CHECK( 1 == bx::uint32_cntbits(1) ); + CHECK( 1 == bx::uint32_cntbits_ref(1) ); + + CHECK(16 == bx::uint32_cntbits(UINT16_MAX) ); + CHECK(16 == bx::uint32_cntbits_ref(UINT16_MAX) ); + + CHECK(32 == bx::uint32_cntbits(UINT32_MAX) ); + CHECK(32 == bx::uint32_cntbits_ref(UINT32_MAX) ); +} + +TEST(uint32_part) +{ + CHECK(UINT32_C(0x55555555) == bx::uint32_part1by1(UINT16_MAX) ); + CHECK(UINT32_C(0x09249249) == bx::uint32_part1by2(0x3ff) ); +} diff --git a/3rdparty/bx/tests/unordered_map_nonpod.cpp b/3rdparty/bx/tests/unordered_map_nonpod.cpp index f9607e35e3f..96aa55e416c 100644 --- a/3rdparty/bx/tests/unordered_map_nonpod.cpp +++ b/3rdparty/bx/tests/unordered_map_nonpod.cpp @@ -1,5 +1,5 @@ /*- - * Copyright 2012-2014 Matthew Endsley + * Copyright 2012-2015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without @@ -29,7 +29,9 @@ #include #include -struct Foo { int bar; }; +namespace { + struct Foo { int bar; }; +} TEST(uomap_nonpod_compiles) { diff --git a/3rdparty/bx/tests/vector_complex.cpp b/3rdparty/bx/tests/vector_complex.cpp index 97716fbc070..8deaa3fd3ff 100644 --- a/3rdparty/bx/tests/vector_complex.cpp +++ b/3rdparty/bx/tests/vector_complex.cpp @@ -1,5 +1,5 @@ /*- - * Copyright 2012 Matthew Endsley + * Copyright 2012-1015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without @@ -35,9 +35,9 @@ struct complex { complex() {data = 0;} - complex(const char* s) { data = _strdup(s); } + complex(const char* s) { data = strdup(s); } ~complex() { free(data); } - complex(const complex& other) { data = 0; if (other.data) data = _strdup(other.data); } + complex(const complex& other) { data = 0; if (other.data) data = strdup(other.data); } complex& operator=(const complex& other) { complex(other).swap(*this); return *this; } void swap(complex& other) { std::swap(data, other.data); } diff --git a/3rdparty/bx/tests/vector_header.cpp b/3rdparty/bx/tests/vector_header.cpp index 82eba45ad6e..4822104dbc9 100644 --- a/3rdparty/bx/tests/vector_header.cpp +++ b/3rdparty/bx/tests/vector_header.cpp @@ -1,5 +1,5 @@ /*- - * Copyright 2012 Matthew Endsley + * Copyright 2012-1015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without diff --git a/3rdparty/bx/tests/vector_nocopy.cpp b/3rdparty/bx/tests/vector_nocopy.cpp new file mode 100644 index 00000000000..960762f8c16 --- /dev/null +++ b/3rdparty/bx/tests/vector_nocopy.cpp @@ -0,0 +1,229 @@ +/*- + * Copyright 2012-1015 Matthew Endsley + * All rights reserved + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted providing that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "test.h" + +#include +#include + +#include +#include +#include + +struct nocopy { + nocopy() { data = 0; } + explicit nocopy(const char* s) { data = s; } + ~nocopy() { } + void swap(nocopy& other) { std::swap(data, other.data); } + void reset(const char* s) { data = s; } + const char* release() { const char* ret = data; data = 0; return ret; } + + const char* data; + +private: + nocopy(const nocopy& other); + nocopy& operator=(const nocopy& other); +}; + +static inline bool operator==(const nocopy& lhs, const char* rhs) { + if (lhs.data == 0 && rhs == 0) + return true; + if (lhs.data != 0 && rhs != 0) + return 0 == strcmp(lhs.data, rhs); + return false; +} + +static inline bool operator==(const nocopy& lhs, const nocopy& rhs) { + if (lhs.data == 0 && rhs.data == 0) + return true; + if (lhs.data != 0 && rhs.data != 0) + return 0 == strcmp(lhs.data, rhs.data); + return false; +} + +TEST(vector_nocopy_constructor) { + typedef tinystl::vector vector; + + { + vector v; + CHECK( v.empty() ); + CHECK( v.size() == 0 ); + } + { + vector v(10); + CHECK( v.size() == 10 ); + for (tinystl::vector::iterator it = v.begin(); it != v.end(); ++it) { + CHECK( it->data == 0 ); + } + } +} + +TEST(vector_nocopy_pushback) { + tinystl::vector v; + v.emplace_back("42"); + v.emplace_back(); + v.back().reset("24"); + + CHECK( v.size() == 2 ); + CHECK( v[0] == "42" ); + CHECK( v[1] == "24" ); +} + +TEST(vector_nocopy_vector) { + tinystl::vector< tinystl::vector > v(10); + + tinystl::vector< tinystl::vector >::iterator it = v.begin(), end = v.end(); + for (; it != end; ++it) { + CHECK( (*it).empty() ); + CHECK( (*it).size() == 0 ); + CHECK( (*it).begin() == (*it).end() ); + } +} + +TEST(vector_nocopy_swap) { + tinystl::vector v1; + v1.emplace_back("12"); + v1.emplace_back("20"); + + tinystl::vector v2; + v2.emplace_back("54"); + + v1.swap(v2); + + CHECK(v1.size() == 1); + CHECK(v2.size() == 2); + CHECK(v1[0] == "54"); + CHECK(v2[0] == "12"); + CHECK(v2[1] == "20"); +} + +TEST(vector_nocopy_popback) { + tinystl::vector v; + v.emplace_back("12"); + v.emplace_back("24"); + + CHECK(v.back() == "24"); + + v.pop_back(); + + CHECK(v.back() == "12"); + CHECK(v.size() == 1); +} + +TEST(vector_nocopy_erase) { + tinystl::vector v; + v.emplace_back("1"); + v.emplace_back("2"); + v.emplace_back("3"); + v.emplace_back("4"); + v.emplace_back("5"); + + tinystl::vector::iterator it = v.erase(v.begin()); + CHECK(*it == "2"); + CHECK(v.size() == 4); + + it = v.erase(v.end() - 1); + CHECK(it == v.end()); + CHECK(v.size() == 3); + + v.erase(v.begin() + 1, v.end() - 1); + CHECK(v.size() == 2); + CHECK(v[0] == "2"); + CHECK(v[1] == "4"); +} + +TEST(vector_nocopy_erase_unordered) { + typedef tinystl::vector vector; + vector v; + v.emplace_back("1"); + v.emplace_back("2"); + v.emplace_back("3"); + v.emplace_back("4"); + v.emplace_back("5"); + + const char* first = v.front().release(); + vector::iterator it = v.erase_unordered(v.begin()); + CHECK( it == v.begin() ); + CHECK( v.size() == 4 ); + CHECK( std::count(v.begin(), v.end(), first) == 0 ); + for (it = v.begin(); it != v.end(); ++it) { + CHECK( std::count(v.begin(), v.end(), *it) == 1 ); + } + + const char* last = v.back().release(); + it = v.erase_unordered(v.end() - 1); + CHECK( it == v.end() ); + CHECK( v.size() == 3 ); + CHECK( std::count(v.begin(), v.end(), last) == 0 ); + for (it = v.begin(); it != v.end(); ++it) { + CHECK( std::count(v.begin(), v.end(), *it) == 1 ); + } + + first = v.begin()->data; + last = (v.end() - 1)->data; + v.erase_unordered(v.begin() + 1, v.end() - 1); + CHECK( v.size() == 2 ); + CHECK( std::count(v.begin(), v.end(), first) == 1 ); + CHECK( std::count(v.begin(), v.end(), last) == 1 ); +} + +TEST(vector_nocopy_insert) { + tinystl::vector v; + v.emplace_back("1"); + v.emplace_back("2"); + v.emplace_back("3"); + v.emplace_back("4"); + v.emplace_back("5"); + + v.emplace(v.begin(), "0"); + CHECK( v.size() == 6 ); + CHECK( v[0] == "0" ); + CHECK( v[1] == "1" ); + CHECK( v[5] == "5" ); + + v.emplace(v.end(), "6"); + CHECK( v.size() == 7 ); + CHECK( v.front() == "0" ); + CHECK( v.back() == "6" ); +} + +TEST(vector_nocopy_iterator) { + tinystl::vector v(5); + v[0].reset("1"); + v[1].reset("2"); + v[2].reset("3"); + v[3].reset("4"); + v[4].reset("5"); + + const tinystl::vector& cv = v; + + //CHECK(v.data() == &*v.begin()); + //CHECK(v.data() == &v[0]); + //CHECK(v.data() + v.size() == &*v.end()); + CHECK(v.begin() == cv.begin()); + CHECK(v.end() == cv.end()); + //CHECK(v.data() == cv.data()); +} diff --git a/3rdparty/bx/tests/vector_nodefault.cpp b/3rdparty/bx/tests/vector_nodefault.cpp index 319fd5546fb..4a8bc8cf1dd 100644 --- a/3rdparty/bx/tests/vector_nodefault.cpp +++ b/3rdparty/bx/tests/vector_nodefault.cpp @@ -1,5 +1,5 @@ /*- - * Copyright 2012 Matthew Endsley + * Copyright 2012-1015 Matthew Endsley * All rights reserved * * Redistribution and use in source and binary forms, with or without @@ -33,14 +33,10 @@ #include #include -#if !BX_COMPILER_MSVC -# define _strdup strdup -#endif // !BX_COMPILER_MSVC - struct nodefault { - nodefault(const char* s) { data = _strdup(s); } + nodefault(const char* s) { data = strdup(s); } ~nodefault() { free(data); } - nodefault(const nodefault& other) { data = 0; if (other.data) data = _strdup(other.data); } + nodefault(const nodefault& other) { data = 0; if (other.data) data = strdup(other.data); } nodefault& operator=(const nodefault& other) { nodefault(other).swap(*this); return *this; } void swap(nodefault& other) { std::swap(data, other.data); } diff --git a/3rdparty/bx/tools/bin/darwin/genie b/3rdparty/bx/tools/bin/darwin/genie index 37ee10c896cba6833b1c050fcde2600a4e374090..80a6659185201d39de80e21d1e0742b60bc99ce5 100644 GIT binary patch delta 75488 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 QJnJ8r7kSa+l}`u#e=P!v4gdfE delta 87999 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 OoGWFj+Da#VN&X*PoDSyz delta 27919 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 RO0ZT+I^{BhG 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