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

14 files changed, 888 insertions, 872 deletions

diff --git a/opengl/README b/opengl/README
index 91050ed..3303d4b 100644
--- a/opengl/README
+++ b/opengl/README
@@ -1,3 +1,19 @@
 This directory contains Android-side modules related to hardware OpenGL ES
 emulation. The host-side modules and documentation are in
 $ANDROID_BUILD_TOP/sdk/emulator/opengl.
+
+Note that this directory contains encoder sources that are auto-generated
+with the 'emugen' host tool (see sdk/emulator/opengl/host/tools/emugen).
+
+To regenerate them, run external/qemu/distrib/update-emugl-sources.sh,
+after building the emulator from sources, this will populate the content
+here with the appropriate updated source files.
+
+You should do this whenever you update one of the *.types, *.in and *.attrib
+files located under one of:
+
+  $AOSP/sdk/emulator/opengl/libs/GLESv1_dec/
+  $AOSP/sdk/emulator/opengl/libs/GLESv2_dec/
+  $AOSP/sdk/emulator/opengl/libs/renderControl_dec/
+
+or when the 'emugen' tool itself is modified.
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
diff --git a/opengl/system/GLESv2_enc/gl2_client_proc.h b/opengl/system/GLESv2_enc/gl2_client_proc.h
index 4eeda70..6ad50a8 100644
--- a/opengl/system/GLESv2_enc/gl2_client_proc.h
+++ b/opengl/system/GLESv2_enc/gl2_client_proc.h
@@ -7,7 +7,7 @@
 
 #include "gl2_types.h"
 #ifndef gl2_APIENTRY
-#define gl2_APIENTRY
+#define gl2_APIENTRY 
 #endif
 typedef void (gl2_APIENTRY *glActiveTexture_client_proc_t) (void * ctx, GLenum);
 typedef void (gl2_APIENTRY *glAttachShader_client_proc_t) (void * ctx, GLuint, GLuint);
@@ -107,7 +107,7 @@ typedef void (gl2_APIENTRY *glRenderbufferStorage_client_proc_t) (void * ctx, GL
 typedef void (gl2_APIENTRY *glSampleCoverage_client_proc_t) (void * ctx, GLclampf, GLboolean);
 typedef void (gl2_APIENTRY *glScissor_client_proc_t) (void * ctx, GLint, GLint, GLsizei, GLsizei);
 typedef void (gl2_APIENTRY *glShaderBinary_client_proc_t) (void * ctx, GLsizei, const GLuint*, GLenum, const GLvoid*, GLsizei);
-typedef void (gl2_APIENTRY *glShaderSource_client_proc_t) (void * ctx, GLuint, GLsizei, const GLchar* const*, const GLint*);
+typedef void (gl2_APIENTRY *glShaderSource_client_proc_t) (void * ctx, GLuint, GLsizei, const GLchar*const*, const GLint*);
 typedef void (gl2_APIENTRY *glStencilFunc_client_proc_t) (void * ctx, GLenum, GLint, GLuint);
 typedef void (gl2_APIENTRY *glStencilFuncSeparate_client_proc_t) (void * ctx, GLenum, GLenum, GLint, GLuint);
 typedef void (gl2_APIENTRY *glStencilMask_client_proc_t) (void * ctx, GLuint);
diff --git a/opengl/system/GLESv2_enc/gl2_enc.cpp b/opengl/system/GLESv2_enc/gl2_enc.cpp
index f3959d2..9c5da32 100644
--- a/opengl/system/GLESv2_enc/gl2_enc.cpp
+++ b/opengl/system/GLESv2_enc/gl2_enc.cpp
@@ -10,9 +10,9 @@
 
 #include <stdio.h>
 
-namespace glesv2_enc {
+namespace {
 
-static void enc_unsupported()
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -1165,7 +1165,7 @@ void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsiz
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
+	const unsigned int __size_length = ((length != NULL) ?  sizeof(GLsizei) : 0);
 	const unsigned int __size_infolog =  bufsize;
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + __size_length + __size_infolog + 2*4;
@@ -2917,9 +2917,7 @@ int glFinishRoundTrip_enc(void *self )
 	return retval;
 }
 
-}  // namespace glesv2_enc
-
-using namespace glesv2_enc;
+}  // namespace
 
 gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream)
 {
diff --git a/opengl/system/GLESv2_enc/gl2_enc.h b/opengl/system/GLESv2_enc/gl2_enc.h
index ca4220f..6f83d3e 100644
--- a/opengl/system/GLESv2_enc/gl2_enc.h
+++ b/opengl/system/GLESv2_enc/gl2_enc.h
@@ -19,4 +19,4 @@ struct gl2_encoder_context_t : public gl2_client_context_t {
 	gl2_encoder_context_t(IOStream *stream);
 };
 
-#endif
\ No newline at end of file
+#endif  // GUARD_gl2_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/GLESv2_enc/gl2_entry.cpp b/opengl/system/GLESv2_enc/gl2_entry.cpp
index abd374b..8e76388 100644
--- a/opengl/system/GLESv2_enc/gl2_entry.cpp
+++ b/opengl/system/GLESv2_enc/gl2_entry.cpp
@@ -104,7 +104,7 @@ extern "C" {
 	void glSampleCoverage(GLclampf value, GLboolean invert);
 	void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
 	void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
-	void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
+	void glShaderSource(GLuint shader, GLsizei count, const GLchar*const* string, const GLint* length);
 	void glStencilFunc(GLenum func, GLint ref, GLuint mask);
 	void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
 	void glStencilMask(GLuint mask);
@@ -226,1258 +226,1258 @@ void gl2_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCur
 void glActiveTexture(GLenum texture)
 {
 	GET_CONTEXT;
-	 ctx->glActiveTexture(ctx, texture);
+	ctx->glActiveTexture(ctx, texture);
 }
 
 void glAttachShader(GLuint program, GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glAttachShader(ctx, program, shader);
+	ctx->glAttachShader(ctx, program, shader);
 }
 
 void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glBindAttribLocation(ctx, program, index, name);
+	ctx->glBindAttribLocation(ctx, program, index, name);
 }
 
 void glBindBuffer(GLenum target, GLuint buffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindBuffer(ctx, target, buffer);
+	ctx->glBindBuffer(ctx, target, buffer);
 }
 
 void glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindFramebuffer(ctx, target, framebuffer);
+	ctx->glBindFramebuffer(ctx, target, framebuffer);
 }
 
 void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindRenderbuffer(ctx, target, renderbuffer);
