Enclose error(GLint) and error(EGLint) into gl and egl namespaces.

This should generate a compile time error if we try to call the wrong function.

TRAC #22411

Signed-off-by: Geoff Lang
Signed-off-by: Shannon Woods
Author: Jamie Madill

git-svn-id: https://angleproject.googlecode.com/svn/branches/dx11proto@1856 736b8ea6-26fd-11df-bfd4-992fa37f6226
diff --git a/src/libEGL/Display.cpp b/src/libEGL/Display.cpp
index f0f0b1b..54523c4 100644
--- a/src/libEGL/Display.cpp
+++ b/src/libEGL/Display.cpp
@@ -436,7 +436,7 @@
     {
         (*context)->markContextLost();
     }
-    error(EGL_CONTEXT_LOST);
+    egl::error(EGL_CONTEXT_LOST);
 }
 
 bool Display::isInitialized() const
diff --git a/src/libEGL/libEGL.cpp b/src/libEGL/libEGL.cpp
index 4a09351..723fb91 100644
--- a/src/libEGL/libEGL.cpp
+++ b/src/libEGL/libEGL.cpp
@@ -22,12 +22,12 @@
 {
     if (display == EGL_NO_DISPLAY)
     {
-        return error(EGL_BAD_DISPLAY, false);
+        return egl::error(EGL_BAD_DISPLAY, false);
     }
 
     if (!display->isInitialized())
     {
-        return error(EGL_NOT_INITIALIZED, false);
+        return egl::error(EGL_NOT_INITIALIZED, false);
     }
 
     return true;
@@ -42,7 +42,7 @@
 
     if (!display->isValidConfig(config))
     {
-        return error(EGL_BAD_CONFIG, false);
+        return egl::error(EGL_BAD_CONFIG, false);
     }
 
     return true;
@@ -57,7 +57,7 @@
 
     if (!display->isValidContext(context))
     {
-        return error(EGL_BAD_CONTEXT, false);
+        return egl::error(EGL_BAD_CONTEXT, false);
     }
 
     return true;
@@ -72,7 +72,7 @@
 
     if (!display->isValidSurface(surface))
     {
-        return error(EGL_BAD_SURFACE, false);
+        return egl::error(EGL_BAD_SURFACE, false);
     }
 
     return true;
@@ -104,7 +104,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
     }
 }
 
@@ -117,24 +117,24 @@
     {
         if (dpy == EGL_NO_DISPLAY)
         {
-            return error(EGL_BAD_DISPLAY, EGL_FALSE);
+            return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
 
         if (!display->initialize())
         {
-            return error(EGL_NOT_INITIALIZED, EGL_FALSE);
+            return egl::error(EGL_NOT_INITIALIZED, EGL_FALSE);
         }
 
         if (major) *major = 1;
         if (minor) *minor = 4;
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -146,18 +146,18 @@
     {
         if (dpy == EGL_NO_DISPLAY)
         {
-            return error(EGL_BAD_DISPLAY, EGL_FALSE);
+            return egl::error(EGL_BAD_DISPLAY, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
 
         display->terminate();
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -177,20 +177,20 @@
         switch (name)
         {
           case EGL_CLIENT_APIS:
-            return success("OpenGL_ES");
+            return egl::success("OpenGL_ES");
           case EGL_EXTENSIONS:
             return display->getExtensionString();
           case EGL_VENDOR:
-            return success("Google Inc.");
+            return egl::success("Google Inc.");
           case EGL_VERSION:
-            return success("1.4 (ANGLE " VERSION_STRING ")");
+            return egl::success("1.4 (ANGLE " VERSION_STRING ")");
         }
 
-        return error(EGL_BAD_PARAMETER, (const char*)NULL);
+        return egl::error(EGL_BAD_PARAMETER, (const char*)NULL);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, (const char*)NULL);
+        return egl::error(EGL_BAD_ALLOC, (const char*)NULL);
     }
 }
 
@@ -211,21 +211,21 @@
 
         if (!num_config)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         const EGLint attribList[] =    {EGL_NONE};
 
         if (!display->getConfigs(configs, attribList, config_size, num_config))
         {
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -246,7 +246,7 @@
 
         if (!num_config)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         const EGLint attribList[] =    {EGL_NONE};
@@ -258,11 +258,11 @@
 
         display->getConfigs(configs, attrib_list, config_size, num_config);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -282,14 +282,14 @@
 
         if (!display->getConfigAttrib(config, attribute, value))
         {
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -311,14 +311,14 @@
 
         if (!IsWindow(window))
         {
-            return error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
         }
 
         return display->createWindowSurface(window, config, attrib_list);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -340,7 +340,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -360,11 +360,11 @@
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(EGL_NO_SURFACE);
+        return egl::success(EGL_NO_SURFACE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -384,16 +384,16 @@
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         display->destroySurface((egl::Surface*)surface);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -414,7 +414,7 @@
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         switch (attribute)
@@ -471,14 +471,14 @@
             *value = eglSurface->isPostSubBufferSupported();
             break;
           default:
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -499,7 +499,7 @@
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         switch (attribute)
@@ -511,14 +511,14 @@
             }
             break;
           default:
-            return error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+            return egl::error(EGL_BAD_ATTRIBUTE, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -532,20 +532,20 @@
         {
           case EGL_OPENGL_API:
           case EGL_OPENVG_API:
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);   // Not supported by this implementation
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);   // Not supported by this implementation
           case EGL_OPENGL_ES_API:
             break;
           default:
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         egl::setCurrentAPI(api);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -557,11 +557,11 @@
     {
         EGLenum API = egl::getCurrentAPI();
 
-        return success(API);
+        return egl::success(API);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -573,11 +573,11 @@
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -589,11 +589,11 @@
     {
         eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -614,14 +614,14 @@
 
         if (buftype != EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE || !buffer)
         {
-            return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
         }
 
         return display->createOffscreenSurface(config, (HANDLE)buffer, attrib_list);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -642,11 +642,11 @@
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -666,34 +666,34 @@
 
         if (buffer != EGL_BACK_BUFFER)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->getBoundTexture())
         {
-            return error(EGL_BAD_ACCESS, EGL_FALSE);
+            return egl::error(EGL_BAD_ACCESS, EGL_FALSE);
         }
 
         if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
         if (!glBindTexImage(eglSurface))
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -713,17 +713,17 @@
 
         if (buffer != EGL_BACK_BUFFER)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
         {
-            return error(EGL_BAD_MATCH, EGL_FALSE);
+            return egl::error(EGL_BAD_MATCH, EGL_FALSE);
         }
 
         gl::Texture2D *texture = eglSurface->getBoundTexture();
@@ -733,11 +733,11 @@
             texture->releaseTexImage();
         }
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -758,16 +758,16 @@
 
         if (draw_surface == NULL)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
         
         draw_surface->setSwapInterval(interval);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -795,32 +795,32 @@
                   case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
                     if (attribute[1] == EGL_TRUE)
                     {
-                        return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);   // Unimplemented
+                        return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);   // Unimplemented
                         // robust_access = true;
                     }
                     else if (attribute[1] != EGL_FALSE)
-                        return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                        return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                     break;
                   case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
                     if (attribute[1] == EGL_LOSE_CONTEXT_ON_RESET_EXT)
                         reset_notification = true;
                     else if (attribute[1] != EGL_NO_RESET_NOTIFICATION_EXT)
-                        return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                        return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                     break;
                   default:
-                    return error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
+                    return egl::error(EGL_BAD_ATTRIBUTE, EGL_NO_CONTEXT);
                 }
             }
         }
 
         if (client_version != 2)
         {
-            return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
+            return egl::error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
         }
 
         if (share_context && static_cast<gl::Context*>(share_context)->isResetNotificationEnabled() != reset_notification)
         {
-            return error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
+            return egl::error(EGL_BAD_MATCH, EGL_NO_CONTEXT);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -833,13 +833,13 @@
         EGLContext context = display->createContext(config, static_cast<gl::Context*>(share_context), reset_notification, robust_access);
 
         if (context)
-            return success(context);
+            return egl::success(context);
         else
-            return error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
+            return egl::error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
     }
 }
 
@@ -859,16 +859,16 @@
 
         if (ctx == EGL_NO_CONTEXT)
         {
-            return error(EGL_BAD_CONTEXT, EGL_FALSE);
+            return egl::error(EGL_BAD_CONTEXT, EGL_FALSE);
         }
 
         display->destroyContext(context);
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -895,7 +895,7 @@
 
         if (renderer->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if ((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) ||
@@ -915,11 +915,11 @@
 
         glMakeCurrent(context, display, static_cast<egl::Surface*>(draw));
 
-        return success(EGL_TRUE);
+        return egl::success(EGL_TRUE);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -931,11 +931,11 @@
     {
         EGLContext context = glGetCurrentContext();
 
-        return success(context);
+        return egl::success(context);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
     }
 }
 
@@ -948,21 +948,21 @@
         if (readdraw == EGL_READ)
         {
             EGLSurface read = egl::getCurrentReadSurface();
-            return success(read);
+            return egl::success(read);
         }
         else if (readdraw == EGL_DRAW)
         {
             EGLSurface draw = egl::getCurrentDrawSurface();
-            return success(draw);
+            return egl::success(draw);
         }
         else
         {
-            return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
     }
 }
 
@@ -974,11 +974,11 @@
     {
         EGLDisplay dpy = egl::getCurrentDisplay();
 
-        return success(dpy);
+        return egl::success(dpy);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
+        return egl::error(EGL_BAD_ALLOC, EGL_NO_DISPLAY);
     }
 }
 
