opengl: Regenerate GPU emulation encoder sources.

This patch updates the encoder sources to match the auto-generated
output of the latest 'emugen' tools from sdk/emulator/opengl/

Generated by using external/qemu/distrib/update-emugl-source.sh

This shall only results in minor changes:

  - Minor indentation fixes.
  - Using 'const' to define constant tables.
  - Using anonymous namespaces in the encoders.

Change-Id: Ib282b31c4c05da897157ef90e5a9deb914a08bda

4 files changed, 591 insertions, 593 deletions

diff --git a/opengl/system/GLESv1_enc/gl_enc.cpp b/opengl/system/GLESv1_enc/gl_enc.cpp
index 19ee3ed..16d8cac 100644
--- a/opengl/system/GLESv1_enc/gl_enc.cpp
+++ b/opengl/system/GLESv1_enc/gl_enc.cpp
@@ -7,10 +7,12 @@
 
 #include "gl_enc.h"
 
-namespace glesv1_enc {
 
 #include <stdio.h>
-static void enc_unsupported()
+
+namespace {
+
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -4886,9 +4888,7 @@ void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask)
 		memcpy(ptr, &preserveMask, 4); ptr += 4;
 }
 
-}  // namespace glesv1_enc
-
-using namespace glesv1_enc;
+}  // namespace
 
 gl_encoder_context_t::gl_encoder_context_t(IOStream *stream)
 {
diff --git a/opengl/system/GLESv1_enc/gl_enc.h b/opengl/system/GLESv1_enc/gl_enc.h
index 3090cb1..03ebb42 100644
--- a/opengl/system/GLESv1_enc/gl_enc.h
+++ b/opengl/system/GLESv1_enc/gl_enc.h
@@ -16,8 +16,6 @@ struct gl_encoder_context_t : public gl_client_context_t {
 	IOStream *m_stream;
 
 	gl_encoder_context_t(IOStream *stream);
-
-
 };
 
-#endif
\ No newline at end of file
+#endif  // GUARD_gl_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/GLESv1_enc/gl_entry.cpp b/opengl/system/GLESv1_enc/gl_entry.cpp
index b43df09..6408e52 100644
--- a/opengl/system/GLESv1_enc/gl_entry.cpp
+++ b/opengl/system/GLESv1_enc/gl_entry.cpp
@@ -303,1764 +303,1764 @@ extern "C" {
 #ifndef GET_CONTEXT
 static gl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 void gl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
-#define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext() 
+#define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext()
 #endif
 
 void glAlphaFunc(GLenum func, GLclampf ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFunc(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFunc(ctx, func, ref);
 }
 
 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColor(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColor(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthf(GLclampf depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthf(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthf(ctx, depth);
 }
 
 void glClipPlanef(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanef(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanef(ctx, plane, equation);
 }
 
 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4f(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4f(ctx, red, green, blue, alpha);
 }
 
 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangef(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangef(ctx, zNear, zFar);
 }
 
 void glFogf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogf(ctx, pname, param);
 }
 
 void glFogfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogfv(ctx, pname, params);
 }
 
 void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetClipPlanef(GLenum pname, GLfloat* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanef(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanef(ctx, pname, eqn);
 }
 
 void glGetFloatv(GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFloatv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFloatv(ctx, pname, params);
 }
 
 void glGetLightfv(GLenum light, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightfv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightfv(ctx, light, pname, params);
 }
 
 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialfv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialfv(ctx, face, pname, params);
 }
 
 void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvfv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvfv(ctx, env, pname, params);
 }
 
 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterfv(ctx, target, pname, params);
 }
 
 void glLightModelf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelf(ctx, pname, param);
 }
 
 void glLightModelfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelfv(ctx, pname, params);
 }
 
 void glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightf(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightf(ctx, light, pname, param);
 }
 
 void glLightfv(GLenum light, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightfv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightfv(ctx, light, pname, params);
 }
 
 void glLineWidth(GLfloat width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidth(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidth(ctx, width);
 }
 
 void glLoadMatrixf(const GLfloat* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixf(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixf(ctx, m);
 }
 
 void glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialf(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialf(ctx, face, pname, param);
 }
 
 void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialfv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialfv(ctx, face, pname, params);
 }
 
 void glMultMatrixf(const GLfloat* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixf(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixf(ctx, m);
 }
 
 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4f(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4f(ctx, target, s, t, r, q);
 }
 
 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3f(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3f(ctx, nx, ny, nz);
 }
 
 void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPointParameterf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterf(ctx, pname, param);
 }
 
 void glPointParameterfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterfv(ctx, pname, params);
 }
 
 void glPointSize(GLfloat size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSize(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSize(ctx, size);
 }
 
 void glPolygonOffset(GLfloat factor, GLfloat units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffset(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffset(ctx, factor, units);
 }
 
 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatef(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatef(ctx, angle, x, y, z);
 }
 
 void glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalef(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalef(ctx, x, y, z);
 }
 
 void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvf(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvf(ctx, target, pname, param);
 }
 
 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvfv(ctx, target, pname, params);
 }
 
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterf(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterf(ctx, target, pname, param);
 }
 
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterfv(ctx, target, pname, params);
 }
 
 void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatef(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatef(ctx, x, y, z);
 }
 
 void glActiveTexture(GLenum texture)
 {
-	GET_CONTEXT; 
-	 ctx->glActiveTexture(ctx, texture);
+	GET_CONTEXT;
+	ctx->glActiveTexture(ctx, texture);
 }
 
 void glAlphaFuncx(GLenum func, GLclampx ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFuncx(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFuncx(ctx, func, ref);
 }
 
 void glBindBuffer(GLenum target, GLuint buffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindBuffer(ctx, target, buffer);
+	GET_CONTEXT;
+	ctx->glBindBuffer(ctx, target, buffer);
 }
 
 void glBindTexture(GLenum target, GLuint texture)
 {
-	GET_CONTEXT; 
-	 ctx->glBindTexture(ctx, target, texture);
+	GET_CONTEXT;
+	ctx->glBindTexture(ctx, target, texture);
 }
 
 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendFunc(ctx, sfactor, dfactor);
+	GET_CONTEXT;
+	ctx->glBlendFunc(ctx, sfactor, dfactor);
 }
 
 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 {
-	GET_CONTEXT; 
-	 ctx->glBufferData(ctx, target, size, data, usage);
+	GET_CONTEXT;
+	ctx->glBufferData(ctx, target, size, data, usage);
 }
 
 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glBufferSubData(ctx, target, offset, size, data);
+	GET_CONTEXT;
+	ctx->glBufferSubData(ctx, target, offset, size, data);
 }
 
 void glClear(GLbitfield mask)
 {
-	GET_CONTEXT; 
-	 ctx->glClear(ctx, mask);
+	GET_CONTEXT;
+	ctx->glClear(ctx, mask);
 }
 
 void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColorx(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColorx(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthx(GLclampx depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthx(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthx(ctx, depth);
 }
 
 void glClearStencil(GLint s)
 {
-	GET_CONTEXT; 
-	 ctx->glClearStencil(ctx, s);
+	GET_CONTEXT;
+	ctx->glClearStencil(ctx, s);
 }
 
 void glClientActiveTexture(GLenum texture)
 {
-	GET_CONTEXT; 
-	 ctx->glClientActiveTexture(ctx, texture);
+	GET_CONTEXT;
+	ctx->glClientActiveTexture(ctx, texture);
 }
 
 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4ub(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4ub(ctx, red, green, blue, alpha);
 }
 
 void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4x(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4x(ctx, red, green, blue, alpha);
 }
 
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColorMask(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColorMask(ctx, red, green, blue, alpha);
 }
 
 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glColorPointer(ctx, size, type, stride, pointer);
 }
 
 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
+	GET_CONTEXT;
+	ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
 }
 
 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
+	GET_CONTEXT;
+	ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-	GET_CONTEXT; 
-	 ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
+	GET_CONTEXT;
+	ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
 }
 
 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 }
 
 void glCullFace(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glCullFace(ctx, mode);
+	GET_CONTEXT;
+	ctx->glCullFace(ctx, mode);
 }
 
 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteBuffers(ctx, n, buffers);