+	ctx->glBindRenderbuffer(ctx, target, renderbuffer);
 }
 
 void glBindTexture(GLenum target, GLuint texture)
 {
 	GET_CONTEXT;
-	 ctx->glBindTexture(ctx, target, texture);
+	ctx->glBindTexture(ctx, target, texture);
 }
 
 void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendColor(ctx, red, green, blue, alpha);
+	ctx->glBlendColor(ctx, red, green, blue, alpha);
 }
 
 void glBlendEquation(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glBlendEquation(ctx, mode);
+	ctx->glBlendEquation(ctx, mode);
 }
 
 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha);
+	ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha);
 }
 
 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
 	GET_CONTEXT;
-	 ctx->glBlendFunc(ctx, sfactor, dfactor);
+	ctx->glBlendFunc(ctx, sfactor, dfactor);
 }
 
 void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
+	ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 {
 	GET_CONTEXT;
-	 ctx->glBufferData(ctx, target, size, data, usage);
+	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);
+	ctx->glBufferSubData(ctx, target, offset, size, data);
 }
 
 GLenum glCheckFramebufferStatus(GLenum target)
 {
 	GET_CONTEXT;
-	 return ctx->glCheckFramebufferStatus(ctx, target);
+	return ctx->glCheckFramebufferStatus(ctx, target);
 }
 
 void glClear(GLbitfield mask)
 {
 	GET_CONTEXT;
-	 ctx->glClear(ctx, mask);
+	ctx->glClear(ctx, mask);
 }
 
 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
 	GET_CONTEXT;
-	 ctx->glClearColor(ctx, red, green, blue, alpha);
+	ctx->glClearColor(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthf(GLclampf depth)
 {
 	GET_CONTEXT;
-	 ctx->glClearDepthf(ctx, depth);
+	ctx->glClearDepthf(ctx, depth);
 }
 
 void glClearStencil(GLint s)
 {
 	GET_CONTEXT;
-	 ctx->glClearStencil(ctx, s);
+	ctx->glClearStencil(ctx, s);
 }
 
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
 	GET_CONTEXT;
-	 ctx->glColorMask(ctx, red, green, blue, alpha);
+	ctx->glColorMask(ctx, red, green, blue, alpha);
 }
 
 void glCompileShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glCompileShader(ctx, shader);
+	ctx->glCompileShader(ctx, shader);
 }
 
 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);
+	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);
+	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);
+	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);
+	ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 }
 
 GLuint glCreateProgram()
 {
 	GET_CONTEXT;
-	 return ctx->glCreateProgram(ctx);
+	return ctx->glCreateProgram(ctx);
 }
 
 GLuint glCreateShader(GLenum type)
 {
 	GET_CONTEXT;
-	 return ctx->glCreateShader(ctx, type);
+	return ctx->glCreateShader(ctx, type);
 }
 
 void glCullFace(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glCullFace(ctx, mode);
+	ctx->glCullFace(ctx, mode);
 }
 
 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteBuffers(ctx, n, buffers);
+	ctx->glDeleteBuffers(ctx, n, buffers);
 }
 
 void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFramebuffers(ctx, n, framebuffers);
+	ctx->glDeleteFramebuffers(ctx, n, framebuffers);
 }
 
 void glDeleteProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteProgram(ctx, program);
+	ctx->glDeleteProgram(ctx, program);
 }
 
 void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteRenderbuffers(ctx, n, renderbuffers);
+	ctx->glDeleteRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glDeleteShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteShader(ctx, shader);
+	ctx->glDeleteShader(ctx, shader);
 }
 
 void glDeleteTextures(GLsizei n, const GLuint* textures)
 {
 	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);
