upload tizen1.0 source

1 files changed, 3389 insertions, 0 deletions

diff --git a/libGL/client_glx.c b/libGL/client_glx.c
new file mode 100755
index 0000000..7a46193
--- /dev/null
+++ b/libGL/client_glx.c
@@ -0,0 +1,3389 @@
+/*
+ *  Guest-side implementation of GL/GLX API. Replacement of standard libGL.so
+ *
+ *  Copyright (c) 2006,2007 Even Rouault
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+#include <dlfcn.h>
+#include <sys/time.h>
+
+#include <X11/Xlib-xcb.h>
+#include <xcb/xcb.h>
+
+#include "opengl_func.h"
+#include "common.h"
+#include "lock.h"
+#include "call.h"
+#include "log.h"
+
+GLState* new_gl_state()
+{
+  int i, j;
+  GLState* state;
+
+  state = malloc(sizeof(GLState));
+  memset(state, 0, sizeof(GLState));
+  state->activeTexture = GL_TEXTURE0_ARB;
+  state->client_state.pack.alignment = 4;
+  state->client_state.unpack.alignment = 4;
+  state->current_server_state.matrixMode = GL_MODELVIEW;
+  state->current_server_state.depthFunc = GL_LESS;
+  state->current_server_state.fog.mode = GL_EXP;
+  state->current_server_state.fog.density = 1;
+  state->current_server_state.fog.start = 0;
+  state->current_server_state.fog.end = 1;
+  state->current_server_state.fog.index = 0;
+  state->textureAllocator = &state->ownTextureAllocator;
+  state->bufferAllocator = &state->ownBufferAllocator;
+  state->listAllocator = &state->ownListAllocator;
+  state->currentRasterPosKnown = 1;
+  state->currentRasterPos[0] = 0;
+  state->currentRasterPos[1] = 0;
+  state->currentRasterPos[2] = 0;
+  state->currentRasterPos[3] = 1;
+  for(i=0;i<NB_GL_MATRIX;i++)
+  {
+    state->matrix[i].sp = 0;
+    for(j=0;j<16;j++)
+    {
+      state->matrix[i].current.val[j] = (j == 0 || j == 5 || j == 10 || j == 15);
+    }
+  }
+  return state;
+}
+
+
+typedef struct
+{
+  int attrib;
+  int value;
+  int ret;
+} _glXGetConfigAttribs;
+
+typedef struct
+{
+  int val;
+  char* name;
+} glXAttrib;
+
+#define VAL_AND_NAME(x)  { x, #x }
+
+static const glXAttrib tabRequestedAttribsPair[] =
+{
+  VAL_AND_NAME(GLX_USE_GL),
+  VAL_AND_NAME(GLX_BUFFER_SIZE),
+  VAL_AND_NAME(GLX_LEVEL),
+  VAL_AND_NAME(GLX_RGBA),
+  VAL_AND_NAME(GLX_DOUBLEBUFFER),
+  VAL_AND_NAME(GLX_STEREO),
+  VAL_AND_NAME(GLX_AUX_BUFFERS),
+  VAL_AND_NAME(GLX_RED_SIZE),
+  VAL_AND_NAME(GLX_GREEN_SIZE),
+  VAL_AND_NAME(GLX_BLUE_SIZE),
+  VAL_AND_NAME(GLX_ALPHA_SIZE),
+  VAL_AND_NAME(GLX_DEPTH_SIZE),
+  VAL_AND_NAME(GLX_STENCIL_SIZE),
+  VAL_AND_NAME(GLX_ACCUM_RED_SIZE),
+  VAL_AND_NAME(GLX_ACCUM_GREEN_SIZE),
+  VAL_AND_NAME(GLX_ACCUM_BLUE_SIZE),
+  VAL_AND_NAME(GLX_ACCUM_ALPHA_SIZE),
+  VAL_AND_NAME(GLX_CONFIG_CAVEAT),
+  VAL_AND_NAME(GLX_X_VISUAL_TYPE),
+  VAL_AND_NAME(GLX_TRANSPARENT_TYPE),
+  VAL_AND_NAME(GLX_TRANSPARENT_INDEX_VALUE),
+  VAL_AND_NAME(GLX_TRANSPARENT_RED_VALUE),
+  VAL_AND_NAME(GLX_TRANSPARENT_GREEN_VALUE),
+  VAL_AND_NAME(GLX_TRANSPARENT_BLUE_VALUE),
+  VAL_AND_NAME(GLX_TRANSPARENT_ALPHA_VALUE),
+  VAL_AND_NAME(GLX_SLOW_CONFIG),
+  VAL_AND_NAME(GLX_TRUE_COLOR),
+  VAL_AND_NAME(GLX_DIRECT_COLOR),
+  VAL_AND_NAME(GLX_PSEUDO_COLOR),
+  VAL_AND_NAME(GLX_STATIC_COLOR),
+  VAL_AND_NAME(GLX_GRAY_SCALE),
+  VAL_AND_NAME(GLX_STATIC_GRAY),
+  VAL_AND_NAME(GLX_TRANSPARENT_RGB),
+  VAL_AND_NAME(GLX_TRANSPARENT_INDEX),
+  VAL_AND_NAME(GLX_VISUAL_ID),
+  VAL_AND_NAME(GLX_DRAWABLE_TYPE),
+  VAL_AND_NAME(GLX_RENDER_TYPE),
+  VAL_AND_NAME(GLX_X_RENDERABLE),
+  VAL_AND_NAME(GLX_FBCONFIG_ID),
+  VAL_AND_NAME(GLX_RGBA_TYPE),
+  VAL_AND_NAME(GLX_COLOR_INDEX_TYPE),
+  VAL_AND_NAME(GLX_MAX_PBUFFER_WIDTH),
+  VAL_AND_NAME(GLX_MAX_PBUFFER_HEIGHT),
+  VAL_AND_NAME(GLX_MAX_PBUFFER_PIXELS),
+  VAL_AND_NAME(GLX_PRESERVED_CONTENTS),
+  VAL_AND_NAME(GLX_FLOAT_COMPONENTS_NV),
+  VAL_AND_NAME(GLX_SAMPLE_BUFFERS),
+  VAL_AND_NAME(GLX_SAMPLES)
+};
+#define N_REQUESTED_ATTRIBS (sizeof(tabRequestedAttribsPair)/sizeof(tabRequestedAttribsPair[0]))
+
+static int* getTabRequestedAttribsInt()
+{
+  static int tabRequestedAttribsInt[N_REQUESTED_ATTRIBS] = { 0 };
+  if (tabRequestedAttribsInt[0] == 0)
+  {
+    int i;
+    for(i=0;i<N_REQUESTED_ATTRIBS;i++)
+      tabRequestedAttribsInt[i] = tabRequestedAttribsPair[i].val;
+  }
+  return tabRequestedAttribsInt;
+}
+
+#define N_MAX_ATTRIBS N_REQUESTED_ATTRIBS+10
+typedef struct
+{
+  int                  visualid;
+  _glXGetConfigAttribs attribs[N_MAX_ATTRIBS];
+  int                  nbAttribs;
+} _glXConfigs;
+#define N_MAX_CONFIGS 80
+static _glXConfigs configs[N_MAX_CONFIGS];
+static int nbConfigs = 0;
+
+typedef struct
+{
+  GLXFBConfig config;
+  _glXGetConfigAttribs attribs[N_MAX_ATTRIBS];
+  int nbAttribs;
+} _glXFBConfig;
+
+static _glXFBConfig fbconfigs[N_MAX_CONFIGS];
+static int nbFBConfigs = 0;
+
+const char *glXQueryExtensionsString( Display *dpy, int screen )
+{
+  LOCK(glXQueryExtensionsString_func);
+  static char* ret = NULL;
+  if (ret == NULL)
+  {
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen) };
+    do_opengl_call_no_lock(glXQueryExtensionsString_func, &ret, args, NULL);
+    ret = strdup(ret);
+  }
+  UNLOCK(glXQueryExtensionsString_func);
+  return ret;
+}
+
+
+typedef struct
+{
+  XVisualInfo* vis;
+  int visualid;
+  GLXFBConfig fbconfig;
+} AssocVisualInfoVisualId;
+
+#define MAX_SIZE_TAB_ASSOC_VISUALINFO_VISUALID  100
+AssocVisualInfoVisualId tabAssocVisualInfoVisualId[MAX_SIZE_TAB_ASSOC_VISUALINFO_VISUALID];
+int nEltTabAssocVisualInfoVisualId = 0;
+
+static const char* _getAttribNameFromValue(int val)
+{
+  int i;
+  static char buffer[80];
+  for(i=0;i<N_REQUESTED_ATTRIBS;i++)
+  {
+    if (tabRequestedAttribsPair[i].val == val)
+      return tabRequestedAttribsPair[i].name;
+  }
+  sprintf(buffer, "(unknown name = %d, 0x%X)", val, val);
+  return buffer;
+}
+
+static int _compute_length_of_attrib_list_including_zero(const int* attribList, int booleanMustHaveValue)
+{
+  int i = 0;
+  debug_gl = getenv("DEBUG_GL") != NULL;
+  //##fredrick.kim
+  //debug_gl = 1;
+
+  if (debug_gl) log_gl("attribList = \n");
+  while(attribList[i])
+  {
+    if (booleanMustHaveValue ||
+        !(attribList[i] == GLX_USE_GL ||
+          attribList[i] == GLX_RGBA ||
+          attribList[i] == GLX_DOUBLEBUFFER ||
+          attribList[i] == GLX_STEREO))
+    {
+      if (debug_gl) log_gl("%s = %d\n", _getAttribNameFromValue(attribList[i]), attribList[i+1]);
+      i+=2;
+    }
+    else
+    {
+      if (debug_gl) log_gl("%s\n", _getAttribNameFromValue(attribList[i]));
+      i++;
+    }
+  }
+  if (debug_gl) log_gl("\n");
+  return i + 1;
+}
+
+
+XVisualInfo* glXChooseVisual( Display *dpy, int screen,
+                              int *attribList )
+{
+  XVisualInfo temp, *vis;
+  long mask;
+  int n;
+  int i;
+
+  int visualid = 0;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen), POINTER_TO_ARG(attribList) };
+  int args_size[] = { 0, 0, sizeof(int) * _compute_length_of_attrib_list_including_zero(attribList, 0) };
+  do_opengl_call(glXChooseVisual_func, &visualid, CHECK_ARGS(args, args_size));
+
+  if (visualid)
+  {
+    mask = VisualScreenMask | VisualDepthMask | VisualClassMask | VisualIDMask;
+    temp.screen = screen;
+    temp.depth = DefaultDepth(dpy,screen);
+    temp.class = DefaultVisual(dpy,screen)->class;
+    temp.visualid = DefaultVisual(dpy,screen)->visualid;
+
+    vis = XGetVisualInfo( dpy, mask, &temp, &n );
+    if (vis == NULL)
+      log_gl("cannot get visual from client side\n");
+
+    assert (nEltTabAssocVisualInfoVisualId < MAX_SIZE_TAB_ASSOC_VISUALINFO_VISUALID);
+    for(i=0;i<nEltTabAssocVisualInfoVisualId;i++)
+    {
+      if (tabAssocVisualInfoVisualId[i].vis == vis) break;
+    }
+    if (i == nEltTabAssocVisualInfoVisualId)
+      nEltTabAssocVisualInfoVisualId++;
+    tabAssocVisualInfoVisualId[i].vis = vis;
+    tabAssocVisualInfoVisualId[i].fbconfig = 0;
+    tabAssocVisualInfoVisualId[i].visualid = visualid;
+  }
+  else
+  {
+    vis = NULL;
+  }
+
+  if (debug_gl) log_gl("glXChooseVisual returning vis %p (visualid=%d, 0x%X)\n", vis, visualid, visualid);
+
+  return vis;
+}
+
+const char *glXQueryServerString( Display *dpy, int screen, int name )
+{
+  LOCK(glXQueryServerString_func);
+  static char* glXQueryServerString_ret[100] = {NULL};
+  assert(name >= 0 && name < 100);
+  if (glXQueryServerString_ret[name] == NULL)
+  {
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen), INT_TO_ARG(name) };
+    do_opengl_call_no_lock(glXQueryServerString_func, &glXQueryServerString_ret[name], args, NULL);
+    glXQueryServerString_ret[name] = strdup(glXQueryServerString_ret[name]);
+  }
+  UNLOCK(glXQueryServerString_func);
+  return glXQueryServerString_ret[name];
+}
+
+const char *glXGetClientString( Display *dpy, int name )
+{
+  LOCK(glXGetClientString_func);
+  static char* glXGetClientString_ret[100] = {NULL};
+  assert(name >= 0 && name < 100);
+  if (glXGetClientString_ret[name] == NULL)
+  {
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(name) };
+    do_opengl_call_no_lock(glXGetClientString_func, &glXGetClientString_ret[name], args, NULL);
+    if (getenv("GLX_VENDOR") && name == GLX_VENDOR)
+    {
+      glXGetClientString_ret[name] = getenv("GLX_VENDOR");
+    }
+    else
+      glXGetClientString_ret[name] = strdup(glXGetClientString_ret[name]);
+  }
+  UNLOCK(glXGetClientString_func);
+  return glXGetClientString_ret[name];
+}
+
+static void _create_context(GLXContext context, GLXContext shareList)
+{
+  int i;
+  glstates = realloc(glstates, (nbGLStates+1) * sizeof(GLState*));
+  glstates[nbGLStates] = new_gl_state();
+  glstates[nbGLStates]->ref = 1;
+  glstates[nbGLStates]->context = context;
+  glstates[nbGLStates]->shareList = shareList;
+  glstates[nbGLStates]->viewport.width = 0;
+  if (shareList)
+  {
+    for(i=0; i<nbGLStates; i++)
+    {
+      if (glstates[i]->context == shareList)
+      {
+        glstates[i]->ref++;
+        glstates[nbGLStates]->textureAllocator = glstates[i]->textureAllocator;
+        glstates[nbGLStates]->bufferAllocator = glstates[i]->bufferAllocator;
+        glstates[nbGLStates]->listAllocator = glstates[i]->listAllocator;
+        break;
+      }
+    }
+    if (i == nbGLStates)
+    {
+      log_gl("unknown shareList %p\n", (void*)shareList);
+    }
+  }
+  nbGLStates++;
+}
+
+static GLXFBConfig* glXChooseFBConfig_no_lock( Display *dpy, int screen,
+                                               const int *attribList, int *nitems );
+static XVisualInfo* glXGetVisualFromFBConfig_no_lock( Display *dpy, GLXFBConfig config );
+
+GLXContext glXCreateContext( Display *dpy, XVisualInfo *vis,
+                             GLXContext shareList, Bool direct )
+{
+  LOCK(glXCreateContext_func);
+  int isFbConfigVisual = 0;
+  int i;
+  int visualid = 0;
+
+  for(i=0;i<nEltTabAssocVisualInfoVisualId;i++)
+  {
+    if (tabAssocVisualInfoVisualId[i].vis == vis)
+    {
+      if (tabAssocVisualInfoVisualId[i].fbconfig != NULL)
+      {
+        log_gl("isFbConfigVisual = 1\n");
+        isFbConfigVisual = 1;
+      }
+      visualid = tabAssocVisualInfoVisualId[i].visualid;
+      if (debug_gl) log_gl("found visualid %d corresponding to vis %p\n", visualid, vis);
+      break;
+    }
+  }
+
+  GLXContext ctxt = NULL;
+  if (i == nEltTabAssocVisualInfoVisualId)
+  {
+    visualid = vis->visualid;
+    if (debug_gl) log_gl("not found vis %p in table, visualid=%d\n", vis, visualid);
+  }
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(visualid), INT_TO_ARG(shareList), INT_TO_ARG(direct) };
+  do_opengl_call_no_lock(glXCreateContext_func, &ctxt, args, NULL);
+
+  if (ctxt)
+  {
+    _create_context(ctxt, shareList);
+    glstates[nbGLStates-1]->isAssociatedToFBConfigVisual = isFbConfigVisual;
+  }
+
+  UNLOCK(glXCreateContext_func);
+  return ctxt;
+}
+
+GLXContext glXGetCurrentContext (void)
+{
+  GET_CURRENT_STATE();
+  if (debug_gl) log_gl("glXGetCurrentContext() -> %p\n", state->context);
+  return state->context;
+}
+
+GLXDrawable glXGetCurrentDrawable (void)
+{
+  GET_CURRENT_STATE();
+  if (debug_gl) log_gl("glXGetCurrentDrawable() -> %p\n", (void*)state->current_drawable);
+  return state->current_drawable;
+}
+
+static void _free_context(Display* dpy, int i, GLState* state)
+{
+  free(state->last_cursor.pixels);
+  free(state->ownTextureAllocator.values);
+  free(state->ownBufferAllocator.values);
+  free(state->ownListAllocator.values);
+  free(state);
+  //memmove(&state, &glstates[i+1], (nbGLStates-i-1) * sizeof(GLState*));
+  memmove(&glstates[i], &glstates[i+1], (nbGLStates-i-1) * sizeof(GLState*));
+  nbGLStates--;
+}
+
+GLAPI void APIENTRY glXDestroyContext( Display *dpy, GLXContext ctx )
+{
+  int i;
+  LOCK(glXDestroyContext_func);
+  GET_CURRENT_STATE();
+  for(i=0;i<nbGLStates;i++)
+  {
+    if (glstates[i]->context == ctx)
+    {
+      long args[] = { POINTER_TO_ARG(dpy), POINTER_TO_ARG(ctx) };
+      do_opengl_call_no_lock(glXDestroyContext_func, NULL, args, NULL);
+      if (ctx == state->context)
+      {
+        SET_CURRENT_STATE(NULL);
+      }
+
+      GLXContext shareList = glstates[i]->shareList;
+
+      glstates[i]->ref --;
+      if (glstates[i]->ref == 0)
+      {
+        _free_context(dpy, i, glstates[i]);
+      }
+
+      if (shareList)
+      {
+        for(i=0; i<nbGLStates; i++)
+        {
+          if (glstates[i]->context == shareList)
+          {
+            glstates[i]->ref--;
+            if (glstates[i]->ref == 0)
+            {
+              _free_context(dpy, i, glstates[i]);
+            }
+            break;
+          }
+        }
+      }
+      break;
+    }
+  }
+  UNLOCK(glXDestroyContext_func);
+}
+
+Bool glXQueryVersion( Display *dpy, int *maj, int *min )
+{
+  LOCK(glXQueryVersion_func);
+  static Bool ret = -1;
+  static int l_maj, l_min;
+  if (ret == -1)
+  {
+    long args[] = { POINTER_TO_ARG(dpy), POINTER_TO_ARG(&l_maj), POINTER_TO_ARG(&l_min) };
+    do_opengl_call_no_lock(glXQueryVersion_func, &ret, args, NULL);
+  }
+  if (maj) *maj = l_maj;
+  if (min) *min = l_min;
+  UNLOCK(glXQueryVersion_func);
+  return ret;
+}
+
+/* Getting window information by using XCB API. It looks more complicated
+ * than the way using xlib API. The reason not to use xlib is to avoid the
+ * potential conflicts between xcb and xlib.
+ *
+ * XCB could be called asynchronously. Take the example of getting window
+ * attributes. If there is xlib call of "XGetWindowAttributes()" between
+ * xcb_shape_get_rectangles() and xcb_shape_get_rectangles_reply(), xcb call
+ * will not be able to get the result.
+ *
+ * That is the case we countered for mcompositor in MeeGo handset image while
+ * running with GL accelerations. Using xcb API here could avoid such conflict.
+ */
+static void _get_window_info(Display *dpy, Window win, WindowInfoStruct* info)
+{
+    xcb_connection_t *xcb_conn = XGetXCBConnection(dpy);
+    xcb_get_window_attributes_reply_t *attr = xcb_get_window_attributes_reply(
+                                    xcb_conn,
+                                    xcb_get_window_attributes(xcb_conn, win), 0);
+    if (attr) {
+        if (attr->map_state == XCB_MAP_STATE_VIEWABLE) {
+            info->map_state = IsViewable;
+        } else if (attr->map_state == XCB_MAP_STATE_UNVIEWABLE){
+            info->map_state = IsUnviewable;
+        } else {
+            info->map_state = IsUnmapped;
+        }
+        xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(
+                             xcb_conn,
+                             xcb_get_geometry(xcb_conn, win), 0);
+        free (attr);
+
+        if (geom) {
+            info->width = geom->width;
+            info->height = geom->height;
+            free (geom);
+        } else {
+            info->width = 0;
+            info->height= 0;
+        }
+    } else {
+        // TODO: need error handling. Right now just simply set default value.
+        info->width = 0;
+        info->height= 0;
+        info->map_state = IsUnviewable;
+    }
+}
+
+#if 0
+/* Alternative implementation of getting window attributes. Using xlib API 
+ */
+static void _get_window_info(Display *dpy, Window win, WindowInfoStruct* info)
+{
+  XWindowAttributes attr;
+
+  XGetWindowAttributes(dpy, win, &attr);
+
+  info->width     = attr.width;
+  info->height    = attr.height;
+  info->map_state = attr.map_state;
+}
+#endif
+
+RendererData *renderer_create_image(Display *dpy, int w, int h)
+{
+  RendererData *rdata = calloc(1, sizeof(*rdata));
+
+  if(!rdata)
+    goto out;
+
+  rdata->w = w;
+  rdata->h = h;
+
+  rdata->image = XShmCreateImage(dpy, DefaultVisual(dpy, 0), 24, ZPixmap, NULL,
+                                 &rdata->shminfo, w, h);
+  
+  if(!rdata->image)
+    goto out_try_non_shm;
+
+  rdata->shminfo.shmid = shmget(IPC_PRIVATE, rdata->image->bytes_per_line * h,
+                                IPC_CREAT | 0777);
+  if(rdata->shminfo.shmid == -1) {
+    goto out_destroy_img;
+  }
+
+  rdata->shminfo.shmaddr = shmat(rdata->shminfo.shmid, NULL,0);
+  if(rdata->shminfo.shmaddr == (void*)-1)
+    goto out_shmput;
+
+  rdata->buffer = rdata->shminfo.shmaddr;
+  rdata->image->data = rdata->buffer;
+  rdata->shminfo.readOnly = False;
+  rdata->use_shm = 1;
+
+  XShmAttach(dpy, &rdata->shminfo);
+  XSync(dpy, 0);
+
+  memset(rdata->buffer, 0, rdata->image->bytes_per_line * h);
+
+  return rdata;
+
+out_shmput:
+  shmctl(rdata->shminfo.shmid, IPC_RMID, NULL);
+out_destroy_img:
+  XDestroyImage(rdata->image);
+out_try_non_shm:
+  // Fallback path
+  rdata->image = XCreateImage(dpy, DefaultVisual(dpy, 0), 24, ZPixmap, 0, NULL, w, h, 32, 0);
+  if(rdata->image) {
+    rdata->buffer = calloc(1, (rdata->image->bytes_per_line) * h);
+    if(rdata->buffer) {
+      rdata->image->data = rdata->buffer;
+      return rdata;
+    }
+  }
+  XDestroyImage(rdata->image);
+  free(rdata);
+out:
+  return NULL;
+}
+
+void renderer_destroy_image(Display *dpy, RendererData *rdata) {
+  if(!rdata) {
+    return;
+  }
+  if(rdata->use_shm)
+    XShmDetach(dpy, &rdata->shminfo);
+  else
+    free(rdata->image->data);
+
+  rdata->image->data = NULL;
+  XDestroyImage(rdata->image);
+
+  if(rdata->use_shm) {
+    shmdt(rdata->shminfo.shmaddr);
+    shmctl(rdata->shminfo.shmid, IPC_RMID, NULL);
+  }
+  free(rdata);
+}
+
+#define MAX_PBUFFERS 100
+
+/* Do this only with lock held */
+static void _request_host_resize(Display *dpy, Window win, GLState *state, int w, int h)
+{
+    if(state->renderer_data)
+      renderer_destroy_image(dpy, state->renderer_data);
+
+    state->renderer_data = renderer_create_image(dpy, w, h);
+
+    long args[] = { INT_TO_ARG(win), INT_TO_ARG(w), INT_TO_ARG(h)};
+    do_opengl_call_no_lock(_resize_surface_func, NULL, args, 0);
+}
+
+static void _update_renderer(Display *dpy, Window win) {
+  GET_CURRENT_STATE();
+  WindowInfoStruct info;
+  WindowInfoStruct *old_info = &state->last_win_state;
+
+  if(!win)
+    return;
+
+  _get_window_info(dpy, win, &info);
+
+  if(info.map_state != IsViewable) {
+    if(state->renderer_data);
+      renderer_destroy_image(dpy, state->renderer_data);
+    state->renderer_data = NULL;
+    goto out;
+  }
+
+  if(!state->renderer_data) {
+    state->renderer_data = renderer_create_image(dpy, info.width, info.height);
+    _request_host_resize(dpy, win, state, info.width, info.height);
+    goto out;
+  }
+
+  if ((info.width != old_info->width) || (info.height != old_info->height)) {
+    _request_host_resize(dpy, win, state, info.width, info.height);
+    goto out;
+  }
+
+  //fprintf(stderr, "render: win: %08x w: %d h: %d stride: %d\n", win, state->renderer_data->w, state->renderer_data->h, state->renderer_data->image->bytes_per_line);
+
+// Actually render stuff
+  long args[] = { INT_TO_ARG(win), INT_TO_ARG(state->renderer_data->image->bits_per_pixel), INT_TO_ARG(state->renderer_data->image->bytes_per_line), POINTER_TO_ARG(state->renderer_data->buffer)};
+  int args_size[] = {0, 0, 0, state->renderer_data->image->bytes_per_line*state->renderer_data->h};
+  do_opengl_call_no_lock(_render_surface_func, NULL, args, args_size);
+
+  /* draw into window */
+  if(state->renderer_data->use_shm)
+    XShmPutImage(dpy, win, DefaultGC(dpy, 0), state->renderer_data->image,
+                 0, 0, 0, 0, state->renderer_data->w, state->renderer_data->h,
+                 False);
+  else 
+    XPutImage(dpy, win, DefaultGC(dpy, 0), state->renderer_data->image, 0, 0,
+              0, 0, state->renderer_data->w, state->renderer_data->h);
+
+  XFlush(dpy);
+
+#if 0
+  do {
+    char filename[50];
+    FILE *f;
+
+    sprintf(filename, "/home/ian/dump_%08x.rgb", win);
+    f = fopen(filename, "wb");
+    fwrite(state->renderer_data->buffer, state->renderer_data->image->bytes_per_line*state->renderer_data->h, 1, f);
+    fclose(f);
+  } while(0);
+#endif
+
+out:
+  memcpy(old_info, &info, sizeof(info));
+}
+
+/* Read the X window information to see whether the resize of render buffer
+ * on host side is needed. If so do the resize and return 1; otherwise
+ * return 0.
+ */
+int _check_and_resize_window (GLState *state, Window win) {
+  WindowInfoStruct info;
+  WindowInfoStruct *old_info = &state->last_win_state;
+  int changed = 0;
+
+  if(!win)
+    return changed;
+
+  _get_window_info(state->display, win, &info);
+
+  LOCK(_resize_surface_func);
+  if(info.map_state != IsViewable) {
+    if(state->renderer_data);
+      renderer_destroy_image(state->display, state->renderer_data);
+    state->renderer_data = NULL;
+    changed = 1;
+  } else if(!state->renderer_data) {
+    state->renderer_data = renderer_create_image(state->display, info.width, info.height);
+    _request_host_resize(state->display, win, state, info.width, info.height);
+    changed = 1;
+  } else if ((info.width != old_info->width) || (info.height != old_info->height)) {
+    _request_host_resize(state->display, win, state, info.width, info.height);
+    changed = 1;
+  }
+
+  memcpy(old_info, &info, sizeof(info));
+  UNLOCK(_resize_surface_func);
+
+  return changed;
+}
+
+Bool glXMakeCurrent_no_lock( Display *dpy, GLXDrawable drawable, GLXContext ctx)
+{
+  Bool ret = False;
+  int i;
+#if 0
+  if (drawable == 0 && ctx == 0)
+    return True;
+  if (current_drawable == drawable && current_context == ctx) /* optimization */
+    return True;
+#endif
+  GET_CURRENT_STATE();
+
+  {
+    //log_gl("glXMakeCurrent %d %d\n", drawable, ctx);
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(drawable), INT_TO_ARG(ctx) };
+    do_opengl_call_no_lock(glXMakeCurrent_func, NULL /*&ret*/, args, NULL);
+    ret = True;
+  }
+
+  if (ret)
+  {
+    int i;
+	
+    if (ctx > 0)
+    {
+      for(i=0; i<nbGLStates; i++)
+      {
+        if (glstates[i]->context == ctx)
+        {
+          state = glstates[i];
+          SET_CURRENT_STATE(state);
+          break;
+        }
+      }
+      if (i == nbGLStates)
+      {
+        log_gl("cannot set current_gl_state\n");
+        log_gl("nbGLStates = %d\n", nbGLStates);
+      }
+    }
+
+    state->display = dpy;
+    state->current_drawable = drawable;
+    state->current_read_drawable = drawable;
+  }
+  
+  return ret;
+}
+
+GLAPI Bool APIENTRY glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx)
+{
+  Bool ret;
+  LOCK(glXMakeCurrent_func);
+  ret = glXMakeCurrent_no_lock(dpy, drawable, ctx);
+  UNLOCK(glXMakeCurrent_func);
+  return ret;
+}
+
+GLAPI void APIENTRY glXCopyContext( Display *dpy, GLXContext src, GLXContext dst, unsigned long mask )
+{
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(src), INT_TO_ARG(dst), INT_TO_ARG(mask) };
+  do_opengl_call(glXCopyContext_func, NULL, args, NULL);
+}
+
+GLAPI Bool APIENTRY glXIsDirect( Display *dpy, GLXContext ctx )
+{
+  Bool ret = False;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(ctx) };
+  do_opengl_call(glXIsDirect_func, &ret, args, NULL);
+  return ret;
+}
+
+GLAPI int APIENTRY glXGetConfig( Display *dpy, XVisualInfo *vis,
+                                 int attrib, int *value )
+{
+  int ret = 0;
+  int i, j;
+  if (vis == NULL || value == NULL) return 0;
+  LOCK(glXGetConfig_func);
+
+  int visualid = 0;
+  for(i=0;i<nEltTabAssocVisualInfoVisualId;i++)
+  {
+    if (vis == tabAssocVisualInfoVisualId[i].vis)
+    {
+      visualid = tabAssocVisualInfoVisualId[i].visualid;
+      if (debug_gl) log_gl("found visualid %d corresponding to vis %p\n", visualid, vis);
+      break;
+    }
+  }
+  if (i == nEltTabAssocVisualInfoVisualId)
+  {
+    if (debug_gl) log_gl("not found vis %p in table\n", vis);
+    visualid = vis->visualid;
+  }
+
+   /* Optimization */
+  for(i=0;i<nbConfigs;i++)
+  {
+    if (visualid == configs[i].visualid)
+    {
+      for(j=0;j<configs[i].nbAttribs;j++)
+      {
+        if (configs[i].attribs[j].attrib == attrib)
+        {
+          *value = configs[i].attribs[j].value;
+          ret = configs[i].attribs[j].ret;
+          if (debug_gl) log_gl("glXGetConfig(%s)=%d (%d)\n", _getAttribNameFromValue(attrib), *value, ret);
+          goto end_of_glx_get_config;
+        }
+      }
+      break;
+    }
+  }
+
+  if (i < N_MAX_CONFIGS)
+  {
+    if (i == nbConfigs)
+    {
+      configs[i].visualid = visualid;
+      configs[i].nbAttribs = 0;
+      int tabGottenValues[N_REQUESTED_ATTRIBS];
+      int tabGottenRes[N_REQUESTED_ATTRIBS];
+      if (debug_gl) log_gl("glXGetConfig_extended visual=%p\n", vis);
+      long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(visualid), INT_TO_ARG(N_REQUESTED_ATTRIBS),
+                      POINTER_TO_ARG(getTabRequestedAttribsInt()), POINTER_TO_ARG(tabGottenValues),
+                      POINTER_TO_ARG(tabGottenRes) };
+      int args_size[] = {0, 0, 0, N_REQUESTED_ATTRIBS*sizeof(int), N_REQUESTED_ATTRIBS*sizeof(int),
+                         N_REQUESTED_ATTRIBS*sizeof(int) };
+      do_opengl_call_no_lock(glXGetConfig_extended_func, NULL, CHECK_ARGS(args, args_size));
+
+      int j;
+      int found = 0;
+      int  jDblBuffer = -1, jUseGL = -1;
+      for(j=0;j<N_REQUESTED_ATTRIBS;j++)
+      {
+        if (GLX_USE_GL == tabRequestedAttribsPair[j].val)
+          jUseGL = j;
+        else if (GLX_DOUBLEBUFFER == tabRequestedAttribsPair[j].val)
+          jDblBuffer = j;
+        configs[i].attribs[j].attrib = tabRequestedAttribsPair[j].val;
+        configs[i].attribs[j].value = tabGottenValues[j];
+        configs[i].attribs[j].ret = tabGottenRes[j];
+        configs[i].nbAttribs++;
+        if (tabRequestedAttribsPair[j].val == attrib)
+        {
+          found = 1;
+          *value = configs[i].attribs[j].value;
+          ret = configs[i].attribs[j].ret;
+          if (debug_gl) log_gl("glXGetConfig(%s)=%d (%d)\n", tabRequestedAttribsPair[j].name, *value, ret);
+        }
+      }
+
+      if (getenv("DISABLE_DOUBLE_BUFFER"))
+      {
+        if (configs[i].attribs[jDblBuffer].value == 1)
+        {
+          if (attrib == GLX_USE_GL)
+            *value = 0;
+          configs[i].attribs[jUseGL].value = 0;
+        }
+      }
+
+      nbConfigs++;
+      if (found)
+        goto end_of_glx_get_config;
+    }
+
+    {
+      long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(visualid), INT_TO_ARG(attrib), POINTER_TO_ARG(value) };
+      do_opengl_call_no_lock(glXGetConfig_func, &ret, args, NULL);
+      if (debug_gl) log_gl("glXGetConfig visual=%p, attrib=%d -> %d\n", vis, attrib, *value);
+      if (configs[i].nbAttribs < N_MAX_ATTRIBS)
+      {
+        configs[i].attribs[configs[i].nbAttribs].attrib = attrib;
+        configs[i].attribs[configs[i].nbAttribs].value = *value;
+        configs[i].attribs[configs[i].nbAttribs].ret = ret;
+        configs[i].nbAttribs++;
+      }
+    }
+  }
+  else
+  {
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(visualid), INT_TO_ARG(attrib), POINTER_TO_ARG(value) };
+    do_opengl_call_no_lock(glXGetConfig_func, &ret, args, NULL);
+    if (debug_gl) log_gl("glXGetConfig visual=%p, attrib=%d -> %d\n", vis, attrib, *value);
+  }
+end_of_glx_get_config:
+  UNLOCK(glXGetConfig_func);
+  return ret;
+}
+
+void glXSwapBuffers_no_lock( Display *dpy, GLXDrawable drawable )
+{
+  //log_gl("glXSwapBuffers %d\n", drawable);
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(drawable) };
+  do_opengl_call_no_lock(glXSwapBuffers_func, NULL, args, NULL);
+
+  _update_renderer(dpy, drawable);
+}
+
+GLAPI void APIENTRY glXSwapBuffers( Display *dpy, GLXDrawable drawable )
+{
+  LOCK(glXSwapBuffers_func);
+  glXSwapBuffers_no_lock(dpy, drawable);
+  UNLOCK(glXSwapBuffers_func);
+}
+
+GLAPI Bool APIENTRY glXQueryExtension( Display *dpy, int *errorBase, int *eventBase )
+{
+  Bool ret;
+  LOCK(glXQueryExtension_func);
+  int fake_int;
+  if (errorBase == NULL) errorBase = &fake_int;
+  if (eventBase == NULL) eventBase = &fake_int;
+  long args[] = { POINTER_TO_ARG(dpy), POINTER_TO_ARG(errorBase), POINTER_TO_ARG(eventBase) };
+  do_opengl_call_no_lock(glXQueryExtension_func, &ret, args, NULL);
+  UNLOCK(glXQueryExtension_func);
+  return ret;
+}
+
+GLAPI void APIENTRY glXWaitGL (void)
+{
+  int ret;
+  do_opengl_call(glXWaitGL_func, &ret, NULL, NULL);
+}
+
+GLAPI void APIENTRY glXWaitX (void)
+{
+  int ret;
+  do_opengl_call(glXWaitX_func, &ret, NULL, NULL);
+}
+
+GLAPI Display* APIENTRY glXGetCurrentDisplay( void )
+{
+  GET_CURRENT_STATE();
+  return state->display;
+}
+
+static GLXFBConfig* glXChooseFBConfig_no_lock( Display *dpy, int screen,
+                                const int *attribList, int *nitems )
+{
+  CHECK_PROC_WITH_RET(glXChooseFBConfig);
+  GLXFBConfig* fbConfig = NULL;
+  if (debug_gl) log_gl("glXChooseFBConfig\n");
+  int i=0;
+  int ret = 0;
+  int emptyAttribList = None;
+  if (attribList == NULL) attribList = &emptyAttribList;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen), POINTER_TO_ARG(attribList), POINTER_TO_ARG(nitems) };
+  int args_size[] = { 0, 0, sizeof(int) * _compute_length_of_attrib_list_including_zero(attribList, 1), 0 };
+  do_opengl_call_no_lock(glXChooseFBConfig_func, &ret, args, args_size);
+  if (debug_gl) log_gl("nitems = %d\n", *nitems);
+  if (*nitems == 0)
+    return NULL;
+  fbConfig = malloc(sizeof(GLXFBConfig) * (*nitems));
+  for(i=0;i<*nitems;i++)
+  {
+    fbConfig[i] = (GLXFBConfig)(long)(ret + i);
+    if (debug_gl && (i == 0 || i == *nitems-1)) log_gl("config %d = %d\n", i, ret+i);
+  }
+  return fbConfig;
+}
+
+GLAPI GLXFBConfig* APIENTRY glXChooseFBConfig( Display *dpy, int screen,
+                                const int *attribList, int *nitems )
+{
+  GLXFBConfig* fbconfig;
+  LOCK(glXChooseFBConfig_func);
+  fbconfig = glXChooseFBConfig_no_lock(dpy, screen, attribList, nitems);
+  UNLOCK(glXChooseFBConfig_func);
+  return fbconfig;
+}
+
+GLAPI GLXFBConfig* APIENTRY glXGetFBConfigs( Display *dpy, int screen, int *nitems )
+{
+  CHECK_PROC_WITH_RET(glXGetFBConfigs);
+  if (debug_gl) log_gl("glXGetFBConfigs\n");
+  int i = 0;
+  GLXFBConfig* fbConfig;
+  int ret = 0;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen), POINTER_TO_ARG(nitems) };
+  do_opengl_call(glXGetFBConfigs_func, &ret, args, NULL);
+  if (debug_gl) log_gl("nitems = %d\n", *nitems);
+  fbConfig = malloc(sizeof(GLXFBConfig) * (*nitems));
+  for(i=0;i<*nitems;i++)
+  {
+    fbConfig[i] = (GLXFBConfig)(long)(ret + i);
+    if (debug_gl && (i == 0 || i == *nitems-1)) log_gl("config %d = %d\n", i, ret+i);
+  }
+  return fbConfig;
+}
+
+
+GLAPI int APIENTRY glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attrib, int *value)
+{
+  CHECK_PROC_WITH_RET(glXGetFBConfigAttrib);
+  LOCK(glXGetFBConfigAttrib_func);
+  int ret = 0;
+  int i, j;
+
+   /* Optimization */
+  for(i=0;i<nbFBConfigs;i++)
+  {
+    if (config == fbconfigs[i].config)
+    {
+      for(j=0;j<fbconfigs[i].nbAttribs;j++)
+      {
+        if (fbconfigs[i].attribs[j].attrib == attrib)
+        {
+          *value = fbconfigs[i].attribs[j].value;
+          ret = fbconfigs[i].attribs[j].ret;
+          if (debug_gl)
+          {
+            log_gl("glXGetFBConfigAttrib(config=%p,%s)=%d (%d)\n", config,
+                    _getAttribNameFromValue(attrib), *value, ret);
+          }
+          goto end_of_glx_get_fb_config_attrib;
+        }
+      }
+      break;
+    }
+  }
+
+  if (i < N_MAX_CONFIGS)
+  {
+    if (i == nbFBConfigs)
+    {
+      fbconfigs[i].config = config;
+      fbconfigs[i].nbAttribs = 0;
+      int tabGottenValues[N_REQUESTED_ATTRIBS];
+      int tabGottenRes[N_REQUESTED_ATTRIBS];
+      if (debug_gl) log_gl("glXGetFBConfigAttrib_extended config=%p\n", config);
+      long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(config), INT_TO_ARG(N_REQUESTED_ATTRIBS),
+                      POINTER_TO_ARG(getTabRequestedAttribsInt()), POINTER_TO_ARG(tabGottenValues),
+                      POINTER_TO_ARG(tabGottenRes) };
+      int args_size[] = {0, 0, 0, N_REQUESTED_ATTRIBS*sizeof(int), N_REQUESTED_ATTRIBS*sizeof(int),
+                         N_REQUESTED_ATTRIBS*sizeof(int) };
+      do_opengl_call_no_lock(glXGetFBConfigAttrib_extended_func, NULL, CHECK_ARGS(args, args_size));
+
+      int j;
+      int found = 0;
+      for(j=0;j<N_REQUESTED_ATTRIBS;j++)
+      {
+        if (tabRequestedAttribsPair[j].val == GLX_VISUAL_ID) {
+            // ignore the VISUAL_ID from QEMU host;
+            int screen = 0;
+            fbconfigs[i].attribs[j].attrib = GLX_VISUAL_ID;
+            fbconfigs[i].attribs[j].value = DefaultVisual(dpy, screen)->visualid;
+            fbconfigs[i].attribs[j].ret = 0;
+        } else if (tabRequestedAttribsPair[j].val == GLX_X_VISUAL_TYPE) {
+            fbconfigs[i].attribs[j].attrib = GLX_X_VISUAL_TYPE;
+            fbconfigs[i].attribs[j].value = GLX_TRUE_COLOR;
+            fbconfigs[i].attribs[j].ret = 0;
+        } else {
+            fbconfigs[i].attribs[j].attrib = tabRequestedAttribsPair[j].val;
+            fbconfigs[i].attribs[j].value = tabGottenValues[j];
+            fbconfigs[i].attribs[j].ret = tabGottenRes[j];
+        }
+        fbconfigs[i].nbAttribs++;
+        if (tabRequestedAttribsPair[j].val == attrib)
+        {
+          found = 1;
+          *value = fbconfigs[i].attribs[j].value;
+          ret = fbconfigs[i].attribs[j].ret;
+          if (debug_gl) log_gl("glXGetFBConfigAttrib(config=%p, %s)=%d (%d)\n",
+              config, tabRequestedAttribsPair[j].name, *value, ret);
+        }
+      }
+      nbFBConfigs++;
+      if (found)
+        goto end_of_glx_get_fb_config_attrib;
+    }
+
+    {
+      long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(config), INT_TO_ARG(attrib), POINTER_TO_ARG(value) };
+      do_opengl_call_no_lock(glXGetFBConfigAttrib_func, &ret, args, NULL);
+      if (debug_gl) log_gl("glXGetFBConfigAttrib config=%p, attrib=%d -> %d\n", config, attrib, *value);
+      if (fbconfigs[i].nbAttribs < N_MAX_ATTRIBS)
+      {
+        fbconfigs[i].attribs[fbconfigs[i].nbAttribs].attrib = attrib;
+        fbconfigs[i].attribs[fbconfigs[i].nbAttribs].value = *value;
+        fbconfigs[i].attribs[fbconfigs[i].nbAttribs].ret = ret;
+        fbconfigs[i].nbAttribs++;
+      }
+    }
+  }
+  else
+  {
+    if (attrib == GLX_VISUAL_ID) {
+        // get the visual id in guest os
+        int screen = 0;
+        *value = DefaultVisual(dpy, screen)->visualid;
+        ret = 0;
+    } else if (attrib == GLX_X_VISUAL_TYPE){
+        *value = GLX_TRUE_COLOR;
+        ret = 0;
+    } else {
+        long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(config), INT_TO_ARG(attrib), POINTER_TO_ARG(value) };
+        do_opengl_call_no_lock(glXGetFBConfigAttrib_func, &ret, args, NULL);
+        if (debug_gl) log_gl("glXGetFBConfigAttrib config=%p, attrib=%d -> %d\n", config, attrib, *value);
+    }
+  }
+end_of_glx_get_fb_config_attrib:
+  UNLOCK(glXGetFBConfigAttrib_func);
+  return ret;
+}
+
+GLAPI int APIENTRY glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value )
+{
+  CHECK_PROC_WITH_RET(glXQueryContext);
+  int ret = 0;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(ctx), INT_TO_ARG(attribute), POINTER_TO_ARG(value) };
+  do_opengl_call(glXQueryContext_func, &ret, args, NULL);
+  return ret;
+}
+
+GLAPI void APIENTRY glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute, unsigned int *value )
+{
+  CHECK_PROC(glXQueryDrawable);
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(draw), INT_TO_ARG(attribute), POINTER_TO_ARG(value) };
+  do_opengl_call(glXQueryDrawable_func, NULL, args, NULL);
+}
+
+static XVisualInfo* glXGetVisualFromFBConfig_no_lock( Display *dpy, GLXFBConfig config )
+{
+  CHECK_PROC_WITH_RET(glXGetVisualFromFBConfig);
+  int screen = 0;
+
+  if (debug_gl) log_gl("glXGetVisualFromFBConfig %p\n", (void*)config);
+
+  XVisualInfo temp, *vis;
+  long mask;
+  int n;
+  int i;
+
+  mask = VisualScreenMask | VisualDepthMask | VisualClassMask;
+  temp.screen = screen;
+  temp.depth = DefaultDepth(dpy,screen);
+  temp.class = DefaultVisual(dpy,screen)->class;
+  temp.visualid = DefaultVisual(dpy,screen)->visualid;
+  mask |= VisualIDMask;
+
+  vis = XGetVisualInfo( dpy, mask, &temp, &n );
+
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(config)};
+  int visualid;
+  do_opengl_call_no_lock(glXGetVisualFromFBConfig_func, &visualid, args, NULL);
+
+  vis->visualid = visualid;
+
+  assert (nEltTabAssocVisualInfoVisualId < MAX_SIZE_TAB_ASSOC_VISUALINFO_VISUALID);
+  for(i=0;i<nEltTabAssocVisualInfoVisualId;i++)
+  {
+    if (tabAssocVisualInfoVisualId[i].vis == vis) break;
+  }
+  if (i == nEltTabAssocVisualInfoVisualId)
+    nEltTabAssocVisualInfoVisualId++;
+  tabAssocVisualInfoVisualId[i].vis = vis;
+  tabAssocVisualInfoVisualId[i].fbconfig = config;
+  tabAssocVisualInfoVisualId[i].visualid = visualid;
+
+  if (debug_gl) log_gl("glXGetVisualFromFBConfig returning vis %p (visualid=%d, 0x%X)\n", vis, visualid, visualid);
+
+  return vis;
+}
+
+GLAPI XVisualInfo* APIENTRY glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config )
+{
+  XVisualInfo* vis;
+  LOCK(glXGetVisualFromFBConfig_func);
+  vis = glXGetVisualFromFBConfig_no_lock(dpy, config);
+  UNLOCK(glXGetVisualFromFBConfig_func);
+  return vis;
+}
+
+GLAPI GLXContext APIENTRY glXCreateNewContext(Display * dpy,
+                               GLXFBConfig  fbconfig,
+                               int  renderType,
+                               GLXContext  shareList,
+                               Bool  direct)
+{
+  CHECK_PROC_WITH_RET(glXCreateNewContext);
+  LOCK(glXCreateNewContext_func);
+  if (debug_gl) log_gl("glXCreateNewContext %p\n", (void*)fbconfig);
+
+  GLXContext ctxt;
+  long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(fbconfig), INT_TO_ARG(renderType), INT_TO_ARG(shareList),
+                    INT_TO_ARG(direct) };
+  do_opengl_call_no_lock(glXCreateNewContext_func, &ctxt, args, NULL);
+  if (ctxt)
+  {
+    _create_context(ctxt, shareList);
+  }
+  UNLOCK(glXCreateNewContext_func);
+  return ctxt;
+}
+
+GLAPI Bool APIENTRY glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
+                                           GLXDrawable read, GLXContext ctx )
+{
+  Bool ret;
+  GET_CURRENT_STATE();
+  if (draw != read)
+  {
+    static int first_time = 1;
+    if (first_time)
+    {
+      first_time = 0;
+      log_gl("using glXMakeCurrent instead of real glXMakeContextCurrent... may help some program work...\n");
+    }
+  }
+  ret = glXMakeCurrent(dpy, draw, ctx);
+  if (ret)
+    state->current_read_drawable = read;
+  return ret;
+}
+
+GLAPI GLXWindow APIENTRY glXCreateWindow( Display *dpy, GLXFBConfig config, Window win, const int *attribList )
+{
+  CHECK_PROC_WITH_RET(glXCreateWindow);
+  /* do nothing. Not sure about this implementation. FIXME */
+  fprintf(stderr, "createwindow?\n");
+  return win;
+}
+
+GLAPI void APIENTRY glXDestroyWindow( Display *dpy, GLXWindow window )
+{
+  CHECK_PROC(glXDestroyWindow);
+  /* do nothing. Not sure about this implementation. FIXME */
+}
+
+GLAPI GLXPixmap APIENTRY glXCreateGLXPixmap( Display *dpy,
+                              XVisualInfo *vis,
+                              Pixmap pixmap )
+{
+  CHECK_PROC_WITH_RET(glXCreateGLXPixmap);
+  /* FIXME */
+  log_gl("glXCreateGLXPixmap : sorry, unsupported call and I don't really see how I could implement it...");
+  return 0;
+}
+
+GLAPI void APIENTRY glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap )
+{
+  CHECK_PROC(glXDestroyGLXPixmap);
+  /* FIXME */
+  log_gl("glXDestroyGLXPixmap : sorry, unsupported call and I don't really see how I could implement it...");
+}
+
+GLAPI GLXPixmap APIENTRY glXCreatePixmap( Display *dpy, GLXFBConfig config,
+                                  Pixmap pixmap, const int *attribList )
+{
+  CHECK_PROC_WITH_RET(glXCreatePixmap);
+  /* FIXME */
+  log_gl("glXCreatePixmap : sorry, unsupported call and I don't really see how I could implement it...");
+  return 0;
+}
+
+GLAPI void APIENTRY glXDestroyPixmap( Display *dpy, GLXPixmap pixmap )
+{
+  CHECK_PROC(glXDestroyPixmap);
+  /* FIXME */
+  log_gl("glXDestroyPixmap : sorry, unsupported call and I don't really see how I could implement it...");
+}
+
+GLAPI GLXPbuffer APIENTRY glXCreatePbuffer( Display *dpy, GLXFBConfig config,
+                                            const int *attribList )
+{
+  CHECK_PROC_WITH_RET(glXCreatePbuffer);
+  /* FIXME */
+  log_gl("glXCreatePbuffer: sorry, unsupported call and I don't really see how I could implement it...");
+  return 0;
+}
+
+GLAPI void APIENTRY glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf )
+{
+  CHECK_PROC(glXDestroyPbuffer);
+  /* FIXME */
+  log_gl("glXDestroyPbuffer: sorry, unsupported call and I don't really see how I could implement it...");
+}
+
+GLAPI GLXDrawable APIENTRY glXGetCurrentReadDrawable( void )
+{
+  CHECK_PROC_WITH_RET(glXGetCurrentReadDrawable);
+  GET_CURRENT_STATE();
+  return state->current_read_drawable;
+}
+
+GLAPI void APIENTRY glXSelectEvent( Display *dpy, GLXDrawable drawable,
+                            unsigned long mask )
+{
+  CHECK_PROC(glXSelectEvent);
+  log_gl("glXSelectEvent : sorry, unsupported call");
+}
+
+GLAPI void APIENTRY glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
+                                 unsigned long *mask )
+{
+  CHECK_PROC(glXGetSelectedEvent);
+  log_gl("glXGetSelectedEvent : sorry, unsupported call");
+}
+
+
+#include "opengl_client_xfonts.c"
+
+GLAPI const char * APIENTRY EXT_FUNC(glXGetScreenDriver) (Display *dpy, int screen)
+{
+  static const char* ret = NULL;
+  LOCK(glXGetScreenDriver_func);
+  CHECK_PROC_WITH_RET(glXGetScreenDriver);
+  if (ret == NULL)
+  {
+    long args[] = { POINTER_TO_ARG(dpy), INT_TO_ARG(screen) };
+    do_opengl_call_no_lock(glXGetScreenDriver_func, &ret, args, NULL);
+    ret = strdup(ret);
+  }
+  UNLOCK(glXGetScreenDriver_func);
+  return ret;
+}
+
+GLAPI const char * APIENTRY EXT_FUNC(glXGetDriverConfig) (const char *drivername)
+{
+  static const char* ret = NULL;
+  CHECK_PROC_WITH_RET(glXGetDriverConfig);
+  long args[] = { POINTER_TO_ARG(drivername) };
+  if (ret) free((void*)ret);
+  do_opengl_call(glXGetDriverConfig_func, &ret, args, NULL);
+  ret = strdup(ret);
+  return ret;
+}
+
+/* For googleearth */
+static int counterSync = 0;
+
+GLAPI int APIENTRY EXT_FUNC(glXWaitVideoSyncSGI) ( int divisor, int remainder, unsigned int *count )
+{
+  CHECK_PROC_WITH_RET(glXWaitVideoSyncSGI);
+  //log_gl("glXWaitVideoSyncSGI %d %d\n", divisor, remainder);
+  *count = counterSync++; // FIXME ?
+  return 0;
+}
+
+GLAPI int APIENTRY EXT_FUNC(glXGetVideoSyncSGI)( unsigned int *count )
+{
+  CHECK_PROC_WITH_RET(glXGetVideoSyncSGI);
+  //log_gl("glXGetVideoSyncSGI\n");
+  *count = counterSync++; // FIXME ?
+  return 0;
+}
+
+GLAPI int APIENTRY EXT_FUNC(glXSwapIntervalSGI) ( int interval )
+{
+  CHECK_PROC_WITH_RET(glXSwapIntervalSGI);
+  long args[] = { INT_TO_ARG(interval) };
+  int ret = 0;
+  do_opengl_call(glXSwapIntervalSGI_func, &ret, args, NULL);
+  //log_gl("glXSwapIntervalSGI(%d) = %d\n", interval, ret);
+  return ret;
+}
+
+static unsigned int str_hash (const void* v)
+{
+  /* 31 bit hash function */
+  const signed char *p = v;
+  unsigned int h = *p;
+
+  if (h)
+    for (p += 1; *p != '\0'; p++)
+      h = (h << 5) - h + *p;
+
+  return h;
+}
+
+static const char* global_glXGetProcAddress_request =
+{
+"glAccum\0"
+"glActiveStencilFaceEXT\0"
+"glActiveTexture\0"
+"glActiveTextureARB\0"
+"glActiveVaryingNV\0"
+"glAddSwapHintRectWIN\0"
+"glAlphaFragmentOp1ATI\0"
+"glAlphaFragmentOp2ATI\0"
+"glAlphaFragmentOp3ATI\0"
+"glAlphaFunc\0"
+"glApplyTextureEXT\0"
+"glAreProgramsResidentNV\0"
+"glAreTexturesResident\0"
+"glAreTexturesResidentEXT\0"
+"glArrayElement\0"
+"glArrayElementEXT\0"
+"glArrayObjectATI\0"
+"glAsyncMarkerSGIX\0"
+"glAttachObjectARB\0"
+"glAttachShader\0"
+"glBegin\0"
+"glBeginConditionalRenderNVX\0"
+"glBeginDefineVisibilityQueryATI\0"
+"glBeginFragmentShaderATI\0"
+"glBeginOcclusionQuery\0"
+"glBeginOcclusionQueryNV\0"
+"glBeginQuery\0"
+"glBeginQueryARB\0"
+"glBeginSceneEXT\0"
+"glBeginTransformFeedbackNV\0"
+"glBeginUseVisibilityQueryATI\0"
+"glBeginVertexShaderEXT\0"
+"glBindArraySetARB\0"
+"glBindAttribLocation\0"
+"glBindAttribLocationARB\0"
+"glBindBuffer\0"
+"glBindBufferARB\0"
+"glBindBufferBaseNV\0"
+"glBindBufferOffsetNV\0"
+"glBindBufferRangeNV\0"
+"glBindFragDataLocationEXT\0"
+"glBindFragmentShaderATI\0"
+"glBindFramebufferEXT\0"
+"glBindLightParameterEXT\0"
+"glBindMaterialParameterEXT\0"
+"glBindParameterEXT\0"
+"glBindProgramARB\0"
+"glBindProgramNV\0"
+"glBindRenderbufferEXT\0"
+"glBindTexGenParameterEXT\0"
+"glBindTexture\0"
+"glBindTextureEXT\0"
+"glBindTextureUnitParameterEXT\0"
+"glBindVertexArrayAPPLE\0"
+"glBindVertexShaderEXT\0"
+"glBinormal3bEXT\0"
+"glBinormal3bvEXT\0"
+"glBinormal3dEXT\0"
+"glBinormal3dvEXT\0"
+"glBinormal3fEXT\0"
+"glBinormal3fvEXT\0"
+"glBinormal3iEXT\0"
+"glBinormal3ivEXT\0"
+"glBinormal3sEXT\0"
+"glBinormal3svEXT\0"
+"glBinormalArrayEXT\0"
+"glBitmap\0"
+"glBlendColor\0"
+"glBlendColorEXT\0"
+"glBlendEquation\0"
+"glBlendEquationEXT\0"
+"glBlendEquationSeparate\0"
+"glBlendEquationSeparateATI\0"
+"glBlendEquationSeparateEXT\0"
+"glBlendFunc\0"
+"glBlendFuncSeparate\0"
+"glBlendFuncSeparateEXT\0"
+"glBlendFuncSeparateINGR\0"
+"glBlitFramebufferEXT\0"
+"glBufferData\0"
+"glBufferDataARB\0"
+"glBufferParameteriAPPLE\0"
+"glBufferRegionEnabled\0"
+"glBufferRegionEnabledEXT\0"
+"glBufferSubData\0"
+"glBufferSubDataARB\0"
+"glCallList\0"
+"glCallLists\0"
+"glCheckFramebufferStatusEXT\0"
+"glClampColorARB\0"
+"glClear\0"
+"glClearAccum\0"
+"glClearColor\0"
+"glClearColorIiEXT\0"
+"glClearColorIuiEXT\0"
+"glClearDepth\0"
+"glClearDepthdNV\0"
+"glClearIndex\0"
+"glClearStencil\0"
+"glClientActiveTexture\0"
+"glClientActiveTextureARB\0"
+"glClientActiveVertexStreamATI\0"
+"glClipPlane\0"
+"glColor3b\0"
+"glColor3bv\0"
+"glColor3d\0"
+"glColor3dv\0"
+"glColor3f\0"
+"glColor3fv\0"
+"glColor3fVertex3fSUN\0"
+"glColor3fVertex3fvSUN\0"
+"glColor3hNV\0"
+"glColor3hvNV\0"
+"glColor3i\0"
+"glColor3iv\0"
+"glColor3s\0"
+"glColor3sv\0"
+"glColor3ub\0"
+"glColor3ubv\0"
+"glColor3ui\0"
+"glColor3uiv\0"
+"glColor3us\0"
+"glColor3usv\0"
+"glColor4b\0"
+"glColor4bv\0"
+"glColor4d\0"
+"glColor4dv\0"
+"glColor4f\0"
+"glColor4fNormal3fVertex3fSUN\0"
+"glColor4fNormal3fVertex3fvSUN\0"
+"glColor4fv\0"
+"glColor4hNV\0"
+"glColor4hvNV\0"
+"glColor4i\0"
+"glColor4iv\0"
+"glColor4s\0"
+"glColor4sv\0"
+"glColor4ub\0"
+"glColor4ubv\0"
+"glColor4ubVertex2fSUN\0"
+"glColor4ubVertex2fvSUN\0"
+"glColor4ubVertex3fSUN\0"
+"glColor4ubVertex3fvSUN\0"
+"glColor4ui\0"
+"glColor4uiv\0"
+"glColor4us\0"
+"glColor4usv\0"
+"glColorFragmentOp1ATI\0"
+"glColorFragmentOp2ATI\0"
+"glColorFragmentOp3ATI\0"
+"glColorMask\0"
+"glColorMaskIndexedEXT\0"
+"glColorMaterial\0"
+"glColorPointer\0"
+"glColorPointerEXT\0"
+"glColorPointerListIBM\0"
+"glColorPointervINTEL\0"
+"glColorSubTable\0"
+"glColorSubTableEXT\0"
+"glColorTable\0"
+"glColorTableEXT\0"
+"glColorTableParameterfv\0"
+"glColorTableParameterfvSGI\0"
+"glColorTableParameteriv\0"
+"glColorTableParameterivSGI\0"
+"glColorTableSGI\0"
+"glCombinerInputNV\0"
+"glCombinerOutputNV\0"
+"glCombinerParameterfNV\0"
+"glCombinerParameterfvNV\0"
+"glCombinerParameteriNV\0"
+"glCombinerParameterivNV\0"
+"glCombinerStageParameterfvNV\0"
+"glCompileShader\0"
+"glCompileShaderARB\0"
+"glCompressedTexImage1D\0"
+"glCompressedTexImage1DARB\0"
+"glCompressedTexImage2D\0"
+"glCompressedTexImage2DARB\0"
+"glCompressedTexImage3D\0"
+"glCompressedTexImage3DARB\0"
+"glCompressedTexSubImage1D\0"
+"glCompressedTexSubImage1DARB\0"
+"glCompressedTexSubImage2D\0"
+"glCompressedTexSubImage2DARB\0"
+"glCompressedTexSubImage3D\0"
+"glCompressedTexSubImage3DARB\0"
+"glConvolutionFilter1D\0"
+"glConvolutionFilter1DEXT\0"
+"glConvolutionFilter2D\0"
+"glConvolutionFilter2DEXT\0"
+"glConvolutionParameterf\0"
+"glConvolutionParameterfEXT\0"
+"glConvolutionParameterfv\0"
+"glConvolutionParameterfvEXT\0"
+"glConvolutionParameteri\0"
+"glConvolutionParameteriEXT\0"
+"glConvolutionParameteriv\0"
+"glConvolutionParameterivEXT\0"
+"glCopyColorSubTable\0"
+"glCopyColorSubTableEXT\0"
+"glCopyColorTable\0"
+"glCopyColorTableSGI\0"
+"glCopyConvolutionFilter1D\0"
+"glCopyConvolutionFilter1DEXT\0"
+"glCopyConvolutionFilter2D\0"
+"glCopyConvolutionFilter2DEXT\0"
+"glCopyPixels\0"
+"glCopyTexImage1D\0"
+"glCopyTexImage1DEXT\0"
+"glCopyTexImage2D\0"
+"glCopyTexImage2DEXT\0"
+"glCopyTexSubImage1D\0"
+"glCopyTexSubImage1DEXT\0"
+"glCopyTexSubImage2D\0"
+"glCopyTexSubImage2DEXT\0"
+"glCopyTexSubImage3D\0"
+"glCopyTexSubImage3DEXT\0"
+"glCreateProgram\0"
+"glCreateProgramObjectARB\0"
+"glCreateShader\0"
+"glCreateShaderObjectARB\0"
+"glCullFace\0"
+"glCullParameterdvEXT\0"
+"glCullParameterfvEXT\0"
+"glCurrentPaletteMatrixARB\0"
+"glDeformationMap3dSGIX\0"
+"glDeformationMap3fSGIX\0"
+"glDeformSGIX\0"
+"glDeleteArraySetsARB\0"
+"glDeleteAsyncMarkersSGIX\0"
+"glDeleteBufferRegion\0"
+"glDeleteBufferRegionEXT\0"
+"glDeleteBuffers\0"
+"glDeleteBuffersARB\0"
+"glDeleteFencesAPPLE\0"
+"glDeleteFencesNV\0"
+"glDeleteFragmentShaderATI\0"
+"glDeleteFramebuffersEXT\0"
+"glDeleteLists\0"
+"glDeleteObjectARB\0"
+"glDeleteObjectBufferATI\0"
+"glDeleteOcclusionQueries\0"
+"glDeleteOcclusionQueriesNV\0"
+"glDeleteProgram\0"
+"glDeleteProgramsARB\0"
+"glDeleteProgramsNV\0"
+"glDeleteQueries\0"
+"glDeleteQueriesARB\0"
+"glDeleteRenderbuffersEXT\0"
+"glDeleteShader\0"
+"glDeleteTextures\0"
+"glDeleteTexturesEXT\0"
+"glDeleteVertexArraysAPPLE\0"
+"glDeleteVertexShaderEXT\0"
+"glDeleteVisibilityQueriesATI\0"
+"glDepthBoundsdNV\0"
+"glDepthBoundsEXT\0"
+"glDepthFunc\0"
+"glDepthMask\0"
+"glDepthRange\0"
+"glDepthRangedNV\0"
+"glDetachObjectARB\0"
+"glDetachShader\0"
+"glDetailTexFuncSGIS\0"
+"glDisable\0"
+"glDisableClientState\0"
+"glDisableIndexedEXT\0"
+"glDisableVariantClientStateEXT\0"
+"glDisableVertexAttribAPPLE\0"
+"glDisableVertexAttribArray\0"
+"glDisableVertexAttribArrayARB\0"
+"glDrawArrays\0"
+"glDrawArraysEXT\0"
+"glDrawArraysInstancedEXT\0"
+"glDrawBuffer\0"
+"glDrawBufferRegion\0"
+"glDrawBufferRegionEXT\0"
+"glDrawBuffers\0"
+"glDrawBuffersARB\0"
+"glDrawBuffersATI\0"
+"glDrawElementArrayAPPLE\0"
+"glDrawElementArrayATI\0"
+"glDrawElements\0"
+"glDrawElementsFGL\0"
+"glDrawElementsInstancedEXT\0"
+"glDrawMeshArraysSUN\0"
+"glDrawMeshNV\0"
+"glDrawPixels\0"
+"glDrawRangeElementArrayAPPLE\0"
+"glDrawRangeElementArrayATI\0"
+"glDrawRangeElements\0"
+"glDrawRangeElementsEXT\0"
+"glDrawWireTrianglesFGL\0"
+"glEdgeFlag\0"
+"glEdgeFlagPointer\0"
+"glEdgeFlagPointerEXT\0"
+"glEdgeFlagPointerListIBM\0"
+"glEdgeFlagv\0"
+"glElementPointerAPPLE\0"
+"glElementPointerATI\0"
+"glEnable\0"
+"glEnableClientState\0"
+"glEnableIndexedEXT\0"
+"glEnableVariantClientStateEXT\0"
+"glEnableVertexAttribAPPLE\0"
+"glEnableVertexAttribArray\0"
+"glEnableVertexAttribArrayARB\0"
+"glEnd\0"
+"glEndConditionalRenderNVX\0"
+"glEndDefineVisibilityQueryATI\0"
+"glEndFragmentShaderATI\0"
+"glEndList\0"
+"glEndOcclusionQuery\0"
+"glEndOcclusionQueryNV\0"
+"glEndQuery\0"
+"glEndQueryARB\0"
+"glEndSceneEXT\0"
+"glEndTransformFeedbackNV\0"
+"glEndUseVisibilityQueryATI\0"
+"glEndVertexShaderEXT\0"
+"glEvalCoord1d\0"
+"glEvalCoord1dv\0"
+"glEvalCoord1f\0"
+"glEvalCoord1fv\0"
+"glEvalCoord2d\0"
+"glEvalCoord2dv\0"
+"glEvalCoord2f\0"
+"glEvalCoord2fv\0"
+"glEvalMapsNV\0"
+"glEvalMesh1\0"
+"glEvalMesh2\0"
+"glEvalPoint1\0"
+"glEvalPoint2\0"
+"glExecuteProgramNV\0"
+"glExtractComponentEXT\0"
+"glFeedbackBuffer\0"
+"glFinalCombinerInputNV\0"
+"glFinish\0"
+"glFinishAsyncSGIX\0"
+"glFinishFenceAPPLE\0"
+"glFinishFenceNV\0"
+"glFinishObjectAPPLE\0"
+"glFinishRenderAPPLE\0"
+"glFinishTextureSUNX\0"
+"glFlush\0"
+"glFlushMappedBufferRangeAPPLE\0"
+"glFlushPixelDataRangeNV\0"
+"glFlushRasterSGIX\0"
+"glFlushRenderAPPLE\0"
+"glFlushVertexArrayRangeAPPLE\0"
+"glFlushVertexArrayRangeNV\0"
+"glFogCoordd\0"
+"glFogCoorddEXT\0"
+"glFogCoorddv\0"
+"glFogCoorddvEXT\0"
+"glFogCoordf\0"
+"glFogCoordfEXT\0"
+"glFogCoordfv\0"
+"glFogCoordfvEXT\0"
+"glFogCoordhNV\0"
+"glFogCoordhvNV\0"
+"glFogCoordPointer\0"
+"glFogCoordPointerEXT\0"
+"glFogCoordPointerListIBM\0"
+"glFogf\0"
+"glFogFuncSGIS\0"
+"glFogfv\0"
+"glFogi\0"
+"glFogiv\0"
+"glFragmentColorMaterialEXT\0"
+"glFragmentColorMaterialSGIX\0"
+"glFragmentLightfEXT\0"
+"glFragmentLightfSGIX\0"
+"glFragmentLightfvEXT\0"
+"glFragmentLightfvSGIX\0"
+"glFragmentLightiEXT\0"
+"glFragmentLightiSGIX\0"
+"glFragmentLightivEXT\0"
+"glFragmentLightivSGIX\0"
+"glFragmentLightModelfEXT\0"
+"glFragmentLightModelfSGIX\0"
+"glFragmentLightModelfvEXT\0"
+"glFragmentLightModelfvSGIX\0"
+"glFragmentLightModeliEXT\0"
+"glFragmentLightModeliSGIX\0"
+"glFragmentLightModelivEXT\0"
+"glFragmentLightModelivSGIX\0"
+"glFragmentMaterialfEXT\0"
+"glFragmentMaterialfSGIX\0"
+"glFragmentMaterialfvEXT\0"
+"glFragmentMaterialfvSGIX\0"
+"glFragmentMaterialiEXT\0"
+"glFragmentMaterialiSGIX\0"
+"glFragmentMaterialivEXT\0"
+"glFragmentMaterialivSGIX\0"
+"glFramebufferRenderbufferEXT\0"
+"glFramebufferTexture1DEXT\0"
+"glFramebufferTexture2DEXT\0"
+"glFramebufferTexture2D\0"
+"glFramebufferTexture3DEXT\0"
+"glFramebufferTextureEXT\0"
+"glFramebufferTextureFaceEXT\0"
+"glFramebufferTextureLayerEXT\0"
+"glFrameZoomSGIX\0"
+"glFreeObjectBufferATI\0"
+"glFrontFace\0"
+"glFrustum\0"
+"glGenArraySetsARB\0"
+"glGenAsyncMarkersSGIX\0"
+"glGenBuffers\0"
+"glGenBuffersARB\0"
+"glGenerateMipmapEXT\0"
+"glGenFencesAPPLE\0"
+"glGenFencesNV\0"
+"glGenFragmentShadersATI\0"
+"glGenFramebuffersEXT\0"
+"glGenLists\0"
+"glGenOcclusionQueries\0"
+"glGenOcclusionQueriesNV\0"
+"glGenProgramsARB\0"
+"glGenProgramsNV\0"
+"glGenQueries\0"
+"glGenQueriesARB\0"
+"glGenRenderbuffersEXT\0"
+"glGenSymbolsEXT\0"
+"glGenTextures\0"
+"glGenTexturesEXT\0"
+"glGenVertexArraysAPPLE\0"
+"glGenVertexShadersEXT\0"
+"glGenVisibilityQueriesATI\0"
+"glGetActiveAttrib\0"
+"glGetActiveAttribARB\0"
+"glGetActiveUniform\0"
+"glGetActiveUniformARB\0"
+"glGetActiveVaryingNV\0"
+"glGetArrayObjectfvATI\0"
+"glGetArrayObjectivATI\0"
+"glGetAttachedObjectsARB\0"
+"glGetAttachedShaders\0"
+"glGetAttribLocation\0"
+"glGetAttribLocationARB\0"
+"glGetBooleanIndexedvEXT\0"
+"glGetBooleanv\0"
+"glGetBufferParameteriv\0"
+"glGetBufferParameterivARB\0"
+"glGetBufferPointerv\0"
+"glGetBufferPointervARB\0"
+"glGetBufferSubData\0"
+"glGetBufferSubDataARB\0"
+"glGetClipPlane\0"
+"glGetColorTable\0"
+"glGetColorTableEXT\0"
+"glGetColorTableParameterfv\0"
+"glGetColorTableParameterfvEXT\0"
+"glGetColorTableParameterfvSGI\0"
+"glGetColorTableParameteriv\0"
+"glGetColorTableParameterivEXT\0"
+"glGetColorTableParameterivSGI\0"
+"glGetColorTableSGI\0"
+"glGetCombinerInputParameterfvNV\0"
+"glGetCombinerInputParameterivNV\0"
+"glGetCombinerOutputParameterfvNV\0"
+"glGetCombinerOutputParameterivNV\0"
+"glGetCombinerStageParameterfvNV\0"
+"glGetCompressedTexImage\0"
+"glGetCompressedTexImageARB\0"
+"glGetConvolutionFilter\0"
+"glGetConvolutionFilterEXT\0"
+"glGetConvolutionParameterfv\0"
+"glGetConvolutionParameterfvEXT\0"
+"glGetConvolutionParameteriv\0"
+"glGetConvolutionParameterivEXT\0"
+"glGetDetailTexFuncSGIS\0"
+"glGetDoublev\0"
+"glGetError\0"
+"glGetFenceivNV\0"
+"glGetFinalCombinerInputParameterfvNV\0"
+"glGetFinalCombinerInputParameterivNV\0"
+"glGetFloatv\0"
+"glGetFogFuncSGIS\0"
+"glGetFragDataLocationEXT\0"
+"glGetFragmentLightfvEXT\0"
+"glGetFragmentLightfvSGIX\0"
+"glGetFragmentLightivEXT\0"
+"glGetFragmentLightivSGIX\0"
+"glGetFragmentMaterialfvEXT\0"
+"glGetFragmentMaterialfvSGIX\0"
+"glGetFragmentMaterialivEXT\0"
+"glGetFragmentMaterialivSGIX\0"
+"glGetFramebufferAttachmentParameterivEXT\0"
+"glGetHandleARB\0"
+"glGetHistogram\0"
+"glGetHistogramEXT\0"
+"glGetHistogramParameterfv\0"
+"glGetHistogramParameterfvEXT\0"
+"glGetHistogramParameteriv\0"
+"glGetHistogramParameterivEXT\0"
+"glGetImageTransformParameterfvHP\0"
+"glGetImageTransformParameterivHP\0"
+"glGetInfoLogARB\0"
+"glGetInstrumentsSGIX\0"
+"glGetIntegerIndexedvEXT\0"
+"glGetIntegerv\0"
+"glGetInvariantBooleanvEXT\0"
+"glGetInvariantFloatvEXT\0"
+"glGetInvariantIntegervEXT\0"
+"glGetLightfv\0"
+"glGetLightiv\0"
+"glGetListParameterfvSGIX\0"
+"glGetListParameterivSGIX\0"
+"glGetLocalConstantBooleanvEXT\0"
+"glGetLocalConstantFloatvEXT\0"
+"glGetLocalConstantIntegervEXT\0"
+"glGetMapAttribParameterfvNV\0"
+"glGetMapAttribParameterivNV\0"
+"glGetMapControlPointsNV\0"
+"glGetMapdv\0"
+"glGetMapfv\0"
+"glGetMapiv\0"
+"glGetMapParameterfvNV\0"
+"glGetMapParameterivNV\0"
+"glGetMaterialfv\0"
+"glGetMaterialiv\0"
+"glGetMinmax\0"
+"glGetMinmaxEXT\0"
+"glGetMinmaxParameterfv\0"
+"glGetMinmaxParameterfvEXT\0"
+"glGetMinmaxParameteriv\0"
+"glGetMinmaxParameterivEXT\0"
+"glGetObjectBufferfvATI\0"
+"glGetObjectBufferivATI\0"
+"glGetObjectParameterfvARB\0"
+"glGetObjectParameterivARB\0"
+"glGetOcclusionQueryiv\0"
+"glGetOcclusionQueryivNV\0"
+"glGetOcclusionQueryuiv\0"
+"glGetOcclusionQueryuivNV\0"
+"glGetPixelMapfv\0"
+"glGetPixelMapuiv\0"
+"glGetPixelMapusv\0"
+"glGetPixelTexGenParameterfvSGIS\0"
+"glGetPixelTexGenParameterivSGIS\0"
+"glGetPixelTransformParameterfvEXT\0"
+"glGetPixelTransformParameterivEXT\0"
+"glGetPointerv\0"
+"glGetPointervEXT\0"
+"glGetPolygonStipple\0"
+"glGetProgramEnvParameterdvARB\0"
+"glGetProgramEnvParameterfvARB\0"
+"glGetProgramEnvParameterIivNV\0"
+"glGetProgramEnvParameterIuivNV\0"
+"glGetProgramInfoLog\0"
+"glGetProgramiv\0"
+"glGetProgramivARB\0"
+"glGetProgramivNV\0"
+"glGetProgramLocalParameterdvARB\0"
+"glGetProgramLocalParameterfvARB\0"
+"glGetProgramLocalParameterIivNV\0"
+"glGetProgramLocalParameterIuivNV\0"
+"glGetProgramNamedParameterdvNV\0"
+"glGetProgramNamedParameterfvNV\0"
+"glGetProgramParameterdvNV\0"
+"glGetProgramParameterfvNV\0"
+"glGetProgramRegisterfvMESA\0"
+"glGetProgramStringARB\0"
+"glGetProgramStringNV\0"
+"glGetQueryiv\0"
+"glGetQueryivARB\0"
+"glGetQueryObjecti64vEXT\0"
+"glGetQueryObjectiv\0"
+"glGetQueryObjectivARB\0"
+"glGetQueryObjectui64vEXT\0"
+"glGetQueryObjectuiv\0"
+"glGetQueryObjectuivARB\0"
+"glGetRenderbufferParameterivEXT\0"
+"glGetSeparableFilter\0"
+"glGetSeparableFilterEXT\0"
+"glGetShaderInfoLog\0"
+"glGetShaderiv\0"
+"glGetShaderSource\0"
+"glGetShaderSourceARB\0"
+"glGetSharpenTexFuncSGIS\0"
+"glGetString\0"
+"glGetTexBumpParameterfvATI\0"
+"glGetTexBumpParameterivATI\0"
+"glGetTexEnvfv\0"
+"glGetTexEnviv\0"
+"glGetTexFilterFuncSGIS\0"
+"glGetTexGendv\0"
+"glGetTexGenfv\0"
+"glGetTexGeniv\0"
+"glGetTexImage\0"
+"glGetTexLevelParameterfv\0"
+"glGetTexLevelParameteriv\0"
+"glGetTexParameterfv\0"
+"glGetTexParameterIivEXT\0"
+"glGetTexParameterIuivEXT\0"
+"glGetTexParameteriv\0"
+"glGetTexParameterPointervAPPLE\0"
+"glGetTrackMatrixivNV\0"
+"glGetTransformFeedbackVaryingNV\0"
+"glGetUniformBufferSizeEXT\0"
+"glGetUniformfv\0"
+"glGetUniformfvARB\0"
+"glGetUniformiv\0"
+"glGetUniformivARB\0"
+"glGetUniformLocation\0"
+"glGetUniformLocationARB\0"
+"glGetUniformOffsetEXT\0"
+"glGetUniformuivEXT\0"
+"glGetVariantArrayObjectfvATI\0"
+"glGetVariantArrayObjectivATI\0"
+"glGetVariantBooleanvEXT\0"
+"glGetVariantFloatvEXT\0"
+"glGetVariantIntegervEXT\0"
+"glGetVariantPointervEXT\0"
+"glGetVaryingLocationNV\0"
+"glGetVertexAttribArrayObjectfvATI\0"
+"glGetVertexAttribArrayObjectivATI\0"
+"glGetVertexAttribdv\0"
+"glGetVertexAttribdvARB\0"
+"glGetVertexAttribdvNV\0"
+"glGetVertexAttribfv\0"
+"glGetVertexAttribfvARB\0"
+"glGetVertexAttribfvNV\0"
+"glGetVertexAttribIivEXT\0"
+"glGetVertexAttribIuivEXT\0"
+"glGetVertexAttribiv\0"
+"glGetVertexAttribivARB\0"
+"glGetVertexAttribivNV\0"
+"glGetVertexAttribPointerv\0"
+"glGetVertexAttribPointervARB\0"
+"glGetVertexAttribPointervNV\0"
+"glGlobalAlphaFactorbSUN\0"
+"glGlobalAlphaFactordSUN\0"
+"glGlobalAlphaFactorfSUN\0"
+"glGlobalAlphaFactoriSUN\0"
+"glGlobalAlphaFactorsSUN\0"
+"glGlobalAlphaFactorubSUN\0"
+"glGlobalAlphaFactoruiSUN\0"
+"glGlobalAlphaFactorusSUN\0"
+"glHint\0"
+"glHintPGI\0"
+"glHistogram\0"
+"glHistogramEXT\0"
+"glIglooInterfaceSGIX\0"
+"glImageTransformParameterfHP\0"
+"glImageTransformParameterfvHP\0"
+"glImageTransformParameteriHP\0"
+"glImageTransformParameterivHP\0"
+"glIndexd\0"
+"glIndexdv\0"
+"glIndexf\0"
+"glIndexFuncEXT\0"
+"glIndexfv\0"
+"glIndexi\0"
+"glIndexiv\0"
+"glIndexMask\0"
+"glIndexMaterialEXT\0"
+"glIndexPointer\0"
+"glIndexPointerEXT\0"
+"glIndexPointerListIBM\0"
+"glIndexs\0"
+"glIndexsv\0"
+"glIndexub\0"
+"glIndexubv\0"
+"glInitNames\0"
+"glInsertComponentEXT\0"
+"glInstrumentsBufferSGIX\0"
+"glInterleavedArrays\0"
+"glIsArraySetARB\0"
+"glIsAsyncMarkerSGIX\0"
+"glIsBuffer\0"
+"glIsBufferARB\0"
+"glIsEnabled\0"
+"glIsEnabledIndexedEXT\0"
+"glIsFenceAPPLE\0"
+"glIsFenceNV\0"
+"glIsFramebufferEXT\0"
+"glIsList\0"
+"glIsObjectBufferATI\0"
+"glIsOcclusionQuery\0"
+"_glIsOcclusionQueryNV\0"
+"glIsOcclusionQueryNV\0"
+"glIsProgram\0"
+"glIsProgramARB\0"
+"glIsProgramNV\0"
+"glIsQuery\0"
+"glIsQueryARB\0"
+"glIsRenderbufferEXT\0"
+"glIsShader\0"
+"glIsTexture\0"
+"glIsTextureEXT\0"
+"glIsVariantEnabledEXT\0"
+"glIsVertexArrayAPPLE\0"
+"glIsVertexAttribEnabledAPPLE\0"
+"glLightEnviEXT\0"
+"glLightEnviSGIX\0"
+"glLightf\0"
+"glLightfv\0"
+"glLighti\0"
+"glLightiv\0"
+"glLightModelf\0"
+"glLightModelfv\0"
+"glLightModeli\0"
+"glLightModeliv\0"
+"glLineStipple\0"
+"glLineWidth\0"
+"glLinkProgram\0"
+"glLinkProgramARB\0"
+"glListBase\0"
+"glListParameterfSGIX\0"
+"glListParameterfvSGIX\0"
+"glListParameteriSGIX\0"
+"glListParameterivSGIX\0"
+"glLoadIdentity\0"
+"glLoadIdentityDeformationMapSGIX\0"
+"glLoadMatrixd\0"
+"glLoadMatrixf\0"
+"glLoadName\0"
+"glLoadProgramNV\0"
+"glLoadTransposeMatrixd\0"
+"glLoadTransposeMatrixdARB\0"
+"glLoadTransposeMatrixf\0"
+"glLoadTransposeMatrixfARB\0"
+"glLockArraysEXT\0"
+"glLogicOp\0"
+"glMap1d\0"
+"glMap1f\0"
+"glMap2d\0"
+"glMap2f\0"
+"glMapBuffer\0"
+"glMapBufferARB\0"
+"glMapControlPointsNV\0"
+"glMapGrid1d\0"
+"glMapGrid1f\0"
+"glMapGrid2d\0"
+"glMapGrid2f\0"
+"glMapObjectBufferATI\0"
+"glMapParameterfvNV\0"
+"glMapParameterivNV\0"
+"glMapTexture3DATI\0"
+"glMapVertexAttrib1dAPPLE\0"
+"glMapVertexAttrib1fAPPLE\0"
+"glMapVertexAttrib2dAPPLE\0"
+"glMapVertexAttrib2fAPPLE\0"
+"glMaterialf\0"
+"glMaterialfv\0"
+"glMateriali\0"
+"glMaterialiv\0"
+"glMatrixIndexPointerARB\0"
+"glMatrixIndexubvARB\0"
+"glMatrixIndexuivARB\0"
+"glMatrixIndexusvARB\0"
+"glMatrixMode\0"
+"glMinmax\0"
+"glMinmaxEXT\0"
+"glMultiDrawArrays\0"
+"glMultiDrawArraysEXT\0"
+"glMultiDrawElementArrayAPPLE\0"
+"glMultiDrawElements\0"
+"glMultiDrawElementsEXT\0"
+"glMultiDrawRangeElementArrayAPPLE\0"
+"glMultiModeDrawArraysIBM\0"
+"glMultiModeDrawElementsIBM\0"
+"glMultiTexCoord1d\0"
+"glMultiTexCoord1dARB\0"
+"glMultiTexCoord1dSGIS\0"
+"glMultiTexCoord1dv\0"
+"glMultiTexCoord1dvARB\0"
+"glMultiTexCoord1dvSGIS\0"
+"glMultiTexCoord1f\0"
+"glMultiTexCoord1fARB\0"
+"glMultiTexCoord1fSGIS\0"
+"glMultiTexCoord1fv\0"
+"glMultiTexCoord1fvARB\0"
+"glMultiTexCoord1fvSGIS\0"
+"glMultiTexCoord1hNV\0"
+"glMultiTexCoord1hvNV\0"
+"glMultiTexCoord1i\0"
+"glMultiTexCoord1iARB\0"
+"glMultiTexCoord1iSGIS\0"
+"glMultiTexCoord1iv\0"
+"glMultiTexCoord1ivARB\0"
+"glMultiTexCoord1ivSGIS\0"
+"glMultiTexCoord1s\0"
+"glMultiTexCoord1sARB\0"
+"glMultiTexCoord1sSGIS\0"
+"glMultiTexCoord1sv\0"
+"glMultiTexCoord1svARB\0"
+"glMultiTexCoord1svSGIS\0"
+"glMultiTexCoord2d\0"
+"glMultiTexCoord2dARB\0"
+"glMultiTexCoord2dSGIS\0"
+"glMultiTexCoord2dv\0"
+"glMultiTexCoord2dvARB\0"
+"glMultiTexCoord2dvSGIS\0"
+"glMultiTexCoord2f\0"
+"glMultiTexCoord2fARB\0"
+"glMultiTexCoord2fSGIS\0"
+"glMultiTexCoord2fv\0"
+"glMultiTexCoord2fvARB\0"
+"glMultiTexCoord2fvSGIS\0"
+"glMultiTexCoord2hNV\0"
+"glMultiTexCoord2hvNV\0"
+"glMultiTexCoord2i\0"
+"glMultiTexCoord2iARB\0"
+"glMultiTexCoord2iSGIS\0"
+"glMultiTexCoord2iv\0"
+"glMultiTexCoord2ivARB\0"
+"glMultiTexCoord2ivSGIS\0"
+"glMultiTexCoord2s\0"
+"glMultiTexCoord2sARB\0"
+"glMultiTexCoord2sSGIS\0"
+"glMultiTexCoord2sv\0"
+"glMultiTexCoord2svARB\0"
+"glMultiTexCoord2svSGIS\0"
+"glMultiTexCoord3d\0"
+"glMultiTexCoord3dARB\0"
+"glMultiTexCoord3dSGIS\0"
+"glMultiTexCoord3dv\0"
+"glMultiTexCoord3dvARB\0"
+"glMultiTexCoord3dvSGIS\0"
+"glMultiTexCoord3f\0"
+"glMultiTexCoord3fARB\0"
+"glMultiTexCoord3fSGIS\0"
+"glMultiTexCoord3fv\0"
+"glMultiTexCoord3fvARB\0"
+"glMultiTexCoord3fvSGIS\0"
+"glMultiTexCoord3hNV\0"
+"glMultiTexCoord3hvNV\0"
+"glMultiTexCoord3i\0"
+"glMultiTexCoord3iARB\0"
+"glMultiTexCoord3iSGIS\0"
+"glMultiTexCoord3iv\0"
+"glMultiTexCoord3ivARB\0"
+"glMultiTexCoord3ivSGIS\0"
+"glMultiTexCoord3s\0"
+"glMultiTexCoord3sARB\0"
+"glMultiTexCoord3sSGIS\0"
+"glMultiTexCoord3sv\0"
+"glMultiTexCoord3svARB\0"
+"glMultiTexCoord3svSGIS\0"
+"glMultiTexCoord4d\0"
+"glMultiTexCoord4dARB\0"
+"glMultiTexCoord4dSGIS\0"
+"glMultiTexCoord4dv\0"
+"glMultiTexCoord4dvARB\0"
+"glMultiTexCoord4dvSGIS\0"
+"glMultiTexCoord4f\0"
+"glMultiTexCoord4fARB\0"
+"glMultiTexCoord4fSGIS\0"
+"glMultiTexCoord4fv\0"
+"glMultiTexCoord4fvARB\0"
+"glMultiTexCoord4fvSGIS\0"
+"glMultiTexCoord4hNV\0"
+"glMultiTexCoord4hvNV\0"
+"glMultiTexCoord4i\0"
+"glMultiTexCoord4iARB\0"
+"glMultiTexCoord4iSGIS\0"
+"glMultiTexCoord4iv\0"
+"glMultiTexCoord4ivARB\0"
+"glMultiTexCoord4ivSGIS\0"
+"glMultiTexCoord4s\0"
+"glMultiTexCoord4sARB\0"
+"glMultiTexCoord4sSGIS\0"
+"glMultiTexCoord4sv\0"
+"glMultiTexCoord4svARB\0"
+"glMultiTexCoord4svSGIS\0"
+"glMultiTexCoordPointerSGIS\0"
+"glMultMatrixd\0"
+"glMultMatrixf\0"
+"glMultTransposeMatrixd\0"
+"glMultTransposeMatrixdARB\0"
+"glMultTransposeMatrixf\0"
+"glMultTransposeMatrixfARB\0"
+"glNewBufferRegion\0"
+"glNewBufferRegionEXT\0"
+"glNewList\0"
+"glNewObjectBufferATI\0"
+"glNormal3b\0"
+"glNormal3bv\0"
+"glNormal3d\0"
+"glNormal3dv\0"
+"glNormal3f\0"
+"glNormal3fv\0"
+"glNormal3fVertex3fSUN\0"
+"glNormal3fVertex3fvSUN\0"
+"glNormal3hNV\0"
+"glNormal3hvNV\0"
+"glNormal3i\0"
+"glNormal3iv\0"
+"glNormal3s\0"
+"glNormal3sv\0"
+"glNormalPointer\0"
+"glNormalPointerEXT\0"
+"glNormalPointerListIBM\0"
+"glNormalPointervINTEL\0"
+"glNormalStream3bATI\0"
+"glNormalStream3bvATI\0"
+"glNormalStream3dATI\0"
+"glNormalStream3dvATI\0"
+"glNormalStream3fATI\0"
+"glNormalStream3fvATI\0"
+"glNormalStream3iATI\0"
+"glNormalStream3ivATI\0"
+"glNormalStream3sATI\0"
+"glNormalStream3svATI\0"
+"glOrtho\0"
+"glPassTexCoordATI\0"
+"glPassThrough\0"
+"glPixelDataRangeNV\0"
+"glPixelMapfv\0"
+"glPixelMapuiv\0"
+"glPixelMapusv\0"
+"glPixelStoref\0"
+"glPixelStorei\0"
+"glPixelTexGenParameterfSGIS\0"
+"glPixelTexGenParameterfvSGIS\0"
+"glPixelTexGenParameteriSGIS\0"
+"glPixelTexGenParameterivSGIS\0"
+"glPixelTexGenSGIX\0"
+"glPixelTransferf\0"
+"glPixelTransferi\0"
+"glPixelTransformParameterfEXT\0"
+"glPixelTransformParameterfvEXT\0"
+"glPixelTransformParameteriEXT\0"
+"glPixelTransformParameterivEXT\0"
+"glPixelZoom\0"
+"glPNTrianglesfATI\0"
+"glPNTrianglesiATI\0"
+"glPointParameterf\0"
+"glPointParameterfARB\0"
+"glPointParameterfEXT\0"
+"glPointParameterfSGIS\0"
+"glPointParameterfv\0"
+"glPointParameterfvARB\0"
+"glPointParameterfvEXT\0"
+"glPointParameterfvSGIS\0"
+"glPointParameteri\0"
+"glPointParameteriEXT\0"
+"glPointParameteriNV\0"
+"glPointParameteriv\0"
+"glPointParameterivEXT\0"
+"glPointParameterivNV\0"
+"glPointSize\0"
+"glPollAsyncSGIX\0"
+"glPollInstrumentsSGIX\0"
+"glPolygonMode\0"
+"glPolygonOffset\0"
+"glPolygonOffsetEXT\0"
+"glPolygonStipple\0"
+"glPopAttrib\0"
+"glPopClientAttrib\0"
+"glPopMatrix\0"
+"glPopName\0"
+"glPrimitiveRestartIndexNV\0"
+"glPrimitiveRestartNV\0"
+"glPrioritizeTextures\0"
+"glPrioritizeTexturesEXT\0"
+"glProgramBufferParametersfvNV\0"
+"glProgramBufferParametersIivNV\0"
+"glProgramBufferParametersIuivNV\0"
+"glProgramCallbackMESA\0"
+"glProgramEnvParameter4dARB\0"
+"glProgramEnvParameter4dvARB\0"
+"glProgramEnvParameter4fARB\0"
+"glProgramEnvParameter4fvARB\0"
+"glProgramEnvParameterI4iNV\0"
+"glProgramEnvParameterI4ivNV\0"
+"glProgramEnvParameterI4uiNV\0"
+"glProgramEnvParameterI4uivNV\0"
+"glProgramEnvParameters4fvEXT\0"
+"glProgramEnvParametersI4ivNV\0"
+"glProgramEnvParametersI4uivNV\0"
+"glProgramLocalParameter4dARB\0"
+"glProgramLocalParameter4dvARB\0"
+"glProgramLocalParameter4fARB\0"
+"glProgramLocalParameter4fvARB\0"
+"glProgramLocalParameterI4iNV\0"
+"glProgramLocalParameterI4ivNV\0"
+"glProgramLocalParameterI4uiNV\0"
+"glProgramLocalParameterI4uivNV\0"
+"glProgramLocalParameters4fvEXT\0"
+"glProgramLocalParametersI4ivNV\0"
+"glProgramLocalParametersI4uivNV\0"
+"glProgramNamedParameter4dNV\0"
+"glProgramNamedParameter4dvNV\0"
+"glProgramNamedParameter4fNV\0"
+"glProgramNamedParameter4fvNV\0"
+"glProgramParameter4dNV\0"
+"glProgramParameter4dvNV\0"
+"glProgramParameter4fNV\0"
+"glProgramParameter4fvNV\0"
+"glProgramParameteriEXT\0"
+"glProgramParameters4dvNV\0"
+"glProgramParameters4fvNV\0"
+"glProgramStringARB\0"
+"glProgramVertexLimitNV\0"
+"glPushAttrib\0"
+"glPushClientAttrib\0"
+"glPushMatrix\0"
+"glPushName\0"
+"glRasterPos2d\0"
+"glRasterPos2dv\0"
+"glRasterPos2f\0"
+"glRasterPos2fv\0"
+"glRasterPos2i\0"
+"glRasterPos2iv\0"
+"glRasterPos2s\0"
+"glRasterPos2sv\0"
+"glRasterPos3d\0"
+"glRasterPos3dv\0"
+"glRasterPos3f\0"
+"glRasterPos3fv\0"
+"glRasterPos3i\0"
+"glRasterPos3iv\0"
+"glRasterPos3s\0"
+"glRasterPos3sv\0"
+"glRasterPos4d\0"
+"glRasterPos4dv\0"
+"glRasterPos4f\0"
+"glRasterPos4fv\0"
+"glRasterPos4i\0"
+"glRasterPos4iv\0"
+"glRasterPos4s\0"
+"glRasterPos4sv\0"
+"glReadBuffer\0"
+"glReadBufferRegion\0"
+"glReadBufferRegionEXT\0"
+"glReadInstrumentsSGIX\0"
+"glReadPixels\0"
+"glReadVideoPixelsSUN\0"
+"glRectd\0"
+"glRectdv\0"
+"glRectf\0"
+"glRectfv\0"
+"glRecti\0"
+"glRectiv\0"
+"glRects\0"
+"glRectsv\0"
+"glReferencePlaneSGIX\0"
+"glRenderbufferStorageEXT\0"
+"glRenderbufferStorageMultisampleCoverageNV\0"
+"glRenderbufferStorageMultisampleEXT\0"
+"glRenderMode\0"
+"glReplacementCodePointerSUN\0"
+"glReplacementCodeubSUN\0"
+"glReplacementCodeubvSUN\0"
+"glReplacementCodeuiColor3fVertex3fSUN\0"
+"glReplacementCodeuiColor3fVertex3fvSUN\0"
+"glReplacementCodeuiColor4fNormal3fVertex3fSUN\0"
+"glReplacementCodeuiColor4fNormal3fVertex3fvSUN\0"
+"glReplacementCodeuiColor4ubVertex3fSUN\0"
+"glReplacementCodeuiColor4ubVertex3fvSUN\0"
+"glReplacementCodeuiNormal3fVertex3fSUN\0"
+"glReplacementCodeuiNormal3fVertex3fvSUN\0"
+"glReplacementCodeuiSUN\0"
+"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN\0"
+"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN\0"
+"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN\0"
+"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN\0"
+"glReplacementCodeuiTexCoord2fVertex3fSUN\0"
+"glReplacementCodeuiTexCoord2fVertex3fvSUN\0"
+"glReplacementCodeuiVertex3fSUN\0"
+"glReplacementCodeuiVertex3fvSUN\0"
+"glReplacementCodeuivSUN\0"
+"glReplacementCodeusSUN\0"
+"glReplacementCodeusvSUN\0"
+"glRequestResidentProgramsNV\0"
+"glResetHistogram\0"
+"glResetHistogramEXT\0"
+"glResetMinmax\0"
+"glResetMinmaxEXT\0"
+"glResizeBuffersMESA\0"
+"glRotated\0"
+"glRotatef\0"
+"glSampleCoverage\0"
+"glSampleCoverageARB\0"
+"glSampleMapATI\0"
+"glSampleMaskEXT\0"
+"glSampleMaskSGIS\0"
+"glSamplePassARB\0"
+"glSamplePatternEXT\0"
+"glSamplePatternSGIS\0"
+"glScaled\0"
+"glScalef\0"
+"glScissor\0"
+"glSecondaryColor3b\0"
+"glSecondaryColor3bEXT\0"
+"glSecondaryColor3bv\0"
+"glSecondaryColor3bvEXT\0"
+"glSecondaryColor3d\0"
+"glSecondaryColor3dEXT\0"
+"glSecondaryColor3dv\0"
+"glSecondaryColor3dvEXT\0"
+"glSecondaryColor3f\0"
+"glSecondaryColor3fEXT\0"
+"glSecondaryColor3fv\0"
+"glSecondaryColor3fvEXT\0"
+"glSecondaryColor3hNV\0"
+"glSecondaryColor3hvNV\0"
+"glSecondaryColor3i\0"
+"glSecondaryColor3iEXT\0"
+"glSecondaryColor3iv\0"
+"glSecondaryColor3ivEXT\0"
+"glSecondaryColor3s\0"
+"glSecondaryColor3sEXT\0"
+"glSecondaryColor3sv\0"
+"glSecondaryColor3svEXT\0"
+"glSecondaryColor3ub\0"
+"glSecondaryColor3ubEXT\0"
+"glSecondaryColor3ubv\0"
+"glSecondaryColor3ubvEXT\0"
+"glSecondaryColor3ui\0"
+"glSecondaryColor3uiEXT\0"
+"glSecondaryColor3uiv\0"
+"glSecondaryColor3uivEXT\0"
+"glSecondaryColor3us\0"
+"glSecondaryColor3usEXT\0"
+"glSecondaryColor3usv\0"
+"glSecondaryColor3usvEXT\0"
+"glSecondaryColorPointer\0"
+"glSecondaryColorPointerEXT\0"
+"glSecondaryColorPointerListIBM\0"
+"glSelectBuffer\0"
+"glSelectTextureCoordSetSGIS\0"
+"glSelectTextureSGIS\0"
+"glSelectTextureTransformSGIS\0"
+"glSeparableFilter2D\0"
+"glSeparableFilter2DEXT\0"
+"glSetFenceAPPLE\0"
+"glSetFenceNV\0"
+"glSetFragmentShaderConstantATI\0"
+"glSetInvariantEXT\0"
+"glSetLocalConstantEXT\0"
+"glShadeModel\0"
+"glShaderOp1EXT\0"
+"glShaderOp2EXT\0"
+"glShaderOp3EXT\0"
+"glShaderSource\0"
+"glShaderSourceARB\0"
+"glSharpenTexFuncSGIS\0"
+"glSpriteParameterfSGIX\0"
+"glSpriteParameterfvSGIX\0"
+"glSpriteParameteriSGIX\0"
+"glSpriteParameterivSGIX\0"
+"glStartInstrumentsSGIX\0"
+"glStencilClearTagEXT\0"
+"glStencilFunc\0"
+"glStencilFuncSeparate\0"
+"glStencilFuncSeparateATI\0"
+"glStencilMask\0"
+"glStencilMaskSeparate\0"
+"glStencilOp\0"
+"glStencilOpSeparate\0"
+"glStencilOpSeparateATI\0"
+"glStopInstrumentsSGIX\0"
+"glStringMarkerGREMEDY\0"
+"glSwapAPPLE\0"
+"glSwizzleEXT\0"
+"glTagSampleBufferSGIX\0"
+"glTangent3bEXT\0"
+"glTangent3bvEXT\0"
+"glTangent3dEXT\0"
+"glTangent3dvEXT\0"
+"glTangent3fEXT\0"
+"glTangent3fvEXT\0"
+"glTangent3iEXT\0"
+"glTangent3ivEXT\0"
+"glTangent3sEXT\0"
+"glTangent3svEXT\0"
+"glTangentPointerEXT\0"
+"glTbufferMask3DFX\0"
+"glTestFenceAPPLE\0"
+"glTestFenceNV\0"
+"glTestObjectAPPLE\0"
+"glTexBufferEXT\0"
+"glTexBumpParameterfvATI\0"
+"glTexBumpParameterivATI\0"
+"glTexCoord1d\0"
+"glTexCoord1dv\0"
+"glTexCoord1f\0"
+"glTexCoord1fv\0"
+"glTexCoord1hNV\0"
+"glTexCoord1hvNV\0"
+"glTexCoord1i\0"
+"glTexCoord1iv\0"
+"glTexCoord1s\0"
+"glTexCoord1sv\0"
+"glTexCoord2d\0"
+"glTexCoord2dv\0"
+"glTexCoord2f\0"
+"glTexCoord2fColor3fVertex3fSUN\0"
+"glTexCoord2fColor3fVertex3fvSUN\0"
+"glTexCoord2fColor4fNormal3fVertex3fSUN\0"
+"glTexCoord2fColor4fNormal3fVertex3fvSUN\0"
+"glTexCoord2fColor4ubVertex3fSUN\0"
+"glTexCoord2fColor4ubVertex3fvSUN\0"
+"glTexCoord2fNormal3fVertex3fSUN\0"
+"glTexCoord2fNormal3fVertex3fvSUN\0"
+"glTexCoord2fv\0"
+"glTexCoord2fVertex3fSUN\0"
+"glTexCoord2fVertex3fvSUN\0"
+"glTexCoord2hNV\0"
+"glTexCoord2hvNV\0"
+"glTexCoord2i\0"
+"glTexCoord2iv\0"
+"glTexCoord2s\0"
+"glTexCoord2sv\0"
+"glTexCoord3d\0"
+"glTexCoord3dv\0"
+"glTexCoord3f\0"
+"glTexCoord3fv\0"
+"glTexCoord3hNV\0"
+"glTexCoord3hvNV\0"
+"glTexCoord3i\0"
+"glTexCoord3iv\0"
+"glTexCoord3s\0"
+"glTexCoord3sv\0"
+"glTexCoord4d\0"
+"glTexCoord4dv\0"
+"glTexCoord4f\0"
+"glTexCoord4fColor4fNormal3fVertex4fSUN\0"
+"glTexCoord4fColor4fNormal3fVertex4fvSUN\0"
+"glTexCoord4fv\0"
+"glTexCoord4fVertex4fSUN\0"
+"glTexCoord4fVertex4fvSUN\0"
+"glTexCoord4hNV\0"
+"glTexCoord4hvNV\0"
+"glTexCoord4i\0"
+"glTexCoord4iv\0"
+"glTexCoord4s\0"
+"glTexCoord4sv\0"
+"glTexCoordPointer\0"
+"glTexCoordPointerEXT\0"
+"glTexCoordPointerListIBM\0"
+"glTexCoordPointervINTEL\0"
+"glTexEnvf\0"
+"glTexEnvfv\0"
+"glTexEnvi\0"
+"glTexEnviv\0"
+"glTexFilterFuncSGIS\0"
+"glTexGend\0"
+"glTexGendv\0"
+"glTexGenf\0"
+"glTexGenfv\0"
+"glTexGeni\0"
+"glTexGeniv\0"
+"glTexImage1D\0"
+"glTexImage2D\0"
+"glTexImage3D\0"
+"glTexImage3DEXT\0"
+"glTexImage4DSGIS\0"
+"glTexParameterf\0"
+"glTexParameterfv\0"
+"glTexParameteri\0"
+"glTexParameterIivEXT\0"
+"glTexParameterIuivEXT\0"
+"glTexParameteriv\0"
+"glTexScissorFuncINTEL\0"
+"glTexScissorINTEL\0"
+"glTexSubImage1D\0"
+"glTexSubImage1DEXT\0"
+"glTexSubImage2D\0"
+"glTexSubImage2DEXT\0"
+"glTexSubImage3D\0"
+"glTexSubImage3DEXT\0"
+"glTexSubImage4DSGIS\0"
+"glTextureColorMaskSGIS\0"
+"glTextureFogSGIX\0"
+"glTextureLightEXT\0"
+"glTextureMaterialEXT\0"
+"glTextureNormalEXT\0"
+"glTextureRangeAPPLE\0"
+"glTrackMatrixNV\0"
+"glTransformFeedbackAttribsNV\0"
+"glTransformFeedbackVaryingsNV\0"
+"glTranslated\0"
+"glTranslatef\0"
+"glUniform1f\0"
+"glUniform1fARB\0"
+"glUniform1fv\0"
+"glUniform1fvARB\0"
+"glUniform1i\0"
+"glUniform1iARB\0"
+"glUniform1iv\0"
+"glUniform1ivARB\0"
+"glUniform1uiEXT\0"
+"glUniform1uivEXT\0"
+"glUniform2f\0"
+"glUniform2fARB\0"
+"glUniform2fv\0"
+"glUniform2fvARB\0"
+"glUniform2i\0"
+"glUniform2iARB\0"
+"glUniform2iv\0"
+"glUniform2ivARB\0"
+"glUniform2uiEXT\0"
+"glUniform2uivEXT\0"
+"glUniform3f\0"
+"glUniform3fARB\0"
+"glUniform3fv\0"
+"glUniform3fvARB\0"
+"glUniform3i\0"
+"glUniform3iARB\0"
+"glUniform3iv\0"
+"glUniform3ivARB\0"
+"glUniform3uiEXT\0"
+"glUniform3uivEXT\0"
+"glUniform4f\0"
+"glUniform4fARB\0"
+"glUniform4fv\0"
+"glUniform4fvARB\0"
+"glUniform4i\0"
+"glUniform4iARB\0"
+"glUniform4iv\0"
+"glUniform4ivARB\0"
+"glUniform4uiEXT\0"
+"glUniform4uivEXT\0"
+"glUniformBufferEXT\0"
+"glUniformMatrix2fv\0"
+"glUniformMatrix2fvARB\0"
+"glUniformMatrix2x3fv\0"
+"glUniformMatrix2x4fv\0"
+"glUniformMatrix3fv\0"
+"glUniformMatrix3fvARB\0"
+"glUniformMatrix3x2fv\0"
+"glUniformMatrix3x4fv\0"
+"glUniformMatrix4fv\0"
+"glUniformMatrix4fvARB\0"
+"glUniformMatrix4x2fv\0"
+"glUniformMatrix4x3fv\0"
+"glUnlockArraysEXT\0"
+"glUnmapBuffer\0"
+"glUnmapBufferARB\0"
+"glUnmapObjectBufferATI\0"
+"glUnmapTexture3DATI\0"
+"glUpdateObjectBufferATI\0"
+"glUseProgram\0"
+"glUseProgramObjectARB\0"
+"glValidateProgram\0"
+"glValidateProgramARB\0"
+"glValidBackBufferHintAutodesk\0"
+"glVariantArrayObjectATI\0"
+"glVariantbvEXT\0"
+"glVariantdvEXT\0"
+"glVariantfvEXT\0"
+"glVariantivEXT\0"
+"glVariantPointerEXT\0"
+"glVariantsvEXT\0"
+"glVariantubvEXT\0"
+"glVariantuivEXT\0"
+"glVariantusvEXT\0"
+"glVertex2d\0"
+"glVertex2dv\0"
+"glVertex2f\0"
+"glVertex2fv\0"
+"glVertex2hNV\0"
+"glVertex2hvNV\0"
+"glVertex2i\0"
+"glVertex2iv\0"
+"glVertex2s\0"
+"glVertex2sv\0"
+"glVertex3d\0"
+"glVertex3dv\0"
+"glVertex3f\0"
+"glVertex3fv\0"
+"glVertex3hNV\0"
+"glVertex3hvNV\0"
+"glVertex3i\0"
+"glVertex3iv\0"
+"glVertex3s\0"
+"glVertex3sv\0"
+"glVertex4d\0"
+"glVertex4dv\0"
+"glVertex4f\0"
+"glVertex4fv\0"
+"glVertex4hNV\0"
+"glVertex4hvNV\0"
+"glVertex4i\0"
+"glVertex4iv\0"
+"glVertex4s\0"
+"glVertex4sv\0"
+"glVertexArrayParameteriAPPLE\0"
+"glVertexArrayRangeAPPLE\0"
+"glVertexArrayRangeNV\0"
+"glVertexAttrib1d\0"
+"glVertexAttrib1dARB\0"
+"glVertexAttrib1dNV\0"
+"glVertexAttrib1dv\0"
+"glVertexAttrib1dvARB\0"
+"glVertexAttrib1dvNV\0"
+"glVertexAttrib1f\0"
+"glVertexAttrib1fARB\0"
+"glVertexAttrib1fNV\0"
+"glVertexAttrib1fv\0"
+"glVertexAttrib1fvARB\0"
+"glVertexAttrib1fvNV\0"
+"glVertexAttrib1hNV\0"
+"glVertexAttrib1hvNV\0"
+"glVertexAttrib1s\0"
+"glVertexAttrib1sARB\0"
+"glVertexAttrib1sNV\0"
+"glVertexAttrib1sv\0"
+"glVertexAttrib1svARB\0"
+"glVertexAttrib1svNV\0"
+"glVertexAttrib2d\0"
+"glVertexAttrib2dARB\0"
+"glVertexAttrib2dNV\0"
+"glVertexAttrib2dv\0"
+"glVertexAttrib2dvARB\0"
+"glVertexAttrib2dvNV\0"
+"glVertexAttrib2f\0"
+"glVertexAttrib2fARB\0"
+"glVertexAttrib2fNV\0"
+"glVertexAttrib2fv\0"
+"glVertexAttrib2fvARB\0"
+"glVertexAttrib2fvNV\0"
+"glVertexAttrib2hNV\0"
+"glVertexAttrib2hvNV\0"
+"glVertexAttrib2s\0"
+"glVertexAttrib2sARB\0"
+"glVertexAttrib2sNV\0"
+"glVertexAttrib2sv\0"
+"glVertexAttrib2svARB\0"
+"glVertexAttrib2svNV\0"
+"glVertexAttrib3d\0"
+"glVertexAttrib3dARB\0"
+"glVertexAttrib3dNV\0"
+"glVertexAttrib3dv\0"
+"glVertexAttrib3dvARB\0"
+"glVertexAttrib3dvNV\0"
+"glVertexAttrib3f\0"
+"glVertexAttrib3fARB\0"
+"glVertexAttrib3fNV\0"
+"glVertexAttrib3fv\0"
+"glVertexAttrib3fvARB\0"
+"glVertexAttrib3fvNV\0"
+"glVertexAttrib3hNV\0"
+"glVertexAttrib3hvNV\0"
+"glVertexAttrib3s\0"
+"glVertexAttrib3sARB\0"
+"glVertexAttrib3sNV\0"
+"glVertexAttrib3sv\0"
+"glVertexAttrib3svARB\0"
+"glVertexAttrib3svNV\0"
+"glVertexAttrib4bv\0"
+"glVertexAttrib4bvARB\0"
+"glVertexAttrib4d\0"
+"glVertexAttrib4dARB\0"
+"glVertexAttrib4dNV\0"
+"glVertexAttrib4dv\0"
+"glVertexAttrib4dvARB\0"
+"glVertexAttrib4dvNV\0"
+"glVertexAttrib4f\0"
+"glVertexAttrib4fARB\0"
+"glVertexAttrib4fNV\0"
+"glVertexAttrib4fv\0"
+"glVertexAttrib4fvARB\0"
+"glVertexAttrib4fvNV\0"
+"glVertexAttrib4hNV\0"
+"glVertexAttrib4hvNV\0"
+"glVertexAttrib4iv\0"
+"glVertexAttrib4ivARB\0"
+"glVertexAttrib4Nbv\0"
+"glVertexAttrib4NbvARB\0"
+"glVertexAttrib4Niv\0"
+"glVertexAttrib4NivARB\0"
+"glVertexAttrib4Nsv\0"
+"glVertexAttrib4NsvARB\0"
+"glVertexAttrib4Nub\0"
+"glVertexAttrib4NubARB\0"
+"glVertexAttrib4Nubv\0"
+"glVertexAttrib4NubvARB\0"
+"glVertexAttrib4Nuiv\0"
+"glVertexAttrib4NuivARB\0"
+"glVertexAttrib4Nusv\0"
+"glVertexAttrib4NusvARB\0"
+"glVertexAttrib4s\0"
+"glVertexAttrib4sARB\0"
+"glVertexAttrib4sNV\0"
+"glVertexAttrib4sv\0"
+"glVertexAttrib4svARB\0"
+"glVertexAttrib4svNV\0"
+"glVertexAttrib4ubNV\0"
+"glVertexAttrib4ubv\0"
+"glVertexAttrib4ubvARB\0"
+"glVertexAttrib4ubvNV\0"
+"glVertexAttrib4uiv\0"
+"glVertexAttrib4uivARB\0"
+"glVertexAttrib4usv\0"
+"glVertexAttrib4usvARB\0"
+"glVertexAttribArrayObjectATI\0"
+"glVertexAttribI1iEXT\0"
+"glVertexAttribI1ivEXT\0"
+"glVertexAttribI1uiEXT\0"
+"glVertexAttribI1uivEXT\0"
+"glVertexAttribI2iEXT\0"
+"glVertexAttribI2ivEXT\0"
+"glVertexAttribI2uiEXT\0"
+"glVertexAttribI2uivEXT\0"
+"glVertexAttribI3iEXT\0"
+"glVertexAttribI3ivEXT\0"
+"glVertexAttribI3uiEXT\0"
+"glVertexAttribI3uivEXT\0"
+"glVertexAttribI4bvEXT\0"
+"glVertexAttribI4iEXT\0"
+"glVertexAttribI4ivEXT\0"
+"glVertexAttribI4svEXT\0"
+"glVertexAttribI4ubvEXT\0"
+"glVertexAttribI4uiEXT\0"
+"glVertexAttribI4uivEXT\0"
+"glVertexAttribI4usvEXT\0"
+"glVertexAttribIPointerEXT\0"
+"glVertexAttribPointer\0"
+"glVertexAttribPointerARB\0"
+"glVertexAttribPointerNV\0"
+"glVertexAttribs1dvNV\0"
+"glVertexAttribs1fvNV\0"
+"glVertexAttribs1hvNV\0"
+"glVertexAttribs1svNV\0"
+"glVertexAttribs2dvNV\0"
+"glVertexAttribs2fvNV\0"
+"glVertexAttribs2hvNV\0"
+"glVertexAttribs2svNV\0"
+"glVertexAttribs3dvNV\0"
+"glVertexAttribs3fvNV\0"
+"glVertexAttribs3hvNV\0"
+"glVertexAttribs3svNV\0"
+"glVertexAttribs4dvNV\0"
+"glVertexAttribs4fvNV\0"
+"glVertexAttribs4hvNV\0"
+"glVertexAttribs4svNV\0"
+"glVertexAttribs4ubvNV\0"
+"glVertexBlendARB\0"
+"glVertexBlendEnvfATI\0"
+"glVertexBlendEnviATI\0"
+"glVertexPointer\0"
+"glVertexPointerEXT\0"
+"glVertexPointerListIBM\0"
+"glVertexPointervINTEL\0"
+"glVertexStream1dATI\0"
+"glVertexStream1dvATI\0"
+"glVertexStream1fATI\0"
+"glVertexStream1fvATI\0"
+"glVertexStream1iATI\0"
+"glVertexStream1ivATI\0"
+"glVertexStream1sATI\0"
+"glVertexStream1svATI\0"
+"glVertexStream2dATI\0"
+"glVertexStream2dvATI\0"
+"glVertexStream2fATI\0"
+"glVertexStream2fvATI\0"
+"glVertexStream2iATI\0"
+"glVertexStream2ivATI\0"
+"glVertexStream2sATI\0"
+"glVertexStream2svATI\0"
+"glVertexStream3dATI\0"
+"glVertexStream3dvATI\0"
+"glVertexStream3fATI\0"
+"glVertexStream3fvATI\0"
+"glVertexStream3iATI\0"
+"glVertexStream3ivATI\0"
+"glVertexStream3sATI\0"
+"glVertexStream3svATI\0"
+"glVertexStream4dATI\0"
+"glVertexStream4dvATI\0"
+"glVertexStream4fATI\0"
+"glVertexStream4fvATI\0"
+"glVertexStream4iATI\0"
+"glVertexStream4ivATI\0"
+"glVertexStream4sATI\0"
+"glVertexStream4svATI\0"
+"glVertexWeightfEXT\0"
+"glVertexWeightfvEXT\0"
+"glVertexWeighthNV\0"
+"glVertexWeighthvNV\0"
+"glVertexWeightPointerEXT\0"
+"glViewport\0"
+"glWeightbvARB\0"
+"glWeightdvARB\0"
+"glWeightfvARB\0"
+"glWeightivARB\0"
+"glWeightPointerARB\0"
+"glWeightsvARB\0"
+"glWeightubvARB\0"
+"glWeightuivARB\0"
+"glWeightusvARB\0"
+"glWindowBackBufferHintAutodesk\0"
+"glWindowPos2d\0"
+"glWindowPos2dARB\0"
+"glWindowPos2dMESA\0"
+"glWindowPos2dv\0"
+"glWindowPos2dvARB\0"
+"glWindowPos2dvMESA\0"
+"glWindowPos2f\0"
+"glWindowPos2fARB\0"
+"glWindowPos2fMESA\0"
+"glWindowPos2fv\0"
+"glWindowPos2fvARB\0"
+"glWindowPos2fvMESA\0"
+"glWindowPos2i\0"
+"glWindowPos2iARB\0"
+"glWindowPos2iMESA\0"
+"glWindowPos2iv\0"
+"glWindowPos2ivARB\0"
+"glWindowPos2ivMESA\0"
+"glWindowPos2s\0"
+"glWindowPos2sARB\0"
+"glWindowPos2sMESA\0"
+"glWindowPos2sv\0"
+"glWindowPos2svARB\0"
+"glWindowPos2svMESA\0"
+"glWindowPos3d\0"
+"glWindowPos3dARB\0"
+"glWindowPos3dMESA\0"
+"glWindowPos3dv\0"
+"glWindowPos3dvARB\0"
+"glWindowPos3dvMESA\0"
+"glWindowPos3f\0"
+"glWindowPos3fARB\0"
+"glWindowPos3fMESA\0"
+"glWindowPos3fv\0"
+"glWindowPos3fvARB\0"
+"glWindowPos3fvMESA\0"
+"glWindowPos3i\0"
+"glWindowPos3iARB\0"
+"glWindowPos3iMESA\0"
+"glWindowPos3iv\0"
+"glWindowPos3ivARB\0"
+"glWindowPos3ivMESA\0"
+"glWindowPos3s\0"
+"glWindowPos3sARB\0"
+"glWindowPos3sMESA\0"
+"glWindowPos3sv\0"
+"glWindowPos3svARB\0"
+"glWindowPos3svMESA\0"
+"glWindowPos4dMESA\0"
+"glWindowPos4dvMESA\0"
+"glWindowPos4fMESA\0"
+"glWindowPos4fvMESA\0"
+"glWindowPos4iMESA\0"
+"glWindowPos4ivMESA\0"
+"glWindowPos4sMESA\0"
+"glWindowPos4svMESA\0"
+"glWriteMaskEXT\0"
+"glXAllocateMemoryMESA\0"
+"glXAllocateMemoryNV\0"
+"glXBindChannelToWindowSGIX\0"
+"glXBindHyperpipeSGIX\0"
+"glXBindSwapBarrierNV\0"
+"glXBindSwapBarrierSGIX\0"
+"glXBindTexImageEXT\0"
+"glXBindVideoImageNV\0"
+"glXChannelRectSGIX\0"
+"glXChannelRectSyncSGIX\0"
+"glXChooseFBConfig\0"
+"glXChooseVisual\0"
+"glXCopyContext\0"
+"glXCopySubBufferMESA\0"
+"glXCreateContext\0"
+"glXCreateGLXPixmap\0"
+"glXCreateGLXPixmapMESA\0"
+"glXCreateGLXPixmapWithConfigSGIX\0"
+"glXCreateNewContext\0"
+"glXCreatePbuffer\0"
+"glXCreatePixmap\0"
+"glXCreateWindow\0"
+"glXCushionSGI\0"
+"glXDestroyContext\0"
+"glXDestroyGLXPixmap\0"
+"glXDestroyHyperpipeConfigSGIX\0"
+"glXDestroyPbuffer\0"
+"glXDestroyPixmap\0"
+"glXDestroyWindow\0"
+"glXDrawableAttribARB\0"
+"glXDrawableAttribATI\0"
+"glXFreeContextEXT\0"
+"glXFreeMemoryMESA\0"
+"glXFreeMemoryNV\0"
+"glXGetAGPOffsetMESA\0"
+"glXGetClientString\0"
+"glXGetConfig\0"
+"glXGetContextIDEXT\0"
+"glXGetCurrentContext\0"
+"glXGetCurrentDisplay\0"
+"glXGetCurrentDisplayEXT\0"
+"glXGetCurrentDrawable\0"
+"glXGetCurrentReadDrawable\0"
+"glXGetCurrentReadDrawableSGI\0"
+"glXGetDriverConfig\0"
+"glXGetFBConfigAttrib\0"
+"glXGetFBConfigFromVisualSGIX\0"
+"glXGetFBConfigs\0"
+"glXGetMemoryOffsetMESA\0"
+"glXGetMscRateOML\0"
+"glXGetProcAddress\0"
+"glXGetProcAddressARB\0"
+"glXGetRefreshRateSGI\0"
+"glXGetScreenDriver\0"
+"glXGetSelectedEvent\0"
+"glXGetSelectedEventSGIX\0"
+"glXGetSyncValuesOML\0"
+"glXGetTransparentIndexSUN\0"
+"glXGetVideoDeviceNV\0"
+"glXGetVideoInfoNV\0"
+"glXGetVideoResizeSUN\0"
+"glXGetVideoSyncSGI\0"
+"glXGetVisualFromFBConfig\0"
+"glXGetVisualFromFBConfigSGIX\0"
+"glXHyperpipeAttribSGIX\0"
+"glXHyperpipeConfigSGIX\0"
+"glXImportContextEXT\0"
+"glXIsDirect\0"
+"glXJoinSwapGroupNV\0"
+"glXJoinSwapGroupSGIX\0"
+"glXMakeContextCurrent\0"
+"glXMakeCurrent\0"
+"glXMakeCurrentReadSGI\0"
+"glXQueryChannelDeltasSGIX\0"
+"glXQueryChannelRectSGIX\0"
+"glXQueryContext\0"
+"glXQueryContextInfoEXT\0"
+"glXQueryDrawable\0"
+"glXQueryExtension\0"
+"glXQueryExtensionsString\0"
+"glXQueryFrameCountNV\0"
+"glXQueryHyperpipeAttribSGIX\0"
+"glXQueryHyperpipeBestAttribSGIX\0"
+"glXQueryHyperpipeConfigSGIX\0"
+"glXQueryHyperpipeNetworkSGIX\0"
+"glXQueryMaxSwapBarriersSGIX\0"
+"glXQueryMaxSwapGroupsNV\0"
+"glXQueryServerString\0"
+"glXQuerySwapGroupNV\0"
+"glXQueryVersion\0"
+"glXReleaseBuffersMESA\0"
+"glXReleaseTexImageEXT\0"
+"glXReleaseVideoDeviceNV\0"
+"glXReleaseVideoImageNV\0"
+"glXResetFrameCountNV\0"
+"glXSelectEvent\0"
+"glXSelectEventSGIX\0"
+"glXSendPbufferToVideoNV\0"
+"glXSet3DfxModeMESA\0"
+"glXSwapBuffers\0"
+"glXSwapBuffersMscOML\0"
+"glXSwapIntervalSGI\0"
+"glXUseXFont\0"
+"glXVideoResizeSUN\0"
+"glXWaitForMscOML\0"
+"glXWaitForSbcOML\0"
+"glXWaitGL\0"
+"glXWaitVideoSyncSGI\0"
+"glXWaitX\0"
+"\0"
+};
+
+typedef struct
+{
+  unsigned int hash;
+  char* name;
+  __GLXextFuncPtr func;
+  int found_on_client_side;
+  int found_on_server_side;
+  int alreadyAsked;
+} AssocProcAdress;
+
+#ifdef PROVIDE_STUB_IMPLEMENTATION
+static void _glStubImplementation()
+{
+  log_gl("This function is a stub !!!\n");
+}
+#endif
+
+__GLXextFuncPtr glXGetProcAddress_no_lock(const GLubyte * _name)
+{
+  static int nbElts = 0;
+  static int tabSize = 0;
+  static AssocProcAdress* tab_assoc = NULL;
+  static void* handle = NULL;
+  __GLXextFuncPtr ret = NULL;
+
+  const char* name = (const char*)_name;
+  if(debug_gl) log_gl(">>> looking for \"%s\",\n", name);
+  int i;
+
+  if (name == NULL)
+  {
+    goto end_of_glx_get_proc_address;
+  }
+
+  if (tabSize == 0)
+  {
+    tabSize = 2000;
+    tab_assoc = calloc(tabSize, sizeof(AssocProcAdress));
+
+    handle = dlopen(getenv("REAL_LIBGL") ? getenv("REAL_LIBGL") : "libGL.so.1" ,RTLD_LAZY);
+    if (!handle) {
+      log_gl("%s\n", dlerror());
+      exit(1);
+    }
+
+    {
+      if(debug_gl) log_gl("global_glXGetProcAddress request\n");
+      int sizeOfString = 0;
+      int nbRequestElts = 0;
+      int i = 0;
+      while(1)
+      {
+        if (global_glXGetProcAddress_request[i] == '\0')
+        {
+          nbRequestElts++;
+          if (global_glXGetProcAddress_request[i + 1] == '\0')
+          {
+            sizeOfString = i + 1;
+            break;
+          }
+        }
+        i++;
+      }
+      if(debug_gl) log_gl("nbRequestElts=%d\n", nbRequestElts);
+      char* result = (char*)malloc(nbRequestElts);
+
+      long args[] = { INT_TO_ARG(nbRequestElts), POINTER_TO_ARG(global_glXGetProcAddress_request), POINTER_TO_ARG(result) };
+      int args_size[] = { 0, sizeOfString, nbRequestElts };
+      do_opengl_call_no_lock(glXGetProcAddress_global_fake_func, NULL, CHECK_ARGS(args, args_size));
+      int offset = 0;
+      for(i=0; i<nbRequestElts;i++)
+      {
+        const char* funcName = global_glXGetProcAddress_request + offset;
+        void* func = dlsym(handle, funcName);
+#ifdef PROVIDE_STUB_IMPLEMENTATION
+        if (func == NULL)
+          func = _glStubImplementation;
+#endif
+        if (result[i] && func == NULL && debug_gl)
+          log_gl("%s %d %d\n", funcName, result[i], func != NULL);
+        if (result[i] == 0)
+        {
+          if (nbElts < tabSize)
+          {
+            int hash = str_hash(funcName);
+            tab_assoc[nbElts].alreadyAsked = 0;
+            tab_assoc[nbElts].found_on_server_side = 0;
+            tab_assoc[nbElts].found_on_client_side = func != NULL;
+            tab_assoc[nbElts].hash = hash;
+            tab_assoc[nbElts].name = strdup(funcName);
+            tab_assoc[nbElts].func = NULL;
+            nbElts ++;
+          }
+        }
+        else
+        {
+          if (nbElts < tabSize)
+          {
+            int hash = str_hash(funcName);
+            tab_assoc[nbElts].alreadyAsked = 0;
+            tab_assoc[nbElts].found_on_server_side = 1;
+            tab_assoc[nbElts].found_on_client_side = func != NULL;
+            tab_assoc[nbElts].hash = hash;
+            tab_assoc[nbElts].name = strdup(funcName);
+            tab_assoc[nbElts].func = func;
+            nbElts ++;
+          }
+        }
+        offset += strlen(funcName) + 1;
+      }
+      free(result);
+
+      ret = glXGetProcAddress_no_lock(_name);
+      goto end_of_glx_get_proc_address;
+    }
+  }
+
+  int hash = str_hash(name);
+  for(i=0;i<nbElts;i++)
+  {
+    if (tab_assoc[i].hash == hash && strcmp(tab_assoc[i].name, name) == 0)
+    {
+      if (tab_assoc[i].alreadyAsked == 0)
+      {
+        tab_assoc[i].alreadyAsked = 1;
+        if (tab_assoc[i].found_on_server_side == 0 && tab_assoc[i].found_on_client_side == 0)
+        {
+          log_gl("not found name on server and client side = %s\n", name);
+        }
+        else if (tab_assoc[i].found_on_server_side == 0)
+        {
+          log_gl("not found name on server side = %s\n", name);
+        }
+        else if (tab_assoc[i].found_on_client_side == 0)
+        {
+          log_gl("not found name on client side = %s\n", name);
+        }
+      }
+      ret = (__GLXextFuncPtr)tab_assoc[i].func;
+      goto end_of_glx_get_proc_address;
+    }
+  }
+  if(1/*debug_gl*/) log_gl("==looking for \"%s\",\n", name);
+  int ret_call = 0;
+  long args[] = { INT_TO_ARG(name) };
+  do_opengl_call_no_lock(glXGetProcAddress_fake_func, &ret_call, args, NULL);
+
+
+  void* func = dlsym(handle, name);
+#ifdef PROVIDE_STUB_IMPLEMENTATION
+  if (func == NULL)
+    func = _glStubImplementation;
+#endif
+  if (ret_call == 0)
+  {
+    if (nbElts < tabSize)
+    {
+      tab_assoc[nbElts].alreadyAsked = 1;
+      tab_assoc[nbElts].found_on_server_side = 0;
+      tab_assoc[nbElts].found_on_client_side = func != NULL;
+      tab_assoc[nbElts].hash = hash;
+      tab_assoc[nbElts].name = strdup(name);
+      tab_assoc[nbElts].func = NULL;
+      nbElts ++;
+    }
+    if (func == NULL)
+    {
+      log_gl("not found name on server and client side = %s\n", name);
+    }
+    else
+    {
+      log_gl("not found name on server side = %s\n", name);
+    }
+    ret = NULL;
+    goto end_of_glx_get_proc_address;
+  }
+  else
+  {
+    if (func == NULL)
+    {
+      log_gl("not found name on client side = %s\n", name);
+    }
+    if (nbElts < tabSize)
+    {
+      tab_assoc[nbElts].alreadyAsked = 1;
+      tab_assoc[nbElts].found_on_server_side = 1;
+      tab_assoc[nbElts].found_on_client_side = func != NULL;
+      tab_assoc[nbElts].hash = hash;
+      tab_assoc[nbElts].name = strdup(name);
+      tab_assoc[nbElts].func = func;
+      nbElts ++;
+    }
+    ret = func;
+    goto end_of_glx_get_proc_address;
+  }
+end_of_glx_get_proc_address:
+  return ret;
+}
+
+__GLXextFuncPtr glXGetProcAddress(const GLubyte * name)
+{
+  __GLXextFuncPtr ret;
+  LOCK(glXGetProcAddress_fake_func);
+  ret = glXGetProcAddress_no_lock(name);
+  UNLOCK(glXGetProcAddress_fake_func);
+  return ret;
+}
+
+__GLXextFuncPtr glXGetProcAddressARB (const GLubyte * name)
+{
+  return glXGetProcAddress(name);
+}
+