+	ctx->glDeleteBuffers(ctx, n, buffers);
 }
 
 void glDeleteTextures(GLsizei n, const GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteTextures(ctx, n, textures);
+	ctx->glDeleteTextures(ctx, n, textures);
 }
 
 void glDepthFunc(GLenum func)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthFunc(ctx, func);
+	GET_CONTEXT;
+	ctx->glDepthFunc(ctx, func);
 }
 
 void glDepthMask(GLboolean flag)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthMask(ctx, flag);
+	GET_CONTEXT;
+	ctx->glDepthMask(ctx, flag);
 }
 
 void glDepthRangex(GLclampx zNear, GLclampx zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangex(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangex(ctx, zNear, zFar);
 }
 
 void glDisable(GLenum cap)
 {
-	GET_CONTEXT; 
-	 ctx->glDisable(ctx, cap);
+	GET_CONTEXT;
+	ctx->glDisable(ctx, cap);
 }
 
 void glDisableClientState(GLenum array)
 {
-	GET_CONTEXT; 
-	 ctx->glDisableClientState(ctx, array);
+	GET_CONTEXT;
+	ctx->glDisableClientState(ctx, array);
 }
 
 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawArrays(ctx, mode, first, count);
+	GET_CONTEXT;
+	ctx->glDrawArrays(ctx, mode, first, count);
 }
 
 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElements(ctx, mode, count, type, indices);