@@ -999,11 +999,11 @@
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1015,11 +1015,11 @@
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1031,11 +1031,11 @@
     {
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1055,22 +1055,22 @@
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->swap())
         {
-            return success(EGL_TRUE);
+            return egl::success(EGL_TRUE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 
     return EGL_FALSE;
@@ -1092,16 +1092,16 @@
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         UNIMPLEMENTED();   // FIXME
 
-        return success(0);
+        return egl::success(0);
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 }
 
@@ -1113,7 +1113,7 @@
     {
         if (x < 0 || y < 0 || width < 0 || height < 0)
         {
-            return error(EGL_BAD_PARAMETER, EGL_FALSE);
+            return egl::error(EGL_BAD_PARAMETER, EGL_FALSE);
         }
 
         egl::Display *display = static_cast<egl::Display*>(dpy);
@@ -1126,22 +1126,22 @@
 
         if (display->getRenderer()->isDeviceLost())
         {
-            return error(EGL_CONTEXT_LOST, EGL_FALSE);
+            return egl::error(EGL_CONTEXT_LOST, EGL_FALSE);
         }
 
         if (surface == EGL_NO_SURFACE)
         {
-            return error(EGL_BAD_SURFACE, EGL_FALSE);
+            return egl::error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
         if (eglSurface->postSubBuffer(x, y, width, height))
         {
-            return success(EGL_TRUE);
+            return egl::success(EGL_TRUE);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, EGL_FALSE);
+        return egl::error(EGL_BAD_ALLOC, EGL_FALSE);
     }
 
     return EGL_FALSE;
@@ -1178,7 +1178,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
+        return egl::error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
     }
 }
 }
diff --git a/src/libEGL/main.cpp b/src/libEGL/main.cpp
index dc24c4f..424ec3f 100644
--- a/src/libEGL/main.cpp
+++ b/src/libEGL/main.cpp
@@ -157,9 +157,10 @@
 
     return current->readSurface;
 }
-}
 
 void error(EGLint errorCode)
 {
     egl::setCurrentError(errorCode);
 }
+
+}
diff --git a/src/libEGL/main.h b/src/libEGL/main.h
index d09d9e6..77da8f0 100644
--- a/src/libEGL/main.h
+++ b/src/libEGL/main.h
@@ -38,7 +38,6 @@
 
 void setCurrentReadSurface(EGLSurface surface);
 EGLSurface getCurrentReadSurface();
-}
 
 void error(EGLint errorCode);
 
@@ -58,4 +57,6 @@
     return returnValue;
 }
 
+}
+
 #endif  // LIBEGL_MAIN_H_
