src/init.c - third_party/glfw - Git at Google

 //========================================================================
 // GLFW 3.5 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================

 #include "internal.h"

 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <assert.h>


 // NOTE: The global variables below comprise all mutable global data in GLFW
 //       Any other mutable global variable is a bug

 // This contains all mutable state shared between compilation units of GLFW
 //
 _GLFWlibrary _glfw = { GLFW_FALSE };

 // These are outside of _glfw so they can be used before initialization and
 // after termination without special handling when _glfw is cleared to zero
 //
 static _GLFWerror _glfwMainThreadError;
 static GLFWerrorfun _glfwErrorCallback;
 static GLFWallocator _glfwInitAllocator;
 static _GLFWinitconfig _glfwInitHints =
 {
     .hatButtons = GLFW_TRUE,
     .angleType = GLFW_ANGLE_PLATFORM_TYPE_NONE,
     .platformID = GLFW_ANY_PLATFORM,
     .vulkanLoader = NULL,
     .ns =
     {
         .menubar = GLFW_TRUE,
         .chdir = GLFW_TRUE
     },
     .x11 =
     {
         .xcbVulkanSurface = GLFW_TRUE,
     },
     .wl =
     {
         .libdecorMode = GLFW_WAYLAND_PREFER_LIBDECOR
     },
 };

 // The allocation function used when no custom allocator is set
 //
 static void* defaultAllocate(size_t size, void* user)
 {
     return malloc(size);
 }

 // The deallocation function used when no custom allocator is set
 //
 static void defaultDeallocate(void* block, void* user)
 {
     free(block);
 }

 // The reallocation function used when no custom allocator is set
 //
 static void* defaultReallocate(void* block, size_t size, void* user)
 {
     return realloc(block, size);
 }

 // Terminate the library
 //
 static void terminate(void)
 {
     int i;

     memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));

     while (_glfw.windowListHead)
         glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);

     while (_glfw.cursorListHead)
         glfwDestroyCursor((GLFWcursor*) _glfw.cursorListHead);

     for (i = 0;  i < _glfw.monitorCount;  i++)
     {
         _GLFWmonitor* monitor = _glfw.monitors[i];
         if (monitor->originalRamp.size)
             _glfw.platform.setGammaRamp(monitor, &monitor->originalRamp);
         _glfwFreeMonitor(monitor);
     }

     _glfw_free(_glfw.monitors);
     _glfw.monitors = NULL;
     _glfw.monitorCount = 0;

     _glfw_free(_glfw.mappings);
     _glfw.mappings = NULL;
     _glfw.mappingCount = 0;

     _glfwTerminateVulkan();
     _glfw.platform.terminateJoysticks();
     _glfw.platform.terminate();

     _glfw.initialized = GLFW_FALSE;

     while (_glfw.errorListHead)
     {
         _GLFWerror* error = _glfw.errorListHead;
         _glfw.errorListHead = error->next;
         _glfw_free(error);
     }

     _glfwPlatformDestroyTls(&_glfw.contextSlot);
     _glfwPlatformDestroyTls(&_glfw.errorSlot);
     _glfwPlatformDestroyMutex(&_glfw.errorLock);

     memset(&_glfw, 0, sizeof(_glfw));
 }


 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////

 // Encode a Unicode code point to a UTF-8 stream
 // Based on cutef8 by Jeff Bezanson (Public Domain)
 //
 size_t _glfwEncodeUTF8(char* s, uint32_t codepoint)
 {
     size_t count = 0;

     if (codepoint < 0x80)
         s[count++] = (char) codepoint;
     else if (codepoint < 0x800)
     {
         s[count++] = (codepoint >> 6) | 0xc0;
         s[count++] = (codepoint & 0x3f) | 0x80;
     }
     else if (codepoint < 0x10000)
     {
         s[count++] = (codepoint >> 12) | 0xe0;
         s[count++] = ((codepoint >> 6) & 0x3f) | 0x80;
         s[count++] = (codepoint & 0x3f) | 0x80;
     }
     else if (codepoint < 0x110000)
     {
         s[count++] = (codepoint >> 18) | 0xf0;
         s[count++] = ((codepoint >> 12) & 0x3f) | 0x80;
         s[count++] = ((codepoint >> 6) & 0x3f) | 0x80;
         s[count++] = (codepoint & 0x3f) | 0x80;
     }

     return count;
 }

 // Splits and translates a text/uri-list into separate file paths
 // NOTE: This function destroys the provided string
 //
 char** _glfwParseUriList(char* text, int* count)
 {
     const char* prefix = "file://";
     char** paths = NULL;
     char* line;

     *count = 0;

     while ((line = strtok(text, "\r\n")))
     {
         char* path;

         text = NULL;

         if (line[0] == '#')
             continue;

         if (strncmp(line, prefix, strlen(prefix)) == 0)
         {
             line += strlen(prefix);
             // TODO: Validate hostname
             while (*line != '/')
                 line++;
         }

         (*count)++;

         path = _glfw_calloc(strlen(line) + 1, 1);
         paths = _glfw_realloc(paths, *count * sizeof(char*));
         paths[*count - 1] = path;

         while (*line)
         {
             if (line[0] == '%' && line[1] && line[2])
             {
                 const char digits[3] = { line[1], line[2], '\0' };
                 *path = (char) strtol(digits, NULL, 16);
                 line += 2;
             }
             else
                 *path = *line;

             path++;
             line++;
         }
     }

     return paths;
 }

 char* _glfw_strdup(const char* source)
 {
     const size_t length = strlen(source);
     char* result = _glfw_calloc(length + 1, 1);
     strcpy(result, source);
     return result;
 }

 int _glfw_min(int a, int b)
 {
     return a < b ? a : b;
 }

 int _glfw_max(int a, int b)
 {
     return a > b ? a : b;
 }

 void* _glfw_calloc(size_t count, size_t size)
 {
     if (count && size)
     {
         void* block;

         if (count > SIZE_MAX / size)
         {
             _glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
             return NULL;
         }

         block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
         if (block)
             return memset(block, 0, count * size);
         else
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
             return NULL;
         }
     }
     else
         return NULL;
 }

 void* _glfw_realloc(void* block, size_t size)
 {
     if (block && size)
     {
         void* resized = _glfw.allocator.reallocate(block, size, _glfw.allocator.user);
         if (resized)
             return resized;
         else
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
             return NULL;
         }
     }
     else if (block)
     {
         _glfw_free(block);
         return NULL;
     }
     else
         return _glfw_calloc(1, size);
 }

 void _glfw_free(void* block)
 {
     if (block)
         _glfw.allocator.deallocate(block, _glfw.allocator.user);
 }


 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////

 // Notifies shared code of an error
 //
 void _glfwInputError(int code, const char* format, ...)
 {
     _GLFWerror* error;
     char description[_GLFW_MESSAGE_SIZE];

     if (format)
     {
         va_list vl;

         va_start(vl, format);
         vsnprintf(description, sizeof(description), format, vl);
         va_end(vl);

         description[sizeof(description) - 1] = '\0';
     }
     else
     {
         if (code == GLFW_NOT_INITIALIZED)
             strcpy(description, "The GLFW library is not initialized");
         else if (code == GLFW_NO_CURRENT_CONTEXT)
             strcpy(description, "There is no current context");
         else if (code == GLFW_INVALID_ENUM)
             strcpy(description, "Invalid argument for enum parameter");
         else if (code == GLFW_INVALID_VALUE)
             strcpy(description, "Invalid value for parameter");
         else if (code == GLFW_OUT_OF_MEMORY)
             strcpy(description, "Out of memory");
         else if (code == GLFW_API_UNAVAILABLE)
             strcpy(description, "The requested API is unavailable");
         else if (code == GLFW_VERSION_UNAVAILABLE)
             strcpy(description, "The requested API version is unavailable");
         else if (code == GLFW_PLATFORM_ERROR)
             strcpy(description, "A platform-specific error occurred");
         else if (code == GLFW_FORMAT_UNAVAILABLE)
             strcpy(description, "The requested format is unavailable");
         else if (code == GLFW_NO_WINDOW_CONTEXT)
             strcpy(description, "The specified window has no context");
         else if (code == GLFW_CURSOR_UNAVAILABLE)
             strcpy(description, "The specified cursor shape is unavailable");
         else if (code == GLFW_FEATURE_UNAVAILABLE)
             strcpy(description, "The requested feature cannot be implemented for this platform");
         else if (code == GLFW_FEATURE_UNIMPLEMENTED)
             strcpy(description, "The requested feature has not yet been implemented for this platform");
         else if (code == GLFW_PLATFORM_UNAVAILABLE)
             strcpy(description, "The requested platform is unavailable");
         else
             strcpy(description, "ERROR: UNKNOWN GLFW ERROR");
     }

     if (_glfw.initialized)
     {
         error = _glfwPlatformGetTls(&_glfw.errorSlot);
         if (!error)
         {
             error = _glfw_calloc(1, sizeof(_GLFWerror));
             _glfwPlatformSetTls(&_glfw.errorSlot, error);
             _glfwPlatformLockMutex(&_glfw.errorLock);
             error->next = _glfw.errorListHead;
             _glfw.errorListHead = error;
             _glfwPlatformUnlockMutex(&_glfw.errorLock);
         }
     }
     else
         error = &_glfwMainThreadError;

     error->code = code;
     strcpy(error->description, description);

     if (_glfwErrorCallback)
         _glfwErrorCallback(code, description);
 }


 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW public API                       //////
 //////////////////////////////////////////////////////////////////////////

 GLFWAPI int glfwInit(void)
 {
     if (_glfw.initialized)
         return GLFW_TRUE;

     memset(&_glfw, 0, sizeof(_glfw));
     _glfw.hints.init = _glfwInitHints;

     _glfw.allocator = _glfwInitAllocator;
     if (!_glfw.allocator.allocate)
     {
         _glfw.allocator.allocate   = defaultAllocate;
         _glfw.allocator.reallocate = defaultReallocate;
         _glfw.allocator.deallocate = defaultDeallocate;
     }

     if (!_glfwSelectPlatform(_glfw.hints.init.platformID, &_glfw.platform))
         return GLFW_FALSE;

     if (!_glfw.platform.init())
     {
         terminate();
         return GLFW_FALSE;
     }

     if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
         !_glfwPlatformCreateTls(&_glfw.errorSlot) ||
         !_glfwPlatformCreateTls(&_glfw.contextSlot))
     {
         terminate();
         return GLFW_FALSE;
     }

     _glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);

     _glfwInitGamepadMappings();

     _glfwPlatformInitTimer();
     _glfw.timer.offset = _glfwPlatformGetTimerValue();

     _glfw.initialized = GLFW_TRUE;

     glfwDefaultWindowHints();
     return GLFW_TRUE;
 }

 GLFWAPI void glfwTerminate(void)
 {
     if (!_glfw.initialized)
         return;

     terminate();
 }

 GLFWAPI void glfwInitHint(int hint, int value)
 {
     switch (hint)
     {
         case GLFW_JOYSTICK_HAT_BUTTONS:
             _glfwInitHints.hatButtons = value;
             return;
         case GLFW_ANGLE_PLATFORM_TYPE:
             _glfwInitHints.angleType = value;
             return;
         case GLFW_PLATFORM:
             _glfwInitHints.platformID = value;
             return;
         case GLFW_COCOA_CHDIR_RESOURCES:
             _glfwInitHints.ns.chdir = value;
             return;
         case GLFW_COCOA_MENUBAR:
             _glfwInitHints.ns.menubar = value;
             return;
         case GLFW_X11_XCB_VULKAN_SURFACE:
             _glfwInitHints.x11.xcbVulkanSurface = value;
             return;
         case GLFW_WAYLAND_LIBDECOR:
             _glfwInitHints.wl.libdecorMode = value;
             return;
     }

     _glfwInputError(GLFW_INVALID_ENUM,
                     "Invalid init hint 0x%08X", hint);
 }

 GLFWAPI void glfwInitAllocator(const GLFWallocator* allocator)
 {
     if (allocator)
     {
         if (allocator->allocate && allocator->reallocate && allocator->deallocate)
             _glfwInitAllocator = *allocator;
         else
             _glfwInputError(GLFW_INVALID_VALUE, "Missing function in allocator");
     }
     else
         memset(&_glfwInitAllocator, 0, sizeof(GLFWallocator));
 }

 GLFWAPI void glfwInitVulkanLoader(PFN_vkGetInstanceProcAddr loader)
 {
     _glfwInitHints.vulkanLoader = loader;
 }

 GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
 {
     if (major != NULL)
         *major = GLFW_VERSION_MAJOR;
     if (minor != NULL)
         *minor = GLFW_VERSION_MINOR;
     if (rev != NULL)
         *rev = GLFW_VERSION_REVISION;
 }

 GLFWAPI int glfwGetError(const char** description)
 {
     _GLFWerror* error;
     int code = GLFW_NO_ERROR;

     if (description)
         *description = NULL;

     if (_glfw.initialized)
         error = _glfwPlatformGetTls(&_glfw.errorSlot);
     else
         error = &_glfwMainThreadError;

     if (error)
     {
         code = error->code;
         error->code = GLFW_NO_ERROR;
         if (description && code)
             *description = error->description;
     }

     return code;
 }

 GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
 {
     _GLFW_SWAP(GLFWerrorfun, _glfwErrorCallback, cbfun);
     return cbfun;
 }
	//========================================================================
	// GLFW 3.5 - www.glfw.org
	//------------------------------------------------------------------------
	// Copyright (c) 2002-2006 Marcus Geelnard
	// Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
	//
	// This software is provided 'as-is', without any express or implied
	// warranty. In no event will the authors be held liable for any damages
	// arising from the use of this software.
	//
	// Permission is granted to anyone to use this software for any purpose,
	// including commercial applications, and to alter it and redistribute it
	// freely, subject to the following restrictions:
	//
	// 1. The origin of this software must not be misrepresented; you must not
	// claim that you wrote the original software. If you use this software
	// in a product, an acknowledgment in the product documentation would
	// be appreciated but is not required.
	//
	// 2. Altered source versions must be plainly marked as such, and must not
	// be misrepresented as being the original software.
	//
	// 3. This notice may not be removed or altered from any source
	// distribution.
	//
	//========================================================================

	#include "internal.h"

	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <stdarg.h>
	#include <assert.h>


	// NOTE: The global variables below comprise all mutable global data in GLFW
	// Any other mutable global variable is a bug

	// This contains all mutable state shared between compilation units of GLFW
	//
	_GLFWlibrary _glfw = { GLFW_FALSE };

	// These are outside of _glfw so they can be used before initialization and
	// after termination without special handling when _glfw is cleared to zero
	//
	static _GLFWerror _glfwMainThreadError;
	static GLFWerrorfun _glfwErrorCallback;
	static GLFWallocator _glfwInitAllocator;
	static _GLFWinitconfig _glfwInitHints =
	{
	.hatButtons = GLFW_TRUE,
	.angleType = GLFW_ANGLE_PLATFORM_TYPE_NONE,
	.platformID = GLFW_ANY_PLATFORM,
	.vulkanLoader = NULL,
	.ns =
	{
	.menubar = GLFW_TRUE,
	.chdir = GLFW_TRUE
	},
	.x11 =
	{
	.xcbVulkanSurface = GLFW_TRUE,
	},
	.wl =
	{
	.libdecorMode = GLFW_WAYLAND_PREFER_LIBDECOR
	},
	};

	// The allocation function used when no custom allocator is set
	//
	static void* defaultAllocate(size_t size, void* user)
	{
	return malloc(size);
	}

	// The deallocation function used when no custom allocator is set
	//
	static void defaultDeallocate(void* block, void* user)
	{
	free(block);
	}

	// The reallocation function used when no custom allocator is set
	//
	static void* defaultReallocate(void* block, size_t size, void* user)
	{
	return realloc(block, size);
	}

	// Terminate the library
	//
	static void terminate(void)
	{
	int i;

	memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));

	while (_glfw.windowListHead)
	glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);

	while (_glfw.cursorListHead)
	glfwDestroyCursor((GLFWcursor*) _glfw.cursorListHead);

	for (i = 0; i < _glfw.monitorCount; i++)
	{
	_GLFWmonitor* monitor = _glfw.monitors[i];
	if (monitor->originalRamp.size)
	_glfw.platform.setGammaRamp(monitor, &monitor->originalRamp);
	_glfwFreeMonitor(monitor);
	}

	_glfw_free(_glfw.monitors);
	_glfw.monitors = NULL;
	_glfw.monitorCount = 0;

	_glfw_free(_glfw.mappings);
	_glfw.mappings = NULL;
	_glfw.mappingCount = 0;

	_glfwTerminateVulkan();
	_glfw.platform.terminateJoysticks();
	_glfw.platform.terminate();

	_glfw.initialized = GLFW_FALSE;

	while (_glfw.errorListHead)
	{
	_GLFWerror* error = _glfw.errorListHead;
	_glfw.errorListHead = error->next;
	_glfw_free(error);
	}

	_glfwPlatformDestroyTls(&_glfw.contextSlot);
	_glfwPlatformDestroyTls(&_glfw.errorSlot);
	_glfwPlatformDestroyMutex(&_glfw.errorLock);

	memset(&_glfw, 0, sizeof(_glfw));
	}


	//////////////////////////////////////////////////////////////////////////
	////// GLFW internal API //////
	//////////////////////////////////////////////////////////////////////////

	// Encode a Unicode code point to a UTF-8 stream
	// Based on cutef8 by Jeff Bezanson (Public Domain)
	//
	size_t _glfwEncodeUTF8(char* s, uint32_t codepoint)
	{
	size_t count = 0;

	if (codepoint < 0x80)
	s[count++] = (char) codepoint;
	else if (codepoint < 0x800)
	{
	s[count++] = (codepoint >> 6) \| 0xc0;
	s[count++] = (codepoint & 0x3f) \| 0x80;
	}
	else if (codepoint < 0x10000)
	{
	s[count++] = (codepoint >> 12) \| 0xe0;
	s[count++] = ((codepoint >> 6) & 0x3f) \| 0x80;
	s[count++] = (codepoint & 0x3f) \| 0x80;
	}
	else if (codepoint < 0x110000)
	{
	s[count++] = (codepoint >> 18) \| 0xf0;
	s[count++] = ((codepoint >> 12) & 0x3f) \| 0x80;
	s[count++] = ((codepoint >> 6) & 0x3f) \| 0x80;
	s[count++] = (codepoint & 0x3f) \| 0x80;
	}

	return count;
	}

	// Splits and translates a text/uri-list into separate file paths
	// NOTE: This function destroys the provided string
	//
	char** _glfwParseUriList(char* text, int* count)
	{
	const char* prefix = "file://";
	char** paths = NULL;
	char* line;

	*count = 0;

	while ((line = strtok(text, "\r\n")))
	{
	char* path;

	text = NULL;

	if (line[0] == '#')
	continue;

	if (strncmp(line, prefix, strlen(prefix)) == 0)
	{
	line += strlen(prefix);
	// TODO: Validate hostname
	while (*line != '/')
	line++;
	}

	(*count)++;

	path = _glfw_calloc(strlen(line) + 1, 1);
	paths = _glfw_realloc(paths, count sizeof(char*));
	paths[*count - 1] = path;

	while (*line)
	{
	if (line[0] == '%' && line[1] && line[2])
	{
	const char digits[3] = { line[1], line[2], '\0' };
	*path = (char) strtol(digits, NULL, 16);
	line += 2;
	}
	else
	path = line;

	path++;
	line++;
	}
	}

	return paths;
	}

	char* _glfw_strdup(const char* source)
	{
	const size_t length = strlen(source);
	char* result = _glfw_calloc(length + 1, 1);
	strcpy(result, source);
	return result;
	}

	int _glfw_min(int a, int b)
	{
	return a < b ? a : b;
	}

	int _glfw_max(int a, int b)
	{
	return a > b ? a : b;
	}

	void* _glfw_calloc(size_t count, size_t size)
	{
	if (count && size)
	{
	void* block;

	if (count > SIZE_MAX / size)
	{
	_glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
	return NULL;
	}

	block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
	if (block)
	return memset(block, 0, count * size);
	else
	{
	_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
	return NULL;
	}
	}
	else
	return NULL;
	}

	void* _glfw_realloc(void* block, size_t size)
	{
	if (block && size)
	{
	void* resized = _glfw.allocator.reallocate(block, size, _glfw.allocator.user);
	if (resized)
	return resized;
	else
	{
	_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
	return NULL;
	}
	}
	else if (block)
	{
	_glfw_free(block);
	return NULL;
	}
	else
	return _glfw_calloc(1, size);
	}

	void _glfw_free(void* block)
	{
	if (block)
	_glfw.allocator.deallocate(block, _glfw.allocator.user);
	}


	//////////////////////////////////////////////////////////////////////////
	////// GLFW event API //////
	//////////////////////////////////////////////////////////////////////////

	// Notifies shared code of an error
	//
	void _glfwInputError(int code, const char* format, ...)
	{
	_GLFWerror* error;
	char description[_GLFW_MESSAGE_SIZE];

	if (format)
	{
	va_list vl;

	va_start(vl, format);
	vsnprintf(description, sizeof(description), format, vl);
	va_end(vl);

	description[sizeof(description) - 1] = '\0';
	}
	else
	{
	if (code == GLFW_NOT_INITIALIZED)
	strcpy(description, "The GLFW library is not initialized");
	else if (code == GLFW_NO_CURRENT_CONTEXT)
	strcpy(description, "There is no current context");
	else if (code == GLFW_INVALID_ENUM)
	strcpy(description, "Invalid argument for enum parameter");
	else if (code == GLFW_INVALID_VALUE)
	strcpy(description, "Invalid value for parameter");
	else if (code == GLFW_OUT_OF_MEMORY)
	strcpy(description, "Out of memory");
	else if (code == GLFW_API_UNAVAILABLE)
	strcpy(description, "The requested API is unavailable");
	else if (code == GLFW_VERSION_UNAVAILABLE)
	strcpy(description, "The requested API version is unavailable");
	else if (code == GLFW_PLATFORM_ERROR)
	strcpy(description, "A platform-specific error occurred");
	else if (code == GLFW_FORMAT_UNAVAILABLE)
	strcpy(description, "The requested format is unavailable");
	else if (code == GLFW_NO_WINDOW_CONTEXT)
	strcpy(description, "The specified window has no context");
	else if (code == GLFW_CURSOR_UNAVAILABLE)
	strcpy(description, "The specified cursor shape is unavailable");
	else if (code == GLFW_FEATURE_UNAVAILABLE)
	strcpy(description, "The requested feature cannot be implemented for this platform");
	else if (code == GLFW_FEATURE_UNIMPLEMENTED)
	strcpy(description, "The requested feature has not yet been implemented for this platform");
	else if (code == GLFW_PLATFORM_UNAVAILABLE)
	strcpy(description, "The requested platform is unavailable");
	else
	strcpy(description, "ERROR: UNKNOWN GLFW ERROR");
	}

	if (_glfw.initialized)
	{
	error = _glfwPlatformGetTls(&_glfw.errorSlot);
	if (!error)
	{
	error = _glfw_calloc(1, sizeof(_GLFWerror));
	_glfwPlatformSetTls(&_glfw.errorSlot, error);
	_glfwPlatformLockMutex(&_glfw.errorLock);
	error->next = _glfw.errorListHead;
	_glfw.errorListHead = error;
	_glfwPlatformUnlockMutex(&_glfw.errorLock);
	}
	}
	else
	error = &_glfwMainThreadError;

	error->code = code;
	strcpy(error->description, description);

	if (_glfwErrorCallback)
	_glfwErrorCallback(code, description);
	}


	//////////////////////////////////////////////////////////////////////////
	////// GLFW public API //////
	//////////////////////////////////////////////////////////////////////////

	GLFWAPI int glfwInit(void)
	{
	if (_glfw.initialized)
	return GLFW_TRUE;

	memset(&_glfw, 0, sizeof(_glfw));
	_glfw.hints.init = _glfwInitHints;

	_glfw.allocator = _glfwInitAllocator;
	if (!_glfw.allocator.allocate)
	{
	_glfw.allocator.allocate = defaultAllocate;
	_glfw.allocator.reallocate = defaultReallocate;
	_glfw.allocator.deallocate = defaultDeallocate;
	}

	if (!_glfwSelectPlatform(_glfw.hints.init.platformID, &_glfw.platform))
	return GLFW_FALSE;

	if (!_glfw.platform.init())
	{
	terminate();
	return GLFW_FALSE;
	}

	if (!_glfwPlatformCreateMutex(&_glfw.errorLock) \|\|
	!_glfwPlatformCreateTls(&_glfw.errorSlot) \|\|
	!_glfwPlatformCreateTls(&_glfw.contextSlot))
	{
	terminate();
	return GLFW_FALSE;
	}

	_glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);

	_glfwInitGamepadMappings();

	_glfwPlatformInitTimer();
	_glfw.timer.offset = _glfwPlatformGetTimerValue();

	_glfw.initialized = GLFW_TRUE;

	glfwDefaultWindowHints();
	return GLFW_TRUE;
	}

	GLFWAPI void glfwTerminate(void)
	{
	if (!_glfw.initialized)
	return;

	terminate();
	}

	GLFWAPI void glfwInitHint(int hint, int value)
	{
	switch (hint)
	{
	case GLFW_JOYSTICK_HAT_BUTTONS:
	_glfwInitHints.hatButtons = value;
	return;
	case GLFW_ANGLE_PLATFORM_TYPE:
	_glfwInitHints.angleType = value;
	return;
	case GLFW_PLATFORM:
	_glfwInitHints.platformID = value;
	return;
	case GLFW_COCOA_CHDIR_RESOURCES:
	_glfwInitHints.ns.chdir = value;
	return;
	case GLFW_COCOA_MENUBAR:
	_glfwInitHints.ns.menubar = value;
	return;
	case GLFW_X11_XCB_VULKAN_SURFACE:
	_glfwInitHints.x11.xcbVulkanSurface = value;
	return;
	case GLFW_WAYLAND_LIBDECOR:
	_glfwInitHints.wl.libdecorMode = value;
	return;
	}

	_glfwInputError(GLFW_INVALID_ENUM,
	"Invalid init hint 0x%08X", hint);
	}

	GLFWAPI void glfwInitAllocator(const GLFWallocator* allocator)
	{
	if (allocator)
	{
	if (allocator->allocate && allocator->reallocate && allocator->deallocate)
	_glfwInitAllocator = *allocator;
	else
	_glfwInputError(GLFW_INVALID_VALUE, "Missing function in allocator");
	}
	else
	memset(&_glfwInitAllocator, 0, sizeof(GLFWallocator));
	}

	GLFWAPI void glfwInitVulkanLoader(PFN_vkGetInstanceProcAddr loader)
	{
	_glfwInitHints.vulkanLoader = loader;
	}

	GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
	{
	if (major != NULL)
	*major = GLFW_VERSION_MAJOR;
	if (minor != NULL)
	*minor = GLFW_VERSION_MINOR;
	if (rev != NULL)
	*rev = GLFW_VERSION_REVISION;
	}

	GLFWAPI int glfwGetError(const char** description)
	{
	_GLFWerror* error;
	int code = GLFW_NO_ERROR;

	if (description)
	*description = NULL;

	if (_glfw.initialized)
	error = _glfwPlatformGetTls(&_glfw.errorSlot);
	else
	error = &_glfwMainThreadError;

	if (error)
	{
	code = error->code;
	error->code = GLFW_NO_ERROR;
	if (description && code)
	*description = error->description;
	}

	return code;
	}

	GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
	{
	_GLFW_SWAP(GLFWerrorfun, _glfwErrorCallback, cbfun);
	return cbfun;
	}