+	GET_CONTEXT;
+	ctx->glDrawElements(ctx, mode, count, type, indices);
 }
 
 void glEnable(GLenum cap)
 {
-	GET_CONTEXT; 
-	 ctx->glEnable(ctx, cap);
+	GET_CONTEXT;
+	ctx->glEnable(ctx, cap);
 }
 
 void glEnableClientState(GLenum array)
 {
-	GET_CONTEXT; 
-	 ctx->glEnableClientState(ctx, array);
+	GET_CONTEXT;
+	ctx->glEnableClientState(ctx, array);
 }
 
 void glFinish()
 {
-	GET_CONTEXT; 
-	 ctx->glFinish(ctx);
+	GET_CONTEXT;
+	ctx->glFinish(ctx);
 }
 
 void glFlush()
 {
-	GET_CONTEXT; 
-	 ctx->glFlush(ctx);
+	GET_CONTEXT;
+	ctx->glFlush(ctx);
 }
 
 void glFogx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogx(ctx, pname, param);
 }
 
 void glFogxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogxv(ctx, pname, params);
 }
 
 void glFrontFace(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glFrontFace(ctx, mode);
+	GET_CONTEXT;
+	ctx->glFrontFace(ctx, mode);
 }
 
 void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetBooleanv(GLenum pname, GLboolean* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBooleanv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBooleanv(ctx, pname, params);
 }
 
 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBufferParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBufferParameteriv(ctx, target, pname, params);
 }
 
 void glClipPlanex(GLenum pname, const GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanex(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glClipPlanex(ctx, pname, eqn);
 }
 
 void glGenBuffers(GLsizei n, GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenBuffers(ctx, n, buffers);
+	ctx->glGenBuffers(ctx, n, buffers);
 }
 
 void glGenTextures(GLsizei n, GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenTextures(ctx, n, textures);
+	ctx->glGenTextures(ctx, n, textures);
 }
 
 GLenum glGetError()
 {
-	GET_CONTEXT; 
-	 return ctx->glGetError(ctx);
+	GET_CONTEXT;
+	return ctx->glGetError(ctx);
 }
 
 void glGetFixedv(GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFixedv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFixedv(ctx, pname, params);
 }
 
 void glGetIntegerv(GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetIntegerv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetIntegerv(ctx, pname, params);
 }
 
 void glGetLightxv(GLenum light, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightxv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightxv(ctx, light, pname, params);
 }
 
 void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialxv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialxv(ctx, face, pname, params);
 }
 
 void glGetPointerv(GLenum pname, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetPointerv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetPointerv(ctx, pname, params);
 }
 
 const GLubyte* glGetString(GLenum name)
 {
-	GET_CONTEXT; 
-	 return ctx->glGetString(ctx, name);
+	GET_CONTEXT;
+	return ctx->glGetString(ctx, name);
 }
 
 void glGetTexEnviv(GLenum env, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnviv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnviv(ctx, env, pname, params);
 }
 
 void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvxv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvxv(ctx, env, pname, params);
 }
 
 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameteriv(ctx, target, pname, params);
 }
 
 void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterxv(ctx, target, pname, params);
 }
 
 void glHint(GLenum target, GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glHint(ctx, target, mode);
+	GET_CONTEXT;
+	ctx->glHint(ctx, target, mode);
 }
 
 GLboolean glIsBuffer(GLuint buffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsBuffer(ctx, buffer);
+	GET_CONTEXT;
+	return ctx->glIsBuffer(ctx, buffer);
 }
 
 GLboolean glIsEnabled(GLenum cap)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsEnabled(ctx, cap);