+	ctx->glDepthFunc(ctx, func);
 }
 
 void glDepthMask(GLboolean flag)
 {
 	GET_CONTEXT;
-	 ctx->glDepthMask(ctx, flag);
+	ctx->glDepthMask(ctx, flag);
 }
 
 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
 	GET_CONTEXT;
-	 ctx->glDepthRangef(ctx, zNear, zFar);
+	ctx->glDepthRangef(ctx, zNear, zFar);
 }
 
 void glDetachShader(GLuint program, GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glDetachShader(ctx, program, shader);
+	ctx->glDetachShader(ctx, program, shader);
 }
 
 void glDisable(GLenum cap)
 {
 	GET_CONTEXT;
-	 ctx->glDisable(ctx, cap);
+	ctx->glDisable(ctx, cap);
 }
 
 void glDisableVertexAttribArray(GLuint index)
 {
 	GET_CONTEXT;
-	 ctx->glDisableVertexAttribArray(ctx, index);
+	ctx->glDisableVertexAttribArray(ctx, index);
 }
 
 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
 	GET_CONTEXT;
-	 ctx->glDrawArrays(ctx, mode, first, count);
+	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);
+	ctx->glDrawElements(ctx, mode, count, type, indices);
 }
 
 void glEnable(GLenum cap)
 {
 	GET_CONTEXT;
-	 ctx->glEnable(ctx, cap);
+	ctx->glEnable(ctx, cap);
 }
 
 void glEnableVertexAttribArray(GLuint index)
 {
 	GET_CONTEXT;
-	 ctx->glEnableVertexAttribArray(ctx, index);
+	ctx->glEnableVertexAttribArray(ctx, index);
 }
 
 void glFinish()
 {
 	GET_CONTEXT;
-	 ctx->glFinish(ctx);
+	ctx->glFinish(ctx);
 }
 
 void glFlush()
 {
 	GET_CONTEXT;
-	 ctx->glFlush(ctx);
+	ctx->glFlush(ctx);
 }
 
 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer);
+	ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level);
+	ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level);
 }
 
 void glFrontFace(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glFrontFace(ctx, mode);
+	ctx->glFrontFace(ctx, mode);
 }
 
 void glGenBuffers(GLsizei n, GLuint* buffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenBuffers(ctx, n, buffers);
+	ctx->glGenBuffers(ctx, n, buffers);
 }
 
 void glGenerateMipmap(GLenum target)
 {
 	GET_CONTEXT;
-	 ctx->glGenerateMipmap(ctx, target);
+	ctx->glGenerateMipmap(ctx, target);
 }
 
 void glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFramebuffers(ctx, n, framebuffers);
+	ctx->glGenFramebuffers(ctx, n, framebuffers);
 }
 
 void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenRenderbuffers(ctx, n, renderbuffers);
+	ctx->glGenRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glGenTextures(GLsizei n, GLuint* textures)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenTextures(ctx, n, textures);
+	ctx->glGenTextures(ctx, n, textures);
 }
 
 void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name);
+	ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name);
+	ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
 	GET_CONTEXT;
-	 ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders);
+	ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders);
 }
 
 int glGetAttribLocation(GLuint program, const GLchar* name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetAttribLocation(ctx, program, name);
+	return ctx->glGetAttribLocation(ctx, program, name);
 }
 
 void glGetBooleanv(GLenum pname, GLboolean* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetBooleanv(ctx, pname, params);
+	ctx->glGetBooleanv(ctx, pname, params);
 }
 
 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetBufferParameteriv(ctx, target, pname, params);
+	ctx->glGetBufferParameteriv(ctx, target, pname, params);
 }
 
 GLenum glGetError()
 {
 	GET_CONTEXT;
-	 return ctx->glGetError(ctx);
+	return ctx->glGetError(ctx);
 }
 
 void glGetFloatv(GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFloatv(ctx, pname, params);
+	ctx->glGetFloatv(ctx, pname, params);
 }
 
 void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params);
+	ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params);
 }
 
 void glGetIntegerv(GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetIntegerv(ctx, pname, params);
+	ctx->glGetIntegerv(ctx, pname, params);
 }
 
 void glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramiv(ctx, program, pname, params);
+	ctx->glGetProgramiv(ctx, program, pname, params);
 }
 
 void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog);
+	ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog);
 }
 
 void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetRenderbufferParameteriv(ctx, target, pname, params);
+	ctx->glGetRenderbufferParameteriv(ctx, target, pname, params);
 }
 
 void glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderiv(ctx, shader, pname, params);
+	ctx->glGetShaderiv(ctx, shader, pname, params);
 }
 
 void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog);
+	ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog);
 }
 
 void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision);
+	ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision);
 }
 
 void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderSource(ctx, shader, bufsize, length, source);
+	ctx->glGetShaderSource(ctx, shader, bufsize, length, source);
 }
 
 const GLubyte* glGetString(GLenum name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetString(ctx, name);
+	return ctx->glGetString(ctx, name);
 }
 
 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetTexParameterfv(ctx, target, pname, params);
+	ctx->glGetTexParameterfv(ctx, target, pname, params);
 }
 
 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetTexParameteriv(ctx, target, pname, params);
