Update clang-format settings.

To allow for extern "C" declarations to not break on a brace. This preserves the current code style. Also add indented preprocessor definitions. This makes the formatting of "platform.h" much nicer. Bug: angleproject:2971 Change-Id: I392babe0c8d67539a8e026a36a023a7404bb63c2 Reviewed-on: https://chromium-review.googlesource.com/c/1347452 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>
2018-11-26 13:22:57 -05:00 · 2018-11-26 13:22:57 -05:00 · 7fa8824b15
--- a/.clang-format
+++ b/.clang-format
@ -13,7 +13,24 @@ IndentWidth: 4
 ColumnLimit: 100

 # Always break before braces
-BreakBeforeBraces: Allman
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterClass: true
+  AfterControlStatement: true
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterUnion: true
+  BeforeCatch: true
+  BeforeElse: true
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+
+  # Keeps extern "C" blocks unindented.
+  AfterExternBlock: false

 # Indent case labels.
 IndentCaseLabels: true
@ -33,3 +50,6 @@ AllowShortCaseLabelsOnASingleLine: false

 # Useful for spacing out functions in classes
 KeepEmptyLinesAtTheStartOfBlocks: true
+
+# Indent nested PP directives.
+IndentPPDirectives: AfterHash
--- a/src/common/debug.h
+++ b/src/common/debug.h
@ -13,15 +13,15 @@
 #include <assert.h>
 #include <stdio.h>

-#include <ios>
 #include <iomanip>
+#include <ios>
 #include <sstream>
 #include <string>

 #include "common/angleutils.h"

 #if !defined(TRACE_OUTPUT_FILE)
-#define TRACE_OUTPUT_FILE "angle_debug.txt"
+#    define TRACE_OUTPUT_FILE "angle_debug.txt"
 #endif

 namespace gl
@ -80,12 +80,12 @@ class LogMessage : angle::NonCopyable
 class DebugAnnotator : angle::NonCopyable
 {
  public:
-    DebugAnnotator(){};
-    virtual ~DebugAnnotator() { };
+    DebugAnnotator() {}
+    virtual ~DebugAnnotator() {}
    virtual void beginEvent(const char *eventName, const char *eventMessage) = 0;
    virtual void endEvent(const char *eventName)                             = 0;
    virtual void setMarker(const char *markerName)                           = 0;
-    virtual bool getStatus() = 0;
+    virtual bool getStatus()                                                 = 0;
    // Log Message Handler that gets passed every log message,
    // when debug annotations are initialized,
    // replacing default handling by LogMessage.
@ -215,11 +215,11 @@ std::ostream &FmtHex(std::ostream &os, T value)
 }  // namespace gl

 #if defined(ANGLE_ENABLE_DEBUG_TRACE) || defined(ANGLE_ENABLE_DEBUG_ANNOTATIONS)
-#define ANGLE_TRACE_ENABLED
+#    define ANGLE_TRACE_ENABLED
 #endif

 #if !defined(NDEBUG) || defined(ANGLE_ENABLE_RELEASE_ASSERTS)
-#define ANGLE_ENABLE_ASSERTS
+#    define ANGLE_ENABLE_ASSERTS
 #endif

 #define WARN() ANGLE_LOG(WARN)
@ -227,28 +227,32 @@ std::ostream &FmtHex(std::ostream &os, T value)

 // A macro to log a performance event around a scope.
 #if defined(ANGLE_TRACE_ENABLED)