+	GET_CONTEXT;
+	return ctx->glIsEnabled(ctx, cap);
 }
 
 GLboolean glIsTexture(GLuint texture)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsTexture(ctx, texture);
+	GET_CONTEXT;
+	return ctx->glIsTexture(ctx, texture);
 }
 
 void glLightModelx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelx(ctx, pname, param);
 }
 
 void glLightModelxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelxv(ctx, pname, params);
 }
 
 void glLightx(GLenum light, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightx(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightx(ctx, light, pname, param);
 }
 
 void glLightxv(GLenum light, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightxv(ctx, light, pname, params);
 }
 
 void glLineWidthx(GLfixed width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidthx(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidthx(ctx, width);
 }
 
 void glLoadIdentity()
 {
-	GET_CONTEXT; 
-	 ctx->glLoadIdentity(ctx);
+	GET_CONTEXT;
+	ctx->glLoadIdentity(ctx);
 }
 
 void glLoadMatrixx(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixx(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixx(ctx, m);
 }
 
 void glLogicOp(GLenum opcode)
 {
-	GET_CONTEXT; 
-	 ctx->glLogicOp(ctx, opcode);
+	GET_CONTEXT;
+	ctx->glLogicOp(ctx, opcode);
 }
 
 void glMaterialx(GLenum face, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialx(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialx(ctx, face, pname, param);
 }
 
 void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialxv(ctx, face, pname, params);
 }
 
 void glMatrixMode(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixMode(ctx, mode);
+	GET_CONTEXT;
+	ctx->glMatrixMode(ctx, mode);
 }
 
 void glMultMatrixx(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixx(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixx(ctx, m);
 }
 
 void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4x(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4x(ctx, target, s, t, r, q);
 }
 
 void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3x(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3x(ctx, nx, ny, nz);
 }
 
 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointer(ctx, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glNormalPointer(ctx, type, stride, pointer);
 }
 
 void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPixelStorei(GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glPixelStorei(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPixelStorei(ctx, pname, param);
 }
 
 void glPointParameterx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterx(ctx, pname, param);
 }
 
 void glPointParameterxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterxv(ctx, pname, params);
 }
 
 void glPointSizex(GLfixed size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizex(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSizex(ctx, size);
 }
 
 void glPolygonOffsetx(GLfixed factor, GLfixed units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffsetx(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffsetx(ctx, factor, units);
 }
 
 void glPopMatrix()
 {
-	GET_CONTEXT; 
-	 ctx->glPopMatrix(ctx);
+	GET_CONTEXT;
+	ctx->glPopMatrix(ctx);
 }
 
 void glPushMatrix()
 {
-	GET_CONTEXT; 
-	 ctx->glPushMatrix(ctx);
+	GET_CONTEXT;
+	ctx->glPushMatrix(ctx);
 }
 
 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
 }
 
 void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatex(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatex(ctx, angle, x, y, z);
 }
 
 void glSampleCoverage(GLclampf value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoverage(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoverage(ctx, value, invert);
 }
 
 void glSampleCoveragex(GLclampx value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoveragex(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoveragex(ctx, value, invert);
 }
 
 void glScalex(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalex(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalex(ctx, x, y, z);
 }
 
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glScissor(ctx, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glScissor(ctx, x, y, width, height);
 }
 
 void glShadeModel(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glShadeModel(ctx, mode);
+	GET_CONTEXT;
+	ctx->glShadeModel(ctx, mode);
 }
 
 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilFunc(ctx, func, ref, mask);
+	GET_CONTEXT;
+	ctx->glStencilFunc(ctx, func, ref, mask);
 }
 
 void glStencilMask(GLuint mask)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilMask(ctx, mask);
+	GET_CONTEXT;
+	ctx->glStencilMask(ctx, mask);
 }
 
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilOp(ctx, fail, zfail, zpass);
+	GET_CONTEXT;
+	ctx->glStencilOp(ctx, fail, zfail, zpass);
 }
 
 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glTexCoordPointer(ctx, size, type, stride, pointer);
 }
 
 void glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvi(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvi(ctx, target, pname, param);
 }
 
 void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvx(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvx(ctx, target, pname, param);
 }
 
 void glTexEnviv(GLenum target, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnviv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnviv(ctx, target, pname, params);
 }
 
 void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvxv(ctx, target, pname, params);
 }
 
 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameteri(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameteri(ctx, target, pname, param);
 }
 
 void glTexParameterx(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterx(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterx(ctx, target, pname, param);
 }
 
 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameteriv(ctx, target, pname, params);
 }
 
 void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterxv(ctx, target, pname, params);
 }
 
 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatex(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatex(ctx, x, y, z);
 }
 
 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glVertexPointer(ctx, size, type, stride, pointer);
 }
 
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glViewport(ctx, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glViewport(ctx, x, y, width, height);
 }
 
 void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerOES(ctx, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glPointSizePointerOES(ctx, type, stride, pointer);
 }
 
 void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glVertexPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glColorPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointerOffset(ctx, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glNormalPointerOffset(ctx, type, stride, offset);
 }
 
 void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerOffset(ctx, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glPointSizePointerOffset(ctx, type, stride, offset);
 }
 
 void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glWeightPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glVertexPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glColorPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointerData(ctx, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glNormalPointerData(ctx, type, stride, data, datalen);
 }
 
 void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen);
 }
 
 void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerData(ctx, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glPointSizePointerData(ctx, type, stride, data, datalen);
 }
 
 void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glWeightPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