+	ctx->glGetTexParameteriv(ctx, target, pname, params);
 }
 
 void glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetUniformfv(ctx, program, location, params);
+	ctx->glGetUniformfv(ctx, program, location, params);
 }
 
 void glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetUniformiv(ctx, program, location, params);
+	ctx->glGetUniformiv(ctx, program, location, params);
 }
 
 int glGetUniformLocation(GLuint program, const GLchar* name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetUniformLocation(ctx, program, name);
+	return ctx->glGetUniformLocation(ctx, program, name);
 }
 
 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribfv(ctx, index, pname, params);
+	ctx->glGetVertexAttribfv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribiv(ctx, index, pname, params);
+	ctx->glGetVertexAttribiv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer);
+	ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer);
 }
 
 void glHint(GLenum target, GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glHint(ctx, target, mode);
+	ctx->glHint(ctx, target, mode);
 }
 
 GLboolean glIsBuffer(GLuint buffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsBuffer(ctx, buffer);
+	return ctx->glIsBuffer(ctx, buffer);
 }
 
 GLboolean glIsEnabled(GLenum cap)
 {
 	GET_CONTEXT;
-	 return ctx->glIsEnabled(ctx, cap);
+	return ctx->glIsEnabled(ctx, cap);
 }
 
 GLboolean glIsFramebuffer(GLuint framebuffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsFramebuffer(ctx, framebuffer);
+	return ctx->glIsFramebuffer(ctx, framebuffer);
 }
 
 GLboolean glIsProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 return ctx->glIsProgram(ctx, program);
+	return ctx->glIsProgram(ctx, program);
 }
 
 GLboolean glIsRenderbuffer(GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsRenderbuffer(ctx, renderbuffer);
+	return ctx->glIsRenderbuffer(ctx, renderbuffer);
 }
 
 GLboolean glIsShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 return ctx->glIsShader(ctx, shader);
+	return ctx->glIsShader(ctx, shader);
 }
 
 GLboolean glIsTexture(GLuint texture)
 {
 	GET_CONTEXT;
-	 return ctx->glIsTexture(ctx, texture);
+	return ctx->glIsTexture(ctx, texture);
 }
 
 void glLineWidth(GLfloat width)
 {
 	GET_CONTEXT;
-	 ctx->glLineWidth(ctx, width);
+	ctx->glLineWidth(ctx, width);
 }
 
 void glLinkProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glLinkProgram(ctx, program);
+	ctx->glLinkProgram(ctx, program);
 }
 
 void glPixelStorei(GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glPixelStorei(ctx, pname, param);
+	ctx->glPixelStorei(ctx, pname, param);
 }
 
 void glPolygonOffset(GLfloat factor, GLfloat units)
 {
 	GET_CONTEXT;
-	 ctx->glPolygonOffset(ctx, factor, units);
+	ctx->glPolygonOffset(ctx, factor, units);
 }
 
 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);
+	ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
 }
 
 void glReleaseShaderCompiler()
 {
 	GET_CONTEXT;
-	 ctx->glReleaseShaderCompiler(ctx);
+	ctx->glReleaseShaderCompiler(ctx);
 }
 
 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glRenderbufferStorage(ctx, target, internalformat, width, height);
+	ctx->glRenderbufferStorage(ctx, target, internalformat, width, height);
 }
 
 void glSampleCoverage(GLclampf value, GLboolean invert)
 {
 	GET_CONTEXT;
-	 ctx->glSampleCoverage(ctx, value, invert);
+	ctx->glSampleCoverage(ctx, value, invert);
 }
 
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glScissor(ctx, x, y, width, height);
+	ctx->glScissor(ctx, x, y, width, height);
 }
 
 void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
 {
 	GET_CONTEXT;
-	 ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length);
+	ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length);
 }
 
-void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length)
+void glShaderSource(GLuint shader, GLsizei count, const GLchar*const* string, const GLint* length)
 {
 	GET_CONTEXT;
-	 ctx->glShaderSource(ctx, shader, count, string, length);
+	ctx->glShaderSource(ctx, shader, count, string, length);
 }
 
 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilFunc(ctx, func, ref, mask);
+	ctx->glStencilFunc(ctx, func, ref, mask);
 }
 
 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilFuncSeparate(ctx, face, func, ref, mask);
+	ctx->glStencilFuncSeparate(ctx, face, func, ref, mask);
 }
 
 void glStencilMask(GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilMask(ctx, mask);
+	ctx->glStencilMask(ctx, mask);
 }
 
 void glStencilMaskSeparate(GLenum face, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilMaskSeparate(ctx, face, mask);
+	ctx->glStencilMaskSeparate(ctx, face, mask);
 }
 
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
 	GET_CONTEXT;
-	 ctx->glStencilOp(ctx, fail, zfail, zpass);
+	ctx->glStencilOp(ctx, fail, zfail, zpass);
 }
 
 void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
 	GET_CONTEXT;
-	 ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass);
+	ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass);
 }
 
 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);