-#if defined(_MSC_VER)
-#define EVENT(message, ...) gl::ScopedPerfEventHelper scopedPerfEventHelper ## __LINE__("%s" message "\n", __FUNCTION__, __VA_ARGS__);
+#    if defined(_MSC_VER)
+#        define EVENT(message, ...)                                                      \
+            gl::ScopedPerfEventHelper scopedPerfEventHelper##__LINE__("%s" message "\n", \
+                                                                      __FUNCTION__, __VA_ARGS__);
+#    else
+#        define EVENT(message, ...)                                                          \
+            gl::ScopedPerfEventHelper scopedPerfEventHelper("%s" message "\n", __FUNCTION__, \
+                                                            ##__VA_ARGS__);
+#    endif  // _MSC_VER
 #else
-#define EVENT(message, ...) gl::ScopedPerfEventHelper scopedPerfEventHelper("%s" message "\n", __FUNCTION__, ##__VA_ARGS__);
-#endif // _MSC_VER
-#else
-#define EVENT(message, ...) (void(0))
+#    define EVENT(message, ...) (void(0))
 #endif

 #if defined(COMPILER_GCC) || defined(__clang__)
-#define ANGLE_CRASH() __builtin_trap()
+#    define ANGLE_CRASH() __builtin_trap()
 #else
-#define ANGLE_CRASH() ((void)(*(volatile char *)0 = 0)), __assume(0)
+#    define ANGLE_CRASH() ((void)(*(volatile char *)0 = 0)), __assume(0)
 #endif

 #if !defined(NDEBUG)
-#define ANGLE_ASSERT_IMPL(expression) assert(expression)
-#define ANGLE_ASSERT_IMPL_IS_NORETURN 0
+#    define ANGLE_ASSERT_IMPL(expression) assert(expression)
+#    define ANGLE_ASSERT_IMPL_IS_NORETURN 0
 #else
 // TODO(jmadill): Detect if debugger is attached and break.
-#define ANGLE_ASSERT_IMPL(expression) ANGLE_CRASH()
-#define ANGLE_ASSERT_IMPL_IS_NORETURN 1
+#    define ANGLE_ASSERT_IMPL(expression) ANGLE_CRASH()
+#    define ANGLE_ASSERT_IMPL_IS_NORETURN 1
 #endif  // !defined(NDEBUG)

 // Note that gSwallowStream is used instead of an arbitrary LOG() stream to avoid the creation of an
@ -265,78 +269,80 @@ std::ostream &FmtHex(std::ostream &os, T value)

 // A macro asserting a condition and outputting failures to the debug log
 #if defined(ANGLE_ENABLE_ASSERTS)
-#define ASSERT(expression)                                                                         \
-    (expression ? static_cast<void>(0) : ((ERR() << "\t! Assert failed in " << __FUNCTION__ << "(" \
-                                                 << __LINE__ << "): " << #expression),             \
-                                          ANGLE_ASSERT_IMPL(expression)))
-#define UNREACHABLE_IS_NORETURN ANGLE_ASSERT_IMPL_IS_NORETURN
+#    define ASSERT(expression)                                                              \
+        (expression ? static_cast<void>(0)                                                  \
+                    : ((ERR() << "\t! Assert failed in " << __FUNCTION__ << "(" << __LINE__ \
+                              << "): " << #expression),                                     \
+                       ANGLE_ASSERT_IMPL(expression)))
+#    define UNREACHABLE_IS_NORETURN ANGLE_ASSERT_IMPL_IS_NORETURN
 #else
-#define ASSERT(condition) ANGLE_EAT_STREAM_PARAMETERS << !(condition)
-#define UNREACHABLE_IS_NORETURN 0
+#    define ASSERT(condition) ANGLE_EAT_STREAM_PARAMETERS << !(condition)
+#    define UNREACHABLE_IS_NORETURN 0
 #endif  // defined(ANGLE_ENABLE_ASSERTS)

 #define ANGLE_UNUSED_VARIABLE(variable) (static_cast<void>(variable))

 // A macro to indicate unimplemented functionality
 #ifndef NOASSERT_UNIMPLEMENTED
-#define NOASSERT_UNIMPLEMENTED 1
+#    define NOASSERT_UNIMPLEMENTED 1
 #endif

 #if defined(ANGLE_TRACE_ENABLED) || defined(ANGLE_ENABLE_ASSERTS)
-#define UNIMPLEMENTED()                                                                       \
-    do                                                                                        \
-    {                                                                                         \
-        WARN() << "\t! Unimplemented: " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ \
-               << ")";                                                                        \
-        ASSERT(NOASSERT_UNIMPLEMENTED);                                                       \
-    } while (0)
+#    define UNIMPLEMENTED()                                                                       \
+        do                                                                                        \
+        {                                                                                         \
+            WARN() << "\t! Unimplemented: " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ \
+                   << ")";                                                                        \
+            ASSERT(NOASSERT_UNIMPLEMENTED);                                                       \
+        } while (0)

 // A macro for code which is not expected to be reached under valid assumptions
-#define UNREACHABLE()                                                                              \
-    do                                                                                             \
-    {                                                                                              \
-        ERR() << "\t! Unreachable reached: " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ \
-              << ")";                                                                              \
-        ASSERT(false);                                                                             \
-    } while (0)
+#    define UNREACHABLE()                                                                  \
+        do                                                                                 \
+        {                                                                                  \
+            ERR() << "\t! Unreachable reached: " << __FUNCTION__ << "(" << __FILE__ << ":" \
+                  << __LINE__ << ")";                                                      \
+            ASSERT(false);                                                                 \
+        } while (0)
 #else
-#define UNIMPLEMENTED()                 \
-    do                                  \
-    {                                   \
-        ASSERT(NOASSERT_UNIMPLEMENTED); \
-    } while (0)
+#    define UNIMPLEMENTED()                 \
+        do                                  \
+        {                                   \
+            ASSERT(NOASSERT_UNIMPLEMENTED); \
+        } while (0)

 // A macro for code which is not expected to be reached under valid assumptions
-#define UNREACHABLE()  \
-    do                 \
-    {                  \
-        ASSERT(false); \
-    } while (0)
+#    define UNREACHABLE()  \
+        do                 \
+        {                  \
+            ASSERT(false); \
+        } while (0)
 #endif  // defined(ANGLE_TRACE_ENABLED) || defined(ANGLE_ENABLE_ASSERTS)

 #if defined(ANGLE_PLATFORM_WINDOWS)
-#define ANGLE_FUNCTION __FUNCTION__
+#    define ANGLE_FUNCTION __FUNCTION__
 #else
-#define ANGLE_FUNCTION __func__
+#    define ANGLE_FUNCTION __func__
 #endif

 // Defining ANGLE_ENABLE_STRUCT_PADDING_WARNINGS will enable warnings when members are added to
 // structs to enforce packing. This is helpful for diagnosing unexpected struct sizes when making
 // fast cache variables.
 #if defined(__clang__)
-#define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS \
-    _Pragma("clang diagnostic push") _Pragma("clang diagnostic error \"-Wpadded\"")
-#define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS _Pragma("clang diagnostic pop")
+#    define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS \
+        _Pragma("clang diagnostic push") _Pragma("clang diagnostic error \"-Wpadded\"")
+#    define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS _Pragma("clang diagnostic pop")
 #elif defined(COMPILER_GCC)
-#define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS \
-    _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic error \"-Wpadded\"")
-#define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS _Pragma("GCC diagnostic pop")
+#    define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS \
+        _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic error \"-Wpadded\"")
+#    define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS _Pragma("GCC diagnostic pop")
 #elif defined(_MSC_VER)
-#define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS __pragma(warning(push)) __pragma(warning(error : 4820))
-#define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS __pragma(warning(pop))
+#    define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS \
+        __pragma(warning(push)) __pragma(warning(error : 4820))
+#    define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS __pragma(warning(pop))
 #else
-#define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
-#define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
+#    define ANGLE_ENABLE_STRUCT_PADDING_WARNINGS
+#    define ANGLE_DISABLE_STRUCT_PADDING_WARNINGS
 #endif

-#endif   // COMMON_DEBUG_H_
+#endif  // COMMON_DEBUG_H_
--- a/src/common/platform.h
+++ b/src/common/platform.h
@ -10,91 +10,84 @@
 #define COMMON_PLATFORM_H_

 #if defined(_WIN32)
-#   define ANGLE_PLATFORM_WINDOWS 1
+#    define ANGLE_PLATFORM_WINDOWS 1
 #elif defined(__APPLE__)
-#   define ANGLE_PLATFORM_APPLE 1
-#   define ANGLE_PLATFORM_POSIX 1
+#    define ANGLE_PLATFORM_APPLE 1
+#    define ANGLE_PLATFORM_POSIX 1
 #elif defined(ANDROID)
-#   define ANGLE_PLATFORM_ANDROID 1
-#   define ANGLE_PLATFORM_POSIX 1
+#    define ANGLE_PLATFORM_ANDROID 1
+#    define ANGLE_PLATFORM_POSIX 1
 #elif defined(__linux__) || defined(EMSCRIPTEN)
-#   define ANGLE_PLATFORM_LINUX 1
-#   define ANGLE_PLATFORM_POSIX 1
-#elif defined(__FreeBSD__) || \
-      defined(__OpenBSD__) || \
-      defined(__NetBSD__) || \
-      defined(__DragonFly__) || \
-      defined(__sun) || \
-      defined(__GLIBC__) || \
-      defined(__GNU__) || \
-      defined(__QNX__) || \
-      defined(__Fuchsia__) || \
-      defined(__HAIKU__)
-#   define ANGLE_PLATFORM_POSIX 1
+#    define ANGLE_PLATFORM_LINUX 1
+#    define ANGLE_PLATFORM_POSIX 1
+#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) ||              \
+    defined(__DragonFly__) || defined(__sun) || defined(__GLIBC__) || defined(__GNU__) || \
+    defined(__QNX__) || defined(__Fuchsia__) || defined(__HAIKU__)
+#    define ANGLE_PLATFORM_POSIX 1
 #else
-#   error Unsupported platform.
+#    error Unsupported platform.
 #endif

 #ifdef ANGLE_PLATFORM_WINDOWS
-#   ifndef STRICT
-#       define STRICT 1
-#   endif
-#   ifndef WIN32_LEAN_AND_MEAN
-#       define WIN32_LEAN_AND_MEAN 1
-#   endif
-#   ifndef NOMINMAX
-#       define NOMINMAX 1
-#   endif
+#    ifndef STRICT
+#        define STRICT 1
+#    endif
+#    ifndef WIN32_LEAN_AND_MEAN
+#        define WIN32_LEAN_AND_MEAN 1
+#    endif
+#    ifndef NOMINMAX
+#        define NOMINMAX 1
+#    endif

-#   include <windows.h>
-#   include <intrin.h>
+#    include <intrin.h>
+#    include <windows.h>

-#   if defined(WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
-#       define ANGLE_ENABLE_WINDOWS_STORE 1
-#   endif
+#    if defined(WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
+#        define ANGLE_ENABLE_WINDOWS_STORE 1
+#    endif

-#   if defined(ANGLE_ENABLE_D3D9)
-#       include <d3d9.h>
-#       include <d3dcompiler.h>
-#   endif
+#    if defined(ANGLE_ENABLE_D3D9)
+#        include <d3d9.h>
+#        include <d3dcompiler.h>
+#    endif

 // Include D3D11 headers when OpenGL is enabled on Windows for interop extensions.
-#if defined(ANGLE_ENABLE_D3D11) || defined(ANGLE_ENABLE_OPENGL)
-#include <d3d10_1.h>
-#include <d3d11.h>
-#include <d3d11_3.h>
-#include <d3dcompiler.h>
-#include <dxgi.h>
-#include <dxgi1_2.h>
-#   endif
+#    if defined(ANGLE_ENABLE_D3D11) || defined(ANGLE_ENABLE_OPENGL)
+#        include <d3d10_1.h>
+#        include <d3d11.h>
+#        include <d3d11_3.h>
+#        include <d3dcompiler.h>
+#        include <dxgi.h>
+#        include <dxgi1_2.h>
+#    endif

-#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
-#include <wrl.h>
-#endif
+#    if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
+#        include <wrl.h>
+#    endif

-#   if defined(ANGLE_ENABLE_WINDOWS_STORE)
-#       include <dxgi1_3.h>
-#       if defined(_DEBUG)
-#           include <DXProgrammableCapture.h>
-#           include <dxgidebug.h>
-#       endif
-#   endif
+#    if defined(ANGLE_ENABLE_WINDOWS_STORE)
+#        include <dxgi1_3.h>
+#        if defined(_DEBUG)
+#            include <DXProgrammableCapture.h>
+#            include <dxgidebug.h>
+#        endif
+#    endif

-#   undef near
-#   undef far
+#    undef near
+#    undef far
 #endif

 #if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
-#include <intrin.h>
-#define ANGLE_USE_SSE
+#    include <intrin.h>
+#    define ANGLE_USE_SSE
 #elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-#include <x86intrin.h>
-#define ANGLE_USE_SSE
+#    include <x86intrin.h>
+#    define ANGLE_USE_SSE
 #endif

 // Mips and arm devices need to include stddef for size_t.
 #if defined(__mips__) || defined(__arm__) || defined(__aarch64__)
-#include <stddef.h>
+#    include <stddef.h>
 #endif

 // The MemoryBarrier function name collides with a macro under Windows
@ -103,13 +96,13 @@

 // Macro for hinting that an expression is likely to be true/false.
 #if !defined(ANGLE_LIKELY) || !defined(ANGLE_UNLIKELY)
-#if defined(__GNUC__) || defined(__clang__)
-#define ANGLE_LIKELY(x) __builtin_expect(!!(x), 1)
-#define ANGLE_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define ANGLE_LIKELY(x) (x)
-#define ANGLE_UNLIKELY(x) (x)
-#endif  // defined(__GNUC__) || defined(__clang__)
-#endif  // !defined(ANGLE_LIKELY) || !defined(ANGLE_UNLIKELY)
+#    if defined(__GNUC__) || defined(__clang__)
+#        define ANGLE_LIKELY(x) __builtin_expect(!!(x), 1)
+#        define ANGLE_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#    else
+#        define ANGLE_LIKELY(x) (x)
+#        define ANGLE_UNLIKELY(x) (x)
+#    endif  // defined(__GNUC__) || defined(__clang__)
+#endif      // !defined(ANGLE_LIKELY) || !defined(ANGLE_UNLIKELY)

-#endif // COMMON_PLATFORM_H_
+#endif  // COMMON_PLATFORM_H_
--- a/src/common/tls.cpp
+++ b/src/common/tls.cpp
@ -11,24 +11,24 @@
 #include <assert.h>

 #ifdef ANGLE_ENABLE_WINDOWS_STORE
-#include <vector>
-#include <set>
-#include <map>
-#include <mutex>
+#    include <map>
+#    include <mutex>
+#    include <set>
+#    include <vector>

-#include <wrl/client.h>
-#include <wrl/async.h>
-#include <Windows.System.Threading.h>
+#    include <Windows.System.Threading.h>
+#    include <wrl/async.h>
+#    include <wrl/client.h>

 using namespace std;
 using namespace Windows::Foundation;
 using namespace ABI::Windows::System::Threading;

 // Thread local storage for Windows Store support
-typedef vector<void*> ThreadLocalData;
+typedef vector<void *> ThreadLocalData;

-static __declspec(thread) ThreadLocalData* currentThreadData = nullptr;
-static set<ThreadLocalData*> allThreadData;
+static __declspec(thread) ThreadLocalData *currentThreadData = nullptr;
+static set<ThreadLocalData *> allThreadData;
 static DWORD nextTlsIndex = 0;
 static vector<DWORD> freeTlsIndices;

@ -39,7 +39,7 @@ TLSIndex CreateTLSIndex()
    TLSIndex index;

 #ifdef ANGLE_PLATFORM_WINDOWS
-#ifdef ANGLE_ENABLE_WINDOWS_STORE
+#    ifdef ANGLE_ENABLE_WINDOWS_STORE
    if (!freeTlsIndices.empty())
    {
        DWORD result = freeTlsIndices.back();
@ -50,9 +50,9 @@ TLSIndex CreateTLSIndex()
    {
        index = nextTlsIndex++;
    }
-#else
+#    else
    index = TlsAlloc();
-#endif
+#    endif

 #elif defined(ANGLE_PLATFORM_POSIX)
    // Create global pool key
@ -62,7 +62,8 @@ TLSIndex CreateTLSIndex()
    }
 #endif

-    assert(index != TLS_INVALID_INDEX && "CreateTLSIndex(): Unable to allocate Thread Local Storage");
+    assert(index != TLS_INVALID_INDEX &&
+           "CreateTLSIndex(): Unable to allocate Thread Local Storage");
    return index;
 }