+	GET_CONTEXT;
+	ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
 }
 
 void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
+	GET_CONTEXT;
+	ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
 }
 
 void glGetCompressedTextureFormats(int count, GLint* formats)
 {
-	GET_CONTEXT; 
-	 ctx->glGetCompressedTextureFormats(ctx, count, formats);
+	GET_CONTEXT;
+	ctx->glGetCompressedTextureFormats(ctx, count, formats);
 }
 
 int glFinishRoundTrip()
 {
-	GET_CONTEXT; 
-	 return ctx->glFinishRoundTrip(ctx);
+	GET_CONTEXT;
+	return ctx->glFinishRoundTrip(ctx);
 }
 
 void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha);
+	GET_CONTEXT;
+	ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha);
 }
 
 void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
+	GET_CONTEXT;
+	ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void glBlendEquationOES(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendEquationOES(ctx, mode);
+	GET_CONTEXT;
+	ctx->glBlendEquationOES(ctx, mode);
 }
 
 void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexsOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexsOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexiOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexiOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexxOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexxOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexsvOES(const GLshort* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexsvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexsvOES(ctx, coords);
 }
 
 void glDrawTexivOES(const GLint* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexivOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexivOES(ctx, coords);
 }
 
 void glDrawTexxvOES(const GLfixed* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexxvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexxvOES(ctx, coords);
 }
 
 void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexfOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexfOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexfvOES(const GLfloat* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexfvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexfvOES(ctx, coords);
 }
 
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
-	 ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
+	GET_CONTEXT;
+	ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
 }
 
 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