+	ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameterf(ctx, target, pname, param);
+	ctx->glTexParameterf(ctx, target, pname, param);
 }
 
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameterfv(ctx, target, pname, params);
+	ctx->glTexParameterfv(ctx, target, pname, params);
 }
 
 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameteri(ctx, target, pname, param);
+	ctx->glTexParameteri(ctx, target, pname, param);
 }
 
 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameteriv(ctx, target, pname, params);
+	ctx->glTexParameteriv(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);
+	ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void glUniform1f(GLint location, GLfloat x)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1f(ctx, location, x);
+	ctx->glUniform1f(ctx, location, x);
 }
 
 void glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1fv(ctx, location, count, v);
+	ctx->glUniform1fv(ctx, location, count, v);
 }
 
 void glUniform1i(GLint location, GLint x)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1i(ctx, location, x);
+	ctx->glUniform1i(ctx, location, x);
 }
 
 void glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1iv(ctx, location, count, v);
+	ctx->glUniform1iv(ctx, location, count, v);
 }
 
 void glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2f(ctx, location, x, y);
+	ctx->glUniform2f(ctx, location, x, y);
 }
 
 void glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2fv(ctx, location, count, v);
+	ctx->glUniform2fv(ctx, location, count, v);
 }
 
 void glUniform2i(GLint location, GLint x, GLint y)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2i(ctx, location, x, y);
+	ctx->glUniform2i(ctx, location, x, y);
 }
 
 void glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2iv(ctx, location, count, v);
+	ctx->glUniform2iv(ctx, location, count, v);
 }
 
 void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3f(ctx, location, x, y, z);
+	ctx->glUniform3f(ctx, location, x, y, z);
 }
 
 void glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3fv(ctx, location, count, v);
+	ctx->glUniform3fv(ctx, location, count, v);
 }
 
 void glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3i(ctx, location, x, y, z);
+	ctx->glUniform3i(ctx, location, x, y, z);
 }
 
 void glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3iv(ctx, location, count, v);
+	ctx->glUniform3iv(ctx, location, count, v);
 }
 
 void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4f(ctx, location, x, y, z, w);
+	ctx->glUniform4f(ctx, location, x, y, z, w);
 }
 
 void glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4fv(ctx, location, count, v);
+	ctx->glUniform4fv(ctx, location, count, v);
 }
 
 void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4i(ctx, location, x, y, z, w);
+	ctx->glUniform4i(ctx, location, x, y, z, w);
 }
 
 void glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4iv(ctx, location, count, v);
+	ctx->glUniform4iv(ctx, location, count, v);
 }
 
 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix2fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix2fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix3fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix3fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix4fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix4fv(ctx, location, count, transpose, value);
 }
 
 void glUseProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glUseProgram(ctx, program);
+	ctx->glUseProgram(ctx, program);
 }
 
 void glValidateProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glValidateProgram(ctx, program);
+	ctx->glValidateProgram(ctx, program);
 }
 
 void glVertexAttrib1f(GLuint indx, GLfloat x)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib1f(ctx, indx, x);
+	ctx->glVertexAttrib1f(ctx, indx, x);
 }
 
 void glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib1fv(ctx, indx, values);
+	ctx->glVertexAttrib1fv(ctx, indx, values);
 }
 
 void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib2f(ctx, indx, x, y);
+	ctx->glVertexAttrib2f(ctx, indx, x, y);
 }
 
 void glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib2fv(ctx, indx, values);
+	ctx->glVertexAttrib2fv(ctx, indx, values);
 }
 
 void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib3f(ctx, indx, x, y, z);
+	ctx->glVertexAttrib3f(ctx, indx, x, y, z);
 }
 
 void glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib3fv(ctx, indx, values);
+	ctx->glVertexAttrib3fv(ctx, indx, values);
 }
 
 void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib4f(ctx, indx, x, y, z, w);
+	ctx->glVertexAttrib4f(ctx, indx, x, y, z, w);
 }
 
 void glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib4fv(ctx, indx, values);
+	ctx->glVertexAttrib4fv(ctx, indx, values);
 }
 
 void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr);
+	ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr);
 }
 
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glViewport(ctx, x, y, width, height);
+	ctx->glViewport(ctx, x, y, width, height);
 }
 
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
 	GET_CONTEXT;
-	 ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
+	ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
 }
 
 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
 	GET_CONTEXT;
-	 ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
+	ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
 }
 
 void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary);
+	ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary);
 }
 
 void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length)
 {
 	GET_CONTEXT;
-	 ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length);
+	ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length);
 }
 
 void* glMapBufferOES(GLenum target, GLenum access)
 {
 	GET_CONTEXT;
-	 return ctx->glMapBufferOES(ctx, target, access);
+	return ctx->glMapBufferOES(ctx, target, access);
 }
 
 GLboolean glUnmapBufferOES(GLenum target)
 {
 	GET_CONTEXT;
-	 return ctx->glUnmapBufferOES(ctx, target);
+	return ctx->glUnmapBufferOES(ctx, target);
 }
 
 void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels);