diff --git a/src/libGLESv2/Context.cpp b/src/libGLESv2/Context.cpp
index 8e4b703..7fec8d5 100644
--- a/src/libGLESv2/Context.cpp
+++ b/src/libGLESv2/Context.cpp
@@ -982,7 +982,7 @@
     {
         if (mState.activeQuery[i].get() != NULL)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1005,13 +1005,13 @@
     // check that name was obtained with glGenQueries
     if (!queryObject)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     // check for type mismatch
     if (queryObject->getType() != target)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     // set query as active for specified target
@@ -1042,7 +1042,7 @@
 
     if (queryObject == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     queryObject->end();
@@ -1471,7 +1471,7 @@
         {
             if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
             {
-                error(GL_INVALID_OPERATION);
+                gl::error(GL_INVALID_OPERATION);
                 return false;
             }
 
@@ -1482,7 +1482,7 @@
         {
             if (mState.activeSampler > mRenderer->getMaxCombinedTextureImageUnits() - 1)
             {
-                error(GL_INVALID_OPERATION);
+                gl::error(GL_INVALID_OPERATION);
                 return false;
             }
 
@@ -1694,7 +1694,7 @@
 
     if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
     }
 
     mRenderer->applyRenderTarget(framebufferObject);
@@ -1826,12 +1826,12 @@
 
     if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     if (getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     GLsizei outputPitch = ComputePitch(width, ConvertSizedInternalFormat(format, type), getPackAlignment());
@@ -1841,7 +1841,7 @@
         int requiredSize = outputPitch * height;
         if (requiredSize > *bufSize)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1854,7 +1854,7 @@
 
     if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     DWORD flags = 0;
@@ -1900,7 +1900,7 @@
 
     if (mask != 0)
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     if (!applyRenderTarget(GL_TRIANGLES, true))   // Clips the clear to the scissor rectangle but not the viewport
@@ -1926,7 +1926,7 @@
 {
     if (!mState.currentProgram)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!mRenderer->applyPrimitiveType(mode, count))
@@ -1946,7 +1946,7 @@
     GLenum err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, first, count, instances);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     applyShaders();
@@ -1954,7 +1954,7 @@
 
     if (!programBinary->validateSamplers(NULL))
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!skipDraw(mode))
@@ -1967,12 +1967,12 @@
 {
     if (!mState.currentProgram)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!indices && !mState.elementArrayBuffer)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
     
     if (!mRenderer->applyPrimitiveType(mode, count))
@@ -1991,7 +1991,7 @@
     GLenum err = mRenderer->applyIndexBuffer(indices, mState.elementArrayBuffer.get(), count, mode, type, &indexInfo);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     ProgramBinary *programBinary = getCurrentProgramBinary();
@@ -2000,7 +2000,7 @@
     err = mRenderer->applyVertexBuffer(programBinary, mState.vertexAttribute, indexInfo.minIndex, vertexCount, instances);
     if (err != GL_NO_ERROR)
     {
-        return error(err);
+        return gl::error(err);
     }
 
     applyShaders();
@@ -2008,7 +2008,7 @@
 
     if (!programBinary->validateSamplers(NULL))
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!skipDraw(mode))
@@ -2262,13 +2262,13 @@
     Framebuffer *framebuffer = getReadFramebuffer();
     if (!framebuffer || framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     Renderbuffer *renderbuffer = framebuffer->getColorbuffer();
     if (!renderbuffer)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     *format = gl::ExtractFormat(renderbuffer->getActualFormat()); 
@@ -2619,12 +2619,12 @@
     if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
         !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
-        return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
     if (drawFramebuffer->getSamples() != 0)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     int readBufferWidth = readFramebuffer->getColorbuffer()->getWidth();
@@ -2797,12 +2797,12 @@
             readFramebuffer->getColorbuffer()->getActualFormat() != drawFramebuffer->getColorbuffer()->getActualFormat())
         {
             ERR("Color buffer format conversion in BlitFramebufferANGLE not supported by this implementation");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
         
         if (partialBufferCopy && readFramebuffer->getSamples() != 0)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         blitRenderTarget = true;
@@ -2824,7 +2824,7 @@
                 if (readFramebuffer->getDepthbufferType() != drawFramebuffer->getDepthbufferType() ||
                     readFramebuffer->getDepthbuffer()->getActualFormat() != drawFramebuffer->getDepthbuffer()->getActualFormat())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 blitDepthStencil = true;
@@ -2840,7 +2840,7 @@
                 if (readFramebuffer->getStencilbufferType() != drawFramebuffer->getStencilbufferType() ||
                     readFramebuffer->getStencilbuffer()->getActualFormat() != drawFramebuffer->getStencilbuffer()->getActualFormat())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 blitDepthStencil = true;
@@ -2852,13 +2852,13 @@
         if (partialBufferCopy)
         {
             ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
-            return error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
+            return gl::error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
         }
 
         if ((drawDSBuffer && drawDSBuffer->getSamples() != 0) || 
             (readDSBuffer && readDSBuffer->getSamples() != 0))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
diff --git a/src/libGLESv2/Texture.cpp b/src/libGLESv2/Texture.cpp
index 28c27db..4ac8e74 100644
--- a/src/libGLESv2/Texture.cpp
+++ b/src/libGLESv2/Texture.cpp
@@ -513,7 +513,7 @@
 {
     if (xoffset + width > mImageArray[level]->getWidth() || yoffset + height > mImageArray[level]->getHeight())
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     if (!mImageArray[level]->isRenderableFormat() || (!mTexStorage && !isSamplerComplete()))
@@ -740,7 +740,7 @@
             if (!mRenderer->copyToRenderTarget(newTexStorage, mTexStorage))
             {   
                 delete newTexStorage;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
     }
@@ -757,7 +757,7 @@
     {
         if (!isPow2(mImageArray[0]->getWidth()) || !isPow2(mImageArray[0]->getHeight()))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -792,7 +792,7 @@
 {
     if (target != GL_TEXTURE_2D)
     {
-        return error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
+        return gl::error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
     }
 
     if (mColorbufferProxy == NULL)
@@ -1199,7 +1199,7 @@
             if (!mRenderer->copyToRenderTarget(newTexStorage, mTexStorage))
             {
                 delete newTexStorage;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
     }
@@ -1291,7 +1291,7 @@
 
     if (xoffset + width > size || yoffset + height > size)
     {
-        return error(GL_INVALID_VALUE);
+        return gl::error(GL_INVALID_VALUE);
     }
 
     unsigned int faceindex = faceIndex(target);
@@ -1365,14 +1365,14 @@
 {
     if (!isCubeComplete())
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     if (!mRenderer->getNonPower2TextureSupport())
     {
         if (!isPow2(mImageArray[0][0]->getWidth()))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
     }
 
@@ -1416,7 +1416,7 @@
 {
     if (!IsCubemapTextureTarget(target))
     {
-        return error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
+        return gl::error(GL_INVALID_OPERATION, (Renderbuffer *)NULL);
     }
 
     unsigned int face = faceIndex(target);
diff --git a/src/libGLESv2/libGLESv2.cpp b/src/libGLESv2/libGLESv2.cpp
index ad35739..52bf8d7 100644
--- a/src/libGLESv2/libGLESv2.cpp
+++ b/src/libGLESv2/libGLESv2.cpp
@@ -71,7 +71,7 @@
       case GL_DEPTH_STENCIL_OES:
         break;
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 
     // invalid <type> -> sets INVALID_ENUM
@@ -89,7 +89,7 @@
           case GL_LUMINANCE_ALPHA:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       case GL_FLOAT:
@@ -103,7 +103,7 @@
           case GL_LUMINANCE_ALPHA:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       case GL_UNSIGNED_SHORT_4_4_4_4:
@@ -113,7 +113,7 @@
           case GL_RGBA:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       case GL_UNSIGNED_SHORT_5_6_5:
@@ -122,7 +122,7 @@
           case GL_RGB:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       case GL_UNSIGNED_SHORT:
@@ -132,7 +132,7 @@
           case GL_DEPTH_COMPONENT:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       case GL_UNSIGNED_INT_24_8_OES:
@@ -141,11 +141,11 @@
           case GL_DEPTH_STENCIL_OES:
             return true;
           default:
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
 
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 }
 
@@ -155,12 +155,12 @@
 {
     if (!texture)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     if (compressed != texture->isCompressed(level))
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     if (format != GL_NONE)
@@ -168,7 +168,7 @@
         GLenum internalformat = gl::ConvertSizedInternalFormat(format, type);
         if (internalformat != texture->getInternalFormat(level))
         {
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
     }
 
@@ -177,14 +177,14 @@
         if ((width % 4 != 0 && width != texture->getWidth(0)) ||
             (height % 4 != 0 && height != texture->getHeight(0)))
         {
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
     }
 
     if (xoffset + width > texture->getWidth(level) ||
         yoffset + height > texture->getHeight(level))
     {
-        return error(GL_INVALID_VALUE, false);
+        return gl::error(GL_INVALID_VALUE, false);
     }
 
     return true;
@@ -196,12 +196,12 @@
 {
     if (!texture)
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     if (compressed != texture->isCompressed(target, level))
     {
-        return error(GL_INVALID_OPERATION, false);
+        return gl::error(GL_INVALID_OPERATION, false);
     }
 
     if (format != GL_NONE)
@@ -209,7 +209,7 @@
         GLenum internalformat = gl::ConvertSizedInternalFormat(format, type);
         if (internalformat != texture->getInternalFormat(target, level))
         {
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
     }
 
@@ -218,14 +218,14 @@
         if ((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
             (height % 4 != 0 && height != texture->getHeight(target, 0)))
         {
-            return error(GL_INVALID_OPERATION, false);
+            return gl::error(GL_INVALID_OPERATION, false);
         }
     }
 
     if (xoffset + width > texture->getWidth(target, level) ||
         yoffset + height > texture->getHeight(target, level))
     {
-        return error(GL_INVALID_VALUE, false);
+        return gl::error(GL_INVALID_VALUE, false);
     }
 
     return true;
@@ -277,7 +277,7 @@
         {
             if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + context->getMaximumCombinedTextureImageUnits() - 1)
             {
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             context->setActiveSampler(texture - GL_TEXTURE0);
@@ -285,7 +285,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -306,11 +306,11 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -318,23 +318,23 @@
             {
                 if (context->getProgram(shader))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
             if (!programObject->attachShader(shaderObject))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -350,12 +350,12 @@
           case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
               break;
           default: 
-              return error(GL_INVALID_ENUM);
+              return gl::error(GL_INVALID_ENUM);
         }
 
         if (id == 0)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -367,7 +367,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -379,7 +379,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -392,17 +392,17 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
             if (strncmp(name, "gl_", 3) == 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             programObject->bindAttributeLocation(index, name);
@@ -410,7 +410,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -433,13 +433,13 @@
                 context->bindElementArrayBuffer(buffer);
                 return;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -451,7 +451,7 @@
     {
         if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -471,7 +471,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -483,7 +483,7 @@
     {
         if (target != GL_RENDERBUFFER)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -495,7 +495,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -513,7 +513,7 @@
 
             if (textureObject && textureObject->getTarget() != target && texture != 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch (target)
@@ -525,13 +525,13 @@
                 context->bindTextureCubeMap(texture);
                 return;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -551,7 +551,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -573,7 +573,7 @@
           case GL_FUNC_REVERSE_SUBTRACT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (modeAlpha)
@@ -583,7 +583,7 @@
           case GL_FUNC_REVERSE_SUBTRACT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -595,7 +595,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -630,7 +630,7 @@
           case GL_SRC_ALPHA_SATURATE:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (dstRGB)
@@ -651,7 +651,7 @@
           case GL_ONE_MINUS_CONSTANT_ALPHA:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (srcAlpha)
@@ -673,7 +673,7 @@
           case GL_SRC_ALPHA_SATURATE:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (dstAlpha)
@@ -694,7 +694,7 @@
           case GL_ONE_MINUS_CONSTANT_ALPHA:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         bool constantColorUsed = (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR ||
@@ -706,7 +706,7 @@
         if (constantColorUsed && constantAlphaUsed)
         {
             ERR("Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR invalid under WebGL");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -718,7 +718,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -731,7 +731,7 @@
     {
         if (size < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         switch (usage)
@@ -741,7 +741,7 @@
           case GL_DYNAMIC_DRAW:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -759,12 +759,12 @@
                 buffer = context->getElementArrayBuffer();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             if (!buffer)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             buffer->bufferData(data, size, usage);
@@ -772,7 +772,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -785,7 +785,7 @@
     {
         if (size < 0 || offset < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (data == NULL)
@@ -808,17 +808,17 @@
                 buffer = context->getElementArrayBuffer();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             if (!buffer)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if ((size_t)size + offset > buffer->size())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             buffer->bufferSubData(data, size, offset);
@@ -826,7 +826,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -838,7 +838,7 @@
     {
         if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
         {
-            return error(GL_INVALID_ENUM, 0);
+            return gl::error(GL_INVALID_ENUM, 0);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -860,7 +860,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, 0);
+        return gl::error(GL_OUT_OF_MEMORY, 0);
     }
 
     return 0;
@@ -881,7 +881,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -901,7 +901,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -920,7 +920,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -939,7 +939,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -959,7 +959,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -979,11 +979,11 @@
             {
                 if (context->getProgram(shader))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -992,7 +992,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1007,7 +1007,7 @@
     {
         if (!validImageSize(level, width, height) || border != 0 || imageSize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         switch (internalformat)
@@ -1018,12 +1018,12 @@
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (border != 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1032,7 +1032,7 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (target)
@@ -1041,7 +1041,7 @@
                 if (width > (context->getMaximumTextureDimension() >> level) ||
                     height > (context->getMaximumTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
@@ -1052,17 +1052,17 @@
               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
                 if (width != height)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
 
                 if (width > (context->getMaximumCubeTextureDimension() >> level) ||
                     height > (context->getMaximumCubeTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (internalformat) {
@@ -1070,19 +1070,19 @@
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
                 if (!context->supportsDXT1Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
                 if (!context->supportsDXT3Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if (!context->supportsDXT5Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               default: UNREACHABLE();
@@ -1090,7 +1090,7 @@
 
             if (imageSize != gl::ComputeCompressedSize(width, height, internalformat))
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             if (target == GL_TEXTURE_2D)
@@ -1099,12 +1099,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
@@ -1115,12 +1115,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 switch (target)
@@ -1141,7 +1141,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1157,12 +1157,12 @@
     {
         if (!gl::IsInternalTextureTarget(target))
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (xoffset < 0 || yoffset < 0 || !validImageSize(level, width, height) || imageSize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         switch (format)
@@ -1173,7 +1173,7 @@
           case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (width == 0 || height == 0 || data == NULL)
@@ -1187,7 +1187,7 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (format) {
@@ -1195,19 +1195,19 @@
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
                 if (!context->supportsDXT1Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
                 if (!context->supportsDXT3Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if (!context->supportsDXT5Textures())
                 {
-                    return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
+                    return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
                 }
                 break;
               default: UNREACHABLE();
@@ -1215,12 +1215,12 @@
 
             if (imageSize != gl::ComputeCompressedSize(width, height, format))
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             if (xoffset % 4 != 0 || yoffset % 4 != 0)
             {
-                return error(GL_INVALID_OPERATION); // we wait to check the offsets until this point, because the multiple-of-four restriction
+                return gl::error(GL_INVALID_OPERATION); // we wait to check the offsets until this point, because the multiple-of-four restriction
                                                     // does not exist unless DXT textures are supported.
             }
 
@@ -1248,7 +1248,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1262,12 +1262,12 @@
     {
         if (!validImageSize(level, width, height))
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (border != 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1276,7 +1276,7 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (target)
@@ -1285,7 +1285,7 @@
                 if (width > (context->getMaximumTextureDimension() >> level) ||
                     height > (context->getMaximumTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
@@ -1296,29 +1296,29 @@
               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
                 if (width != height)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
 
                 if (width > (context->getMaximumCubeTextureDimension() >> level) ||
                     height > (context->getMaximumCubeTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             gl::Framebuffer *framebuffer = context->getReadFramebuffer();
 
             if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
             {
-                return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+                return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
             }
 
             if (context->getReadFramebufferHandle() != 0 && framebuffer->getColorbuffer()->getSamples() != 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::Renderbuffer *source = framebuffer->getColorbuffer();
@@ -1333,7 +1333,7 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               case GL_LUMINANCE:
@@ -1344,7 +1344,7 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               case GL_LUMINANCE_ALPHA:
@@ -1353,38 +1353,38 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                  {
-                     return error(GL_INVALID_OPERATION);
+                     return gl::error(GL_INVALID_OPERATION);
                  }
                  break;
               case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
                 if (context->supportsDXT1Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
                 if (context->supportsDXT3Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if (context->supportsDXT5Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_DEPTH_COMPONENT:
@@ -1394,14 +1394,14 @@
               case GL_DEPTH24_STENCIL8_OES:
                   if (context->supportsDepthTextures())
                   {
-                      return error(GL_INVALID_OPERATION);
+                      return gl::error(GL_INVALID_OPERATION);
                   }
                   else
                   {
-                      return error(GL_INVALID_ENUM);
+                      return gl::error(GL_INVALID_ENUM);
                   }
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             if (target == GL_TEXTURE_2D)
@@ -1410,12 +1410,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->copyImage(level, internalformat, x, y, width, height, framebuffer);
@@ -1426,12 +1426,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);
@@ -1441,7 +1441,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1455,17 +1455,17 @@
     {
         if (!gl::IsInternalTextureTarget(target))
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (width == 0 || height == 0)
@@ -1479,19 +1479,19 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             gl::Framebuffer *framebuffer = context->getReadFramebuffer();
 
             if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
             {
-                return error(GL_INVALID_FRAMEBUFFER_OPERATION);
+                return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
             }
 
             if (context->getReadFramebufferHandle() != 0 && framebuffer->getColorbuffer()->getSamples() != 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::Renderbuffer *source = framebuffer->getColorbuffer();
@@ -1532,7 +1532,7 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               case GL_LUMINANCE:
@@ -1543,7 +1543,7 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               case GL_LUMINANCE_ALPHA:
@@ -1552,19 +1552,19 @@
                     colorbufferFormat != GL_RGB5_A1 &&
                     colorbufferFormat != GL_RGBA8_OES)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
               case GL_DEPTH_COMPONENT:
               case GL_DEPTH_STENCIL_OES:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             texture->copySubImage(target, level, xoffset, yoffset, x, y, width, height, framebuffer);
@@ -1573,7 +1573,7 @@
 
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1592,7 +1592,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, 0);
+        return gl::error(GL_OUT_OF_MEMORY, 0);
     }
 
     return 0;
@@ -1614,13 +1614,13 @@
               case GL_VERTEX_SHADER:
                 return context->createShader(type);
               default:
-                return error(GL_INVALID_ENUM, 0);
+                return gl::error(GL_INVALID_ENUM, 0);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, 0);
+        return gl::error(GL_OUT_OF_MEMORY, 0);
     }
 
     return 0;
@@ -1647,12 +1647,12 @@
             }
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1664,7 +1664,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1679,7 +1679,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1691,7 +1691,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1706,7 +1706,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1718,7 +1718,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1736,7 +1736,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1759,11 +1759,11 @@
             {
                 if(context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -1772,7 +1772,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1784,7 +1784,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1799,7 +1799,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1811,7 +1811,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1826,7 +1826,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1849,11 +1849,11 @@
             {
                 if(context->getProgram(shader))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -1862,7 +1862,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1874,7 +1874,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1892,7 +1892,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1914,7 +1914,7 @@
           case GL_NOTEQUAL:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -1926,7 +1926,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1945,7 +1945,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1964,7 +1964,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -1988,11 +1988,11 @@
                 shaderByProgramHandle = context->getShader(program);
                 if (!shaderByProgramHandle)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 else
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
             }
 
@@ -2001,23 +2001,23 @@
                 gl::Program *programByShaderHandle = context->getProgram(shader);
                 if (!programByShaderHandle)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 else
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
             }
 
             if (!programObject->detachShader(shaderObject))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2043,13 +2043,13 @@
               case GL_BLEND:                    context->setBlend(false);                 break;
               case GL_DITHER:                   context->setDither(false);                break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2061,7 +2061,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2073,7 +2073,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2085,7 +2085,7 @@
     {
         if (count < 0 || first < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2097,7 +2097,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2109,7 +2109,7 @@
     {
         if (count < 0 || first < 0 || primcount < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (primcount > 0)
@@ -2124,7 +2124,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2137,7 +2137,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2152,11 +2152,11 @@
               case GL_UNSIGNED_INT:
                 if (!context->supports32bitIndices())
                 {
-                    return error(GL_INVALID_ENUM);    
+                    return gl::error(GL_INVALID_ENUM);    
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         
             context->drawElements(mode, count, type, indices, 0);
@@ -2164,7 +2164,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2177,7 +2177,7 @@
     {
         if (count < 0 || primcount < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (primcount > 0)
@@ -2194,11 +2194,11 @@
                   case GL_UNSIGNED_INT:
                     if (!context->supports32bitIndices())
                     {
-                        return error(GL_INVALID_ENUM);    
+                        return gl::error(GL_INVALID_ENUM);    
                     }
                     break;
                   default:
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
             
                 context->drawElements(mode, count, type, indices, primcount);
@@ -2207,7 +2207,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2233,13 +2233,13 @@
               case GL_BLEND:                    context->setBlend(true);                 break;
               case GL_DITHER:                   context->setDither(true);                break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2251,7 +2251,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2263,7 +2263,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2279,7 +2279,7 @@
           case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
               break;
           default: 
-              return error(GL_INVALID_ENUM);
+              return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2291,7 +2291,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2309,7 +2309,7 @@
 
             if (fenceObject == NULL)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             fenceObject->finishFence();
@@ -2317,7 +2317,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2336,7 +2336,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2355,7 +2355,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2369,7 +2369,7 @@
         if ((target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
             || (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2391,7 +2391,7 @@
 
             if (!framebuffer || (framebufferHandle == 0 && renderbuffer != 0))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch (attachment)
@@ -2406,13 +2406,13 @@
                 framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2425,7 +2425,7 @@
     {
         if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (attachment)
@@ -2435,7 +2435,7 @@
           case GL_STENCIL_ATTACHMENT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2452,7 +2452,7 @@
 
                 if (tex == NULL)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 switch (textarget)
@@ -2461,12 +2461,12 @@
                     {
                         if (tex->getTarget() != GL_TEXTURE_2D)
                         {
-                            return error(GL_INVALID_OPERATION);
+                            return gl::error(GL_INVALID_OPERATION);
                         }
                         gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
                         if (tex2d->isCompressed(0))
                         {
-                            return error(GL_INVALID_OPERATION);
+                            return gl::error(GL_INVALID_OPERATION);
                         }
                         break;
                     }
@@ -2480,23 +2480,23 @@
                     {
                         if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
                         {
-                            return error(GL_INVALID_OPERATION);
+                            return gl::error(GL_INVALID_OPERATION);
                         }
                         gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
                         if (texcube->isCompressed(textarget, level))
                         {
-                            return error(GL_INVALID_OPERATION);
+                            return gl::error(GL_INVALID_OPERATION);
                         }
                         break;
                     }
 
                   default:
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
 
                 if (level != 0)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -2515,7 +2515,7 @@
 
             if (framebufferHandle == 0 || !framebuffer)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch (attachment)
@@ -2528,7 +2528,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2552,12 +2552,12 @@
             }
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2569,7 +2569,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2584,7 +2584,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2606,11 +2606,11 @@
 
                     if (tex2d->isCompressed(0))
                     {
-                        return error(GL_INVALID_OPERATION);
+                        return gl::error(GL_INVALID_OPERATION);
                     }
                     if (tex2d->isDepth(0))
                     {
-                        return error(GL_INVALID_OPERATION);
+                        return gl::error(GL_INVALID_OPERATION);
                     }
 
                     tex2d->generateMipmaps();
@@ -2623,7 +2623,7 @@
 
                     if (texcube->isCompressed(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0))
                     {
-                        return error(GL_INVALID_OPERATION);
+                        return gl::error(GL_INVALID_OPERATION);
                     }
 
                     texcube->generateMipmaps();
@@ -2631,13 +2631,13 @@
                 }
 
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2649,7 +2649,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2664,7 +2664,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2676,7 +2676,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2691,7 +2691,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2703,7 +2703,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2718,7 +2718,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2730,7 +2730,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2745,7 +2745,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2757,7 +2757,7 @@
     {
         if (n < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2772,7 +2772,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2786,7 +2786,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2799,17 +2799,17 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
             if (index >= (GLuint)programObject->getActiveAttributeCount())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             programObject->getActiveAttribute(index, bufsize, length, size, type, name);
@@ -2817,7 +2817,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2831,7 +2831,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2844,17 +2844,17 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
             if (index >= (GLuint)programObject->getActiveUniformCount())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             programObject->getActiveUniform(index, bufsize, length, size, type, name);
@@ -2862,7 +2862,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2875,7 +2875,7 @@
     {
         if (maxcount < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -2888,11 +2888,11 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -2901,7 +2901,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -2922,18 +2922,18 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION, -1);
+                    return gl::error(GL_INVALID_OPERATION, -1);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE, -1);
+                    return gl::error(GL_INVALID_VALUE, -1);
                 }
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programObject->isLinked() || !programBinary)
             {
-                return error(GL_INVALID_OPERATION, -1);
+                return gl::error(GL_INVALID_OPERATION, -1);
             }
 
             return programBinary->getAttributeLocation(name);
@@ -2941,7 +2941,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, -1);
+        return gl::error(GL_OUT_OF_MEMORY, -1);
     }
 
     return -1;
@@ -2962,7 +2962,7 @@
                 GLenum nativeType;
                 unsigned int numParams = 0;
                 if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
 
                 if (numParams == 0)
                     return; // it is known that the pname is valid, but there are no parameters to return
@@ -3006,7 +3006,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3030,13 +3030,13 @@
               case GL_ELEMENT_ARRAY_BUFFER:
                 buffer = context->getElementArrayBuffer();
                 break;
-              default: return error(GL_INVALID_ENUM);
+              default: return gl::error(GL_INVALID_ENUM);
             }
 
             if (!buffer)
             {
                 // A null buffer means that "0" is bound to the requested buffer target
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch (pname)
@@ -3047,13 +3047,13 @@
               case GL_BUFFER_SIZE:
                 *params = buffer->size();
                 break;
-              default: return error(GL_INVALID_ENUM);
+              default: return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3086,7 +3086,7 @@
 
             if (fenceObject == NULL)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             fenceObject->getFenceiv(pname, params);
@@ -3094,7 +3094,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3113,7 +3113,7 @@
                 GLenum nativeType;
                 unsigned int numParams = 0;
                 if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
 
                 if (numParams == 0)
                     return; // it is known that the pname is valid, but that there are no parameters to return.
@@ -3154,7 +3154,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3171,7 +3171,7 @@
         {
             if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
             {
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             gl::Framebuffer *framebuffer = NULL;
@@ -3179,7 +3179,7 @@
             {
                 if(context->getReadFramebufferHandle() == 0)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 framebuffer = context->getReadFramebuffer();
@@ -3188,7 +3188,7 @@
             {
                 if (context->getDrawFramebufferHandle() == 0)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 framebuffer = context->getDrawFramebuffer();
@@ -3210,7 +3210,7 @@
                 attachmentType = framebuffer->getStencilbufferType();
                 attachmentHandle = framebuffer->getStencilbufferHandle();
                 break;
-              default: return error(GL_INVALID_ENUM);
+              default: return gl::error(GL_INVALID_ENUM);
             }
 
             GLenum attachmentObjectType;   // Type category
@@ -3240,7 +3240,7 @@
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
@@ -3250,7 +3250,7 @@
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
@@ -3267,17 +3267,17 @@
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3317,7 +3317,7 @@
                 GLenum nativeType;
                 unsigned int numParams = 0;
                 if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
 
                 if (numParams == 0)
                     return; // it is known that pname is valid, but there are no parameters to return
@@ -3363,7 +3363,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3381,7 +3381,7 @@
 
             if (!programObject)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (pname)
@@ -3417,13 +3417,13 @@
                 *params = programObject->getProgramBinaryLength();
                 return;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3436,7 +3436,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3447,7 +3447,7 @@
 
             if (!programObject)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             programObject->getInfoLog(bufsize, length, infolog);
@@ -3455,7 +3455,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3470,7 +3470,7 @@
           case GL_CURRENT_QUERY_EXT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3482,7 +3482,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3498,7 +3498,7 @@
           case GL_QUERY_RESULT_AVAILABLE_EXT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
         gl::Context *context = gl::getNonLostContext();
 
@@ -3508,12 +3508,12 @@
 
             if (!queryObject)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (context->getActiveQuery(queryObject->getType()) == id)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch(pname)
@@ -3531,7 +3531,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3547,12 +3547,12 @@
         {
             if (target != GL_RENDERBUFFER)
             {
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             if (context->getRenderbufferHandle() == 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferHandle());
@@ -3575,17 +3575,17 @@
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3603,7 +3603,7 @@
 
             if (!shaderObject)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (pname)
@@ -3627,13 +3627,13 @@
                 *params = shaderObject->getTranslatedSourceLength();
                 return;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3646,7 +3646,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3657,7 +3657,7 @@
 
             if (!shaderObject)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             shaderObject->getInfoLog(bufsize, length, infolog);
@@ -3665,7 +3665,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3682,7 +3682,7 @@
           case GL_FRAGMENT_SHADER:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (precisiontype)
@@ -3705,12 +3705,12 @@
             *precision = 0;
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3723,7 +3723,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3734,7 +3734,7 @@
 
             if (!shaderObject)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             shaderObject->getSource(bufsize, length, source);
@@ -3742,7 +3742,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3755,7 +3755,7 @@
     {
         if (bufsize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3766,7 +3766,7 @@
 
             if (!shaderObject)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             shaderObject->getTranslatedSource(bufsize, length, source);
@@ -3774,7 +3774,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3799,12 +3799,12 @@
           case GL_EXTENSIONS:
             return (GLubyte*)((context != NULL) ? context->getExtensionString() : "");
           default:
-            return error(GL_INVALID_ENUM, (GLubyte*)NULL);
+            return gl::error(GL_INVALID_ENUM, (GLubyte*)NULL);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
     }
 }
 
@@ -3829,7 +3829,7 @@
                 texture = context->getTextureCubeMap();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (pname)
@@ -3855,18 +3855,18 @@
               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (!context->supportsTextureFilterAnisotropy())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 *params = (GLfloat)texture->getMaxAnisotropy();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3891,7 +3891,7 @@
                 texture = context->getTextureCubeMap();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (pname)
@@ -3917,18 +3917,18 @@
               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (!context->supportsTextureFilterAnisotropy())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 *params = (GLint)texture->getMaxAnisotropy();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3941,7 +3941,7 @@
     {
         if (bufSize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -3950,31 +3950,31 @@
         {
             if (program == 0)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             gl::Program *programObject = context->getProgram(program);
 
             if (!programObject || !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->getUniformfv(location, &bufSize, params))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -3990,31 +3990,31 @@
         {
             if (program == 0)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             gl::Program *programObject = context->getProgram(program);
 
             if (!programObject || !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->getUniformfv(location, NULL, params))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4027,7 +4027,7 @@
     {
         if (bufSize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4036,31 +4036,31 @@
         {
             if (program == 0)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             gl::Program *programObject = context->getProgram(program);
 
             if (!programObject || !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->getUniformiv(location, &bufSize, params))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4076,31 +4076,31 @@
         {
             if (program == 0)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             gl::Program *programObject = context->getProgram(program);
 
             if (!programObject || !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->getUniformiv(location, NULL, params))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4125,18 +4125,18 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION, -1);
+                    return gl::error(GL_INVALID_OPERATION, -1);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE, -1);
+                    return gl::error(GL_INVALID_VALUE, -1);
                 }
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
             if (!programObject->isLinked() || !programBinary)
             {
-                return error(GL_INVALID_OPERATION, -1);
+                return gl::error(GL_INVALID_OPERATION, -1);
             }
 
             return programBinary->getUniformLocation(name);
@@ -4144,7 +4144,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, -1);
+        return gl::error(GL_OUT_OF_MEMORY, -1);
     }
 
     return -1;
@@ -4162,7 +4162,7 @@
         {
             if (index >= gl::MAX_VERTEX_ATTRIBS)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
@@ -4196,13 +4196,13 @@
               case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE:
                 *params = (GLfloat)attribState.mDivisor;
                 break;
-              default: return error(GL_INVALID_ENUM);
+              default: return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4218,7 +4218,7 @@
         {
             if (index >= gl::MAX_VERTEX_ATTRIBS)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
@@ -4253,13 +4253,13 @@
               case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE:
                 *params = (GLint)attribState.mDivisor;
                 break;
-              default: return error(GL_INVALID_ENUM);
+              default: return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4275,12 +4275,12 @@
         {
             if (index >= gl::MAX_VERTEX_ATTRIBS)
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
             {
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             *pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));
@@ -4288,7 +4288,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4305,7 +4305,7 @@
           case GL_DONT_CARE:
             break;
           default:
-            return error(GL_INVALID_ENUM); 
+            return gl::error(GL_INVALID_ENUM); 
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4318,12 +4318,12 @@
             if (context) context->setFragmentShaderDerivativeHint(mode);
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4347,7 +4347,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4375,13 +4375,13 @@
               case GL_BLEND:                    return context->isBlendEnabled();
               case GL_DITHER:                   return context->isDitherEnabled();
               default:
-                return error(GL_INVALID_ENUM, false);
+                return gl::error(GL_INVALID_ENUM, false);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     return false;
@@ -4409,7 +4409,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4435,7 +4435,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4461,7 +4461,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4492,7 +4492,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4518,7 +4518,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4544,7 +4544,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4570,7 +4570,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
     }
 
     return GL_FALSE;
@@ -4584,7 +4584,7 @@
     {
         if (width <= 0.0f)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4596,7 +4596,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4616,11 +4616,11 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -4629,7 +4629,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4648,7 +4648,7 @@
               case GL_UNPACK_ALIGNMENT:
                 if (param != 1 && param != 2 && param != 4 && param != 8)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
 
                 context->setUnpackAlignment(param);
@@ -4657,7 +4657,7 @@
               case GL_PACK_ALIGNMENT:
                 if (param != 1 && param != 2 && param != 4 && param != 8)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
 
                 context->setPackAlignment(param);
@@ -4668,13 +4668,13 @@
                 break;
 
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4693,7 +4693,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4709,7 +4709,7 @@
     {
         if (width < 0 || height < 0 || bufSize < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4726,7 +4726,7 @@
 
             if (!(currentFormat == format && currentType == type) && !validReadFormatType(format, type))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             context->readPixels(x, y, width, height, format, type, &bufSize, data);
@@ -4734,7 +4734,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4749,7 +4749,7 @@
     {
         if (width < 0 || height < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4766,7 +4766,7 @@
 
             if (!(currentFormat == format && currentType == type) && !validReadFormatType(format, type))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             context->readPixels(x, y, width, height, format, type, NULL, pixels);
@@ -4774,7 +4774,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4788,7 +4788,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4804,17 +4804,17 @@
           case GL_RENDERBUFFER:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (!gl::IsColorRenderable(internalformat) && !gl::IsDepthRenderable(internalformat) && !gl::IsStencilRenderable(internalformat))
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (width < 0 || height < 0 || samples < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4825,13 +4825,13 @@
                 height > context->getMaximumRenderbufferDimension() ||
                 samples > context->getMaxSupportedSamples())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             GLuint handle = context->getRenderbufferHandle();
             if (handle == 0)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             switch (internalformat)
@@ -4847,13 +4847,13 @@
                 context->setRenderbufferStorage(width, height, internalformat, samples);
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4877,7 +4877,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4889,7 +4889,7 @@
     {
         if (condition != GL_ALL_COMPLETED_NV)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4900,7 +4900,7 @@
 
             if (fenceObject == NULL)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             fenceObject->setFence(condition);    
@@ -4908,7 +4908,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4920,7 +4920,7 @@
     {
         if (width < 0 || height < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context* context = gl::getNonLostContext();
@@ -4932,7 +4932,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4945,11 +4945,11 @@
     try
     {
         // No binary shader formats are supported.
-        return error(GL_INVALID_ENUM);
+        return gl::error(GL_INVALID_ENUM);
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -4962,7 +4962,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -4975,11 +4975,11 @@
             {
                 if (context->getProgram(shader))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -4988,7 +4988,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5010,7 +5010,7 @@
           case GL_FRONT_AND_BACK:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (func)
@@ -5025,7 +5025,7 @@
           case GL_NOTEQUAL:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -5045,7 +5045,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5067,7 +5067,7 @@
           case GL_FRONT_AND_BACK:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -5087,7 +5087,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5110,7 +5110,7 @@
           case GL_FRONT_AND_BACK:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (fail)
@@ -5125,7 +5125,7 @@
           case GL_DECR_WRAP:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (zfail)
@@ -5140,7 +5140,7 @@
           case GL_DECR_WRAP:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         switch (zpass)
@@ -5155,7 +5155,7 @@
           case GL_DECR_WRAP:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -5175,7 +5175,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5193,7 +5193,7 @@
 
             if (fenceObject == NULL)
             {
-                return error(GL_INVALID_OPERATION, GL_TRUE);
+                return gl::error(GL_INVALID_OPERATION, GL_TRUE);
             }
 
             return fenceObject->testFence();
@@ -5201,7 +5201,7 @@
     }
     catch(std::bad_alloc&)
     {
-        error(GL_OUT_OF_MEMORY);
+        gl::error(GL_OUT_OF_MEMORY);
     }
     
     return GL_TRUE;
@@ -5218,12 +5218,12 @@
     {
         if (!validImageSize(level, width, height))
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (internalformat != GLint(format))
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         // validate <type> by itself (used as secondary key below)
@@ -5240,7 +5240,7 @@
           case GL_FLOAT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         // validate <format> + <type> combinations
@@ -5258,7 +5258,7 @@
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           case GL_RGB:
@@ -5270,7 +5270,7 @@
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           case GL_RGBA:
@@ -5283,7 +5283,7 @@
               case GL_HALF_FLOAT_OES:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           case GL_BGRA_EXT:
@@ -5292,7 +5292,7 @@
               case GL_UNSIGNED_BYTE:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  // error cases for compressed textures are handled below
@@ -5307,7 +5307,7 @@
               case GL_UNSIGNED_INT:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           case GL_DEPTH_STENCIL_OES:
@@ -5316,16 +5316,16 @@
               case GL_UNSIGNED_INT_24_8_OES:
                 break;
               default:
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (border != 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -5334,7 +5334,7 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             switch (target)
@@ -5343,7 +5343,7 @@
                 if (width > (context->getMaximumTextureDimension() >> level) ||
                     height > (context->getMaximumTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
@@ -5354,17 +5354,17 @@
               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
                 if (width != height)
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
 
                 if (width > (context->getMaximumCubeTextureDimension() >> level) ||
                     height > (context->getMaximumCubeTextureDimension() >> level))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (format) {
@@ -5372,48 +5372,48 @@
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
                 if (context->supportsDXT1Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
                 if (context->supportsDXT3Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if (context->supportsDXT5Textures())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_DEPTH_COMPONENT:
               case GL_DEPTH_STENCIL_OES:
                 if (!context->supportsDepthTextures())
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 if (target != GL_TEXTURE_2D)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 // OES_depth_texture supports loading depth data and multiple levels,
                 // but ANGLE_depth_texture does not
                 if (pixels != NULL || level != 0)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               default:
@@ -5424,14 +5424,14 @@
             {
                 if (!context->supportsFloat32Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
             }
             else if (type == GL_HALF_FLOAT_OES)
             {
                 if (!context->supportsFloat16Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
             }
 
@@ -5441,12 +5441,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);
@@ -5457,12 +5457,12 @@
 
                 if (!texture)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 switch (target)
@@ -5492,7 +5492,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5517,7 +5517,7 @@
                 texture = context->getTextureCubeMap();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (pname)
@@ -5525,51 +5525,51 @@
               case GL_TEXTURE_WRAP_S:
                 if (!texture->setWrapS((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_WRAP_T:
                 if (!texture->setWrapT((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MIN_FILTER:
                 if (!texture->setMinFilter((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MAG_FILTER:
                 if (!texture->setMagFilter((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_USAGE_ANGLE:
                 if (!texture->setUsage((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (!context->supportsTextureFilterAnisotropy())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 if (!texture->setMaxAnisotropy((float)param, context->getTextureMaxAnisotropy()))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5599,7 +5599,7 @@
                 texture = context->getTextureCubeMap();
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             switch (pname)
@@ -5607,51 +5607,51 @@
               case GL_TEXTURE_WRAP_S:
                 if (!texture->setWrapS((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_WRAP_T:
                 if (!texture->setWrapT((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MIN_FILTER:
                 if (!texture->setMinFilter((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MAG_FILTER:
                 if (!texture->setMagFilter((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_USAGE_ANGLE:
                 if (!texture->setUsage((GLenum)param))
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (!context->supportsTextureFilterAnisotropy())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 if (!texture->setMaxAnisotropy((float)param, context->getTextureMaxAnisotropy()))
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5669,22 +5669,22 @@
     {
         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (width < 1 || height < 1 || levels < 1)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (target == GL_TEXTURE_CUBE_MAP && width != height)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
         {
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         GLenum format = gl::ExtractFormat(internalformat);
@@ -5692,7 +5692,7 @@
 
         if (format == GL_NONE || type == GL_NONE)
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -5705,25 +5705,25 @@
                 if (width > context->getMaximumTextureDimension() ||
                     height > context->getMaximumTextureDimension())
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               case GL_TEXTURE_CUBE_MAP:
                 if (width > context->getMaximumCubeTextureDimension() ||
                     height > context->getMaximumCubeTextureDimension())
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
                 break;
               default:
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             if (levels != 1 && !context->supportsNonPower2Texture())
             {
                 if (!gl::isPow2(width) || !gl::isPow2(height))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
             }
 
@@ -5733,19 +5733,19 @@
               case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
                 if (!context->supportsDXT1Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
                 if (!context->supportsDXT3Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if (!context->supportsDXT5Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_RGBA32F_EXT:
@@ -5755,7 +5755,7 @@
               case GL_LUMINANCE_ALPHA32F_EXT:
                 if (!context->supportsFloat32Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_RGBA16F_EXT:
@@ -5765,7 +5765,7 @@
               case GL_LUMINANCE_ALPHA16F_EXT:
                 if (!context->supportsFloat16Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 break;
               case GL_DEPTH_COMPONENT16:
@@ -5773,16 +5773,16 @@
               case GL_DEPTH24_STENCIL8_OES:
                 if (!context->supportsDepthTextures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 if (target != GL_TEXTURE_2D)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 // ANGLE_depth_texture only supports 1-level textures
                 if (levels != 1)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 break;
               default:
@@ -5795,12 +5795,12 @@
 
                 if (!texture || texture->id() == 0)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->storage(levels, internalformat, width, height);
@@ -5811,12 +5811,12 @@
 
                 if (!texture || texture->id() == 0)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 if (texture->isImmutable())
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
 
                 texture->storage(levels, internalformat, width);
@@ -5826,7 +5826,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5842,17 +5842,17 @@
     {
         if (!gl::IsInternalTextureTarget(target))
         {
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (!checkTextureFormatType(format, type))
@@ -5866,35 +5866,35 @@
         {
             if (level > context->getMaximumTextureLevel())
             {
-                return error(GL_INVALID_VALUE);
+                return gl::error(GL_INVALID_VALUE);
             }
 
             if (format == GL_FLOAT)
             {
                 if (!context->supportsFloat32Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
             }
             else if (format == GL_HALF_FLOAT_OES)
             {
                 if (!context->supportsFloat16Textures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
             }
             else if (gl::IsDepthTexture(format))
             {
                 if (!context->supportsDepthTextures())
                 {
-                    return error(GL_INVALID_ENUM);
+                    return gl::error(GL_INVALID_ENUM);
                 }
                 if (target != GL_TEXTURE_2D)
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 // OES_depth_texture supports loading depth data, but ANGLE_depth_texture does not
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (width == 0 || height == 0 || pixels == NULL)
@@ -5926,7 +5926,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5943,7 +5943,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -5958,18 +5958,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform1fv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -5986,7 +5986,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6001,18 +6001,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform1iv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6031,7 +6031,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
         
         if (location == -1)
@@ -6046,18 +6046,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform2fv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6076,7 +6076,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6091,18 +6091,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform2iv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6121,7 +6121,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6136,18 +6136,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform3fv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6166,7 +6166,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6181,18 +6181,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform3iv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6211,7 +6211,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6226,18 +6226,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform4fv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6256,7 +6256,7 @@
     {
         if (count < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6271,18 +6271,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniform4iv(location, count, v))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6295,7 +6295,7 @@
     {
         if (count < 0 || transpose != GL_FALSE)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6310,18 +6310,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniformMatrix2fv(location, count, value))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6334,7 +6334,7 @@
     {
         if (count < 0 || transpose != GL_FALSE)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6349,18 +6349,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniformMatrix3fv(location, count, value))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6373,7 +6373,7 @@
     {
         if (count < 0 || transpose != GL_FALSE)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (location == -1)
@@ -6388,18 +6388,18 @@
             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->setUniformMatrix4fv(location, count, value))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
         }
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6419,17 +6419,17 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
             if (program != 0 && !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             context->useProgram(program);
@@ -6437,7 +6437,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6457,11 +6457,11 @@
             {
                 if (context->getShader(program))
                 {
-                    return error(GL_INVALID_OPERATION);
+                    return gl::error(GL_INVALID_OPERATION);
                 }
                 else
                 {
-                    return error(GL_INVALID_VALUE);
+                    return gl::error(GL_INVALID_VALUE);
                 }
             }
 
@@ -6470,7 +6470,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6482,7 +6482,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6495,7 +6495,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6507,7 +6507,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6520,7 +6520,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6532,7 +6532,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6545,7 +6545,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6557,7 +6557,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6570,7 +6570,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6582,7 +6582,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6595,7 +6595,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6607,7 +6607,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6620,7 +6620,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6632,7 +6632,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6645,7 +6645,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6657,7 +6657,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6669,7 +6669,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6681,7 +6681,7 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6693,7 +6693,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6707,12 +6707,12 @@
     {
         if (index >= gl::MAX_VERTEX_ATTRIBS)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (size < 1 || size > 4)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         switch (type)
@@ -6725,12 +6725,12 @@
           case GL_FLOAT:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if (stride < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6742,7 +6742,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6754,7 +6754,7 @@
     {
         if (width < 0 || height < 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6766,7 +6766,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6785,18 +6785,18 @@
           case GL_NEAREST:
             break;
           default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
         }
 
         if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
         {
-            return error(GL_INVALID_VALUE);
+            return gl::error(GL_INVALID_VALUE);
         }
 
         if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
         {
             ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         gl::Context *context = gl::getNonLostContext();
@@ -6806,7 +6806,7 @@
             if (context->getReadFramebufferHandle() == context->getDrawFramebufferHandle())
             {
                 ERR("Blits with the same source and destination framebuffer are not supported by this implementation.");
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask);
@@ -6814,7 +6814,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6832,7 +6832,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6852,19 +6852,19 @@
 
             if (!programObject || !programObject->isLinked())
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
 
             if (!programBinary)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             if (!programBinary->save(binary, bufSize, length))
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
@@ -6872,7 +6872,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6890,14 +6890,14 @@
         {
             if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
             {
-                return error(GL_INVALID_ENUM);
+                return gl::error(GL_INVALID_ENUM);
             }
 
             gl::Program *programObject = context->getProgram(program);
 
             if (!programObject)
             {
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             context->setProgramBinary(program, binary, length);
@@ -6905,7 +6905,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -6987,7 +6987,7 @@
     }
     catch(std::bad_alloc&)
     {
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     return true;
diff --git a/src/libGLESv2/main.cpp b/src/libGLESv2/main.cpp
index 935a402..09d64ec 100644
--- a/src/libGLESv2/main.cpp
+++ b/src/libGLESv2/main.cpp
@@ -101,7 +101,7 @@
     {
         if (context->isContextLost())
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
             return NULL;
         }
         else
@@ -119,8 +119,6 @@
     return current->display;
 }
 
-}
-
 // Records an error code
 void error(GLenum errorCode)
 {
@@ -154,3 +152,6 @@
         }
     }
 }
+
+}
+
diff --git a/src/libGLESv2/main.h b/src/libGLESv2/main.h
index e3e40ba..99a956e 100644
--- a/src/libGLESv2/main.h
+++ b/src/libGLESv2/main.h
@@ -32,8 +32,6 @@
 Context *getNonLostContext();
 egl::Display *getDisplay();
 
-}
-
 void error(GLenum errorCode);
 
 template<class T>
@@ -44,6 +42,8 @@
     return returnValue;
 }
 
+}
+
 extern "C"
 {
 // Exported functions for use by EGL
diff --git a/src/libGLESv2/renderer/Blit.cpp b/src/libGLESv2/renderer/Blit.cpp
index ec23121..74c4480 100644
--- a/src/libGLESv2/renderer/Blit.cpp
+++ b/src/libGLESv2/renderer/Blit.cpp
@@ -85,7 +85,7 @@
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void *lockPtr = NULL;
@@ -94,7 +94,7 @@
     if (FAILED(result) || lockPtr == NULL)
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     memcpy(lockPtr, quad, sizeof(quad));
@@ -111,7 +111,7 @@
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 }
 
@@ -230,7 +230,7 @@
     if (!source)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());
@@ -266,7 +266,7 @@
     if (!source)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());
@@ -306,7 +306,7 @@
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
     }
     else
@@ -428,7 +428,7 @@
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     IDirect3DSurface9 *textureSurface;
@@ -438,7 +438,7 @@
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         texture->Release();
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     mRenderer->endScene();
@@ -450,7 +450,7 @@
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         texture->Release();
-        return error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
+        return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
     }
 
     return texture;
diff --git a/src/libGLESv2/renderer/Fence11.cpp b/src/libGLESv2/renderer/Fence11.cpp
index 2959a0a..2ed7975 100644
--- a/src/libGLESv2/renderer/Fence11.cpp
+++ b/src/libGLESv2/renderer/Fence11.cpp
@@ -44,7 +44,7 @@
 
         if (FAILED(mRenderer->getDevice()->CreateQuery(&queryDesc, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -58,14 +58,14 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION, GL_TRUE);
+        return gl::error(GL_INVALID_OPERATION, GL_TRUE);
     }
 
     HRESULT result = mRenderer->getDeviceContext()->GetData(mQuery, NULL, 0, 0);
 
     if (mRenderer->isDeviceLost())
     {
-       return error(GL_OUT_OF_MEMORY, GL_TRUE);
+       return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
@@ -77,7 +77,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     while (!testFence())
@@ -90,7 +90,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     switch (pname)
@@ -111,7 +111,7 @@
             if (mRenderer->isDeviceLost())
             {
                 params[0] = GL_TRUE;
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
 
             ASSERT(result == S_OK || result == S_FALSE);
@@ -124,7 +124,7 @@
         params[0] = getCondition();
         break;
       default:
-        return error(GL_INVALID_ENUM);
+        return gl::error(GL_INVALID_ENUM);
         break;
     }
 }
diff --git a/src/libGLESv2/renderer/Fence9.cpp b/src/libGLESv2/renderer/Fence9.cpp
index 50a42ca..74abfcf 100644
--- a/src/libGLESv2/renderer/Fence9.cpp
+++ b/src/libGLESv2/renderer/Fence9.cpp
@@ -42,7 +42,7 @@
         mQuery = mRenderer->allocateEventQuery();
         if (!mQuery)
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -57,7 +57,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION, GL_TRUE);
+        return gl::error(GL_INVALID_OPERATION, GL_TRUE);
     }
 
     HRESULT result = mQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
@@ -65,7 +65,7 @@
     if (d3d9::isDeviceLostError(result))
     {
         mRenderer->notifyDeviceLost();
-        return error(GL_OUT_OF_MEMORY, GL_TRUE);
+        return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
@@ -77,7 +77,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     while (!testFence())
@@ -90,7 +90,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     switch (pname)
@@ -112,7 +112,7 @@
             {
                 params[0] = GL_TRUE;
                 mRenderer->notifyDeviceLost();
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
 
             ASSERT(result == S_OK || result == S_FALSE);
@@ -125,7 +125,7 @@
             params[0] = getCondition();
             break;
         default:
-            return error(GL_INVALID_ENUM);
+            return gl::error(GL_INVALID_ENUM);
             break;
     }
 }
diff --git a/src/libGLESv2/renderer/Image11.cpp b/src/libGLESv2/renderer/Image11.cpp
index 26b1413..41dc670 100644
--- a/src/libGLESv2/renderer/Image11.cpp
+++ b/src/libGLESv2/renderer/Image11.cpp
@@ -389,7 +389,7 @@
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
diff --git a/src/libGLESv2/renderer/Image9.cpp b/src/libGLESv2/renderer/Image9.cpp
index 453b8fc..060fa20 100644
--- a/src/libGLESv2/renderer/Image9.cpp
+++ b/src/libGLESv2/renderer/Image9.cpp
@@ -106,7 +106,7 @@
 {
     IDirect3DSurface9 *sourceSurface = source->getSurface();
     if (sourceSurface == NULL)
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
 
     IDirect3DSurface9 *destSurface = dest->getSurface();
     generateMip(destSurface, sourceSurface);
@@ -199,7 +199,7 @@
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             ERR("Creating image surface failed.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         newTexture->GetSurfaceLevel(levelToFetch, &newSurface);
@@ -500,7 +500,7 @@
     if (!surface)
     {
         ERR("Failed to retrieve the render target.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
@@ -515,7 +515,7 @@
     {
         ERR("Could not create matching destination surface.");
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     result = device->GetRenderTargetData(surface, renderTargetData);
@@ -525,7 +525,7 @@
         ERR("GetRenderTargetData unexpectedly failed.");
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     RECT sourceRect = {x, y, x + width, y + height};
@@ -539,7 +539,7 @@
         ERR("Failed to lock the source surface (rectangle might be invalid).");
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     D3DLOCKED_RECT destLock = {0};
@@ -551,7 +551,7 @@
         renderTargetData->UnlockRect();
         renderTargetData->Release();
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (destLock.pBits && sourceLock.pBits)
diff --git a/src/libGLESv2/renderer/Query11.cpp b/src/libGLESv2/renderer/Query11.cpp
index 7db198c..629b27d 100644
--- a/src/libGLESv2/renderer/Query11.cpp
+++ b/src/libGLESv2/renderer/Query11.cpp
@@ -37,7 +37,7 @@
 
         if (FAILED(mRenderer->getDevice()->CreateQuery(&queryDesc, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -48,7 +48,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     mRenderer->getDeviceContext()->End(mQuery);
@@ -68,7 +68,7 @@
             // if the device is lost
             if (mRenderer->testDeviceLost(true))
             {
-                return error(GL_OUT_OF_MEMORY, 0);
+                return gl::error(GL_OUT_OF_MEMORY, 0);
             }
         }
     }
@@ -108,7 +108,7 @@
         }
         else if (mRenderer->testDeviceLost(true))
         {
-            return error(GL_OUT_OF_MEMORY, GL_TRUE);
+            return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
         }
 
         return getStatus();
diff --git a/src/libGLESv2/renderer/Query9.cpp b/src/libGLESv2/renderer/Query9.cpp
index 2904e0e..0d1b9a9 100644
--- a/src/libGLESv2/renderer/Query9.cpp
+++ b/src/libGLESv2/renderer/Query9.cpp
@@ -35,7 +35,7 @@
     {
         if (FAILED(mRenderer->getDevice()->CreateQuery(D3DQUERYTYPE_OCCLUSION, &mQuery)))
         {
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -47,7 +47,7 @@
 {
     if (mQuery == NULL)
     {
-        return error(GL_INVALID_OPERATION);
+        return gl::error(GL_INVALID_OPERATION);
     }
 
     HRESULT result = mQuery->Issue(D3DISSUE_END);
@@ -69,7 +69,7 @@
             // instead of D3DERR_DEVICELOST like they should
             if (mRenderer->testDeviceLost(true))
             {
-                return error(GL_OUT_OF_MEMORY, 0);
+                return gl::error(GL_OUT_OF_MEMORY, 0);
             }
         }
     }
@@ -111,7 +111,7 @@
         else if (d3d9::isDeviceLostError(hres))
         {
             mRenderer->notifyDeviceLost();
-            return error(GL_OUT_OF_MEMORY, GL_TRUE);
+            return gl::error(GL_OUT_OF_MEMORY, GL_TRUE);
         }
 
         return getStatus();
diff --git a/src/libGLESv2/renderer/RenderTarget11.cpp b/src/libGLESv2/renderer/RenderTarget11.cpp
index 5f16b79..37d777b 100644
--- a/src/libGLESv2/renderer/RenderTarget11.cpp
+++ b/src/libGLESv2/renderer/RenderTarget11.cpp
@@ -233,7 +233,7 @@
 
     if (supportedSamples == -1)
     {
-        error(GL_OUT_OF_MEMORY);
+        gl::error(GL_OUT_OF_MEMORY);
 
         return;
     }
@@ -262,7 +262,7 @@
 
         if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
             return;
         }
         ASSERT(SUCCEEDED(result));
@@ -279,7 +279,7 @@
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
                 rtTexture->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));
@@ -295,7 +295,7 @@
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
                 rtTexture->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));
@@ -311,7 +311,7 @@
             {
                 rtTexture->Release();
                 mRenderTarget->Release();
-                error(GL_OUT_OF_MEMORY);
+                gl::error(GL_OUT_OF_MEMORY);
                 return;
             }
             ASSERT(SUCCEEDED(result));
diff --git a/src/libGLESv2/renderer/RenderTarget9.cpp b/src/libGLESv2/renderer/RenderTarget9.cpp
index ff83c45..9d5aae4 100644
--- a/src/libGLESv2/renderer/RenderTarget9.cpp
+++ b/src/libGLESv2/renderer/RenderTarget9.cpp
@@ -45,7 +45,7 @@
 
     if (supportedSamples == -1)
     {
-        error(GL_OUT_OF_MEMORY);
+        gl::error(GL_OUT_OF_MEMORY);
 
         return;
     }
@@ -69,7 +69,7 @@
 
         if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
         {
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
 
             return;
         }
diff --git a/src/libGLESv2/renderer/Renderer.cpp b/src/libGLESv2/renderer/Renderer.cpp
index 029b2ea..92efd3e 100644
--- a/src/libGLESv2/renderer/Renderer.cpp
+++ b/src/libGLESv2/renderer/Renderer.cpp
@@ -143,7 +143,7 @@
         {
             if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
             {
-                return error(GL_OUT_OF_MEMORY, (ID3DBlob*) NULL);
+                return gl::error(GL_OUT_OF_MEMORY, (ID3DBlob*) NULL);
             }
 
             infoLog.append("Warning: D3D shader compilation failed with ");
diff --git a/src/libGLESv2/renderer/Renderer11.cpp b/src/libGLESv2/renderer/Renderer11.cpp
index 09889f4..f47f11a 100644
--- a/src/libGLESv2/renderer/Renderer11.cpp
+++ b/src/libGLESv2/renderer/Renderer11.cpp
@@ -535,7 +535,7 @@
         {
             ERR("Separate front/back stencil writemasks, reference values, or stencil mask values are "
                 "invalid under WebGL.");
-            return error(GL_INVALID_OPERATION);
+            return gl::error(GL_INVALID_OPERATION);
         }
 
         ID3D11DepthStencilState *dxDepthStencilState = mStateCache.getDepthStencilState(depthStencilState);
@@ -663,7 +663,7 @@
           // emulate fans via rewriting index buffer
       case GL_TRIANGLE_FAN:   primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;	break;
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 
     mDeviceContext->IASetPrimitiveTopology(primitiveTopology);
@@ -914,7 +914,7 @@
             mLineLoopIB = NULL;
 
             ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -922,7 +922,7 @@
     if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
     {
         ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void* mappedMemory = NULL;
@@ -930,7 +930,7 @@
     if (offset == -1 || mappedMemory == NULL)
     {
         ERR("Could not map index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
@@ -972,7 +972,7 @@
     if (!mLineLoopIB->unmapBuffer())
     {
         ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (mAppliedIBSerial != mLineLoopIB->getSerial() || mAppliedIBOffset != indexBufferOffset)
@@ -1006,7 +1006,7 @@
             mTriangleFanIB = NULL;
 
             ERR("Could not create a scratch index buffer for GL_TRIANGLE_FAN.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -1015,7 +1015,7 @@
     if (!mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
     {
         ERR("Could not reserve enough space in scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     void* mappedMemory = NULL;
@@ -1023,7 +1023,7 @@
     if (offset == -1 || mappedMemory == NULL)
     {
         ERR("Could not map scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
@@ -1069,7 +1069,7 @@
     if (!mTriangleFanIB->unmapBuffer())
     {
         ERR("Could not unmap scratch index buffer for GL_TRIANGLE_FAN.");
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     if (mAppliedIBSerial != mTriangleFanIB->getSerial() || mAppliedIBOffset != indexBufferOffset)
@@ -1781,6 +1781,8 @@
     if (isLost)
     {
         // ensure we note the device loss --
+        // we'll probably get this done again by notifyDeviceLost
+        // but best to remember it!
         // Note that we don't want to clear the device loss status here
         // -- this needs to be done by resetDevice
         mDeviceLost = true;
@@ -2160,21 +2162,21 @@
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
     if (!sourceRenderTarget)
     {
         ERR("Failed to retrieve the render target from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
     if (!source)
     {
         ERR("Failed to retrieve the render target view from the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
@@ -2182,7 +2184,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the texture storage from the destination.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(level));
@@ -2190,7 +2192,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the render target from the destination storage.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
@@ -2198,7 +2200,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the render target view from the destination render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     gl::Rectangle destRect;
@@ -2223,21 +2225,21 @@
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *sourceRenderTarget = RenderTarget11::makeRenderTarget11(colorbuffer->getRenderTarget());
     if (!sourceRenderTarget)
     {
         ERR("Failed to retrieve the render target from the frame buffer.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11ShaderResourceView *source = sourceRenderTarget->getShaderResourceView();
     if (!source)
     {
         ERR("Failed to retrieve the render target view from the render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
@@ -2245,7 +2247,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the texture storage from the destination.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(target, level));
@@ -2253,7 +2255,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the render target from the destination storage.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     ID3D11RenderTargetView *dest = destRenderTarget->getRenderTargetView();
@@ -2261,7 +2263,7 @@
     {
         source->Release();
         ERR("Failed to retrieve the render target view from the destination render target.");
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     gl::Rectangle destRect;
@@ -2358,7 +2360,7 @@
         destArea.x < 0 || destArea.x + destArea.width > static_cast<int>(destWidth) ||
         destArea.y < 0 || destArea.y + destArea.height > static_cast<int>(destHeight))
     {
-        return error(GL_INVALID_VALUE, false);
+        return gl::error(GL_INVALID_VALUE, false);
     }
 
     // Set vertices
@@ -2367,7 +2369,7 @@
     if (FAILED(result))
     {
         ERR("Failed to map vertex buffer for texture copy, HRESULT: 0x%X.", result);
-        return error(GL_OUT_OF_MEMORY, false);
+        return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
     d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);
diff --git a/src/libGLESv2/renderer/Renderer9.cpp b/src/libGLESv2/renderer/Renderer9.cpp
index 930a15d..ea4cdba 100644
--- a/src/libGLESv2/renderer/Renderer9.cpp
+++ b/src/libGLESv2/renderer/Renderer9.cpp
@@ -955,7 +955,7 @@
                 depthStencilState.stencilMask != depthStencilState.stencilBackMask)
             {
                 ERR("Separate front/back stencil writemasks, reference values, or stencil mask values are invalid under WebGL.");
-                return error(GL_INVALID_OPERATION);
+                return gl::error(GL_INVALID_OPERATION);
             }
 
             // get the maximum size of the stencil ref
@@ -1149,7 +1149,7 @@
         mPrimitiveCount = count - 2;
         break;
       default:
-        return error(GL_INVALID_ENUM, false);
+        return gl::error(GL_INVALID_ENUM, false);
     }
 
     return mPrimitiveCount > 0;
@@ -1397,7 +1397,7 @@
         else
         {
             ERR("Could not create a counting index buffer for glDrawArraysInstanced.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
     else   // Regular case
@@ -1447,7 +1447,7 @@
                 mLineLoopIB = NULL;
 
                 ERR("Could not create a 32-bit looping index buffer for GL_LINE_LOOP.");
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
 
@@ -1455,7 +1455,7 @@
         if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT))
         {
             ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         void* mappedMemory = NULL;
@@ -1463,7 +1463,7 @@
         if (offset == -1 || mappedMemory == NULL)
         {
             ERR("Could not map index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         startIndex = static_cast<UINT>(offset) / 4;
@@ -1505,7 +1505,7 @@
         if (!mLineLoopIB->unmapBuffer())
         {
             ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
     else
@@ -1519,7 +1519,7 @@
                 mLineLoopIB = NULL;
 
                 ERR("Could not create a 16-bit looping index buffer for GL_LINE_LOOP.");
-                return error(GL_OUT_OF_MEMORY);
+                return gl::error(GL_OUT_OF_MEMORY);
             }
         }
 
@@ -1527,7 +1527,7 @@
         if (!mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT))
         {
             ERR("Could not reserve enough space in looping index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         void* mappedMemory = NULL;
@@ -1535,7 +1535,7 @@
         if (offset == -1 || mappedMemory == NULL)
         {
             ERR("Could not map index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
 
         startIndex = static_cast<UINT>(offset) / 2;
@@ -1577,7 +1577,7 @@
         if (!mLineLoopIB->unmapBuffer())
         {
             ERR("Could not unmap index buffer for GL_LINE_LOOP.");
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -2048,6 +2048,8 @@
     if (isLost)
     {
         // ensure we note the device loss --
+        // we'll probably get this done again by notifyDeviceLost
+        // but best to remember it!
         // Note that we don't want to clear the device loss status here
         // -- this needs to be done by resetDevice
         mDeviceLost = true;
@@ -2547,7 +2549,7 @@
         if (!readSurface || !drawSurface)
         {
             ERR("Failed to retrieve the render target.");
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
 
         RECT srcRect, dstRect;
@@ -2614,7 +2616,7 @@
         if (!readSurface || !drawSurface)
         {
             ERR("Failed to retrieve the render target.");
-            return error(GL_OUT_OF_MEMORY, false);
+            return gl::error(GL_OUT_OF_MEMORY, false);
         }
 
         HRESULT result = mDevice->StretchRect(readSurface, NULL, drawSurface, NULL, D3DTEXF_NONE);
@@ -2662,7 +2664,7 @@
     {
         UNIMPLEMENTED();   // FIXME: Requires resolve using StretchRect into non-multisampled render target
         surface->Release();
-        return error(GL_OUT_OF_MEMORY);
+        return gl::error(GL_OUT_OF_MEMORY);
     }
 
     HRESULT result;
@@ -2690,7 +2692,7 @@
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             surface->Release();
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -2707,7 +2709,7 @@
         if (d3d9::isDeviceLostError(result))
         {
             notifyDeviceLost();
-            return error(GL_OUT_OF_MEMORY);
+            return gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {
diff --git a/src/libGLESv2/renderer/TextureStorage11.cpp b/src/libGLESv2/renderer/TextureStorage11.cpp
index bebd588..b75d94e 100644
--- a/src/libGLESv2/renderer/TextureStorage11.cpp
+++ b/src/libGLESv2/renderer/TextureStorage11.cpp
@@ -239,7 +239,7 @@
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {
@@ -298,7 +298,7 @@
 
             if (result == E_OUTOFMEMORY)
             {
-                return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
             }
             ASSERT(SUCCEEDED(result));
 
@@ -314,7 +314,7 @@
             if (result == E_OUTOFMEMORY)
             {
                 rtv->Release();
-                return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
             }
             ASSERT(SUCCEEDED(result));
 
@@ -352,7 +352,7 @@
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
+            return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
         ASSERT(SUCCEEDED(result));
     }
@@ -414,7 +414,7 @@
         {
             ASSERT(result == E_OUTOFMEMORY);
             ERR("Creating image failed.");
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
         else
         {
@@ -481,7 +481,7 @@
 
                 if (result == E_OUTOFMEMORY)
                 {
-                    return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                    return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
                 }
                 ASSERT(SUCCEEDED(result));
 
@@ -499,7 +499,7 @@
                 if (result == E_OUTOFMEMORY)
                 {
                     rtv->Release();
-                    return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+                    return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
                 }
                 ASSERT(SUCCEEDED(result));
 
@@ -544,7 +544,7 @@
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
+            return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
         ASSERT(SUCCEEDED(result));
     }
diff --git a/src/libGLESv2/renderer/TextureStorage9.cpp b/src/libGLESv2/renderer/TextureStorage9.cpp
index 6b9bd07..14a5e74 100644
--- a/src/libGLESv2/renderer/TextureStorage9.cpp
+++ b/src/libGLESv2/renderer/TextureStorage9.cpp
@@ -134,7 +134,7 @@
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
     }
 
@@ -236,7 +236,7 @@
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            error(GL_OUT_OF_MEMORY);
+            gl::error(GL_OUT_OF_MEMORY);
         }
     }