-	 ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
+	GET_CONTEXT;
+	ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
 }
 
 void glAlphaFuncxOES(GLenum func, GLclampx ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFuncxOES(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFuncxOES(ctx, func, ref);
 }
 
 void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColorxOES(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColorxOES(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthxOES(GLclampx depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthxOES(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthxOES(ctx, depth);
 }
 
 void glClipPlanexOES(GLenum plane, const GLfixed* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanexOES(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanexOES(ctx, plane, equation);
 }
 
 void glClipPlanexIMG(GLenum plane, const GLfixed* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanexIMG(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanexIMG(ctx, plane, equation);
 }
 
 void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4xOES(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4xOES(ctx, red, green, blue, alpha);
 }
 
 void glDepthRangexOES(GLclampx zNear, GLclampx zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangexOES(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangexOES(ctx, zNear, zFar);
 }
 
 void glFogxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogxOES(ctx, pname, param);
 }
 
 void glFogxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogxvOES(ctx, pname, params);
 }
 
 void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetClipPlanexOES(GLenum pname, GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanexOES(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanexOES(ctx, pname, eqn);
 }
 
 void glGetClipPlanex(GLenum pname, GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanex(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanex(ctx, pname, eqn);
 }
 
 void glGetFixedvOES(GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFixedvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFixedvOES(ctx, pname, params);
 }
 
 void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightxvOES(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightxvOES(ctx, light, pname, params);
 }
 
 void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialxvOES(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialxvOES(ctx, face, pname, params);
 }
 
 void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvxvOES(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvxvOES(ctx, env, pname, params);
 }
 
 void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterxvOES(ctx, target, pname, params);
 }
 
 void glLightModelxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelxOES(ctx, pname, param);
 }
 
 void glLightModelxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelxvOES(ctx, pname, params);
 }
 
 void glLightxOES(GLenum light, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxOES(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightxOES(ctx, light, pname, param);
 }
 
 void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxvOES(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightxvOES(ctx, light, pname, params);
 }
 
 void glLineWidthxOES(GLfixed width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidthxOES(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidthxOES(ctx, width);
 }
 
 void glLoadMatrixxOES(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixxOES(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixxOES(ctx, m);
 }
 
 void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxOES(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialxOES(ctx, face, pname, param);
 }
 
 void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxvOES(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialxvOES(ctx, face, pname, params);
 }
 
 void glMultMatrixxOES(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixxOES(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixxOES(ctx, m);
 }
 
 void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q);
 }
 
 void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3xOES(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3xOES(ctx, nx, ny, nz);
 }
 
 void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPointParameterxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterxOES(ctx, pname, param);
 }
 
 void glPointParameterxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterxvOES(ctx, pname, params);
 }
 
 void glPointSizexOES(GLfixed size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizexOES(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSizexOES(ctx, size);
 }
 
 void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffsetxOES(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffsetxOES(ctx, factor, units);
 }
 
 void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatexOES(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatexOES(ctx, angle, x, y, z);
 }
 
 void glSampleCoveragexOES(GLclampx value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoveragexOES(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoveragexOES(ctx, value, invert);
 }
 
 void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalexOES(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalexOES(ctx, x, y, z);
 }
 
 void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxOES(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvxOES(ctx, target, pname, param);
 }
 
 void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvxvOES(ctx, target, pname, params);
 }
 
 void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxOES(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterxOES(ctx, target, pname, param);
 }
 
 void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterxvOES(ctx, target, pname, params);
 }
 
 void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatexOES(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatexOES(ctx, x, y, z);
 }
 
 GLboolean glIsRenderbufferOES(GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsRenderbufferOES(ctx, renderbuffer);
+	GET_CONTEXT;
+	return ctx->glIsRenderbufferOES(ctx, renderbuffer);
 }
 
 void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindRenderbufferOES(ctx, target, renderbuffer);
+	GET_CONTEXT;
+	ctx->glBindRenderbufferOES(ctx, target, renderbuffer);
 }
 
 void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers);
+	ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers);
 }
 
 void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenRenderbuffersOES(ctx, n, renderbuffers);
+	ctx->glGenRenderbuffersOES(ctx, n, renderbuffers);
 }
 
 void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height);
+	GET_CONTEXT;
+	ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height);
 }
 
 void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params);
 }
 
 GLboolean glIsFramebufferOES(GLuint framebuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsFramebufferOES(ctx, framebuffer);
+	GET_CONTEXT;
+	return ctx->glIsFramebufferOES(ctx, framebuffer);
 }
 
 void glBindFramebufferOES(GLenum target, GLuint framebuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindFramebufferOES(ctx, target, framebuffer);
+	GET_CONTEXT;
+	ctx->glBindFramebufferOES(ctx, target, framebuffer);
 }
 
 void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFramebuffersOES(ctx, n, framebuffers);
+	ctx->glDeleteFramebuffersOES(ctx, n, framebuffers);
 }
 
 void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFramebuffersOES(ctx, n, framebuffers);
+	ctx->glGenFramebuffersOES(ctx, n, framebuffers);
 }
 
 GLenum glCheckFramebufferStatusOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 return ctx->glCheckFramebufferStatusOES(ctx, target);