+	ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+	ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height);
+	ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data);
+	ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+	ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset);
+	ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset);
 }
 
 void glBindVertexArrayOES(GLuint array)
 {
 	GET_CONTEXT;
-	 ctx->glBindVertexArrayOES(ctx, array);
+	ctx->glBindVertexArrayOES(ctx, array);
 }
 
 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
 {
 	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;
 	 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);
+	return ctx->glIsVertexArrayOES(ctx, array);
 }
 
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
 {
 	GET_CONTEXT;
-	 ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
+	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);
+	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);
+	ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
 }
 
 void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups);
+	ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups);
 }
 
 void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters);
+	ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters);
 }
 
 void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString);
+	ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString);
 }
 
 void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString);
+	ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString);
 }
 
 void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data);
+	ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data);
 }
 
 void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
 	GET_CONTEXT;
-	 ctx->glGenPerfMonitorsAMD(ctx, n, monitors);
+	ctx->glGenPerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
 	GET_CONTEXT;
-	 ctx->glDeletePerfMonitorsAMD(ctx, n, monitors);
+	ctx->glDeletePerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList)
 {
 	GET_CONTEXT;
-	 ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList);
+	ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList);
 }
 
 void glBeginPerfMonitorAMD(GLuint monitor)
 {
 	GET_CONTEXT;
-	 ctx->glBeginPerfMonitorAMD(ctx, monitor);
+	ctx->glBeginPerfMonitorAMD(ctx, monitor);
 }
 
 void glEndPerfMonitorAMD(GLuint monitor)
 {
 	GET_CONTEXT;
-	 ctx->glEndPerfMonitorAMD(ctx, monitor);
+	ctx->glEndPerfMonitorAMD(ctx, monitor);
 }
 
 void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten);
+	ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten);
 }
 
 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
+	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);
+	ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
 }
 
 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteFencesNV(ctx, n, fences);
+	ctx->glDeleteFencesNV(ctx, n, fences);
 }
 
 void glGenFencesNV(GLsizei n, GLuint* fences)
 {
 	GET_CONTEXT;
-	 ctx->glGenFencesNV(ctx, n, fences);
+	ctx->glGenFencesNV(ctx, n, fences);
 }
 
 GLboolean glIsFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 return ctx->glIsFenceNV(ctx, fence);
+	return ctx->glIsFenceNV(ctx, fence);
 }
 
 GLboolean glTestFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 return ctx->glTestFenceNV(ctx, fence);
+	return ctx->glTestFenceNV(ctx, fence);
 }
 
 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFenceivNV(ctx, fence, pname, params);
+	ctx->glGetFenceivNV(ctx, fence, pname, params);
 }
 
 void glFinishFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 ctx->glFinishFenceNV(ctx, fence);
+	ctx->glFinishFenceNV(ctx, fence);
 }
 
 void glSetFenceNV(GLuint fence, GLenum condition)
 {
 	GET_CONTEXT;
-	 ctx->glSetFenceNV(ctx, fence, condition);
+	ctx->glSetFenceNV(ctx, fence, condition);
 }
 
 void glCoverageMaskNV(GLboolean mask)
 {
 	GET_CONTEXT;
-	 ctx->glCoverageMaskNV(ctx, mask);
+	ctx->glCoverageMaskNV(ctx, mask);
 }
 
 void glCoverageOperationNV(GLenum operation)
 {
 	GET_CONTEXT;
-	 ctx->glCoverageOperationNV(ctx, operation);
+	ctx->glCoverageOperationNV(ctx, operation);
 }
 
 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
 {
 	GET_CONTEXT;
-	 ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
+	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);
+	ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
 }
 
 void glEnableDriverControlQCOM(GLuint driverControl)
 {
 	GET_CONTEXT;
-	 ctx->glEnableDriverControlQCOM(ctx, driverControl);
+	ctx->glEnableDriverControlQCOM(ctx, driverControl);
 }
 
 void glDisableDriverControlQCOM(GLuint driverControl)
 {
 	GET_CONTEXT;
-	 ctx->glDisableDriverControlQCOM(ctx, driverControl);
+	ctx->glDisableDriverControlQCOM(ctx, driverControl);
 }
 
 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
+	ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
 }
 
 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
+	ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
 }
 
 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
+	ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
 }
 
 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
+	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);
+	ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
 }
 
 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
+	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);
+	ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
 }
 
 void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetBufferPointervQCOM(ctx, target, params);
+	ctx->glExtGetBufferPointervQCOM(ctx, target, params);
 }
 
 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
+	ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
 }
 
 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
+	ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
 }
 
 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 {
 	GET_CONTEXT;
-	 return ctx->glExtIsProgramBinaryQCOM(ctx, program);
+	return ctx->glExtIsProgramBinaryQCOM(ctx, program);
 }
 
 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
+	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);
+	ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
 }
 
 void glEndTilingQCOM(GLbitfield preserveMask)
 {
 	GET_CONTEXT;
-	 ctx->glEndTilingQCOM(ctx, preserveMask);
+	ctx->glEndTilingQCOM(ctx, preserveMask);
 }
 
 void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen);
+	ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen);
 }
 
 void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset);
