text: /*
   * Copyright © 2005 Novell, Inc.
   *
   * Permission to use, copy, modify, distribute, and sell this software
   * and its documentation for any purpose is hereby granted without
   * fee, provided that the above copyright notice appear in all copies
   * and that both that copyright notice and this permission notice
   * appear in supporting documentation, and that the name of
   * Novell, Inc. not be used in advertising or publicity pertaining to
   * distribution of the software without specific, written prior permission.
   * Novell, Inc. makes no representations about the suitability of this
   * software for any purpose. It is provided "as is" without express or
   * implied warranty.
   *
   * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
   * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
   * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
   * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
   * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
   * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
   * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   *
   * Author: David Reveman <davidr@novell.com>
   */
  
  #include "xglglx.h"
  #include "xglglxext.h"
  #include "glapitable.h"
  
  #ifndef NGLXEXTLOG
  
  static struct _glapi_table *nativeRenderTable = 0;
  
  static FILE *logFp = 0;
  
  static Bool logVertexAttribs = FALSE;
  
  static struct VertexAttribCount {
      int  n;
      char *name;
  } vCnt[] = {
      { 0, "glArrayElement"	},
      { 0, "glCallList"		},
      { 0, "glCallLists"		},
      { 0, "glColor3bv"		},
      { 0, "glColor3dv"		},
      { 0, "glColor3fv"		},
      { 0, "glColor3iv"		},
      { 0, "glColor3sv"		},
      { 0, "glColor3ubv"		},
      { 0, "glColor3uiv"		},
      { 0, "glColor3usv"		},
      { 0, "glColor4bv"		},
      { 0, "glColor4dv"		},
      { 0, "glColor4fv"		},
      { 0, "glColor4iv"		},
      { 0, "glColor4sv"		},
      { 0, "glColor4ubv"		},
      { 0, "glColor4uiv"		},
      { 0, "glColor4usv"		},
      { 0, "glEdgeFlagv"		},
      { 0, "glEvalCoord1dv"	},
      { 0, "glEvalCoord1fv"	},
      { 0, "glEvalCoord2dv"	},
      { 0, "glEvalCoord2fv"	},
      { 0, "glEvalPoint1"		},
      { 0, "glEvalPoint2"		},
      { 0, "glIndexdv"		},
      { 0, "glIndexfv"		},
      { 0, "glIndexiv"		},
      { 0, "glIndexsv"		},
      { 0, "glIndexubv"		},
      { 0, "glMaterialf"		},
      { 0, "glMaterialfv"		},
      { 0, "glMateriali"		},
      { 0, "glMaterialiv"		},
      { 0, "glNormal3bv"		},
      { 0, "glNormal3dv"		},
      { 0, "glNormal3fv"		},
      { 0, "glNormal3iv"		},
      { 0, "glNormal3sv"		},
      { 0, "glTexCoord1dv"	},
      { 0, "glTexCoord1fv"	},
      { 0, "glTexCoord1iv"	},
      { 0, "glTexCoord1sv"	},
      { 0, "glTexCoord2dv"	},
      { 0, "glTexCoord2fv"	},
      { 0, "glTexCoord2iv"	},
      { 0, "glTexCoord2sv"	},
      { 0, "glTexCoord3dv"	},
      { 0, "glTexCoord3fv"	},
      { 0, "glTexCoord3iv"	},
      { 0, "glTexCoord3sv"	},
      { 0, "glTexCoord4dv"	},
      { 0, "glTexCoord4fv"	},
      { 0, "glTexCoord4iv"	},
      { 0, "glTexCoord4sv"	},
      { 0, "glVertex2dv"		},
      { 0, "glVertex2fv"		},
      { 0, "glVertex2iv"		},
      { 0, "glVertex2sv"		},
      { 0, "glVertex3dv"		},
      { 0, "glVertex3fv"		},
      { 0, "glVertex3iv"		},
      { 0, "glVertex3sv"		},
      { 0, "glVertex4dv"		},
      { 0, "glVertex4fv"		},
      { 0, "glVertex4iv"		},
      { 0, "glVertex4sv"		},
      { 0, "glMultiTexCoord1dv"	},
      { 0, "glMultiTexCoord1fv"	},
      { 0, "glMultiTexCoord1iv"	},
      { 0, "glMultiTexCoord1sv"	},
      { 0, "glMultiTexCoord2dv"	},
      { 0, "glMultiTexCoord2fv"	},
      { 0, "glMultiTexCoord2iv"	},
      { 0, "glMultiTexCoord2sv"	},
      { 0, "glMultiTexCoord3dv"	},
      { 0, "glMultiTexCoord3fv"	},
      { 0, "glMultiTexCoord3iv"	},
      { 0, "glMultiTexCoord3sv"	},
      { 0, "glMultiTexCoord4dv"	},
      { 0, "glMultiTexCoord4fv"	},
      { 0, "glMultiTexCoord4iv"	},
      { 0, "glMultiTexCoord4sv"	},
      { 0, "glFogCoordfv"		},
      { 0, "glFogCoorddv"		},
      { 0, "glSecondaryColor3bv"	},
      { 0, "glSecondaryColor3dv"	},
      { 0, "glSecondaryColor3fv"	},
      { 0, "glSecondaryColor3iv"	},
      { 0, "glSecondaryColor3sv"	},
      { 0, "glSecondaryColor3ubv"	},
      { 0, "glSecondaryColor3uiv"	},
      { 0, "glSecondaryColor3usv"	}
  };
  
  #define arrayElementIndex	0
  #define callListIndex		1
  #define callListsIndex		2
  #define color3bvIndex		3
  #define color3dvIndex		4
  #define color3fvIndex		5
  #define color3ivIndex		6
  #define color3svIndex		7
  #define color3ubvIndex		8
  #define color3uivIndex		9
  #define color3usvIndex		10
  #define color4bvIndex		11
  #define color4dvIndex		12
  #define color4fvIndex		13
  #define color4ivIndex		14
  #define color4svIndex		15
  #define color4ubvIndex		16
  #define color4uivIndex		17
  #define color4usvIndex		18
  #define edgeFlagvIndex		19
  #define evalCoord1dvIndex	20
  #define evalCoord1fvIndex	21
  #define evalCoord2dvIndex	22
  #define evalCoord2fvIndex	23
  #define evalPoint1Index		24
  #define evalPoint2Index		25
  #define indexdvIndex		26
  #define indexfvIndex		27
  #define indexivIndex		28
  #define indexsvIndex		29
  #define indexubvIndex		30
  #define materialfIndex		31
  #define materialfvIndex		32
  #define materialiIndex		33
  #define materialivIndex		34
  #define normal3bvIndex		35
  #define normal3dvIndex		36
  #define normal3fvIndex		37
  #define normal3ivIndex		38
  #define normal3svIndex		39
  #define texCoord1dvIndex	40
  #define texCoord1fvIndex	41
  #define texCoord1ivIndex	42
  #define texCoord1svIndex	43
  #define texCoord2dvIndex	44
  #define texCoord2fvIndex	45
  #define texCoord2ivIndex	46
  #define texCoord2svIndex	47
  #define texCoord3dvIndex	48
  #define texCoord3fvIndex	49
  #define texCoord3ivIndex	50
  #define texCoord3svIndex	51
  #define texCoord4dvIndex	52
  #define texCoord4fvIndex	53
  #define texCoord4ivIndex	54
  #define texCoord4svIndex	55
  #define vertex2dvIndex		56
  #define vertex2fvIndex		57
  #define vertex2ivIndex		58
  #define vertex2svIndex		59
  #define vertex3dvIndex		60
  #define vertex3fvIndex		61
  #define vertex3ivIndex		62
  #define vertex3svIndex		63
  #define vertex4dvIndex		64
  #define vertex4fvIndex		65
  #define vertex4ivIndex		66
  #define vertex4svIndex		67
  #define multiTexCoord1dvIndex	68
  #define multiTexCoord1fvIndex	69
  #define multiTexCoord1ivIndex	70
  #define multiTexCoord1svIndex	71
  #define multiTexCoord2dvIndex	72
  #define multiTexCoord2fvIndex	73
  #define multiTexCoord2ivIndex	74
  #define multiTexCoord2svIndex	75
  #define multiTexCoord3dvIndex	76
  #define multiTexCoord3fvIndex	77
  #define multiTexCoord3ivIndex	78
  #define multiTexCoord3svIndex	79
  #define multiTexCoord4dvIndex	80
  #define multiTexCoord4fvIndex	81
  #define multiTexCoord4ivIndex	82
  #define multiTexCoord4svIndex	83
  #define fogCoordfvIndex		84
  #define fogCoorddvIndex		85
  #define secondaryColor3bvIndex	86
  #define secondaryColor3dvIndex	87
  #define secondaryColor3fvIndex	88
  #define secondaryColor3ivIndex	89
  #define secondaryColor3svIndex	90
  #define secondaryColor3ubvIndex 91
  #define secondaryColor3uivIndex 92
  #define secondaryColor3usvIndex 93
  
  static void
  logAccum (GLenum  op,
  	  GLfloat value)
  {
      fprintf (logFp, "glAccum (0x%x, %f)\n", op, value);
      (*nativeRenderTable->Accum) (op, value);
  }
  
  static void
  logAlphaFunc (GLenum   func,
  	      GLclampf ref)
  {
      fprintf (logFp, "glAlphaFunc (0x%x, %f)\n", func, ref);
      (*nativeRenderTable->AlphaFunc) (func, ref);
  }
  
  static GLboolean
  logAreTexturesResident (GLsizei	     n,
  			const GLuint *textures,
  			GLboolean    *residences)
  {
      fprintf (logFp, "glAreTexturesResident (%d, %p, %p)\n", n, textures,
  	     residences);
      return (*nativeRenderTable->AreTexturesResident) (n, textures,
  						      residences);
  }
  
  static void
  logArrayElement (GLint i)
  {
      vCnt[arrayElementIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glArrayElement (%d)\n", i);
      (*nativeRenderTable->ArrayElement) (i);
  }
  
  static void
  logBegin (GLenum mode)
  {
      fprintf (logFp, "glBegin (0x%x)\n", mode);
      (*nativeRenderTable->Begin) (mode);
  }
  
  static void
  logBindTexture (GLenum target,
  		GLuint texture)
  {
      fprintf (logFp, "glBindTexture (0x%x, %u)\n", target, texture);
      (*nativeRenderTable->BindTexture) (target, texture);
  }
  
  static void
  logBitmap (GLsizei	 width,
  	   GLsizei	 height,
  	   GLfloat	 xorig,
  	   GLfloat	 yorig,
  	   GLfloat	 xmove,
  	   GLfloat	 ymove,
  	   const GLubyte *bitmap)
  {
      fprintf (logFp, "glBitmap (%d, %d, %f, %f, %f, %f, %p)\n",
  	     width, height, xorig, yorig, xmove, ymove, bitmap);
      (*nativeRenderTable->Bitmap) (width, height, xorig, yorig,
  				  xmove, ymove, bitmap);
  }
  
  static void
  logBlendFunc (GLenum sfactor,
  	      GLenum dfactor)
  {
      fprintf (logFp, "glBlendFunc (0x%x, 0x%x)\n", sfactor, dfactor);
      (*nativeRenderTable->BlendFunc) (sfactor, dfactor);
  }
  
  static void
  logCallList (GLuint list)
  {
      vCnt[callListIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glCallList (%u)\n", list);
      (*nativeRenderTable->CallList) (list);
  }
  
  static void
  logCallLists (GLsizei	 n,
  	      GLenum	 type,
  	      const void *lists)
  {
      vCnt[callListsIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glCallLists (%d, 0x%x, %p)\n", n, type, lists);
      (*nativeRenderTable->CallLists) (n, type, lists);
  }
  
  static void
  logClear (GLbitfield mask)
  {
      fprintf (logFp, "glClear (0x%x)\n", mask);
      (*nativeRenderTable->Clear) (mask);
  }
  
  static void
  logClearAccum (GLfloat red,
  	       GLfloat green,
  	       GLfloat blue,
  	       GLfloat alpha)
  {
      fprintf (logFp, "glClearAccum (%f, %f, %f, %f)\n",
  	     red, green, blue, alpha);
      (*nativeRenderTable->ClearAccum) (red, green, blue, alpha);
  }
  
  static void
  logClearColor (GLclampf red,
  	       GLclampf green,
  	       GLclampf blue,
  	       GLclampf alpha)
  {
      fprintf (logFp, "glClearColor (%f, %f, %f, %f)\n",
  	     red, green, blue, alpha);
      (*nativeRenderTable->ClearColor) (red, green, blue, alpha);
  }
  
  static void
  logClearDepth (GLclampd depth)
  {
      fprintf (logFp, "glClearDepth (%f)\n", depth);
      (*nativeRenderTable->ClearDepth) (depth);
  }
  
  static void
  logClearIndex (GLfloat c)
  {
      fprintf (logFp, "glClearIndex (%f)\n", c);
      (*nativeRenderTable->ClearIndex) (c);
  }
  
  static void
  logClearStencil (GLint s)
  {
      fprintf (logFp, "glClearStencil (%d)\n", s);
      (*nativeRenderTable->ClearStencil) (s);
  }
  
  static void
  logClipPlane (GLenum	     plane,
  	      const GLdouble *equation)
  {
      fprintf (logFp, "glClipPlane (0x%x, %p)\n", plane, equation);
      (*nativeRenderTable->ClipPlane) (plane, equation);
  }
  
  static void
  logColor3bv (const GLbyte *v)
  {
      vCnt[color3bvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3bv (%p)\n", v);
      (*nativeRenderTable->Color3bv) (v);
  }
  
  static void
  logColor3dv (const GLdouble *v)
  {
      vCnt[color3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3dv (%p)\n", v);
      (*nativeRenderTable->Color3dv) (v);
  }
  
  static void
  logColor3fv (const GLfloat *v)
  {
      vCnt[color3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3fv (%p)\n", v);
      (*nativeRenderTable->Color3fv) (v);
  }
  
  static void
  logColor3iv (const GLint *v)
  {
      vCnt[color3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3iv (%p)\n", v);
      (*nativeRenderTable->Color3iv) (v);
  }
  
  static void
  logColor3sv (const GLshort *v)
  {
      vCnt[color3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3sv (%p)\n", v);
      (*nativeRenderTable->Color3sv) (v);
  }
  
  static void
  logColor3ubv (const GLubyte *v)
  {
      vCnt[color3ubvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3ubv (%p)\n", v);
      (*nativeRenderTable->Color3ubv) (v);
  }
  
  static void
  logColor3uiv (const GLuint *v)
  {
      vCnt[color3uivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3uiv (%p)\n", v);
      (*nativeRenderTable->Color3uiv) (v);
  }
  
  static void
  logColor3usv (const GLushort *v)
  {
      vCnt[color3usvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor3usv (%p)\n", v);
      (*nativeRenderTable->Color3usv) (v);
  }
  
  static void
  logColor4bv (const GLbyte *v)
  {
      vCnt[color4bvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4bv (%p)\n", v);
      (*nativeRenderTable->Color4bv) (v);
  }
  
  static void
  logColor4dv (const GLdouble *v)
  {
      vCnt[color4dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4dv (%p)\n", v);
      (*nativeRenderTable->Color4dv) (v);
  }
  
  static void
  logColor4fv (const GLfloat *v)
  {
      vCnt[color4fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4fv (%p)\n", v);
      (*nativeRenderTable->Color4fv) (v);
  }
  
  static void
  logColor4iv (const GLint *v)
  {
      vCnt[color4ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4iv (%p)\n", v);
      (*nativeRenderTable->Color4iv) (v);
  }
  
  static void
  logColor4sv (const GLshort *v)
  {
      vCnt[color4svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4sv (%p)\n", v);
      (*nativeRenderTable->Color4sv) (v);
  }
  
  static void
  logColor4ubv (const GLubyte *v)
  {
      vCnt[color4ubvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4ubv (%p)\n", v);
      (*nativeRenderTable->Color4ubv) (v);
  }
  
  static void
  logColor4uiv(const GLuint *v)
  {
      vCnt[color4uivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4uiv (%p)\n", v);
      (*nativeRenderTable->Color4uiv) (v);
  }
  
  static void
  logColor4usv (const GLushort *v)
  {
      vCnt[color4usvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glColor4usv (%p)\n", v);
      (*nativeRenderTable->Color4usv) (v);
  }
  
  static void
  logColorMask (GLboolean red,
  	      GLboolean green,
  	      GLboolean blue,
  	      GLboolean alpha)
  {
      fprintf (logFp, "glColorMask (%d, %d, %d, %d)\n", red, green, blue, alpha);
      (*nativeRenderTable->ColorMask) (red, green, blue, alpha);
  }
  
  static void
  logColorMaterial (GLenum face,
  		  GLenum mode)
  {
      fprintf (logFp, "glColorMaterial (0x%x, 0x%x)\n", face, mode);
      (*nativeRenderTable->ColorMaterial) (face, mode);
  }
  
  static void
  logColorPointer (GLint	    size,
  		 GLenum	    type,
  		 GLsizei    stride,
  		 const void *pointer)
  {
      fprintf (logFp, "glColorPointer (%d, 0x%x, %d, %p)\n",
  	     size, type, stride, pointer);
      (*nativeRenderTable->ColorPointer) (size, type, stride, pointer);
  }
  
  static void
  logCopyPixels (GLint   x,
  	       GLint   y,
  	       GLsizei width,
  	       GLsizei height,
  	       GLenum  type)
  {
      fprintf (logFp, "glCopyPixels (%d, %d, %d, %d, 0x%x)\n",
  	     x, y, width, height, type);
      (*nativeRenderTable->CopyPixels) (x, y, width, height, type);
  }
  
  static void
  logCopyTexImage1D (GLenum  target,
  		   GLint   level,
  		   GLenum  internalFormat,
  		   GLint   x,
  		   GLint   y,
  		   GLsizei width,
  		   GLint   border)
  {
      fprintf (logFp, "glCopyTexImage1D (0x%x, %d, 0x%x, %d, %d, %d, %d)\n",
  	     target, level, internalFormat, x, y, width, border);
      (*nativeRenderTable->CopyTexImage1D) (target, level, internalFormat,
  					  x, y, width, border);
  }
  
  static void
  logCopyTexImage2D (GLenum  target,
  		   GLint   level,
  		   GLenum  internalFormat,
  		   GLint   x,
  		   GLint   y,
  		   GLsizei width,
  		   GLsizei height,
  		   GLint   border)
  {
      fprintf (logFp, "glCopyTexImage2D (0x%x, %d, 0x%x, %d, %d, %d, %d, %d)\n",
  	     target, level, internalFormat, x, y, width, height, border);
      (*nativeRenderTable->CopyTexImage2D) (target, level, internalFormat,
  					  x, y, width, height, border);
  }
  
  static void
  logCopyTexSubImage1D (GLenum  target,
  		      GLint   level,
  		      GLint   xoffset,
  		      GLint   x,
  		      GLint   y,
  		      GLsizei width)
  {
      fprintf (logFp, "glCopyTexSubImage1D (0x%x, %d, %d, %d, %d, %d)\n",
  	     target, level, xoffset, x, y, width);
      (*nativeRenderTable->CopyTexSubImage1D) (target, level, xoffset, x, y,
  					     width);
  }
  
  static void
  logCopyTexSubImage2D (GLenum  target,
  		      GLint   level,
  		      GLint   xoffset,
  		      GLint   yoffset,
  		      GLint   x,
  		      GLint   y,
  		      GLsizei width,
  		      GLsizei height)
  {
      fprintf (logFp, "glCopyTexSubImage2D (0x%x, %d, %d, %d, %d, %d, %d, %d)\n",
  	     target, level, xoffset, yoffset, x, y, width, height);
      (*nativeRenderTable->CopyTexSubImage2D) (target, level,
  					     xoffset, yoffset, x, y,
  					     width, height);
  }
  
  static void
  logCullFace (GLenum mode)
  {
      fprintf (logFp, "glCullFace (0x%x)\n", mode);
      (*nativeRenderTable->CullFace) (mode);
  }
  
  static void
  logDeleteLists (GLuint  list,
  		GLsizei range)
  {
      fprintf (logFp, "glDeleteLists (%d, %d)\n", list, range);
      (*nativeRenderTable->DeleteLists) (list, range);
  }
  
  static void
  logDeleteTextures (GLsizei n, const GLuint *textures)
  {
      fprintf (logFp, "glDeleteTextures (%d, %p)\n", n, textures);
      (*nativeRenderTable->DeleteTextures) (n, textures);
  }
  
  static void
  logDepthFunc (GLenum func)
  {
      fprintf (logFp, "glDepthFunc (0x%x)\n", func);
      (*nativeRenderTable->DepthFunc) (func);
  }
  
  static void
  logDepthMask (GLboolean flag)
  {
      fprintf (logFp, "glDepthMask (%d)\n", flag);
      (*nativeRenderTable->DepthMask) (flag);
  }
  
  static void
  logDepthRange (GLclampd zNear,
  	       GLclampd zFar)
  {
      fprintf (logFp, "glDepthRange (%f, %f)\n", zNear, zFar);
      (*nativeRenderTable->DepthRange) (zNear, zFar);
  }
  
  static void
  logDisable (GLenum cap)
  {
      fprintf (logFp, "glDisable (0x%x)\n", cap);
      (*nativeRenderTable->Disable) (cap);
  }
  
  static void
  logDisableClientState (GLenum array)
  {
      fprintf (logFp, "glDisableClientState (0x%x)\n", array);
      (*nativeRenderTable->DisableClientState) (array);
  }
  
  static void
  logDrawArrays (GLenum  mode,
  	       GLint   first,
  	       GLsizei count)
  {
      fprintf (logFp, "glDrawArrays (0x%x, %d, %d)\n", mode, first, count);
      (*nativeRenderTable->DrawArrays) (mode, first, count);
  }
  
  static void
  logDrawBuffer (GLenum mode)
  {
      fprintf (logFp, "glDrawBuffer (0x%x)\n", mode);
      (*nativeRenderTable->DrawBuffer) (mode);
  }
  
  static void
  logDrawElements (GLenum     mode,
  		 GLsizei    count,
  		 GLenum	    type,
  		 const void *indices)
  {
      fprintf (logFp, "glDrawElements (0x%x, %d, 0x%x, %p)\n",
  	     mode, count, type, indices);
      (*nativeRenderTable->DrawElements) (mode, count, type, indices);
  }
  
  static void
  logDrawPixels (GLsizei	  width,
  	       GLsizei    height,
  	       GLenum	  format,
  	       GLenum	  type,
  	       const void *pixels)
  {
      fprintf (logFp, "glDrawPixels (%d, %d, 0x%x, 0x%x, %p)\n",
  	     width, height, format, type, pixels);
      (*nativeRenderTable->DrawPixels) (width, height, format, type, pixels);
  }
  
  static void
  logEdgeFlagPointer (GLsizei    stride,
  		    const void *pointer)
  {
      fprintf (logFp, "glEdgeFlagPointer (%d, %p)", stride, pointer);
      (*nativeRenderTable->EdgeFlagPointer) (stride, pointer);
  }
  
  static void
  logEdgeFlagv (const GLboolean *flag)
  {
      vCnt[edgeFlagvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEdgeFlagv (%p)\n", flag);
      (*nativeRenderTable->EdgeFlagv) (flag);
  }
  
  static void
  logEnable (GLenum cap)
  {
      fprintf (logFp, "glEnable (0x%x)\n", cap);
      (*nativeRenderTable->Enable) (cap);
  }
  
  static void
  logEnableClientState (GLenum array)
  {
      fprintf (logFp, "glEnableClientState (0x%x)\n", array);
      (*nativeRenderTable->EnableClientState) (array);
  }
  
  static void
  logEnd (void)
  {
      int i;
  
      for (i = 0; i < sizeof (vCnt) / sizeof (vCnt[0]); i++)
      {
  	if (vCnt[i].n)
  	{
  	    fprintf (logFp, "  %s: %d\n", vCnt[i].name, vCnt[i].n);
  	    vCnt[i].n = 0;
  	}
      }
  
      fprintf (logFp, "glEnd ()\n" );
      (*nativeRenderTable->End) ();
  }
  
  static void
  logEndList (void)
  {
      fprintf (logFp, "glEndList ()\n" );
      (*nativeRenderTable->EndList) ();
  }
  
  static void
  logEvalCoord1dv (const GLdouble *u)
  {
      vCnt[evalCoord1dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalCoord1dv (%p)\n", u);
      (*nativeRenderTable->EvalCoord1dv) (u);
  }
  
  static void
  logEvalCoord1fv (const GLfloat *u)
  {
      vCnt[evalCoord1fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalCoord1fv (%p)\n", u);
      (*nativeRenderTable->EvalCoord1fv) (u);
  }
  
  static void
  logEvalCoord2dv (const GLdouble *u)
  {
      vCnt[evalCoord2dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalCoord2dv (%p)\n", u);
      (*nativeRenderTable->EvalCoord2dv) (u);
  }
  
  static void
  logEvalCoord2fv (const GLfloat *u)
  {
      vCnt[evalCoord1fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalCoord2fv (%p)\n", u);
      (*nativeRenderTable->EvalCoord2fv) (u);
  }
  
  static void
  logEvalMesh1 (GLenum mode,
  	      GLint  i1,
  	      GLint  i2)
  {
      fprintf (logFp, "glEvalMesh1 (0x%x, %d, %d)\n", mode, i1, i2);
      (*nativeRenderTable->EvalMesh1) (mode, i1, i2 );
  }
  
  static void
  logEvalMesh2 (GLenum mode,
  	      GLint  i1,
  	      GLint  i2,
  	      GLint  j1,
  	      GLint  j2)
  {
      fprintf (logFp, "glEvalMesh2 (0x%x, %d, %d, %d, %d)\n",
  	     mode, i1, i2, j1, j2);
      (*nativeRenderTable->EvalMesh2) (mode, i1, i2, j1, j2);
  }
  
  static void
  logEvalPoint1 (GLint i)
  {
      vCnt[evalPoint1Index].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalPoint1 (%d)\n", i);
      (*nativeRenderTable->EvalPoint1) (i);
  }
  
  static void
  logEvalPoint2 (GLint i, GLint j)
  {
      vCnt[evalPoint2Index].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glEvalPoint2 (%d, %d)\n", i, j);
      (*nativeRenderTable->EvalPoint2) (i, j);
  }
  
  static void
  logFeedbackBuffer (GLsizei size,
  		   GLenum  type,
  		   GLfloat *buffer)
  {
      fprintf (logFp, "glFeedbackBuffer (%d, 0x%x, %p)\n", size, type, buffer);
      (*nativeRenderTable->FeedbackBuffer) (size, type, buffer);
  }
  
  static void
  logFinish (void)
  {
      fprintf (logFp, "glFinish ()\n");
      (*nativeRenderTable->Finish) ();
  }
  
  static void
  logFlush (void)
  {
      fprintf (logFp, "glFlush ()\n");
      (*nativeRenderTable->Flush) ();
  }
  
  static void
  logFogf (GLenum  pname,
  	 GLfloat param)
  {
      fprintf (logFp, "glFogf (0x%x, %f)\n", pname, param);
      (*nativeRenderTable->Fogf) (pname, param);
  }
  
  static void
  logFogfv (GLenum	pname,
  	  const GLfloat *params)
  {
      fprintf (logFp, "glFogfv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->Fogfv) (pname, params);
  }
  
  static void
  logFogi (GLenum pname,
  	 GLint  param)
  {
      fprintf (logFp, "glFogi (0x%x, %d)\n", pname, param);
      (*nativeRenderTable->Fogi) (pname, param);
  }
  
  static void
  logFogiv (GLenum      pname,
  	  const GLint *params)
  {
      fprintf (logFp, "glFogiv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->Fogiv) (pname, params);
  }
  
  static void
  logFrontFace (GLenum mode)
  {
      fprintf (logFp, "glFrontFace (0x%x)\n", mode);
      (*nativeRenderTable->FrontFace) (mode);
  }
  
  static void
  logFrustum (GLdouble left,
  	    GLdouble right,
  	    GLdouble bottom,
  	    GLdouble top,
  	    GLdouble zNear,
  	    GLdouble zFar)
  {
      fprintf (logFp, "glFrustum (%f, %f, %f, %f, %f, %f)\n",
  	     left, right, bottom, top, zNear, zFar);
      (*nativeRenderTable->Frustum) (left, right, bottom, top, zNear, zFar);
  }
  
  static GLuint
  logGenLists (GLsizei range)
  {
      fprintf (logFp, "glGenLists (%d)\n", range);
      return (*nativeRenderTable->GenLists) (range);
  }
  
  static void
  logGenTextures (GLsizei n,
  		GLuint *textures)
  {
      fprintf (logFp, "glGenTextures (%d, %p)\n", n, textures);
      (*nativeRenderTable->GenTextures) (n, textures);
  }
  static void
  logGetBooleanv (GLenum	  pname,
  		GLboolean *params)
  {
      fprintf (logFp, "glGetBooleanv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->GetBooleanv) (pname, params);
  }
  
  static void
  logGetClipPlane (GLenum   plane,
  		 GLdouble *equation)
  {
      fprintf (logFp, "glGetClipPlane (0x%x, %p)\n", plane, equation);
      (*nativeRenderTable->GetClipPlane) (plane, equation);
  }
  
  static void
  logGetDoublev (GLenum   pname,
  	       GLdouble *params)
  {
      fprintf (logFp, "glGetDoublev (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->GetDoublev) (pname, params);
  }
  
  static GLenum
  logGetError (void)
  {
      fprintf (logFp, "glGetError ()\n");
      return (*nativeRenderTable->GetError) ();
  }
  
  static void
  logGetFloatv (GLenum  pname,
  	      GLfloat *params)
  {
      fprintf (logFp, "glGetFloatv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->GetFloatv) (pname, params);
  }
  
  static void
  logGetIntegerv (GLenum pname,
  		GLint  *params)
  {
      fprintf (logFp, "glGetIntegerv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->GetIntegerv) (pname, params);
  }
  
  static void
  logGetLightfv (GLenum  light,
  	       GLenum  pname,
  	       GLfloat *params)
  {
      fprintf (logFp, "glGetLightfv (0x%x, 0x%x, %p)\n", light, pname, params);
      (*nativeRenderTable->GetLightfv) (light, pname, params);
  }
  
  static void
  logGetLightiv (GLenum light,
  	       GLenum pname,
  	       GLint  *params)
  {
      fprintf (logFp, "glGetLightiv (0x%x, 0x%x, %p)\n",
  	     light, pname, params);
      (*nativeRenderTable->GetLightiv) (light, pname, params);
  }
  
  static void
  logGetMapdv (GLenum   target,
  	     GLenum   query,
  	     GLdouble *v)
  {
      fprintf (logFp, "glGetMapdv (0x%x, 0x%x, %p)\n", target, query, v);
      (*nativeRenderTable->GetMapdv) (target, query, v);
  }
  
  static void
  logGetMapfv (GLenum  target,
  	     GLenum  query,
  	     GLfloat *v)
  {
      fprintf (logFp, "glGetMapfv (0x%x, 0x%x, %p)\n", target, query, v);
      (*nativeRenderTable->GetMapfv) (target, query, v);
  }
  
  static void
  logGetMapiv (GLenum target,
  	     GLenum query,
  	     GLint  *v)
  {
      fprintf (logFp, "glGetMapiv (0x%x, 0x%x, %p)\n", target, query, v);
      (*nativeRenderTable->GetMapiv) (target, query, v);
  }
  
  static void
  logGetMaterialfv (GLenum  face,
  		  GLenum  pname,
  		  GLfloat *params)
  {
      fprintf (logFp, "glGetMaterialfv (0x%x, 0x%x, %p)\n", face, pname, params);
      (*nativeRenderTable->GetMaterialfv) (face, pname, params);
  }
  
  static void
  logGetMaterialiv (GLenum face,
  		  GLenum pname,
  		  GLint  *params)
  {
      fprintf (logFp, "glGetMaterialiv (0x%x, 0x%x, %p)\n", face, pname, params);
      (*nativeRenderTable->GetMaterialiv) (face, pname, params);
  }
  
  static void
  logGetPixelMapfv (GLenum  map,
  		  GLfloat *values)
  {
      fprintf (logFp, "glGetPixelMapfv (0x%x, %p)\n", map, values);
      (*nativeRenderTable->GetPixelMapfv) (map, values);
  }
  
  static void
  logGetPixelMapuiv (GLenum map,
  		   GLuint *values)
  {
      fprintf (logFp, "glGetPixelMapuiv (0x%x, %p)\n", map, values);
      (*nativeRenderTable->GetPixelMapuiv) (map, values);
  }
  
  static void
  logGetPixelMapusv (GLenum   map,
  		   GLushort *values)
  {
      fprintf (logFp, "glGetPixelMapusv (0x%x, %p)\n", map, values);
      (*nativeRenderTable->GetPixelMapusv) (map, values);
  }
  
  static void
  logGetPointerv (GLenum pname,
  		GLvoid **params)
  {
      fprintf (logFp, "glGetPointerv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->GetPointerv) (pname, params);
  }
  
  static void
  logGetPolygonStipple (GLubyte *mask)
  {
      fprintf (logFp, "glGetPolygonStipple (%p)\n", mask);
      (*nativeRenderTable->GetPolygonStipple) (mask);
  }
  
  static const GLubyte *
  logGetString (GLenum name)
  {
      fprintf (logFp, "glGetString (0x%x)\n", name);
      return (*nativeRenderTable->GetString) (name);
  }
  
  static void
  logGetTexEnvfv (GLenum  target,
  		GLenum  pname,
  		GLfloat *params)
  {
      fprintf (logFp, "glGetTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params);
      (*nativeRenderTable->GetTexEnvfv) (target, pname, params);
  }
  
  static void
  logGetTexEnviv (GLenum target,
  		GLenum pname,
  		GLint  *params)
  {
      fprintf (logFp, "glGetTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params);
      (*nativeRenderTable->GetTexEnviv) (target, pname, params);
  }
  
  static void
  logGetTexGendv (GLenum   coord,
  		GLenum   pname,
  		GLdouble *params)
  {
      fprintf (logFp, "glGetTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->GetTexGendv) (coord, pname, params);
  }
  
  static void
  logGetTexGenfv (GLenum  coord,
  		GLenum  pname,
  		GLfloat *params)
  {
      fprintf (logFp, "glGetTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->GetTexGenfv) (coord, pname, params);
  }
  
  static void
  logGetTexGeniv (GLenum coord,
  		GLenum pname,
  		GLint  *params)
  {
      fprintf (logFp, "glGetTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->GetTexGeniv) (coord, pname, params);
  }
  
  static void
  logGetTexImage (GLenum target,
  		GLint  level,
  		GLenum format,
  		GLenum type,
  		void   *pixels)
  {
      fprintf (logFp, "glGetTexImage (0x%x, %d, 0x%x, 0x%x, %p)\n",
  	     target, level, format, type, pixels);
      (*nativeRenderTable->GetTexImage) (target, level, format, type,
  				       pixels);
  }
  static void
  logGetTexLevelParameterfv (GLenum  target,
  			   GLint   level,
  			   GLenum  pname,
  			   GLfloat *params)
  {
      fprintf (logFp, "glGetTexLevelParameterfv (0x%x, %d, 0x%x, %p)\n",
  	     target, level, pname, params);
      (*nativeRenderTable->GetTexLevelParameterfv) (target, level,
  						  pname, params);
  }
  
  static void
  logGetTexLevelParameteriv (GLenum target,
  			   GLint  level,
  			   GLenum pname,
  			   GLint  *params)
  {
      fprintf (logFp, "glGetTexLevelParameteriv (0x%x, %d, 0x%x, %p)\n",
  	     target, level, pname, params);
      (*nativeRenderTable->GetTexLevelParameteriv) (target, level,
  						  pname, params);
  }
  
  static void
  logGetTexParameterfv (GLenum  target,
  		      GLenum  pname,
  		      GLfloat *params)
  {
      fprintf (logFp, "glGetTexParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetTexParameterfv) (target, pname, params);
  }
  
  static void
  logGetTexParameteriv (GLenum target,
  		      GLenum pname,
  		      GLint  *params)
  {
      fprintf (logFp, "glGetTexParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetTexParameteriv) (target, pname, params);
  }
  
  static void
  logHint (GLenum target,
  	 GLenum mode)
  {
      fprintf (logFp, "glHint (0x%x, 0x%x)\n", target, mode);
      (*nativeRenderTable->Hint) (target, mode);
  }
  
  static void
  logIndexMask (GLuint mask)
  {
      fprintf (logFp, "glIndexMask (%d)\n", mask);
      (*nativeRenderTable->IndexMask) (mask);
  }
  
  static void
  logIndexPointer (GLenum	    type,
  		 GLsizei    stride,
  		 const void *pointer)
  {
      fprintf (logFp, "glIndexPointer (0x%x, %d, %p)\n", type, stride, pointer);
      (*nativeRenderTable->IndexPointer) (type, stride, pointer);
  }
  
  static void
  logIndexdv (const GLdouble *c)
  {
      vCnt[indexdvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glIndexdv (%p)\n", c);
      (*nativeRenderTable->Indexdv) (c);
  }
  
  static void
  logIndexfv (const GLfloat *c)
  {
      vCnt[indexfvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glIndexfv (%p)\n", c);
      (*nativeRenderTable->Indexfv) (c);
  }
  
  static void
  logIndexiv (const GLint *c)
  {
      vCnt[indexivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glIndexiv (%p)\n", c);
      (*nativeRenderTable->Indexiv) (c);
  }
  
  static void
  logIndexsv (const GLshort *c)
  {
      vCnt[indexsvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glIndexsv (%p)\n", c);
      (*nativeRenderTable->Indexsv) (c);
  }
  
  static void
  logIndexubv (const GLubyte *c)
  {
      vCnt[indexubvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glIndexubv (%p)\n", c);
      (*nativeRenderTable->Indexubv) (c);
  }
  
  static void
  logInitNames (void)
  {
      fprintf (logFp, "glInitNames ()\n" );
      (*nativeRenderTable->InitNames) ();
  }
  
  static void
  logInterleavedArrays (GLenum	 format,
  		      GLsizei	 stride,
  		      const void *pointer)
  {
      fprintf (logFp, "glInterleavedArrays (0x%x, %d, %p)\n",
  	     format, stride, pointer);
      (*nativeRenderTable->InterleavedArrays) (format, stride, pointer);
  }
  
  static GLboolean
  logIsEnabled (GLenum cap)
  {
      fprintf (logFp, "glIsEnabled (0x%x)\n", cap);
      return (*nativeRenderTable->IsEnabled) (cap);
  }
  
  static GLboolean
  logIsList (GLuint list)
  {
      fprintf (logFp, "glIsList (%d)\n", list);
      return (*nativeRenderTable->IsList) (list);
  }
  
  static GLboolean
  logIsTexture (GLuint texture)
  {
      fprintf (logFp, "glIsTexture (%d)\n", texture);
      return (*nativeRenderTable->IsTexture) (texture);
  }
  
  static void
  logLightModelf (GLenum  pname,
  		GLfloat param)
  {
      fprintf (logFp, "glLightModelf (0x%x, %f)\n", pname, param);
      (*nativeRenderTable->LightModelf) (pname, param);
  }
  
  static void
  logLightModelfv (GLenum	       pname,
  		 const GLfloat *params)
  {
      fprintf (logFp, "glLightModelfv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->LightModelfv) (pname, params);
  }
  
  static void
  logLightModeli (GLenum pname,
  		GLint  param)
  {
      fprintf (logFp, "glLightModeli (0x%x, %d)\n", pname, param);
      (*nativeRenderTable->LightModeli) (pname, param);
  }
  
  static void
  logLightModeliv (GLenum	     pname,
  		 const GLint *params)
  {
      fprintf (logFp, "glLightModeliv (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->LightModeliv) (pname, params);
  }
  
  static void
  logLightf (GLenum  light,
  	   GLenum  pname,
  	   GLfloat param)
  {
      fprintf (logFp, "glLightf (0x%x, 0x%x, %f)\n", light, pname, param);
      (*nativeRenderTable->Lightf) (light, pname, param);
  }
  
  static void
  logLightfv (GLenum	  light,
  	    GLenum	  pname,
  	    const GLfloat *params)
  {
      fprintf (logFp, "glLightfv (0x%x, 0x%x, %p)\n", light, pname, params);
      (*nativeRenderTable->Lightfv) (light, pname, params);
  }
  
  static void
  logLighti (GLenum light,
  	   GLenum pname,
  	   GLint  param)
  {
      fprintf (logFp, "glLighti (0x%x, 0x%x, %d)\n", light, pname, param);
      (*nativeRenderTable->Lighti) (light, pname, param);
  }
  
  static void
  logLightiv (GLenum	light,
  	    GLenum	pname,
  	    const GLint *params)
  {
      fprintf (logFp, "glLightiv (0x%x, 0x%x, %p)\n", light, pname, params);
      (*nativeRenderTable->Lightiv) (light, pname, params);
  }
  
  static void
  logLineStipple (GLint    factor,
  		GLushort pattern)
  {
      fprintf (logFp, "glLineStipple (%d, %d)\n", factor, pattern);
      (*nativeRenderTable->LineStipple) (factor, pattern);
  }
  
  static void
  logLineWidth (GLfloat width)
  {
      fprintf (logFp, "glLineWidth (%f)\n", width);
      (*nativeRenderTable->LineWidth) (width);
  }
  
  static void
  logListBase (GLuint base)
  {
      fprintf (logFp, "glListBase (%d)\n", base);
      (*nativeRenderTable->ListBase) (base);
  }
  
  static void
  logLoadIdentity (void)
  {
      fprintf (logFp, "glLoadIdentity ()\n");
      (*nativeRenderTable->LoadIdentity) ();
  }
  
  static void
  logLoadMatrixd (const GLdouble *m)
  {
      fprintf (logFp, "glLoadMatrixd (%p)\n", m);
      (*nativeRenderTable->LoadMatrixd) (m);
  }
  
  static void
  logLoadMatrixf (const GLfloat *m)
  {
      fprintf (logFp, "glLoadMatrixf (%p)\n", m);
      (*nativeRenderTable->LoadMatrixf) (m);
  }
  
  static void
  logLoadName (GLuint name)
  {
      fprintf (logFp, "glLoadName (%d)\n", name);
      (*nativeRenderTable->LoadName) (name);
  }
  
  static void
  logLogicOp (GLenum opcode)
  {
      fprintf (logFp, "glLogicOp(0x%x)\n", opcode);
      (*nativeRenderTable->LogicOp) (opcode);
  }
  
  static void
  logMap1d (GLenum	 target,
  	  GLdouble	 u1,
  	  GLdouble	 u2,
  	  GLint		 stride,
  	  GLint		 order,
  	  const GLdouble *points)
  {
      fprintf (logFp, "glMap1d (0x%x, %f, %f, %d, %d, %p)\n",
  	     target, u1, u2, stride, order, points);
      (*nativeRenderTable->Map1d) (target, u1, u2, stride, order, points);
  }
  
  static void
  logMap1f (GLenum	target,
  	  GLfloat	u1,
  	  GLfloat	u2,
  	  GLint		stride,
  	  GLint		order,
  	  const GLfloat *points)
  {
      fprintf (logFp, "glMap1f (0x%x, %f, %f, %d, %d, %p)\n",
  	     target, u1, u2, stride, order, points);
      (*nativeRenderTable->Map1f) (target, u1, u2, stride, order, points);
  }
  
  static void
  logMap2d (GLenum	 target,
  	  GLdouble	 u1,
  	  GLdouble	 u2,
  	  GLint		 ustride,
  	  GLint		 uorder,
  	  GLdouble	 v1,
  	  GLdouble	 v2,
  	  GLint		 vstride,
  	  GLint		 vorder,
  	  const GLdouble *points)
  {
      fprintf (logFp, "glMap2d (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n",
  	     target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
      (*nativeRenderTable->Map2d) (target, u1, u2, ustride, uorder, v1, v2,
  				 vstride, vorder, points);
  }
  
  static void
  logMap2f (GLenum	target,
  	  GLfloat	u1,
  	  GLfloat	u2,
  	  GLint		ustride,
  	  GLint		uorder,
  	  GLfloat	v1,
  	  GLfloat	v2,
  	  GLint		vstride,
  	  GLint		vorder,
  	  const GLfloat *points)
  {
      fprintf (logFp, "glMap2f (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n",
  	     target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
      (*nativeRenderTable->Map2f) (target, u1, u2, ustride, uorder, v1, v2,
  				 vstride, vorder, points);
  }
  
  static void
  logMapGrid1d (GLint    un,
  	      GLdouble u1,
  	      GLdouble u2)
  {
      fprintf (logFp, "glMapGrid1d (%d, %f, %f)\n", un, u1, u2);
      (*nativeRenderTable->MapGrid1d) (un, u1, u2);
  }
  
  static void
  logMapGrid1f (GLint   un,
  	      GLfloat u1,
  	      GLfloat u2)
  {
      fprintf (logFp, "glMapGrid1f (%d, %f, %f)\n", un, u1, u2);
      (*nativeRenderTable->MapGrid1f) (un, u1, u2);
  }
  
  static void
  logMapGrid2d (GLint    un,
  	      GLdouble u1,
  	      GLdouble u2,
  	      GLint    vn,
  	      GLdouble v1,
  	      GLdouble v2)
  {
      fprintf (logFp, "glMapGrid2d (%d, %f, %f, %d, %f, %f)\n",
  	     un, u1, u2, vn, v1, v2);
      (*nativeRenderTable->MapGrid2d) (un, u1, u2, vn, v1, v2);
  }
  
  static void
  logMapGrid2f (GLint   un,
  	      GLfloat u1,
  	      GLfloat u2,
  	      GLint   vn,
  	      GLfloat v1,
  	      GLfloat v2)
  {
      fprintf (logFp, "glMapGrid2f (%d, %f, %f, %d, %f, %f)\n",
  	     un, u1, u2, vn, v1, v2);
      (*nativeRenderTable->MapGrid2f) (un, u1, u2, vn, v1, v2);
  }
  
  static void
  logMaterialf (GLenum  face,
  	      GLenum  pname,
  	      GLfloat param)
  {
      vCnt[materialfIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMaterialf (0x%x, 0x%x, %f)\n", face, pname, param);
      (*nativeRenderTable->Materialf) (face, pname, param);
  }
  
  static void
  logMaterialfv (GLenum	     face,
  	       GLenum	     pname,
  	       const GLfloat *params)
  {
      vCnt[materialfvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMaterialfv (0x%x, 0x%x, %p)\n",
  		 face, pname, params);
      (*nativeRenderTable->Materialfv) (face, pname, params);
  }
  
  static void
  logMateriali (GLenum face,
  	      GLenum pname,
  	      GLint  param)
  {
      vCnt[materialiIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMateriali (0x%x, 0x%x, %d)\n", face, pname, param);
      (*nativeRenderTable->Materiali) (face, pname, param);
  }
  
  static void
  logMaterialiv (GLenum	   face,
  	       GLenum	   pname,
  	       const GLint *params)
  {
      vCnt[materialivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMaterialiv (0x%x, 0x%x, %p)\n",
  		 face, pname, params);
      (*nativeRenderTable->Materialiv) (face, pname, params);
  }
  
  static void
  logMatrixMode (GLenum mode)
  {
      fprintf (logFp, "glMatrixMode (0x%x)\n", mode);
      (*nativeRenderTable->MatrixMode) (mode);
  }
  
  static void
  logMultMatrixd (const GLdouble *m)
  {
      fprintf (logFp, "glMultMatrixd (%p)\n", m);
      (*nativeRenderTable->MultMatrixd) (m);
  }
  
  static void
  logMultMatrixf (const GLfloat *m)
  {
      fprintf (logFp, "glMultMatrixf (%p)\n", m);
      (*nativeRenderTable->MultMatrixf) (m);
  }
  
  static void
  logNewList (GLuint list,
  	    GLenum mode)
  {
      fprintf (logFp, "glNewList (%d, 0x%x)\n", list, mode);
      (*nativeRenderTable->NewList) (list, mode);
  }
  
  static void
  logNormal3bv (const GLbyte *v)
  {
      vCnt[normal3bvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glNormal3bv (%p)\n", v);
      (*nativeRenderTable->Normal3bv) (v);
  }
  
  static void
  logNormal3dv (const GLdouble *v)
  {
      vCnt[normal3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glNormal3dv (%p)\n", v);
      (*nativeRenderTable->Normal3dv) (v);
  }
  
  static void
  logNormal3fv (const GLfloat *v)
  {
      vCnt[normal3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glNormal3fv (%p)\n", v);
      (*nativeRenderTable->Normal3fv) (v);
  }
  
  static void
  logNormal3iv (const GLint *v)
  {
      vCnt[normal3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glNormal3iv (%p)\n", v);
      (*nativeRenderTable->Normal3iv) (v);
  }
  
  static void
  logNormal3sv (const GLshort *v)
  {
      vCnt[normal3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glNormal3sv (%p)\n", v);
      (*nativeRenderTable->Normal3sv) (v);
  }
  
  static void
  logNormalPointer (GLenum     type,
  		  GLsizei    stride,
  		  const void *pointer)
  {
      fprintf (logFp, "glNormalPointer (0x%x, %d, %p)\n", type, stride, pointer);
      (*nativeRenderTable->NormalPointer) (type, stride, pointer);
  }
  
  static void
  logOrtho (GLdouble left,
  	  GLdouble right,
  	  GLdouble bottom,
  	  GLdouble top,
  	  GLdouble zNear,
  	  GLdouble zFar)
  {
      fprintf (logFp, "glOrtho (%f, %f, %f, %f, %f, %f)\n",
  	     left, right, bottom, top, zNear, zFar);
      (*nativeRenderTable->Ortho) (left, right, bottom, top, zNear, zFar);
  }
  
  static void
  logPassThrough (GLfloat token)
  {
      fprintf (logFp, "glPassThrough (%f)\n", token);
      (*nativeRenderTable->PassThrough) (token);
  }
  
  static void
  logPixelMapfv (GLenum	     map,
  	       GLsizei	     mapsize,
  	       const GLfloat *values)
  {
      fprintf (logFp, "glPixelMapfv (0x%x, %d, %p)\n", map, mapsize, values);
      (*nativeRenderTable->PixelMapfv) (map, mapsize, values);
  }
  
  static void
  logPixelMapuiv (GLenum	     map,
  		GLsizei	     mapsize,
  		const GLuint *values)
  {
      fprintf (logFp, "glPixelMapuiv (0x%x, %d, %p)\n", map, mapsize, values);
      (*nativeRenderTable->PixelMapuiv) (map, mapsize, values);
  }
  
  static void
  logPixelMapusv (GLenum	       map,
  		GLsizei	       mapsize,
  		const GLushort *values)
  {
      fprintf (logFp, "glPixelMapusv (0x%x, %d, %p)\n", map, mapsize, values);
      (*nativeRenderTable->PixelMapusv) (map, mapsize, values);
  }
  
  static void
  logPixelStoref (GLenum  pname,
  		GLfloat param)
  {
      fprintf (logFp, "glPixelStoref (0x%x, %f)\n", pname, param);
      (*nativeRenderTable->PixelStoref) (pname, param);
  }
  
  static void
  logPixelStorei (GLenum pname,
  		GLint  param)
  {
      fprintf (logFp, "glPixelStorei (0x%x, %d)\n", pname, param);
      (*nativeRenderTable->PixelStorei) (pname, param);
  }
  
  static void
  logPixelTransferf (GLenum pname, GLfloat param)
  {
      fprintf (logFp, "glPixelTransferf (0x%x, %f)\n", pname, param);
      (*nativeRenderTable->PixelTransferf) (pname, param);
  }
  
  static void
  logPixelTransferi (GLenum pname,
  		   GLint  param)
  {
      fprintf (logFp, "glPixelTransferi (0x%x, %d)\n", pname, param);
      (*nativeRenderTable->PixelTransferi) (pname, param);
  }
  
  static void
  logPixelZoom (GLfloat xfactor,
  	      GLfloat yfactor)
  {
      fprintf (logFp, "glPixelZoom (%f, %f)\n", xfactor, yfactor);
      (*nativeRenderTable->PixelZoom) (xfactor, yfactor);
  }
  
  static void
  logPointSize (GLfloat size)
  {
      fprintf (logFp, "glPointSize" );
      (*nativeRenderTable->PointSize) (size);
  }
  
  static void
  logPolygonMode (GLenum face,
  		GLenum mode)
  {
      fprintf (logFp, "glPolygonMode (0x%x, 0x%x)\n", face, mode );
      (*nativeRenderTable->PolygonMode) (face, mode);
  }
  
  static void
  logPolygonOffset (GLfloat factor,
  		  GLfloat units)
  {
      fprintf (logFp, "glPolygonOffset (%f, %f)\n", factor, units);
      (*nativeRenderTable->PolygonOffset) (factor, units);
  }
  
  static void
  logPolygonStipple (const GLubyte *mask)
  {
      fprintf (logFp, "glPolygonStipple (%p)\n", mask);
      (*nativeRenderTable->PolygonStipple) (mask);
  }
  
  static void
  logPopAttrib (void)
  {
      fprintf (logFp, "glPopAttrib ()\n");
      (*nativeRenderTable->PopAttrib) ();
  }
  
  static void
  logPopClientAttrib (void)
  {
      fprintf (logFp, "glPopClientAttrib ()\n" );
      (*nativeRenderTable->PopClientAttrib) ();
  }
  
  static void
  logPopMatrix (void)
  {
      fprintf (logFp, "glPopMatrix ()\n" );
      (*nativeRenderTable->PopMatrix) ();
  }
  
  static void
  logPopName (void)
  {
      fprintf (logFp, "glPopName ()\n");
      (*nativeRenderTable->PopName) ();
  }
  
  static void
  logPrioritizeTextures (GLsizei	      n,
  		       const GLuint   *textures,
  		       const GLclampf *priorities)
  {
      fprintf (logFp, "glPrioritizeTextures (%d, %p, %p)\n",
  	     n, textures, priorities);
      (*nativeRenderTable->PrioritizeTextures) (n, textures, priorities);
  }
  
  static void
  logPushAttrib (GLbitfield mask)
  {
      fprintf (logFp, "glPushAttrib (0x%x)\n", mask);
      (*nativeRenderTable->PushAttrib) (mask);
  }
  
  static void
  logPushClientAttrib (GLbitfield mask)
  {
      fprintf (logFp, "glPushClientAttrib (0x%x)\n", mask);
      (*nativeRenderTable->PushClientAttrib) (mask);
  }
  
  static void
  logPushMatrix (void)
  {
      fprintf (logFp, "glPushMatrix ()\n" );
      (*nativeRenderTable->PushMatrix) ();
  }
  
  static void
  logPushName (GLuint name)
  {
      fprintf (logFp, "glPushName (%d)\n", name);
      (*nativeRenderTable->PushName) (name);
  }
  
  static void
  logRasterPos2dv (const GLdouble *v)
  {
      fprintf (logFp, "glRasterPos2dv (%p)\n", v);
      (*nativeRenderTable->RasterPos2dv) (v);
  }
  
  static void
  logRasterPos2fv (const GLfloat *v)
  {
      fprintf (logFp, "glRasterPos2dv (%p)\n", v);
      (*nativeRenderTable->RasterPos2fv) (v);
  }
  
  static void
  logRasterPos2iv (const GLint *v)
  {
      fprintf (logFp, "glRasterPos2iv (%p)\n", v);
      (*nativeRenderTable->RasterPos2iv) (v);
  }
  
  static void
  logRasterPos2sv (const GLshort *v)
  {
      fprintf (logFp, "glRasterPos2sv (%p)\n", v);
      (*nativeRenderTable->RasterPos2sv) (v);
  }
  
  static void
  logRasterPos3dv (const GLdouble *v)
  {
      fprintf (logFp, "glRasterPos3dv (%p)\n", v);
      (*nativeRenderTable->RasterPos3dv) (v);
  }
  
  static void
  logRasterPos3fv (const GLfloat *v)
  {
      fprintf (logFp, "glRasterPos3fv (%p)\n", v);
      (*nativeRenderTable->RasterPos3fv) (v);
  }
  
  static void
  logRasterPos3iv (const GLint *v)
  {
      fprintf (logFp, "glRasterPos3iv (%p)\n", v);
      (*nativeRenderTable->RasterPos3iv) (v);
  }
  
  static void
  logRasterPos3sv (const GLshort *v)
  {
      fprintf (logFp, "glRasterPos3sv (%p)\n", v);
      (*nativeRenderTable->RasterPos3sv) (v);
  }
  
  static void
  logRasterPos4dv (const GLdouble *v)
  {
      fprintf (logFp, "glRasterPos4dv (%p)\n", v);
      (*nativeRenderTable->RasterPos4dv) (v);
  }
  
  static void
  logRasterPos4fv (const GLfloat *v)
  {
      fprintf (logFp, "glRasterPos4fv (%p)\n", v);
      (*nativeRenderTable->RasterPos4fv) (v);
  }
  
  static void
  logRasterPos4iv (const GLint *v)
  {
      fprintf (logFp, "glRasterPos4iv (%p)\n", v);
      (*nativeRenderTable->RasterPos4iv) (v);
  }
  
  static void
  logRasterPos4sv (const GLshort *v)
  {
      fprintf (logFp, "glRasterPos4sv (%p)\n", v);
      (*nativeRenderTable->RasterPos4sv) (v);
  }
  
  static void
  logReadBuffer (GLenum mode)
  {
      fprintf (logFp, "glReadBuffer (0x%x)\n", mode);
      (*nativeRenderTable->ReadBuffer) (mode);
  }
  
  static void
  logReadPixels (GLint   x,
  	       GLint   y,
  	       GLsizei width,
  	       GLsizei height,
  	       GLenum  format,
  	       GLenum  type,
  	       void    *pixels)
  {
      fprintf (logFp, "glReadPixels (%d, %d, %d, %d, 0x%x, 0x%x, %p)\n",
  	     x, y, width, height, format, type, pixels);
      (*nativeRenderTable->ReadPixels) (x, y, width, height, format, type,
  				      pixels);
  }
  
  static void
  logRectdv (const GLdouble *v1,
  	   const GLdouble *v2)
  {
      fprintf (logFp, "glRectdv (%p, %p)\n", v1, v2);
      (*nativeRenderTable->Rectdv) (v1, v2);
  }
  
  static void
  logRectfv (const GLfloat *v1,
  	   const GLfloat *v2)
  {
      fprintf (logFp, "glRectfv (%p, %p)\n", v1, v2);
      (*nativeRenderTable->Rectfv) (v1, v2);
  }
  
  static void
  logRectiv (const GLint *v1,
  	   const GLint *v2)
  {
      fprintf (logFp, "glRectiv (%p, %p)\n", v1, v2);
      (*nativeRenderTable->Rectiv) (v1, v2);
  }
  
  static void
  logRectsv (const GLshort *v1,
  	   const GLshort *v2)
  {
      fprintf (logFp, "glRectsv (%p, %p)\n", v1, v2);
      (*nativeRenderTable->Rectsv) (v1, v2);
  }
  
  static GLint
  logRenderMode (GLenum mode)
  {
      fprintf (logFp, "glRenderMode (0x%x)\n", mode);
      return (*nativeRenderTable->RenderMode) (mode);
  }
  
  static void
  logRotated (GLdouble angle,
  	    GLdouble x,
  	    GLdouble y,
  	    GLdouble z)
  {
      fprintf (logFp, "glRotated (%f, %f, %f, %f)\n", angle, x, y, z);
      (*nativeRenderTable->Rotated) (angle, x, y, z);
  }
  
  static void
  logRotatef (GLfloat angle,
  	    GLfloat x,
  	    GLfloat y,
  	    GLfloat z)
  {
      fprintf (logFp, "glRotatef (%f, %f, %f, %f)\n", angle, x, y, z);
      (*nativeRenderTable->Rotatef) (angle, x, y, z);
  }
  
  static void
  logScaled (GLdouble x,
  	   GLdouble y,
  	   GLdouble z)
  {
      fprintf (logFp, "glScaled (%f, %f, %f)\n", x, y, z);
      (*nativeRenderTable->Scaled) (x, y, z);
  }
  
  static void
  logScalef (GLfloat x,
  	   GLfloat y,
  	   GLfloat z)
  {
      fprintf (logFp, "glScalef (%f, %f, %f)\n", x, y, z);
      (*nativeRenderTable->Scalef) (x, y, z);
  }
  
  static void
  logScissor (GLint   x,
  	    GLint   y,
  	    GLsizei width,
  	    GLsizei height)
  {
      fprintf (logFp, "glScissor (%d, %d, %d, %d)\n", x, y, width, height);
      (*nativeRenderTable->Scissor) (x, y, width, height);
  }
  
  static void
  logSelectBuffer (GLsizei size,
  		 GLuint  *buffer)
  {
      fprintf (logFp, "glSelectBuffer (%d, %p)\n", size, buffer);
      (*nativeRenderTable->SelectBuffer) (size, buffer);
  }
  
  static void
  logShadeModel (GLenum mode)
  {
      fprintf (logFp, "glShadeModel (0x%x)\n", mode);
      (*nativeRenderTable->ShadeModel) (mode);
  }
  
  static void
  logStencilFunc (GLenum func,
  		GLint  ref,
  		GLuint mask)
  {
      fprintf (logFp, "glStencilFunc (0x%x, %d, %d)\n", func, ref, mask);
      (*nativeRenderTable->StencilFunc) (func, ref, mask);
  }
  
  static void
  logStencilMask (GLuint mask)
  {
      fprintf (logFp, "glStencilMask (0x%x)\n", mask);
      (*nativeRenderTable->StencilMask) (mask);
  }
  
  static void
  logStencilOp (GLenum fail,
  	      GLenum zfail,
  	      GLenum zpass)
  {
      fprintf (logFp, "glStencilOp (0x%x, 0x%x, 0x%x)\n", fail, zfail, zpass);
      (*nativeRenderTable->StencilOp) (fail, zfail, zpass);
  }
  
  static void
  logTexCoord1dv (const GLdouble *v)
  {
      vCnt[texCoord1dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord1dv (%p)\n", v);
      (*nativeRenderTable->TexCoord1dv) (v);
  }
  
  static void
  logTexCoord1fv (const GLfloat *v)
  {
      vCnt[texCoord1fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord1fv (%p)\n", v);
      (*nativeRenderTable->TexCoord1fv) (v);
  }
  
  static void
  logTexCoord1iv (const GLint *v)
  {
      vCnt[texCoord1ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord1iv (%p)\n", v);
      (*nativeRenderTable->TexCoord1iv) (v);
  }
  
  static void
  logTexCoord1sv (const GLshort *v)
  {
      vCnt[texCoord1svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord1sv (%p)\n", v);
      (*nativeRenderTable->TexCoord1sv) (v);
  }
  
  static void
  logTexCoord2dv (const GLdouble *v)
  {
      vCnt[texCoord2dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord2dv (%p)\n", v);
      (*nativeRenderTable->TexCoord2dv) (v);
  }
  
  static void
  logTexCoord2fv (const GLfloat *v)
  {
      vCnt[texCoord2fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord2fv (%p)\n", v);
      (*nativeRenderTable->TexCoord2fv) (v);
  }
  
  static void
  logTexCoord2iv (const GLint *v)
  {
      vCnt[texCoord2ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord2iv (%p)\n", v);
      (*nativeRenderTable->TexCoord2iv) (v);
  }
  
  static void
  logTexCoord2sv (const GLshort *v)
  {
      vCnt[texCoord2svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord2sv (%p)\n", v);
      (*nativeRenderTable->TexCoord2sv) (v);
  }
  
  
  static void
  logTexCoord3dv (const GLdouble *v)
  {
      vCnt[texCoord3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord3dv (%p)\n", v);
      (*nativeRenderTable->TexCoord3dv) (v);
  }
  
  static void
  logTexCoord3fv (const GLfloat *v)
  {
      vCnt[texCoord3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord3fv (%p)\n", v);
      (*nativeRenderTable->TexCoord3fv) (v);
  }
  
  static void
  logTexCoord3iv (const GLint *v)
  {
      vCnt[texCoord3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord3iv (%p)\n", v);
      (*nativeRenderTable->TexCoord3iv) (v);
  }
  
  static void
  logTexCoord3sv (const GLshort *v)
  {
      vCnt[texCoord3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord3sv (%p)\n", v);
      (*nativeRenderTable->TexCoord3sv) (v);
  }
  
  static void
  logTexCoord4dv (const GLdouble *v)
  {
      vCnt[texCoord4dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord4dv (%p)\n", v);
      (*nativeRenderTable->TexCoord4dv) (v);
  }
  
  static void
  logTexCoord4fv (const GLfloat *v)
  {
      vCnt[texCoord4fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord4fv (%p)\n", v);
      (*nativeRenderTable->TexCoord4fv) (v);
  }
  
  static void
  logTexCoord4iv (const GLint *v)
  {
      vCnt[texCoord4ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord4iv (%p)\n", v);
      (*nativeRenderTable->TexCoord4iv) (v);
  }
  
  static void
  logTexCoord4sv (const GLshort *v)
  {
      vCnt[texCoord4svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glTexCoord4sv (%p)\n", v);
      (*nativeRenderTable->TexCoord4sv) (v);
  }
  
  static void
  logTexCoordPointer (GLint      size,
  		    GLenum     type,
  		    GLsizei    stride,
  		    const void *pointer)
  {
      fprintf (logFp, "glTexCoordPointer (%d, 0x%x, %d, %p)\n",
  	     size, type, stride, pointer);
      (*nativeRenderTable->TexCoordPointer) (size, type, stride, pointer);
  }
  
  static void
  logTexEnvf (GLenum  target,
  	    GLenum  pname,
  	    GLfloat param)
  {
      fprintf (logFp, "glTexEnvf (0x%x, 0x%x, %f)\n", target, pname, param);
      (*nativeRenderTable->TexEnvf) (target, pname, param);
  }
  
  static void
  logTexEnvfv (GLenum	   target,
  	     GLenum	   pname,
  	     const GLfloat *params)
  {
      fprintf (logFp, "glTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params);
      (*nativeRenderTable->TexEnvfv) (target, pname, params);
  }
  
  static void
  logTexEnvi (GLenum target,
  	    GLenum pname,
  	    GLint  param)
  {
      fprintf (logFp, "glTexEnvi (0x%x, 0x%x, %d)\n", target, pname, param);
      (*nativeRenderTable->TexEnvi) (target, pname, param);
  }
  
  static void
  logTexEnviv (GLenum	 target,
  	     GLenum	 pname,
  	     const GLint *params)
  {
      fprintf (logFp, "glTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params);
      (*nativeRenderTable->TexEnviv) (target, pname, params);
  }
  
  static void
  logTexGend (GLenum   coord,
  	    GLenum   pname,
  	    GLdouble param)
  {
      fprintf (logFp, "glTexGend (0x%x, 0x%x, %f)\n", coord, pname, param);
      (*nativeRenderTable->TexGend) (coord, pname, param);
  }
  
  static void
  logTexGendv (GLenum	    coord,
  	     GLenum	    pname,
  	     const GLdouble *params)
  {
      fprintf (logFp, "glTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->TexGendv) (coord, pname, params);
  }
  
  static void
  logTexGenf (GLenum  coord,
  	    GLenum  pname,
  	    GLfloat param)
  {
      fprintf (logFp, "glTexGenf (0x%x, 0x%x, %f)\n", coord, pname, param);
      (*nativeRenderTable->TexGenf) (coord, pname, param);
  }
  
  static void
  logTexGenfv (GLenum	   coord,
  	     GLenum	   pname,
  	     const GLfloat *params)
  {
      fprintf (logFp, "glTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->TexGenfv) (coord, pname, params);
  }
  
  static void
  logTexGeni (GLenum coord,
  	    GLenum pname,
  	    GLint  param)
  {
      fprintf (logFp, "glTexGeni (0x%x, 0x%x, %d)\n", coord, pname, param);
      (*nativeRenderTable->TexGeni) (coord, pname, param);
  }
  
  static void
  logTexGeniv (GLenum	 coord,
  	     GLenum	 pname,
  	     const GLint *params)
  {
      fprintf (logFp, "glTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params);
      (*nativeRenderTable->TexGeniv) (coord, pname, params);
  }
  
  static void
  logTexImage1D (GLenum	  target,
  	       GLint	  level,
  	       GLint	  internalformat,
  	       GLsizei	  width,
  	       GLint	  border,
  	       GLenum	  format,
  	       GLenum	  type,
  	       const void *pixels)
  {
      fprintf (logFp, "glTexImage1D (0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)\n",
  	     target, level, internalformat, width, border, format, type,
  	     pixels);
      (*nativeRenderTable->TexImage1D) (target, level, internalformat,
  				      width, border, format, type,
  				      pixels);
  }
  
  static void
  logTexImage2D (GLenum     target,
  	       GLint	  level,
  	       GLint	  internalformat,
  	       GLsizei	  width,
  	       GLsizei	  height,
  	       GLint	  border,
  	       GLenum	  format,
  	       GLenum	  type,
  	       const void *pixels)
  {
      fprintf (logFp, "glTexImage2D (0x%x, %d, %d, %d, %d, %d, "
  	     "0x%x, 0x%x, %p)\n", target, level, internalformat,
  	     width, height, border, format, type, pixels);
      (*nativeRenderTable->TexImage2D) (target, level, internalformat,
  				      width, height, border, format, type,
  				      pixels);
  }
  
  static void
  logTexParameterf (GLenum  target,
  		  GLenum  pname,
  		  GLfloat param)
  {
      fprintf (logFp, "glTexParameterf (0x%x, 0x%x, %f)\n",
  	     target, pname, param);
      (*nativeRenderTable->TexParameterf) (target, pname, param);
  }
  
  static void
  logTexParameterfv (GLenum	 target,
  		   GLenum	 pname,
  		   const GLfloat *params)
  {
      fprintf (logFp, "glTexParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->TexParameterfv) (target, pname, params);
  }
  
  static void
  logTexParameteri (GLenum target,
  		  GLenum pname,
  		  GLint  param)
  {
      fprintf (logFp, "glTexParameteri (0x%x, 0x%x, 0x%x)\n",
  	     target, pname, param);
      (*nativeRenderTable->TexParameteri) (target, pname, param);
  }
  
  static void
  logTexParameteriv (GLenum      target,
  		   GLenum      pname,
  		   const GLint *params)
  {
      fprintf (logFp, "glTexParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->TexParameteriv) (target, pname, params);
  }
  
  static void
  logTexSubImage1D (GLenum     target,
  		  GLint	     level,
  		  GLint	     xoffset,
  		  GLsizei    width,
  		  GLenum     format,
  		  GLenum     type,
  		  const void *pixels)
  {
      fprintf (logFp, "glTexSubImage1D (0x%x, %d, %d, %d, 0x%x, 0x%x, %p)\n",
  	     target, level, xoffset, width, format, type, pixels);
      (*nativeRenderTable->TexSubImage1D) (target, level, xoffset, width,
  					 format, type, pixels);
  }
  
  static void
  logTexSubImage2D (GLenum     target,
  		  GLint	     level,
  		  GLint	     xoffset,
  		  GLint	     yoffset,
  		  GLsizei    width,
  		  GLsizei    height,
  		  GLenum     format,
  		  GLenum     type,
  		  const void *pixels)
  {
      fprintf (logFp, "glTexSubImage2D (0x%x, %d, %d, %d, %d, %d, "
  	     "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset,
  	     width, height, format, type, pixels);
      (*nativeRenderTable->TexSubImage2D) (target, level, xoffset, yoffset,
  					 width, height, format, type,
  					 pixels);
  }
  
  static void
  logTranslated (GLdouble x,
  	       GLdouble y,
  	       GLdouble z)
  {
      fprintf (logFp, "glTranslated (%f, %f, %f)\n", x, y, z);
      (*nativeRenderTable->Translated) (x, y, z);
  }
  
  static void
  logTranslatef (GLfloat x,
  	       GLfloat y,
  	       GLfloat z)
  {
      fprintf (logFp, "glTranslatef (%f, %f, %f)\n", x, y, z);
      (*nativeRenderTable->Translatef) (x, y, z);
  }
  
  static void
  logVertex2dv (const GLdouble *v)
  {
      vCnt[vertex2dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex2dv (%p)\n", v);
      (*nativeRenderTable->Vertex2dv) (v);
  }
  
  static void
  logVertex2fv (const GLfloat *v)
  {
      vCnt[vertex2fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex2dv (%p)\n", v);
      (*nativeRenderTable->Vertex2fv) (v);
  }
  
  static void
  logVertex2iv (const GLint *v)
  {
      vCnt[vertex2ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex2iv (%p)\n", v);
      (*nativeRenderTable->Vertex2iv) (v);
  }
  
  static void
  logVertex2sv (const GLshort *v)
  {
      vCnt[vertex2svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex2sv (%p)\n", v);
      (*nativeRenderTable->Vertex2sv) (v);
  }
  
  static void
  logVertex3dv (const GLdouble *v)
  {
      vCnt[vertex3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex3dv (%p)\n", v);
      (*nativeRenderTable->Vertex3dv) (v);
  }
  
  static void
  logVertex3fv (const GLfloat *v)
  {
      vCnt[vertex3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex3fv (%p)\n", v);
      (*nativeRenderTable->Vertex3fv) (v);
  }
  
  static void
  logVertex3iv (const GLint *v)
  {
      vCnt[vertex3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex3iv (%p)\n", v);
      (*nativeRenderTable->Vertex3iv) (v);
  }
  
  static void
  logVertex3sv (const GLshort *v)
  {
      vCnt[vertex3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex3sv (%p)\n", v);
      (*nativeRenderTable->Vertex3sv) (v);
  }
  
  static void
  logVertex4dv (const GLdouble *v)
  {
      vCnt[vertex4dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex4dv (%p)\n", v);
      (*nativeRenderTable->Vertex4dv) (v);
  }
  
  static void
  logVertex4fv (const GLfloat *v)
  {
      vCnt[vertex4fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex4fv (%p)\n", v);
      (*nativeRenderTable->Vertex4fv) (v);
  }
  
  static void
  logVertex4iv (const GLint *v)
  {
      vCnt[vertex4ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex4iv (%p)\n", v);
      (*nativeRenderTable->Vertex4iv) (v);
  }
  
  static void
  logVertex4sv (const GLshort *v)
  {
      vCnt[vertex4svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glVertex4sv (%p)\n", v);
      (*nativeRenderTable->Vertex4sv) (v);
  }
  
  static void
  logVertexPointer (GLint	     size,
  		  GLenum     type,
  		  GLsizei    stride,
  		  const void *pointer)
  {
      fprintf (logFp, "glVertexPointer (%d, 0x%x, %d, %p)\n",
  	     size, type, stride, pointer);
      (*nativeRenderTable->VertexPointer) (size, type, stride, pointer);
  }
  
  static void
  logViewport (GLint   x,
  	     GLint   y,
  	     GLsizei width,
  	     GLsizei height)
  {
      fprintf (logFp, "glViewport (%d %d %d %d)\n", x, y, width, height);
      (*nativeRenderTable->Viewport) (x, y, width, height);
  }
  
  static void
  logBlendColor (GLclampf red,
  	       GLclampf green,
  	       GLclampf blue,
  	       GLclampf alpha)
  {
      fprintf (logFp, "glBlendColor (%f, %f, %f, %f)\n",
  	     red, green, blue, alpha);
      (*nativeRenderTable->BlendColor) (red, green, blue, alpha);
  }
  
  static void
  logBlendEquation (GLenum mode)
  {
      fprintf (logFp, "glBlendEquation (0x%x)\n", mode);
      (*nativeRenderTable->BlendEquation) (mode);
  }
  
  static void
  logColorTable (GLenum       target,
  	       GLenum       internalformat,
  	       GLsizei      width,
  	       GLenum       format,
  	       GLenum	    type,
  	       const GLvoid *table)
  {
      fprintf (logFp, "glColorTable (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n",
  	     target, internalformat, width, format, type, table);
      (*nativeRenderTable->ColorTable) (target, internalformat, width,
  				      format, type, table);
  }
  
  static void
  logColorTableParameterfv (GLenum	target,
  			  GLenum	pname,
  			  const GLfloat *params)
  {
      fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->ColorTableParameterfv) (target, pname, params);
  }
  
  static void
  logColorTableParameteriv (GLenum      target,
  			  GLenum      pname,
  			  const GLint *params)
  {
      fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->ColorTableParameteriv) (target, pname, params);
  }
  
  static void
  logCopyColorTable (GLenum  target,
  		   GLenum  internalformat,
  		   GLint   x,
  		   GLint   y,
  		   GLsizei width)
  {
      fprintf (logFp, "glCopyColorTable (0x%x, 0x%x, %d, %d, %d)\n",
  	     target, internalformat, x, y, width);
      (*nativeRenderTable->CopyColorTable) (target, internalformat,
  					  x, y, width);
  }
  
  static void
  logGetColorTable (GLenum target,
  		  GLenum format,
  		  GLenum type,
  		  GLvoid *table)
  {
      fprintf (logFp, "glGetColorTable (0x%x, 0x%x, 0x%x, %p)\n",
  	     target, format, type, table);
      (*nativeRenderTable->GetColorTable) (target, format, type, table);
  }
  
  static void
  logGetColorTableParameterfv (GLenum  target,
  			     GLenum  pname,
  			     GLfloat *params)
  {
      fprintf (logFp, "glGetColorTableParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetColorTableParameterfv) (target, pname, params);
  }
  
  static void
  logGetColorTableParameteriv (GLenum target,
  			     GLenum pname,
  			     GLint  *params)
  {
      fprintf (logFp, "glGetColorTableParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetColorTableParameteriv) (target, pname, params);
  }
  
  static void
  logColorSubTable (GLenum       target,
  		  GLsizei      start,
  		  GLsizei      count,
  		  GLenum       format,
  		  GLenum       type,
  		  const GLvoid *data)
  {
      fprintf (logFp, "glColorSubTable (0x%x, %d, %d, 0x%x, 0x%x, %p)\n",
  	     target, start, count, format, type, data);
      (*nativeRenderTable->ColorSubTable) (target, start, count,
  					 format, type, data);
  }
  
  static void
  logCopyColorSubTable (GLenum  target,
  		      GLsizei start,
  		      GLint   x,
  		      GLint   y,
  		      GLsizei width)
  {
      fprintf (logFp, "glCopyColorSubTable (0x%x, %d, %d, %d, %d)\n",
  	     target, start, x, y, width);
      (*nativeRenderTable->CopyColorSubTable) (target, start, x, y, width);
  }
  
  static void
  logConvolutionFilter1D (GLenum	     target,
  			GLenum	     internalformat,
  			GLsizei	     width,
  			GLenum	     format,
  			GLenum	     type,
  			const GLvoid *image)
  {
      fprintf (logFp, "glConvolutionFilter1D (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n",
  	     target, internalformat, width, format, type, image);
      (*nativeRenderTable->ConvolutionFilter1D) (target, internalformat,
  					       width, format, type, image);
  }
  
  static void
  logConvolutionFilter2D (GLenum	     target,
  			GLenum	     internalformat,
  			GLsizei	     width,
  			GLsizei	     height,
  			GLenum	     format,
  			GLenum	     type,
  			const GLvoid *image)
  {
      fprintf (logFp, "glConvolutionFilter2D (0x%x, 0x%x, %d, %d, "
  	     "0x%x, 0x%x, %p)\n", target, internalformat, width, height,
  	     format, type, image);
      (*nativeRenderTable->ConvolutionFilter2D) (target, internalformat,
  					       width, height, format,
  					       type, image);
  }
  
  static void
  logConvolutionParameterf (GLenum  target,
  			  GLenum  pname,
  			  GLfloat param)
  {
      fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %f)\n",
  	     target, pname, param);
      (*nativeRenderTable->ConvolutionParameterf) (target, pname, param);
  }
  
  static void
  logConvolutionParameterfv (GLenum	 target,
  			   GLenum	 pname,
  			   const GLfloat *params)
  {
      fprintf (logFp, "glConvolutionParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->ConvolutionParameterfv) (target, pname, params);
  }
  
  static void
  logConvolutionParameteri (GLenum target,
  			  GLenum pname,
  			  GLint  param)
  {
      fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %d)\n",
  	     target, pname, param);
      (*nativeRenderTable->ConvolutionParameteri) (target, pname, param);
  }
  
  static void
  logConvolutionParameteriv (GLenum      target,
  			   GLenum      pname,
  			   const GLint *params)
  {
      fprintf (logFp, "glConvolutionParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->ConvolutionParameteriv) (target, pname, params);
  }
  
  static void
  logCopyConvolutionFilter1D (GLenum  target,
  			    GLenum  internalformat,
  			    GLint   x,
  			    GLint   y,
  			    GLsizei width)
  {
      fprintf (logFp, "glCopyConvolutionFilter1D (0x%x, 0x%x, %d, %d, %d)\n",
  	     target, internalformat, x, y, width);
      (*nativeRenderTable->CopyConvolutionFilter1D) (target, internalformat,
  						   x, y, width);
  }
  
  static void
  logCopyConvolutionFilter2D (GLenum  target,
  			    GLenum  internalformat,
  			    GLint   x,
  			    GLint   y,
  			    GLsizei width,
  			    GLsizei height)
  {
      fprintf (logFp, "glCopyConvolutionFilter2D (0x%x, 0x%x, %d, %d, %d, %d)\n",
  	     target, internalformat, x, y, width, height);
      (*nativeRenderTable->CopyConvolutionFilter2D) (target, internalformat,
  						   x, y, width, height);
  }
  
  static void
  logGetConvolutionFilter (GLenum target,
  			 GLenum format,
  			 GLenum type,
  			 GLvoid *image)
  {
      fprintf (logFp, "glGetConvolutionFilter (0x%x, 0x%x, 0x%x, %p)\n",
  	     target, format, type, image);
      (*nativeRenderTable->GetConvolutionFilter) (target, format, type,
  						image);
  }
  
  static void
  logGetConvolutionParameterfv (GLenum  target,
  			      GLenum  pname,
  			      GLfloat *params)
  {
      fprintf (logFp, "glGetConvolutionParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetConvolutionParameterfv) (target, pname,
  						     params);
  }
  
  static void
  logGetConvolutionParameteriv (GLenum target,
  			      GLenum pname,
  			      GLint  *params)
  {
      fprintf (logFp, "glGetConvolutionParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetConvolutionParameteriv) (target, pname,
  						     params);
  }
  
  static void
  logGetSeparableFilter (GLenum target,
  		       GLenum format,
  		       GLenum type,
  		       GLvoid *row,
  		       GLvoid *column,
  		       GLvoid *span)
  {
      fprintf (logFp, "glGetSeparableFilter (0x%x, 0x%x, 0x%x, %p, %p, %p)\n",
  	     target, format, type, row, column, span);
      (*nativeRenderTable->GetSeparableFilter) (target, format, type,
  					      row, column, span);
  }
  
  static void
  logSeparableFilter2D (GLenum	   target,
  		      GLenum	   internalformat,
  		      GLsizei	   width,
  		      GLsizei	   height,
  		      GLenum	   format,
  		      GLenum	   type,
  		      const GLvoid *row,
  		      const GLvoid *column)
  {
      fprintf (logFp, "glSeparableFilter2D (0x%x, 0x%x, %d, %d, "
  	     "0x%x, 0x%x, %p, %p)\n", target, internalformat, width, height,
  	     format, type, row, column);
      (*nativeRenderTable->SeparableFilter2D) (target, internalformat,
  					     width, height, format,
  					     type, row, column);
  }
  
  static void
  logGetHistogram (GLenum	   target,
  		 GLboolean reset,
  		 GLenum	   format,
  		 GLenum	   type,
  		 GLvoid	   *values)
  {
      fprintf (logFp, "glGetHistogram (0x%x, %d, 0x%x, 0x%x, %p)\n",
  	     target, reset, format, type, values);
      (*nativeRenderTable->GetHistogram) (target, reset, format, type,
  					values);
  }
  
  static void
  logGetHistogramParameterfv (GLenum  target,
  			    GLenum  pname,
  			    GLfloat *params)
  {
      fprintf (logFp, "glGetHistogramParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetHistogramParameterfv) (target, pname, params);
  }
  
  static void
  logGetHistogramParameteriv (GLenum target,
  			    GLenum pname,
  			    GLint  *params)
  {
      fprintf (logFp, "glGetHistogramParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetHistogramParameteriv) (target, pname, params);
  }
  
  static void
  logGetMinmax (GLenum	target,
  	      GLboolean reset,
  	      GLenum	format,
  	      GLenum	type,
  	      GLvoid	*values)
  {
      fprintf (logFp, "glGetMinmax (0x%x, %d, 0x%x, 0x%x, %p)\n",
  	     target, reset, format, type, values);
      (*nativeRenderTable->GetMinmax) (target, reset, format, type, values);
  }
  
  static void
  logGetMinmaxParameterfv (GLenum  target,
  			 GLenum  pname,
  			 GLfloat *params)
  {
      fprintf (logFp, "GetMinmaxParameterfv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetMinmaxParameterfv) (target, pname, params);
  }
  
  static void
  logGetMinmaxParameteriv (GLenum target,
  			 GLenum pname,
  			 GLint  *params)
  {
      fprintf (logFp, "GetMinmaxParameteriv (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetMinmaxParameteriv) (target, pname, params);
  }
  
  static void
  logHistogram (GLenum	target,
  	      GLsizei	width,
  	      GLenum	internalformat,
  	      GLboolean sink)
  {
      fprintf (logFp, "glHistogram (0x%x, %d, 0x%x, %d)\n",
  	     target, width, internalformat, sink);
      (*nativeRenderTable->Histogram) (target, width, internalformat, sink);
  }
  
  static void
  logMinmax (GLenum    target,
  	   GLenum    internalformat,
  	   GLboolean sink)
  {
      fprintf (logFp, "glMinmax (0x%x, 0x%x, %d)\n",
  	     target, internalformat, sink);
      (*nativeRenderTable->Minmax) (target, internalformat, sink);
  }
  
  static void
  logResetHistogram (GLenum target)
  {
      fprintf (logFp, "glResetHistogram (0x%x)\n", target);
      (*nativeRenderTable->ResetHistogram) (target);
  }
  
  static void
  logResetMinmax (GLenum target)
  {
      fprintf (logFp, "glResetMinmax (0x%x)\n", target);
      (*nativeRenderTable->ResetMinmax) (target);
  }
  
  static void
  logCopyTexSubImage3D (GLenum  target,
  		      GLint   level,
  		      GLint   xoffset,
  		      GLint   yoffset,
  		      GLint   zoffset,
  		      GLint   x,
  		      GLint   y,
  		      GLsizei width,
  		      GLsizei height)
  {
      fprintf (logFp, "glCopyTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, "
  	     "%d, %d)\n", target, level, xoffset, yoffset, zoffset,
  	     x, y, width, height);
      (*nativeRenderTable->CopyTexSubImage3D) (target, level,
  					     xoffset, yoffset, zoffset,
  					     x, y, width, height);
  }
  
  static void
  logTexImage3D (GLenum	    target,
  	       GLint	    level,
  	       GLint	    internalformat,
  	       GLsizei	    width,
  	       GLsizei	    height,
  	       GLsizei	    depth,
  	       GLint	    border,
  	       GLenum	    format,
  	       GLenum	    type,
  	       const GLvoid *pixels)
  {
      fprintf (logFp, "glTexImage3D (0x%x, %d, %d, %d, %d, %d, %d, "
  	     "0x%x, 0x%x, %p)\n", target, level, internalformat,
  	     width, height, depth, border, format, type, pixels);
      (*nativeRenderTable->TexImage3D) (target, level, internalformat,
  				      width, height, depth, border,
  				      format, type, pixels);
  }
  
  static void
  logTexSubImage3D (GLenum       target,
  		  GLint	       level,
  		  GLint	       xoffset,
  		  GLint	       yoffset,
  		  GLint	       zoffset,
  		  GLsizei      width,
  		  GLsizei      height,
  		  GLsizei      depth,
  		  GLenum       format,
  		  GLenum       type,
  		  const GLvoid *pixels)
  {
      fprintf (logFp, "glTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, %d, "
  	     "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset, zoffset,
  	     width, height, depth, format, type, pixels);
      (*nativeRenderTable->TexSubImage3D) (target, level,
  					 xoffset, yoffset, zoffset,
  					 width, height, depth,
  					 format, type, pixels);
  }
  
  /* GL_ARB_multitexture */
  
  static void
  logActiveTextureARB (GLenum texture)
  {
      fprintf (logFp, "glActiveTextureARB (0x%x)\n", texture);
      (*nativeRenderTable->ActiveTextureARB) (texture);
  }
  
  static void
  logClientActiveTextureARB (GLenum texture)
  {
      fprintf (logFp, "glClientActiveTextureARB (0x%x)\n", texture);
      (*nativeRenderTable->ClientActiveTextureARB) (texture);
  }
  
  static void
  logMultiTexCoord1dvARB (GLenum	       target,
  			const GLdouble *v)
  {
      vCnt[multiTexCoord1dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord1dvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord1dvARB) (target, v);
  }
  
  static void
  logMultiTexCoord1fvARB (GLenum	      target,
  			const GLfloat *v)
  {
      vCnt[multiTexCoord1fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord1fvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord1fvARB) (target, v);
  }
  
  static void
  logMultiTexCoord1ivARB (GLenum	    target,
  			const GLint *v)
  {
      vCnt[multiTexCoord1ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord1ivARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord1ivARB) (target, v);
  }
  
  static void
  logMultiTexCoord1svARB (GLenum	      target,
  			const GLshort *v)
  {
      vCnt[multiTexCoord1svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord1svARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord1svARB) (target, v);
  }
  
  static void
  logMultiTexCoord2dvARB (GLenum	       target,
  			const GLdouble *v)
  {
      vCnt[multiTexCoord2dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord2dvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord2dvARB) (target, v);
  }
  
  static void
  logMultiTexCoord2fvARB (GLenum	      target,
  			const GLfloat *v)
  {
      vCnt[multiTexCoord2fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord2fvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord2fvARB) (target, v);
  }
  
  static void
  logMultiTexCoord2ivARB (GLenum	    target,
  			const GLint *v)
  {
      vCnt[multiTexCoord2ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord2ivARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord2ivARB) (target, v);
  }
  
  static void
  logMultiTexCoord2svARB (GLenum	      target,
  			const GLshort *v)
  {
      vCnt[multiTexCoord2svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord2svARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord2svARB) (target, v);
  }
  
  static void
  logMultiTexCoord3dvARB (GLenum	       target,
  			const GLdouble *v)
  {
      vCnt[multiTexCoord3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord3dvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord3dvARB) (target, v);
  }
  
  static void
  logMultiTexCoord3fvARB (GLenum	      target,
  			const GLfloat *v)
  {
      vCnt[multiTexCoord3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord3fvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord3fvARB) (target, v);
  }
  
  static void
  logMultiTexCoord3ivARB (GLenum	    target,
  			const GLint *v)
  {
      vCnt[multiTexCoord3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord3ivARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord3ivARB) (target, v);
  }
  
  static void
  logMultiTexCoord3svARB (GLenum	      target,
  			const GLshort *v)
  {
      vCnt[multiTexCoord3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord3svARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord3svARB) (target, v);
  }
  
  static void
  logMultiTexCoord4dvARB (GLenum	       target,
  			const GLdouble *v)
  {
      vCnt[multiTexCoord4dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord4dvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord4dvARB) (target, v);
  }
  
  static void
  logMultiTexCoord4fvARB (GLenum	      target,
  			const GLfloat *v)
  {
      vCnt[multiTexCoord4fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord4fvARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord4fvARB) (target, v);
  }
  
  static void
  logMultiTexCoord4ivARB (GLenum	    target,
  			const GLint *v)
  {
      vCnt[multiTexCoord4ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord4ivARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord4ivARB) (target, v);
  }
  
  static void
  logMultiTexCoord4svARB (GLenum	      target,
  			const GLshort *v)
  {
      vCnt[multiTexCoord4svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glMultiTexCoord4svARB (0x%x, %p)\n", target, v);
      (*nativeRenderTable->MultiTexCoord4svARB) (target, v);
  }
  
  
  /* GL_ARB_multisample */
  
  static void
  logSampleCoverageARB (GLclampf  value,
  		      GLboolean invert)
  {
      fprintf (logFp, "glSampleCoverageARB (%f, %d)\n", value, invert);
      (*nativeRenderTable->SampleCoverageARB) (value, invert);
  }
  
  
  /* GL_EXT_texture_object */
  
  static GLboolean
  logAreTexturesResidentEXT (GLsizei	n,
  			   const GLuint *textures,
  			   GLboolean	*residences)
  {
      fprintf (logFp, "glAreTexturesResidentEXT (%d, %p, %p)\n",
  	     n, textures, residences);
      return (*nativeRenderTable->AreTexturesResidentEXT) (n, textures,
  							 residences);
  }
  static void
  logGenTexturesEXT (GLsizei n,
  		   GLuint  *textures)
  {
      fprintf (logFp, "glGenTexturesEXT (%d, %p)\n", n, textures);
      (*nativeRenderTable->GenTexturesEXT) (n, textures);
  }
  
  static GLboolean
  logIsTextureEXT (GLuint texture)
  {
      fprintf (logFp, "glIsTextureEXT (%d)\n", texture);
      return (*nativeRenderTable->IsTextureEXT) (texture);
  }
  
  
  /* GL_SGIS_multisample */
  
  static void
  logSampleMaskSGIS (GLclampf  value,
  		   GLboolean invert)
  {
      fprintf (logFp, "glSampleMaskSGIS (%f, %d)\n", value, invert);
      (*nativeRenderTable->SampleMaskSGIS) (value, invert);
  }
  
  static void
  logSamplePatternSGIS (GLenum pattern)
  {
      fprintf (logFp, "glSamplePatternSGIS (0x%x)\n", pattern);
      (*nativeRenderTable->SamplePatternSGIS) (pattern);
  }
  
  
  /* GL_EXT_point_parameters */
  
  static void
  logPointParameterfEXT (GLenum  pname,
  		       GLfloat param)
  {
      fprintf (logFp, "glPointParameterfEXT (0x%x, %f)\n", pname, param);
      (*nativeRenderTable->PointParameterfEXT) (pname, param);
  }
  
  static void
  logPointParameterfvEXT (GLenum	      pname,
  			const GLfloat *params)
  {
      fprintf (logFp, "glPointParameterfvEXT (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->PointParameterfvEXT) (pname, params);
  }
  
  
  /* GL_MESA_window_pos */
  
  static void
  logWindowPos3fMESA (GLfloat x,
  		    GLfloat y,
  		    GLfloat z)
  {
      fprintf (logFp, "glWindowPos3fMESA (%f, %f, %f)\n", x, y, z);
      (*nativeRenderTable->WindowPos3fMESA) (x, y, z);
  }
  
  
  /* GL_EXT_blend_func_separate */
  
  static void
  logBlendFuncSeparateEXT (GLenum sfactorRGB,
  			 GLenum dfactorRGB,
  			 GLenum sfactorAlpha,
  			 GLenum dfactorAlpha)
  {
      fprintf (logFp, "glBlendFuncSeparateEXT (0x%x, 0x%x, 0x%x, 0x%x)\n",
  	     sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
      (*nativeRenderTable->BlendFuncSeparateEXT) (sfactorRGB,
  						dfactorRGB,
  						sfactorAlpha,
  						dfactorAlpha);
  }
  
  
  /* GL_EXT_fog_coord */
  
  static void
  logFogCoordfvEXT (const GLfloat *coord)
  {
      vCnt[fogCoordfvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glFogCoordfvEXT (%p)\n", coord);
      (*nativeRenderTable->FogCoordfvEXT) (coord);
  }
  
  static void
  logFogCoorddvEXT (const GLdouble *coord)
  {
      vCnt[fogCoorddvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glFogCoorddvEXT (%p)\n", coord);
      (*nativeRenderTable->FogCoorddvEXT) (coord);
  }
  
  static void
  logFogCoordPointerEXT (GLenum	    type,
  		       GLsizei	    stride,
  		       const GLvoid *pointer)
  {
      fprintf (logFp, "glFogCoordPointerEXT (0x%x, %d, %p)\n",
  	     type, stride, pointer);
      (*nativeRenderTable->FogCoordPointerEXT) (type, stride, pointer);
  }
  
  
  /* GL_EXT_secondary_color */
  
  static void
  logSecondaryColor3bvEXT (const GLbyte *v)
  {
      vCnt[secondaryColor3bvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3bvEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3bvEXT) (v);
  }
  
  static void
  logSecondaryColor3dvEXT (const GLdouble *v)
  {
      vCnt[secondaryColor3dvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3dvEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3dvEXT) (v);
  }
  
  static void
  logSecondaryColor3fvEXT (const GLfloat *v)
  {
      vCnt[secondaryColor3fvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3fvEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3fvEXT) (v);
  }
  
  static void
  logSecondaryColor3ivEXT (const GLint *v)
  {
      vCnt[secondaryColor3ivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3ivEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3ivEXT) (v);
  }
  
  static void
  logSecondaryColor3svEXT (const GLshort *v)
  {
      vCnt[secondaryColor3svIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3svEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3svEXT) (v);
  }
  
  static void
  logSecondaryColor3ubvEXT (const GLubyte *v)
  {
      vCnt[secondaryColor3ubvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3ubvEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3ubvEXT) (v);
  }
  
  static void
  logSecondaryColor3uivEXT (const GLuint *v)
  {
      vCnt[secondaryColor3uivIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3uivEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3uivEXT) (v);
  }
  
  static void
  logSecondaryColor3usvEXT (const GLushort *v)
  {
      vCnt[secondaryColor3usvIndex].n++;
      if (logVertexAttribs)
  	fprintf (logFp, "glSecondaryColor3usvEXT (%p)\n", v);
      (*nativeRenderTable->SecondaryColor3usvEXT) (v);
  }
  
  static void
  logSecondaryColorPointerEXT (GLint	  size,
  			     GLenum	  type,
  			     GLsizei	  stride,
  			     const GLvoid *pointer)
  {
      fprintf (logFp, "glSecondaryColorPointerEXT (%d, 0x%x, %d, %p)\n",
  	     size, type, stride, pointer);
      (*nativeRenderTable->SecondaryColorPointerEXT) (size, type,
  						    stride, pointer);
  }
  
  
  /* GL_NV_point_sprite */
  
  static void
  logPointParameteriNV (GLenum pname,
  		      GLint  param)
  {
      fprintf (logFp, "glPointParameteriNV (0x%x, %d)\n", pname, param);
      (*nativeRenderTable->PointParameteriNV) (pname, param);
  }
  
  static void
  logPointParameterivNV (GLenum	   pname,
  		       const GLint *params)
  {
      fprintf (logFp, "glPointParameterivNV (0x%x, %p)\n", pname, params);
      (*nativeRenderTable->PointParameterivNV) (pname, params);
  }
  
  
  /* GL_EXT_stencil_two_side */
  
  static void
  logActiveStencilFaceEXT (GLenum face)
  {
      fprintf (logFp, "glActiveStencilFaceEXT (0x%x)\n", face);
      (*nativeRenderTable->ActiveStencilFaceEXT) (face);
  }
  
  
  /* GL_EXT_framebuffer_object */
  
  static GLboolean
  logIsRenderbufferEXT (GLuint renderbuffer)
  {
      fprintf (logFp, "glIsRenderbufferEXT (%d)\n", renderbuffer);
      return (*nativeRenderTable->IsRenderbufferEXT) (renderbuffer);
  }
  
  static void
  logBindRenderbufferEXT (GLenum target,
  			GLuint renderbuffer)
  {
      fprintf (logFp, "glBindRenderbufferEXT (0x%x, %d)\n",
  	     target, renderbuffer);
      (*nativeRenderTable->BindRenderbufferEXT) (target, renderbuffer);
  }
  
  static void
  logDeleteRenderbuffersEXT (GLsizei	n,
  			   const GLuint *renderbuffers)
  {
      fprintf (logFp, "glDeleteRenderbuffersEXT (%d, %p)\n", n, renderbuffers);
      (*nativeRenderTable->DeleteRenderbuffersEXT) (n, renderbuffers);
  }
  
  static void
  logGenRenderbuffersEXT (GLsizei n,
  			GLuint  *renderbuffers)
  {
      fprintf (logFp, "glGenRenderbuffersEXT (%d, %p)\n", n, renderbuffers);
      (*nativeRenderTable->GenRenderbuffersEXT) (n, renderbuffers);
  }
  
  static void
  logRenderbufferStorageEXT (GLenum  target,
  			   GLenum  internalformat,
  			   GLsizei width,
  			   GLsizei height)
  {
      fprintf (logFp, "glRenderbufferStorageEXT (0x%x, 0x%x, %d, %d)\n",
  	     target, internalformat, width, height);
      (*nativeRenderTable->RenderbufferStorageEXT) (target,
  						  internalformat,
  						  width, height);
  }
  
  static void
  logGetRenderbufferParameterivEXT (GLenum target,
  				  GLenum pname,
  				  GLint  *params)
  {
      fprintf (logFp, "glGetRenderbufferParameterivEXT (0x%x, 0x%x, %p)\n",
  	     target, pname, params);
      (*nativeRenderTable->GetRenderbufferParameterivEXT) (target,
  							 pname,
  							 params);
  }
  
  static GLboolean
  logIsFramebufferEXT (GLuint framebuffer)
  {
      fprintf (logFp, "glIsFramebufferEXT (%d)\n", framebuffer);
      return (*nativeRenderTable->IsFramebufferEXT) (framebuffer);
  }
  
  static void
  logBindFramebufferEXT (GLenum target,
  		       GLuint framebuffer)
  {
      fprintf (logFp, "glBindFramebufferEXT (0x%x, %d)\n", target, framebuffer);
      (*nativeRenderTable->BindFramebufferEXT) (target, framebuffer);
  }
  
  static void
  logDeleteFramebuffersEXT (GLsizei      n,
  			  const GLuint *framebuffers)
  {
      fprintf (logFp, "glDeleteFramebuffersEXT (%d, %p)\n", n, framebuffers);
      (*nativeRenderTable->DeleteFramebuffersEXT) (n, framebuffers);
  }
  
  static void
  logGenFramebuffersEXT (GLsizei n,
  		       GLuint  *framebuffers)
  {
      fprintf (logFp, "glGenFramebuffersEXT (%d, %p)\n", n, framebuffers);
      (*nativeRenderTable->GenFramebuffersEXT) (n, framebuffers);
  }
  
  static GLenum
  logCheckFramebufferStatusEXT (GLenum target)
  {
      fprintf (logFp, "glCheckFramebufferStatusEXT (0x%x)\n", target);
      return (*nativeRenderTable->CheckFramebufferStatusEXT) (target);
  }
  
  static void
  logFramebufferTexture1DEXT (GLenum target,
  			    GLenum attachment,
  			    GLenum textarget,
  			    GLuint texture,
  			    GLint  level)
  {
      fprintf (logFp, "glFramebufferTexture1DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n",
  	     target, attachment, textarget, texture, level);
      (*nativeRenderTable->FramebufferTexture1DEXT) (target, attachment,
  						   textarget, texture,
  						   level);
  }
  
  static void
  logFramebufferTexture2DEXT (GLenum target,
  			    GLenum attachment,
  			    GLenum textarget,
  			    GLuint texture,
  			    GLint  level)
  {
      fprintf (logFp, "glFramebufferTexture2DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n",
  	     target, attachment, textarget, texture, level);
      (*nativeRenderTable->FramebufferTexture2DEXT) (target, attachment,
  						   textarget, texture,
  						   level);
  }
  
  static void
  logFramebufferTexture3DEXT (GLenum target,
  			    GLenum attachment,
  			    GLenum textarget,
  			    GLuint texture,
  			    GLint  level,
  			    GLint  zoffset)
  {
      fprintf (logFp, "glFramebufferTexture3DEXT (0x%x, 0x%x, 0x%x, "
  	     "%d, %d, %d)\n", target, attachment, textarget, texture,
  	     level, zoffset);
      (*nativeRenderTable->FramebufferTexture3DEXT) (target, attachment,
  						   textarget, texture,
  						   level, zoffset);
  }
  
  static void
  logFramebufferRenderbufferEXT (GLenum target,
  			       GLenum attachment,
  			       GLenum buffertarget,
  			       GLuint renderbuffer)
  {
      fprintf (logFp, "glFramebufferRenderbufferEXT (0x%x, 0x%x, 0x%x, %d)\n",
  	     target, attachment, buffertarget, renderbuffer);
      (*nativeRenderTable->FramebufferRenderbufferEXT) (target,
  						      attachment,
  						      buffertarget,
  						      renderbuffer);
  }
  
  static void
  logGetFramebufferAttachmentParameterivEXT (GLenum target,
  					   GLenum attach,
  					   GLenum pname,
  					   GLint  *params)
  {
      fprintf (logFp, "glGetFramebufferAttachmentParameterivEXT (0x%x, "
  	     "0x%x, 0x%x, %p)\n", target, attach, pname, params);
      (*nativeRenderTable->GetFramebufferAttachmentParameterivEXT) (target,
  								  attach,
  								  pname,
  								  params);
  }
  
  static void
  logGenerateMipmapEXT (GLenum target)
  {
      fprintf (logFp, "glGenerateMipmapEXT (0x%x)\n", target);
      (*nativeRenderTable->GenerateMipmapEXT) (target);
  }
  
  static struct _glapi_table __logRenderTable = {
      logNewList,
      logEndList,
      logCallList,
      logCallLists,
      logDeleteLists,
      logGenLists,
      logListBase,
      logBegin,
      logBitmap,
      0, /* glColor3b */
      logColor3bv,
      0, /* glColor3d */
      logColor3dv,
      0, /* glColor3f */
      logColor3fv,
      0, /* glColor3i */
      logColor3iv,
      0, /* glColor3s */
      logColor3sv,
      0, /* glColor3ub */
      logColor3ubv,
      0, /* glColor3ui */
      logColor3uiv,
      0, /* glColor3us */
      logColor3usv,
      0, /* glColor4b */
      logColor4bv,
      0, /* glColor4d */
      logColor4dv,
      0, /* glColor4f */
      logColor4fv,
      0, /* glColor4i */
      logColor4iv,
      0, /* glColor4s */
      logColor4sv,
      0, /* glColor4ub */
      logColor4ubv,
      0, /* glColor4ui */
      logColor4uiv,
      0, /* glColor4us */
      logColor4usv,
      0, /* glEdgeFlag */
      logEdgeFlagv,
      logEnd,
      0, /* glIndexd */
      logIndexdv,
      0, /* glIndexf */
      logIndexfv,
      0, /* glIndexi */
      logIndexiv,
      0, /* glIndexs */
      logIndexsv,
      0, /* glNormal3b */
      logNormal3bv,
      0, /* glNormal3d */
      logNormal3dv,
      0, /* glNormal3f */
      logNormal3fv,
      0, /* glNormal3i */
      logNormal3iv,
      0, /* glNormal3s */
      logNormal3sv,
      0, /* glRasterPos2d */
      logRasterPos2dv,
      0, /* glRasterPos2f */
      logRasterPos2fv,
      0, /* glRasterPos2i */
      logRasterPos2iv,
      0, /* glRasterPos2s */
      logRasterPos2sv,
      0, /* glRasterPos3d */
      logRasterPos3dv,
      0, /* glRasterPos3f */
      logRasterPos3fv,
      0, /* glRasterPos3i */
      logRasterPos3iv,
      0, /* glRasterPos3s */
      logRasterPos3sv,
      0, /* glRasterPos4d */
      logRasterPos4dv,
      0, /* glRasterPos4f */
      logRasterPos4fv,
      0, /* glRasterPos4i */
      logRasterPos4iv,
      0, /* glRasterPos4s */
      logRasterPos4sv,
      0, /* glRectd */
      logRectdv,
      0, /* glRectf */
      logRectfv,
      0, /* glRecti */
      logRectiv,
      0, /* glRects */
      logRectsv,
      0, /* glTexCoord1d */
      logTexCoord1dv,
      0, /* glTexCoord1f */
      logTexCoord1fv,
      0, /* glTexCoord1i */
      logTexCoord1iv,
      0, /* glTexCoord1s */
      logTexCoord1sv,
      0, /* glTexCoord2d */
      logTexCoord2dv,
      0, /* glTexCoord2f */
      logTexCoord2fv,
      0, /* glTexCoord2i */
      logTexCoord2iv,
      0, /* glTexCoord2s */
      logTexCoord2sv,
      0, /* glTexCoord3d */
      logTexCoord3dv,
      0, /* glTexCoord3f */
      logTexCoord3fv,
      0, /* glTexCoord3i */
      logTexCoord3iv,
      0, /* glTexCoord3s */
      logTexCoord3sv,
      0, /* glTexCoord4d */
      logTexCoord4dv,
      0, /* glTexCoord4f */
      logTexCoord4fv,
      0, /* glTexCoord4i */
      logTexCoord4iv,
      0, /* glTexCoord4s */
      logTexCoord4sv,
      0, /* glVertex2d */
      logVertex2dv,
      0, /* glVertex2f */
      logVertex2fv,
      0, /* glVertex2i */
      logVertex2iv,
      0, /* glVertex2s */
      logVertex2sv,
      0, /* glVertex3d */
      logVertex3dv,
      0, /* glVertex3f */
      logVertex3fv,
      0, /* glVertex3i */
      logVertex3iv,
      0, /* glVertex3s */
      logVertex3sv,
      0, /* glVertex4d */
      logVertex4dv,
      0, /* glVertex4f */
      logVertex4fv,
      0, /* glVertex4i */
      logVertex4iv,
      0, /* glVertex4s */
      logVertex4sv,
      logClipPlane,
      logColorMaterial,
      logCullFace,
      logFogf,
      logFogfv,
      logFogi,
      logFogiv,
      logFrontFace,
      logHint,
      logLightf,
      logLightfv,
      logLighti,
      logLightiv,
      logLightModelf,
      logLightModelfv,
      logLightModeli,
      logLightModeliv,
      logLineStipple,
      logLineWidth,
      logMaterialf,
      logMaterialfv,
      logMateriali,
      logMaterialiv,
      logPointSize,
      logPolygonMode,
      logPolygonStipple,
      logScissor,
      logShadeModel,
      logTexParameterf,
      logTexParameterfv,
      logTexParameteri,
      logTexParameteriv,
      logTexImage1D,
      logTexImage2D,
      logTexEnvf,
      logTexEnvfv,
      logTexEnvi,
      logTexEnviv,
      logTexGend,
      logTexGendv,
      logTexGenf,
      logTexGenfv,
      logTexGeni,
      logTexGeniv,
      logFeedbackBuffer,
      logSelectBuffer,
      logRenderMode,
      logInitNames,
      logLoadName,
      logPassThrough,
      logPopName,
      logPushName,
      logDrawBuffer,
      logClear,
      logClearAccum,
      logClearIndex,
      logClearColor,
      logClearStencil,
      logClearDepth,
      logStencilMask,
      logColorMask,
      logDepthMask,
      logIndexMask,
      logAccum,
      logDisable,
      logEnable,
      logFinish,
      logFlush,
      logPopAttrib,
      logPushAttrib,
      logMap1d,
      logMap1f,
      logMap2d,
      logMap2f,
      logMapGrid1d,
      logMapGrid1f,
      logMapGrid2d,
      logMapGrid2f,
      0, /* glEvalCoord1d */
      logEvalCoord1dv,
      0, /* glEvalCoord1f */
      logEvalCoord1fv,
      0, /* glEvalCoord2d */
      logEvalCoord2dv,
      0, /* glEvalCoord2f */
      logEvalCoord2fv,
      logEvalMesh1,
      logEvalPoint1,
      logEvalMesh2,
      logEvalPoint2,
      logAlphaFunc,
      logBlendFunc,
      logLogicOp,
      logStencilFunc,
      logStencilOp,
      logDepthFunc,
      logPixelZoom,
      logPixelTransferf,
      logPixelTransferi,
      logPixelStoref,
      logPixelStorei,
      logPixelMapfv,
      logPixelMapuiv,
      logPixelMapusv,
      logReadBuffer,
      logCopyPixels,
      logReadPixels,
      logDrawPixels,
      logGetBooleanv,
      logGetClipPlane,
      logGetDoublev,
      logGetError,
      logGetFloatv,
      logGetIntegerv,
      logGetLightfv,
      logGetLightiv,
      logGetMapdv,
      logGetMapfv,
      logGetMapiv,
      logGetMaterialfv,
      logGetMaterialiv,
      logGetPixelMapfv,
      logGetPixelMapuiv,
      logGetPixelMapusv,
      logGetPolygonStipple,
      logGetString,
      logGetTexEnvfv,
      logGetTexEnviv,
      logGetTexGendv,
      logGetTexGenfv,
      logGetTexGeniv,
      logGetTexImage,
      logGetTexParameterfv,
      logGetTexParameteriv,
      logGetTexLevelParameterfv,
      logGetTexLevelParameteriv,
      logIsEnabled,
      logIsList,
      logDepthRange,
      logFrustum,
      logLoadIdentity,
      logLoadMatrixf,
      logLoadMatrixd,
      logMatrixMode,
      logMultMatrixf,
      logMultMatrixd,
      logOrtho,
      logPopMatrix,
      logPushMatrix,
      logRotated,
      logRotatef,
      logScaled,
      logScalef,
      logTranslated,
      logTranslatef,
      logViewport,
      logArrayElement,
      logBindTexture,
      logColorPointer,
      logDisableClientState,
      logDrawArrays,
      logDrawElements,
      logEdgeFlagPointer,
      logEnableClientState,
      logIndexPointer,
      0, /* glIndexub */
      logIndexubv,
      logInterleavedArrays,
      logNormalPointer,
      logPolygonOffset,
      logTexCoordPointer,
      logVertexPointer,
      logAreTexturesResident,
      logCopyTexImage1D,
      logCopyTexImage2D,
      logCopyTexSubImage1D,
      logCopyTexSubImage2D,
      logDeleteTextures,
      logGenTextures,
      logGetPointerv,
      logIsTexture,
      logPrioritizeTextures,
      logTexSubImage1D,
      logTexSubImage2D,
      logPopClientAttrib,
      logPushClientAttrib,
      logBlendColor,
      logBlendEquation,
      0, /* glDrawRangeElements */
      logColorTable,
      logColorTableParameterfv,
      logColorTableParameteriv,
      logCopyColorTable,
      logGetColorTable,
      logGetColorTableParameterfv,
      logGetColorTableParameteriv,
      logColorSubTable,
      logCopyColorSubTable,
      logConvolutionFilter1D,
      logConvolutionFilter2D,
      logConvolutionParameterf,
      logConvolutionParameterfv,
      logConvolutionParameteri,
      logConvolutionParameteriv,
      logCopyConvolutionFilter1D,
      logCopyConvolutionFilter2D,
      logGetConvolutionFilter,
      logGetConvolutionParameterfv,
      logGetConvolutionParameteriv,
      logGetSeparableFilter,
      logSeparableFilter2D,
      logGetHistogram,
      logGetHistogramParameterfv,
      logGetHistogramParameteriv,
      logGetMinmax,
      logGetMinmaxParameterfv,
      logGetMinmaxParameteriv,
      logHistogram,
      logMinmax,
      logResetHistogram,
      logResetMinmax,
      logTexImage3D,
      logTexSubImage3D,
      logCopyTexSubImage3D,
      logActiveTextureARB,
      logClientActiveTextureARB,
      0, /* glMultiTexCoord1dARB */
      logMultiTexCoord1dvARB,
      0, /* glMultiTexCoord1fARB */
      logMultiTexCoord1fvARB,
      0, /* glMultiTexCoord1iARB */
      logMultiTexCoord1ivARB,
      0, /* glMultiTexCoord1sARB */
      logMultiTexCoord1svARB,
      0, /* glMultiTexCoord2dARB */
      logMultiTexCoord2dvARB,
      0, /* glMultiTexCoord2fARB */
      logMultiTexCoord2fvARB,
      0, /* glMultiTexCoord2iARB */
      logMultiTexCoord2ivARB,
      0, /* glMultiTexCoord2sARB */
      logMultiTexCoord2svARB,
      0, /* glMultiTexCoord3dARB */
      logMultiTexCoord3dvARB,
      0, /* glMultiTexCoord3fARB */
      logMultiTexCoord3fvARB,
      0, /* glMultiTexCoord3iARB */
      logMultiTexCoord3ivARB,
      0, /* glMultiTexCoord3sARB */
      logMultiTexCoord3svARB,
      0, /* glMultiTexCoord4dARB */
      logMultiTexCoord4dvARB,
      0, /* glMultiTexCoord4fARB */
      logMultiTexCoord4fvARB,
      0, /* glMultiTexCoord4iARB */
      logMultiTexCoord4ivARB,
      0, /* glMultiTexCoord4sARB */
      logMultiTexCoord4svARB,
      0, /* glLoadTransposeMatrixfARB */
      0, /* glLoadTransposeMatrixdARB */
      0, /* glMultTransposeMatrixfARB */
      0, /* glMultTransposeMatrixdARB */
      logSampleCoverageARB,
      0, /* glDrawBuffersARB */
      0, /* glPolygonOffsetEXT */
      0, /* glGetTexFilterFuncSGIS */
      0, /* glTexFilterFuncSGIS */
      0, /* glGetHistogramEXT */
      0, /* glGetHistogramParameterfvEXT */
      0, /* glGetHistogramParameterivEXT */
      0, /* glGetMinmaxEXT */
      0, /* glGetMinmaxParameterfvEXT */
      0, /* glGetMinmaxParameterivEXT */
      0, /* glGetConvolutionFilterEXT */
      0, /* glGetConvolutionParameterfvEXT */
      0, /* glGetConvolutionParameterivEXT */
      0, /* glGetSeparableFilterEXT */
      0, /* glGetColorTableSGI */
      0, /* glGetColorTableParameterfvSGI */
      0, /* glGetColorTableParameterivSGI */
      0, /* glPixelTexGenSGIX */
      0, /* glPixelTexGenParameteriSGIS */
      0, /* glPixelTexGenParameterivSGIS */
      0, /* glPixelTexGenParameterfSGIS */
      0, /* glPixelTexGenParameterfvSGIS */
      0, /* glGetPixelTexGenParameterivSGIS */
      0, /* glGetPixelTexGenParameterfvSGIS */
      0, /* glTexImage4DSGIS */
      0, /* glTexSubImage4DSGIS */
      logAreTexturesResidentEXT,
      logGenTexturesEXT,
      logIsTextureEXT,
      0, /* glDetailTexFuncSGIS */
      0, /* glGetDetailTexFuncSGIS */
      0, /* glSharpenTexFuncSGIS */
      0, /* glGetSharpenTexFuncSGIS */
      logSampleMaskSGIS,
      logSamplePatternSGIS,
      0, /* glColorPointerEXT */
      0, /* glEdgeFlagPointerEXT */
      0, /* glIndexPointerEXT */
      0, /* glNormalPointerEXT */
      0, /* glTexCoordPointerEXT */
      0, /* glVertexPointerEXT */
      0, /* glSpriteParameterfSGIX */
      0, /* glSpriteParameterfvSGIX */
      0, /* glSpriteParameteriSGIX */
      0, /* glSpriteParameterivSGIX */
      logPointParameterfEXT,
      logPointParameterfvEXT,
      0, /* glGetInstrumentsSGIX */
      0, /* glInstrumentsBufferSGIX */
      0, /* glPollInstrumentsSGIX */
      0, /* glReadInstrumentsSGIX */
      0, /* glStartInstrumentsSGIX */
      0, /* glStopInstrumentsSGIX */
      0, /* glFrameZoomSGIX */
      0, /* glTagSampleBufferSGIX */
      0, /* glReferencePlaneSGIX */
      0, /* glFlushRasterSGIX */
      0, /* glGetListParameterfvSGIX */
      0, /* glGetListParameterivSGIX */
      0, /* glListParameterfSGIX */
      0, /* glListParameterfvSGIX */
      0, /* glListParameteriSGIX */
      0, /* glListParameterivSGIX */
      0, /* glFragmentColorMaterialSGIX */
      0, /* glFragmentLightfSGIX */
      0, /* glFragmentLightfvSGIX */
      0, /* glFragmentLightiSGIX */
      0, /* glFragmentLightivSGIX */
      0, /* glFragmentLightModelfSGIX */
      0, /* glFragmentLightModelfvSGIX */
      0, /* glFragmentLightModeliSGIX */
      0, /* glFragmentLightModelivSGIX */
      0, /* glFragmentMaterialfSGIX */
      0, /* glFragmentMaterialfvSGIX */
      0, /* glFragmentMaterialiSGIX */
      0, /* glFragmentMaterialivSGIX */
      0, /* glGetFragmentLightfvSGIX */
      0, /* glGetFragmentLightivSGIX */
      0, /* glGetFragmentMaterialfvSGIX */
      0, /* glGetFragmentMaterialivSGIX */
      0, /* glLightEnviSGIX */
      0, /* glVertexWeightfEXT */
      0, /* glVertexWeightfvEXT */
      0, /* glVertexWeightPointerEXT */
      0, /* glFlushVertexArrayRangeNV */
      0, /* glVertexArrayRangeNV */
      0, /* glCombinerParameterfvNV */
      0, /* glCombinerParameterfNV */
      0, /* glCombinerParameterivNV */
      0, /* glCombinerParameteriNV */
      0, /* glCombinerInputNV */
      0, /* glCombinerOutputNV */
      0, /* glFinalCombinerInputNV */
      0, /* glGetCombinerInputParameterfvNV */
      0, /* glGetCombinerInputParameterivNV */
      0, /* glGetCombinerOutputParameterfvNV */
      0, /* glGetCombinerOutputParameterivNV */
      0, /* glGetFinalCombinerInputParameterfvNV */
      0, /* glGetFinalCombinerInputParameterivNV */
      0, /* glResizeBuffersMESA */
      0, /* glWindowPos2dMESA */
      0, /* glWindowPos2dvMESA */
      0, /* glWindowPos2fMESA */
      0, /* glWindowPos2fvMESA */
      0, /* glWindowPos2iMESA */
      0, /* glWindowPos2ivMESA */
      0, /* glWindowPos2sMESA */
      0, /* glWindowPos2svMESA */
      0, /* glWindowPos3dMESA */
      0, /* glWindowPos3dvMESA */
      logWindowPos3fMESA,
      0, /* glWindowPos3fvMESA */
      0, /* glWindowPos3iMESA */
      0, /* glWindowPos3ivMESA */
      0, /* glWindowPos3sMESA */
      0, /* glWindowPos3svMESA */
      0, /* glWindowPos4dMESA */
      0, /* glWindowPos4dvMESA */
      0, /* glWindowPos4fMESA */
      0, /* glWindowPos4fvMESA */
      0, /* glWindowPos4iMESA */
      0, /* glWindowPos4ivMESA */
      0, /* glWindowPos4sMESA */
      0, /* glWindowPos4svMESA */
      logBlendFuncSeparateEXT,
      0, /* glIndexMaterialEXT */
      0, /* glIndexFuncEXT */
      0, /* glLockArraysEXT */
      0, /* glUnlockArraysEXT */
      0, /* glCullParameterdvEXT */
      0, /* glCullParameterfvEXT */
      0, /* glHintPGI */
      0, /* glFogCoordfEXT */
      logFogCoordfvEXT,
      0, /* glFogCoorddEXT */
      logFogCoorddvEXT,
      logFogCoordPointerEXT,
      0, /* glGetColorTableEXT */
      0, /* glGetColorTableParameterivEXT */
      0, /* glGetColorTableParameterfvEXT */
      0, /* glTbufferMask3DFX */
      0, /* glCompressedTexImage3DARB */
      0, /* glCompressedTexImage2DARB */
      0, /* glCompressedTexImage1DARB */
      0, /* glCompressedTexSubImage3DARB */
      0, /* glCompressedTexSubImage2DARB */
      0, /* glCompressedTexSubImage1DARB */
      0, /* glGetCompressedTexImageARB */
      0, /* glSecondaryColor3bEXT */
      logSecondaryColor3bvEXT,
      0, /* glSecondaryColor3dEXT */
      logSecondaryColor3dvEXT,
      0, /* glSecondaryColor3fEXT */
      logSecondaryColor3fvEXT,
      0, /* glSecondaryColor3iEXT */
      logSecondaryColor3ivEXT,
      0, /* glSecondaryColor3sEXT */
      logSecondaryColor3svEXT,
      0, /* glSecondaryColor3ubEXT */
      logSecondaryColor3ubvEXT,
      0, /* glSecondaryColor3uiEXT */
      logSecondaryColor3uivEXT,
      0, /* glSecondaryColor3usEXT */
      logSecondaryColor3usvEXT,
      logSecondaryColorPointerEXT,
      0, /* glAreProgramsResidentNV */
      0, /* glBindProgramNV */
      0, /* glDeleteProgramsNV */
      0, /* glExecuteProgramNV */
      0, /* glGenProgramsNV */
      0, /* glGetProgramParameterdvNV */
      0, /* glGetProgramParameterfvNV */
      0, /* glGetProgramivNV */
      0, /* glGetProgramStringNV */
      0, /* glGetTrackMatrixivNV */
      0, /* glGetVertexAttribdvARB */
      0, /* glGetVertexAttribfvARB */
      0, /* glGetVertexAttribivARB */
      0, /* glGetVertexAttribPointervNV */
      0, /* glIsProgramNV */
      0, /* glLoadProgramNV */
      0, /* glProgramParameter4dNV */
      0, /* glProgramParameter4dvNV */
      0, /* glProgramParameter4fNV */
      0, /* glProgramParameter4fvNV */
      0, /* glProgramParameters4dvNV */
      0, /* glProgramParameters4fvNV */
      0, /* glRequestResidentProgramsNV */
      0, /* glTrackMatrixNV */
      0, /* glVertexAttribPointerNV */
      0, /* glVertexAttrib1dARB */
      0, /* glVertexAttrib1dvARB */
      0, /* glVertexAttrib1fARB */
      0, /* glVertexAttrib1fvARB */
      0, /* glVertexAttrib1sARB */
      0, /* glVertexAttrib1svARB */
      0, /* glVertexAttrib2dARB */
      0, /* glVertexAttrib2dvARB */
      0, /* glVertexAttrib2fARB */
      0, /* glVertexAttrib2fvARB */
      0, /* glVertexAttrib2sARB */
      0, /* glVertexAttrib2svARB */
      0, /* glVertexAttrib3dARB */
      0, /* glVertexAttrib3dvARB */
      0, /* glVertexAttrib3fARB */
      0, /* glVertexAttrib3fvARB */
      0, /* glVertexAttrib3sARB */
      0, /* glVertexAttrib3svARB */
      0, /* glVertexAttrib4dARB */
      0, /* glVertexAttrib4dvARB */
      0, /* glVertexAttrib4fARB */
      0, /* glVertexAttrib4fvARB */
      0, /* glVertexAttrib4sARB */
      0, /* glVertexAttrib4svARB */
      0, /* glVertexAttrib4NubARB */
      0, /* glVertexAttrib4NubvARB */
      0, /* glVertexAttribs1dvNV */
      0, /* glVertexAttribs1fvNV */
      0, /* glVertexAttribs1svNV */
      0, /* glVertexAttribs2dvNV */
      0, /* glVertexAttribs2fvNV */
      0, /* glVertexAttribs2svNV */
      0, /* glVertexAttribs3dvNV */
      0, /* glVertexAttribs3fvNV */
      0, /* glVertexAttribs3svNV */
      0, /* glVertexAttribs4dvNV */
      0, /* glVertexAttribs4fvNV */
      0, /* glVertexAttribs4svNV */
      0, /* glVertexAttribs4ubvNV */
      logPointParameteriNV,
      logPointParameterivNV,
      0, /* glMultiDrawArraysEXT */
      0, /* glMultiDrawElementsEXT */
      logActiveStencilFaceEXT,
      0, /* glDeleteFencesNV */
      0, /* glGenFencesNV */
      0, /* glIsFenceNV */
      0, /* glTestFenceNV */
      0, /* glGetFenceivNV */
      0, /* glFinishFenceNV */
      0, /* glSetFenceNV */
      0, /* glVertexAttrib4bvARB */
      0, /* glVertexAttrib4ivARB */
      0, /* glVertexAttrib4ubvARB */
      0, /* glVertexAttrib4usvARB */
      0, /* glVertexAttrib4uivARB */
      0, /* glVertexAttrib4NbvARB */
      0, /* glVertexAttrib4NsvARB */
      0, /* glVertexAttrib4NivARB */
      0, /* glVertexAttrib4NusvARB */
      0, /* glVertexAttrib4NuivARB */
      0, /* glVertexAttribPointerARB */
      0, /* glEnableVertexAttribArrayARB */
      0, /* glDisableVertexAttribArrayARB */
      0, /* glProgramStringARB */
      0, /* glProgramEnvParameter4dARB */
      0, /* glProgramEnvParameter4dvARB */
      0, /* glProgramEnvParameter4fARB */
      0, /* glProgramEnvParameter4fvARB */
      0, /* glProgramLocalParameter4dARB */
      0, /* glProgramLocalParameter4dvARB */
      0, /* glProgramLocalParameter4fARB */
      0, /* glProgramLocalParameter4fvARB */
      0, /* glGetProgramEnvParameterdvARB */
      0, /* glGetProgramEnvParameterfvARB */
      0, /* glGetProgramLocalParameterdvARB */
      0, /* glGetProgramLocalParameterfvARB */
      0, /* glGetProgramivARB */
      0, /* glGetProgramStringARB */
      0, /* glProgramNamedParameter4fNV */
      0, /* glProgramNamedParameter4dNV */
      0, /* glProgramNamedParameter4fvNV */
      0, /* glProgramNamedParameter4dvNV */
      0, /* glGetProgramNamedParameterfvNV */
      0, /* glGetProgramNamedParameterdvNV */
      0, /* glBindBufferARB */
      0, /* glBufferDataARB */
      0, /* glBufferSubDataARB */
      0, /* glDeleteBuffersARB */
      0, /* glGenBuffersARB */
      0, /* glGetBufferParameterivARB */
      0, /* glGetBufferPointervARB */
      0, /* glGetBufferSubDataARB */
      0, /* glIsBufferARB */
      0, /* glMapBufferARB */
      0, /* glUnmapBufferARB */
      0, /* glDepthBoundsEXT */
      0, /* glGenQueriesARB */
      0, /* glDeleteQueriesARB */
      0, /* glIsQueryARB */
      0, /* glBeginQueryARB */
      0, /* glEndQueryARB */
      0, /* glGetQueryivARB */
      0, /* glGetQueryObjectivARB */
      0, /* glGetQueryObjectuivARB */
      0, /* glMultiModeDrawArraysIBM */
      0, /* glMultiModeDrawElementsIBM */
      0, /* glBlendEquationSeparateEXT */
      0, /* glDeleteObjectARB */
      0, /* glGetHandleARB */
      0, /* glDetachObjectARB */
      0, /* glCreateShaderObjectARB */
      0, /* glShaderSourceARB */
      0, /* glCompileShaderARB */
      0, /* glCreateProgramObjectARB */
      0, /* glAttachObjectARB */
      0, /* glLinkProgramARB */
      0, /* glUseProgramObjectARB */
      0, /* glValidateProgramARB */
      0, /* glUniform1fARB */
      0, /* glUniform2fARB */
      0, /* glUniform3fARB */
      0, /* glUniform4fARB */
      0, /* glUniform1iARB */
      0, /* glUniform2iARB */
      0, /* glUniform3iARB */
      0, /* glUniform4iARB */
      0, /* glUniform1fvARB */
      0, /* glUniform2fvARB */
      0, /* glUniform3fvARB */
      0, /* glUniform4fvARB */
      0, /* glUniform1ivARB */
      0, /* glUniform2ivARB */
      0, /* glUniform3ivARB */
      0, /* glUniform4ivARB */
      0, /* glUniformMatrix2fvARB */
      0, /* glUniformMatrix3fvARB */
      0, /* glUniformMatrix4fvARB */
      0, /* glGetObjectParameterfvARB */
      0, /* glGetObjectParameterivARB */
      0, /* glGetInfoLogARB */
      0, /* glGetAttachedObjectsARB */
      0, /* glGetUniformLocationARB */
      0, /* glGetActiveUniformARB */
      0, /* glGetUniformfvARB */
      0, /* glGetUniformivARB */
      0, /* glGetShaderSourceARB */
      0, /* glBindAttribLocationARB */
      0, /* glGetActiveAttribARB */
      0, /* glGetAttribLocationARB */
      0, /* glGetVertexAttribdvNV */
      0, /* glGetVertexAttribfvNV */
      0, /* glGetVertexAttribivNV */
      0, /* glVertexAttrib1dNV */
      0, /* glVertexAttrib1dvNV */
      0, /* glVertexAttrib1fNV */
      0, /* glVertexAttrib1fvNV */
      0, /* glVertexAttrib1sNV */
      0, /* glVertexAttrib1svNV */
      0, /* glVertexAttrib2dNV */
      0, /* glVertexAttrib2dvNV */
      0, /* glVertexAttrib2fNV */
      0, /* glVertexAttrib2fvNV */
      0, /* glVertexAttrib2sNV */
      0, /* glVertexAttrib2svNV */
      0, /* glVertexAttrib3dNV */
      0, /* glVertexAttrib3dvNV */
      0, /* glVertexAttrib3fNV */
      0, /* glVertexAttrib3fvNV */
      0, /* glVertexAttrib3sNV */
      0, /* glVertexAttrib3svNV */
      0, /* glVertexAttrib4dNV */
      0, /* glVertexAttrib4dvNV */
      0, /* glVertexAttrib4fNV */
      0, /* glVertexAttrib4fvNV */
      0, /* glVertexAttrib4sNV */
      0, /* glVertexAttrib4svNV */
      0, /* glVertexAttrib4ubNV */
      0, /* glVertexAttrib4ubvNV */
      0, /* glGenFragmentShadersATI */
      0, /* glBindFragmentShaderATI */
      0, /* glDeleteFragmentShaderATI */
      0, /* glBeginFragmentShaderATI */
      0, /* glEndFragmentShaderATI */
      0, /* glPassTexCoordATI */
      0, /* glSampleMapATI */
      0, /* glColorFragmentOp1ATI */
      0, /* glColorFragmentOp2ATI */
      0, /* glColorFragmentOp3ATI */
      0, /* glAlphaFragmentOp1ATI */
      0, /* glAlphaFragmentOp2ATI */
      0, /* glAlphaFragmentOp3ATI */
      0, /* glSetFragmentShaderConstantATI */
      logIsRenderbufferEXT,
      logBindRenderbufferEXT,
      logDeleteRenderbuffersEXT,
      logGenRenderbuffersEXT,
      logRenderbufferStorageEXT,
      logGetRenderbufferParameterivEXT,
      logIsFramebufferEXT,
      logBindFramebufferEXT,
      logDeleteFramebuffersEXT,
      logGenFramebuffersEXT,
      logCheckFramebufferStatusEXT,
      logFramebufferTexture1DEXT,
      logFramebufferTexture2DEXT,
      logFramebufferTexture3DEXT,
      logFramebufferRenderbufferEXT,
      logGetFramebufferAttachmentParameterivEXT,
      logGenerateMipmapEXT,
      0, /* glStencilFuncSeparate */
      0, /* glStencilOpSeparate */
      0, /* glStencilMaskSeparate */
      0, /* glGetQueryObjecti64vEXT */
      0  /* glGetQueryObjectui64vEXT */
  };
  
  static Bool isCurrent = FALSE;
  
  static void (*flushContextCache) (void);
  static void (*setRenderTables)   (struct _glapi_table *table);
  
  static void
  GlxLogFlushContextCache (void)
  {
      if (isCurrent)
      {
  	fprintf (logFp, "LOSE CURRENT\n");
  	isCurrent = FALSE;
      }
  
      (*flushContextCache) ();
  }
  
  static void
  GlxLogSetRenderTables (struct _glapi_table *table)
  {
      nativeRenderTable = table;
  
      if (table)
      {
  	fprintf (logFp, "FORCE CURRENT\n");
  	isCurrent = TRUE;
  
  	(*setRenderTables) (&__logRenderTable);
      }
      else
      {
  	(*setRenderTables) (0);
      }
  }
  
  void
  xglInitGlxLog (void)
  {
      if (logFp)
  	return;
  
      if (__xglGLXLogFp)
      {
  	logFp = __xglGLXLogFp;
  
  	flushContextCache = __xglGLXFunc.flushContextCache;
  	setRenderTables   = __xglGLXFunc.setRenderTables;
  
  	__xglGLXFunc.flushContextCache = GlxLogFlushContextCache;
  	__xglGLXFunc.setRenderTables   = GlxLogSetRenderTables;
      }
  }
  
  #endif
  