+	GET_CONTEXT;
+	return ctx->glCheckFramebufferStatusOES(ctx, target);
 }
 
 void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer);
+	GET_CONTEXT;
+	ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level);
+	GET_CONTEXT;
+	ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level);
 }
 
 void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params);
 }
 
 void glGenerateMipmapOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 ctx->glGenerateMipmapOES(ctx, target);
+	GET_CONTEXT;
+	ctx->glGenerateMipmapOES(ctx, target);
 }
 
 void* glMapBufferOES(GLenum target, GLenum access)
 {
-	GET_CONTEXT; 
-	 return ctx->glMapBufferOES(ctx, target, access);
+	GET_CONTEXT;
+	return ctx->glMapBufferOES(ctx, target, access);
 }
 
 GLboolean glUnmapBufferOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 return ctx->glUnmapBufferOES(ctx, target);
+	GET_CONTEXT;
+	return ctx->glUnmapBufferOES(ctx, target);
 }
 
 void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBufferPointervOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBufferPointervOES(ctx, target, pname, params);
 }
 
 void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
 {
-	GET_CONTEXT; 
-	 ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex);
+	GET_CONTEXT;
+	ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex);
 }
 
 void glLoadPaletteFromModelViewMatrixOES()
 {
-	GET_CONTEXT; 
-	 ctx->glLoadPaletteFromModelViewMatrixOES(ctx);
+	GET_CONTEXT;
+	ctx->glLoadPaletteFromModelViewMatrixOES(ctx);
 }
 
 void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer);
 }
 
 void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerOES(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glWeightPointerOES(ctx, size, type, stride, pointer);
 }
 
 GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent)
 {
-	GET_CONTEXT; 
-	 return ctx->glQueryMatrixxOES(ctx, mantissa, exponent);
+	GET_CONTEXT;
+	return ctx->glQueryMatrixxOES(ctx, mantissa, exponent);
 }
 
 void glDepthRangefOES(GLclampf zNear, GLclampf zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangefOES(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangefOES(ctx, zNear, zFar);
 }
 
 void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glClipPlanefOES(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanefOES(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanefOES(ctx, plane, equation);
 }
 
 void glClipPlanefIMG(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanefIMG(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanefIMG(ctx, plane, equation);
 }
 
 void glGetClipPlanefOES(GLenum pname, GLfloat* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanefOES(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanefOES(ctx, pname, eqn);
 }
 
 void glClearDepthfOES(GLclampf depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthfOES(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthfOES(ctx, depth);
 }
 
 void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenfOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGenfOES(ctx, coord, pname, param);
 }
 
 void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenfvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenfvOES(ctx, coord, pname, params);
 }
 
 void glTexGeniOES(GLenum coord, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGeniOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGeniOES(ctx, coord, pname, param);
 }
 
 void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenivOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenivOES(ctx, coord, pname, params);
 }
 
 void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenxOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGenxOES(ctx, coord, pname, param);
 }
 
 void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenxvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenxvOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenfvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenfvOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenivOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenivOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenxvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenxvOES(ctx, coord, pname, params);
 }
 
 void glBindVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
-	 ctx->glBindVertexArrayOES(ctx, array);
+	GET_CONTEXT;
+	ctx->glBindVertexArrayOES(ctx, array);
 }
 
 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteVertexArraysOES(ctx, n, arrays);
+	ctx->glDeleteVertexArraysOES(ctx, n, arrays);
 }
 
 void glGenVertexArraysOES(GLsizei n, GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenVertexArraysOES(ctx, n, arrays);
+	ctx->glGenVertexArraysOES(ctx, n, arrays);
 }
 
 GLboolean glIsVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsVertexArrayOES(ctx, array);
+	GET_CONTEXT;
+	return ctx->glIsVertexArrayOES(ctx, array);
 }
 
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
 {
-	GET_CONTEXT; 
-	 ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
+	GET_CONTEXT;
+	ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
 }
 
 void glMultiDrawArraysEXT(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
 }
 
 void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount);
 }
 
 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
+	GET_CONTEXT;
+	ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
 }
 
 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
+	GET_CONTEXT;
+	ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
 }
 
 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFencesNV(ctx, n, fences);