+	ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset);
 }
 
 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
 {
 	GET_CONTEXT;
-	 ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
+	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);
+	ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
 }
 
 void glGetCompressedTextureFormats(int count, GLint* formats)
 {
 	GET_CONTEXT;
-	 ctx->glGetCompressedTextureFormats(ctx, count, formats);
+	ctx->glGetCompressedTextureFormats(ctx, count, formats);
 }
 
 void glShaderString(GLuint shader, const GLchar* string, GLsizei len)
 {
 	GET_CONTEXT;
-	 ctx->glShaderString(ctx, shader, string, len);
+	ctx->glShaderString(ctx, shader, string, len);
 }
 
 int glFinishRoundTrip()
 {
 	GET_CONTEXT;
-	 return ctx->glFinishRoundTrip(ctx);
+	return ctx->glFinishRoundTrip(ctx);
 }
 
diff --git a/opengl/system/GLESv2_enc/gl2_ftable.h b/opengl/system/GLESv2_enc/gl2_ftable.h
index 4cbda78..25df4f0 100644
--- a/opengl/system/GLESv2_enc/gl2_ftable.h
+++ b/opengl/system/GLESv2_enc/gl2_ftable.h
@@ -4,7 +4,7 @@
 #define __gl2_client_ftable_t_h
 
 
-static struct _gl2_funcs_by_name {
+static const struct _gl2_funcs_by_name {
 	const char *name;
 	void *proc;
 } gl2_funcs_by_name[] = {
@@ -210,7 +210,7 @@ static struct _gl2_funcs_by_name {
 	{"glStartTilingQCOM", (void*)glStartTilingQCOM},
 	{"glEndTilingQCOM", (void*)glEndTilingQCOM},
 };
-static int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name);
+static const int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name);
 
 
 #endif
diff --git a/opengl/system/renderControl_enc/renderControl_enc.cpp b/opengl/system/renderControl_enc/renderControl_enc.cpp
index 8031485..34113e1 100644
--- a/opengl/system/renderControl_enc/renderControl_enc.cpp
+++ b/opengl/system/renderControl_enc/renderControl_enc.cpp
@@ -9,7 +9,10 @@
 
 
 #include <stdio.h>
-static void enc_unsupported()
+
+namespace {
+
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -311,7 +314,6 @@ void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
 
 		memcpy(ptr, &colorbuffer, 4); ptr += 4;
-
 	stream->flush();
 }
 
@@ -524,6 +526,8 @@ int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
 	return retval;
 }
 
+}  // namespace
+
 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream)
 {
 	m_stream = stream;
diff --git a/opengl/system/renderControl_enc/renderControl_enc.h b/opengl/system/renderControl_enc/renderControl_enc.h
index f2d0c0e..9469ae4 100644
--- a/opengl/system/renderControl_enc/renderControl_enc.h
+++ b/opengl/system/renderControl_enc/renderControl_enc.h
@@ -19,4 +19,4 @@ struct renderControl_encoder_context_t : public renderControl_client_context_t {
 	renderControl_encoder_context_t(IOStream *stream);
 };
 
-#endif
\ No newline at end of file
+#endif  // GUARD_renderControl_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/renderControl_enc/renderControl_entry.cpp b/opengl/system/renderControl_enc/renderControl_entry.cpp
index a15fd14..71edb83 100644
--- a/opengl/system/renderControl_enc/renderControl_entry.cpp
+++ b/opengl/system/renderControl_enc/renderControl_entry.cpp
@@ -38,162 +38,162 @@ extern "C" {
 #ifndef GET_CONTEXT
 static renderControl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 void renderControl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
-#define GET_CONTEXT renderControl_client_context_t * ctx = getCurrentContext() 
+#define GET_CONTEXT renderControl_client_context_t * ctx = getCurrentContext()
 #endif
 
 GLint rcGetRendererVersion()
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetRendererVersion(ctx);
+	GET_CONTEXT;
+	return ctx->rcGetRendererVersion(ctx);
 }
 
 EGLint rcGetEGLVersion(EGLint* major, EGLint* minor)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetEGLVersion(ctx, major, minor);
+	GET_CONTEXT;
+	return ctx->rcGetEGLVersion(ctx, major, minor);
 }
 
 EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize)
 {
-	GET_CONTEXT; 
-	 return ctx->rcQueryEGLString(ctx, name, buffer, bufferSize);
+	GET_CONTEXT;
+	return ctx->rcQueryEGLString(ctx, name, buffer, bufferSize);
 }
 
 EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetGLString(ctx, name, buffer, bufferSize);
+	GET_CONTEXT;
+	return ctx->rcGetGLString(ctx, name, buffer, bufferSize);
 }
 
 EGLint rcGetNumConfigs(uint32_t* numAttribs)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetNumConfigs(ctx, numAttribs);
+	GET_CONTEXT;
+	return ctx->rcGetNumConfigs(ctx, numAttribs);
 }
 
 EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetConfigs(ctx, bufSize, buffer);