@ -75,7 +76,7 @@ bool DestroyTLSIndex(TLSIndex index)
    }

 #ifdef ANGLE_PLATFORM_WINDOWS
-#ifdef ANGLE_ENABLE_WINDOWS_STORE
+#    ifdef ANGLE_ENABLE_WINDOWS_STORE
    assert(index < nextTlsIndex);
    assert(find(freeTlsIndices.begin(), freeTlsIndices.end(), index) == freeTlsIndices.end());

@ -88,9 +89,9 @@ bool DestroyTLSIndex(TLSIndex index)
        }
    }
    return true;
-#else
+#    else
    return (TlsFree(index) == TRUE);
-#endif
+#    endif
 #elif defined(ANGLE_PLATFORM_POSIX)
    return (pthread_key_delete(index) == 0);
 #endif
@ -105,8 +106,8 @@ bool SetTLSValue(TLSIndex index, void *value)
    }

 #ifdef ANGLE_PLATFORM_WINDOWS
-#ifdef ANGLE_ENABLE_WINDOWS_STORE
-    ThreadLocalData* threadData = currentThreadData;
+#    ifdef ANGLE_ENABLE_WINDOWS_STORE
+    ThreadLocalData *threadData = currentThreadData;
    if (!threadData)
    {
        threadData = new ThreadLocalData(index + 1, nullptr);
@ -120,9 +121,9 @@ bool SetTLSValue(TLSIndex index, void *value)

    threadData->at(index) = value;
    return true;
-#else
+#    else
    return (TlsSetValue(index, value) == TRUE);
-#endif
+#    endif
 #elif defined(ANGLE_PLATFORM_POSIX)
    return (pthread_setspecific(index, value) == 0);
 #endif
@ -137,8 +138,8 @@ void *GetTLSValue(TLSIndex index)
    }

 #ifdef ANGLE_PLATFORM_WINDOWS
-#ifdef ANGLE_ENABLE_WINDOWS_STORE
-    ThreadLocalData* threadData = currentThreadData;
+#    ifdef ANGLE_ENABLE_WINDOWS_STORE
+    ThreadLocalData *threadData = currentThreadData;
    if (threadData && threadData->size() > index)
    {
        return threadData->at(index);
@ -147,9 +148,9 @@ void *GetTLSValue(TLSIndex index)
    {
        return nullptr;
    }
-#else
+#    else
    return TlsGetValue(index);
-#endif
+#    endif
 #elif defined(ANGLE_PLATFORM_POSIX)
    return pthread_getspecific(index);
 #endif