+	ctx->glDeleteFencesNV(ctx, n, fences);
 }
 
 void glGenFencesNV(GLsizei n, GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFencesNV(ctx, n, fences);
+	ctx->glGenFencesNV(ctx, n, fences);
 }
 
 GLboolean glIsFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsFenceNV(ctx, fence);
+	GET_CONTEXT;
+	return ctx->glIsFenceNV(ctx, fence);
 }
 
 GLboolean glTestFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 return ctx->glTestFenceNV(ctx, fence);
+	GET_CONTEXT;
+	return ctx->glTestFenceNV(ctx, fence);
 }
 
 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFenceivNV(ctx, fence, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFenceivNV(ctx, fence, pname, params);
 }
 
 void glFinishFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 ctx->glFinishFenceNV(ctx, fence);
+	GET_CONTEXT;
+	ctx->glFinishFenceNV(ctx, fence);
 }
 
 void glSetFenceNV(GLuint fence, GLenum condition)
 {
-	GET_CONTEXT; 
-	 ctx->glSetFenceNV(ctx, fence, condition);
+	GET_CONTEXT;
+	ctx->glSetFenceNV(ctx, fence, condition);
 }
 
 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
 {
-	GET_CONTEXT; 
-	 ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
+	GET_CONTEXT;
+	ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
 }
 
 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
 {
-	GET_CONTEXT; 
-	 ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
+	GET_CONTEXT;
+	ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
 }
 
 void glEnableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
-	 ctx->glEnableDriverControlQCOM(ctx, driverControl);
+	GET_CONTEXT;
+	ctx->glEnableDriverControlQCOM(ctx, driverControl);
 }
 
 void glDisableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
-	 ctx->glDisableDriverControlQCOM(ctx, driverControl);
+	GET_CONTEXT;
+	ctx->glDisableDriverControlQCOM(ctx, driverControl);
 }
 
 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
+	GET_CONTEXT;
+	ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
 }
 
 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
+	GET_CONTEXT;
+	ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
 }
 
 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
+	GET_CONTEXT;
+	ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
 }
 
 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
+	GET_CONTEXT;
+	ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
 }
 
 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
+	GET_CONTEXT;
+	ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
 }
 
 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
 }
 
 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
+	GET_CONTEXT;
+	ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
 }
 
 void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetBufferPointervQCOM(ctx, target, params);
+	GET_CONTEXT;
+	ctx->glExtGetBufferPointervQCOM(ctx, target, params);
 }
 
 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
+	GET_CONTEXT;
+	ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
 }
 
 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
+	GET_CONTEXT;
+	ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
 }
 
 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 {
-	GET_CONTEXT; 
-	 return ctx->glExtIsProgramBinaryQCOM(ctx, program);
+	GET_CONTEXT;
+	return ctx->glExtIsProgramBinaryQCOM(ctx, program);
 }
 
 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
+	GET_CONTEXT;
+	ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
 }
 
 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
-	 ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
+	GET_CONTEXT;
+	ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
 }
 
 void glEndTilingQCOM(GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
-	 ctx->glEndTilingQCOM(ctx, preserveMask);
+	GET_CONTEXT;
+	ctx->glEndTilingQCOM(ctx, preserveMask);
 }
 
diff --git a/opengl/system/GLESv1_enc/gl_ftable.h b/opengl/system/GLESv1_enc/gl_ftable.h
index 7201e7f..67ba6f4 100644
--- a/opengl/system/GLESv1_enc/gl_ftable.h
+++ b/opengl/system/GLESv1_enc/gl_ftable.h
@@ -4,7 +4,7 @@
 #define __gl_client_ftable_t_h
 
 
-static struct _gl_funcs_by_name {
+static const struct _gl_funcs_by_name {
 	const char *name;
 	void *proc;
 } gl_funcs_by_name[] = {
@@ -282,7 +282,7 @@ static struct _gl_funcs_by_name {
 	{"glStartTilingQCOM", (void*)glStartTilingQCOM},
 	{"glEndTilingQCOM", (void*)glEndTilingQCOM},
 };
-static int gl_num_funcs = sizeof(gl_funcs_by_name) / sizeof(struct _gl_funcs_by_name);
+static const int gl_num_funcs = sizeof(gl_funcs_by_name) / sizeof(struct _gl_funcs_by_name);
 
 
 #endif