+	GET_CONTEXT;
+	return ctx->rcGetConfigs(ctx, bufSize, buffer);
 }
 
 EGLint rcChooseConfig(EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
 {
-	GET_CONTEXT; 
-	 return ctx->rcChooseConfig(ctx, attribs, attribs_size, configs, configs_size);
+	GET_CONTEXT;
+	return ctx->rcChooseConfig(ctx, attribs, attribs_size, configs, configs_size);
 }
 
 EGLint rcGetFBParam(EGLint param)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetFBParam(ctx, param);
+	GET_CONTEXT;
+	return ctx->rcGetFBParam(ctx, param);
 }
 
 uint32_t rcCreateContext(uint32_t config, uint32_t share, uint32_t glVersion)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateContext(ctx, config, share, glVersion);
+	GET_CONTEXT;
+	return ctx->rcCreateContext(ctx, config, share, glVersion);
 }
 
 void rcDestroyContext(uint32_t context)
 {
-	GET_CONTEXT; 
-	 ctx->rcDestroyContext(ctx, context);
+	GET_CONTEXT;
+	ctx->rcDestroyContext(ctx, context);
 }
 
 uint32_t rcCreateWindowSurface(uint32_t config, uint32_t width, uint32_t height)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateWindowSurface(ctx, config, width, height);
+	GET_CONTEXT;
+	return ctx->rcCreateWindowSurface(ctx, config, width, height);
 }
 
 void rcDestroyWindowSurface(uint32_t windowSurface)
 {
-	GET_CONTEXT; 
-	 ctx->rcDestroyWindowSurface(ctx, windowSurface);
+	GET_CONTEXT;
+	ctx->rcDestroyWindowSurface(ctx, windowSurface);
 }
 
 uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateColorBuffer(ctx, width, height, internalFormat);
+	GET_CONTEXT;
+	return ctx->rcCreateColorBuffer(ctx, width, height, internalFormat);
 }
 
 void rcOpenColorBuffer(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcOpenColorBuffer(ctx, colorbuffer);
+	GET_CONTEXT;
+	ctx->rcOpenColorBuffer(ctx, colorbuffer);
 }
 
 void rcCloseColorBuffer(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcCloseColorBuffer(ctx, colorbuffer);
+	GET_CONTEXT;
+	ctx->rcCloseColorBuffer(ctx, colorbuffer);
 }
 
 void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcSetWindowColorBuffer(ctx, windowSurface, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcSetWindowColorBuffer(ctx, windowSurface, colorBuffer);
 }
 
 int rcFlushWindowColorBuffer(uint32_t windowSurface)
 {
-	GET_CONTEXT; 
-	 return ctx->rcFlushWindowColorBuffer(ctx, windowSurface);
+	GET_CONTEXT;
+	return ctx->rcFlushWindowColorBuffer(ctx, windowSurface);
 }
 
 EGLint rcMakeCurrent(uint32_t context, uint32_t drawSurf, uint32_t readSurf)
 {
-	GET_CONTEXT; 
-	 return ctx->rcMakeCurrent(ctx, context, drawSurf, readSurf);
+	GET_CONTEXT;
+	return ctx->rcMakeCurrent(ctx, context, drawSurf, readSurf);
 }
 
 void rcFBPost(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcFBPost(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcFBPost(ctx, colorBuffer);
 }
 
 void rcFBSetSwapInterval(EGLint interval)
 {
-	GET_CONTEXT; 
-	 ctx->rcFBSetSwapInterval(ctx, interval);
+	GET_CONTEXT;
+	ctx->rcFBSetSwapInterval(ctx, interval);
 }
 
 void rcBindTexture(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcBindTexture(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcBindTexture(ctx, colorBuffer);
 }
 
 void rcBindRenderbuffer(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcBindRenderbuffer(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcBindRenderbuffer(ctx, colorBuffer);
 }
 
 EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead)
 {
-	GET_CONTEXT; 
-	 return ctx->rcColorBufferCacheFlush(ctx, colorbuffer, postCount, forRead);
+	GET_CONTEXT;
+	return ctx->rcColorBufferCacheFlush(ctx, colorbuffer, postCount, forRead);
 }
 
 void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->rcReadColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->rcReadColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
 }
 
 int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
 {
-	GET_CONTEXT; 
-	 return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
 }
 
 int rcOpenColorBuffer2(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->rcOpenColorBuffer2(ctx, colorbuffer);
+	GET_CONTEXT;
+	return ctx->rcOpenColorBuffer2(ctx, colorbuffer);
 }
 
diff --git a/opengl/system/renderControl_enc/renderControl_ftable.h b/opengl/system/renderControl_enc/renderControl_ftable.h
index a43fe5b..e15fb0c 100644
--- a/opengl/system/renderControl_enc/renderControl_ftable.h
+++ b/opengl/system/renderControl_enc/renderControl_ftable.h
@@ -4,7 +4,7 @@
 #define __renderControl_client_ftable_t_h
 
 
-static struct _renderControl_funcs_by_name {
+static const struct _renderControl_funcs_by_name {
 	const char *name;
 	void *proc;
 } renderControl_funcs_by_name[] = {
@@ -35,7 +35,7 @@ static struct _renderControl_funcs_by_name {
 	{"rcUpdateColorBuffer", (void*)rcUpdateColorBuffer},
 	{"rcOpenColorBuffer2", (void*)rcOpenColorBuffer2},
 };
-static int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
+static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
 
 
 #endif