vertex program check-in

56 files changed, 6842 insertions, 2823 deletions

diff --git a/src/mesa/Makefile.X11 b/src/mesa/Makefile.X11
index dc7b2c99f2..6a2e5d7ae4 100644
--- a/src/mesa/Makefile.X11
+++ b/src/mesa/Makefile.X11
@@ -1,4 +1,4 @@
-# $Id: Makefile.X11,v 1.59 2001/11/23 20:44:12 brianp Exp $
+# $Id: Makefile.X11,v 1.60 2001/12/14 02:55:08 brianp Exp $
 
 # Mesa 3-D graphics library
 # Version:  4.1
@@ -21,9 +21,9 @@ LIBDIR = ../lib
 
 
 CORE_SOURCES = \
-	swrast_setup/ss_context.c \
-	swrast_setup/ss_triangle.c \
-	swrast_setup/ss_vb.c \
+	vpexec.c \
+	vpparse.c \
+	vpstate.c \
 	api_arrayelt.c \
 	api_loopback.c \
 	api_noop.c \
@@ -121,6 +121,9 @@ CORE_SOURCES = \
 	swrast/s_texstore.c \
 	swrast/s_triangle.c \
 	swrast/s_zoom.c \
+	swrast_setup/ss_context.c \
+	swrast_setup/ss_triangle.c \
+	swrast_setup/ss_vb.c \
 	tnl/t_array_api.c \
 	tnl/t_array_import.c \
 	tnl/t_context.c \
@@ -138,6 +141,7 @@ CORE_SOURCES = \
 	tnl/t_vb_light.c \
 	tnl/t_vb_normals.c \
 	tnl/t_vb_points.c \
+	tnl/t_vb_program.c \
 	tnl/t_vb_render.c \
 	tnl/t_vb_texgen.c \
 	tnl/t_vb_texmat.c \
@@ -337,3 +341,28 @@ dep: $(CORE_SOURCES) $(DRIVER_SOURCES) $(OSMESA_SOURCES)
 
 tags:
 	etags `find . -name \*.[ch]` `find ../include`
+
+
+
+# XXX temporary for NV_vertex_program
+VPFILES = \
+	include/GL/glext.h \
+	src/Makefile.X11 \
+	src/vpparse.[ch] \
+	src/vpexec.[ch] \
+	src/vpstate.[ch] \
+	src/attrib.c \
+	src/context.c \
+	src/enable.c \
+	src/extensions.c \
+	src/get.c \
+	src/matrix.c \
+	src/mtypes.h \
+	src/varray.c \
+	src/tnl/t_vb_program.c \
+	tests/vptest1.c \
+	tests/vptest2.c
+	
+vptar:
+	cd .. ; tar cvf vpfiles.tar $(VPFILES) ; gzip vpfiles.tar
+
diff --git a/src/mesa/array_cache/ac_context.c b/src/mesa/array_cache/ac_context.c
index 569b62b654..f5a9b4623d 100644
--- a/src/mesa/array_cache/ac_context.c
+++ b/src/mesa/array_cache/ac_context.c
@@ -1,4 +1,4 @@
-/* $Id: ac_context.c,v 1.5 2001/07/19 15:54:35 brianp Exp $ */
+/* $Id: ac_context.c,v 1.6 2001/12/14 02:50:57 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -46,7 +46,7 @@ static void _ac_fallbacks_init( GLcontext *ctx )
    cl->Type = GL_FLOAT;
    cl->Stride = 0;
    cl->StrideB = 0;
-   cl->Ptr = (void *) ctx->Current.Normal;
+   cl->Ptr = (void *) ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
    cl->Enabled = 1;
    cl->Flags = CA_CLIENT_DATA;	/* hack */
 
@@ -55,7 +55,7 @@ static void _ac_fallbacks_init( GLcontext *ctx )
    cl->Type = GL_FLOAT;
    cl->Stride = 0;
    cl->StrideB = 0;
-   cl->Ptr = (void *) ctx->Current.Color;
+   cl->Ptr = (void *) ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    cl->Enabled = 1;
    cl->Flags = CA_CLIENT_DATA;	/* hack */
 
@@ -64,7 +64,7 @@ static void _ac_fallbacks_init( GLcontext *ctx )
    cl->Type = GL_FLOAT;
    cl->Stride = 0;
    cl->StrideB = 0;
-   cl->Ptr = (void *) ctx->Current.SecondaryColor;
+   cl->Ptr = (void *) ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
    cl->Enabled = 1;
    cl->Flags = CA_CLIENT_DATA;	/* hack */
 
@@ -73,7 +73,7 @@ static void _ac_fallbacks_init( GLcontext *ctx )
    cl->Type = GL_FLOAT;
    cl->Stride = 0;
    cl->StrideB = 0;
-   cl->Ptr = (void *) &ctx->Current.FogCoord;
+   cl->Ptr = (void *) &ctx->Current.Attrib[VERT_ATTRIB_FOG];
    cl->Enabled = 1;
    cl->Flags = CA_CLIENT_DATA;	/* hack */
 
@@ -92,7 +92,7 @@ static void _ac_fallbacks_init( GLcontext *ctx )
       cl->Type = GL_FLOAT;
       cl->Stride = 0;
       cl->StrideB = 0;
-      cl->Ptr = (void *) ctx->Current.Texcoord[i];
+      cl->Ptr = (void *) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i];
       cl->Enabled = 1;
       cl->Flags = CA_CLIENT_DATA;	/* hack */
    }
diff --git a/src/mesa/array_cache/ac_import.c b/src/mesa/array_cache/ac_import.c
index a2f3ceabad..35538e294c 100644
--- a/src/mesa/array_cache/ac_import.c
+++ b/src/mesa/array_cache/ac_import.c
@@ -1,4 +1,4 @@
-/* $Id: ac_import.c,v 1.14 2001/04/28 08:39:18 keithw Exp $ */
+/* $Id: ac_import.c,v 1.15 2001/12/14 02:50:57 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -59,9 +59,9 @@ static void reset_texcoord( GLcontext *ctx, GLuint unit )
    else {
       ac->Raw.TexCoord[unit] = ac->Fallback.TexCoord[unit];
 
-      if (ctx->Current.Texcoord[unit][3] != 1.0)
+      if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3] != 1.0)
 	 ac->Raw.TexCoord[unit].Size = 4;
-      else if (ctx->Current.Texcoord[unit][2] != 0.0)
+      else if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2] != 0.0)
 	 ac->Raw.TexCoord[unit].Size = 3;
       else
 	 ac->Raw.TexCoord[unit].Size = 2;
@@ -104,7 +104,7 @@ static void reset_color( GLcontext *ctx )
    ACcontext *ac = AC_CONTEXT(ctx);
 
 
-   if (ctx->Array._Enabled & _NEW_ARRAY_COLOR) {
+   if (ctx->Array._Enabled & _NEW_ARRAY_COLOR0) {
       ac->Raw.Color = ctx->Array.Color;
       STRIDE_ARRAY(ac->Raw.Color, ac->start);
    }
@@ -112,7 +112,7 @@ static void reset_color( GLcontext *ctx )
       ac->Raw.Color = ac->Fallback.Color;
 
    ac->IsCached.Color = GL_FALSE;
-   ac->NewArrayState &= ~_NEW_ARRAY_COLOR;
+   ac->NewArrayState &= ~_NEW_ARRAY_COLOR0;
 }
 
 
@@ -120,7 +120,7 @@ static void reset_secondarycolor( GLcontext *ctx )
 {
    ACcontext *ac = AC_CONTEXT(ctx);
 
-   if (ctx->Array._Enabled & _NEW_ARRAY_SECONDARYCOLOR) {
+   if (ctx->Array._Enabled & _NEW_ARRAY_COLOR1) {
       ac->Raw.SecondaryColor = ctx->Array.SecondaryColor;
       STRIDE_ARRAY(ac->Raw.SecondaryColor, ac->start);
    }
@@ -128,7 +128,7 @@ static void reset_secondarycolor( GLcontext *ctx )
       ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor;
 
    ac->IsCached.SecondaryColor = GL_FALSE;
-   ac->NewArrayState &= ~_NEW_ARRAY_SECONDARYCOLOR;
+   ac->NewArrayState &= ~_NEW_ARRAY_COLOR1;
 }
 
 
@@ -533,7 +533,7 @@ struct gl_client_array *_ac_import_color( GLcontext *ctx,
 
    /* Can we keep the existing version?
     */
-   if (ac->NewArrayState & _NEW_ARRAY_COLOR)
+   if (ac->NewArrayState & _NEW_ARRAY_COLOR0)
       reset_color( ctx );
 
    /* Is the request impossible?
@@ -601,7 +601,7 @@ struct gl_client_array *_ac_import_secondarycolor( GLcontext *ctx,
 
    /* Can we keep the existing version?
     */
-   if (ac->NewArrayState & _NEW_ARRAY_SECONDARYCOLOR)
+   if (ac->NewArrayState & _NEW_ARRAY_COLOR1)
       reset_secondarycolor( ctx );
 
    /* Is the request impossible?
diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h
index f3a28fc193..34d2a9d516 100644
--- a/src/mesa/glapi/glapioffsets.h
+++ b/src/mesa/glapi/glapioffsets.h
@@ -596,5 +596,69 @@
 #define _gloffset_WindowPos3fvARB 591
 #define _gloffset_WindowPos3ivARB 592
 #define _gloffset_WindowPos3svARB 593
+#define _gloffset_BindProgramNV 594
+#define _gloffset_DeleteProgramsNV 595
+#define _gloffset_ExecuteProgramNV 596
+#define _gloffset_GenProgramsNV 597
+#define _gloffset_AreProgramsResidentNV 598
+#define _gloffset_RequestResidentProgramsNV 599
+#define _gloffset_GetProgramParameterfvNV 600
+#define _gloffset_GetProgramParameterdvNV 601
+#define _gloffset_GetProgramivNV 602
+#define _gloffset_GetProgramStringNV 603
+#define _gloffset_GetTrackMatrixivNV 604
+#define _gloffset_GetVertexAttribdvNV 605
+#define _gloffset_GetVertexAttribfvNV 606
+#define _gloffset_GetVertexAttribivNV 607
+#define _gloffset_GetVertexAttribPointervNV 608
+#define _gloffset_IsProgramNV 609
+#define _gloffset_LoadProgramNV 610
+#define _gloffset_ProgramParameter4fNV 611
+#define _gloffset_ProgramParameter4dNV 612
+#define _gloffset_ProgramParameter4dvNV 613
+#define _gloffset_ProgramParameter4fvNV 614
+#define _gloffset_ProgramParameters4dvNV 615
+#define _gloffset_ProgramParameters4fvNV 616
+#define _gloffset_TrackMatrixNV 617
+#define _gloffset_VertexAttribPointerNV 618
+#define _gloffset_VertexAttrib1sNV 619
+#define _gloffset_VertexAttrib1fNV 620
+#define _gloffset_VertexAttrib1dNV 621
+#define _gloffset_VertexAttrib2sNV 622
+#define _gloffset_VertexAttrib2fNV 623
+#define _gloffset_VertexAttrib2dNV 624
+#define _gloffset_VertexAttrib3sNV 625
+#define _gloffset_VertexAttrib3fNV 626
+#define _gloffset_VertexAttrib3dNV 627
+#define _gloffset_VertexAttrib4sNV 628
+#define _gloffset_VertexAttrib4fNV 629
+#define _gloffset_VertexAttrib4dNV 630
+#define _gloffset_VertexAttrib4ubNV 631
+#define _gloffset_VertexAttrib1svNV 632
+#define _gloffset_VertexAttrib1fvNV 633
+#define _gloffset_VertexAttrib1dvNV 634
+#define _gloffset_VertexAttrib2svNV 635
+#define _gloffset_VertexAttrib2fvNV 636
+#define _gloffset_VertexAttrib2dvNV 637
+#define _gloffset_VertexAttrib3svNV 638
+#define _gloffset_VertexAttrib3fvNV 639
+#define _gloffset_VertexAttrib3dvNV 640
+#define _gloffset_VertexAttrib4svNV 641
+#define _gloffset_VertexAttrib4fvNV 642
+#define _gloffset_VertexAttrib4dvNV 643
+#define _gloffset_VertexAttrib4ubvNV 644
+#define _gloffset_VertexAttribs1svNV 645
+#define _gloffset_VertexAttribs1fvNV 646
+#define _gloffset_VertexAttribs1dvNV 647
+#define _gloffset_VertexAttribs2svNV 648
+#define _gloffset_VertexAttribs2fvNV 649
+#define _gloffset_VertexAttribs2dvNV 650
+#define _gloffset_VertexAttribs3svNV 651
+#define _gloffset_VertexAttribs3fvNV 652
+#define _gloffset_VertexAttribs3dvNV 653
+#define _gloffset_VertexAttribs4svNV 654
+#define _gloffset_VertexAttribs4fvNV 655
+#define _gloffset_VertexAttribs4dvNV 656
+#define _gloffset_VertexAttribs4ubvNV 657
 
 #endif
diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h
index c0cde27ab9..8cf465bfb9 100644
--- a/src/mesa/glapi/glapitable.h
+++ b/src/mesa/glapi/glapitable.h
@@ -600,6 +600,70 @@ struct _glapi_table
    void (*WindowPos3fvARB)(const GLfloat * p); /* 591 */
    void (*WindowPos3ivARB)(const GLint * p); /* 592 */
    void (*WindowPos3svARB)(const GLshort * p); /* 593 */
+   void (*BindProgramNV)(GLenum target, GLuint id); /* 594 */
+   void (*DeleteProgramsNV)(GLsizei n, const GLuint * ids); /* 595 */
+   void (*ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 596 */
+   void (*GenProgramsNV)(GLsizei n, GLuint * ids); /* 597 */
+   GLboolean (*AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 598 */
+   void (*RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 599 */
+   void (*GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 600 */
+   void (*GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 601 */
+   void (*GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 602 */
+   void (*GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 603 */
+   void (*GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 604 */
+   void (*GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 605 */
+   void (*GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 606 */
+   void (*GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 607 */
+   void (*GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 608 */
+   GLboolean (*IsProgramNV)(GLuint id); /* 609 */
+   void (*LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 610 */
+   void (*ProgramParameter4fNV)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 611 */
+   void (*ProgramParameter4dNV)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 612 */
+   void (*ProgramParameter4dvNV)(GLenum target, GLuint index, const GLdouble * params); /* 613 */
+   void (*ProgramParameter4fvNV)(GLenum target, GLuint index, const GLfloat * params); /* 614 */
+   void (*ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 615 */
+   void (*ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 616 */
+   void (*TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 617 */
+   void (*VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 618 */
+   void (*VertexAttrib1sNV)(GLuint index, GLshort x); /* 619 */
+   void (*VertexAttrib1fNV)(GLuint index, GLfloat x); /* 620 */
+   void (*VertexAttrib1dNV)(GLuint index, GLdouble x); /* 621 */
+   void (*VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 622 */
+   void (*VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 623 */
+   void (*VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 624 */
+   void (*VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 625 */
+   void (*VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 626 */
+   void (*VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 627 */
+   void (*VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 628 */
+   void (*VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 629 */
+   void (*VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 630 */
+   void (*VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 631 */
+   void (*VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 632 */
+   void (*VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 633 */
+   void (*VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 634 */
+   void (*VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 635 */
+   void (*VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 636 */
+   void (*VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 637 */
+   void (*VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 638 */
+   void (*VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 639 */
+   void (*VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 640 */
+   void (*VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 641 */
+   void (*VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 642 */
+   void (*VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 643 */
+   void (*VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 644 */
+   void (*VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 645 */
+   void (*VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 646 */
+   void (*VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 647 */
+   void (*VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 648 */
+   void (*VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 649 */
+   void (*VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 650 */
+   void (*VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 651 */
+   void (*VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 652 */
+   void (*VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 653 */
+   void (*VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 654 */
+   void (*VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 655 */
+   void (*VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 656 */
+   void (*VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 657 */
 };
 
 #endif
diff --git a/src/mesa/glapi/glapitemp.h b/src/mesa/glapi/glapitemp.h
index dbdab5c827..b244e12e32 100644
--- a/src/mesa/glapi/glapitemp.h
+++ b/src/mesa/glapi/glapitemp.h
@@ -46,2337 +46,2336 @@
 #error RETURN_DISPATCH must be defined
 #endif
 
-extern void gl__unused413(void);  /* silence warning */
 
 KEYWORD1 void KEYWORD2 NAME(NewList)(GLuint list, GLenum mode)
 {
-   DISPATCH(NewList, (list, mode), (F, "glNewList(%d, 0x%x);\n", list, mode));
+   DISPATCH(NewList, (list, mode), (F, "glNewList(%d, 0x%x);", list, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EndList)(void)
 {
-   DISPATCH(EndList, (), (F, "glEndList();\n"));
+   DISPATCH(EndList, (), (F, "glEndList();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CallList)(GLuint list)
 {
-   DISPATCH(CallList, (list), (F, "glCallList(%d);\n", list));
+   DISPATCH(CallList, (list), (F, "glCallList(%d);", list));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CallLists)(GLsizei n, GLenum type, const GLvoid * lists)
 {
-   DISPATCH(CallLists, (n, type, lists), (F, "glCallLists(%p, 0x%x, %p);\n", (void *) n, type, (void *) lists));
+   DISPATCH(CallLists, (n, type, lists), (F, "glCallLists(%p, 0x%x, %p);", (void *) n, type, (void *) lists));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DeleteLists)(GLuint list, GLsizei range)
 {
-   DISPATCH(DeleteLists, (list, range), (F, "glDeleteLists(%d, %p);\n", list, (void *) range));
+   DISPATCH(DeleteLists, (list, range), (F, "glDeleteLists(%d, %p);", list, (void *) range));
 }
 
 KEYWORD1 GLuint KEYWORD2 NAME(GenLists)(GLsizei range)
 {
-   RETURN_DISPATCH(GenLists, (range), (F, "glGenLists(%p);\n", (void *) range));
+   RETURN_DISPATCH(GenLists, (range), (F, "glGenLists(%p);", (void *) range));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListBase)(GLuint base)
 {
-   DISPATCH(ListBase, (base), (F, "glListBase(%d);\n", base));
+   DISPATCH(ListBase, (base), (F, "glListBase(%d);", base));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Begin)(GLenum mode)
 {
-   DISPATCH(Begin, (mode), (F, "glBegin(0x%x);\n", mode));
+   DISPATCH(Begin, (mode), (F, "glBegin(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
 {
-   DISPATCH(Bitmap, (width, height, xorig, yorig, xmove, ymove, bitmap), (F, "glBitmap(%p, %p, %f, %f, %f, %f, %p);\n", (void *) width, (void *) height, xorig, yorig, xmove, ymove, (void *) bitmap));
+   DISPATCH(Bitmap, (width, height, xorig, yorig, xmove, ymove, bitmap), (F, "glBitmap(%p, %p, %f, %f, %f, %f, %p);", (void *) width, (void *) height, xorig, yorig, xmove, ymove, (void *) bitmap));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3b)(GLbyte red, GLbyte green, GLbyte blue)
 {
-   DISPATCH(Color3b, (red, green, blue), (F, "glColor3b(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3b, (red, green, blue), (F, "glColor3b(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3bv)(const GLbyte * v)
 {
-   DISPATCH(Color3bv, (v), (F, "glColor3bv(%p);\n", (void *) v));
+   DISPATCH(Color3bv, (v), (F, "glColor3bv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3d)(GLdouble red, GLdouble green, GLdouble blue)
 {
-   DISPATCH(Color3d, (red, green, blue), (F, "glColor3d(%f, %f, %f);\n", red, green, blue));
+   DISPATCH(Color3d, (red, green, blue), (F, "glColor3d(%f, %f, %f);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3dv)(const GLdouble * v)
 {
-   DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);\n", (void *) v));
+   DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3f)(GLfloat red, GLfloat green, GLfloat blue)
 {
-   DISPATCH(Color3f, (red, green, blue), (F, "glColor3f(%f, %f, %f);\n", red, green, blue));
+   DISPATCH(Color3f, (red, green, blue), (F, "glColor3f(%f, %f, %f);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3fv)(const GLfloat * v)
 {
-   DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);\n", (void *) v));
+   DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3i)(GLint red, GLint green, GLint blue)
 {
-   DISPATCH(Color3i, (red, green, blue), (F, "glColor3i(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3i, (red, green, blue), (F, "glColor3i(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3iv)(const GLint * v)
 {
-   DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);\n", (void *) v));
+   DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3s)(GLshort red, GLshort green, GLshort blue)
 {
-   DISPATCH(Color3s, (red, green, blue), (F, "glColor3s(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3s, (red, green, blue), (F, "glColor3s(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3sv)(const GLshort * v)
 {
-   DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);\n", (void *) v));
+   DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3ub)(GLubyte red, GLubyte green, GLubyte blue)
 {
-   DISPATCH(Color3ub, (red, green, blue), (F, "glColor3ub(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3ub, (red, green, blue), (F, "glColor3ub(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3ubv)(const GLubyte * v)
 {
-   DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);\n", (void *) v));
+   DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3ui)(GLuint red, GLuint green, GLuint blue)
 {
-   DISPATCH(Color3ui, (red, green, blue), (F, "glColor3ui(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3ui, (red, green, blue), (F, "glColor3ui(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3uiv)(const GLuint * v)
 {
-   DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);\n", (void *) v));
+   DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3us)(GLushort red, GLushort green, GLushort blue)
 {
-   DISPATCH(Color3us, (red, green, blue), (F, "glColor3us(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(Color3us, (red, green, blue), (F, "glColor3us(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3usv)(const GLushort * v)
 {
-   DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);\n", (void *) v));
+   DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-   DISPATCH(Color4b, (red, green, blue, alpha), (F, "glColor4b(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4b, (red, green, blue, alpha), (F, "glColor4b(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4bv)(const GLbyte * v)
 {
-   DISPATCH(Color4bv, (v), (F, "glColor4bv(%p);\n", (void *) v));
+   DISPATCH(Color4bv, (v), (F, "glColor4bv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-   DISPATCH(Color4d, (red, green, blue, alpha), (F, "glColor4d(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(Color4d, (red, green, blue, alpha), (F, "glColor4d(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4dv)(const GLdouble * v)
 {
-   DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);\n", (void *) v));
+   DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-   DISPATCH(Color4f, (red, green, blue, alpha), (F, "glColor4f(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(Color4f, (red, green, blue, alpha), (F, "glColor4f(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4fv)(const GLfloat * v)
 {
-   DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);\n", (void *) v));
+   DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4i)(GLint red, GLint green, GLint blue, GLint alpha)
 {
-   DISPATCH(Color4i, (red, green, blue, alpha), (F, "glColor4i(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4i, (red, green, blue, alpha), (F, "glColor4i(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4iv)(const GLint * v)
 {
-   DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);\n", (void *) v));
+   DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-   DISPATCH(Color4s, (red, green, blue, alpha), (F, "glColor4s(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4s, (red, green, blue, alpha), (F, "glColor4s(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4sv)(const GLshort * v)
 {
-   DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);\n", (void *) v));
+   DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-   DISPATCH(Color4ub, (red, green, blue, alpha), (F, "glColor4ub(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4ub, (red, green, blue, alpha), (F, "glColor4ub(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4ubv)(const GLubyte * v)
 {
-   DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);\n", (void *) v));
+   DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-   DISPATCH(Color4ui, (red, green, blue, alpha), (F, "glColor4ui(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4ui, (red, green, blue, alpha), (F, "glColor4ui(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4uiv)(const GLuint * v)
 {
-   DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);\n", (void *) v));
+   DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-   DISPATCH(Color4us, (red, green, blue, alpha), (F, "glColor4us(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(Color4us, (red, green, blue, alpha), (F, "glColor4us(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4usv)(const GLushort * v)
 {
-   DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);\n", (void *) v));
+   DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EdgeFlag)(GLboolean flag)
 {
-   DISPATCH(EdgeFlag, (flag), (F, "glEdgeFlag(%d);\n", flag));
+   DISPATCH(EdgeFlag, (flag), (F, "glEdgeFlag(%d);", flag));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EdgeFlagv)(const GLboolean * flag)
 {
-   DISPATCH(EdgeFlagv, (flag), (F, "glEdgeFlagv(%p);\n", (void *) flag));
+   DISPATCH(EdgeFlagv, (flag), (F, "glEdgeFlagv(%p);", (void *) flag));
 }
 
 KEYWORD1 void KEYWORD2 NAME(End)(void)
 {
-   DISPATCH(End, (), (F, "glEnd();\n"));
+   DISPATCH(End, (), (F, "glEnd();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexd)(GLdouble c)
 {
-   DISPATCH(Indexd, (c), (F, "glIndexd(%f);\n", c));
+   DISPATCH(Indexd, (c), (F, "glIndexd(%f);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexdv)(const GLdouble * c)
 {
-   DISPATCH(Indexdv, (c), (F, "glIndexdv(%p);\n", (void *) c));
+   DISPATCH(Indexdv, (c), (F, "glIndexdv(%p);", (void *) c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexf)(GLfloat c)
 {
-   DISPATCH(Indexf, (c), (F, "glIndexf(%f);\n", c));
+   DISPATCH(Indexf, (c), (F, "glIndexf(%f);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexfv)(const GLfloat * c)
 {
-   DISPATCH(Indexfv, (c), (F, "glIndexfv(%p);\n", (void *) c));
+   DISPATCH(Indexfv, (c), (F, "glIndexfv(%p);", (void *) c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexi)(GLint c)
 {
-   DISPATCH(Indexi, (c), (F, "glIndexi(%d);\n", c));
+   DISPATCH(Indexi, (c), (F, "glIndexi(%d);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexiv)(const GLint * c)
 {
-   DISPATCH(Indexiv, (c), (F, "glIndexiv(%p);\n", (void *) c));
+   DISPATCH(Indexiv, (c), (F, "glIndexiv(%p);", (void *) c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexs)(GLshort c)
 {
-   DISPATCH(Indexs, (c), (F, "glIndexs(%d);\n", c));
+   DISPATCH(Indexs, (c), (F, "glIndexs(%d);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexsv)(const GLshort * c)
 {
-   DISPATCH(Indexsv, (c), (F, "glIndexsv(%p);\n", (void *) c));
+   DISPATCH(Indexsv, (c), (F, "glIndexsv(%p);", (void *) c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-   DISPATCH(Normal3b, (nx, ny, nz), (F, "glNormal3b(%d, %d, %d);\n", nx, ny, nz));
+   DISPATCH(Normal3b, (nx, ny, nz), (F, "glNormal3b(%d, %d, %d);", nx, ny, nz));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3bv)(const GLbyte * v)
 {
-   DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);\n", (void *) v));
+   DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-   DISPATCH(Normal3d, (nx, ny, nz), (F, "glNormal3d(%f, %f, %f);\n", nx, ny, nz));
+   DISPATCH(Normal3d, (nx, ny, nz), (F, "glNormal3d(%f, %f, %f);", nx, ny, nz));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3dv)(const GLdouble * v)
 {
-   DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);\n", (void *) v));
+   DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-   DISPATCH(Normal3f, (nx, ny, nz), (F, "glNormal3f(%f, %f, %f);\n", nx, ny, nz));
+   DISPATCH(Normal3f, (nx, ny, nz), (F, "glNormal3f(%f, %f, %f);", nx, ny, nz));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3fv)(const GLfloat * v)
 {
-   DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);\n", (void *) v));
+   DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3i)(GLint nx, GLint ny, GLint nz)
 {
-   DISPATCH(Normal3i, (nx, ny, nz), (F, "glNormal3i(%d, %d, %d);\n", nx, ny, nz));
+   DISPATCH(Normal3i, (nx, ny, nz), (F, "glNormal3i(%d, %d, %d);", nx, ny, nz));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3iv)(const GLint * v)
 {
-   DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);\n", (void *) v));
+   DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3s)(GLshort nx, GLshort ny, GLshort nz)
 {
-   DISPATCH(Normal3s, (nx, ny, nz), (F, "glNormal3s(%d, %d, %d);\n", nx, ny, nz));
+   DISPATCH(Normal3s, (nx, ny, nz), (F, "glNormal3s(%d, %d, %d);", nx, ny, nz));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3sv)(const GLshort * v)
 {
-   DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);\n", (void *) v));
+   DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2d)(GLdouble x, GLdouble y)
 {
-   DISPATCH(RasterPos2d, (x, y), (F, "glRasterPos2d(%f, %f);\n", x, y));
+   DISPATCH(RasterPos2d, (x, y), (F, "glRasterPos2d(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2dv)(const GLdouble * v)
 {
-   DISPATCH(RasterPos2dv, (v), (F, "glRasterPos2dv(%p);\n", (void *) v));
+   DISPATCH(RasterPos2dv, (v), (F, "glRasterPos2dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2f)(GLfloat x, GLfloat y)
 {
-   DISPATCH(RasterPos2f, (x, y), (F, "glRasterPos2f(%f, %f);\n", x, y));
+   DISPATCH(RasterPos2f, (x, y), (F, "glRasterPos2f(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2fv)(const GLfloat * v)
 {
-   DISPATCH(RasterPos2fv, (v), (F, "glRasterPos2fv(%p);\n", (void *) v));
+   DISPATCH(RasterPos2fv, (v), (F, "glRasterPos2fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2i)(GLint x, GLint y)
 {
-   DISPATCH(RasterPos2i, (x, y), (F, "glRasterPos2i(%d, %d);\n", x, y));
+   DISPATCH(RasterPos2i, (x, y), (F, "glRasterPos2i(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2iv)(const GLint * v)
 {
-   DISPATCH(RasterPos2iv, (v), (F, "glRasterPos2iv(%p);\n", (void *) v));
+   DISPATCH(RasterPos2iv, (v), (F, "glRasterPos2iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2s)(GLshort x, GLshort y)
 {
-   DISPATCH(RasterPos2s, (x, y), (F, "glRasterPos2s(%d, %d);\n", x, y));
+   DISPATCH(RasterPos2s, (x, y), (F, "glRasterPos2s(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2sv)(const GLshort * v)
 {
-   DISPATCH(RasterPos2sv, (v), (F, "glRasterPos2sv(%p);\n", (void *) v));
+   DISPATCH(RasterPos2sv, (v), (F, "glRasterPos2sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3d)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(RasterPos3d, (x, y, z), (F, "glRasterPos3d(%f, %f, %f);\n", x, y, z));
+   DISPATCH(RasterPos3d, (x, y, z), (F, "glRasterPos3d(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3dv)(const GLdouble * v)
 {
-   DISPATCH(RasterPos3dv, (v), (F, "glRasterPos3dv(%p);\n", (void *) v));
+   DISPATCH(RasterPos3dv, (v), (F, "glRasterPos3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3f)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(RasterPos3f, (x, y, z), (F, "glRasterPos3f(%f, %f, %f);\n", x, y, z));
+   DISPATCH(RasterPos3f, (x, y, z), (F, "glRasterPos3f(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3fv)(const GLfloat * v)
 {
-   DISPATCH(RasterPos3fv, (v), (F, "glRasterPos3fv(%p);\n", (void *) v));
+   DISPATCH(RasterPos3fv, (v), (F, "glRasterPos3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3i)(GLint x, GLint y, GLint z)
 {
-   DISPATCH(RasterPos3i, (x, y, z), (F, "glRasterPos3i(%d, %d, %d);\n", x, y, z));
+   DISPATCH(RasterPos3i, (x, y, z), (F, "glRasterPos3i(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3iv)(const GLint * v)
 {
-   DISPATCH(RasterPos3iv, (v), (F, "glRasterPos3iv(%p);\n", (void *) v));
+   DISPATCH(RasterPos3iv, (v), (F, "glRasterPos3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3s)(GLshort x, GLshort y, GLshort z)
 {
-   DISPATCH(RasterPos3s, (x, y, z), (F, "glRasterPos3s(%d, %d, %d);\n", x, y, z));
+   DISPATCH(RasterPos3s, (x, y, z), (F, "glRasterPos3s(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3sv)(const GLshort * v)
 {
-   DISPATCH(RasterPos3sv, (v), (F, "glRasterPos3sv(%p);\n", (void *) v));
+   DISPATCH(RasterPos3sv, (v), (F, "glRasterPos3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   DISPATCH(RasterPos4d, (x, y, z, w), (F, "glRasterPos4d(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(RasterPos4d, (x, y, z, w), (F, "glRasterPos4d(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4dv)(const GLdouble * v)
 {
-   DISPATCH(RasterPos4dv, (v), (F, "glRasterPos4dv(%p);\n", (void *) v));
+   DISPATCH(RasterPos4dv, (v), (F, "glRasterPos4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-   DISPATCH(RasterPos4f, (x, y, z, w), (F, "glRasterPos4f(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(RasterPos4f, (x, y, z, w), (F, "glRasterPos4f(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4fv)(const GLfloat * v)
 {
-   DISPATCH(RasterPos4fv, (v), (F, "glRasterPos4fv(%p);\n", (void *) v));
+   DISPATCH(RasterPos4fv, (v), (F, "glRasterPos4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4i)(GLint x, GLint y, GLint z, GLint w)
 {
-   DISPATCH(RasterPos4i, (x, y, z, w), (F, "glRasterPos4i(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(RasterPos4i, (x, y, z, w), (F, "glRasterPos4i(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4iv)(const GLint * v)
 {
-   DISPATCH(RasterPos4iv, (v), (F, "glRasterPos4iv(%p);\n", (void *) v));
+   DISPATCH(RasterPos4iv, (v), (F, "glRasterPos4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-   DISPATCH(RasterPos4s, (x, y, z, w), (F, "glRasterPos4s(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(RasterPos4s, (x, y, z, w), (F, "glRasterPos4s(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4sv)(const GLshort * v)
 {
-   DISPATCH(RasterPos4sv, (v), (F, "glRasterPos4sv(%p);\n", (void *) v));
+   DISPATCH(RasterPos4sv, (v), (F, "glRasterPos4sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-   DISPATCH(Rectd, (x1, y1, x2, y2), (F, "glRectd(%f, %f, %f, %f);\n", x1, y1, x2, y2));
+   DISPATCH(Rectd, (x1, y1, x2, y2), (F, "glRectd(%f, %f, %f, %f);", x1, y1, x2, y2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectdv)(const GLdouble * v1, const GLdouble * v2)
 {
-   DISPATCH(Rectdv, (v1, v2), (F, "glRectdv(%p, %p);\n", (void *) v1, (void *) v2));
+   DISPATCH(Rectdv, (v1, v2), (F, "glRectdv(%p, %p);", (void *) v1, (void *) v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-   DISPATCH(Rectf, (x1, y1, x2, y2), (F, "glRectf(%f, %f, %f, %f);\n", x1, y1, x2, y2));
+   DISPATCH(Rectf, (x1, y1, x2, y2), (F, "glRectf(%f, %f, %f, %f);", x1, y1, x2, y2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectfv)(const GLfloat * v1, const GLfloat * v2)
 {
-   DISPATCH(Rectfv, (v1, v2), (F, "glRectfv(%p, %p);\n", (void *) v1, (void *) v2));
+   DISPATCH(Rectfv, (v1, v2), (F, "glRectfv(%p, %p);", (void *) v1, (void *) v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Recti)(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-   DISPATCH(Recti, (x1, y1, x2, y2), (F, "glRecti(%d, %d, %d, %d);\n", x1, y1, x2, y2));
+   DISPATCH(Recti, (x1, y1, x2, y2), (F, "glRecti(%d, %d, %d, %d);", x1, y1, x2, y2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectiv)(const GLint * v1, const GLint * v2)
 {
-   DISPATCH(Rectiv, (v1, v2), (F, "glRectiv(%p, %p);\n", (void *) v1, (void *) v2));
+   DISPATCH(Rectiv, (v1, v2), (F, "glRectiv(%p, %p);", (void *) v1, (void *) v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-   DISPATCH(Rects, (x1, y1, x2, y2), (F, "glRects(%d, %d, %d, %d);\n", x1, y1, x2, y2));
+   DISPATCH(Rects, (x1, y1, x2, y2), (F, "glRects(%d, %d, %d, %d);", x1, y1, x2, y2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rectsv)(const GLshort * v1, const GLshort * v2)
 {
-   DISPATCH(Rectsv, (v1, v2), (F, "glRectsv(%p, %p);\n", (void *) v1, (void *) v2));
+   DISPATCH(Rectsv, (v1, v2), (F, "glRectsv(%p, %p);", (void *) v1, (void *) v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1d)(GLdouble s)
 {
-   DISPATCH(TexCoord1d, (s), (F, "glTexCoord1d(%f);\n", s));
+   DISPATCH(TexCoord1d, (s), (F, "glTexCoord1d(%f);", s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1dv)(const GLdouble * v)
 {
-   DISPATCH(TexCoord1dv, (v), (F, "glTexCoord1dv(%p);\n", (void *) v));
+   DISPATCH(TexCoord1dv, (v), (F, "glTexCoord1dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1f)(GLfloat s)
 {
-   DISPATCH(TexCoord1f, (s), (F, "glTexCoord1f(%f);\n", s));
+   DISPATCH(TexCoord1f, (s), (F, "glTexCoord1f(%f);", s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1fv)(const GLfloat * v)
 {
-   DISPATCH(TexCoord1fv, (v), (F, "glTexCoord1fv(%p);\n", (void *) v));
+   DISPATCH(TexCoord1fv, (v), (F, "glTexCoord1fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1i)(GLint s)
 {
-   DISPATCH(TexCoord1i, (s), (F, "glTexCoord1i(%d);\n", s));
+   DISPATCH(TexCoord1i, (s), (F, "glTexCoord1i(%d);", s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1iv)(const GLint * v)
 {
-   DISPATCH(TexCoord1iv, (v), (F, "glTexCoord1iv(%p);\n", (void *) v));
+   DISPATCH(TexCoord1iv, (v), (F, "glTexCoord1iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1s)(GLshort s)
 {
-   DISPATCH(TexCoord1s, (s), (F, "glTexCoord1s(%d);\n", s));
+   DISPATCH(TexCoord1s, (s), (F, "glTexCoord1s(%d);", s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord1sv)(const GLshort * v)
 {
-   DISPATCH(TexCoord1sv, (v), (F, "glTexCoord1sv(%p);\n", (void *) v));
+   DISPATCH(TexCoord1sv, (v), (F, "glTexCoord1sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2d)(GLdouble s, GLdouble t)
 {
-   DISPATCH(TexCoord2d, (s, t), (F, "glTexCoord2d(%f, %f);\n", s, t));
+   DISPATCH(TexCoord2d, (s, t), (F, "glTexCoord2d(%f, %f);", s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2dv)(const GLdouble * v)
 {
-   DISPATCH(TexCoord2dv, (v), (F, "glTexCoord2dv(%p);\n", (void *) v));
+   DISPATCH(TexCoord2dv, (v), (F, "glTexCoord2dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2f)(GLfloat s, GLfloat t)
 {
-   DISPATCH(TexCoord2f, (s, t), (F, "glTexCoord2f(%f, %f);\n", s, t));
+   DISPATCH(TexCoord2f, (s, t), (F, "glTexCoord2f(%f, %f);", s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2fv)(const GLfloat * v)
 {
-   DISPATCH(TexCoord2fv, (v), (F, "glTexCoord2fv(%p);\n", (void *) v));
+   DISPATCH(TexCoord2fv, (v), (F, "glTexCoord2fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2i)(GLint s, GLint t)
 {
-   DISPATCH(TexCoord2i, (s, t), (F, "glTexCoord2i(%d, %d);\n", s, t));
+   DISPATCH(TexCoord2i, (s, t), (F, "glTexCoord2i(%d, %d);", s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2iv)(const GLint * v)
 {
-   DISPATCH(TexCoord2iv, (v), (F, "glTexCoord2iv(%p);\n", (void *) v));
+   DISPATCH(TexCoord2iv, (v), (F, "glTexCoord2iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2s)(GLshort s, GLshort t)
 {
-   DISPATCH(TexCoord2s, (s, t), (F, "glTexCoord2s(%d, %d);\n", s, t));
+   DISPATCH(TexCoord2s, (s, t), (F, "glTexCoord2s(%d, %d);", s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord2sv)(const GLshort * v)
 {
-   DISPATCH(TexCoord2sv, (v), (F, "glTexCoord2sv(%p);\n", (void *) v));
+   DISPATCH(TexCoord2sv, (v), (F, "glTexCoord2sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3d)(GLdouble s, GLdouble t, GLdouble r)
 {
-   DISPATCH(TexCoord3d, (s, t, r), (F, "glTexCoord3d(%f, %f, %f);\n", s, t, r));
+   DISPATCH(TexCoord3d, (s, t, r), (F, "glTexCoord3d(%f, %f, %f);", s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3dv)(const GLdouble * v)
 {
-   DISPATCH(TexCoord3dv, (v), (F, "glTexCoord3dv(%p);\n", (void *) v));
+   DISPATCH(TexCoord3dv, (v), (F, "glTexCoord3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3f)(GLfloat s, GLfloat t, GLfloat r)
 {
-   DISPATCH(TexCoord3f, (s, t, r), (F, "glTexCoord3f(%f, %f, %f);\n", s, t, r));
+   DISPATCH(TexCoord3f, (s, t, r), (F, "glTexCoord3f(%f, %f, %f);", s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3fv)(const GLfloat * v)
 {
-   DISPATCH(TexCoord3fv, (v), (F, "glTexCoord3fv(%p);\n", (void *) v));
+   DISPATCH(TexCoord3fv, (v), (F, "glTexCoord3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3i)(GLint s, GLint t, GLint r)
 {
-   DISPATCH(TexCoord3i, (s, t, r), (F, "glTexCoord3i(%d, %d, %d);\n", s, t, r));
+   DISPATCH(TexCoord3i, (s, t, r), (F, "glTexCoord3i(%d, %d, %d);", s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3iv)(const GLint * v)
 {
-   DISPATCH(TexCoord3iv, (v), (F, "glTexCoord3iv(%p);\n", (void *) v));
+   DISPATCH(TexCoord3iv, (v), (F, "glTexCoord3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3s)(GLshort s, GLshort t, GLshort r)
 {
-   DISPATCH(TexCoord3s, (s, t, r), (F, "glTexCoord3s(%d, %d, %d);\n", s, t, r));
+   DISPATCH(TexCoord3s, (s, t, r), (F, "glTexCoord3s(%d, %d, %d);", s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord3sv)(const GLshort * v)
 {
-   DISPATCH(TexCoord3sv, (v), (F, "glTexCoord3sv(%p);\n", (void *) v));
+   DISPATCH(TexCoord3sv, (v), (F, "glTexCoord3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-   DISPATCH(TexCoord4d, (s, t, r, q), (F, "glTexCoord4d(%f, %f, %f, %f);\n", s, t, r, q));
+   DISPATCH(TexCoord4d, (s, t, r, q), (F, "glTexCoord4d(%f, %f, %f, %f);", s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4dv)(const GLdouble * v)
 {
-   DISPATCH(TexCoord4dv, (v), (F, "glTexCoord4dv(%p);\n", (void *) v));
+   DISPATCH(TexCoord4dv, (v), (F, "glTexCoord4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-   DISPATCH(TexCoord4f, (s, t, r, q), (F, "glTexCoord4f(%f, %f, %f, %f);\n", s, t, r, q));
+   DISPATCH(TexCoord4f, (s, t, r, q), (F, "glTexCoord4f(%f, %f, %f, %f);", s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4fv)(const GLfloat * v)
 {
-   DISPATCH(TexCoord4fv, (v), (F, "glTexCoord4fv(%p);\n", (void *) v));
+   DISPATCH(TexCoord4fv, (v), (F, "glTexCoord4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4i)(GLint s, GLint t, GLint r, GLint q)
 {
-   DISPATCH(TexCoord4i, (s, t, r, q), (F, "glTexCoord4i(%d, %d, %d, %d);\n", s, t, r, q));
+   DISPATCH(TexCoord4i, (s, t, r, q), (F, "glTexCoord4i(%d, %d, %d, %d);", s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4iv)(const GLint * v)
 {
-   DISPATCH(TexCoord4iv, (v), (F, "glTexCoord4iv(%p);\n", (void *) v));
+   DISPATCH(TexCoord4iv, (v), (F, "glTexCoord4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-   DISPATCH(TexCoord4s, (s, t, r, q), (F, "glTexCoord4s(%d, %d, %d, %d);\n", s, t, r, q));
+   DISPATCH(TexCoord4s, (s, t, r, q), (F, "glTexCoord4s(%d, %d, %d, %d);", s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoord4sv)(const GLshort * v)
 {
-   DISPATCH(TexCoord4sv, (v), (F, "glTexCoord4sv(%p);\n", (void *) v));
+   DISPATCH(TexCoord4sv, (v), (F, "glTexCoord4sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2d)(GLdouble x, GLdouble y)
 {
-   DISPATCH(Vertex2d, (x, y), (F, "glVertex2d(%f, %f);\n", x, y));
+   DISPATCH(Vertex2d, (x, y), (F, "glVertex2d(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2dv)(const GLdouble * v)
 {
-   DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);\n", (void *) v));
+   DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2f)(GLfloat x, GLfloat y)
 {
-   DISPATCH(Vertex2f, (x, y), (F, "glVertex2f(%f, %f);\n", x, y));
+   DISPATCH(Vertex2f, (x, y), (F, "glVertex2f(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2fv)(const GLfloat * v)
 {
-   DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);\n", (void *) v));
+   DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2i)(GLint x, GLint y)
 {
-   DISPATCH(Vertex2i, (x, y), (F, "glVertex2i(%d, %d);\n", x, y));
+   DISPATCH(Vertex2i, (x, y), (F, "glVertex2i(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2iv)(const GLint * v)
 {
-   DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);\n", (void *) v));
+   DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2s)(GLshort x, GLshort y)
 {
-   DISPATCH(Vertex2s, (x, y), (F, "glVertex2s(%d, %d);\n", x, y));
+   DISPATCH(Vertex2s, (x, y), (F, "glVertex2s(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2sv)(const GLshort * v)
 {
-   DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);\n", (void *) v));
+   DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3d)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(Vertex3d, (x, y, z), (F, "glVertex3d(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Vertex3d, (x, y, z), (F, "glVertex3d(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3dv)(const GLdouble * v)
 {
-   DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);\n", (void *) v));
+   DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(Vertex3f, (x, y, z), (F, "glVertex3f(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Vertex3f, (x, y, z), (F, "glVertex3f(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3fv)(const GLfloat * v)
 {
-   DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);\n", (void *) v));
+   DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3i)(GLint x, GLint y, GLint z)
 {
-   DISPATCH(Vertex3i, (x, y, z), (F, "glVertex3i(%d, %d, %d);\n", x, y, z));
+   DISPATCH(Vertex3i, (x, y, z), (F, "glVertex3i(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3iv)(const GLint * v)
 {
-   DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);\n", (void *) v));
+   DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3s)(GLshort x, GLshort y, GLshort z)
 {
-   DISPATCH(Vertex3s, (x, y, z), (F, "glVertex3s(%d, %d, %d);\n", x, y, z));
+   DISPATCH(Vertex3s, (x, y, z), (F, "glVertex3s(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3sv)(const GLshort * v)
 {
-   DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);\n", (void *) v));
+   DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   DISPATCH(Vertex4d, (x, y, z, w), (F, "glVertex4d(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(Vertex4d, (x, y, z, w), (F, "glVertex4d(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4dv)(const GLdouble * v)
 {
-   DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);\n", (void *) v));
+   DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-   DISPATCH(Vertex4f, (x, y, z, w), (F, "glVertex4f(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(Vertex4f, (x, y, z, w), (F, "glVertex4f(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4fv)(const GLfloat * v)
 {
-   DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);\n", (void *) v));
+   DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4i)(GLint x, GLint y, GLint z, GLint w)
 {
-   DISPATCH(Vertex4i, (x, y, z, w), (F, "glVertex4i(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(Vertex4i, (x, y, z, w), (F, "glVertex4i(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4iv)(const GLint * v)
 {
-   DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);\n", (void *) v));
+   DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-   DISPATCH(Vertex4s, (x, y, z, w), (F, "glVertex4s(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(Vertex4s, (x, y, z, w), (F, "glVertex4s(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4sv)(const GLshort * v)
 {
-   DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);\n", (void *) v));
+   DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClipPlane)(GLenum plane, const GLdouble * equation)
 {
-   DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(0x%x, %p);\n", plane, (void *) equation));
+   DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(0x%x, %p);", plane, (void *) equation));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorMaterial)(GLenum face, GLenum mode)
 {
-   DISPATCH(ColorMaterial, (face, mode), (F, "glColorMaterial(0x%x, 0x%x);\n", face, mode));
+   DISPATCH(ColorMaterial, (face, mode), (F, "glColorMaterial(0x%x, 0x%x);", face, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CullFace)(GLenum mode)
 {
-   DISPATCH(CullFace, (mode), (F, "glCullFace(0x%x);\n", mode));
+   DISPATCH(CullFace, (mode), (F, "glCullFace(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Fogf)(GLenum pname, GLfloat param)
 {
-   DISPATCH(Fogf, (pname, param), (F, "glFogf(0x%x, %f);\n", pname, param));
+   DISPATCH(Fogf, (pname, param), (F, "glFogf(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Fogfv)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Fogi)(GLenum pname, GLint param)
 {
-   DISPATCH(Fogi, (pname, param), (F, "glFogi(0x%x, %d);\n", pname, param));
+   DISPATCH(Fogi, (pname, param), (F, "glFogi(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Fogiv)(GLenum pname, const GLint * params)
 {
-   DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FrontFace)(GLenum mode)
 {
-   DISPATCH(FrontFace, (mode), (F, "glFrontFace(0x%x);\n", mode));
+   DISPATCH(FrontFace, (mode), (F, "glFrontFace(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Hint)(GLenum target, GLenum mode)
 {
-   DISPATCH(Hint, (target, mode), (F, "glHint(0x%x, 0x%x);\n", target, mode));
+   DISPATCH(Hint, (target, mode), (F, "glHint(0x%x, 0x%x);", target, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lightf)(GLenum light, GLenum pname, GLfloat param)
 {
-   DISPATCH(Lightf, (light, pname, param), (F, "glLightf(0x%x, 0x%x, %f);\n", light, pname, param));
+   DISPATCH(Lightf, (light, pname, param), (F, "glLightf(0x%x, 0x%x, %f);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lightfv)(GLenum light, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(Lightfv, (light, pname, params), (F, "glLightfv(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(Lightfv, (light, pname, params), (F, "glLightfv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lighti)(GLenum light, GLenum pname, GLint param)
 {
-   DISPATCH(Lighti, (light, pname, param), (F, "glLighti(0x%x, 0x%x, %d);\n", light, pname, param));
+   DISPATCH(Lighti, (light, pname, param), (F, "glLighti(0x%x, 0x%x, %d);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lightiv)(GLenum light, GLenum pname, const GLint * params)
 {
-   DISPATCH(Lightiv, (light, pname, params), (F, "glLightiv(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(Lightiv, (light, pname, params), (F, "glLightiv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModelf)(GLenum pname, GLfloat param)
 {
-   DISPATCH(LightModelf, (pname, param), (F, "glLightModelf(0x%x, %f);\n", pname, param));
+   DISPATCH(LightModelf, (pname, param), (F, "glLightModelf(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModelfv)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(LightModelfv, (pname, params), (F, "glLightModelfv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(LightModelfv, (pname, params), (F, "glLightModelfv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModeli)(GLenum pname, GLint param)
 {
-   DISPATCH(LightModeli, (pname, param), (F, "glLightModeli(0x%x, %d);\n", pname, param));
+   DISPATCH(LightModeli, (pname, param), (F, "glLightModeli(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModeliv)(GLenum pname, const GLint * params)
 {
-   DISPATCH(LightModeliv, (pname, params), (F, "glLightModeliv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(LightModeliv, (pname, params), (F, "glLightModeliv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LineStipple)(GLint factor, GLushort pattern)
 {
-   DISPATCH(LineStipple, (factor, pattern), (F, "glLineStipple(%d, %d);\n", factor, pattern));
+   DISPATCH(LineStipple, (factor, pattern), (F, "glLineStipple(%d, %d);", factor, pattern));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LineWidth)(GLfloat width)
 {
-   DISPATCH(LineWidth, (width), (F, "glLineWidth(%f);\n", width));
+   DISPATCH(LineWidth, (width), (F, "glLineWidth(%f);", width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Materialf)(GLenum face, GLenum pname, GLfloat param)
 {
-   DISPATCH(Materialf, (face, pname, param), (F, "glMaterialf(0x%x, 0x%x, %f);\n", face, pname, param));
+   DISPATCH(Materialf, (face, pname, param), (F, "glMaterialf(0x%x, 0x%x, %f);", face, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Materialfv)(GLenum face, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(Materialfv, (face, pname, params), (F, "glMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(Materialfv, (face, pname, params), (F, "glMaterialfv(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Materiali)(GLenum face, GLenum pname, GLint param)
 {
-   DISPATCH(Materiali, (face, pname, param), (F, "glMateriali(0x%x, 0x%x, %d);\n", face, pname, param));
+   DISPATCH(Materiali, (face, pname, param), (F, "glMateriali(0x%x, 0x%x, %d);", face, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Materialiv)(GLenum face, GLenum pname, const GLint * params)
 {
-   DISPATCH(Materialiv, (face, pname, params), (F, "glMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(Materialiv, (face, pname, params), (F, "glMaterialiv(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointSize)(GLfloat size)
 {
-   DISPATCH(PointSize, (size), (F, "glPointSize(%f);\n", size));
+   DISPATCH(PointSize, (size), (F, "glPointSize(%f);", size));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonMode)(GLenum face, GLenum mode)
 {
-   DISPATCH(PolygonMode, (face, mode), (F, "glPolygonMode(0x%x, 0x%x);\n", face, mode));
+   DISPATCH(PolygonMode, (face, mode), (F, "glPolygonMode(0x%x, 0x%x);", face, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonStipple)(const GLubyte * mask)
 {
-   DISPATCH(PolygonStipple, (mask), (F, "glPolygonStipple(%p);\n", (void *) mask));
+   DISPATCH(PolygonStipple, (mask), (F, "glPolygonStipple(%p);", (void *) mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Scissor)(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(Scissor, (x, y, width, height), (F, "glScissor(%d, %d, %p, %p);\n", x, y, (void *) width, (void *) height));
+   DISPATCH(Scissor, (x, y, width, height), (F, "glScissor(%d, %d, %p, %p);", x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ShadeModel)(GLenum mode)
 {
-   DISPATCH(ShadeModel, (mode), (F, "glShadeModel(0x%x);\n", mode));
+   DISPATCH(ShadeModel, (mode), (F, "glShadeModel(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexParameterf)(GLenum target, GLenum pname, GLfloat param)
 {
-   DISPATCH(TexParameterf, (target, pname, param), (F, "glTexParameterf(0x%x, 0x%x, %f);\n", target, pname, param));
+   DISPATCH(TexParameterf, (target, pname, param), (F, "glTexParameterf(0x%x, 0x%x, %f);", target, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(TexParameterfv, (target, pname, params), (F, "glTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(TexParameterfv, (target, pname, params), (F, "glTexParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexParameteri)(GLenum target, GLenum pname, GLint param)
 {
-   DISPATCH(TexParameteri, (target, pname, param), (F, "glTexParameteri(0x%x, 0x%x, %d);\n", target, pname, param));
+   DISPATCH(TexParameteri, (target, pname, param), (F, "glTexParameteri(0x%x, 0x%x, %d);", target, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexParameteriv)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(TexParameteriv, (target, pname, params), (F, "glTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(TexParameteriv, (target, pname, params), (F, "glTexParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexImage1D, (target, level, internalformat, width, border, format, type, pixels), (F, "glTexImage1D(0x%x, %d, %d, %p, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, (void *) width, border, format, type, (void *) pixels));
+   DISPATCH(TexImage1D, (target, level, internalformat, width, border, format, type, pixels), (F, "glTexImage1D(0x%x, %d, %d, %p, %d, 0x%x, 0x%x, %p);", target, level, internalformat, (void *) width, border, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexImage2D, (target, level, internalformat, width, height, border, format, type, pixels), (F, "glTexImage2D(0x%x, %d, %d, %p, %p, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, (void *) width, (void *) height, border, format, type, (void *) pixels));
+   DISPATCH(TexImage2D, (target, level, internalformat, width, height, border, format, type, pixels), (F, "glTexImage2D(0x%x, %d, %d, %p, %p, %d, 0x%x, 0x%x, %p);", target, level, internalformat, (void *) width, (void *) height, border, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexEnvf)(GLenum target, GLenum pname, GLfloat param)
 {
-   DISPATCH(TexEnvf, (target, pname, param), (F, "glTexEnvf(0x%x, 0x%x, %f);\n", target, pname, param));
+   DISPATCH(TexEnvf, (target, pname, param), (F, "glTexEnvf(0x%x, 0x%x, %f);", target, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexEnvfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(TexEnvfv, (target, pname, params), (F, "glTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(TexEnvfv, (target, pname, params), (F, "glTexEnvfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexEnvi)(GLenum target, GLenum pname, GLint param)
 {
-   DISPATCH(TexEnvi, (target, pname, param), (F, "glTexEnvi(0x%x, 0x%x, %d);\n", target, pname, param));
+   DISPATCH(TexEnvi, (target, pname, param), (F, "glTexEnvi(0x%x, 0x%x, %d);", target, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexEnviv)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(TexEnviv, (target, pname, params), (F, "glTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(TexEnviv, (target, pname, params), (F, "glTexEnviv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGend)(GLenum coord, GLenum pname, GLdouble param)
 {
-   DISPATCH(TexGend, (coord, pname, param), (F, "glTexGend(0x%x, 0x%x, %f);\n", coord, pname, param));
+   DISPATCH(TexGend, (coord, pname, param), (F, "glTexGend(0x%x, 0x%x, %f);", coord, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGendv)(GLenum coord, GLenum pname, const GLdouble * params)
 {
-   DISPATCH(TexGendv, (coord, pname, params), (F, "glTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(TexGendv, (coord, pname, params), (F, "glTexGendv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGenf)(GLenum coord, GLenum pname, GLfloat param)
 {
-   DISPATCH(TexGenf, (coord, pname, param), (F, "glTexGenf(0x%x, 0x%x, %f);\n", coord, pname, param));
+   DISPATCH(TexGenf, (coord, pname, param), (F, "glTexGenf(0x%x, 0x%x, %f);", coord, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGenfv)(GLenum coord, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(TexGenfv, (coord, pname, params), (F, "glTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(TexGenfv, (coord, pname, params), (F, "glTexGenfv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGeni)(GLenum coord, GLenum pname, GLint param)
 {
-   DISPATCH(TexGeni, (coord, pname, param), (F, "glTexGeni(0x%x, 0x%x, %d);\n", coord, pname, param));
+   DISPATCH(TexGeni, (coord, pname, param), (F, "glTexGeni(0x%x, 0x%x, %d);", coord, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexGeniv)(GLenum coord, GLenum pname, const GLint * params)
 {
-   DISPATCH(TexGeniv, (coord, pname, params), (F, "glTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(TexGeniv, (coord, pname, params), (F, "glTexGeniv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer)
 {
-   DISPATCH(FeedbackBuffer, (size, type, buffer), (F, "glFeedbackBuffer(%p, 0x%x, %p);\n", (void *) size, type, (void *) buffer));
+   DISPATCH(FeedbackBuffer, (size, type, buffer), (F, "glFeedbackBuffer(%p, 0x%x, %p);", (void *) size, type, (void *) buffer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SelectBuffer)(GLsizei size, GLuint * buffer)
 {
-   DISPATCH(SelectBuffer, (size, buffer), (F, "glSelectBuffer(%p, %p);\n", (void *) size, (void *) buffer));
+   DISPATCH(SelectBuffer, (size, buffer), (F, "glSelectBuffer(%p, %p);", (void *) size, (void *) buffer));
 }
 
 KEYWORD1 GLint KEYWORD2 NAME(RenderMode)(GLenum mode)
 {
-   RETURN_DISPATCH(RenderMode, (mode), (F, "glRenderMode(0x%x);\n", mode));
+   RETURN_DISPATCH(RenderMode, (mode), (F, "glRenderMode(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(InitNames)(void)
 {
-   DISPATCH(InitNames, (), (F, "glInitNames();\n"));
+   DISPATCH(InitNames, (), (F, "glInitNames();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadName)(GLuint name)
 {
-   DISPATCH(LoadName, (name), (F, "glLoadName(%d);\n", name));
+   DISPATCH(LoadName, (name), (F, "glLoadName(%d);", name));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PassThrough)(GLfloat token)
 {
-   DISPATCH(PassThrough, (token), (F, "glPassThrough(%f);\n", token));
+   DISPATCH(PassThrough, (token), (F, "glPassThrough(%f);", token));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopName)(void)
 {
-   DISPATCH(PopName, (), (F, "glPopName();\n"));
+   DISPATCH(PopName, (), (F, "glPopName();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PushName)(GLuint name)
 {
-   DISPATCH(PushName, (name), (F, "glPushName(%d);\n", name));
+   DISPATCH(PushName, (name), (F, "glPushName(%d);", name));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawBuffer)(GLenum mode)
 {
-   DISPATCH(DrawBuffer, (mode), (F, "glDrawBuffer(0x%x);\n", mode));
+   DISPATCH(DrawBuffer, (mode), (F, "glDrawBuffer(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Clear)(GLbitfield mask)
 {
-   DISPATCH(Clear, (mask), (F, "glClear(%p);\n", (void *) mask));
+   DISPATCH(Clear, (mask), (F, "glClear(%p);", (void *) mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-   DISPATCH(ClearAccum, (red, green, blue, alpha), (F, "glClearAccum(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(ClearAccum, (red, green, blue, alpha), (F, "glClearAccum(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClearIndex)(GLfloat c)
 {
-   DISPATCH(ClearIndex, (c), (F, "glClearIndex(%f);\n", c));
+   DISPATCH(ClearIndex, (c), (F, "glClearIndex(%f);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-   DISPATCH(ClearColor, (red, green, blue, alpha), (F, "glClearColor(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(ClearColor, (red, green, blue, alpha), (F, "glClearColor(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClearStencil)(GLint s)
 {
-   DISPATCH(ClearStencil, (s), (F, "glClearStencil(%d);\n", s));
+   DISPATCH(ClearStencil, (s), (F, "glClearStencil(%d);", s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClearDepth)(GLclampd depth)
 {
-   DISPATCH(ClearDepth, (depth), (F, "glClearDepth(%f);\n", depth));
+   DISPATCH(ClearDepth, (depth), (F, "glClearDepth(%f);", depth));
 }
 
 KEYWORD1 void KEYWORD2 NAME(StencilMask)(GLuint mask)
 {
-   DISPATCH(StencilMask, (mask), (F, "glStencilMask(%d);\n", mask));
+   DISPATCH(StencilMask, (mask), (F, "glStencilMask(%d);", mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-   DISPATCH(ColorMask, (red, green, blue, alpha), (F, "glColorMask(%d, %d, %d, %d);\n", red, green, blue, alpha));
+   DISPATCH(ColorMask, (red, green, blue, alpha), (F, "glColorMask(%d, %d, %d, %d);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DepthMask)(GLboolean flag)
 {
-   DISPATCH(DepthMask, (flag), (F, "glDepthMask(%d);\n", flag));
+   DISPATCH(DepthMask, (flag), (F, "glDepthMask(%d);", flag));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexMask)(GLuint mask)
 {
-   DISPATCH(IndexMask, (mask), (F, "glIndexMask(%d);\n", mask));
+   DISPATCH(IndexMask, (mask), (F, "glIndexMask(%d);", mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Accum)(GLenum op, GLfloat value)
 {
-   DISPATCH(Accum, (op, value), (F, "glAccum(0x%x, %f);\n", op, value));
+   DISPATCH(Accum, (op, value), (F, "glAccum(0x%x, %f);", op, value));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Disable)(GLenum cap)
 {
-   DISPATCH(Disable, (cap), (F, "glDisable(0x%x);\n", cap));
+   DISPATCH(Disable, (cap), (F, "glDisable(0x%x);", cap));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Enable)(GLenum cap)
 {
-   DISPATCH(Enable, (cap), (F, "glEnable(0x%x);\n", cap));
+   DISPATCH(Enable, (cap), (F, "glEnable(0x%x);", cap));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Finish)(void)
 {
-   DISPATCH(Finish, (), (F, "glFinish();\n"));
+   DISPATCH(Finish, (), (F, "glFinish();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Flush)(void)
 {
-   DISPATCH(Flush, (), (F, "glFlush();\n"));
+   DISPATCH(Flush, (), (F, "glFlush();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopAttrib)(void)
 {
-   DISPATCH(PopAttrib, (), (F, "glPopAttrib();\n"));
+   DISPATCH(PopAttrib, (), (F, "glPopAttrib();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PushAttrib)(GLbitfield mask)
 {
-   DISPATCH(PushAttrib, (mask), (F, "glPushAttrib(%p);\n", (void *) mask));
+   DISPATCH(PushAttrib, (mask), (F, "glPushAttrib(%p);", (void *) mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points)
 {
-   DISPATCH(Map1d, (target, u1, u2, stride, order, points), (F, "glMap1d(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (void *) points));
+   DISPATCH(Map1d, (target, u1, u2, stride, order, points), (F, "glMap1d(0x%x, %f, %f, %d, %d, %p);", target, u1, u2, stride, order, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points)
 {
-   DISPATCH(Map1f, (target, u1, u2, stride, order, points), (F, "glMap1f(0x%x, %f, %f, %d, %d, %p);\n", target, u1, u2, stride, order, (void *) points));
+   DISPATCH(Map1f, (target, u1, u2, stride, order, points), (F, "glMap1f(0x%x, %f, %f, %d, %d, %p);", target, u1, u2, stride, order, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points)
 {
-   DISPATCH(Map2d, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (void *) points));
+   DISPATCH(Map2d, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points)
 {
-   DISPATCH(Map2f, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (void *) points));
+   DISPATCH(Map2f, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points), (F, "glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MapGrid1d)(GLint un, GLdouble u1, GLdouble u2)
 {
-   DISPATCH(MapGrid1d, (un, u1, u2), (F, "glMapGrid1d(%d, %f, %f);\n", un, u1, u2));
+   DISPATCH(MapGrid1d, (un, u1, u2), (F, "glMapGrid1d(%d, %f, %f);", un, u1, u2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MapGrid1f)(GLint un, GLfloat u1, GLfloat u2)
 {
-   DISPATCH(MapGrid1f, (un, u1, u2), (F, "glMapGrid1f(%d, %f, %f);\n", un, u1, u2));
+   DISPATCH(MapGrid1f, (un, u1, u2), (F, "glMapGrid1f(%d, %f, %f);", un, u1, u2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-   DISPATCH(MapGrid2d, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2d(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2));
+   DISPATCH(MapGrid2d, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2d(%d, %f, %f, %d, %f, %f);", un, u1, u2, vn, v1, v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-   DISPATCH(MapGrid2f, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2f(%d, %f, %f, %d, %f, %f);\n", un, u1, u2, vn, v1, v2));
+   DISPATCH(MapGrid2f, (un, u1, u2, vn, v1, v2), (F, "glMapGrid2f(%d, %f, %f, %d, %f, %f);", un, u1, u2, vn, v1, v2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord1d)(GLdouble u)
 {
-   DISPATCH(EvalCoord1d, (u), (F, "glEvalCoord1d(%f);\n", u));
+   DISPATCH(EvalCoord1d, (u), (F, "glEvalCoord1d(%f);", u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord1dv)(const GLdouble * u)
 {
-   DISPATCH(EvalCoord1dv, (u), (F, "glEvalCoord1dv(%p);\n", (void *) u));
+   DISPATCH(EvalCoord1dv, (u), (F, "glEvalCoord1dv(%p);", (void *) u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord1f)(GLfloat u)
 {
-   DISPATCH(EvalCoord1f, (u), (F, "glEvalCoord1f(%f);\n", u));
+   DISPATCH(EvalCoord1f, (u), (F, "glEvalCoord1f(%f);", u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord1fv)(const GLfloat * u)
 {
-   DISPATCH(EvalCoord1fv, (u), (F, "glEvalCoord1fv(%p);\n", (void *) u));
+   DISPATCH(EvalCoord1fv, (u), (F, "glEvalCoord1fv(%p);", (void *) u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord2d)(GLdouble u, GLdouble v)
 {
-   DISPATCH(EvalCoord2d, (u, v), (F, "glEvalCoord2d(%f, %f);\n", u, v));
+   DISPATCH(EvalCoord2d, (u, v), (F, "glEvalCoord2d(%f, %f);", u, v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord2dv)(const GLdouble * u)
 {
-   DISPATCH(EvalCoord2dv, (u), (F, "glEvalCoord2dv(%p);\n", (void *) u));
+   DISPATCH(EvalCoord2dv, (u), (F, "glEvalCoord2dv(%p);", (void *) u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord2f)(GLfloat u, GLfloat v)
 {
-   DISPATCH(EvalCoord2f, (u, v), (F, "glEvalCoord2f(%f, %f);\n", u, v));
+   DISPATCH(EvalCoord2f, (u, v), (F, "glEvalCoord2f(%f, %f);", u, v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalCoord2fv)(const GLfloat * u)
 {
-   DISPATCH(EvalCoord2fv, (u), (F, "glEvalCoord2fv(%p);\n", (void *) u));
+   DISPATCH(EvalCoord2fv, (u), (F, "glEvalCoord2fv(%p);", (void *) u));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalMesh1)(GLenum mode, GLint i1, GLint i2)
 {
-   DISPATCH(EvalMesh1, (mode, i1, i2), (F, "glEvalMesh1(0x%x, %d, %d);\n", mode, i1, i2));
+   DISPATCH(EvalMesh1, (mode, i1, i2), (F, "glEvalMesh1(0x%x, %d, %d);", mode, i1, i2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalPoint1)(GLint i)
 {
-   DISPATCH(EvalPoint1, (i), (F, "glEvalPoint1(%d);\n", i));
+   DISPATCH(EvalPoint1, (i), (F, "glEvalPoint1(%d);", i));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-   DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, "glEvalMesh2(0x%x, %d, %d, %d, %d);\n", mode, i1, i2, j1, j2));
+   DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, "glEvalMesh2(0x%x, %d, %d, %d, %d);", mode, i1, i2, j1, j2));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EvalPoint2)(GLint i, GLint j)
 {
-   DISPATCH(EvalPoint2, (i, j), (F, "glEvalPoint2(%d, %d);\n", i, j));
+   DISPATCH(EvalPoint2, (i, j), (F, "glEvalPoint2(%d, %d);", i, j));
 }
 
 KEYWORD1 void KEYWORD2 NAME(AlphaFunc)(GLenum func, GLclampf ref)
 {
-   DISPATCH(AlphaFunc, (func, ref), (F, "glAlphaFunc(0x%x, %f);\n", func, ref));
+   DISPATCH(AlphaFunc, (func, ref), (F, "glAlphaFunc(0x%x, %f);", func, ref));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BlendFunc)(GLenum sfactor, GLenum dfactor)
 {
-   DISPATCH(BlendFunc, (sfactor, dfactor), (F, "glBlendFunc(0x%x, 0x%x);\n", sfactor, dfactor));
+   DISPATCH(BlendFunc, (sfactor, dfactor), (F, "glBlendFunc(0x%x, 0x%x);", sfactor, dfactor));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LogicOp)(GLenum opcode)
 {
-   DISPATCH(LogicOp, (opcode), (F, "glLogicOp(0x%x);\n", opcode));
+   DISPATCH(LogicOp, (opcode), (F, "glLogicOp(0x%x);", opcode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(StencilFunc)(GLenum func, GLint ref, GLuint mask)
 {
-   DISPATCH(StencilFunc, (func, ref, mask), (F, "glStencilFunc(0x%x, %d, %d);\n", func, ref, mask));
+   DISPATCH(StencilFunc, (func, ref, mask), (F, "glStencilFunc(0x%x, %d, %d);", func, ref, mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(StencilOp)(GLenum fail, GLenum zfail, GLenum zpass)
 {
-   DISPATCH(StencilOp, (fail, zfail, zpass), (F, "glStencilOp(0x%x, 0x%x, 0x%x);\n", fail, zfail, zpass));
+   DISPATCH(StencilOp, (fail, zfail, zpass), (F, "glStencilOp(0x%x, 0x%x, 0x%x);", fail, zfail, zpass));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DepthFunc)(GLenum func)
 {
-   DISPATCH(DepthFunc, (func), (F, "glDepthFunc(0x%x);\n", func));
+   DISPATCH(DepthFunc, (func), (F, "glDepthFunc(0x%x);", func));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelZoom)(GLfloat xfactor, GLfloat yfactor)
 {
-   DISPATCH(PixelZoom, (xfactor, yfactor), (F, "glPixelZoom(%f, %f);\n", xfactor, yfactor));
+   DISPATCH(PixelZoom, (xfactor, yfactor), (F, "glPixelZoom(%f, %f);", xfactor, yfactor));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTransferf)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PixelTransferf, (pname, param), (F, "glPixelTransferf(0x%x, %f);\n", pname, param));
+   DISPATCH(PixelTransferf, (pname, param), (F, "glPixelTransferf(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTransferi)(GLenum pname, GLint param)
 {
-   DISPATCH(PixelTransferi, (pname, param), (F, "glPixelTransferi(0x%x, %d);\n", pname, param));
+   DISPATCH(PixelTransferi, (pname, param), (F, "glPixelTransferi(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelStoref)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PixelStoref, (pname, param), (F, "glPixelStoref(0x%x, %f);\n", pname, param));
+   DISPATCH(PixelStoref, (pname, param), (F, "glPixelStoref(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelStorei)(GLenum pname, GLint param)
 {
-   DISPATCH(PixelStorei, (pname, param), (F, "glPixelStorei(0x%x, %d);\n", pname, param));
+   DISPATCH(PixelStorei, (pname, param), (F, "glPixelStorei(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelMapfv)(GLenum map, GLint mapsize, const GLfloat * values)
 {
-   DISPATCH(PixelMapfv, (map, mapsize, values), (F, "glPixelMapfv(0x%x, %d, %p);\n", map, mapsize, (void *) values));
+   DISPATCH(PixelMapfv, (map, mapsize, values), (F, "glPixelMapfv(0x%x, %d, %p);", map, mapsize, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelMapuiv)(GLenum map, GLint mapsize, const GLuint * values)
 {
-   DISPATCH(PixelMapuiv, (map, mapsize, values), (F, "glPixelMapuiv(0x%x, %d, %p);\n", map, mapsize, (void *) values));
+   DISPATCH(PixelMapuiv, (map, mapsize, values), (F, "glPixelMapuiv(0x%x, %d, %p);", map, mapsize, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelMapusv)(GLenum map, GLint mapsize, const GLushort * values)
 {
-   DISPATCH(PixelMapusv, (map, mapsize, values), (F, "glPixelMapusv(0x%x, %d, %p);\n", map, mapsize, (void *) values));
+   DISPATCH(PixelMapusv, (map, mapsize, values), (F, "glPixelMapusv(0x%x, %d, %p);", map, mapsize, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ReadBuffer)(GLenum mode)
 {
-   DISPATCH(ReadBuffer, (mode), (F, "glReadBuffer(0x%x);\n", mode));
+   DISPATCH(ReadBuffer, (mode), (F, "glReadBuffer(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-   DISPATCH(CopyPixels, (x, y, width, height, type), (F, "glCopyPixels(%d, %d, %p, %p, 0x%x);\n", x, y, (void *) width, (void *) height, type));
+   DISPATCH(CopyPixels, (x, y, width, height, type), (F, "glCopyPixels(%d, %d, %p, %p, 0x%x);", x, y, (void *) width, (void *) height, type));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
 {
-   DISPATCH(ReadPixels, (x, y, width, height, format, type, pixels), (F, "glReadPixels(%d, %d, %p, %p, 0x%x, 0x%x, %p);\n", x, y, (void *) width, (void *) height, format, type, (void *) pixels));
+   DISPATCH(ReadPixels, (x, y, width, height, format, type, pixels), (F, "glReadPixels(%d, %d, %p, %p, 0x%x, 0x%x, %p);", x, y, (void *) width, (void *) height, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(DrawPixels, (width, height, format, type, pixels), (F, "glDrawPixels(%p, %p, 0x%x, 0x%x, %p);\n", (void *) width, (void *) height, format, type, (void *) pixels));
+   DISPATCH(DrawPixels, (width, height, format, type, pixels), (F, "glDrawPixels(%p, %p, 0x%x, 0x%x, %p);", (void *) width, (void *) height, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetBooleanv)(GLenum pname, GLboolean * params)
 {
-   DISPATCH(GetBooleanv, (pname, params), (F, "glGetBooleanv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetBooleanv, (pname, params), (F, "glGetBooleanv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetClipPlane)(GLenum plane, GLdouble * equation)
 {
-   DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(0x%x, %p);\n", plane, (void *) equation));
+   DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(0x%x, %p);", plane, (void *) equation));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetDoublev)(GLenum pname, GLdouble * params)
 {
-   DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 GLenum KEYWORD2 NAME(GetError)(void)
 {
-   RETURN_DISPATCH(GetError, (), (F, "glGetError();\n"));
+   RETURN_DISPATCH(GetError, (), (F, "glGetError();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFloatv)(GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetIntegerv)(GLenum pname, GLint * params)
 {
-   DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetLightfv)(GLenum light, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetLightfv, (light, pname, params), (F, "glGetLightfv(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(GetLightfv, (light, pname, params), (F, "glGetLightfv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetLightiv)(GLenum light, GLenum pname, GLint * params)
 {
-   DISPATCH(GetLightiv, (light, pname, params), (F, "glGetLightiv(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(GetLightiv, (light, pname, params), (F, "glGetLightiv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapdv)(GLenum target, GLenum query, GLdouble * v)
 {
-   DISPATCH(GetMapdv, (target, query, v), (F, "glGetMapdv(0x%x, 0x%x, %p);\n", target, query, (void *) v));
+   DISPATCH(GetMapdv, (target, query, v), (F, "glGetMapdv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapfv)(GLenum target, GLenum query, GLfloat * v)
 {
-   DISPATCH(GetMapfv, (target, query, v), (F, "glGetMapfv(0x%x, 0x%x, %p);\n", target, query, (void *) v));
+   DISPATCH(GetMapfv, (target, query, v), (F, "glGetMapfv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapiv)(GLenum target, GLenum query, GLint * v)
 {
-   DISPATCH(GetMapiv, (target, query, v), (F, "glGetMapiv(0x%x, 0x%x, %p);\n", target, query, (void *) v));
+   DISPATCH(GetMapiv, (target, query, v), (F, "glGetMapiv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMaterialfv)(GLenum face, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetMaterialfv, (face, pname, params), (F, "glGetMaterialfv(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(GetMaterialfv, (face, pname, params), (F, "glGetMaterialfv(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMaterialiv)(GLenum face, GLenum pname, GLint * params)
 {
-   DISPATCH(GetMaterialiv, (face, pname, params), (F, "glGetMaterialiv(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(GetMaterialiv, (face, pname, params), (F, "glGetMaterialiv(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapfv)(GLenum map, GLfloat * values)
 {
-   DISPATCH(GetPixelMapfv, (map, values), (F, "glGetPixelMapfv(0x%x, %p);\n", map, (void *) values));
+   DISPATCH(GetPixelMapfv, (map, values), (F, "glGetPixelMapfv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapuiv)(GLenum map, GLuint * values)
 {
-   DISPATCH(GetPixelMapuiv, (map, values), (F, "glGetPixelMapuiv(0x%x, %p);\n", map, (void *) values));
+   DISPATCH(GetPixelMapuiv, (map, values), (F, "glGetPixelMapuiv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapusv)(GLenum map, GLushort * values)
 {
-   DISPATCH(GetPixelMapusv, (map, values), (F, "glGetPixelMapusv(0x%x, %p);\n", map, (void *) values));
+   DISPATCH(GetPixelMapusv, (map, values), (F, "glGetPixelMapusv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPolygonStipple)(GLubyte * mask)
 {
-   DISPATCH(GetPolygonStipple, (mask), (F, "glGetPolygonStipple(%p);\n", (void *) mask));
+   DISPATCH(GetPolygonStipple, (mask), (F, "glGetPolygonStipple(%p);", (void *) mask));
 }
 
 KEYWORD1 const GLubyte * KEYWORD2 NAME(GetString)(GLenum name)
 {
-   RETURN_DISPATCH(GetString, (name), (F, "glGetString(0x%x);\n", name));
+   RETURN_DISPATCH(GetString, (name), (F, "glGetString(0x%x);", name));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetTexEnvfv, (target, pname, params), (F, "glGetTexEnvfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetTexEnvfv, (target, pname, params), (F, "glGetTexEnvfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexEnviv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetTexEnviv, (target, pname, params), (F, "glGetTexEnviv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetTexEnviv, (target, pname, params), (F, "glGetTexEnviv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGendv)(GLenum coord, GLenum pname, GLdouble * params)
 {
-   DISPATCH(GetTexGendv, (coord, pname, params), (F, "glGetTexGendv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(GetTexGendv, (coord, pname, params), (F, "glGetTexGendv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGenfv)(GLenum coord, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetTexGenfv, (coord, pname, params), (F, "glGetTexGenfv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(GetTexGenfv, (coord, pname, params), (F, "glGetTexGenfv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGeniv)(GLenum coord, GLenum pname, GLint * params)
 {
-   DISPATCH(GetTexGeniv, (coord, pname, params), (F, "glGetTexGeniv(0x%x, 0x%x, %p);\n", coord, pname, (void *) params));
+   DISPATCH(GetTexGeniv, (coord, pname, params), (F, "glGetTexGeniv(0x%x, 0x%x, %p);", coord, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
 {
-   DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, "glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);\n", target, level, format, type, (void *) pixels));
+   DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, "glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);", target, level, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetTexParameterfv, (target, pname, params), (F, "glGetTexParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetTexParameterfv, (target, pname, params), (F, "glGetTexParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexParameteriv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetTexParameteriv, (target, pname, params), (F, "glGetTexParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetTexParameteriv, (target, pname, params), (F, "glGetTexParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, "glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (void *) params));
+   DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, "glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);", target, level, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params)
 {
-   DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, "glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);\n", target, level, pname, (void *) params));
+   DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, "glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);", target, level, pname, (void *) params));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsEnabled)(GLenum cap)
 {
-   RETURN_DISPATCH(IsEnabled, (cap), (F, "glIsEnabled(0x%x);\n", cap));
+   RETURN_DISPATCH(IsEnabled, (cap), (F, "glIsEnabled(0x%x);", cap));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsList)(GLuint list)
 {
-   RETURN_DISPATCH(IsList, (list), (F, "glIsList(%d);\n", list));
+   RETURN_DISPATCH(IsList, (list), (F, "glIsList(%d);", list));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DepthRange)(GLclampd zNear, GLclampd zFar)
 {
-   DISPATCH(DepthRange, (zNear, zFar), (F, "glDepthRange(%f, %f);\n", zNear, zFar));
+   DISPATCH(DepthRange, (zNear, zFar), (F, "glDepthRange(%f, %f);", zNear, zFar));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-   DISPATCH(Frustum, (left, right, bottom, top, zNear, zFar), (F, "glFrustum(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar));
+   DISPATCH(Frustum, (left, right, bottom, top, zNear, zFar), (F, "glFrustum(%f, %f, %f, %f, %f, %f);", left, right, bottom, top, zNear, zFar));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadIdentity)(void)
 {
-   DISPATCH(LoadIdentity, (), (F, "glLoadIdentity();\n"));
+   DISPATCH(LoadIdentity, (), (F, "glLoadIdentity();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadMatrixf)(const GLfloat * m)
 {
-   DISPATCH(LoadMatrixf, (m), (F, "glLoadMatrixf(%p);\n", (void *) m));
+   DISPATCH(LoadMatrixf, (m), (F, "glLoadMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadMatrixd)(const GLdouble * m)
 {
-   DISPATCH(LoadMatrixd, (m), (F, "glLoadMatrixd(%p);\n", (void *) m));
+   DISPATCH(LoadMatrixd, (m), (F, "glLoadMatrixd(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MatrixMode)(GLenum mode)
 {
-   DISPATCH(MatrixMode, (mode), (F, "glMatrixMode(0x%x);\n", mode));
+   DISPATCH(MatrixMode, (mode), (F, "glMatrixMode(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultMatrixf)(const GLfloat * m)
 {
-   DISPATCH(MultMatrixf, (m), (F, "glMultMatrixf(%p);\n", (void *) m));
+   DISPATCH(MultMatrixf, (m), (F, "glMultMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultMatrixd)(const GLdouble * m)
 {
-   DISPATCH(MultMatrixd, (m), (F, "glMultMatrixd(%p);\n", (void *) m));
+   DISPATCH(MultMatrixd, (m), (F, "glMultMatrixd(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-   DISPATCH(Ortho, (left, right, bottom, top, zNear, zFar), (F, "glOrtho(%f, %f, %f, %f, %f, %f);\n", left, right, bottom, top, zNear, zFar));
+   DISPATCH(Ortho, (left, right, bottom, top, zNear, zFar), (F, "glOrtho(%f, %f, %f, %f, %f, %f);", left, right, bottom, top, zNear, zFar));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopMatrix)(void)
 {
-   DISPATCH(PopMatrix, (), (F, "glPopMatrix();\n"));
+   DISPATCH(PopMatrix, (), (F, "glPopMatrix();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PushMatrix)(void)
 {
-   DISPATCH(PushMatrix, (), (F, "glPushMatrix();\n"));
+   DISPATCH(PushMatrix, (), (F, "glPushMatrix();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(Rotated, (angle, x, y, z), (F, "glRotated(%f, %f, %f, %f);\n", angle, x, y, z));
+   DISPATCH(Rotated, (angle, x, y, z), (F, "glRotated(%f, %f, %f, %f);", angle, x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(Rotatef, (angle, x, y, z), (F, "glRotatef(%f, %f, %f, %f);\n", angle, x, y, z));
+   DISPATCH(Rotatef, (angle, x, y, z), (F, "glRotatef(%f, %f, %f, %f);", angle, x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Scaled)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(Scaled, (x, y, z), (F, "glScaled(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Scaled, (x, y, z), (F, "glScaled(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Scalef)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(Scalef, (x, y, z), (F, "glScalef(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Scalef, (x, y, z), (F, "glScalef(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Translated)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(Translated, (x, y, z), (F, "glTranslated(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Translated, (x, y, z), (F, "glTranslated(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Translatef)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(Translatef, (x, y, z), (F, "glTranslatef(%f, %f, %f);\n", x, y, z));
+   DISPATCH(Translatef, (x, y, z), (F, "glTranslatef(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Viewport)(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(Viewport, (x, y, width, height), (F, "glViewport(%d, %d, %p, %p);\n", x, y, (void *) width, (void *) height));
+   DISPATCH(Viewport, (x, y, width, height), (F, "glViewport(%d, %d, %p, %p);", x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ArrayElement)(GLint i)
 {
-   DISPATCH(ArrayElement, (i), (F, "glArrayElement(%d);\n", i));
+   DISPATCH(ArrayElement, (i), (F, "glArrayElement(%d);", i));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(ColorPointer, (size, type, stride, pointer), (F, "glColorPointer(%d, 0x%x, %p, %p);\n", size, type, (void *) stride, (void *) pointer));
+   DISPATCH(ColorPointer, (size, type, stride, pointer), (F, "glColorPointer(%d, 0x%x, %p, %p);", size, type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DisableClientState)(GLenum array)
 {
-   DISPATCH(DisableClientState, (array), (F, "glDisableClientState(0x%x);\n", array));
+   DISPATCH(DisableClientState, (array), (F, "glDisableClientState(0x%x);", array));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawArrays)(GLenum mode, GLint first, GLsizei count)
 {
-   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %p);\n", mode, first, (void *) count));
+   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %p);", mode, first, (void *) count));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
 {
-   DISPATCH(DrawElements, (mode, count, type, indices), (F, "glDrawElements(0x%x, %p, 0x%x, %p);\n", mode, (void *) count, type, (void *) indices));
+   DISPATCH(DrawElements, (mode, count, type, indices), (F, "glDrawElements(0x%x, %p, 0x%x, %p);", mode, (void *) count, type, (void *) indices));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EdgeFlagPointer)(GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(EdgeFlagPointer, (stride, pointer), (F, "glEdgeFlagPointer(%p, %p);\n", (void *) stride, (void *) pointer));
+   DISPATCH(EdgeFlagPointer, (stride, pointer), (F, "glEdgeFlagPointer(%p, %p);", (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EnableClientState)(GLenum array)
 {
-   DISPATCH(EnableClientState, (array), (F, "glEnableClientState(0x%x);\n", array));
+   DISPATCH(EnableClientState, (array), (F, "glEnableClientState(0x%x);", array));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPointerv)(GLenum pname, GLvoid ** params)
 {
-   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexPointer)(GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(IndexPointer, (type, stride, pointer), (F, "glIndexPointer(0x%x, %p, %p);\n", type, (void *) stride, (void *) pointer));
+   DISPATCH(IndexPointer, (type, stride, pointer), (F, "glIndexPointer(0x%x, %p, %p);", type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(InterleavedArrays, (format, stride, pointer), (F, "glInterleavedArrays(0x%x, %p, %p);\n", format, (void *) stride, (void *) pointer));
+   DISPATCH(InterleavedArrays, (format, stride, pointer), (F, "glInterleavedArrays(0x%x, %p, %p);", format, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(NormalPointer)(GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(NormalPointer, (type, stride, pointer), (F, "glNormalPointer(0x%x, %p, %p);\n", type, (void *) stride, (void *) pointer));
+   DISPATCH(NormalPointer, (type, stride, pointer), (F, "glNormalPointer(0x%x, %p, %p);", type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(TexCoordPointer, (size, type, stride, pointer), (F, "glTexCoordPointer(%d, 0x%x, %p, %p);\n", size, type, (void *) stride, (void *) pointer));
+   DISPATCH(TexCoordPointer, (size, type, stride, pointer), (F, "glTexCoordPointer(%d, 0x%x, %p, %p);", size, type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(VertexPointer, (size, type, stride, pointer), (F, "glVertexPointer(%d, 0x%x, %p, %p);\n", size, type, (void *) stride, (void *) pointer));
+   DISPATCH(VertexPointer, (size, type, stride, pointer), (F, "glVertexPointer(%d, 0x%x, %p, %p);", size, type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonOffset)(GLfloat factor, GLfloat units)
 {
-   DISPATCH(PolygonOffset, (factor, units), (F, "glPolygonOffset(%f, %f);\n", factor, units));
+   DISPATCH(PolygonOffset, (factor, units), (F, "glPolygonOffset(%f, %f);", factor, units));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %p, %d);\n", target, level, internalformat, x, y, (void *) width, border));
+   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %p, %d);", target, level, internalformat, x, y, (void *) width, border));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %p, %p, %d);\n", target, level, internalformat, x, y, (void *) width, (void *) height, border));
+   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %p, %p, %d);", target, level, internalformat, x, y, (void *) width, (void *) height, border));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %p);\n", target, level, xoffset, x, y, (void *) width));
+   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %p);", target, level, xoffset, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %p, %p);\n", target, level, xoffset, yoffset, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %p, %p);", target, level, xoffset, yoffset, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1D(0x%x, %d, %d, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, (void *) width, format, type, (void *) pixels));
+   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1D(0x%x, %d, %d, %p, 0x%x, 0x%x, %p);", target, level, xoffset, (void *) width, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2D(0x%x, %d, %d, %d, %p, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, (void *) width, (void *) height, format, type, (void *) pixels));
+   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2D(0x%x, %d, %d, %d, %p, %p, 0x%x, 0x%x, %p);", target, level, xoffset, yoffset, (void *) width, (void *) height, format, type, (void *) pixels));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(AreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences)
 {
-   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%p, %p, %p);\n", (void *) n, (void *) textures, (void *) residences));
+   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%p, %p, %p);", (void *) n, (void *) textures, (void *) residences));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BindTexture)(GLenum target, GLuint texture)
 {
-   DISPATCH(BindTexture, (target, texture), (F, "glBindTexture(0x%x, %d);\n", target, texture));
+   DISPATCH(BindTexture, (target, texture), (F, "glBindTexture(0x%x, %d);", target, texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DeleteTextures)(GLsizei n, const GLuint * textures)
 {
-   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%p, %p);\n", (void *) n, (void *) textures));
+   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%p, %p);", (void *) n, (void *) textures));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GenTextures)(GLsizei n, GLuint * textures)
 {
-   DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%p, %p);\n", (void *) n, (void *) textures));
+   DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%p, %p);", (void *) n, (void *) textures));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsTexture)(GLuint texture)
 {
-   RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTexture(%d);\n", texture));
+   RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTexture(%d);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PrioritizeTextures)(GLsizei n, const GLuint * textures, const GLclampf * priorities)
 {
-   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%p, %p, %p);\n", (void *) n, (void *) textures, (void *) priorities));
+   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%p, %p, %p);", (void *) n, (void *) textures, (void *) priorities));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexub)(GLubyte c)
 {
-   DISPATCH(Indexub, (c), (F, "glIndexub(%d);\n", c));
+   DISPATCH(Indexub, (c), (F, "glIndexub(%d);", c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexubv)(const GLubyte * c)
 {
-   DISPATCH(Indexubv, (c), (F, "glIndexubv(%p);\n", (void *) c));
+   DISPATCH(Indexubv, (c), (F, "glIndexubv(%p);", (void *) c));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopClientAttrib)(void)
 {
-   DISPATCH(PopClientAttrib, (), (F, "glPopClientAttrib();\n"));
+   DISPATCH(PopClientAttrib, (), (F, "glPopClientAttrib();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PushClientAttrib)(GLbitfield mask)
 {
-   DISPATCH(PushClientAttrib, (mask), (F, "glPushClientAttrib(%p);\n", (void *) mask));
+   DISPATCH(PushClientAttrib, (mask), (F, "glPushClientAttrib(%p);", (void *) mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColor(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColor(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BlendEquation)(GLenum mode)
 {
-   DISPATCH(BlendEquation, (mode), (F, "glBlendEquation(0x%x);\n", mode));
+   DISPATCH(BlendEquation, (mode), (F, "glBlendEquation(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
 {
-   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElements(0x%x, %d, %d, %p, 0x%x, %p);\n", mode, start, end, (void *) count, type, (void *) indices));
+   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElements(0x%x, %d, %d, %p, 0x%x, %p);", mode, start, end, (void *) count, type, (void *) indices));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
 {
-   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTable(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, format, type, (void *) table));
+   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTable(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, format, type, (void *) table));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameteriv)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTable(0x%x, 0x%x, %d, %d, %p);\n", target, internalformat, x, y, (void *) width));
+   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTable(0x%x, 0x%x, %d, %d, %p);", target, internalformat, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid * table)
 {
-   DISPATCH(GetColorTable, (target, format, type, table), (F, "glGetColorTable(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (void *) table));
+   DISPATCH(GetColorTable, (target, format, type, table), (F, "glGetColorTable(0x%x, 0x%x, 0x%x, %p);", target, format, type, (void *) table));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetColorTableParameterfv, (target, pname, params), (F, "glGetColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameterfv, (target, pname, params), (F, "glGetColorTableParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameteriv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetColorTableParameteriv, (target, pname, params), (F, "glGetColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameteriv, (target, pname, params), (F, "glGetColorTableParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
 {
-   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTable(0x%x, %p, %p, 0x%x, 0x%x, %p);\n", target, (void *) start, (void *) count, format, type, (void *) data));
+   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTable(0x%x, %p, %p, 0x%x, 0x%x, %p);", target, (void *) start, (void *) count, format, type, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTable(0x%x, %p, %d, %d, %p);\n", target, (void *) start, x, y, (void *) width));
+   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTable(0x%x, %p, %d, %d, %p);", target, (void *) start, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
 {
-   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1D(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, format, type, (void *) image));
+   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1D(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
 {
-   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2D(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, (void *) height, format, type, (void *) image));
+   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2D(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, (void *) height, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params)
 {
-   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterf(0x%x, 0x%x, %f);\n", target, pname, params));
+   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterf(0x%x, 0x%x, %f);", target, pname, params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteri)(GLenum target, GLenum pname, GLint params)
 {
-   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteri(0x%x, 0x%x, %d);\n", target, pname, params));
+   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteri(0x%x, 0x%x, %d);", target, pname, params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %p);\n", target, internalformat, x, y, (void *) width));
+   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %p);", target, internalformat, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %p, %p);\n", target, internalformat, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %p, %p);", target, internalformat, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid * image)
 {
-   DISPATCH(GetConvolutionFilter, (target, format, type, image), (F, "glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (void *) image));
+   DISPATCH(GetConvolutionFilter, (target, format, type, image), (F, "glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);", target, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetConvolutionParameterfv, (target, pname, params), (F, "glGetConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetConvolutionParameterfv, (target, pname, params), (F, "glGetConvolutionParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetConvolutionParameteriv, (target, pname, params), (F, "glGetConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetConvolutionParameteriv, (target, pname, params), (F, "glGetConvolutionParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)
 {
-   DISPATCH(GetSeparableFilter, (target, format, type, row, column, span), (F, "glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p);\n", target, format, type, (void *) row, (void *) column, (void *) span));
+   DISPATCH(GetSeparableFilter, (target, format, type, row, column, span), (F, "glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p);", target, format, type, (void *) row, (void *) column, (void *) span));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)
 {
-   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2D(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p, %p);\n", target, internalformat, (void *) width, (void *) height, format, type, (void *) row, (void *) column));
+   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2D(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p, %p);", target, internalformat, (void *) width, (void *) height, format, type, (void *) row, (void *) column));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
 {
-   DISPATCH(GetHistogram, (target, reset, format, type, values), (F, "glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (void *) values));
+   DISPATCH(GetHistogram, (target, reset, format, type, values), (F, "glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);", target, reset, format, type, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetHistogramParameterfv, (target, pname, params), (F, "glGetHistogramParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetHistogramParameterfv, (target, pname, params), (F, "glGetHistogramParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogramParameteriv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetHistogramParameteriv, (target, pname, params), (F, "glGetHistogramParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetHistogramParameteriv, (target, pname, params), (F, "glGetHistogramParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
 {
-   DISPATCH(GetMinmax, (target, reset, format, type, values), (F, "glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (void *) values));
+   DISPATCH(GetMinmax, (target, reset, format, type, values), (F, "glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p);", target, reset, format, type, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetMinmaxParameterfv, (target, pname, params), (F, "glGetMinmaxParameterfv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetMinmaxParameterfv, (target, pname, params), (F, "glGetMinmaxParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetMinmaxParameteriv, (target, pname, params), (F, "glGetMinmaxParameteriv(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetMinmaxParameteriv, (target, pname, params), (F, "glGetMinmaxParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogram(0x%x, %p, 0x%x, %d);\n", target, (void *) width, internalformat, sink));
+   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogram(0x%x, %p, 0x%x, %d);", target, (void *) width, internalformat, sink));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Minmax)(GLenum target, GLenum internalformat, GLboolean sink)
 {
-   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmax(0x%x, 0x%x, %d);\n", target, internalformat, sink));
+   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmax(0x%x, 0x%x, %d);", target, internalformat, sink));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ResetHistogram)(GLenum target)
 {
-   DISPATCH(ResetHistogram, (target), (F, "glResetHistogram(0x%x);\n", target));
+   DISPATCH(ResetHistogram, (target), (F, "glResetHistogram(0x%x);", target));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ResetMinmax)(GLenum target)
 {
-   DISPATCH(ResetMinmax, (target), (F, "glResetMinmax(0x%x);\n", target));
+   DISPATCH(ResetMinmax, (target), (F, "glResetMinmax(0x%x);", target));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3D(0x%x, %d, %d, %p, %p, %p, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, format, type, (void *) pixels));
+   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3D(0x%x, %d, %d, %p, %p, %p, %d, 0x%x, 0x%x, %p);", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3D(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, type, (void *) pixels));
+   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3D(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, 0x%x, %p);", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %p, %p);\n", target, level, xoffset, yoffset, zoffset, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %p, %p);", target, level, xoffset, yoffset, zoffset, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ActiveTextureARB)(GLenum texture)
 {
-   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTextureARB(0x%x);\n", texture));
+   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTextureARB(0x%x);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClientActiveTextureARB)(GLenum texture)
 {
-   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTextureARB(0x%x);\n", texture));
+   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTextureARB(0x%x);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dARB)(GLenum target, GLdouble s)
 {
-   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1dARB(0x%x, %f);\n", target, s));
+   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1dARB(0x%x, %f);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dvARB)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fARB)(GLenum target, GLfloat s)
 {
-   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1fARB(0x%x, %f);\n", target, s));
+   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1fARB(0x%x, %f);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fvARB)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iARB)(GLenum target, GLint s)
 {
-   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1iARB(0x%x, %d);\n", target, s));
+   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1iARB(0x%x, %d);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1ivARB)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1ivARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1ivARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sARB)(GLenum target, GLshort s)
 {
-   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1sARB(0x%x, %d);\n", target, s));
+   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1sARB(0x%x, %d);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1svARB)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1svARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1svARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t)
 {
-   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2dARB(0x%x, %f, %f);\n", target, s, t));
+   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2dARB(0x%x, %f, %f);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dvARB)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t)
 {
-   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2fARB(0x%x, %f, %f);\n", target, s, t));
+   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2fARB(0x%x, %f, %f);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fvARB)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iARB)(GLenum target, GLint s, GLint t)
 {
-   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2iARB(0x%x, %d, %d);\n", target, s, t));
+   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2iARB(0x%x, %d, %d);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2ivARB)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2ivARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2ivARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t)
 {
-   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2sARB(0x%x, %d, %d);\n", target, s, t));
+   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2sARB(0x%x, %d, %d);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2svARB)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2svARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2svARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3dARB(0x%x, %f, %f, %f);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3dARB(0x%x, %f, %f, %f);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dvARB)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3fARB(0x%x, %f, %f, %f);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3fARB(0x%x, %f, %f, %f);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fvARB)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r)
 {
-   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3iARB(0x%x, %d, %d, %d);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3iARB(0x%x, %d, %d, %d);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3ivARB)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3ivARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3ivARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3sARB(0x%x, %d, %d, %d);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3sARB(0x%x, %d, %d, %d);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3svARB)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3svARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3svARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dvARB)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fvARB)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fvARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fvARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4ivARB)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4ivARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4ivARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4svARB)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4svARB(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4svARB(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixfARB)(const GLfloat * m)
 {
-   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p);\n", (void *) m));
+   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixdARB)(const GLdouble * m)
 {
-   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixdARB(%p);\n", (void *) m));
+   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixdARB(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixfARB)(const GLfloat * m)
 {
-   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixfARB(%p);\n", (void *) m));
+   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixfARB(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixdARB)(const GLdouble * m)
 {
-   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixdARB(%p);\n", (void *) m));
+   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixdARB(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SampleCoverageARB)(GLclampf value, GLboolean invert)
 {
-   DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);\n", value, invert));
+   DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);", value, invert));
 }
 
 KEYWORD1 void KEYWORD2 NAME(__unused413)(void)
 {
-   DISPATCH(__unused413, (), (F, "gl__unused413();\n"));
+   DISPATCH(__unused413, (), (F, "gl__unused413();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DARB(0x%x, %d, 0x%x, %p, %p, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DARB(0x%x, %d, 0x%x, %p, %p, %p, %d, %p, %p);", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB(0x%x, %d, 0x%x, %p, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, (void *) height, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB(0x%x, %d, 0x%x, %p, %p, %d, %p, %p);", target, level, internalformat, (void *) width, (void *) height, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB(0x%x, %d, 0x%x, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB(0x%x, %d, 0x%x, %p, %d, %p, %p);", target, level, internalformat, (void *) width, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DARB(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, %p, %p);\n", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DARB(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, %p, %p);", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB(0x%x, %d, %d, %d, %p, %p, 0x%x, %p, %p);\n", target, level, xoffset, yoffset, (void *) width, (void *) height, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB(0x%x, %d, %d, %d, %p, %p, 0x%x, %p, %p);", target, level, xoffset, yoffset, (void *) width, (void *) height, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1DARB(0x%x, %d, %d, %p, 0x%x, %p, %p);\n", target, level, xoffset, (void *) width, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1DARB(0x%x, %d, %d, %p, 0x%x, %p, %p);", target, level, xoffset, (void *) width, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImageARB)(GLenum target, GLint level, GLvoid * img)
 {
-   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImageARB(0x%x, %d, %p);\n", target, level, (void *) img));
+   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImageARB(0x%x, %d, %p);", target, level, (void *) img));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture)
 {
-   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTexture(0x%x);\n", texture));
+   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTexture(0x%x);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ClientActiveTexture)(GLenum texture)
 {
-   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTexture(0x%x);\n", texture));
+   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTexture(0x%x);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1d)(GLenum target, GLdouble s)
 {
-   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1d(0x%x, %f);\n", target, s));
+   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1d(0x%x, %f);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dv)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1f)(GLenum target, GLfloat s)
 {
-   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1f(0x%x, %f);\n", target, s));
+   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1f(0x%x, %f);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1i)(GLenum target, GLint s)
 {
-   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1i(0x%x, %d);\n", target, s));
+   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1i(0x%x, %d);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iv)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1iv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1iv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1s)(GLenum target, GLshort s)
 {
-   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1s(0x%x, %d);\n", target, s));
+   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1s(0x%x, %d);", target, s));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sv)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1sv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1sv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t)
 {
-   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2d(0x%x, %f, %f);\n", target, s, t));
+   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2d(0x%x, %f, %f);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dv)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t)
 {
-   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2f(0x%x, %f, %f);\n", target, s, t));
+   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2f(0x%x, %f, %f);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2i)(GLenum target, GLint s, GLint t)
 {
-   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2i(0x%x, %d, %d);\n", target, s, t));
+   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2i(0x%x, %d, %d);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iv)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2iv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2iv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2s)(GLenum target, GLshort s, GLshort t)
 {
-   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2s(0x%x, %d, %d);\n", target, s, t));
+   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2s(0x%x, %d, %d);", target, s, t));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sv)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2sv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2sv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3d(0x%x, %f, %f, %f);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3d(0x%x, %f, %f, %f);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dv)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3f(0x%x, %f, %f, %f);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3f(0x%x, %f, %f, %f);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r)
 {
-   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3i(0x%x, %d, %d, %d);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3i(0x%x, %d, %d, %d);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iv)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3iv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3iv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3s(0x%x, %d, %d, %d);\n", target, s, t, r));
+   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3s(0x%x, %d, %d, %d);", target, s, t, r));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sv)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3sv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3sv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4d(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4d(0x%x, %f, %f, %f, %f);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dv)(GLenum target, const GLdouble * v)
 {
-   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4f(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4f(0x%x, %f, %f, %f, %f);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
 {
-   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4i(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4i(0x%x, %d, %d, %d, %d);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iv)(GLenum target, const GLint * v)
 {
-   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4iv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4iv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4s(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4s(0x%x, %d, %d, %d, %d);", target, s, t, r, q));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sv)(GLenum target, const GLshort * v)
 {
-   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4sv(0x%x, %p);\n", target, (void *) v));
+   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4sv(0x%x, %p);", target, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixf)(const GLfloat * m)
 {
-   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixf(%p);\n", (void *) m));
+   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixd)(const GLdouble * m)
 {
-   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixd(%p);\n", (void *) m));
+   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixd(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixf)(const GLfloat * m)
 {
-   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixf(%p);\n", (void *) m));
+   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixd)(const GLdouble * m)
 {
-   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixd(%p);\n", (void *) m));
+   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixd(%p);", (void *) m));
 }
 
 /* No dispatch for SampleCover() */
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3D(0x%x, %d, 0x%x, %p, %p, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3D(0x%x, %d, 0x%x, %p, %p, %p, %d, %p, %p);", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %p, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, (void *) height, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %p, %p, %d, %p, %p);", target, level, internalformat, (void *) width, (void *) height, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1D(0x%x, %d, 0x%x, %p, %d, %p, %p);\n", target, level, internalformat, (void *) width, border, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1D(0x%x, %d, 0x%x, %p, %d, %p, %p);", target, level, internalformat, (void *) width, border, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, %p, %p);\n", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, %p, %p);", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %p, %p, 0x%x, %p, %p);\n", target, level, xoffset, yoffset, (void *) width, (void *) height, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %p, %p, 0x%x, %p, %p);", target, level, xoffset, yoffset, (void *) width, (void *) height, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
-   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1D(0x%x, %d, %d, %p, 0x%x, %p, %p);\n", target, level, xoffset, (void *) width, format, (void *) imageSize, (void *) data));
+   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1D(0x%x, %d, %d, %p, 0x%x, %p, %p);", target, level, xoffset, (void *) width, format, (void *) imageSize, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImage)(GLenum target, GLint level, GLvoid * img)
 {
-   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImage(0x%x, %d, %p);\n", target, level, (void *) img));
+   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImage(0x%x, %d, %p);", target, level, (void *) img));
 }
 
 /* No dispatch for WeightbvARB() */
@@ -2396,462 +2395,462 @@ KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImage)(GLenum target, GLint level, G
 /* No dispatch for MatrixIndexPointerARB() */
 KEYWORD1 void KEYWORD2 NAME(BlendColorEXT)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColorEXT(%f, %f, %f, %f);\n", red, green, blue, alpha));
+   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColorEXT(%f, %f, %f, %f);", red, green, blue, alpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
 {
-   DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);\n", factor, bias));
+   DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);", factor, bias));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexImage3DEXT)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3DEXT(0x%x, %d, 0x%x, %p, %p, %p, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, format, type, (void *) pixels));
+   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3DEXT(0x%x, %d, 0x%x, %p, %p, %p, %d, 0x%x, 0x%x, %p);", target, level, internalformat, (void *) width, (void *) height, (void *) depth, border, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, type, (void *) pixels));
+   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %p, %p, %p, 0x%x, 0x%x, %p);", target, level, xoffset, yoffset, zoffset, (void *) width, (void *) height, (void *) depth, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexFilterFuncSGIS)(GLenum target, GLenum filter, GLfloat * weights)
 {
-   DISPATCH(GetTexFilterFuncSGIS, (target, filter, weights), (F, "glGetTexFilterFuncSGIS(0x%x, 0x%x, %p);\n", target, filter, (void *) weights));
+   DISPATCH(GetTexFilterFuncSGIS, (target, filter, weights), (F, "glGetTexFilterFuncSGIS(0x%x, 0x%x, %p);", target, filter, (void *) weights));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexFilterFuncSGIS)(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights)
 {
-   DISPATCH(TexFilterFuncSGIS, (target, filter, n, weights), (F, "glTexFilterFuncSGIS(0x%x, 0x%x, %p, %p);\n", target, filter, (void *) n, (void *) weights));
+   DISPATCH(TexFilterFuncSGIS, (target, filter, n, weights), (F, "glTexFilterFuncSGIS(0x%x, 0x%x, %p, %p);", target, filter, (void *) n, (void *) weights));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1DEXT(0x%x, %d, %d, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, (void *) width, format, type, (void *) pixels));
+   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1DEXT(0x%x, %d, %d, %p, 0x%x, 0x%x, %p);", target, level, xoffset, (void *) width, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2DEXT(0x%x, %d, %d, %d, %p, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, (void *) width, (void *) height, format, type, (void *) pixels));
+   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2DEXT(0x%x, %d, %d, %d, %p, %p, 0x%x, 0x%x, %p);", target, level, xoffset, yoffset, (void *) width, (void *) height, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage1DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1DEXT(0x%x, %d, 0x%x, %d, %d, %p, %d);\n", target, level, internalformat, x, y, (void *) width, border));
+   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1DEXT(0x%x, %d, 0x%x, %d, %d, %p, %d);", target, level, internalformat, x, y, (void *) width, border));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage2DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2DEXT(0x%x, %d, 0x%x, %d, %d, %p, %p, %d);\n", target, level, internalformat, x, y, (void *) width, (void *) height, border));
+   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2DEXT(0x%x, %d, 0x%x, %d, %d, %p, %p, %d);", target, level, internalformat, x, y, (void *) width, (void *) height, border));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1DEXT(0x%x, %d, %d, %d, %d, %p);\n", target, level, xoffset, x, y, (void *) width));
+   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1DEXT(0x%x, %d, %d, %d, %d, %p);", target, level, xoffset, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, %p, %p);\n", target, level, xoffset, yoffset, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, %p, %p);", target, level, xoffset, yoffset, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %p, %p);\n", target, level, xoffset, yoffset, zoffset, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %p, %p);", target, level, xoffset, yoffset, zoffset, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogramEXT)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
 {
-   DISPATCH(GetHistogramEXT, (target, reset, format, type, values), (F, "glGetHistogramEXT(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (void *) values));
+   DISPATCH(GetHistogramEXT, (target, reset, format, type, values), (F, "glGetHistogramEXT(0x%x, %d, 0x%x, 0x%x, %p);", target, reset, format, type, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogramParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetHistogramParameterfvEXT, (target, pname, params), (F, "glGetHistogramParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetHistogramParameterfvEXT, (target, pname, params), (F, "glGetHistogramParameterfvEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetHistogramParameterivEXT)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetHistogramParameterivEXT, (target, pname, params), (F, "glGetHistogramParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetHistogramParameterivEXT, (target, pname, params), (F, "glGetHistogramParameterivEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmaxEXT)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
 {
-   DISPATCH(GetMinmaxEXT, (target, reset, format, type, values), (F, "glGetMinmaxEXT(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (void *) values));
+   DISPATCH(GetMinmaxEXT, (target, reset, format, type, values), (F, "glGetMinmaxEXT(0x%x, %d, 0x%x, 0x%x, %p);", target, reset, format, type, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmaxParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetMinmaxParameterfvEXT, (target, pname, params), (F, "glGetMinmaxParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetMinmaxParameterfvEXT, (target, pname, params), (F, "glGetMinmaxParameterfvEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMinmaxParameterivEXT)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetMinmaxParameterivEXT, (target, pname, params), (F, "glGetMinmaxParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetMinmaxParameterivEXT, (target, pname, params), (F, "glGetMinmaxParameterivEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(HistogramEXT)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogramEXT(0x%x, %p, 0x%x, %d);\n", target, (void *) width, internalformat, sink));
+   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogramEXT(0x%x, %p, 0x%x, %d);", target, (void *) width, internalformat, sink));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MinmaxEXT)(GLenum target, GLenum internalformat, GLboolean sink)
 {
-   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmaxEXT(0x%x, 0x%x, %d);\n", target, internalformat, sink));
+   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmaxEXT(0x%x, 0x%x, %d);", target, internalformat, sink));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ResetHistogramEXT)(GLenum target)
 {
-   DISPATCH(ResetHistogram, (target), (F, "glResetHistogramEXT(0x%x);\n", target));
+   DISPATCH(ResetHistogram, (target), (F, "glResetHistogramEXT(0x%x);", target));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ResetMinmaxEXT)(GLenum target)
 {
-   DISPATCH(ResetMinmax, (target), (F, "glResetMinmaxEXT(0x%x);\n", target));
+   DISPATCH(ResetMinmax, (target), (F, "glResetMinmaxEXT(0x%x);", target));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
 {
-   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1DEXT(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, format, type, (void *) image));
+   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1DEXT(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
 {
-   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2DEXT(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, (void *) height, format, type, (void *) image));
+   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2DEXT(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, (void *) height, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfEXT)(GLenum target, GLenum pname, GLfloat params)
 {
-   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterfEXT(0x%x, 0x%x, %f);\n", target, pname, params));
+   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterfEXT(0x%x, 0x%x, %f);", target, pname, params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfvEXT)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfvEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriEXT)(GLenum target, GLenum pname, GLint params)
 {
-   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteriEXT(0x%x, 0x%x, %d);\n", target, pname, params));
+   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteriEXT(0x%x, 0x%x, %d);", target, pname, params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterivEXT)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameterivEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1DEXT(0x%x, 0x%x, %d, %d, %p);\n", target, internalformat, x, y, (void *) width));
+   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1DEXT(0x%x, 0x%x, %d, %d, %p);", target, internalformat, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, %p, %p);\n", target, internalformat, x, y, (void *) width, (void *) height));
+   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, %p, %p);", target, internalformat, x, y, (void *) width, (void *) height));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionFilterEXT)(GLenum target, GLenum format, GLenum type, GLvoid * image)
 {
-   DISPATCH(GetConvolutionFilterEXT, (target, format, type, image), (F, "glGetConvolutionFilterEXT(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (void *) image));
+   DISPATCH(GetConvolutionFilterEXT, (target, format, type, image), (F, "glGetConvolutionFilterEXT(0x%x, 0x%x, 0x%x, %p);", target, format, type, (void *) image));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetConvolutionParameterfvEXT, (target, pname, params), (F, "glGetConvolutionParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetConvolutionParameterfvEXT, (target, pname, params), (F, "glGetConvolutionParameterfvEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionParameterivEXT)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetConvolutionParameterivEXT, (target, pname, params), (F, "glGetConvolutionParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetConvolutionParameterivEXT, (target, pname, params), (F, "glGetConvolutionParameterivEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetSeparableFilterEXT)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)
 {
-   DISPATCH(GetSeparableFilterEXT, (target, format, type, row, column, span), (F, "glGetSeparableFilterEXT(0x%x, 0x%x, 0x%x, %p, %p, %p);\n", target, format, type, (void *) row, (void *) column, (void *) span));
+   DISPATCH(GetSeparableFilterEXT, (target, format, type, row, column, span), (F, "glGetSeparableFilterEXT(0x%x, 0x%x, 0x%x, %p, %p, %p);", target, format, type, (void *) row, (void *) column, (void *) span));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SeparableFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)
 {
-   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2DEXT(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p, %p);\n", target, internalformat, (void *) width, (void *) height, format, type, (void *) row, (void *) column));
+   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2DEXT(0x%x, 0x%x, %p, %p, 0x%x, 0x%x, %p, %p);", target, internalformat, (void *) width, (void *) height, format, type, (void *) row, (void *) column));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableSGI)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
 {
-   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTableSGI(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);\n", target, internalformat, (void *) width, format, type, (void *) table));
+   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTableSGI(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);", target, internalformat, (void *) width, format, type, (void *) table));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfvSGI)(GLenum target, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfvSGI(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfvSGI(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameterivSGI)(GLenum target, GLenum pname, const GLint * params)
 {
-   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameterivSGI(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameterivSGI(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyColorTableSGI)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTableSGI(0x%x, 0x%x, %d, %d, %p);\n", target, internalformat, x, y, (void *) width));
+   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTableSGI(0x%x, 0x%x, %d, %d, %p);", target, internalformat, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableSGI)(GLenum target, GLenum format, GLenum type, GLvoid * table)
 {
-   DISPATCH(GetColorTableSGI, (target, format, type, table), (F, "glGetColorTableSGI(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (void *) table));
+   DISPATCH(GetColorTableSGI, (target, format, type, table), (F, "glGetColorTableSGI(0x%x, 0x%x, 0x%x, %p);", target, format, type, (void *) table));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterfvSGI)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetColorTableParameterfvSGI, (target, pname, params), (F, "glGetColorTableParameterfvSGI(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameterfvSGI, (target, pname, params), (F, "glGetColorTableParameterfvSGI(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterivSGI)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetColorTableParameterivSGI, (target, pname, params), (F, "glGetColorTableParameterivSGI(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameterivSGI, (target, pname, params), (F, "glGetColorTableParameterivSGI(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenSGIX)(GLenum mode)
 {
-   DISPATCH(PixelTexGenSGIX, (mode), (F, "glPixelTexGenSGIX(0x%x);\n", mode));
+   DISPATCH(PixelTexGenSGIX, (mode), (F, "glPixelTexGenSGIX(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameteriSGIS)(GLenum pname, GLint param)
 {
-   DISPATCH(PixelTexGenParameteriSGIS, (pname, param), (F, "glPixelTexGenParameteriSGIS(0x%x, %d);\n", pname, param));
+   DISPATCH(PixelTexGenParameteriSGIS, (pname, param), (F, "glPixelTexGenParameteriSGIS(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params)
 {
-   DISPATCH(PixelTexGenParameterivSGIS, (pname, params), (F, "glPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(PixelTexGenParameterivSGIS, (pname, params), (F, "glPixelTexGenParameterivSGIS(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PixelTexGenParameterfSGIS, (pname, param), (F, "glPixelTexGenParameterfSGIS(0x%x, %f);\n", pname, param));
+   DISPATCH(PixelTexGenParameterfSGIS, (pname, param), (F, "glPixelTexGenParameterfSGIS(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(PixelTexGenParameterfvSGIS, (pname, params), (F, "glPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(PixelTexGenParameterfvSGIS, (pname, params), (F, "glPixelTexGenParameterfvSGIS(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params)
 {
-   DISPATCH(GetPixelTexGenParameterivSGIS, (pname, params), (F, "glGetPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetPixelTexGenParameterivSGIS, (pname, params), (F, "glGetPixelTexGenParameterivSGIS(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetPixelTexGenParameterfvSGIS, (pname, params), (F, "glGetPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetPixelTexGenParameterfvSGIS, (pname, params), (F, "glGetPixelTexGenParameterfvSGIS(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexImage4DSGIS)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexImage4DSGIS, (target, level, internalformat, width, height, depth, size4d, border, format, type, pixels), (F, "glTexImage4DSGIS(0x%x, %d, 0x%x, %p, %p, %p, %p, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, (void *) width, (void *) height, (void *) depth, (void *) size4d, border, format, type, (void *) pixels));
+   DISPATCH(TexImage4DSGIS, (target, level, internalformat, width, height, depth, size4d, border, format, type, pixels), (F, "glTexImage4DSGIS(0x%x, %d, 0x%x, %p, %p, %p, %p, %d, 0x%x, 0x%x, %p);", target, level, internalformat, (void *) width, (void *) height, (void *) depth, (void *) size4d, border, format, type, (void *) pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexSubImage4DSGIS)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels)
 {
-   DISPATCH(TexSubImage4DSGIS, (target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels), (F, "glTexSubImage4DSGIS(0x%x, %d, %d, %d, %d, %d, %p, %p, %p, %p, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, woffset, (void *) width, (void *) height, (void *) depth, (void *) size4d, format, type, (void *) pixels));
+   DISPATCH(TexSubImage4DSGIS, (target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels), (F, "glTexSubImage4DSGIS(0x%x, %d, %d, %d, %d, %d, %p, %p, %p, %p, 0x%x, 0x%x, %p);", target, level, xoffset, yoffset, zoffset, woffset, (void *) width, (void *) height, (void *) depth, (void *) size4d, format, type, (void *) pixels));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(AreTexturesResidentEXT)(GLsizei n, const GLuint * textures, GLboolean * residences)
 {
-   RETURN_DISPATCH(AreTexturesResidentEXT, (n, textures, residences), (F, "glAreTexturesResidentEXT(%p, %p, %p);\n", (void *) n, (void *) textures, (void *) residences));
+   RETURN_DISPATCH(AreTexturesResidentEXT, (n, textures, residences), (F, "glAreTexturesResidentEXT(%p, %p, %p);", (void *) n, (void *) textures, (void *) residences));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BindTextureEXT)(GLenum target, GLuint texture)
 {
-   DISPATCH(BindTexture, (target, texture), (F, "glBindTextureEXT(0x%x, %d);\n", target, texture));
+   DISPATCH(BindTexture, (target, texture), (F, "glBindTextureEXT(0x%x, %d);", target, texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DeleteTexturesEXT)(GLsizei n, const GLuint * textures)
 {
-   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTexturesEXT(%p, %p);\n", (void *) n, (void *) textures));
+   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTexturesEXT(%p, %p);", (void *) n, (void *) textures));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GenTexturesEXT)(GLsizei n, GLuint * textures)
 {
-   DISPATCH(GenTexturesEXT, (n, textures), (F, "glGenTexturesEXT(%p, %p);\n", (void *) n, (void *) textures));
+   DISPATCH(GenTexturesEXT, (n, textures), (F, "glGenTexturesEXT(%p, %p);", (void *) n, (void *) textures));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsTextureEXT)(GLuint texture)
 {
-   RETURN_DISPATCH(IsTextureEXT, (texture), (F, "glIsTextureEXT(%d);\n", texture));
+   RETURN_DISPATCH(IsTextureEXT, (texture), (F, "glIsTextureEXT(%d);", texture));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PrioritizeTexturesEXT)(GLsizei n, const GLuint * textures, const GLclampf * priorities)
 {
-   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTexturesEXT(%p, %p, %p);\n", (void *) n, (void *) textures, (void *) priorities));
+   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTexturesEXT(%p, %p, %p);", (void *) n, (void *) textures, (void *) priorities));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DetailTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points)
 {
-   DISPATCH(DetailTexFuncSGIS, (target, n, points), (F, "glDetailTexFuncSGIS(0x%x, %p, %p);\n", target, (void *) n, (void *) points));
+   DISPATCH(DetailTexFuncSGIS, (target, n, points), (F, "glDetailTexFuncSGIS(0x%x, %p, %p);", target, (void *) n, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetDetailTexFuncSGIS)(GLenum target, GLfloat * points)
 {
-   DISPATCH(GetDetailTexFuncSGIS, (target, points), (F, "glGetDetailTexFuncSGIS(0x%x, %p);\n", target, (void *) points));
+   DISPATCH(GetDetailTexFuncSGIS, (target, points), (F, "glGetDetailTexFuncSGIS(0x%x, %p);", target, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SharpenTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points)
 {
-   DISPATCH(SharpenTexFuncSGIS, (target, n, points), (F, "glSharpenTexFuncSGIS(0x%x, %p, %p);\n", target, (void *) n, (void *) points));
+   DISPATCH(SharpenTexFuncSGIS, (target, n, points), (F, "glSharpenTexFuncSGIS(0x%x, %p, %p);", target, (void *) n, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetSharpenTexFuncSGIS)(GLenum target, GLfloat * points)
 {
-   DISPATCH(GetSharpenTexFuncSGIS, (target, points), (F, "glGetSharpenTexFuncSGIS(0x%x, %p);\n", target, (void *) points));
+   DISPATCH(GetSharpenTexFuncSGIS, (target, points), (F, "glGetSharpenTexFuncSGIS(0x%x, %p);", target, (void *) points));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SampleMaskSGIS)(GLclampf value, GLboolean invert)
 {
-   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);\n", value, invert));
+   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);", value, invert));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SamplePatternSGIS)(GLenum pattern)
 {
-   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);\n", pattern));
+   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);", pattern));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ArrayElementEXT)(GLint i)
 {
-   DISPATCH(ArrayElement, (i), (F, "glArrayElementEXT(%d);\n", i));
+   DISPATCH(ArrayElement, (i), (F, "glArrayElementEXT(%d);", i));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
-   DISPATCH(ColorPointerEXT, (size, type, stride, count, pointer), (F, "glColorPointerEXT(%d, 0x%x, %p, %p, %p);\n", size, type, (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(ColorPointerEXT, (size, type, stride, count, pointer), (F, "glColorPointerEXT(%d, 0x%x, %p, %p, %p);", size, type, (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawArraysEXT)(GLenum mode, GLint first, GLsizei count)
 {
-   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArraysEXT(0x%x, %d, %p);\n", mode, first, (void *) count));
+   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArraysEXT(0x%x, %d, %p);", mode, first, (void *) count));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer)
 {
-   DISPATCH(EdgeFlagPointerEXT, (stride, count, pointer), (F, "glEdgeFlagPointerEXT(%p, %p, %p);\n", (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(EdgeFlagPointerEXT, (stride, count, pointer), (F, "glEdgeFlagPointerEXT(%p, %p, %p);", (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPointervEXT)(GLenum pname, GLvoid ** params)
 {
-   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointervEXT(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointervEXT(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
-   DISPATCH(IndexPointerEXT, (type, stride, count, pointer), (F, "glIndexPointerEXT(0x%x, %p, %p, %p);\n", type, (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(IndexPointerEXT, (type, stride, count, pointer), (F, "glIndexPointerEXT(0x%x, %p, %p, %p);", type, (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
-   DISPATCH(NormalPointerEXT, (type, stride, count, pointer), (F, "glNormalPointerEXT(0x%x, %p, %p, %p);\n", type, (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(NormalPointerEXT, (type, stride, count, pointer), (F, "glNormalPointerEXT(0x%x, %p, %p, %p);", type, (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
-   DISPATCH(TexCoordPointerEXT, (size, type, stride, count, pointer), (F, "glTexCoordPointerEXT(%d, 0x%x, %p, %p, %p);\n", size, type, (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(TexCoordPointerEXT, (size, type, stride, count, pointer), (F, "glTexCoordPointerEXT(%d, 0x%x, %p, %p, %p);", size, type, (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
-   DISPATCH(VertexPointerEXT, (size, type, stride, count, pointer), (F, "glVertexPointerEXT(%d, 0x%x, %p, %p, %p);\n", size, type, (void *) stride, (void *) count, (void *) pointer));
+   DISPATCH(VertexPointerEXT, (size, type, stride, count, pointer), (F, "glVertexPointerEXT(%d, 0x%x, %p, %p, %p);", size, type, (void *) stride, (void *) count, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BlendEquationEXT)(GLenum mode)
 {
-   DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);\n", mode));
+   DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SpriteParameterfSGIX)(GLenum pname, GLfloat param)
 {
-   DISPATCH(SpriteParameterfSGIX, (pname, param), (F, "glSpriteParameterfSGIX(0x%x, %f);\n", pname, param));
+   DISPATCH(SpriteParameterfSGIX, (pname, param), (F, "glSpriteParameterfSGIX(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SpriteParameterfvSGIX)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(SpriteParameterfvSGIX, (pname, params), (F, "glSpriteParameterfvSGIX(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(SpriteParameterfvSGIX, (pname, params), (F, "glSpriteParameterfvSGIX(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SpriteParameteriSGIX)(GLenum pname, GLint param)
 {
-   DISPATCH(SpriteParameteriSGIX, (pname, param), (F, "glSpriteParameteriSGIX(0x%x, %d);\n", pname, param));
+   DISPATCH(SpriteParameteriSGIX, (pname, param), (F, "glSpriteParameteriSGIX(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SpriteParameterivSGIX)(GLenum pname, const GLint * params)
 {
-   DISPATCH(SpriteParameterivSGIX, (pname, params), (F, "glSpriteParameterivSGIX(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(SpriteParameterivSGIX, (pname, params), (F, "glSpriteParameterivSGIX(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfEXT)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);\n", pname, param));
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfvEXT)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfARB)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfARB(0x%x, %f);\n", pname, param));
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfARB(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfvARB)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvARB(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvARB(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfSGIS)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfvSGIS)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 GLint KEYWORD2 NAME(GetInstrumentsSGIX)(void)
 {
-   RETURN_DISPATCH(GetInstrumentsSGIX, (), (F, "glGetInstrumentsSGIX();\n"));
+   RETURN_DISPATCH(GetInstrumentsSGIX, (), (F, "glGetInstrumentsSGIX();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(InstrumentsBufferSGIX)(GLsizei size, GLint * buffer)
 {
-   DISPATCH(InstrumentsBufferSGIX, (size, buffer), (F, "glInstrumentsBufferSGIX(%p, %p);\n", (void *) size, (void *) buffer));
+   DISPATCH(InstrumentsBufferSGIX, (size, buffer), (F, "glInstrumentsBufferSGIX(%p, %p);", (void *) size, (void *) buffer));
 }
 
 KEYWORD1 GLint KEYWORD2 NAME(PollInstrumentsSGIX)(GLint * marker_p)
 {
-   RETURN_DISPATCH(PollInstrumentsSGIX, (marker_p), (F, "glPollInstrumentsSGIX(%p);\n", (void *) marker_p));
+   RETURN_DISPATCH(PollInstrumentsSGIX, (marker_p), (F, "glPollInstrumentsSGIX(%p);", (void *) marker_p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ReadInstrumentsSGIX)(GLint marker)
 {
-   DISPATCH(ReadInstrumentsSGIX, (marker), (F, "glReadInstrumentsSGIX(%d);\n", marker));
+   DISPATCH(ReadInstrumentsSGIX, (marker), (F, "glReadInstrumentsSGIX(%d);", marker));
 }
 
 KEYWORD1 void KEYWORD2 NAME(StartInstrumentsSGIX)(void)
 {
-   DISPATCH(StartInstrumentsSGIX, (), (F, "glStartInstrumentsSGIX();\n"));
+   DISPATCH(StartInstrumentsSGIX, (), (F, "glStartInstrumentsSGIX();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(StopInstrumentsSGIX)(GLint marker)
 {
-   DISPATCH(StopInstrumentsSGIX, (marker), (F, "glStopInstrumentsSGIX(%d);\n", marker));
+   DISPATCH(StopInstrumentsSGIX, (marker), (F, "glStopInstrumentsSGIX(%d);", marker));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FrameZoomSGIX)(GLint factor)
 {
-   DISPATCH(FrameZoomSGIX, (factor), (F, "glFrameZoomSGIX(%d);\n", factor));
+   DISPATCH(FrameZoomSGIX, (factor), (F, "glFrameZoomSGIX(%d);", factor));
 }
 
 KEYWORD1 void KEYWORD2 NAME(TagSampleBufferSGIX)(void)
 {
-   DISPATCH(TagSampleBufferSGIX, (), (F, "glTagSampleBufferSGIX();\n"));
+   DISPATCH(TagSampleBufferSGIX, (), (F, "glTagSampleBufferSGIX();"));
 }
 
 /* No dispatch for DeformationMap3dSGIX() */
@@ -2860,12 +2859,12 @@ KEYWORD1 void KEYWORD2 NAME(TagSampleBufferSGIX)(void)
 /* No dispatch for LoadIdentityDeformationMapSGIX() */
 KEYWORD1 void KEYWORD2 NAME(ReferencePlaneSGIX)(const GLdouble * equation)
 {
-   DISPATCH(ReferencePlaneSGIX, (equation), (F, "glReferencePlaneSGIX(%p);\n", (void *) equation));
+   DISPATCH(ReferencePlaneSGIX, (equation), (F, "glReferencePlaneSGIX(%p);", (void *) equation));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FlushRasterSGIX)(void)
 {
-   DISPATCH(FlushRasterSGIX, (), (F, "glFlushRasterSGIX();\n"));
+   DISPATCH(FlushRasterSGIX, (), (F, "glFlushRasterSGIX();"));
 }
 
 /* No dispatch for FogFuncSGIS() */
@@ -2878,192 +2877,192 @@ KEYWORD1 void KEYWORD2 NAME(FlushRasterSGIX)(void)
 /* No dispatch for GetImageTransformParameterfvHP() */
 KEYWORD1 void KEYWORD2 NAME(ColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
 {
-   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTableEXT(0x%x, %p, %p, 0x%x, 0x%x, %p);\n", target, (void *) start, (void *) count, format, type, (void *) data));
+   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTableEXT(0x%x, %p, %p, 0x%x, 0x%x, %p);", target, (void *) start, (void *) count, format, type, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CopyColorSubTableEXT)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTableEXT(0x%x, %p, %d, %d, %p);\n", target, (void *) start, x, y, (void *) width));
+   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTableEXT(0x%x, %p, %d, %d, %p);", target, (void *) start, x, y, (void *) width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(HintPGI)(GLenum target, GLint mode)
 {
-   DISPATCH(HintPGI, (target, mode), (F, "glHintPGI(0x%x, %d);\n", target, mode));
+   DISPATCH(HintPGI, (target, mode), (F, "glHintPGI(0x%x, %d);", target, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableEXT)(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
 {
-   DISPATCH(ColorTable, (target, internalFormat, width, format, type, table), (F, "glColorTableEXT(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);\n", target, internalFormat, (void *) width, format, type, (void *) table));
+   DISPATCH(ColorTable, (target, internalFormat, width, format, type, table), (F, "glColorTableEXT(0x%x, 0x%x, %p, 0x%x, 0x%x, %p);", target, internalFormat, (void *) width, format, type, (void *) table));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableEXT)(GLenum target, GLenum format, GLenum type, GLvoid * data)
 {
-   DISPATCH(GetColorTableEXT, (target, format, type, data), (F, "glGetColorTableEXT(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (void *) data));
+   DISPATCH(GetColorTableEXT, (target, format, type, data), (F, "glGetColorTableEXT(0x%x, 0x%x, 0x%x, %p);", target, format, type, (void *) data));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterivEXT)(GLenum target, GLenum pname, GLint * params)
 {
-   DISPATCH(GetColorTableParameterivEXT, (target, pname, params), (F, "glGetColorTableParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameterivEXT, (target, pname, params), (F, "glGetColorTableParameterivEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetColorTableParameterfvEXT, (target, pname, params), (F, "glGetColorTableParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (void *) params));
+   DISPATCH(GetColorTableParameterfvEXT, (target, pname, params), (F, "glGetColorTableParameterfvEXT(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetListParameterfvSGIX)(GLuint list, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetListParameterfvSGIX, (list, pname, params), (F, "glGetListParameterfvSGIX(%d, 0x%x, %p);\n", list, pname, (void *) params));
+   DISPATCH(GetListParameterfvSGIX, (list, pname, params), (F, "glGetListParameterfvSGIX(%d, 0x%x, %p);", list, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetListParameterivSGIX)(GLuint list, GLenum pname, GLint * params)
 {
-   DISPATCH(GetListParameterivSGIX, (list, pname, params), (F, "glGetListParameterivSGIX(%d, 0x%x, %p);\n", list, pname, (void *) params));
+   DISPATCH(GetListParameterivSGIX, (list, pname, params), (F, "glGetListParameterivSGIX(%d, 0x%x, %p);", list, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListParameterfSGIX)(GLuint list, GLenum pname, GLfloat param)
 {
-   DISPATCH(ListParameterfSGIX, (list, pname, param), (F, "glListParameterfSGIX(%d, 0x%x, %f);\n", list, pname, param));
+   DISPATCH(ListParameterfSGIX, (list, pname, param), (F, "glListParameterfSGIX(%d, 0x%x, %f);", list, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListParameterfvSGIX)(GLuint list, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(ListParameterfvSGIX, (list, pname, params), (F, "glListParameterfvSGIX(%d, 0x%x, %p);\n", list, pname, (void *) params));
+   DISPATCH(ListParameterfvSGIX, (list, pname, params), (F, "glListParameterfvSGIX(%d, 0x%x, %p);", list, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListParameteriSGIX)(GLuint list, GLenum pname, GLint param)
 {
-   DISPATCH(ListParameteriSGIX, (list, pname, param), (F, "glListParameteriSGIX(%d, 0x%x, %d);\n", list, pname, param));
+   DISPATCH(ListParameteriSGIX, (list, pname, param), (F, "glListParameteriSGIX(%d, 0x%x, %d);", list, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListParameterivSGIX)(GLuint list, GLenum pname, const GLint * params)
 {
-   DISPATCH(ListParameterivSGIX, (list, pname, params), (F, "glListParameterivSGIX(%d, 0x%x, %p);\n", list, pname, (void *) params));
+   DISPATCH(ListParameterivSGIX, (list, pname, params), (F, "glListParameterivSGIX(%d, 0x%x, %p);", list, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexMaterialEXT)(GLenum face, GLenum mode)
 {
-   DISPATCH(IndexMaterialEXT, (face, mode), (F, "glIndexMaterialEXT(0x%x, 0x%x);\n", face, mode));
+   DISPATCH(IndexMaterialEXT, (face, mode), (F, "glIndexMaterialEXT(0x%x, 0x%x);", face, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexFuncEXT)(GLenum func, GLclampf ref)
 {
-   DISPATCH(IndexFuncEXT, (func, ref), (F, "glIndexFuncEXT(0x%x, %f);\n", func, ref));
+   DISPATCH(IndexFuncEXT, (func, ref), (F, "glIndexFuncEXT(0x%x, %f);", func, ref));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LockArraysEXT)(GLint first, GLsizei count)
 {
-   DISPATCH(LockArraysEXT, (first, count), (F, "glLockArraysEXT(%d, %p);\n", first, (void *) count));
+   DISPATCH(LockArraysEXT, (first, count), (F, "glLockArraysEXT(%d, %p);", first, (void *) count));
 }
 
 KEYWORD1 void KEYWORD2 NAME(UnlockArraysEXT)(void)
 {
-   DISPATCH(UnlockArraysEXT, (), (F, "glUnlockArraysEXT();\n"));
+   DISPATCH(UnlockArraysEXT, (), (F, "glUnlockArraysEXT();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CullParameterdvEXT)(GLenum pname, GLdouble * params)
 {
-   DISPATCH(CullParameterdvEXT, (pname, params), (F, "glCullParameterdvEXT(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(CullParameterdvEXT, (pname, params), (F, "glCullParameterdvEXT(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CullParameterfvEXT)(GLenum pname, GLfloat * params)
 {
-   DISPATCH(CullParameterfvEXT, (pname, params), (F, "glCullParameterfvEXT(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(CullParameterfvEXT, (pname, params), (F, "glCullParameterfvEXT(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentColorMaterialSGIX)(GLenum face, GLenum mode)
 {
-   DISPATCH(FragmentColorMaterialSGIX, (face, mode), (F, "glFragmentColorMaterialSGIX(0x%x, 0x%x);\n", face, mode));
+   DISPATCH(FragmentColorMaterialSGIX, (face, mode), (F, "glFragmentColorMaterialSGIX(0x%x, 0x%x);", face, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightfSGIX)(GLenum light, GLenum pname, GLfloat param)
 {
-   DISPATCH(FragmentLightfSGIX, (light, pname, param), (F, "glFragmentLightfSGIX(0x%x, 0x%x, %f);\n", light, pname, param));
+   DISPATCH(FragmentLightfSGIX, (light, pname, param), (F, "glFragmentLightfSGIX(0x%x, 0x%x, %f);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightfvSGIX)(GLenum light, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(FragmentLightfvSGIX, (light, pname, params), (F, "glFragmentLightfvSGIX(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(FragmentLightfvSGIX, (light, pname, params), (F, "glFragmentLightfvSGIX(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightiSGIX)(GLenum light, GLenum pname, GLint param)
 {
-   DISPATCH(FragmentLightiSGIX, (light, pname, param), (F, "glFragmentLightiSGIX(0x%x, 0x%x, %d);\n", light, pname, param));
+   DISPATCH(FragmentLightiSGIX, (light, pname, param), (F, "glFragmentLightiSGIX(0x%x, 0x%x, %d);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightivSGIX)(GLenum light, GLenum pname, const GLint * params)
 {
-   DISPATCH(FragmentLightivSGIX, (light, pname, params), (F, "glFragmentLightivSGIX(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(FragmentLightivSGIX, (light, pname, params), (F, "glFragmentLightivSGIX(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightModelfSGIX)(GLenum pname, GLfloat param)
 {
-   DISPATCH(FragmentLightModelfSGIX, (pname, param), (F, "glFragmentLightModelfSGIX(0x%x, %f);\n", pname, param));
+   DISPATCH(FragmentLightModelfSGIX, (pname, param), (F, "glFragmentLightModelfSGIX(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightModelfvSGIX)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(FragmentLightModelfvSGIX, (pname, params), (F, "glFragmentLightModelfvSGIX(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(FragmentLightModelfvSGIX, (pname, params), (F, "glFragmentLightModelfvSGIX(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightModeliSGIX)(GLenum pname, GLint param)
 {
-   DISPATCH(FragmentLightModeliSGIX, (pname, param), (F, "glFragmentLightModeliSGIX(0x%x, %d);\n", pname, param));
+   DISPATCH(FragmentLightModeliSGIX, (pname, param), (F, "glFragmentLightModeliSGIX(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentLightModelivSGIX)(GLenum pname, const GLint * params)
 {
-   DISPATCH(FragmentLightModelivSGIX, (pname, params), (F, "glFragmentLightModelivSGIX(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(FragmentLightModelivSGIX, (pname, params), (F, "glFragmentLightModelivSGIX(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentMaterialfSGIX)(GLenum face, GLenum pname, GLfloat param)
 {
-   DISPATCH(FragmentMaterialfSGIX, (face, pname, param), (F, "glFragmentMaterialfSGIX(0x%x, 0x%x, %f);\n", face, pname, param));
+   DISPATCH(FragmentMaterialfSGIX, (face, pname, param), (F, "glFragmentMaterialfSGIX(0x%x, 0x%x, %f);", face, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentMaterialfvSGIX)(GLenum face, GLenum pname, const GLfloat * params)
 {
-   DISPATCH(FragmentMaterialfvSGIX, (face, pname, params), (F, "glFragmentMaterialfvSGIX(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(FragmentMaterialfvSGIX, (face, pname, params), (F, "glFragmentMaterialfvSGIX(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentMaterialiSGIX)(GLenum face, GLenum pname, GLint param)
 {
-   DISPATCH(FragmentMaterialiSGIX, (face, pname, param), (F, "glFragmentMaterialiSGIX(0x%x, 0x%x, %d);\n", face, pname, param));
+   DISPATCH(FragmentMaterialiSGIX, (face, pname, param), (F, "glFragmentMaterialiSGIX(0x%x, 0x%x, %d);", face, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FragmentMaterialivSGIX)(GLenum face, GLenum pname, const GLint * params)
 {
-   DISPATCH(FragmentMaterialivSGIX, (face, pname, params), (F, "glFragmentMaterialivSGIX(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(FragmentMaterialivSGIX, (face, pname, params), (F, "glFragmentMaterialivSGIX(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFragmentLightfvSGIX)(GLenum light, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetFragmentLightfvSGIX, (light, pname, params), (F, "glGetFragmentLightfvSGIX(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(GetFragmentLightfvSGIX, (light, pname, params), (F, "glGetFragmentLightfvSGIX(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFragmentLightivSGIX)(GLenum light, GLenum pname, GLint * params)
 {
-   DISPATCH(GetFragmentLightivSGIX, (light, pname, params), (F, "glGetFragmentLightivSGIX(0x%x, 0x%x, %p);\n", light, pname, (void *) params));
+   DISPATCH(GetFragmentLightivSGIX, (light, pname, params), (F, "glGetFragmentLightivSGIX(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFragmentMaterialfvSGIX)(GLenum face, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetFragmentMaterialfvSGIX, (face, pname, params), (F, "glGetFragmentMaterialfvSGIX(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(GetFragmentMaterialfvSGIX, (face, pname, params), (F, "glGetFragmentMaterialfvSGIX(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFragmentMaterialivSGIX)(GLenum face, GLenum pname, GLint * params)
 {
-   DISPATCH(GetFragmentMaterialivSGIX, (face, pname, params), (F, "glGetFragmentMaterialivSGIX(0x%x, 0x%x, %p);\n", face, pname, (void *) params));
+   DISPATCH(GetFragmentMaterialivSGIX, (face, pname, params), (F, "glGetFragmentMaterialivSGIX(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightEnviSGIX)(GLenum pname, GLint param)
 {
-   DISPATCH(LightEnviSGIX, (pname, param), (F, "glLightEnviSGIX(0x%x, %d);\n", pname, param));
+   DISPATCH(LightEnviSGIX, (pname, param), (F, "glLightEnviSGIX(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
 {
-   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %d, %d, %p, 0x%x, %p);\n", mode, start, end, (void *) count, type, (void *) indices));
+   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %d, %d, %p, 0x%x, %p);", mode, start, end, (void *) count, type, (void *) indices));
 }
 
 /* No dispatch for ApplyTextureEXT() */
@@ -3085,87 +3084,87 @@ KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsEXT)(GLenum mode, GLuint start, GLu
 /* No dispatch for PixelTransformParameterfvEXT() */
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue)
 {
-   DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3bEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3bEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bvEXT)(const GLbyte * v)
 {
-   DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bvEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bvEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue)
 {
-   DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3dEXT(%f, %f, %f);\n", red, green, blue));
+   DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3dEXT(%f, %f, %f);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dvEXT)(const GLdouble * v)
 {
-   DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dvEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dvEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue)
 {
-   DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3fEXT(%f, %f, %f);\n", red, green, blue));
+   DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3fEXT(%f, %f, %f);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fvEXT)(const GLfloat * v)
 {
-   DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fvEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fvEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3iEXT)(GLint red, GLint green, GLint blue)
 {
-   DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3iEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3iEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ivEXT)(const GLint * v)
 {
-   DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3ivEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3ivEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue)
 {
-   DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3sEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3sEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3svEXT)(const GLshort * v)
 {
-   DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3svEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3svEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue)
 {
-   DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ubEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ubEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubvEXT)(const GLubyte * v)
 {
-   DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubvEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubvEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue)
 {
-   DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3uiEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3uiEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uivEXT)(const GLuint * v)
 {
-   DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uivEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uivEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue)
 {
-   DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3usEXT(%d, %d, %d);\n", red, green, blue));
+   DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3usEXT(%d, %d, %d);", red, green, blue));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usvEXT)(const GLushort * v)
 {
-   DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usvEXT(%p);\n", (void *) v));
+   DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usvEXT(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointerEXT(%d, 0x%x, %p, %p);\n", size, type, (void *) stride, (void *) pointer));
+   DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointerEXT(%d, 0x%x, %p, %p);", size, type, (void *) stride, (void *) pointer));
 }
 
 /* No dispatch for TextureNormalEXT() */
@@ -3173,27 +3172,27 @@ KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointerEXT)(GLint size, GLenum type, G
 /* No dispatch for MultiDrawElementsEXT() */
 KEYWORD1 void KEYWORD2 NAME(FogCoordfEXT)(GLfloat coord)
 {
-   DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordfEXT(%f);\n", coord));
+   DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordfEXT(%f);", coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord)
 {
-   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);\n", (void *) coord));
+   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);", (void *) coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoorddEXT)(GLdouble coord)
 {
-   DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoorddEXT(%f);\n", coord));
+   DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoorddEXT(%f);", coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoorddvEXT)(const GLdouble * coord)
 {
-   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);\n", (void *) coord));
+   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);", (void *) coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %p, %p);\n", type, (void *) stride, (void *) pointer));
+   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %p, %p);", type, (void *) stride, (void *) pointer));
 }
 
 /* No dispatch for Tangent3bEXT() */
@@ -3276,227 +3275,227 @@ KEYWORD1 void KEYWORD2 NAME(FogCoordPointerEXT)(GLenum type, GLsizei stride, con
 /* No dispatch for ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN() */
 KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
+   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateINGR)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
+   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexWeightfEXT)(GLfloat weight)
 {
-   DISPATCH(VertexWeightfEXT, (weight), (F, "glVertexWeightfEXT(%f);\n", weight));
+   DISPATCH(VertexWeightfEXT, (weight), (F, "glVertexWeightfEXT(%f);", weight));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexWeightfvEXT)(const GLfloat * weight)
 {
-   DISPATCH(VertexWeightfvEXT, (weight), (F, "glVertexWeightfvEXT(%p);\n", (void *) weight));
+   DISPATCH(VertexWeightfvEXT, (weight), (F, "glVertexWeightfvEXT(%p);", (void *) weight));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexWeightPointerEXT)(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(VertexWeightPointerEXT, (size, type, stride, pointer), (F, "glVertexWeightPointerEXT(%p, 0x%x, %p, %p);\n", (void *) size, type, (void *) stride, (void *) pointer));
+   DISPATCH(VertexWeightPointerEXT, (size, type, stride, pointer), (F, "glVertexWeightPointerEXT(%p, 0x%x, %p, %p);", (void *) size, type, (void *) stride, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FlushVertexArrayRangeNV)(void)
 {
-   DISPATCH(FlushVertexArrayRangeNV, (), (F, "glFlushVertexArrayRangeNV();\n"));
+   DISPATCH(FlushVertexArrayRangeNV, (), (F, "glFlushVertexArrayRangeNV();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer)
 {
-   DISPATCH(VertexArrayRangeNV, (length, pointer), (F, "glVertexArrayRangeNV(%p, %p);\n", (void *) length, (void *) pointer));
+   DISPATCH(VertexArrayRangeNV, (length, pointer), (F, "glVertexArrayRangeNV(%p, %p);", (void *) length, (void *) pointer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerParameterfvNV)(GLenum pname, const GLfloat * params)
 {
-   DISPATCH(CombinerParameterfvNV, (pname, params), (F, "glCombinerParameterfvNV(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(CombinerParameterfvNV, (pname, params), (F, "glCombinerParameterfvNV(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerParameterfNV)(GLenum pname, GLfloat param)
 {
-   DISPATCH(CombinerParameterfNV, (pname, param), (F, "glCombinerParameterfNV(0x%x, %f);\n", pname, param));
+   DISPATCH(CombinerParameterfNV, (pname, param), (F, "glCombinerParameterfNV(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerParameterivNV)(GLenum pname, const GLint * params)
 {
-   DISPATCH(CombinerParameterivNV, (pname, params), (F, "glCombinerParameterivNV(0x%x, %p);\n", pname, (void *) params));
+   DISPATCH(CombinerParameterivNV, (pname, params), (F, "glCombinerParameterivNV(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerParameteriNV)(GLenum pname, GLint param)
 {
-   DISPATCH(CombinerParameteriNV, (pname, param), (F, "glCombinerParameteriNV(0x%x, %d);\n", pname, param));
+   DISPATCH(CombinerParameteriNV, (pname, param), (F, "glCombinerParameteriNV(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
 {
-   DISPATCH(CombinerInputNV, (stage, portion, variable, input, mapping, componentUsage), (F, "glCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x);\n", stage, portion, variable, input, mapping, componentUsage));
+   DISPATCH(CombinerInputNV, (stage, portion, variable, input, mapping, componentUsage), (F, "glCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x);", stage, portion, variable, input, mapping, componentUsage));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
 {
-   DISPATCH(CombinerOutputNV, (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum), (F, "glCombinerOutputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %d, %d, %d);\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum));
+   DISPATCH(CombinerOutputNV, (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum), (F, "glCombinerOutputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %d, %d, %d);", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
 {
-   DISPATCH(FinalCombinerInputNV, (variable, input, mapping, componentUsage), (F, "glFinalCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x);\n", variable, input, mapping, componentUsage));
+   DISPATCH(FinalCombinerInputNV, (variable, input, mapping, componentUsage), (F, "glFinalCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x);", variable, input, mapping, componentUsage));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetCombinerInputParameterfvNV, (stage, portion, variable, pname, params), (F, "glGetCombinerInputParameterfvNV(0x%x, 0x%x, 0x%x, 0x%x, %p);\n", stage, portion, variable, pname, (void *) params));
+   DISPATCH(GetCombinerInputParameterfvNV, (stage, portion, variable, pname, params), (F, "glGetCombinerInputParameterfvNV(0x%x, 0x%x, 0x%x, 0x%x, %p);", stage, portion, variable, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params)
 {
-   DISPATCH(GetCombinerInputParameterivNV, (stage, portion, variable, pname, params), (F, "glGetCombinerInputParameterivNV(0x%x, 0x%x, 0x%x, 0x%x, %p);\n", stage, portion, variable, pname, (void *) params));
+   DISPATCH(GetCombinerInputParameterivNV, (stage, portion, variable, pname, params), (F, "glGetCombinerInputParameterivNV(0x%x, 0x%x, 0x%x, 0x%x, %p);", stage, portion, variable, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetCombinerOutputParameterfvNV, (stage, portion, pname, params), (F, "glGetCombinerOutputParameterfvNV(0x%x, 0x%x, 0x%x, %p);\n", stage, portion, pname, (void *) params));
+   DISPATCH(GetCombinerOutputParameterfvNV, (stage, portion, pname, params), (F, "glGetCombinerOutputParameterfvNV(0x%x, 0x%x, 0x%x, %p);", stage, portion, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params)
 {
-   DISPATCH(GetCombinerOutputParameterivNV, (stage, portion, pname, params), (F, "glGetCombinerOutputParameterivNV(0x%x, 0x%x, 0x%x, %p);\n", stage, portion, pname, (void *) params));
+   DISPATCH(GetCombinerOutputParameterivNV, (stage, portion, pname, params), (F, "glGetCombinerOutputParameterivNV(0x%x, 0x%x, 0x%x, %p);", stage, portion, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params)
 {
-   DISPATCH(GetFinalCombinerInputParameterfvNV, (variable, pname, params), (F, "glGetFinalCombinerInputParameterfvNV(0x%x, 0x%x, %p);\n", variable, pname, (void *) params));
+   DISPATCH(GetFinalCombinerInputParameterfvNV, (variable, pname, params), (F, "glGetFinalCombinerInputParameterfvNV(0x%x, 0x%x, %p);", variable, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params)
 {
-   DISPATCH(GetFinalCombinerInputParameterivNV, (variable, pname, params), (F, "glGetFinalCombinerInputParameterivNV(0x%x, 0x%x, %p);\n", variable, pname, (void *) params));
+   DISPATCH(GetFinalCombinerInputParameterivNV, (variable, pname, params), (F, "glGetFinalCombinerInputParameterivNV(0x%x, 0x%x, %p);", variable, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ResizeBuffersMESA)(void)
 {
-   DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();\n"));
+   DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dMESA)(GLdouble x, GLdouble y)
 {
-   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2dMESA(%f, %f);\n", x, y));
+   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2dMESA(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dvMESA)(const GLdouble * v)
 {
-   DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fMESA)(GLfloat x, GLfloat y)
 {
-   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2fMESA(%f, %f);\n", x, y));
+   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2fMESA(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fvMESA)(const GLfloat * v)
 {
-   DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2iMESA)(GLint x, GLint y)
 {
-   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2iMESA(%d, %d);\n", x, y));
+   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2iMESA(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2ivMESA)(const GLint * v)
 {
-   DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2ivMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2ivMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2sMESA)(GLshort x, GLshort y)
 {
-   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2sMESA(%d, %d);\n", x, y));
+   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2sMESA(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2svMESA)(const GLshort * v)
 {
-   DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2svMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2svMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3dMESA(%f, %f, %f);\n", x, y, z));
+   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3dMESA(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dvMESA)(const GLdouble * v)
 {
-   DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3fMESA(%f, %f, %f);\n", x, y, z));
+   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3fMESA(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fvMESA)(const GLfloat * v)
 {
-   DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3iMESA)(GLint x, GLint y, GLint z)
 {
-   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3iMESA(%d, %d, %d);\n", x, y, z));
+   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3iMESA(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3ivMESA)(const GLint * v)
 {
-   DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3ivMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3ivMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3sMESA)(GLshort x, GLshort y, GLshort z)
 {
-   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3sMESA(%d, %d, %d);\n", x, y, z));
+   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3sMESA(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3svMESA)(const GLshort * v)
 {
-   DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3svMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3svMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   DISPATCH(WindowPos4dMESA, (x, y, z, w), (F, "glWindowPos4dMESA(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(WindowPos4dMESA, (x, y, z, w), (F, "glWindowPos4dMESA(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4dvMESA)(const GLdouble * v)
 {
-   DISPATCH(WindowPos4dvMESA, (v), (F, "glWindowPos4dvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos4dvMESA, (v), (F, "glWindowPos4dvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-   DISPATCH(WindowPos4fMESA, (x, y, z, w), (F, "glWindowPos4fMESA(%f, %f, %f, %f);\n", x, y, z, w));
+   DISPATCH(WindowPos4fMESA, (x, y, z, w), (F, "glWindowPos4fMESA(%f, %f, %f, %f);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4fvMESA)(const GLfloat * v)
 {
-   DISPATCH(WindowPos4fvMESA, (v), (F, "glWindowPos4fvMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos4fvMESA, (v), (F, "glWindowPos4fvMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w)
 {
-   DISPATCH(WindowPos4iMESA, (x, y, z, w), (F, "glWindowPos4iMESA(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(WindowPos4iMESA, (x, y, z, w), (F, "glWindowPos4iMESA(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4ivMESA)(const GLint * v)
 {
-   DISPATCH(WindowPos4ivMESA, (v), (F, "glWindowPos4ivMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos4ivMESA, (v), (F, "glWindowPos4ivMESA(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-   DISPATCH(WindowPos4sMESA, (x, y, z, w), (F, "glWindowPos4sMESA(%d, %d, %d, %d);\n", x, y, z, w));
+   DISPATCH(WindowPos4sMESA, (x, y, z, w), (F, "glWindowPos4sMESA(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos4svMESA)(const GLshort * v)
 {
-   DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);\n", (void *) v));
+   DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);", (void *) v));
 }
 
 /* No dispatch for MultiModeDrawArraysIBM() */
@@ -3511,17 +3510,17 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos4svMESA)(const GLshort * v)
 /* No dispatch for VertexPointerListIBM() */
 KEYWORD1 void KEYWORD2 NAME(TbufferMask3DFX)(GLuint mask)
 {
-   DISPATCH(TbufferMask3DFX, (mask), (F, "glTbufferMask3DFX(%d);\n", mask));
+   DISPATCH(TbufferMask3DFX, (mask), (F, "glTbufferMask3DFX(%d);", mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SampleMaskEXT)(GLclampf value, GLboolean invert)
 {
-   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskEXT(%f, %d);\n", value, invert));
+   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskEXT(%f, %d);", value, invert));
 }
 
 KEYWORD1 void KEYWORD2 NAME(SamplePatternEXT)(GLenum pattern)
 {
-   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternEXT(0x%x);\n", pattern));
+   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternEXT(0x%x);", pattern));
 }
 
 /* No dispatch for TextureColorMaskSGIS() */
@@ -3544,148 +3543,404 @@ KEYWORD1 void KEYWORD2 NAME(SamplePatternEXT)(GLenum pattern)
 /* No dispatch for EvalMapsNV() */
 /* No dispatch for CombinerStageParameterfvNV() */
 /* No dispatch for GetCombinerStageParameterfvNV() */
-/* No dispatch for BindProgramNV() */
-/* No dispatch for DeleteProgramsNV() */
-/* No dispatch for ExecuteProgramNV() */
-/* No dispatch for GenProgramsNV() */
-/* No dispatch for AreProgramsResidentNV() */
-/* No dispatch for RequestResidentProgramsNV() */
-/* No dispatch for GetProgramParameterfvNV() */
-/* No dispatch for GetProgramParameterdvNV() */
-/* No dispatch for GetProgramivNV() */
-/* No dispatch for GetProgramStringNV() */
-/* No dispatch for GetTrackMatrixivNV() */
-/* No dispatch for GetVertexAttribdvNV() */
-/* No dispatch for GetVertexAttribfvNV() */
-/* No dispatch for GetVertexAttribivNV() */
-/* No dispatch for GetVertexAttribPointervNV() */
-/* No dispatch for IsProgramNV() */
-/* No dispatch for LoadProgramNV() */
-/* No dispatch for ProgramParameter4fNV() */
-/* No dispatch for ProgramParameter4dNV() */
-/* No dispatch for ProgramParameter4dvNV() */
-/* No dispatch for ProgramParameter4fvNV() */
-/* No dispatch for ProgramParameters4dvNV() */
-/* No dispatch for ProgramParameters4fvNV() */
-/* No dispatch for TrackMatrixNV() */
-/* No dispatch for VertexAttribPointerNV() */
-/* No dispatch for VertexAttrib1sNV() */
-/* No dispatch for VertexAttrib1fNV() */
-/* No dispatch for VertexAttrib1dNV() */
-/* No dispatch for VertexAttrib2sNV() */
-/* No dispatch for VertexAttrib2fNV() */
-/* No dispatch for VertexAttrib2dNV() */
-/* No dispatch for VertexAttrib3sNV() */
-/* No dispatch for VertexAttrib3fNV() */
-/* No dispatch for VertexAttrib3dNV() */
-/* No dispatch for VertexAttrib4sNV() */
-/* No dispatch for VertexAttrib4fNV() */
-/* No dispatch for VertexAttrib4dNV() */
-/* No dispatch for VertexAttrib4ubNV() */
-/* No dispatch for VertexAttrib1svNV() */
-/* No dispatch for VertexAttrib1fvNV() */
-/* No dispatch for VertexAttrib1dvNV() */
-/* No dispatch for VertexAttrib2svNV() */
-/* No dispatch for VertexAttrib2fvNV() */
-/* No dispatch for VertexAttrib2dvNV() */
-/* No dispatch for VertexAttrib3svNV() */
-/* No dispatch for VertexAttrib3fvNV() */
-/* No dispatch for VertexAttrib3dvNV() */
-/* No dispatch for VertexAttrib4svNV() */
-/* No dispatch for VertexAttrib4fvNV() */
-/* No dispatch for VertexAttrib4dvNV() */
-/* No dispatch for VertexAttrib4ubvNV() */
-/* No dispatch for VertexAttribs1svNV() */
-/* No dispatch for VertexAttribs1fvNV() */
-/* No dispatch for VertexAttribs1dvNV() */
-/* No dispatch for VertexAttribs2svNV() */
-/* No dispatch for VertexAttribs2fvNV() */
-/* No dispatch for VertexAttribs2dvNV() */
-/* No dispatch for VertexAttribs3svNV() */
-/* No dispatch for VertexAttribs3fvNV() */
-/* No dispatch for VertexAttribs3dvNV() */
-/* No dispatch for VertexAttribs4svNV() */
-/* No dispatch for VertexAttribs4fvNV() */
-/* No dispatch for VertexAttribs4dvNV() */
-/* No dispatch for VertexAttribs4ubvNV() */
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dARB)(GLdouble x, GLdouble y)
 {
-   DISPATCH(WindowPos2dARB, (x, y), (F, "glWindowPos2dARB(%f, %f);\n", x, y));
+   DISPATCH(WindowPos2dARB, (x, y), (F, "glWindowPos2dARB(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fARB)(GLfloat x, GLfloat y)
 {
-   DISPATCH(WindowPos2fARB, (x, y), (F, "glWindowPos2fARB(%f, %f);\n", x, y));
+   DISPATCH(WindowPos2fARB, (x, y), (F, "glWindowPos2fARB(%f, %f);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2iARB)(GLint x, GLint y)
 {
-   DISPATCH(WindowPos2iARB, (x, y), (F, "glWindowPos2iARB(%d, %d);\n", x, y));
+   DISPATCH(WindowPos2iARB, (x, y), (F, "glWindowPos2iARB(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2sARB)(GLshort x, GLshort y)
 {
-   DISPATCH(WindowPos2sARB, (x, y), (F, "glWindowPos2sARB(%d, %d);\n", x, y));
+   DISPATCH(WindowPos2sARB, (x, y), (F, "glWindowPos2sARB(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dvARB)(const GLdouble * p)
 {
-   DISPATCH(WindowPos2dvARB, (p), (F, "glWindowPos2dvARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos2dvARB, (p), (F, "glWindowPos2dvARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fvARB)(const GLfloat * p)
 {
-   DISPATCH(WindowPos2fvARB, (p), (F, "glWindowPos2fvARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos2fvARB, (p), (F, "glWindowPos2fvARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2ivARB)(const GLint * p)
 {
-   DISPATCH(WindowPos2ivARB, (p), (F, "glWindowPos2ivARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos2ivARB, (p), (F, "glWindowPos2ivARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos2svARB)(const GLshort * p)
 {
-   DISPATCH(WindowPos2svARB, (p), (F, "glWindowPos2svARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos2svARB, (p), (F, "glWindowPos2svARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dARB)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(WindowPos3dARB, (x, y, z), (F, "glWindowPos3dARB(%f, %f, %f);\n", x, y, z));
+   DISPATCH(WindowPos3dARB, (x, y, z), (F, "glWindowPos3dARB(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fARB)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(WindowPos3fARB, (x, y, z), (F, "glWindowPos3fARB(%f, %f, %f);\n", x, y, z));
+   DISPATCH(WindowPos3fARB, (x, y, z), (F, "glWindowPos3fARB(%f, %f, %f);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3iARB)(GLint x, GLint y, GLint z)
 {
-   DISPATCH(WindowPos3iARB, (x, y, z), (F, "glWindowPos3iARB(%d, %d, %d);\n", x, y, z));
+   DISPATCH(WindowPos3iARB, (x, y, z), (F, "glWindowPos3iARB(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3sARB)(GLshort x, GLshort y, GLshort z)
 {
-   DISPATCH(WindowPos3sARB, (x, y, z), (F, "glWindowPos3sARB(%d, %d, %d);\n", x, y, z));
+   DISPATCH(WindowPos3sARB, (x, y, z), (F, "glWindowPos3sARB(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dvARB)(const GLdouble * p)
 {
-   DISPATCH(WindowPos3dvARB, (p), (F, "glWindowPos3dvARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos3dvARB, (p), (F, "glWindowPos3dvARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fvARB)(const GLfloat * p)
 {
-   DISPATCH(WindowPos3fvARB, (p), (F, "glWindowPos3fvARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos3fvARB, (p), (F, "glWindowPos3fvARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3ivARB)(const GLint * p)
 {
-   DISPATCH(WindowPos3ivARB, (p), (F, "glWindowPos3ivARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos3ivARB, (p), (F, "glWindowPos3ivARB(%p);", (void *) p));
 }
 
 KEYWORD1 void KEYWORD2 NAME(WindowPos3svARB)(const GLshort * p)
 {
-   DISPATCH(WindowPos3svARB, (p), (F, "glWindowPos3svARB(%p);\n", (void *) p));
+   DISPATCH(WindowPos3svARB, (p), (F, "glWindowPos3svARB(%p);", (void *) p));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindProgramNV)(GLenum target, GLuint id)
+{
+   DISPATCH(BindProgramNV, (target, id), (F, "glBindProgramNV(0x%x, %d);", target, id));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DeleteProgramsNV)(GLsizei n, const GLuint * ids)
+{
+   DISPATCH(DeleteProgramsNV, (n, ids), (F, "glDeleteProgramsNV(%p, %p);", (void *) n, (void *) ids));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params)
+{
+   DISPATCH(ExecuteProgramNV, (target, id, params), (F, "glExecuteProgramNV(0x%x, %d, %p);", target, id, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GenProgramsNV)(GLsizei n, GLuint * ids)
+{
+   DISPATCH(GenProgramsNV, (n, ids), (F, "glGenProgramsNV(%p, %p);", (void *) n, (void *) ids));
+}
+
+KEYWORD1 GLboolean KEYWORD2 NAME(AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences)
+{
+   RETURN_DISPATCH(AreProgramsResidentNV, (n, ids, residences), (F, "glAreProgramsResidentNV(%p, %p, %p);", (void *) n, (void *) ids, (void *) residences));
+}
+
+KEYWORD1 void KEYWORD2 NAME(RequestResidentProgramsNV)(GLsizei n, const GLuint * ids)
+{
+   DISPATCH(RequestResidentProgramsNV, (n, ids), (F, "glRequestResidentProgramsNV(%p, %p);", (void *) n, (void *) ids));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+{
+   DISPATCH(GetProgramParameterfvNV, (target, index, pname, params), (F, "glGetProgramParameterfvNV(0x%x, %d, 0x%x, %p);", target, index, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+{
+   DISPATCH(GetProgramParameterdvNV, (target, index, pname, params), (F, "glGetProgramParameterdvNV(0x%x, %d, 0x%x, %p);", target, index, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetProgramivNV)(GLuint id, GLenum pname, GLint * params)
+{
+   DISPATCH(GetProgramivNV, (id, pname, params), (F, "glGetProgramivNV(%d, 0x%x, %p);", id, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program)
+{
+   DISPATCH(GetProgramStringNV, (id, pname, program), (F, "glGetProgramStringNV(%d, 0x%x, %p);", id, pname, (void *) program));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params)
+{
+   DISPATCH(GetTrackMatrixivNV, (target, address, pname, params), (F, "glGetTrackMatrixivNV(0x%x, %d, 0x%x, %p);", target, address, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params)
+{
+   DISPATCH(GetVertexAttribdvNV, (index, pname, params), (F, "glGetVertexAttribdvNV(%d, 0x%x, %p);", index, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params)
+{
+   DISPATCH(GetVertexAttribfvNV, (index, pname, params), (F, "glGetVertexAttribfvNV(%d, 0x%x, %p);", index, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params)
+{
+   DISPATCH(GetVertexAttribivNV, (index, pname, params), (F, "glGetVertexAttribivNV(%d, 0x%x, %p);", index, pname, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer)
+{
+   DISPATCH(GetVertexAttribPointervNV, (index, pname, pointer), (F, "glGetVertexAttribPointervNV(%d, 0x%x, %p);", index, pname, (void *) pointer));
+}
+
+KEYWORD1 GLboolean KEYWORD2 NAME(IsProgramNV)(GLuint id)
+{
+   RETURN_DISPATCH(IsProgramNV, (id), (F, "glIsProgramNV(%d);", id));
+}
+
+KEYWORD1 void KEYWORD2 NAME(LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+{
+   DISPATCH(LoadProgramNV, (target, id, len, program), (F, "glLoadProgramNV(0x%x, %d, %p, %p);", target, id, (void *) len, (void *) program));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameter4fNV)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+   DISPATCH(ProgramParameter4fNV, (target, index, x, y, z, w), (F, "glProgramParameter4fNV(0x%x, %d, %f, %f, %f, %f);", target, index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameter4dNV)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+   DISPATCH(ProgramParameter4dNV, (target, index, x, y, z, w), (F, "glProgramParameter4dNV(0x%x, %d, %f, %f, %f, %f);", target, index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameter4dvNV)(GLenum target, GLuint index, const GLdouble * params)
+{
+   DISPATCH(ProgramParameter4dvNV, (target, index, params), (F, "glProgramParameter4dvNV(0x%x, %d, %p);", target, index, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameter4fvNV)(GLenum target, GLuint index, const GLfloat * params)
+{
+   DISPATCH(ProgramParameter4fvNV, (target, index, params), (F, "glProgramParameter4fvNV(0x%x, %d, %p);", target, index, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+{
+   DISPATCH(ProgramParameters4dvNV, (target, index, num, params), (F, "glProgramParameters4dvNV(0x%x, %d, %d, %p);", target, index, num, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+{
+   DISPATCH(ProgramParameters4fvNV, (target, index, num, params), (F, "glProgramParameters4fvNV(0x%x, %d, %d, %p);", target, index, num, (void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+{
+   DISPATCH(TrackMatrixNV, (target, address, matrix, transform), (F, "glTrackMatrixNV(0x%x, %d, 0x%x, 0x%x);", target, address, matrix, transform));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+   DISPATCH(VertexAttribPointerNV, (index, size, type, stride, pointer), (F, "glVertexAttribPointerNV(%d, %d, 0x%x, %p, %p);", index, size, type, (void *) stride, (void *) pointer));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1sNV)(GLuint index, GLshort x)
+{
+   DISPATCH(VertexAttrib1sNV, (index, x), (F, "glVertexAttrib1sNV(%d, %d);", index, x));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fNV)(GLuint index, GLfloat x)
+{
+   DISPATCH(VertexAttrib1fNV, (index, x), (F, "glVertexAttrib1fNV(%d, %f);", index, x));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dNV)(GLuint index, GLdouble x)
+{
+   DISPATCH(VertexAttrib1dNV, (index, x), (F, "glVertexAttrib1dNV(%d, %f);", index, x));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y)
+{
+   DISPATCH(VertexAttrib2sNV, (index, x, y), (F, "glVertexAttrib2sNV(%d, %d, %d);", index, x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)
+{
+   DISPATCH(VertexAttrib2fNV, (index, x, y), (F, "glVertexAttrib2fNV(%d, %f, %f);", index, x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y)
+{
+   DISPATCH(VertexAttrib2dNV, (index, x, y), (F, "glVertexAttrib2dNV(%d, %f, %f);", index, x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+   DISPATCH(VertexAttrib3sNV, (index, x, y, z), (F, "glVertexAttrib3sNV(%d, %d, %d, %d);", index, x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+   DISPATCH(VertexAttrib3fNV, (index, x, y, z), (F, "glVertexAttrib3fNV(%d, %f, %f, %f);", index, x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+   DISPATCH(VertexAttrib3dNV, (index, x, y, z), (F, "glVertexAttrib3dNV(%d, %f, %f, %f);", index, x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+   DISPATCH(VertexAttrib4sNV, (index, x, y, z, w), (F, "glVertexAttrib4sNV(%d, %d, %d, %d, %d);", index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+   DISPATCH(VertexAttrib4fNV, (index, x, y, z, w), (F, "glVertexAttrib4fNV(%d, %f, %f, %f, %f);", index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+   DISPATCH(VertexAttrib4dNV, (index, x, y, z, w), (F, "glVertexAttrib4dNV(%d, %f, %f, %f, %f);", index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+   DISPATCH(VertexAttrib4ubNV, (index, x, y, z, w), (F, "glVertexAttrib4ubNV(%d, %d, %d, %d, %d);", index, x, y, z, w));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1svNV)(GLuint index, const GLshort * v)
+{
+   DISPATCH(VertexAttrib1svNV, (index, v), (F, "glVertexAttrib1svNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)
+{
+   DISPATCH(VertexAttrib1fvNV, (index, v), (F, "glVertexAttrib1fvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dvNV)(GLuint index, const GLdouble * v)
+{
+   DISPATCH(VertexAttrib1dvNV, (index, v), (F, "glVertexAttrib1dvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2svNV)(GLuint index, const GLshort * v)
+{
+   DISPATCH(VertexAttrib2svNV, (index, v), (F, "glVertexAttrib2svNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)
+{
+   DISPATCH(VertexAttrib2fvNV, (index, v), (F, "glVertexAttrib2fvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dvNV)(GLuint index, const GLdouble * v)
+{
+   DISPATCH(VertexAttrib2dvNV, (index, v), (F, "glVertexAttrib2dvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3svNV)(GLuint index, const GLshort * v)
+{
+   DISPATCH(VertexAttrib3svNV, (index, v), (F, "glVertexAttrib3svNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fvNV)(GLuint index, const GLfloat * v)
+{
+   DISPATCH(VertexAttrib3fvNV, (index, v), (F, "glVertexAttrib3fvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dvNV)(GLuint index, const GLdouble * v)
+{
+   DISPATCH(VertexAttrib3dvNV, (index, v), (F, "glVertexAttrib3dvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4svNV)(GLuint index, const GLshort * v)
+{
+   DISPATCH(VertexAttrib4svNV, (index, v), (F, "glVertexAttrib4svNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)
+{
+   DISPATCH(VertexAttrib4fvNV, (index, v), (F, "glVertexAttrib4fvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dvNV)(GLuint index, const GLdouble * v)
+{
+   DISPATCH(VertexAttrib4dvNV, (index, v), (F, "glVertexAttrib4dvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubvNV)(GLuint index, const GLubyte * v)
+{
+   DISPATCH(VertexAttrib4ubvNV, (index, v), (F, "glVertexAttrib4ubvNV(%d, %p);", index, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v)
+{
+   DISPATCH(VertexAttribs1svNV, (index, n, v), (F, "glVertexAttribs1svNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v)
+{
+   DISPATCH(VertexAttribs1fvNV, (index, n, v), (F, "glVertexAttribs1fvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v)
+{
+   DISPATCH(VertexAttribs1dvNV, (index, n, v), (F, "glVertexAttribs1dvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v)
+{
+   DISPATCH(VertexAttribs2svNV, (index, n, v), (F, "glVertexAttribs2svNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v)
+{
+   DISPATCH(VertexAttribs2fvNV, (index, n, v), (F, "glVertexAttribs2fvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v)
+{
+   DISPATCH(VertexAttribs2dvNV, (index, n, v), (F, "glVertexAttribs2dvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v)
+{
+   DISPATCH(VertexAttribs3svNV, (index, n, v), (F, "glVertexAttribs3svNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v)
+{
+   DISPATCH(VertexAttribs3fvNV, (index, n, v), (F, "glVertexAttribs3fvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v)
+{
+   DISPATCH(VertexAttribs3dvNV, (index, n, v), (F, "glVertexAttribs3dvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v)
+{
+   DISPATCH(VertexAttribs4svNV, (index, n, v), (F, "glVertexAttribs4svNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v)
+{
+   DISPATCH(VertexAttribs4fvNV, (index, n, v), (F, "glVertexAttribs4fvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v)
+{
+   DISPATCH(VertexAttribs4dvNV, (index, n, v), (F, "glVertexAttribs4dvNV(%d, %p, %p);", index, (void *) n, (void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v)
+{
+   DISPATCH(VertexAttribs4ubvNV, (index, n, v), (F, "glVertexAttribs4ubvNV(%d, %p, %p);", index, (void *) n, (void *) v));
 }
 
 
@@ -4295,6 +4550,70 @@ void *DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(WindowPos3fvARB),
    TABLE_ENTRY(WindowPos3ivARB),
    TABLE_ENTRY(WindowPos3svARB),
+   TABLE_ENTRY(BindProgramNV),
+   TABLE_ENTRY(DeleteProgramsNV),
+   TABLE_ENTRY(ExecuteProgramNV),
+   TABLE_ENTRY(GenProgramsNV),
+   TABLE_ENTRY(AreProgramsResidentNV),
+   TABLE_ENTRY(RequestResidentProgramsNV),
+   TABLE_ENTRY(GetProgramParameterfvNV),
+   TABLE_ENTRY(GetProgramParameterdvNV),
+   TABLE_ENTRY(GetProgramivNV),
+   TABLE_ENTRY(GetProgramStringNV),
+   TABLE_ENTRY(GetTrackMatrixivNV),
+   TABLE_ENTRY(GetVertexAttribdvNV),
+   TABLE_ENTRY(GetVertexAttribfvNV),
+   TABLE_ENTRY(GetVertexAttribivNV),
+   TABLE_ENTRY(GetVertexAttribPointervNV),
+   TABLE_ENTRY(IsProgramNV),
+   TABLE_ENTRY(LoadProgramNV),
+   TABLE_ENTRY(ProgramParameter4fNV),
+   TABLE_ENTRY(ProgramParameter4dNV),
+   TABLE_ENTRY(ProgramParameter4dvNV),
+   TABLE_ENTRY(ProgramParameter4fvNV),
+   TABLE_ENTRY(ProgramParameters4dvNV),
+   TABLE_ENTRY(ProgramParameters4fvNV),
+   TABLE_ENTRY(TrackMatrixNV),
+   TABLE_ENTRY(VertexAttribPointerNV),
+   TABLE_ENTRY(VertexAttrib1sNV),
+   TABLE_ENTRY(VertexAttrib1fNV),
+   TABLE_ENTRY(VertexAttrib1dNV),
+   TABLE_ENTRY(VertexAttrib2sNV),
+   TABLE_ENTRY(VertexAttrib2fNV),
+   TABLE_ENTRY(VertexAttrib2dNV),
+   TABLE_ENTRY(VertexAttrib3sNV),
+   TABLE_ENTRY(VertexAttrib3fNV),
+   TABLE_ENTRY(VertexAttrib3dNV),
+   TABLE_ENTRY(VertexAttrib4sNV),
+   TABLE_ENTRY(VertexAttrib4fNV),
+   TABLE_ENTRY(VertexAttrib4dNV),
+   TABLE_ENTRY(VertexAttrib4ubNV),
+   TABLE_ENTRY(VertexAttrib1svNV),
+   TABLE_ENTRY(VertexAttrib1fvNV),
+   TABLE_ENTRY(VertexAttrib1dvNV),
+   TABLE_ENTRY(VertexAttrib2svNV),
+   TABLE_ENTRY(VertexAttrib2fvNV),
+   TABLE_ENTRY(VertexAttrib2dvNV),
+   TABLE_ENTRY(VertexAttrib3svNV),
+   TABLE_ENTRY(VertexAttrib3fvNV),
+   TABLE_ENTRY(VertexAttrib3dvNV),
+   TABLE_ENTRY(VertexAttrib4svNV),
+   TABLE_ENTRY(VertexAttrib4fvNV),
+   TABLE_ENTRY(VertexAttrib4dvNV),
+   TABLE_ENTRY(VertexAttrib4ubvNV),
+   TABLE_ENTRY(VertexAttribs1svNV),
+   TABLE_ENTRY(VertexAttribs1fvNV),
+   TABLE_ENTRY(VertexAttribs1dvNV),
+   TABLE_ENTRY(VertexAttribs2svNV),
+   TABLE_ENTRY(VertexAttribs2fvNV),
+   TABLE_ENTRY(VertexAttribs2dvNV),
+   TABLE_ENTRY(VertexAttribs3svNV),
+   TABLE_ENTRY(VertexAttribs3fvNV),
+   TABLE_ENTRY(VertexAttribs3dvNV),
+   TABLE_ENTRY(VertexAttribs4svNV),
+   TABLE_ENTRY(VertexAttribs4fvNV),
+   TABLE_ENTRY(VertexAttribs4dvNV),
+   TABLE_ENTRY(VertexAttribs4ubvNV),
    /* A whole bunch of no-op functions.  These might be called
     * when someone tries to call a dynamically-registered
     * extension function without a current rendering context.
diff --git a/src/mesa/main/Makefile.X11 b/src/mesa/main/Makefile.X11
index dc7b2c99f2..6a2e5d7ae4 100644
--- a/src/mesa/main/Makefile.X11
+++ b/src/mesa/main/Makefile.X11
@@ -1,4 +1,4 @@
-# $Id: Makefile.X11,v 1.59 2001/11/23 20:44:12 brianp Exp $
+# $Id: Makefile.X11,v 1.60 2001/12/14 02:55:08 brianp Exp $
 
 # Mesa 3-D graphics library
 # Version:  4.1
@@ -21,9 +21,9 @@ LIBDIR = ../lib
 
 
 CORE_SOURCES = \
-	swrast_setup/ss_context.c \
-	swrast_setup/ss_triangle.c \
-	swrast_setup/ss_vb.c \
+	vpexec.c \
+	vpparse.c \
+	vpstate.c \
 	api_arrayelt.c \
 	api_loopback.c \
 	api_noop.c \
@@ -121,6 +121,9 @@ CORE_SOURCES = \
 	swrast/s_texstore.c \
 	swrast/s_triangle.c \
 	swrast/s_zoom.c \
+	swrast_setup/ss_context.c \
+	swrast_setup/ss_triangle.c \
+	swrast_setup/ss_vb.c \
 	tnl/t_array_api.c \
 	tnl/t_array_import.c \
 	tnl/t_context.c \
@@ -138,6 +141,7 @@ CORE_SOURCES = \
 	tnl/t_vb_light.c \
 	tnl/t_vb_normals.c \
 	tnl/t_vb_points.c \
+	tnl/t_vb_program.c \
 	tnl/t_vb_render.c \
 	tnl/t_vb_texgen.c \
 	tnl/t_vb_texmat.c \
@@ -337,3 +341,28 @@ dep: $(CORE_SOURCES) $(DRIVER_SOURCES) $(OSMESA_SOURCES)
 
 tags:
 	etags `find . -name \*.[ch]` `find ../include`
+
+
+
+# XXX temporary for NV_vertex_program
+VPFILES = \
+	include/GL/glext.h \
+	src/Makefile.X11 \
+	src/vpparse.[ch] \
+	src/vpexec.[ch] \
+	src/vpstate.[ch] \
+	src/attrib.c \
+	src/context.c \
+	src/enable.c \
+	src/extensions.c \
+	src/get.c \
+	src/matrix.c \
+	src/mtypes.h \
+	src/varray.c \
+	src/tnl/t_vb_program.c \
+	tests/vptest1.c \
+	tests/vptest2.c
+	
+vptar:
+	cd .. ; tar cvf vpfiles.tar $(VPFILES) ; gzip vpfiles.tar
+
diff --git a/src/mesa/main/api_eval.c b/src/mesa/main/api_eval.c
index f25ede9bda..f644a98371 100644
--- a/src/mesa/main/api_eval.c
+++ b/src/mesa/main/api_eval.c
@@ -1,4 +1,4 @@
-/* $Id: api_eval.c,v 1.1 2001/06/04 13:57:35 keithw Exp $ */
+/* $Id: api_eval.c,v 1.2 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -281,16 +281,16 @@ void _mesa_EvalCoord1f( GLfloat u )
    GLfloat normal[3], texcoord[4], color[4];
    GLuint index;
 
-   COPY_3FV( normal, ctx->Current.Normal );
-   COPY_4FV( texcoord, ctx->Current.Texcoord[0] );
-   COPY_4FV( color, ctx->Current.Color );
+   COPY_3FV( normal, ctx->Current.Attrib[VERT_ATTRIB_NORMAL] );
+   COPY_4FV( texcoord, ctx->Current.Attrib[VERT_ATTRIB_TEX0] );
+   COPY_4FV( color, ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
    index = ctx->Current.Index;
 
    do_EvalCoord1f( ctx, u );
 
-   COPY_3FV( ctx->Current.Normal, normal );
-   COPY_4FV( ctx->Current.Texcoord[0], texcoord );
-   COPY_4FV( ctx->Current.Color, color );
+   COPY_3FV( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], normal );
+   COPY_4FV( ctx->Current.Attrib[VERT_ATTRIB_TEX0], texcoord );
+   COPY_4FV( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color );
    ctx->Current.Index = index;
 }
 
@@ -300,16 +300,16 @@ void _mesa_EvalCoord2f( GLfloat u, GLfloat v )
    GLfloat normal[3], texcoord[4], color[4];
    GLuint index;
 
-   COPY_3FV( normal, ctx->Current.Normal );
-   COPY_4FV( texcoord, ctx->Current.Texcoord[0] );
-   COPY_4FV( color, ctx->Current.Color );
+   COPY_3FV( normal, ctx->Current.Attrib[VERT_ATTRIB_NORMAL] );
+   COPY_4FV( texcoord, ctx->Current.Attrib[VERT_ATTRIB_TEX0] );
+   COPY_4FV( color, ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
    index = ctx->Current.Index;
 
    do_EvalCoord2f( ctx, u, v );
 
-   COPY_3FV( ctx->Current.Normal, normal );
-   COPY_4FV( ctx->Current.Texcoord[0], texcoord );
-   COPY_4FV( ctx->Current.Color, color );
+   COPY_3FV( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], normal );
+   COPY_4FV( ctx->Current.Attrib[VERT_ATTRIB_TEX0], texcoord );
+   COPY_4FV( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color );
    ctx->Current.Index = index;
 }
 
diff --git a/src/mesa/main/api_loopback.c b/src/mesa/main/api_loopback.c
index 3ec4f30f36..cf38a54901 100644
--- a/src/mesa/main/api_loopback.c
+++ b/src/mesa/main/api_loopback.c
@@ -1,4 +1,4 @@
-/* $Id: api_loopback.c,v 1.11 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: api_loopback.c,v 1.12 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -66,6 +66,7 @@
 #define RECTF(a,b,c,d)              DRIVER(Rectf)(a,b,c,d)
 #define SECONDARYCOLORUB(a,b,c)     DRIVER(SecondaryColor3ubEXT)(a,b,c)
 #define SECONDARYCOLORF(a,b,c)      DRIVER(SecondaryColor3fEXT)(a,b,c)
+#define ATTRIB(index, x, y, z, w)   DRIVER(VertexAttrib4fNV)(index, x, y, z, w)
 
 
 static void
@@ -1367,6 +1368,267 @@ loopback_SecondaryColor3usvEXT_f( const GLushort *v )
 }
 
 
+/*
+ * GL_NV_vertex_program
+ */
+
+static void
+loopback_VertexAttrib1sNV(GLuint index, GLshort x)
+{
+   ATTRIB(index, (GLfloat) x, 0.0F, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib1fNV(GLuint index, GLfloat x)
+{
+   ATTRIB(index, x, 0.0F, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib1dNV(GLuint index, GLdouble x)
+{
+   ATTRIB(index, (GLfloat) x, 0.0F, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+{
+   ATTRIB(index, (GLfloat) x, y, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+{
+   ATTRIB(index, (GLfloat) x, y, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+{
+   ATTRIB(index, (GLfloat) x, y, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+   ATTRIB(index, (GLfloat) x, y, z, 1.0F);
+}
+
+static void
+loopback_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+   ATTRIB(index, x, y, z, 1.0F);
+}
+
+static void
+loopback_VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+   ATTRIB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
+}
+
+static void
+loopback_VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+   ATTRIB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
+}
+
+static void
+loopback_VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+   ATTRIB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
+}
+
+static void
+loopback_VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+   ATTRIB(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y),
+	UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w));
+}
+
+static void
+loopback_VertexAttrib1svNV(GLuint index, const GLshort *v)
+{
+   ATTRIB(index, (GLfloat) v[0], 0.0F, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib1fvNV(GLuint index, const GLfloat *v)
+{
+   ATTRIB(index, v[0], 0.0F, 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib1dvNV(GLuint index, const GLdouble *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2svNV(GLuint index, const GLshort *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2fvNV(GLuint index, const GLfloat *v)
+{
+   ATTRIB(index, v[0], v[1], 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib2dvNV(GLuint index, const GLdouble *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLdouble) v[1], 0.0F, 1.0F);
+}
+
+static void
+loopback_VertexAttrib3svNV(GLuint index, const GLshort *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
+}
+
+static void
+loopback_VertexAttrib3fvNV(GLuint index, const GLfloat *v)
+{
+   ATTRIB(index, v[0], v[1], v[2], 1.0F);
+}
+
+static void
+loopback_VertexAttrib3dvNV(GLuint index, const GLdouble *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
+}
+
+static void
+loopback_VertexAttrib4svNV(GLuint index, const GLshort *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
+}
+
+static void
+loopback_VertexAttrib4fvNV(GLuint index, const GLfloat *v)
+{
+   ATTRIB(index, v[0], v[1], v[2], v[3]);
+}
+
+static void
+loopback_VertexAttrib4dvNV(GLuint index, const GLdouble *v)
+{
+   ATTRIB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
+}
+
+static void
+loopback_VertexAttrib4ubvNV(GLuint index, const GLubyte *v)
+{
+   ATTRIB(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]),
+          UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3]));
+}
+
+
+static void
+loopback_VertexAttribs1svNV(GLuint index, GLsizei n, const GLshort *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib1svNV(index + i, v + i);
+}
+
+static void
+loopback_VertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib1fvNV(index + i, v + i);
+}
+
+static void
+loopback_VertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib1dvNV(index + i, v + i);
+}
+
+static void
+loopback_VertexAttribs2svNV(GLuint index, GLsizei n, const GLshort *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib2svNV(index + i, v + 2 * i);
+}
+
+static void
+loopback_VertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib2fvNV(index + i, v + 2 * i);
+}
+
+static void
+loopback_VertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib2dvNV(index + i, v + 2 * i);
+}
+
+static void
+loopback_VertexAttribs3svNV(GLuint index, GLsizei n, const GLshort *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib3svNV(index + i, v + 3 * i);
+}
+
+static void
+loopback_VertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib3fvNV(index + i, v + 3 * i);
+}
+
+static void
+loopback_VertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib3dvNV(index + i, v + 3 * i);
+}
+
+static void
+loopback_VertexAttribs4svNV(GLuint index, GLsizei n, const GLshort *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib4svNV(index + i, v + 4 * i);
+}
+
+static void
+loopback_VertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib4fvNV(index + i, v + 4 * i);
+}
+
+static void
+loopback_VertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib4dvNV(index + i, v + 4 * i);
+}
+
+static void
+loopback_VertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v)
+{
+   GLint i;
+   for (i = n - 1; i >= 0; i--)
+      loopback_VertexAttrib4ubvNV(index + i, v + 4 * i);
+}
+
 
 void
 _mesa_loopback_prefer_float( struct _glapi_table *dest,
@@ -1564,4 +1826,45 @@ _mesa_loopback_init_api_table( struct _glapi_table *dest,
    dest->Rectsv = loopback_Rectsv;
    dest->FogCoorddEXT = loopback_FogCoorddEXT;
    dest->FogCoorddvEXT = loopback_FogCoorddvEXT;
+
+   dest->VertexAttrib1sNV = loopback_VertexAttrib1sNV;
+   dest->VertexAttrib1fNV = loopback_VertexAttrib1fNV;
+   dest->VertexAttrib1dNV = loopback_VertexAttrib1dNV;
+   dest->VertexAttrib2sNV = loopback_VertexAttrib2sNV;
+   dest->VertexAttrib2fNV = loopback_VertexAttrib2fNV;
+   dest->VertexAttrib2dNV = loopback_VertexAttrib2dNV;
+   dest->VertexAttrib3sNV = loopback_VertexAttrib3sNV;
+   dest->VertexAttrib3fNV = loopback_VertexAttrib3fNV;
+   dest->VertexAttrib3dNV = loopback_VertexAttrib3dNV;
+   dest->VertexAttrib4sNV = loopback_VertexAttrib4sNV;
+   dest->VertexAttrib4dNV = loopback_VertexAttrib4dNV;
+   dest->VertexAttrib4ubNV = loopback_VertexAttrib4ubNV;
+
+   dest->VertexAttrib1svNV = loopback_VertexAttrib1svNV;
+   dest->VertexAttrib1fvNV = loopback_VertexAttrib1fvNV;
+   dest->VertexAttrib1dvNV = loopback_VertexAttrib1dvNV;
+   dest->VertexAttrib2svNV = loopback_VertexAttrib2svNV;
+   dest->VertexAttrib2fvNV = loopback_VertexAttrib2fvNV;
+   dest->VertexAttrib2dvNV = loopback_VertexAttrib2dvNV;
+   dest->VertexAttrib3svNV = loopback_VertexAttrib3svNV;
+   dest->VertexAttrib3fvNV = loopback_VertexAttrib3fvNV;
+   dest->VertexAttrib3dvNV = loopback_VertexAttrib3dvNV;
+   dest->VertexAttrib4svNV = loopback_VertexAttrib4svNV;
+   dest->VertexAttrib4fvNV = loopback_VertexAttrib4fvNV;
+   dest->VertexAttrib4dvNV = loopback_VertexAttrib4dvNV;
+   dest->VertexAttrib4ubvNV = loopback_VertexAttrib4ubvNV;
+
+   dest->VertexAttribs1svNV = loopback_VertexAttribs1svNV;
+   dest->VertexAttribs1fvNV = loopback_VertexAttribs1fvNV;
+   dest->VertexAttribs1dvNV = loopback_VertexAttribs1dvNV;
+   dest->VertexAttribs2svNV = loopback_VertexAttribs2svNV;
+   dest->VertexAttribs2fvNV = loopback_VertexAttribs2fvNV;
+   dest->VertexAttribs2dvNV = loopback_VertexAttribs2dvNV;
+   dest->VertexAttribs3svNV = loopback_VertexAttribs3svNV;
+   dest->VertexAttribs3fvNV = loopback_VertexAttribs3fvNV;
+   dest->VertexAttribs3dvNV = loopback_VertexAttribs3dvNV;
+   dest->VertexAttribs4svNV = loopback_VertexAttribs4svNV;
+   dest->VertexAttribs4fvNV = loopback_VertexAttribs4fvNV;
+   dest->VertexAttribs4dvNV = loopback_VertexAttribs4dvNV;
+   dest->VertexAttribs4ubvNV = loopback_VertexAttribs4ubvNV;
 }
diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c
index 58a6e7d771..b603b74f5e 100644
--- a/src/mesa/main/api_noop.c
+++ b/src/mesa/main/api_noop.c
@@ -1,8 +1,8 @@
-/* $Id: api_noop.c,v 1.8 2001/04/28 08:39:17 keithw Exp $ */
+/* $Id: api_noop.c,v 1.9 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -58,13 +58,13 @@ void _mesa_noop_EdgeFlagv( const GLboolean *b )
 void _mesa_noop_FogCoordfEXT( GLfloat a )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Current.FogCoord = a;
+   ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = a;
 }
 
 void _mesa_noop_FogCoordfvEXT( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Current.FogCoord = *v;
+   ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = *v;
 }
 
 void _mesa_noop_Indexi( GLint i )
@@ -82,7 +82,7 @@ void _mesa_noop_Indexiv( const GLint *v )
 void _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Normal;
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
    COPY_FLOAT(dest[0], a);
    COPY_FLOAT(dest[1], b);
    COPY_FLOAT(dest[2], c);
@@ -91,7 +91,7 @@ void _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c )
 void _mesa_noop_Normal3fv( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Normal;
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
    COPY_FLOAT(dest[0], v[0]);
    COPY_FLOAT(dest[1], v[1]);
    COPY_FLOAT(dest[2], v[2]);
@@ -155,7 +155,7 @@ void _mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
 void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = UBYTE_TO_FLOAT(a);
    color[1] = UBYTE_TO_FLOAT(b);
    color[2] = UBYTE_TO_FLOAT(c);
@@ -165,7 +165,7 @@ void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
 void _mesa_noop_Color4ubv( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = UBYTE_TO_FLOAT(v[0]);
    color[1] = UBYTE_TO_FLOAT(v[1]);
    color[2] = UBYTE_TO_FLOAT(v[2]);
@@ -175,7 +175,7 @@ void _mesa_noop_Color4ubv( const GLubyte *v )
 void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = a;
    color[1] = b;
    color[2] = c;
@@ -185,7 +185,7 @@ void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
 void _mesa_noop_Color4fv( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = v[0];
    color[1] = v[1];
    color[2] = v[2];
@@ -195,7 +195,7 @@ void _mesa_noop_Color4fv( const GLfloat *v )
 void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = UBYTE_TO_FLOAT(a);
    color[1] = UBYTE_TO_FLOAT(b);
    color[2] = UBYTE_TO_FLOAT(c);
@@ -205,7 +205,7 @@ void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c )
 void _mesa_noop_Color3ubv( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = UBYTE_TO_FLOAT(v[0]);
    color[1] = UBYTE_TO_FLOAT(v[1]);
    color[2] = UBYTE_TO_FLOAT(v[2]);
@@ -215,7 +215,7 @@ void _mesa_noop_Color3ubv( const GLubyte *v )
 void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = a;
    color[1] = b;
    color[2] = c;
@@ -225,7 +225,7 @@ void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
 void _mesa_noop_Color3fv( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.Color;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
    color[0] = v[0];
    color[1] = v[1];
    color[2] = v[2];
@@ -241,7 +241,7 @@ void _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], a);
       dest[1] = 0;
       dest[2] = 0;
@@ -258,7 +258,7 @@ void _mesa_noop_MultiTexCoord1fvARB( GLenum target, GLfloat *v )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], v[0]);
       dest[1] = 0;
       dest[2] = 0;
@@ -275,7 +275,7 @@ void _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, GLfloat b )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], a);
       COPY_FLOAT(dest[1], b);
       dest[2] = 0;
@@ -292,7 +292,7 @@ void _mesa_noop_MultiTexCoord2fvARB( GLenum target, GLfloat *v )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], v[0]);
       COPY_FLOAT(dest[1], v[1]);
       dest[2] = 0;
@@ -309,7 +309,7 @@ void _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, GLfloat b, GLfloat
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], a);
       COPY_FLOAT(dest[1], b);
       COPY_FLOAT(dest[2], c);
@@ -326,7 +326,7 @@ void _mesa_noop_MultiTexCoord3fvARB( GLenum target, GLfloat *v )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], v[0]);
       COPY_FLOAT(dest[1], v[1]);
       COPY_FLOAT(dest[2], v[2]);
@@ -344,7 +344,7 @@ void _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, GLfloat b,
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], a);
       COPY_FLOAT(dest[1], b);
       COPY_FLOAT(dest[2], c);
@@ -361,7 +361,7 @@ void _mesa_noop_MultiTexCoord4fvARB( GLenum target, GLfloat *v )
     */
    if (unit < MAX_TEXTURE_UNITS)
    {
-      GLfloat *dest = ctx->Current.Texcoord[unit];
+      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
       COPY_FLOAT(dest[0], v[0]);
       COPY_FLOAT(dest[1], v[1]);
       COPY_FLOAT(dest[2], v[2]);
@@ -372,7 +372,7 @@ void _mesa_noop_MultiTexCoord4fvARB( GLenum target, GLfloat *v )
 void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.SecondaryColor;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
    color[0] = UBYTE_TO_FLOAT(a);
    color[1] = UBYTE_TO_FLOAT(b);
    color[2] = UBYTE_TO_FLOAT(c);
@@ -382,7 +382,7 @@ void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c )
 void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.SecondaryColor;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
    color[0] = UBYTE_TO_FLOAT(v[0]);
    color[1] = UBYTE_TO_FLOAT(v[1]);
    color[2] = UBYTE_TO_FLOAT(v[2]);
@@ -392,7 +392,7 @@ void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v )
 void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.SecondaryColor;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
    color[0] = a;
    color[1] = b;
    color[2] = c;
@@ -402,7 +402,7 @@ void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
 void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *color = ctx->Current.SecondaryColor;
+   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
    color[0] = v[0];
    color[1] = v[1];
    color[2] = v[2];
@@ -412,7 +412,7 @@ void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
 void _mesa_noop_TexCoord1f( GLfloat a )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], a);
    dest[1] = 0;
    dest[2] = 0;
@@ -422,7 +422,7 @@ void _mesa_noop_TexCoord1f( GLfloat a )
 void _mesa_noop_TexCoord1fv( GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], v[0]);
    dest[1] = 0;
    dest[2] = 0;
@@ -432,7 +432,7 @@ void _mesa_noop_TexCoord1fv( GLfloat *v )
 void _mesa_noop_TexCoord2f( GLfloat a, GLfloat b )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], a);
    COPY_FLOAT(dest[1], b);
    dest[2] = 0;
@@ -442,7 +442,7 @@ void _mesa_noop_TexCoord2f( GLfloat a, GLfloat b )
 void _mesa_noop_TexCoord2fv( GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], v[0]);
    COPY_FLOAT(dest[1], v[1]);
    dest[2] = 0;
@@ -452,7 +452,7 @@ void _mesa_noop_TexCoord2fv( GLfloat *v )
 void _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], a);
    COPY_FLOAT(dest[1], b);
    COPY_FLOAT(dest[2], c);
@@ -462,7 +462,7 @@ void _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c )
 void _mesa_noop_TexCoord3fv( GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], v[0]);
    COPY_FLOAT(dest[1], v[1]);
    COPY_FLOAT(dest[2], v[2]);
@@ -472,7 +472,7 @@ void _mesa_noop_TexCoord3fv( GLfloat *v )
 void _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], a);
    COPY_FLOAT(dest[1], b);
    COPY_FLOAT(dest[2], c);
@@ -482,13 +482,32 @@ void _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
 void _mesa_noop_TexCoord4fv( GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat *dest = ctx->Current.Texcoord[0];
+   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
    COPY_FLOAT(dest[0], v[0]);
    COPY_FLOAT(dest[1], v[1]);
    COPY_FLOAT(dest[2], v[2]);
    COPY_FLOAT(dest[3], v[3]);
 }
 
+void _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
+                                  GLfloat y, GLfloat z, GLfloat w )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index < 16) {
+      ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w);
+   }
+}
+
+void _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index < 16) {
+      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]);
+   }
+}
+
+
+
 /* Execute a glRectf() function.  This is not suitable for GL_COMPILE
  * modes (as the test for outside begin/end is not compiled),
  * but may be useful for drivers in circumstances which exclude
diff --git a/src/mesa/main/api_noop.h b/src/mesa/main/api_noop.h
index c80179d293..14fb9fcc2b 100644
--- a/src/mesa/main/api_noop.h
+++ b/src/mesa/main/api_noop.h
@@ -1,8 +1,8 @@
-/* $Id: api_noop.h,v 1.3 2001/03/12 00:48:37 gareth Exp $ */
+/* $Id: api_noop.h,v 1.4 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -116,6 +116,12 @@ extern void _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d );
 
 extern void _mesa_noop_TexCoord4fv( GLfloat *v );
 
+extern void _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
+                                         GLfloat y, GLfloat z, GLfloat w );
+
+extern void _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v );
+
+
 
 /* Not strictly a noop -- translate Rectf down to Begin/End and
  * vertices.  Closer to the loopback operations, but doesn't meet the
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index 01a913955a..8b49cd4e96 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -1,4 +1,4 @@
-/* $Id: attrib.c,v 1.57 2001/09/18 15:27:18 kschultz Exp $ */
+/* $Id: attrib.c,v 1.58 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -240,6 +240,10 @@ _mesa_PushAttrib(GLbitfield mask)
          attr->Texture[i] = ctx->Texture.Unit[i].Enabled;
          attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;
       }
+      /* GL_NV_vertex_program */
+      attr->VertexProgram = ctx->VertexProgram.Enabled;
+      attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled;
+      attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled;
       newnode = new_attrib_node( GL_ENABLE_BIT );
       newnode->data = attr;
       newnode->next = head;
@@ -537,6 +541,17 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable)
    TEST_AND_UPDATE(ctx->Multisample.SampleCoverageInvert,
                    enable->SampleCoverageInvert,
                    GL_SAMPLE_COVERAGE_INVERT_ARB);
+   /* GL_NV_vertex_program */
+   TEST_AND_UPDATE(ctx->VertexProgram.Enabled,
+                   enable->VertexProgram,
+                   GL_VERTEX_PROGRAM_NV);
+   TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled,
+                   enable->VertexProgramPointSize,
+                   GL_VERTEX_PROGRAM_POINT_SIZE_NV);
+   TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled,
+                   enable->VertexProgramTwoSide,
+                   GL_VERTEX_PROGRAM_TWO_SIDE_NV);
+
 #undef TEST_AND_UPDATE
 
    /* texture unit enables */
diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 230af9c564..1f87a13fe6 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -1,8 +1,8 @@
-/* $Id: context.c,v 1.149 2001/11/06 15:53:00 brianp Exp $ */
+/* $Id: context.c,v 1.150 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -53,7 +53,6 @@
 #include "mtypes.h"
 #include "varray.h"
 #include "vtxfmt.h"
-
 #include "math/m_translate.h"
 #include "math/m_vertices.h"
 #include "math/m_matrix.h"
@@ -89,6 +88,8 @@ int MESA_DEBUG_FLAGS = 0
 ;
 #endif
 
+
+
 /**********************************************************************/
 /*****       OpenGL SI-style interface (new in Mesa 3.5)          *****/
 /**********************************************************************/
@@ -477,6 +478,37 @@ one_time_init( void )
 }
 
 
+static void
+init_matrix_stack( struct matrix_stack *stack,
+                   GLuint maxDepth, GLuint dirtyFlag )
+{
+   GLuint i;
+
+   stack->Depth = 0;
+   stack->MaxDepth = maxDepth;
+   stack->DirtyFlag = dirtyFlag;
+   /* Top matrix */
+   _math_matrix_ctr( &stack->Top );
+   _math_matrix_alloc_inv( &stack->Top );
+   /* The stack */
+   stack->Stack = MALLOC(maxDepth * sizeof(GLmatrix));
+   for (i = 0; i < maxDepth; i++) {
+      _math_matrix_ctr(&stack->Stack[i]);
+      _math_matrix_alloc_inv(&stack->Stack[i]);
+   }
+}
+
+
+static void
+free_matrix_stack( struct matrix_stack *stack )
+{
+   GLuint i;
+   _math_matrix_dtr( &stack->Top );
+   for (i = 0; i < stack->MaxDepth; i++) {
+      _math_matrix_dtr(&stack->Stack[i]);
+   }
+}
+
 
 /*
  * Allocate and initialize a shared context state structure.
@@ -768,6 +800,9 @@ init_attrib_groups( GLcontext *ctx )
       _math_matrix_ctr( &ctx->ModelViewStack[i] );
       _math_matrix_alloc_inv( &ctx->ModelViewStack[i] );
    }
+#if 1
+   init_matrix_stack(&ctx->ModelviewStack, 32, _NEW_MODELVIEW);
+#endif
 
    /* Projection matrix - need inv for user clipping in clip space*/
    _math_matrix_ctr( &ctx->ProjectionMatrix );
@@ -828,10 +863,16 @@ init_attrib_groups( GLcontext *ctx )
    ctx->Color.MultiDrawBuffer = GL_FALSE;
 
    /* Current group */
-   ASSIGN_4V( ctx->Current.Color, 1.0, 1.0, 1.0, 1.0 );
+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 0.0 );
+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
+   for (i = 0; i < MAX_TEXTURE_UNITS; i++)
+      ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], 0.0, 0.0, 0.0, 1.0 );
    ctx->Current.Index = 1;
-   for (i=0; i<MAX_TEXTURE_UNITS; i++)
-      ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
+   ctx->Current.EdgeFlag = GL_TRUE;
+   
    ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
    ctx->Current.RasterDistance = 0.0;
    ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
@@ -840,8 +881,6 @@ init_attrib_groups( GLcontext *ctx )
       ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
    ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
    ctx->Current.RasterPosValid = GL_TRUE;
-   ctx->Current.EdgeFlag = GL_TRUE;
-   ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
 
 
    /* Depth buffer group */
@@ -1279,6 +1318,17 @@ init_attrib_groups( GLcontext *ctx )
    _mesa_init_colortable(&ctx->PostColorMatrixColorTable);
    _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
 
+   /* GL_NV_vertex_program */
+   ctx->VertexProgram.Binding = 0;
+   ctx->VertexProgram.HashTable = _mesa_NewHashTable();
+   ctx->VertexProgram.Enabled = GL_FALSE;
+   ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
+   ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
+   for (i = 0; i < VP_NUM_PROG_REGS / 4; i++) {
+      ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
+      ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
+   }
+
    /* Miscellaneous */
    ctx->NewState = _NEW_ALL;
    ctx->RenderMode = GL_RENDER;
@@ -1600,6 +1650,10 @@ _mesa_free_context_data( GLcontext *ctx )
       _mesa_make_current(NULL, NULL);
    }
 
+#if 1
+   free_matrix_stack(&ctx->ModelviewStack);
+#endif
+
    _math_matrix_dtr( &ctx->ModelView );
    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
       _math_matrix_dtr( &ctx->ModelViewStack[i] );
@@ -1690,6 +1744,9 @@ _mesa_free_context_data( GLcontext *ctx )
 
    _mesa_extensions_dtr(ctx);
 
+   /* GL_NV_vertex_program */
+   _mesa_DeleteHashTable(ctx->VertexProgram.HashTable);
+
    FREE(ctx->Exec);
    FREE(ctx->Save);
 }
@@ -1971,21 +2028,6 @@ _mesa_warning( const GLcontext *ctx, const char *s )
 
 
 /*
- * Compile an error into current display list.
- */
-void
-_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
-{
-   if (ctx->CompileFlag)
-      _mesa_save_error( ctx, error, s );
-
-   if (ctx->ExecuteFlag)
-      _mesa_error( ctx, error, s );
-}
-
-
-
-/*
  * This is Mesa's error handler.  Normally, all that's done is the updating
  * of the current error value.  If Mesa is compiled with -DDEBUG or if the
  * environment variable "MESA_DEBUG" is defined then a real error message
diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h
index 3d56ada053..e0bb2ad09f 100644
--- a/src/mesa/main/context.h
+++ b/src/mesa/main/context.h
@@ -1,8 +1,8 @@
-/* $Id: context.h,v 1.27 2001/05/03 14:11:18 brianp Exp $ */
+/* $Id: context.h,v 1.28 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -204,9 +204,6 @@ _mesa_warning( const GLcontext *ctx, const char *s );
 extern void
 _mesa_error( GLcontext *ctx, GLenum error, const char *s );
 
-extern void
-_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s );
-
 
 
 extern void
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index 52707e14f4..f22aa94319 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -1,4 +1,4 @@
-/* $Id: dd.h,v 1.64 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: dd.h,v 1.65 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -696,6 +696,9 @@ typedef struct {
    void (*CallList)( GLuint );	/* NOTE */
    void (*Begin)( GLenum );
    void (*End)( void );
+   void (*VertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+   void (*VertexAttrib4fvNV)( GLuint index, const GLfloat *v );
+
    /* Drivers present a reduced set of the functions possible in
     * begin/end objects.  Core mesa provides translation stubs for the
     * remaining functions to map down to these entrypoints.
diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c
index 050373aee7..bb2c68d0d0 100644
--- a/src/mesa/main/dlist.c
+++ b/src/mesa/main/dlist.c
@@ -1,4 +1,4 @@
-/* $Id: dlist.c,v 1.80 2001/12/13 19:58:20 kschultz Exp $ */
+/* $Id: dlist.c,v 1.81 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -4049,6 +4049,21 @@ _mesa_save_error( GLcontext *ctx, GLenum error, const char *s )
 }
 
 
+/*
+ * Compile an error into current display list.
+ */
+void
+_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
+{
+   if (ctx->CompileFlag)
+      _mesa_save_error( ctx, error, s );
+
+   if (ctx->ExecuteFlag)
+      _mesa_error( ctx, error, s );
+}
+
+
+
 static GLboolean
 islist(GLcontext *ctx, GLuint list)
 {
diff --git a/src/mesa/main/dlist.h b/src/mesa/main/dlist.h
index 2994cf73d0..6671620d47 100644
--- a/src/mesa/main/dlist.h
+++ b/src/mesa/main/dlist.h
@@ -1,8 +1,8 @@
-/* $Id: dlist.h,v 1.16 2001/03/24 06:01:27 gareth Exp $ */
+/* $Id: dlist.h,v 1.17 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -83,19 +83,20 @@ extern void _mesa_ListBase( GLuint base );
 
 extern void _mesa_NewList( GLuint list, GLenum mode );
 
-extern void _mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize );
+extern void _mesa_init_dlist_table( struct _glapi_table *table,
+                                    GLuint tableSize );
 
 extern void _mesa_save_error( GLcontext *ctx, GLenum error, const char *s );
 
+extern void _mesa_compile_error( GLcontext *ctx, GLenum error, const char *s );
 
-void *
-_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz );
 
-int
-_mesa_alloc_opcode( GLcontext *ctx, GLuint sz,
-		    void (*execute)( GLcontext *, void * ),
-		    void (*destroy)( GLcontext *, void * ),
-		    void (*print)( GLcontext *, void * ) );
+extern void *_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz );
+
+extern int _mesa_alloc_opcode( GLcontext *ctx, GLuint sz,
+                               void (*execute)( GLcontext *, void * ),
+                               void (*destroy)( GLcontext *, void * ),
+                               void (*print)( GLcontext *, void * ) );
 
 extern void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2,
 				 GLint j1, GLint j2 );
diff --git a/src/mesa/main/drawpix.c b/src/mesa/main/drawpix.c
index f605ae1624..ac1c68af5e 100644
--- a/src/mesa/main/drawpix.c
+++ b/src/mesa/main/drawpix.c
@@ -1,4 +1,4 @@
-/* $Id: drawpix.c,v 1.57 2001/12/13 19:12:42 brianp Exp $ */
+/* $Id: drawpix.c,v 1.58 2001/12/14 02:55:08 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -71,13 +71,14 @@ _mesa_DrawPixels( GLsizei width, GLsizei height,
 			     &ctx->Unpack, pixels);
    }
    else if (ctx->RenderMode==GL_FEEDBACK) {
+      /* Feedback the current raster pos info */
       if (ctx->Current.RasterPosValid) {
-	 FLUSH_CURRENT(ctx, 0);
+	 FLUSH_CURRENT( ctx, 0 );
          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
          _mesa_feedback_vertex( ctx,
 				ctx->Current.RasterPos,
 				ctx->Current.RasterColor,
-				ctx->Current.RasterIndex, 
+				ctx->Current.RasterIndex,
 				ctx->Current.RasterTexCoord );
       }
    }
@@ -146,13 +147,13 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
    }
    else if (ctx->RenderMode == GL_FEEDBACK) {
       if (ctx->Current.RasterPosValid) {
-	 FLUSH_CURRENT(ctx, 0);
+         FLUSH_CURRENT( ctx, 0 );
          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
-         _mesa_feedback_vertex( ctx,
-				ctx->Current.RasterPos,
-				ctx->Current.RasterColor,
-				ctx->Current.RasterIndex, 
-				ctx->Current.RasterTexCoord );
+         _mesa_feedback_vertex( ctx, 
+                                ctx->Current.RasterPos,
+                                ctx->Current.RasterColor,
+                                ctx->Current.RasterIndex,
+                                ctx->Current.RasterTexCoord );
       }
    }
    else if (ctx->RenderMode == GL_SELECT) {
diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index a1adf1de82..758426d0e4 100644
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -1,4 +1,4 @@
-/* $Id: enable.c,v 1.50 2001/06/26 01:32:48 brianp Exp $ */
+/* $Id: enable.c,v 1.51 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -37,13 +37,20 @@
 #include "simple_list.h"
 #include "mtypes.h"
 #include "enums.h"
-
 #include "math/m_matrix.h"
 #include "math/m_xform.h"
-
 #endif
 
 
+#define CHECK_EXTENSION(EXTNAME)					\
+   if (!ctx->Extensions.EXTNAME) {					\
+      _mesa_error(ctx, GL_INVALID_ENUM,					\
+         state ? "glEnableClientState": "glDisableClientState");	\
+      return;								\
+   }
+
+
+
 static void
 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
 {
@@ -51,41 +58,66 @@ client_state( GLcontext *ctx, GLenum cap, GLboolean state )
    GLboolean *var;
 
    switch (cap) {
-   case GL_VERTEX_ARRAY:
-      var = &ctx->Array.Vertex.Enabled;
-      flag = _NEW_ARRAY_VERTEX;
-      break;
-   case GL_NORMAL_ARRAY:
-      var = &ctx->Array.Normal.Enabled;
-      flag = _NEW_ARRAY_NORMAL;
-      break;
-   case GL_COLOR_ARRAY:
-      var = &ctx->Array.Color.Enabled;
-      flag = _NEW_ARRAY_COLOR;
-      break;
-   case GL_INDEX_ARRAY:
-      var = &ctx->Array.Index.Enabled;
-      flag = _NEW_ARRAY_INDEX;
-      break;
-   case GL_TEXTURE_COORD_ARRAY:
-      var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
-      flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
-      break;
-   case GL_EDGE_FLAG_ARRAY:
-      var = &ctx->Array.EdgeFlag.Enabled;
-      flag = _NEW_ARRAY_EDGEFLAG;
-      break;
-   case GL_FOG_COORDINATE_ARRAY_EXT:
-      var = &ctx->Array.FogCoord.Enabled;
-      flag = _NEW_ARRAY_FOGCOORD;
-      break;
-   case GL_SECONDARY_COLOR_ARRAY_EXT:
-      var = &ctx->Array.SecondaryColor.Enabled;
-      flag = _NEW_ARRAY_SECONDARYCOLOR;
-      break;
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
-      return;
+      case GL_VERTEX_ARRAY:
+         var = &ctx->Array.Vertex.Enabled;
+         flag = _NEW_ARRAY_VERTEX;
+         break;
+      case GL_NORMAL_ARRAY:
+         var = &ctx->Array.Normal.Enabled;
+         flag = _NEW_ARRAY_NORMAL;
+         break;
+      case GL_COLOR_ARRAY:
+         var = &ctx->Array.Color.Enabled;
+         flag = _NEW_ARRAY_COLOR0;
+         break;
+      case GL_INDEX_ARRAY:
+         var = &ctx->Array.Index.Enabled;
+         flag = _NEW_ARRAY_INDEX;
+         break;
+      case GL_TEXTURE_COORD_ARRAY:
+         var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
+         flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
+         break;
+      case GL_EDGE_FLAG_ARRAY:
+         var = &ctx->Array.EdgeFlag.Enabled;
+         flag = _NEW_ARRAY_EDGEFLAG;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         var = &ctx->Array.FogCoord.Enabled;
+         flag = _NEW_ARRAY_FOGCOORD;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         var = &ctx->Array.SecondaryColor.Enabled;
+         flag = _NEW_ARRAY_COLOR1;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         {
+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            var = &ctx->Array.VertexAttrib[n].Enabled;
+            flag = _NEW_ARRAY_VERT_ATTRIB0;  /* XXX flag OK? */
+         }
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
+         return;
    }
 
    if (*var == flag)
@@ -126,6 +158,15 @@ _mesa_DisableClientState( GLenum cap )
 }
 
 
+#undef CHECK_EXTENSION
+#define CHECK_EXTENSION(EXTNAME)			\
+   if (!ctx->Extensions.EXTNAME) {			\
+      _mesa_error(ctx, GL_INVALID_ENUM,			\
+                  state ? "glEnable": "glDisable");	\
+      return;						\
+   }
+
+
 /*
  * Perform glEnable and glDisable calls.
  */
@@ -138,680 +179,686 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 	      ctx->NewState);
 
    switch (cap) {
-   case GL_ALPHA_TEST:
-      if (ctx->Color.AlphaEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.AlphaEnabled = state;
-      break;
-   case GL_AUTO_NORMAL:
-      if (ctx->Eval.AutoNormal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.AutoNormal = state;
-      break;
-   case GL_BLEND:
-      if (ctx->Color.BlendEnabled == state)
-	 return;
-
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.BlendEnabled = state;
-      /* The following needed to accomodate 1.0 RGB logic op blending */
-      ctx->Color.ColorLogicOpEnabled =
-	 (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
-      break;
-   case GL_CLIP_PLANE0:
-   case GL_CLIP_PLANE1:
-   case GL_CLIP_PLANE2:
-   case GL_CLIP_PLANE3:
-   case GL_CLIP_PLANE4:
-   case GL_CLIP_PLANE5: {
-      GLuint p = cap-GL_CLIP_PLANE0;
-
-      if (ctx->Transform.ClipEnabled[p] == state)
-	 return;
-
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.ClipEnabled[p] = state;
-
-      if (state) {
-	 ctx->Transform._AnyClip++;
-
-	 if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
-	    _math_matrix_analyse( &ctx->ProjectionMatrix );
-	 }
-
-	 /* This derived state also calculated in clip.c and
-	  * from _mesa_update_state() on changes to EyeUserPlane
-	  * and ctx->ProjectionMatrix respectively.
-	  */
-	 _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
-			      ctx->Transform.EyeUserPlane[p],
-			      ctx->ProjectionMatrix.inv );
+      case GL_ALPHA_TEST:
+         if (ctx->Color.AlphaEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.AlphaEnabled = state;
+         break;
+      case GL_AUTO_NORMAL:
+         if (ctx->Eval.AutoNormal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.AutoNormal = state;
+         break;
+      case GL_BLEND:
+         if (ctx->Color.BlendEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.BlendEnabled = state;
+         /* The following needed to accomodate 1.0 RGB logic op blending */
+         ctx->Color.ColorLogicOpEnabled =
+            (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
+         break;
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+         {
+            GLuint p = cap-GL_CLIP_PLANE0;
+
+            if (ctx->Transform.ClipEnabled[p] == state)
+               return;
+
+            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+            ctx->Transform.ClipEnabled[p] = state;
+
+            if (state) {
+               ctx->Transform._AnyClip++;
+
+               if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
+                  _math_matrix_analyse( &ctx->ProjectionMatrix );
+               }
+
+               /* This derived state also calculated in clip.c and
+                * from _mesa_update_state() on changes to EyeUserPlane
+                * and ctx->ProjectionMatrix respectively.
+                */
+               _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+                                    ctx->Transform.EyeUserPlane[p],
+                                    ctx->ProjectionMatrix.inv );
+            }
+         }
+         break;
+      case GL_COLOR_MATERIAL:
+         if (ctx->Light.ColorMaterialEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.ColorMaterialEnabled = state;
+         if (state) {
+            FLUSH_CURRENT(ctx, 0);
+            _mesa_update_color_material( ctx,
+                                  ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
+         }
+         break;
+      case GL_CULL_FACE:
+         if (ctx->Polygon.CullFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.CullFlag = state;
+         break;
+      case GL_DEPTH_TEST:
+         if (state && ctx->Visual.depthBits==0) {
+            _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
+            return;
+         }
+         if (ctx->Depth.Test==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_DEPTH);
+         ctx->Depth.Test = state;
+         break;
+      case GL_DITHER:
+         if (ctx->NoDither) {
+            state = GL_FALSE; /* MESA_NO_DITHER env var */
+         }
+         if (ctx->Color.DitherFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.DitherFlag = state;
+         break;
+      case GL_FOG:
+         if (ctx->Fog.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.Enabled = state;
+         break;
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION(EXT_histogram);
+         if (ctx->Pixel.HistogramEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.HistogramEnabled = state;
+         break;
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+         if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
+         if (state) {
+            insert_at_tail(&ctx->Light.EnabledList,
+                           &ctx->Light.Light[cap-GL_LIGHT0]);
+         }
+         else {
+            remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
+         }
+         break;
+      case GL_LIGHTING:
+         if (ctx->Light.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.Enabled = state;
+
+         if ((ctx->Light.Enabled &&
+              ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+             || ctx->Fog.ColorSumEnabled)
+            ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+         else
+            ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+         break;
+      case GL_LINE_SMOOTH:
+         if (ctx->Line.SmoothFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LINE);
+         ctx->Line.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
+         break;
+      case GL_LINE_STIPPLE:
+         if (ctx->Line.StippleFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LINE);
+         ctx->Line.StippleFlag = state;
+         ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
+         break;
+      case GL_INDEX_LOGIC_OP:
+         if (ctx->Color.IndexLogicOpEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.IndexLogicOpEnabled = state;
+         break;
+      case GL_COLOR_LOGIC_OP:
+         if (ctx->Color.ColorLogicOpEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.ColorLogicOpEnabled = state;
+         break;
+      case GL_MAP1_COLOR_4:
+         if (ctx->Eval.Map1Color4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Color4 = state;
+         break;
+      case GL_MAP1_INDEX:
+         if (ctx->Eval.Map1Index == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Index = state;
+         break;
+      case GL_MAP1_NORMAL:
+         if (ctx->Eval.Map1Normal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Normal = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_1:
+         if (ctx->Eval.Map1TextureCoord1 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord1 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_2:
+         if (ctx->Eval.Map1TextureCoord2 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord2 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_3:
+         if (ctx->Eval.Map1TextureCoord3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord3 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_4:
+         if (ctx->Eval.Map1TextureCoord4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord4 = state;
+         break;
+      case GL_MAP1_VERTEX_3:
+         if (ctx->Eval.Map1Vertex3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Vertex3 = state;
+         break;
+      case GL_MAP1_VERTEX_4:
+         if (ctx->Eval.Map1Vertex4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Vertex4 = state;
+         break;
+      case GL_MAP2_COLOR_4:
+         if (ctx->Eval.Map2Color4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Color4 = state;
+         break;
+      case GL_MAP2_INDEX:
+         if (ctx->Eval.Map2Index == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Index = state;
+         break;
+      case GL_MAP2_NORMAL:
+         if (ctx->Eval.Map2Normal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Normal = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_1:
+         if (ctx->Eval.Map2TextureCoord1 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord1 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_2:
+         if (ctx->Eval.Map2TextureCoord2 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord2 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_3:
+         if (ctx->Eval.Map2TextureCoord3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord3 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_4:
+         if (ctx->Eval.Map2TextureCoord4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord4 = state;
+         break;
+      case GL_MAP2_VERTEX_3:
+         if (ctx->Eval.Map2Vertex3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Vertex3 = state;
+         break;
+      case GL_MAP2_VERTEX_4:
+         if (ctx->Eval.Map2Vertex4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Vertex4 = state;
+         break;
+      case GL_MINMAX:
+         if (ctx->Pixel.MinMaxEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.MinMaxEnabled = state;
+         break;
+      case GL_NORMALIZE:
+         if (ctx->Transform.Normalize == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.Normalize = state;
+         break;
+      case GL_POINT_SMOOTH:
+         if (ctx->Point.SmoothFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POINT);
+         ctx->Point.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
+         break;
+      case GL_POLYGON_SMOOTH:
+         if (ctx->Polygon.SmoothFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
+         break;
+      case GL_POLYGON_STIPPLE:
+         if (ctx->Polygon.StippleFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.StippleFlag = state;
+         ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
+         break;
+      case GL_POLYGON_OFFSET_POINT:
+         if (ctx->Polygon.OffsetPoint==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetPoint = state;
+         break;
+      case GL_POLYGON_OFFSET_LINE:
+         if (ctx->Polygon.OffsetLine==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetLine = state;
+         break;
+      case GL_POLYGON_OFFSET_FILL:
+         /*case GL_POLYGON_OFFSET_EXT:*/
+         if (ctx->Polygon.OffsetFill==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetFill = state;
+         break;
+      case GL_RESCALE_NORMAL_EXT:
+         if (ctx->Transform.RescaleNormals == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.RescaleNormals = state;
+         break;
+      case GL_SCISSOR_TEST:
+         if (ctx->Scissor.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_SCISSOR);
+         ctx->Scissor.Enabled = state;
+         break;
+      case GL_SHARED_TEXTURE_PALETTE_EXT:
+         if (ctx->Texture.SharedPalette == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         ctx->Texture.SharedPalette = state;
+         break;
+      case GL_STENCIL_TEST:
+         if (state && ctx->Visual.stencilBits==0) {
+            _mesa_warning(ctx,
+                          "glEnable(GL_STENCIL_TEST) but no stencil buffer");
+            return;
+         }
+         if (ctx->Stencil.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_STENCIL);
+         ctx->Stencil.Enabled = state;
+         break;
+      case GL_TEXTURE_1D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
+         if (state)
+            newenabled |= TEXTURE0_1D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-   }
-   break;
-   case GL_COLOR_MATERIAL:
-      if (ctx->Light.ColorMaterialEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.ColorMaterialEnabled = state;
-      if (state) {
-	 FLUSH_CURRENT(ctx, 0);
-	 _mesa_update_color_material( ctx, ctx->Current.Color );
+      case GL_TEXTURE_2D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
+         if (state)
+            newenabled |= TEXTURE0_2D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-      break;
-   case GL_CULL_FACE:
-      if (ctx->Polygon.CullFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.CullFlag = state;
-      break;
-   case GL_DEPTH_TEST:
-      if (state && ctx->Visual.depthBits==0) {
-	 _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
-	 return;
+      case GL_TEXTURE_3D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
+         if (state)
+            newenabled |= TEXTURE0_3D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-      if (ctx->Depth.Test==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_DEPTH);
-      ctx->Depth.Test = state;
-      break;
-   case GL_DITHER:
-      if (ctx->NoDither) {
-	 state = GL_FALSE; /* MESA_NO_DITHER env var */
+      case GL_TEXTURE_GEN_Q: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
+         if (state)
+            newenabled |= Q_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Color.DitherFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.DitherFlag = state;
-      break;
-   case GL_FOG:
-      if (ctx->Fog.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_FOG);
-      ctx->Fog.Enabled = state;
-      break;
-   case GL_HISTOGRAM:
-      if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, "glEnable(GL_HISTOGRAM)");
-	 return;
+      case GL_TEXTURE_GEN_R: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
+         if (state)
+            newenabled |= R_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Pixel.HistogramEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.HistogramEnabled = state;
       break;
-   case GL_LIGHT0:
-   case GL_LIGHT1:
-   case GL_LIGHT2:
-   case GL_LIGHT3:
-   case GL_LIGHT4:
-   case GL_LIGHT5:
-   case GL_LIGHT6:
-   case GL_LIGHT7:
-      if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
-      if (state) {
-	 insert_at_tail(&ctx->Light.EnabledList,
-			&ctx->Light.Light[cap-GL_LIGHT0]);
-      }
-      else {
-	 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
+      case GL_TEXTURE_GEN_S: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
+         if (state)
+            newenabled |= S_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
       break;
-   case GL_LIGHTING:
-      if (ctx->Light.Enabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.Enabled = state;
-
-      if ((ctx->Light.Enabled &&
-	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
-	  || ctx->Fog.ColorSumEnabled)
-	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-      else
-	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
-
-      break;
-   case GL_LINE_SMOOTH:
-      if (ctx->Line.SmoothFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LINE);
-      ctx->Line.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
-      break;
-   case GL_LINE_STIPPLE:
-      if (ctx->Line.StippleFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LINE);
-      ctx->Line.StippleFlag = state;
-      ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
-      break;
-   case GL_INDEX_LOGIC_OP:
-      if (ctx->Color.IndexLogicOpEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.IndexLogicOpEnabled = state;
-      break;
-   case GL_COLOR_LOGIC_OP:
-      if (ctx->Color.ColorLogicOpEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.ColorLogicOpEnabled = state;
-      break;
-   case GL_MAP1_COLOR_4:
-      if (ctx->Eval.Map1Color4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Color4 = state;
-      break;
-   case GL_MAP1_INDEX:
-      if (ctx->Eval.Map1Index == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Index = state;
-      break;
-   case GL_MAP1_NORMAL:
-      if (ctx->Eval.Map1Normal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Normal = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_1:
-      if (ctx->Eval.Map1TextureCoord1 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord1 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_2:
-      if (ctx->Eval.Map1TextureCoord2 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord2 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_3:
-      if (ctx->Eval.Map1TextureCoord3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord3 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_4:
-      if (ctx->Eval.Map1TextureCoord4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord4 = state;
-      break;
-   case GL_MAP1_VERTEX_3:
-      if (ctx->Eval.Map1Vertex3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Vertex3 = state;
-      break;
-   case GL_MAP1_VERTEX_4:
-      if (ctx->Eval.Map1Vertex4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Vertex4 = state;
-      break;
-   case GL_MAP2_COLOR_4:
-      if (ctx->Eval.Map2Color4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Color4 = state;
-      break;
-   case GL_MAP2_INDEX:
-      if (ctx->Eval.Map2Index == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Index = state;
-      break;
-   case GL_MAP2_NORMAL:
-      if (ctx->Eval.Map2Normal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Normal = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_1:
-      if (ctx->Eval.Map2TextureCoord1 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord1 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_2:
-      if (ctx->Eval.Map2TextureCoord2 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord2 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_3:
-      if (ctx->Eval.Map2TextureCoord3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord3 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_4:
-      if (ctx->Eval.Map2TextureCoord4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord4 = state;
-      break;
-   case GL_MAP2_VERTEX_3:
-      if (ctx->Eval.Map2Vertex3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Vertex3 = state;
-      break;
-   case GL_MAP2_VERTEX_4:
-      if (ctx->Eval.Map2Vertex4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Vertex4 = state;
-      break;
-   case GL_MINMAX:
-      if (ctx->Pixel.MinMaxEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.MinMaxEnabled = state;
-      break;
-   case GL_NORMALIZE:
-      if (ctx->Transform.Normalize == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.Normalize = state;
-      break;
-   case GL_POINT_SMOOTH:
-      if (ctx->Point.SmoothFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POINT);
-      ctx->Point.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
-      break;
-   case GL_POLYGON_SMOOTH:
-      if (ctx->Polygon.SmoothFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
-      break;
-   case GL_POLYGON_STIPPLE:
-      if (ctx->Polygon.StippleFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.StippleFlag = state;
-      ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
-      break;
-   case GL_POLYGON_OFFSET_POINT:
-      if (ctx->Polygon.OffsetPoint==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetPoint = state;
-      break;
-   case GL_POLYGON_OFFSET_LINE:
-      if (ctx->Polygon.OffsetLine==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetLine = state;
-      break;
-   case GL_POLYGON_OFFSET_FILL:
-      /*case GL_POLYGON_OFFSET_EXT:*/
-      if (ctx->Polygon.OffsetFill==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetFill = state;
-      break;
-   case GL_RESCALE_NORMAL_EXT:
-      if (ctx->Transform.RescaleNormals == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.RescaleNormals = state;
-      break;
-   case GL_SCISSOR_TEST:
-      if (ctx->Scissor.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_SCISSOR);
-      ctx->Scissor.Enabled = state;
-      break;
-   case GL_SHARED_TEXTURE_PALETTE_EXT:
-      if (ctx->Texture.SharedPalette == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      ctx->Texture.SharedPalette = state;
-      break;
-   case GL_STENCIL_TEST:
-      if (state && ctx->Visual.stencilBits==0) {
-	 _mesa_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
-	 return;
+      case GL_TEXTURE_GEN_T: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
+         if (state)
+            newenabled |= T_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Stencil.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.Enabled = state;
       break;
-   case GL_TEXTURE_1D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
-      if (state)
-	 newenabled |= TEXTURE0_1D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_2D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
-      if (state)
-	 newenabled |= TEXTURE0_2D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_3D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
-      if (state)
-	 newenabled |= TEXTURE0_3D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_GEN_Q: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
-      if (state)
-	 newenabled |= Q_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_GEN_R: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
-      if (state)
-	 newenabled |= R_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-   case GL_TEXTURE_GEN_S: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
-      if (state)
-	 newenabled |= S_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-   case GL_TEXTURE_GEN_T: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
-      if (state)
-	 newenabled |= T_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-
-   /*
-    * CLIENT STATE!!!
-    */
-   case GL_VERTEX_ARRAY:
-   case GL_NORMAL_ARRAY:
-   case GL_COLOR_ARRAY:
-   case GL_INDEX_ARRAY:
-   case GL_TEXTURE_COORD_ARRAY:
-   case GL_EDGE_FLAG_ARRAY:
-   case GL_FOG_COORDINATE_ARRAY_EXT:
-   case GL_SECONDARY_COLOR_ARRAY_EXT:
-      client_state( ctx, cap, state );
-      return;
+
+      /*
+       * CLIENT STATE!!!
+       */
+      case GL_VERTEX_ARRAY:
+      case GL_NORMAL_ARRAY:
+      case GL_COLOR_ARRAY:
+      case GL_INDEX_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         client_state( ctx, cap, state );
+         return;
 
       /* GL_HP_occlusion_test */
-   case GL_OCCLUSION_TEST_HP:
-      if (!ctx->Extensions.HP_occlusion_test) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Depth.OcclusionTest == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_DEPTH);
-      ctx->Depth.OcclusionTest = state;
-      if (state)
-	 ctx->OcclusionResult = ctx->OcclusionResultSaved;
-      else
-	 ctx->OcclusionResultSaved = ctx->OcclusionResult;
-      break;
+      case GL_OCCLUSION_TEST_HP:
+         CHECK_EXTENSION(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_DEPTH);
+         ctx->Depth.OcclusionTest = state;
+         if (state)
+            ctx->OcclusionResult = ctx->OcclusionResultSaved;
+         else
+            ctx->OcclusionResultSaved = ctx->OcclusionResult;
+         break;
 
       /* GL_SGIS_pixel_texture */
-   case GL_PIXEL_TEXTURE_SGIS:
-      if (!ctx->Extensions.SGIS_pixel_texture) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PixelTextureEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PixelTextureEnabled = state;
-      break;
+      case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION(SGIS_pixel_texture);
+         if (ctx->Pixel.PixelTextureEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PixelTextureEnabled = state;
+         break;
 
       /* GL_SGIX_pixel_texture */
-   case GL_PIXEL_TEX_GEN_SGIX:
-      if (!ctx->Extensions.SGIX_pixel_texture) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PixelTextureEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PixelTextureEnabled = state;
-      break;
+      case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION(SGIX_pixel_texture);
+         if (ctx->Pixel.PixelTextureEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PixelTextureEnabled = state;
+         break;
 
       /* GL_SGI_color_table */
-   case GL_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.ColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.ColorTableEnabled = state;
-      break;
-   case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PostConvolutionColorTableEnabled = state;
-      break;
-   case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PostColorMatrixColorTableEnabled = state;
-      break;
+      case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.ColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.ColorTableEnabled = state;
+         break;
+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PostConvolutionColorTableEnabled = state;
+         break;
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PostColorMatrixColorTableEnabled = state;
+         break;
 
       /* GL_EXT_convolution */
-   case GL_CONVOLUTION_1D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Convolution1DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Convolution1DEnabled = state;
-      break;
-   case GL_CONVOLUTION_2D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Convolution2DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Convolution2DEnabled = state;
-      break;
-   case GL_SEPARABLE_2D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Separable2DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Separable2DEnabled = state;
-      break;
+      case GL_CONVOLUTION_1D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Convolution1DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Convolution1DEnabled = state;
+         break;
+      case GL_CONVOLUTION_2D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Convolution2DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Convolution2DEnabled = state;
+         break;
+      case GL_SEPARABLE_2D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Separable2DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Separable2DEnabled = state;
+         break;
 
       /* GL_ARB_texture_cube_map */
-   case GL_TEXTURE_CUBE_MAP_ARB: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
-      if (state)
-	 newenabled |= TEXTURE0_CUBE;
-      if (!ctx->Extensions.ARB_texture_cube_map) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-      /* GL_EXT_secondary_color */
-   case GL_COLOR_SUM_EXT:
-      if (!ctx->Extensions.EXT_secondary_color) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Fog.ColorSumEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_FOG);
-      ctx->Fog.ColorSumEnabled = state;
-
-      if ((ctx->Light.Enabled &&
-	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
-	  || ctx->Fog.ColorSumEnabled)
-	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-      else
-	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         {
+            const GLuint curr = ctx->Texture.CurrentUnit;
+            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+            GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
+            CHECK_EXTENSION(ARB_texture_cube_map);
+            if (state)
+               newenabled |= TEXTURE0_CUBE;
+            if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+               return;
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texUnit->Enabled = newenabled;
+         }
+         break;
 
-      break;
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION(EXT_secondary_color);
+         if (ctx->Fog.ColorSumEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.ColorSumEnabled = state;
+
+         if ((ctx->Light.Enabled &&
+              ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+             || ctx->Fog.ColorSumEnabled)
+            ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+         else
+            ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+         break;
 
       /* GL_ARB_multisample */
-   case GL_MULTISAMPLE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.Enabled == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.Enabled = state;
-      break;
-   case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleAlphaToCoverage == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleAlphaToCoverage = state;
-      break;
-   case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleAlphaToOne == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleAlphaToOne = state;
-      break;
-   case GL_SAMPLE_COVERAGE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleCoverage == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleCoverage = state;
-      break;
-   case GL_SAMPLE_COVERAGE_INVERT_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleCoverageInvert == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleCoverageInvert = state;
-      break;
+      case GL_MULTISAMPLE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.Enabled = state;
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleAlphaToCoverage == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleAlphaToCoverage = state;
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleAlphaToOne == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleAlphaToOne = state;
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleCoverage == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleCoverage = state;
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleCoverageInvert == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleCoverageInvert = state;
+         break;
 
       /* GL_IBM_rasterpos_clip */
-   case GL_RASTER_POSITION_UNCLIPPED_IBM:
-      if (!ctx->Extensions.IBM_rasterpos_clip) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Transform.RasterPositionUnclipped == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.RasterPositionUnclipped = state;
-      break;
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION(IBM_rasterpos_clip);
+         if (ctx->Transform.RasterPositionUnclipped == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.RasterPositionUnclipped = state;
+         break;
 
       /* GL_MESA_sprite_point */
-   case GL_SPRITE_POINT_MESA:
-      if (!ctx->Extensions.MESA_sprite_point) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Point.SpriteMode == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POINT);
-      ctx->Point.SpriteMode = state;
-      break;
+      case GL_SPRITE_POINT_MESA:
+         CHECK_EXTENSION(MESA_sprite_point);
+         if (ctx->Point.SpriteMode == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POINT);
+         ctx->Point.SpriteMode = state;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.Enabled = state;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.PointSizeEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.PointSizeEnabled = state;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.TwoSideEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.TwoSideEnabled = state;
+         break;
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         break;
+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         break;
 
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-      return;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
    }
 
    if (ctx->Driver.Enable) {
@@ -843,6 +890,13 @@ _mesa_Disable( GLenum cap )
 }
 
 
+#undef CHECK_EXTENSION
+#define CHECK_EXTENSION(EXTNAME)			\
+   if (!ctx->Extensions.EXTNAME) {			\
+      _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");	\
+      return GL_FALSE;					\
+   }
+
 
 GLboolean
 _mesa_IsEnabled( GLenum cap )
@@ -872,14 +926,6 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Color.DitherFlag;
       case GL_FOG:
 	 return ctx->Fog.Enabled;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            return ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
       case GL_LIGHTING:
          return ctx->Light.Enabled;
       case GL_LIGHT0:
@@ -935,8 +981,6 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Eval.Map2Vertex3;
       case GL_MAP2_VERTEX_4:
 	 return ctx->Eval.Map2Vertex4;
-      case GL_MINMAX:
-         return ctx->Pixel.MinMaxEnabled;
       case GL_NORMALIZE:
 	 return ctx->Transform.Normalize;
       case GL_POINT_SMOOTH:
@@ -962,37 +1006,44 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Stencil.Enabled;
       case GL_TEXTURE_1D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_2D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_3D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_Q:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_R:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_S:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_T:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
          }
 
@@ -1012,107 +1063,154 @@ _mesa_IsEnabled( GLenum cap )
       case GL_EDGE_FLAG_ARRAY:
          return ctx->Array.EdgeFlag.Enabled;
 
+      /* GL_EXT_histogram */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION(EXT_histogram);
+         return ctx->Pixel.HistogramEnabled;
+      case GL_MINMAX:
+         CHECK_EXTENSION(EXT_histogram);
+         return ctx->Pixel.MinMaxEnabled;
+
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            return ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(HP_occlusion_test);
+         return ctx->Depth.OcclusionTest;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION(SGIS_pixel_texture);
          return ctx->Pixel.PixelTextureEnabled;
 
       /* GL_SGIX_pixel_texture */
       case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION(SGIX_pixel_texture);
          return ctx->Pixel.PixelTextureEnabled;
 
       /* GL_SGI_color_table */
       case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.ColorTableEnabled;
       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.PostConvolutionColorTableEnabled;
       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.PostColorMatrixColorTableEnabled;
 
       /* GL_EXT_convolution */
       case GL_CONVOLUTION_1D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Convolution1DEnabled;
       case GL_CONVOLUTION_2D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Convolution2DEnabled;
       case GL_SEPARABLE_2D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Separable2DEnabled;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map) {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         CHECK_EXTENSION(ARB_texture_cube_map);
+         {
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
          }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.Enabled;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleAlphaToCoverage;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleAlphaToOne;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleCoverage;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleCoverageInvert;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            return ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(IBM_rasterpos_clip);
+         return ctx->Transform.RasterPositionUnclipped;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
          return ctx->Point.SpriteMode;
 
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.Enabled;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.PointSizeEnabled;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.TwoSideEnabled;
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         {
+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            return ctx->Array.VertexAttrib[n].Enabled;
+         }
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return GL_FALSE;
+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return GL_FALSE;
+
       default:
 	 _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
 	 return GL_FALSE;
diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c
index 75bbb05281..ee8eb4f538 100644
--- a/src/mesa/main/extensions.c
+++ b/src/mesa/main/extensions.c
@@ -1,4 +1,4 @@
-/* $Id: extensions.c,v 1.67 2001/12/04 23:44:55 brianp Exp $ */
+/* $Id: extensions.c,v 1.68 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -112,6 +112,7 @@ static struct {
    { ON,  "GL_MESA_window_pos",                F(MESA_window_pos) },
    { OFF, "GL_NV_blend_square",                F(NV_blend_square) },
    { ON,  "GL_NV_texgen_reflection",           F(NV_texgen_reflection) },
+   { OFF, "GL_NV_vertex_program",              F(NV_vertex_program) },
    { OFF, "GL_SGI_color_matrix",               F(SGI_color_matrix) },
    { OFF, "GL_SGI_color_table",                F(SGI_color_table) },
    { OFF, "GL_SGIS_generate_mipmap",           F(SGIS_generate_mipmap) },
@@ -170,6 +171,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
       "GL_MESA_resize_buffers",
       "GL_NV_blend_square",
       "GL_NV_texgen_reflection",
+      "GL_NV_vertex_program",
       "GL_SGI_color_matrix",
       "GL_SGI_color_table",
       "GL_SGIS_generate_mipmap",
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index 2e51305601..a6a4d12d4c 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -1,4 +1,4 @@
-/* $Id: get.c,v 1.73 2001/12/04 23:44:56 brianp Exp $ */
+/* $Id: get.c,v 1.74 2001/12/14 02:55:08 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -59,6 +59,34 @@
 #endif
 
 
+/* Check if named extension is enabled, if not generate error and return */
+
+#define CHECK_EXTENSION_B(EXTNAME)				\
+   if (!ctx->Extensions.EXTNAME) {				\
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetBooleanv");	\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_I(EXTNAME)				\
+   if (!ctx->Extensions.EXTNAME) {				\
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetIntegerv");	\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_F(EXTNAME)				\
+   if (!ctx->Extensions.EXTNAME) {				\
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetFloatv");	\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_D(EXTNAME)				\
+   if (!ctx->Extensions.EXTNAME) {				\
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetDoublev");	\
+      return;							\
+   }	
+
+
+
 
 static GLenum
 pixel_texgen_mode(const GLcontext *ctx)
@@ -231,10 +259,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_CURRENT_COLOR:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Color[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Color[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Color[2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.Color[3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
          break;
       case GL_CURRENT_INDEX:
 	 FLUSH_CURRENT(ctx, 0);
@@ -242,9 +270,9 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_CURRENT_NORMAL:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
          break;
       case GL_CURRENT_RASTER_COLOR:
 	 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
@@ -275,10 +303,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
 	 break;
       case GL_DEPTH_BIAS:
          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
@@ -363,15 +391,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_GREEN_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
 	 break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram) {
-            *params = ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
-	 break;
       case GL_INDEX_BITS:
          *params = INT_TO_BOOL( ctx->Visual.indexBits );
 	 break;
@@ -595,9 +614,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 	 params[0] = INT_TO_BOOL(MAX_WIDTH);
 	 params[1] = INT_TO_BOOL(MAX_HEIGHT);
 	 break;
-      case GL_MINMAX:
-         *params = ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
 	 for (i=0;i<16;i++) {
 	    params[i] = FLOAT_TO_BOOL(ctx->ModelView.m[i]);
@@ -983,47 +999,34 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-         return;
+         CHECK_EXTENSION_B(ARB_texture_cube_map);
+         *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-         return;
+         CHECK_EXTENSION_B(ARB_texture_cube_map);
+         *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name);
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_cube_map);
+         *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1));
          break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = INT_TO_BOOL(ctx->Hint.TextureCompression);
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_compression);
+         *params = INT_TO_BOOL(ctx->Hint.TextureCompression);
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = INT_TO_BOOL(ctx->Const.NumCompressedTextureFormats);
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_compression);
+         *params = INT_TO_BOOL(ctx->Const.NumCompressedTextureFormats);
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_B(ARB_texture_compression);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = INT_TO_BOOL(ctx->Const.CompressedTextureFormats[i]);
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
 
       /* GL_EXT_compiled_vertex_array */
@@ -1078,26 +1081,18 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-         }
+         CHECK_EXTENSION_B(HP_occlusion_test);
+         *params = ctx->Depth.OcclusionTest;
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = ctx->OcclusionResult;
-            else
-               *params = ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-         }
+         CHECK_EXTENSION_B(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest)
+            *params = ctx->OcclusionResult;
+         else
+            *params = ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
          return;
 
       /* GL_SGIS_pixel_texture */
@@ -1152,63 +1147,68 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution);
+         *params = ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution);
+         *params = ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution);
+         *params = ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = INT_TO_BOOL(ctx->Const.MaxConvolutionWidth);
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = INT_TO_BOOL(ctx->Const.MaxConvolutionHeight);
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[0]);
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[1]);
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[2]);
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[3]);
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[0]);
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[1]);
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_B(EXT_histogram);
+         *params = ctx->Pixel.HistogramEnabled;
+	 break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_B(EXT_histogram);
+         *params = ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = ctx->Pixel.ColorTableEnabled;
@@ -1222,39 +1222,49 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
 	 *params = ctx->Fog.ColorSumEnabled;
 	 break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = INT_TO_BOOL(ctx->Current.SecondaryColor[0]);
-         params[1] = INT_TO_BOOL(ctx->Current.SecondaryColor[1]);
-         params[2] = INT_TO_BOOL(ctx->Current.SecondaryColor[2]);
+         params[0] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
+         params[1] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
+         params[2] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
          *params = ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
 	 *params = ENUM_TO_BOOL(ctx->Array.SecondaryColor.Type);
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
 	 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color);
 	 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
 	 break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord);
 	 FLUSH_CURRENT(ctx, 0);
-	 *params = FLOAT_TO_BOOL(ctx->Current.FogCoord);
+	 *params = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
 	 break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord);
          *params = ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord);
 	 *params = ENUM_TO_BOOL(ctx->Array.FogCoord.Type);
 	 break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord);
 	 *params = INT_TO_BOOL(ctx->Array.FogCoord.Stride);
 	 break;
 
@@ -1265,120 +1275,160 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-	    *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy);
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_texture_filter_anisotropic);
+         *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy);
 	 break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = ctx->Multisample.Enabled;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = ctx->Multisample.SampleAlphaToCoverage;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = ctx->Multisample.SampleAlphaToOne;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = ctx->Multisample.SampleCoverage;
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue);
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = ctx->Multisample.SampleCoverageInvert;
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = 0; /* XXX fix someday */
          break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample);
+         *params = 0; /* XXX fix someday */
          break;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            *params = ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBoolean");
-            return;
-         }
+         CHECK_EXTENSION_B(IBM_rasterpos_clip);
+         *params = ctx->Transform.RasterPositionUnclipped;
          break;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-            return;
-         }
+         CHECK_EXTENSION_B(MESA_sprite_point);
+         *params = ctx->Point.SpriteMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-	    return;
-         }
+         CHECK_EXTENSION_B(SGIS_generate_mipmap);
+         *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap);
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = VP_MAX_MATRIX_DEPTH;
+         break;
+      case GL_MAX_TRACK_MATRICES_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = VP_MAX_MATRICES;
+         break;
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = ctx->VertexProgram.Enabled;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = ctx->VertexProgram.PointSizeEnabled;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = ctx->VertexProgram.TwoSideEnabled;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = 0;
+         break;
+      case GL_CURRENT_MATRIX_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = 0;
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = 0;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         *params = 0;
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         {
+            GLuint n = (GLint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            *params = ctx->Array.VertexAttrib[n].Enabled;
+         }
+         break;
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         _mesa_problem(ctx, "glGetBoolean NV token not implemented");
+         *params = 0;
+         break;
+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION_B(NV_vertex_program);
+         _mesa_problem(ctx, "glGetBoolean NV token not implemented");
+         *params = 0;
          break;
 
       default:
@@ -1535,10 +1585,10 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          break;
       case GL_CURRENT_COLOR:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.Color[0]);
-         params[1] = (ctx->Current.Color[1]);
-         params[2] = (ctx->Current.Color[2]);
-         params[3] = (ctx->Current.Color[3]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
          break;
       case GL_CURRENT_INDEX:
 	 FLUSH_CURRENT(ctx, 0);
@@ -1546,9 +1596,9 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          break;
       case GL_CURRENT_NORMAL:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (GLdouble) ctx->Current.Normal[0];
-         params[1] = (GLdouble) ctx->Current.Normal[1];
-         params[2] = (GLdouble) ctx->Current.Normal[2];
+         params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
+         params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
+         params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
          break;
       case GL_CURRENT_RASTER_COLOR:
 	 params[0] = (GLdouble) ctx->Current.RasterColor[0];
@@ -1579,10 +1629,10 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
 	 FLUSH_CURRENT(ctx, 0);
-	 params[0] = (GLdouble) ctx->Current.Texcoord[texUnit][0];
-	 params[1] = (GLdouble) ctx->Current.Texcoord[texUnit][1];
-	 params[2] = (GLdouble) ctx->Current.Texcoord[texUnit][2];
-	 params[3] = (GLdouble) ctx->Current.Texcoord[texUnit][3];
+	 params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+	 params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+	 params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+	 params[3] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
 	 *params = (GLdouble) ctx->Pixel.DepthBias;
@@ -1667,15 +1717,6 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
       case GL_GREEN_SCALE:
          *params = (GLdouble) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
-	 break;
       case GL_INDEX_BITS:
          *params = (GLdouble) ctx->Visual.indexBits;
 	 break;
@@ -1899,9 +1940,6 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          params[0] = (GLdouble) MAX_WIDTH;
          params[1] = (GLdouble) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
 	 for (i=0;i<16;i++) {
 	    params[i] = (GLdouble) ctx->ModelView.m[i];
@@ -2287,47 +2325,34 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map);
+         *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map);
+         *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map);
+         *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLdouble) ctx->Hint.TextureCompression;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+         CHECK_EXTENSION_D(ARB_texture_compression);
+         *params = (GLdouble) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+         CHECK_EXTENSION_D(ARB_texture_compression);
+         *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_D(ARB_texture_compression);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLdouble) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          break;
 
       /* GL_EXT_compiled_vertex_array */
@@ -2382,27 +2407,19 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLdouble) ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-         }
-         return;
+         CHECK_EXTENSION_D(HP_occlusion_test);
+         *params = (GLdouble) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLdouble) ctx->OcclusionResult;
-            else
-               *params = (GLdouble) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-         }
-         return;
+         CHECK_EXTENSION_D(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLdouble) ctx->OcclusionResult;
+         else
+            *params = (GLdouble) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
@@ -2456,63 +2473,68 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution);
+         *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution);
+         *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution);
+         *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_D(EXT_histogram);
+         *params = (GLdouble) ctx->Pixel.HistogramEnabled;
+	 break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_D(EXT_histogram);
+         *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = (GLdouble) ctx->Pixel.ColorTableEnabled;
@@ -2526,39 +2548,49 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
 	 *params = (GLdouble) ctx->Fog.ColorSumEnabled;
 	 break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.SecondaryColor[0]);
-         params[1] = (ctx->Current.SecondaryColor[1]);
-         params[2] = (ctx->Current.SecondaryColor[2]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
          *params = (GLdouble) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
 	 *params = (GLdouble) ctx->Array.SecondaryColor.Type;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
 	 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color);
 	 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
 	 break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord);
 	 FLUSH_CURRENT(ctx, 0);
-	 *params = (GLdouble) ctx->Current.FogCoord;
+	 *params = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 	 break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord);
          *params = (GLdouble) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord);
 	 *params = (GLdouble) ctx->Array.FogCoord.Type;
 	 break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord);
 	 *params = (GLdouble) ctx->Array.FogCoord.Stride;
 	 break;
 
@@ -2569,122 +2601,65 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-	    *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_texture_filter_anisotropic);
+         *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
 	 break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = (GLdouble) ctx->Multisample.Enabled;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = (GLdouble) ctx->Multisample.SampleCoverage;
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = ctx->Multisample.SampleCoverageValue;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = 0.0; /* XXX fix someday */
          break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample);
+         *params = 0.0; /* XXX fix someday */
          break;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            *params = (GLdouble) ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(IBM_rasterpos_clip);
+         *params = (GLdouble) ctx->Transform.RasterPositionUnclipped;
          break;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLdouble) ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-            return;
-         }
+         CHECK_EXTENSION_D(MESA_sprite_point);
+         *params = (GLdouble) ctx->Point.SpriteMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLdouble) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-	    return;
-         }
+         CHECK_EXTENSION_D(SGIS_generate_mipmap);
+         *params = (GLdouble) ctx->Hint.GenerateMipmap;
          break;
 
+      /* GL_NV_vertex_program */
+         /* to do */
+
       default:
          _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
    }
@@ -2846,10 +2821,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_CURRENT_COLOR:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.Color[0]);
-         params[1] = (ctx->Current.Color[1]);
-         params[2] = (ctx->Current.Color[2]);
-         params[3] = (ctx->Current.Color[3]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
          break;
       case GL_CURRENT_INDEX:
 	 FLUSH_CURRENT(ctx, 0);
@@ -2857,9 +2832,9 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_CURRENT_NORMAL:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = ctx->Current.Normal[0];
-         params[1] = ctx->Current.Normal[1];
-         params[2] = ctx->Current.Normal[2];
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
          break;
       case GL_CURRENT_RASTER_COLOR:
 	 params[0] = ctx->Current.RasterColor[0];
@@ -2890,10 +2865,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
 	 FLUSH_CURRENT(ctx, 0);
-	 params[0] = (GLfloat) ctx->Current.Texcoord[texUnit][0];
-	 params[1] = (GLfloat) ctx->Current.Texcoord[texUnit][1];
-	 params[2] = (GLfloat) ctx->Current.Texcoord[texUnit][2];
-	 params[3] = (GLfloat) ctx->Current.Texcoord[texUnit][3];
+	 params[0] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+	 params[1] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+	 params[2] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+	 params[3] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
 	 *params = (GLfloat) ctx->Pixel.DepthBias;
@@ -2978,15 +2953,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
       case GL_GREEN_SCALE:
          *params = (GLfloat) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
-	 break;
       case GL_INDEX_BITS:
          *params = (GLfloat) ctx->Visual.indexBits;
 	 break;
@@ -3210,9 +3176,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = (GLfloat) MAX_WIDTH;
          params[1] = (GLfloat) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
 	 for (i=0;i<16;i++) {
 	    params[i] = ctx->ModelView.m[i];
@@ -3600,54 +3563,43 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            GET_FLOAT_ERROR;
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map);
+         *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
-         else
-            GET_FLOAT_ERROR;
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map);
+         *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            GET_FLOAT_ERROR;
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map);
+         *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLfloat) ctx->Hint.TextureCompression;
-         }
-         else
-            GET_FLOAT_ERROR;
+         CHECK_EXTENSION_F(ARB_texture_compression);
+         *params = (GLfloat) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            GET_FLOAT_ERROR;
+         CHECK_EXTENSION_F(ARB_texture_compression);
+         *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_F(ARB_texture_compression);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLfloat) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            GET_FLOAT_ERROR;
          break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
+         CHECK_EXTENSION_F(EXT_compiled_vertex_array);
 	 *params = (GLfloat) ctx->Array.LockFirst;
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
+         CHECK_EXTENSION_F(EXT_compiled_vertex_array);
 	 *params = (GLfloat) ctx->Array.LockCount;
 	 break;
 
@@ -3667,27 +3619,19 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLfloat) ctx->Depth.OcclusionTest;
-         }
-         else {
-            GET_FLOAT_ERROR;
-         }
-         return;
+         CHECK_EXTENSION_F(HP_occlusion_test);
+         *params = (GLfloat) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLfloat) ctx->OcclusionResult;
-            else
-               *params = (GLfloat) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            GET_FLOAT_ERROR;
-         }
-         return;
+         CHECK_EXTENSION_F(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLfloat) ctx->OcclusionResult;
+         else
+            *params = (GLfloat) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
@@ -3741,63 +3685,68 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution);
+         *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution);
+         *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution);
+         *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution);
          *params = ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_F(EXT_histogram);
+         *params = (GLfloat) ctx->Pixel.HistogramEnabled;
+	 break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_F(EXT_histogram);
+         *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = (GLfloat) ctx->Pixel.ColorTableEnabled;
@@ -3811,39 +3760,49 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
 	 *params = (GLfloat) ctx->Fog.ColorSumEnabled;
 	 break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.SecondaryColor[0]);
-         params[1] = (ctx->Current.SecondaryColor[1]);
-         params[2] = (ctx->Current.SecondaryColor[2]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
          *params = (GLfloat) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
 	 *params = (GLfloat) ctx->Array.SecondaryColor.Type;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
 	 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color);
 	 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
 	 break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord);
 	 FLUSH_CURRENT(ctx, 0);
-	 *params = (GLfloat) ctx->Current.FogCoord;
+	 *params = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 	 break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord);
          *params = (GLfloat) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord);
 	 *params = (GLfloat) ctx->Array.FogCoord.Type;
 	 break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord);
 	 *params = (GLfloat) ctx->Array.FogCoord.Stride;
 	 break;
 
@@ -3854,122 +3813,65 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-	    *params = ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_texture_filter_anisotropic);
+         *params = ctx->Const.MaxTextureMaxAnisotropy;
 	 break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.Enabled;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = (GLfloat) ctx->Multisample.Enabled;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = (GLfloat) ctx->Multisample.SampleCoverage;
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = ctx->Multisample.SampleCoverageValue;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = 0.0; /* XXX fix someday */
          break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample);
+         *params = 0.0; /* XXX fix someday */
          break;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            *params = (GLfloat) ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(IBM_rasterpos_clip);
+         *params = (GLfloat) ctx->Transform.RasterPositionUnclipped;
          break;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLfloat) ctx->Point.SpriteMode;
-         }
-         else {
-            GET_FLOAT_ERROR;
-            return;
-         }
+         CHECK_EXTENSION_F(MESA_sprite_point);
+         *params = (GLfloat) ctx->Point.SpriteMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLfloat) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            GET_FLOAT_ERROR;
-	    return;
-         }
+         CHECK_EXTENSION_F(SGIS_generate_mipmap);
+         *params = (GLfloat) ctx->Hint.GenerateMipmap;
          break;
 
+      /* GL_NV_vertex_program */
+         /* to do */
+
       default:
          GET_FLOAT_ERROR;
    }
@@ -4126,10 +4028,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_CURRENT_COLOR:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( ( ctx->Current.Color[0] ) );
-         params[1] = FLOAT_TO_INT( ( ctx->Current.Color[1] ) );
-         params[2] = FLOAT_TO_INT( ( ctx->Current.Color[2] ) );
-         params[3] = FLOAT_TO_INT( ( ctx->Current.Color[3] ) );
+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+         params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
          break;
       case GL_CURRENT_INDEX:
 	 FLUSH_CURRENT(ctx, 0);
@@ -4137,9 +4039,9 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_CURRENT_NORMAL:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
-         params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
-         params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
          break;
       case GL_CURRENT_RASTER_COLOR:
 	 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
@@ -4170,10 +4072,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = (GLint) ctx->Current.Texcoord[texUnit][0];
-         params[1] = (GLint) ctx->Current.Texcoord[texUnit][1];
-         params[2] = (GLint) ctx->Current.Texcoord[texUnit][2];
-         params[3] = (GLint) ctx->Current.Texcoord[texUnit][3];
+         params[0] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+         params[1] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+         params[2] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+         params[3] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
          *params = (GLint) ctx->Pixel.DepthBias;
@@ -4258,15 +4160,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
       case GL_GREEN_SCALE:
          *params = (GLint) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
-	 break;
       case GL_INDEX_BITS:
          *params = (GLint) ctx->Visual.indexBits;
          break;
@@ -4490,9 +4383,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = (GLint) MAX_WIDTH;
          params[1] = (GLint) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLint) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
 	 for (i=0;i<16;i++) {
 	    params[i] = (GLint) ctx->ModelView.m[i];
@@ -4878,54 +4768,43 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map);
+         *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = textureUnit->CurrentCubeMap->Name;
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map);
+         *params = textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map);
+         *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLint) ctx->Hint.TextureCompression;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+         CHECK_EXTENSION_I(ARB_texture_compression);
+         *params = (GLint) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLint) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+         CHECK_EXTENSION_I(ARB_texture_compression);
+         *params = (GLint) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_I(ARB_texture_compression);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLint) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
+         CHECK_EXTENSION_I(EXT_compiled_vertex_array);
 	 *params = ctx->Array.LockFirst;
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
+         CHECK_EXTENSION_I(EXT_compiled_vertex_array);
 	 *params = ctx->Array.LockCount;
 	 break;
 
@@ -4973,205 +4852,209 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLint) ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
-         return;
+         CHECK_EXTENSION_I(HP_occlusion_test);
+         *params = (GLint) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLint) ctx->OcclusionResult;
-            else
-               *params = (GLint) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
-         return;
+         CHECK_EXTENSION_I(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLint) ctx->OcclusionResult;
+         else
+            *params = (GLint) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION_I(SGIS_pixel_texture);
          *params = (GLint) ctx->Pixel.PixelTextureEnabled;
          break;
 
       /* GL_SGIX_pixel_texture */
       case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION_I(SGIX_pixel_texture);
          *params = (GLint) ctx->Pixel.PixelTextureEnabled;
          break;
       case GL_PIXEL_TEX_GEN_MODE_SGIX:
+         CHECK_EXTENSION_I(SGIX_pixel_texture);
          *params = (GLint) pixel_texgen_mode(ctx);
          break;
 
       /* GL_SGI_color_matrix (also in 1.2 imaging) */
       case GL_COLOR_MATRIX_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          for (i=0;i<16;i++) {
 	    params[i] = (GLint) ctx->ColorMatrix.m[i];
 	 }
 	 break;
       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = ctx->ColorStackDepth + 1;
          break;
       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = MAX_COLOR_STACK_DEPTH;
          break;
       case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[0];
          break;
       case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[1];
          break;
       case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[2];
          break;
       case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[3];
          break;
       case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[0];
          break;
       case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[1];
          break;
       case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[2];
          break;
       case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[3];
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution);
+         *params = (GLint) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution);
+         *params = (GLint) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution);
+         *params = (GLint) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_I(EXT_histogram);
+         *params = (GLint) ctx->Pixel.HistogramEnabled;
+	 break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_I(EXT_histogram);
+         *params = (GLint) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table);
          *params = (GLint) ctx->Pixel.ColorTableEnabled;
          break;
       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table);
          *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled;
          break;
       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table);
          *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
 	 *params = (GLint) ctx->Fog.ColorSumEnabled;
 	 break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
 	 FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[0]) );
-         params[1] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[1]) );
-         params[2] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[2]) );
+         params[0] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]) );
+         params[1] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]) );
+         params[2] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]) );
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
          *params = (GLint) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
 	 *params = (GLint) ctx->Array.SecondaryColor.Type;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
 	 *params = (GLint) ctx->Array.SecondaryColor.Stride;
 	 break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color);
 	 *params = (GLint) ctx->Array.SecondaryColor.Stride;
 	 break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            FLUSH_CURRENT(ctx, 0);
-            *params = (GLint) ctx->Current.FogCoord;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord);
+         FLUSH_CURRENT(ctx, 0);
+         *params = (GLint) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 	 break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Enabled;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord);
+         *params = (GLint) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Type;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord);
+         *params = (GLint) ctx->Array.FogCoord.Type;
 	 break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Stride;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord);
+         *params = (GLint) ctx->Array.FogCoord.Stride;
 	 break;
 
       /* GL_EXT_texture_lod_bias */
@@ -5181,122 +5064,65 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-	    *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_texture_filter_anisotropic);
+         *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
 	 break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.Enabled;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.SampleAlphaToOne;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.SampleCoverage;
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.SampleCoverageValue;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = (GLint) ctx->Multisample.SampleCoverageInvert;
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = 0; /* XXX fix someday */
          break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample);
+         *params = 0; /* XXX fix someday */
          break;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            *params = (GLint) ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(IBM_rasterpos_clip);
+         *params = (GLint) ctx->Transform.RasterPositionUnclipped;
          break;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLint) ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-            return;
-         }
+         CHECK_EXTENSION_I(MESA_sprite_point);
+         *params = (GLint) ctx->Point.SpriteMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLint) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-	    return;
-         }
+         CHECK_EXTENSION_I(SGIS_generate_mipmap);
+         *params = (GLint) ctx->Hint.GenerateMipmap;
          break;
 
+      /* GL_NV_vertex_program */
+         /* to do */
+
       default:
          _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
    }
diff --git a/src/mesa/main/glprocs.h b/src/mesa/main/glprocs.h
index c91be5a030..bf573adfa0 100644
--- a/src/mesa/main/glprocs.h
+++ b/src/mesa/main/glprocs.h
@@ -688,5 +688,69 @@ static struct name_address_offset static_functions[] = {
    { "glWindowPos3fvARB", (GLvoid *) glWindowPos3fvARB, _gloffset_WindowPos3fvARB },
    { "glWindowPos3ivARB", (GLvoid *) glWindowPos3ivARB, _gloffset_WindowPos3ivARB },
    { "glWindowPos3svARB", (GLvoid *) glWindowPos3svARB, _gloffset_WindowPos3svARB },
+   { "glBindProgramNV", (GLvoid *) glBindProgramNV, _gloffset_BindProgramNV },
+   { "glDeleteProgramsNV", (GLvoid *) glDeleteProgramsNV, _gloffset_DeleteProgramsNV },
+   { "glExecuteProgramNV", (GLvoid *) glExecuteProgramNV, _gloffset_ExecuteProgramNV },
+   { "glGenProgramsNV", (GLvoid *) glGenProgramsNV, _gloffset_GenProgramsNV },
+   { "glAreProgramsResidentNV", (GLvoid *) glAreProgramsResidentNV, _gloffset_AreProgramsResidentNV },
+   { "glRequestResidentProgramsNV", (GLvoid *) glRequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV },
+   { "glGetProgramParameterfvNV", (GLvoid *) glGetProgramParameterfvNV, _gloffset_GetProgramParameterfvNV },
+   { "glGetProgramParameterdvNV", (GLvoid *) glGetProgramParameterdvNV, _gloffset_GetProgramParameterdvNV },
+   { "glGetProgramivNV", (GLvoid *) glGetProgramivNV, _gloffset_GetProgramivNV },
+   { "glGetProgramStringNV", (GLvoid *) glGetProgramStringNV, _gloffset_GetProgramStringNV },
+   { "glGetTrackMatrixivNV", (GLvoid *) glGetTrackMatrixivNV, _gloffset_GetTrackMatrixivNV },
+   { "glGetVertexAttribdvNV", (GLvoid *) glGetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV },
+   { "glGetVertexAttribfvNV", (GLvoid *) glGetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV },
+   { "glGetVertexAttribivNV", (GLvoid *) glGetVertexAttribivNV, _gloffset_GetVertexAttribivNV },
+   { "glGetVertexAttribPointervNV", (GLvoid *) glGetVertexAttribPointervNV, _gloffset_GetVertexAttribPointervNV },
+   { "glIsProgramNV", (GLvoid *) glIsProgramNV, _gloffset_IsProgramNV },
+   { "glLoadProgramNV", (GLvoid *) glLoadProgramNV, _gloffset_LoadProgramNV },
+   { "glProgramParameter4fNV", (GLvoid *) glProgramParameter4fNV, _gloffset_ProgramParameter4fNV },
+   { "glProgramParameter4dNV", (GLvoid *) glProgramParameter4dNV, _gloffset_ProgramParameter4dNV },
+   { "glProgramParameter4dvNV", (GLvoid *) glProgramParameter4dvNV, _gloffset_ProgramParameter4dvNV },
+   { "glProgramParameter4fvNV", (GLvoid *) glProgramParameter4fvNV, _gloffset_ProgramParameter4fvNV },
+   { "glProgramParameters4dvNV", (GLvoid *) glProgramParameters4dvNV, _gloffset_ProgramParameters4dvNV },
+   { "glProgramParameters4fvNV", (GLvoid *) glProgramParameters4fvNV, _gloffset_ProgramParameters4fvNV },
+   { "glTrackMatrixNV", (GLvoid *) glTrackMatrixNV, _gloffset_TrackMatrixNV },
+   { "glVertexAttribPointerNV", (GLvoid *) glVertexAttribPointerNV, _gloffset_VertexAttribPointerNV },
+   { "glVertexAttrib1sNV", (GLvoid *) glVertexAttrib1sNV, _gloffset_VertexAttrib1sNV },
+   { "glVertexAttrib1fNV", (GLvoid *) glVertexAttrib1fNV, _gloffset_VertexAttrib1fNV },
+   { "glVertexAttrib1dNV", (GLvoid *) glVertexAttrib1dNV, _gloffset_VertexAttrib1dNV },
+   { "glVertexAttrib2sNV", (GLvoid *) glVertexAttrib2sNV, _gloffset_VertexAttrib2sNV },
+   { "glVertexAttrib2fNV", (GLvoid *) glVertexAttrib2fNV, _gloffset_VertexAttrib2fNV },
+   { "glVertexAttrib2dNV", (GLvoid *) glVertexAttrib2dNV, _gloffset_VertexAttrib2dNV },
+   { "glVertexAttrib3sNV", (GLvoid *) glVertexAttrib3sNV, _gloffset_VertexAttrib3sNV },
+   { "glVertexAttrib3fNV", (GLvoid *) glVertexAttrib3fNV, _gloffset_VertexAttrib3fNV },
+   { "glVertexAttrib3dNV", (GLvoid *) glVertexAttrib3dNV, _gloffset_VertexAttrib3dNV },
+   { "glVertexAttrib4sNV", (GLvoid *) glVertexAttrib4sNV, _gloffset_VertexAttrib4sNV },
+   { "glVertexAttrib4fNV", (GLvoid *) glVertexAttrib4fNV, _gloffset_VertexAttrib4fNV },
+   { "glVertexAttrib4dNV", (GLvoid *) glVertexAttrib4dNV, _gloffset_VertexAttrib4dNV },
+   { "glVertexAttrib4ubNV", (GLvoid *) glVertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV },
+   { "glVertexAttrib1svNV", (GLvoid *) glVertexAttrib1svNV, _gloffset_VertexAttrib1svNV },
+   { "glVertexAttrib1fvNV", (GLvoid *) glVertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV },
+   { "glVertexAttrib1dvNV", (GLvoid *) glVertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV },
+   { "glVertexAttrib2svNV", (GLvoid *) glVertexAttrib2svNV, _gloffset_VertexAttrib2svNV },
+   { "glVertexAttrib2fvNV", (GLvoid *) glVertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV },
+   { "glVertexAttrib2dvNV", (GLvoid *) glVertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV },
+   { "glVertexAttrib3svNV", (GLvoid *) glVertexAttrib3svNV, _gloffset_VertexAttrib3svNV },
+   { "glVertexAttrib3fvNV", (GLvoid *) glVertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV },
+   { "glVertexAttrib3dvNV", (GLvoid *) glVertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV },
+   { "glVertexAttrib4svNV", (GLvoid *) glVertexAttrib4svNV, _gloffset_VertexAttrib4svNV },
+   { "glVertexAttrib4fvNV", (GLvoid *) glVertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV },
+   { "glVertexAttrib4dvNV", (GLvoid *) glVertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV },
+   { "glVertexAttrib4ubvNV", (GLvoid *) glVertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV },
+   { "glVertexAttribs1svNV", (GLvoid *) glVertexAttribs1svNV, _gloffset_VertexAttribs1svNV },
+   { "glVertexAttribs1fvNV", (GLvoid *) glVertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV },
+   { "glVertexAttribs1dvNV", (GLvoid *) glVertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV },
+   { "glVertexAttribs2svNV", (GLvoid *) glVertexAttribs2svNV, _gloffset_VertexAttribs2svNV },
+   { "glVertexAttribs2fvNV", (GLvoid *) glVertexAttribs2fvNV, _gloffset_VertexAttribs2fvNV },
+   { "glVertexAttribs2dvNV", (GLvoid *) glVertexAttribs2dvNV, _gloffset_VertexAttribs2dvNV },
+   { "glVertexAttribs3svNV", (GLvoid *) glVertexAttribs3svNV, _gloffset_VertexAttribs3svNV },
+   { "glVertexAttribs3fvNV", (GLvoid *) glVertexAttribs3fvNV, _gloffset_VertexAttribs3fvNV },
+   { "glVertexAttribs3dvNV", (GLvoid *) glVertexAttribs3dvNV, _gloffset_VertexAttribs3dvNV },
+   { "glVertexAttribs4svNV", (GLvoid *) glVertexAttribs4svNV, _gloffset_VertexAttribs4svNV },
+   { "glVertexAttribs4fvNV", (GLvoid *) glVertexAttribs4fvNV, _gloffset_VertexAttribs4fvNV },
+   { "glVertexAttribs4dvNV", (GLvoid *) glVertexAttribs4dvNV, _gloffset_VertexAttribs4dvNV },
+   { "glVertexAttribs4ubvNV", (GLvoid *) glVertexAttribs4ubvNV, _gloffset_VertexAttribs4ubvNV },
    { NULL, NULL }  /* end of list marker */
 };
diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c
index 8bd545035c..c5f741567d 100644
--- a/src/mesa/main/light.c
+++ b/src/mesa/main/light.c
@@ -1,4 +1,4 @@
-/* $Id: light.c,v 1.46 2001/09/18 16:16:21 kschultz Exp $ */
+/* $Id: light.c,v 1.47 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -881,7 +881,7 @@ _mesa_ColorMaterial( GLenum face, GLenum mode )
 
    if (ctx->Light.ColorMaterialEnabled) {
       FLUSH_CURRENT( ctx, 0 );
-      _mesa_update_color_material( ctx, ctx->Current.Color );
+      _mesa_update_color_material(ctx,ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
    }
 }
 
diff --git a/src/mesa/main/matrix.c b/src/mesa/main/matrix.c
index 4b510fefcd..763669e0c6 100644
--- a/src/mesa/main/matrix.c
+++ b/src/mesa/main/matrix.c
@@ -1,4 +1,4 @@
-/* $Id: matrix.c,v 1.36 2001/09/18 16:16:21 kschultz Exp $ */
+/* $Id: matrix.c,v 1.37 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -57,25 +57,38 @@
 /**********************************************************************/
 
 
-#define GET_ACTIVE_MATRIX(ctx, mat, flags, where)		\
+#define GET_ACTIVE_MATRIX(mat, where)					\
 do {									\
+   GLint n;								\
    if (MESA_VERBOSE&VERBOSE_API) fprintf(stderr, "%s\n", where);	\
    switch (ctx->Transform.MatrixMode) {					\
       case GL_MODELVIEW:						\
 	 mat = &ctx->ModelView;						\
-	 flags |= _NEW_MODELVIEW;					\
+	 ctx->NewState |= _NEW_MODELVIEW;				\
 	 break;								\
       case GL_PROJECTION:						\
 	 mat = &ctx->ProjectionMatrix;					\
-	 flags |= _NEW_PROJECTION;					\
+	 ctx->NewState |= _NEW_PROJECTION;				\
 	 break;								\
       case GL_TEXTURE:							\
 	 mat = &ctx->TextureMatrix[ctx->Texture.CurrentUnit];		\
-	 flags |= _NEW_TEXTURE_MATRIX;					\
+	 ctx->NewState |= _NEW_TEXTURE_MATRIX;				\
 	 break;								\
       case GL_COLOR:							\
 	 mat = &ctx->ColorMatrix;					\
-	 flags |= _NEW_COLOR_MATRIX;					\
+	 ctx->NewState |= _NEW_COLOR_MATRIX;				\
+	 break;								\
+      case GL_MATRIX0_NV:						\
+      case GL_MATRIX1_NV:						\
+      case GL_MATRIX2_NV:						\
+      case GL_MATRIX3_NV:						\
+      case GL_MATRIX4_NV:						\
+      case GL_MATRIX5_NV:						\
+      case GL_MATRIX6_NV:						\
+      case GL_MATRIX7_NV:						\
+	 n = ctx->Transform.MatrixMode - GL_MATRIX0_NV;			\
+	 mat = &ctx->VertexProgram.Matrix[n];				\
+	 ctx->NewState |= _NEW_TRACK_MATRIX;				\
 	 break;								\
       default:								\
          _mesa_problem(ctx, where);					\
@@ -92,7 +105,7 @@ _mesa_Frustum( GLdouble left, GLdouble right,
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glFrustrum" );
+   GET_ACTIVE_MATRIX(mat, "glFrustrum");
 
    if (nearval <= 0.0 ||
        farval <= 0.0 ||
@@ -119,7 +132,7 @@ _mesa_Ortho( GLdouble left, GLdouble right,
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glOrtho" );
+   GET_ACTIVE_MATRIX(mat, "glOrtho");
 
    if (left == right ||
        bottom == top ||
@@ -142,6 +155,19 @@ _mesa_MatrixMode( GLenum mode )
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (mode) {
+      case GL_MATRIX0_NV:
+      case GL_MATRIX1_NV:
+      case GL_MATRIX2_NV:
+      case GL_MATRIX3_NV:
+      case GL_MATRIX4_NV:
+      case GL_MATRIX5_NV:
+      case GL_MATRIX6_NV:
+      case GL_MATRIX7_NV:
+         if (!ctx->Extensions.NV_vertex_program) {
+            _mesa_error( ctx,  GL_INVALID_ENUM, "glMatrixMode" );
+            return;
+         }
+         /* FALL-THROUGH */
       case GL_MODELVIEW:
       case GL_PROJECTION:
       case GL_TEXTURE:
@@ -275,7 +301,7 @@ _mesa_LoadIdentity( void )
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glLoadIdentity");
+   GET_ACTIVE_MATRIX(mat, "glLoadIdentity");
    _math_matrix_set_identity( mat );
 }
 
@@ -286,7 +312,7 @@ _mesa_LoadMatrixf( const GLfloat *m )
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glLoadMatrix");
+   GET_ACTIVE_MATRIX(mat, "glLoadMatrix");
    _math_matrix_loadf( mat, m );
 }
 
@@ -312,7 +338,7 @@ _mesa_MultMatrixf( const GLfloat *m )
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glMultMatrix" );
+   GET_ACTIVE_MATRIX(mat, "glMultMatrix");
    _math_matrix_mul_floats( mat, m );
 }
 
@@ -343,7 +369,7 @@ _mesa_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    if (angle != 0.0F) {
       GLmatrix *mat = 0;
-      GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glRotate" );
+      GET_ACTIVE_MATRIX(mat, "glRotate");
       _math_matrix_rotate( mat, angle, x, y, z );
    }
 }
@@ -364,7 +390,7 @@ _mesa_Scalef( GLfloat x, GLfloat y, GLfloat z )
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glScale");
+   GET_ACTIVE_MATRIX(mat, "glScale");
    _math_matrix_scale( mat, x, y, z );
 }
 
@@ -385,7 +411,7 @@ _mesa_Translatef( GLfloat x, GLfloat y, GLfloat z )
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glTranslate");
+   GET_ACTIVE_MATRIX(mat, "glTranslate");
    _math_matrix_translate( mat, x, y, z );
 }
 
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 865978214d..32820178d4 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1,4 +1,4 @@
-/* $Id: mtypes.h,v 1.54 2001/12/04 23:44:56 brianp Exp $ */
+/* $Id: mtypes.h,v 1.55 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -63,7 +63,7 @@
 #define CHAN_MAXF 1.0F
 #define CHAN_TYPE GL_FLOAT
 #else
-#error  illegal number of color channel bits
+#error "illegal number of color channel bits"
 #endif
 
 
@@ -295,28 +295,46 @@ struct gl_colorbuffer_attrib {
 };
 
 
+/* These define the aliases between numbered vertex attributes and
+ * conventional OpenGL vertex attributes.
+ */
+#define VERT_ATTRIB_POS      0
+#define VERT_ATTRIB_WEIGHT   1
+#define VERT_ATTRIB_NORMAL   2
+#define VERT_ATTRIB_COLOR0   3
+#define VERT_ATTRIB_COLOR1   4
+#define VERT_ATTRIB_FOG      5
+#define VERT_ATTRIB_SIX      6
+#define VERT_ATTRIB_SEVEN    7
+#define VERT_ATTRIB_TEX0     8
+#define VERT_ATTRIB_TEX1     9
+#define VERT_ATTRIB_TEX2     10
+#define VERT_ATTRIB_TEX3     11
+#define VERT_ATTRIB_TEX4     12
+#define VERT_ATTRIB_TEX5     13
+#define VERT_ATTRIB_TEX6     14
+#define VERT_ATTRIB_TEX7     15
+
 struct gl_current_attrib {
    /* These values valid only when FLUSH_VERTICES has been called.
     */
-   GLfloat Normal[3];				/* Current vertex normal */
-   GLfloat Color[4];				/* Current RGBA color */
-   GLfloat SecondaryColor[4];			/* Current secondary color */
-   GLfloat FogCoord;			        /* Current Fog coord */
+   GLfloat Attrib[8 + MAX_TEXTURE_UNITS][4];	/* Current vertex attributes */
+						/* indexed by VERT_ATTRIB_* */
    GLuint Index;				/* Current color index */
    GLboolean EdgeFlag;				/* Current edge flag */
-   GLfloat Texcoord[MAX_TEXTURE_UNITS][4];	/* Current texture coords */
 
-   /* These values are always valid.
+   /* These values are always valid.  BTW, note how similar this set of
+    * attributes is to the SWvertex datatype in the software rasterizer...
     */
    GLfloat RasterPos[4];			/* Current raster position */
    GLfloat RasterDistance;			/* Current raster distance */
    GLfloat RasterColor[4];			/* Current raster color */
    GLfloat RasterSecondaryColor[4];             /* Current rast 2ndary color */
-   GLuint  RasterIndex;				/* Current raster index */
-   GLfloat *RasterTexCoord;			/* Current raster texcoord*/
+   GLuint RasterIndex;				/* Current raster index */
+   GLfloat *RasterTexCoord;			/* Current raster texcoord */
    GLfloat RasterMultiTexCoord[MAX_TEXTURE_UNITS][4];
    GLfloat RasterFogCoord;
-   GLboolean RasterPosValid;			/* Raster po valid flag */
+   GLboolean RasterPosValid;			/* Raster pos valid flag */
 };
 
 
@@ -387,6 +405,10 @@ struct gl_enable_attrib {
    GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
    GLuint Texture[MAX_TEXTURE_UNITS];
    GLuint TexGen[MAX_TEXTURE_UNITS];
+   /* GL_NV_vertex_program */
+   GLboolean VertexProgram;
+   GLboolean VertexProgramPointSize;
+   GLboolean VertexProgramTwoSide;
 };
 
 
@@ -475,6 +497,11 @@ struct gl_convolution_attrib {
 };
 
 
+#define LIGHT_SPOT         0x1
+#define LIGHT_LOCAL_VIEWER 0x2
+#define LIGHT_POSITIONAL   0x4
+#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
+
 struct gl_light_attrib {
    struct gl_light Light[MAX_LIGHTS];	/* Array of lights */
    struct gl_lightmodel Model;		/* Lighting model */
@@ -494,17 +521,11 @@ struct gl_light_attrib {
 
    /* Derived for optimizations: */
    GLboolean _NeedVertices;		/* Use fast shader? */
-   GLuint  _Flags;		        /* LIGHT_* flags, see below */
+   GLuint  _Flags;		        /* LIGHT_* flags, see above */
    GLfloat _BaseColor[2][3];
 };
 
 
-#define LIGHT_SPOT         0x1
-#define LIGHT_LOCAL_VIEWER 0x2
-#define LIGHT_POSITIONAL   0x4
-
-#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
-
 struct gl_line_attrib {
    GLboolean SmoothFlag;	/* GL_LINE_SMOOTH enabled? */
    GLboolean StippleFlag;	/* GL_LINE_STIPPLE enabled? */
@@ -519,6 +540,7 @@ struct gl_list_attrib {
    GLuint ListBase;
 };
 
+
 struct gl_list_opcode {
    GLuint size;
    void (*execute)( GLcontext *ctx, void *data );
@@ -1021,6 +1043,8 @@ struct gl_array_attrib {
    struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
    struct gl_client_array EdgeFlag;
 
+   struct gl_client_array VertexAttrib[16];  /* GL_NV_vertex_program */
+
    GLint TexCoordInterleaveFactor;
    GLint ActiveTexture;		/* Client Active Texture */
    GLuint LockFirst;
@@ -1103,6 +1127,158 @@ struct gl_evaluators {
 
 
 /*
+ * Vertex program tokens and datatypes
+ */
+
+#define VP_MAX_INSTRUCTIONS 128
+#define VP_MAX_MATRICES 8
+#define VP_MAX_MATRIX_DEPTH 4
+
+#define VP_NUM_INPUT_REGS 16
+#define VP_NUM_OUTPUT_REGS 15
+#define VP_NUM_TEMP_REGS 12
+#define VP_NUM_PROG_REGS 96
+
+#define VP_NUM_TOTAL_REGISTERS (VP_NUM_INPUT_REGS + VP_NUM_OUTPUT_REGS + VP_NUM_TEMP_REGS + VP_NUM_PROG_REGS)
+
+/* Location of register sets within the whole register file */
+#define VP_INPUT_REG_START  0
+#define VP_INPUT_REG_END    (VP_INPUT_REG_START + VP_NUM_INPUT_REGS - 1)
+#define VP_OUTPUT_REG_START (VP_INPUT_REG_END + 1)
+#define VP_OUTPUT_REG_END   (VP_OUTPUT_REG_START + VP_NUM_OUTPUT_REGS - 1)
+#define VP_TEMP_REG_START   (VP_OUTPUT_REG_END + 1)
+#define VP_TEMP_REG_END     (VP_TEMP_REG_START + VP_NUM_TEMP_REGS - 1)
+#define VP_PROG_REG_START   (VP_TEMP_REG_END + 1)
+#define VP_PROG_REG_END     (VP_PROG_REG_START + VP_NUM_PROG_REGS - 1)
+
+/* Input register names */
+#define VP_IN_OPOS (VP_INPUT_REG_START + 0)
+#define VP_IN_WGHT (VP_INPUT_REG_START + 1)
+#define VP_IN_NRML (VP_INPUT_REG_START + 2)
+#define VP_IN_COL0 (VP_INPUT_REG_START + 3)
+#define VP_IN_COL1 (VP_INPUT_REG_START + 4)
+#define VP_IN_FOGC (VP_INPUT_REG_START + 5)
+#define VP_IN_TEX0 (VP_INPUT_REG_START + 8)
+#define VP_IN_TEX1 (VP_INPUT_REG_START + 9)
+#define VP_IN_TEX2 (VP_INPUT_REG_START + 10)
+#define VP_IN_TEX3 (VP_INPUT_REG_START + 11)
+#define VP_IN_TEX4 (VP_INPUT_REG_START + 12)
+#define VP_IN_TEX5 (VP_INPUT_REG_START + 13)
+#define VP_IN_TEX6 (VP_INPUT_REG_START + 14)
+#define VP_IN_TEX7 (VP_INPUT_REG_START + 15)
+
+/* Output register names */
+#define VP_OUT_HPOS (VP_OUTPUT_REG_START + 0)
+#define VP_OUT_COL0 (VP_OUTPUT_REG_START + 1)
+#define VP_OUT_COL1 (VP_OUTPUT_REG_START + 2)
+#define VP_OUT_BFC0 (VP_OUTPUT_REG_START + 3)
+#define VP_OUT_BFC1 (VP_OUTPUT_REG_START + 4)
+#define VP_OUT_FOGC (VP_OUTPUT_REG_START + 5)
+#define VP_OUT_PSIZ (VP_OUTPUT_REG_START + 6)
+#define VP_OUT_TEX0 (VP_OUTPUT_REG_START + 7)
+#define VP_OUT_TEX1 (VP_OUTPUT_REG_START + 8)
+#define VP_OUT_TEX2 (VP_OUTPUT_REG_START + 9)
+#define VP_OUT_TEX3 (VP_OUTPUT_REG_START + 10)
+#define VP_OUT_TEX4 (VP_OUTPUT_REG_START + 11)
+#define VP_OUT_TEX5 (VP_OUTPUT_REG_START + 12)
+#define VP_OUT_TEX6 (VP_OUTPUT_REG_START + 13)
+#define VP_OUT_TEX7 (VP_OUTPUT_REG_START + 14)
+
+
+
+/* Machine state (i.e. the register file) */
+struct vp_machine
+{
+   GLfloat Registers[VP_NUM_TOTAL_REGISTERS][4];
+   GLint AddressReg;  /* might someday be a 4-vector */
+};
+
+
+/* Vertex program opcodes */
+enum vp_opcode
+{
+   MOV,
+   LIT,
+   RCP,
+   RSQ,
+   EXP,
+   LOG,
+   MUL,
+   ADD,
+   DP3,
+   DP4,
+   DST,
+   MIN,
+   MAX,
+   SLT,
+   SGE,
+   MAD,
+   ARL,
+   END
+};
+
+
+/* Instruction source register */
+struct vp_src_register
+{
+   GLint Register;    /* or the offset from the address register */
+   GLuint Swizzle[4];
+   GLboolean Negate;
+   GLboolean RelAddr;
+};
+
+
+/* Instruction destination register */
+struct vp_dst_register
+{
+   GLint Register;
+   GLboolean WriteMask[4];
+};
+
+
+/* Vertex program instruction */
+struct vp_instruction
+{
+   enum vp_opcode Opcode;
+   struct vp_src_register SrcReg[3];
+   struct vp_dst_register DstReg;
+};
+
+
+/* The actual vertex program, stored in the hash table */
+struct vp_program
+{
+   GLubyte *String;                      /* Original user code */
+   struct vp_instruction *Instructions;  /* Compiled instructions */
+   GLenum Target;      /* GL_VERTEX_PROGRAM_NV or GL_VERTEX_STATE_PROGRAM_NV */
+   GLint ErrorPos;
+   GLboolean Resident;
+};
+
+
+/*
+ * State vars for GL_NV_vertex_program
+ */
+struct gl_vertex_program
+{
+   GLboolean Enabled;                    /* GL_VERTEX_PROGRAM_NV */
+   GLboolean PointSizeEnabled;           /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   GLboolean TwoSideEnabled;            /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   GLuint Binding;                       /* currently bound program */
+   struct _mesa_HashTable *HashTable;    /* all programs */
+   struct vp_machine Machine;            /* machine state */
+   GLmatrix Matrix[VP_MAX_MATRICES];          /* Tracking matrices */
+   GLmatrix MatrixStack[VP_MAX_MATRICES][VP_MAX_MATRIX_DEPTH-1];  /* stacks */
+   GLuint MatrixStackDepth[VP_MAX_MATRICES];
+
+   GLenum TrackMatrix[VP_NUM_PROG_REGS / 4];
+   GLenum TrackMatrixTransform[VP_NUM_PROG_REGS / 4];
+
+};
+
+
+
+/*
  * State which can be shared by multiple contexts:
  */
 struct gl_shared_state {
@@ -1246,6 +1422,7 @@ struct gl_extensions {
    GLboolean MESA_sprite_point;
    GLboolean NV_blend_square;
    GLboolean NV_texgen_reflection;
+   GLboolean NV_vertex_program;
    GLboolean SGI_color_matrix;
    GLboolean SGI_color_table;
    GLboolean SGIS_generate_mipmap;
@@ -1259,6 +1436,16 @@ struct gl_extensions {
 };
 
 
+/* XXX just an idea */
+struct matrix_stack
+{
+   GLmatrix Top;
+   GLmatrix *Stack;
+   GLuint Depth;
+   GLuint MaxDepth;
+   GLuint DirtyFlag;   /* _NEW_MODELVIEW or _NEW_PROJECTION, for example */
+};
+
 
 /*
  * Bits for image transfer operations (ctx->ImageTransferState).
@@ -1319,28 +1506,32 @@ struct gl_extensions {
 #define _NEW_RENDERMODE		0x800000   /* RenderMode, Feedback, Select */
 #define _NEW_BUFFERS            0x1000000  /* ctx->Visual, ctx->DrawBuffer, */
 #define _NEW_MULTISAMPLE        0x2000000  /* ctx->Multisample */
+#define _NEW_TRACK_MATRIX       0x4000000  /* ctx->VertexProgram */
 #define _NEW_ALL ~0
 
 
 
 /* Bits to track array state changes (also used to summarize array enabled)
  */
-#define _NEW_ARRAY_VERTEX           0x1
-#define _NEW_ARRAY_COLOR            0x2
-#define _NEW_ARRAY_NORMAL           0x4
-#define _NEW_ARRAY_INDEX            0x8
-#define _NEW_ARRAY_EDGEFLAG         0x10
-#define _NEW_ARRAY_SECONDARYCOLOR   0x20
-#define _NEW_ARRAY_FOGCOORD         0x40
-#define _NEW_ARRAY_TEXCOORD_0       0x80
-#define _NEW_ARRAY_TEXCOORD_1       0x100
-#define _NEW_ARRAY_TEXCOORD_2       0x200
-#define _NEW_ARRAY_TEXCOORD_3       0x400
-#define _NEW_ARRAY_TEXCOORD_4       0x800
-#define _NEW_ARRAY_TEXCOORD_5       0x1000
-#define _NEW_ARRAY_TEXCOORD_6       0x2000
-#define _NEW_ARRAY_TEXCOORD_7       0x4000
-#define _NEW_ARRAY_ALL              0x7fff
+#define _NEW_ARRAY_VERTEX           (1 << VERT_ATTRIB_POS)
+#define _NEW_ARRAY_WEIGHT           (1 << VERT_ATTRIB_WEIGHT)
+#define _NEW_ARRAY_NORMAL           (1 << VERT_ATTRIB_NORMAL)
+#define _NEW_ARRAY_COLOR0           (1 << VERT_ATTRIB_COLOR0)
+#define _NEW_ARRAY_COLOR1           (1 << VERT_ATTRIB_COLOR1)
+#define _NEW_ARRAY_FOGCOORD         (1 << VERT_ATTRIB_FOG)
+#define _NEW_ARRAY_INDEX            (1 << VERT_ATTRIB_SIX)
+#define _NEW_ARRAY_EDGEFLAG         (1 << VERT_ATTRIB_SEVEN)
+#define _NEW_ARRAY_TEXCOORD_0       (1 << VERT_ATTRIB_TEX0)
+#define _NEW_ARRAY_TEXCOORD_1       (1 << VERT_ATTRIB_TEX1)
+#define _NEW_ARRAY_TEXCOORD_2       (1 << VERT_ATTRIB_TEX2)
+#define _NEW_ARRAY_TEXCOORD_3       (1 << VERT_ATTRIB_TEX3)
+#define _NEW_ARRAY_TEXCOORD_4       (1 << VERT_ATTRIB_TEX4)
+#define _NEW_ARRAY_TEXCOORD_5       (1 << VERT_ATTRIB_TEX5)
+#define _NEW_ARRAY_TEXCOORD_6       (1 << VERT_ATTRIB_TEX6)
+#define _NEW_ARRAY_TEXCOORD_7       (1 << VERT_ATTRIB_TEX7)
+#define _NEW_ARRAY_ALL              0xffff
+#define _NEW_ARRAY_VERT_ATTRIB0     0x10000
+
 
 #define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
 
@@ -1467,6 +1658,9 @@ struct __GLcontextRec {
    GLmatrix ModelView;           /* current matrix, not stored on stack */
    GLuint ModelViewStackDepth;
    GLmatrix ModelViewStack[MAX_MODELVIEW_STACK_DEPTH - 1];
+#if 1
+   struct matrix_stack ModelviewStack;
+#endif
 
    /* Projection matrix and stack */
    GLmatrix ProjectionMatrix;    /* current matrix, not stored on stack */
@@ -1551,6 +1745,8 @@ struct __GLcontextRec {
    struct gl_color_table PostColorMatrixColorTable;
    struct gl_color_table ProxyPostColorMatrixColorTable;
 
+   struct gl_vertex_program VertexProgram;  /* GL_NV_vertex_program */
+
    GLenum ErrorValue;        /* Last error code */
    GLenum RenderMode;        /* either GL_RENDER, GL_SELECT, GL_FEEDBACK */
    GLuint NewState;          /* bitwise-or of _NEW_* flags */
diff --git a/src/mesa/main/rastpos.c b/src/mesa/main/rastpos.c
index a7b4e16a41..276c54c6ec 100644
--- a/src/mesa/main/rastpos.c
+++ b/src/mesa/main/rastpos.c
@@ -1,4 +1,4 @@
-/* $Id: rastpos.c,v 1.32 2001/11/18 23:52:38 brianp Exp $ */
+/* $Id: rastpos.c,v 1.33 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -291,7 +291,7 @@ raster_pos4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    /* raster color */
    if (ctx->Light.Enabled) {
       GLfloat *norm, eyenorm[3];
-      GLfloat *objnorm = ctx->Current.Normal;
+      GLfloat *objnorm = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
 
       if (ctx->_NeedEyeCoords) {
 	 GLfloat *inv = ctx->ModelView.inv;
@@ -311,9 +311,10 @@ raster_pos4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    else {
       /* use current color or index */
       if (ctx->Visual.rgbMode) {
-         COPY_4FV(ctx->Current.RasterColor, ctx->Current.Color);
+         COPY_4FV(ctx->Current.RasterColor,
+                  ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
          COPY_4FV(ctx->Current.RasterSecondaryColor,
-                  ctx->Current.SecondaryColor);
+                  ctx->Current.Attrib[VERT_ATTRIB_COLOR1]);
       }
       else {
 	 ctx->Current.RasterIndex = ctx->Current.Index;
@@ -362,13 +363,13 @@ raster_pos4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    ctx->Current.RasterPos[3] = clip[3];
    ctx->Current.RasterPosValid = GL_TRUE;
 
-   ctx->Current.RasterFogCoord = ctx->Current.FogCoord;
+   ctx->Current.RasterFogCoord = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 
    {
       GLuint texSet;
       for (texSet = 0; texSet < ctx->Const.MaxTextureUnits; texSet++) {
          COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
-                  ctx->Current.Texcoord[texSet] );
+                  ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texSet] );
       }
    }
 
@@ -559,10 +560,8 @@ _mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
 
    /* raster color = current color or index */
    if (ctx->Visual.rgbMode) {
-      ctx->Current.RasterColor[0] = (ctx->Current.Color[0]);
-      ctx->Current.RasterColor[1] = (ctx->Current.Color[1]);
-      ctx->Current.RasterColor[2] = (ctx->Current.Color[2]);
-      ctx->Current.RasterColor[3] = (ctx->Current.Color[3]);
+      COPY_4FV(ctx->Current.RasterColor,
+               ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
    }
    else {
       ctx->Current.RasterIndex = ctx->Current.Index;
@@ -573,7 +572,7 @@ _mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
       GLuint texSet;
       for (texSet = 0; texSet < ctx->Const.MaxTextureUnits; texSet++) {
          COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
-                  ctx->Current.Texcoord[texSet] );
+                  ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texSet] );
       }
    }
 
@@ -834,23 +833,27 @@ void _mesa_WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
 
    ctx->Current.RasterPosValid = GL_TRUE;
    /* XXX might have to change this */
-   ctx->Current.RasterDistance = ctx->Current.FogCoord;
-   ctx->Current.RasterFogCoord = ctx->Current.FogCoord;
+   ctx->Current.RasterDistance = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
+   ctx->Current.RasterFogCoord = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 
    /* raster color = current color or index */
    if (ctx->Visual.rgbMode) {
-      ctx->Current.RasterColor[0] = CLAMP(ctx->Current.Color[0], 0.0F, 1.0F);
-      ctx->Current.RasterColor[1] = CLAMP(ctx->Current.Color[1], 0.0F, 1.0F);
-      ctx->Current.RasterColor[2] = CLAMP(ctx->Current.Color[2], 0.0F, 1.0F);
-      ctx->Current.RasterColor[3] = CLAMP(ctx->Current.Color[3], 0.0F, 1.0F);
+      ctx->Current.RasterColor[0]
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0], 0.0F, 1.0F);
+      ctx->Current.RasterColor[1]
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1], 0.0F, 1.0F);
+      ctx->Current.RasterColor[2]
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2], 0.0F, 1.0F);
+      ctx->Current.RasterColor[3]
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3], 0.0F, 1.0F);
       ctx->Current.RasterSecondaryColor[0]
-         = CLAMP(ctx->Current.SecondaryColor[0], 0.0F, 1.0F);
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0], 0.0F, 1.0F);
       ctx->Current.RasterSecondaryColor[1]
-         = CLAMP(ctx->Current.SecondaryColor[1], 0.0F, 1.0F);
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1], 0.0F, 1.0F);
       ctx->Current.RasterSecondaryColor[2]
-         = CLAMP(ctx->Current.SecondaryColor[2], 0.0F, 1.0F);
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2], 0.0F, 1.0F);
       ctx->Current.RasterSecondaryColor[3]
-         = CLAMP(ctx->Current.SecondaryColor[3], 0.0F, 1.0F);
+         = CLAMP(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3], 0.0F, 1.0F);
    }
    else {
       ctx->Current.RasterIndex = ctx->Current.Index;
@@ -861,7 +864,7 @@ void _mesa_WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
       GLuint texSet;
       for (texSet = 0; texSet < ctx->Const.MaxTextureUnits; texSet++) {
          COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
-                  ctx->Current.Texcoord[texSet] );
+                  ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texSet] );
       }
    }
 
diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c
index 4beaa07d5c..d331d434c6 100644
--- a/src/mesa/main/state.c
+++ b/src/mesa/main/state.c
@@ -1,4 +1,4 @@
-/* $Id: state.c,v 1.72 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: state.c,v 1.73 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -69,6 +69,7 @@
 #include "texstate.h"
 #include "mtypes.h"
 #include "varray.h"
+#include "vpstate.h"
 
 #include "math/m_matrix.h"
 #include "math/m_xform.h"
@@ -456,6 +457,33 @@ _mesa_init_exec_table(struct _glapi_table *exec, GLuint tableSize)
    exec->WindowPos4sMESA = _mesa_WindowPos4sMESA;
    exec->WindowPos4svMESA = _mesa_WindowPos4svMESA;
 
+   /* ###. GL_NV_vertex_program */
+   exec->BindProgramNV = _mesa_BindProgramNV;
+   exec->DeleteProgramsNV = _mesa_DeleteProgramsNV;
+   exec->ExecuteProgramNV = _mesa_ExecuteProgramNV;
+   exec->GenProgramsNV = _mesa_GenProgramsNV;
+   exec->AreProgramsResidentNV = _mesa_AreProgramsResidentNV;
+   exec->RequestResidentProgramsNV = _mesa_RequestResidentProgramsNV;
+   exec->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV;
+   exec->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV;
+   exec->GetProgramivNV = _mesa_GetProgramivNV;
+   exec->GetProgramStringNV = _mesa_GetProgramStringNV;
+   exec->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV;
+   exec->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
+   exec->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
+   exec->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
+   exec->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
+   exec->IsProgramNV = _mesa_IsProgramNV;
+   exec->LoadProgramNV = _mesa_LoadProgramNV;
+   exec->ProgramParameter4dNV = _mesa_ProgramParameter4dNV;
+   exec->ProgramParameter4dvNV = _mesa_ProgramParameter4dvNV;
+   exec->ProgramParameter4fNV = _mesa_ProgramParameter4fNV;
+   exec->ProgramParameter4fvNV = _mesa_ProgramParameter4fvNV;
+   exec->ProgramParameters4dvNV = _mesa_ProgramParameters4dvNV;
+   exec->ProgramParameters4fvNV = _mesa_ProgramParameters4fvNV;
+   exec->TrackMatrixNV = _mesa_TrackMatrixNV;
+   exec->VertexAttribPointerNV = _mesa_VertexAttribPointerNV;
+
    /* ARB 1. GL_ARB_multitexture */
    exec->ActiveTextureARB = _mesa_ActiveTextureARB;
    exec->ClientActiveTextureARB = _mesa_ClientActiveTextureARB;
diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c
index 73f54a0b40..29e57fc8fd 100644
--- a/src/mesa/main/vtxfmt.c
+++ b/src/mesa/main/vtxfmt.c
@@ -1,4 +1,4 @@
-/* $Id: vtxfmt.c,v 1.8 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: vtxfmt.c,v 1.9 2001/12/14 02:50:02 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -82,6 +82,7 @@
 
 static void install_vtxfmt( struct _glapi_table *tab, GLvertexformat *vfmt )
 {
+   printf("%s()\n", __FUNCTION__);
    tab->ArrayElement = vfmt->ArrayElement;
    tab->Color3f = vfmt->Color3f;
    tab->Color3fv = vfmt->Color3fv;
@@ -132,18 +133,17 @@ static void install_vtxfmt( struct _glapi_table *tab, GLvertexformat *vfmt )
    tab->Vertex3fv = vfmt->Vertex3fv;
    tab->Vertex4f = vfmt->Vertex4f;
    tab->Vertex4fv = vfmt->Vertex4fv;
+   tab->CallList = vfmt->CallList;
    tab->Begin = vfmt->Begin;
    tab->End = vfmt->End;
-
-/*     tab->NewList = vfmt->NewList; */
-   tab->CallList = vfmt->CallList;
-
+   tab->VertexAttrib4fNV = vfmt->VertexAttrib4fNV;
    tab->Rectf = vfmt->Rectf;
    tab->DrawArrays = vfmt->DrawArrays;
    tab->DrawElements = vfmt->DrawElements;
    tab->DrawRangeElements = vfmt->DrawRangeElements;
    tab->EvalMesh1 = vfmt->EvalMesh1;
    tab->EvalMesh2 = vfmt->EvalMesh2;
+   assert(tab->EvalMesh2);
 }
 
 
diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h
index 59a8b441ac..e946a85987 100644
--- a/src/mesa/main/vtxfmt_tmp.h
+++ b/src/mesa/main/vtxfmt_tmp.h
@@ -1,4 +1,4 @@
-/* $Id: vtxfmt_tmp.h,v 1.7 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: vtxfmt_tmp.h,v 1.8 2001/12/14 02:55:08 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -391,6 +391,18 @@ static void TAG(EvalMesh2)( GLenum mode, GLint i1, GLint i2,
    _glapi_Dispatch->EvalMesh2( mode, i1, i2, j1, j2 );
 }
 
+static void TAG(VertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   PRE_LOOPBACK( VertexAttrib4fNV );
+   glVertexAttrib4fNV( index, x, y, z, w );
+}
+
+static void TAG(VertexAttrib4fvNV)( GLuint index, const GLfloat *v )
+{
+   PRE_LOOPBACK( VertexAttrib4fNV );
+   glVertexAttrib4fvNV( index, v );
+}
+
 
 static GLvertexformat TAG(vtxfmt) = {
    TAG(ArrayElement),
@@ -446,12 +458,14 @@ static GLvertexformat TAG(vtxfmt) = {
    TAG(CallList),
    TAG(Begin),
    TAG(End),
+   TAG(VertexAttrib4fNV),
+   TAG(VertexAttrib4fvNV),
    TAG(Rectf),
    TAG(DrawArrays),
    TAG(DrawElements),
    TAG(DrawRangeElements),
    TAG(EvalMesh1),
-   TAG(EvalMesh2),
+   TAG(EvalMesh2)
 };
 
 #undef TAG
diff --git a/src/mesa/sparc/glapi_sparc.S b/src/mesa/sparc/glapi_sparc.S
index 300d5e8cac..be42dd4923 100644
--- a/src/mesa/sparc/glapi_sparc.S
+++ b/src/mesa/sparc/glapi_sparc.S
@@ -11542,13 +11542,13 @@ GL_PREFIX(PointParameterfSGIS):
 	or	%g1, %lo(0x00000000), %g1
 	sllx	%g2, 32, %g2
 	ldx	[%g1 + %g2], %g1
-	sethi	%hi(8 * _gloffset_PointParameterfARB), %g2
-	or	%g2, %lo(8 * _gloffset_PointParameterfARB), %g2
+	sethi	%hi(8 * _gloffset_PointParameterfEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfEXT), %g2
 	ldx	[%g1 + %g2], %g3
 #else
 	sethi	%hi(0x00000000), %g1
 	ld	[%g1 + %lo(0x00000000)], %g1
-	ld	[%g1 + (4 * _gloffset_PointParameterfARB)], %g3
+	ld	[%g1 + (4 * _gloffset_PointParameterfEXT)], %g3
 #endif
 	jmpl	%g3, %g0
 	nop
@@ -11563,13 +11563,13 @@ GL_PREFIX(PointParameterfvSGIS):
 	or	%g1, %lo(0x00000000), %g1
 	sllx	%g2, 32, %g2
 	ldx	[%g1 + %g2], %g1
-	sethi	%hi(8 * _gloffset_PointParameterfvARB), %g2
-	or	%g2, %lo(8 * _gloffset_PointParameterfvARB), %g2
+	sethi	%hi(8 * _gloffset_PointParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfvEXT), %g2
 	ldx	[%g1 + %g2], %g3
 #else
 	sethi	%hi(0x00000000), %g1
 	ld	[%g1 + %lo(0x00000000)], %g1
-	ld	[%g1 + (4 * _gloffset_PointParameterfvARB)], %g3
+	ld	[%g1 + (4 * _gloffset_PointParameterfvEXT)], %g3
 #endif
 	jmpl	%g3, %g0
 	nop
@@ -14387,6 +14387,1350 @@ GL_PREFIX(WindowPos3svARB):
 #endif
 	jmpl	%g3, %g0
 	nop
+
+GLOBL_FN(GL_PREFIX(BindProgramNV))
+.type glBindProgramNV,#function
+GL_PREFIX(BindProgramNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BindProgramNV), %g2
+	or	%g2, %lo(8 * _gloffset_BindProgramNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BindProgramNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(DeleteProgramsNV))
+.type glDeleteProgramsNV,#function
+GL_PREFIX(DeleteProgramsNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DeleteProgramsNV), %g2
+	or	%g2, %lo(8 * _gloffset_DeleteProgramsNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DeleteProgramsNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ExecuteProgramNV))
+.type glExecuteProgramNV,#function
+GL_PREFIX(ExecuteProgramNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ExecuteProgramNV), %g2
+	or	%g2, %lo(8 * _gloffset_ExecuteProgramNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ExecuteProgramNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GenProgramsNV))
+.type glGenProgramsNV,#function
+GL_PREFIX(GenProgramsNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GenProgramsNV), %g2
+	or	%g2, %lo(8 * _gloffset_GenProgramsNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GenProgramsNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(AreProgramsResidentNV))
+.type glAreProgramsResidentNV,#function
+GL_PREFIX(AreProgramsResidentNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_AreProgramsResidentNV), %g2
+	or	%g2, %lo(8 * _gloffset_AreProgramsResidentNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_AreProgramsResidentNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(RequestResidentProgramsNV))
+.type glRequestResidentProgramsNV,#function
+GL_PREFIX(RequestResidentProgramsNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RequestResidentProgramsNV), %g2
+	or	%g2, %lo(8 * _gloffset_RequestResidentProgramsNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RequestResidentProgramsNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetProgramParameterfvNV))
+.type glGetProgramParameterfvNV,#function
+GL_PREFIX(GetProgramParameterfvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetProgramParameterfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetProgramParameterfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetProgramParameterfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetProgramParameterdvNV))
+.type glGetProgramParameterdvNV,#function
+GL_PREFIX(GetProgramParameterdvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetProgramParameterdvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetProgramParameterdvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetProgramParameterdvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetProgramivNV))
+.type glGetProgramivNV,#function
+GL_PREFIX(GetProgramivNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetProgramivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetProgramivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetProgramivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetProgramStringNV))
+.type glGetProgramStringNV,#function
+GL_PREFIX(GetProgramStringNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetProgramStringNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetProgramStringNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetProgramStringNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetTrackMatrixivNV))
+.type glGetTrackMatrixivNV,#function
+GL_PREFIX(GetTrackMatrixivNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTrackMatrixivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetTrackMatrixivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTrackMatrixivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetVertexAttribdvNV))
+.type glGetVertexAttribdvNV,#function
+GL_PREFIX(GetVertexAttribdvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetVertexAttribdvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetVertexAttribdvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetVertexAttribdvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetVertexAttribfvNV))
+.type glGetVertexAttribfvNV,#function
+GL_PREFIX(GetVertexAttribfvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetVertexAttribfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetVertexAttribfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetVertexAttribfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetVertexAttribivNV))
+.type glGetVertexAttribivNV,#function
+GL_PREFIX(GetVertexAttribivNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetVertexAttribivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetVertexAttribivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetVertexAttribivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(GetVertexAttribPointervNV))
+.type glGetVertexAttribPointervNV,#function
+GL_PREFIX(GetVertexAttribPointervNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetVertexAttribPointervNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetVertexAttribPointervNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetVertexAttribPointervNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(IsProgramNV))
+.type glIsProgramNV,#function
+GL_PREFIX(IsProgramNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IsProgramNV), %g2
+	or	%g2, %lo(8 * _gloffset_IsProgramNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IsProgramNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(LoadProgramNV))
+.type glLoadProgramNV,#function
+GL_PREFIX(LoadProgramNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadProgramNV), %g2
+	or	%g2, %lo(8 * _gloffset_LoadProgramNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadProgramNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameter4fNV))
+.type glProgramParameter4fNV,#function
+GL_PREFIX(ProgramParameter4fNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameter4fNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameter4fNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameter4fNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameter4dNV))
+.type glProgramParameter4dNV,#function
+GL_PREFIX(ProgramParameter4dNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameter4dNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameter4dNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameter4dNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameter4dvNV))
+.type glProgramParameter4dvNV,#function
+GL_PREFIX(ProgramParameter4dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameter4dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameter4dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameter4dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameter4fvNV))
+.type glProgramParameter4fvNV,#function
+GL_PREFIX(ProgramParameter4fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameter4fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameter4fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameter4fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameters4dvNV))
+.type glProgramParameters4dvNV,#function
+GL_PREFIX(ProgramParameters4dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameters4dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameters4dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameters4dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(ProgramParameters4fvNV))
+.type glProgramParameters4fvNV,#function
+GL_PREFIX(ProgramParameters4fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ProgramParameters4fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_ProgramParameters4fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ProgramParameters4fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(TrackMatrixNV))
+.type glTrackMatrixNV,#function
+GL_PREFIX(TrackMatrixNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TrackMatrixNV), %g2
+	or	%g2, %lo(8 * _gloffset_TrackMatrixNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TrackMatrixNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribPointerNV))
+.type glVertexAttribPointerNV,#function
+GL_PREFIX(VertexAttribPointerNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribPointerNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribPointerNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribPointerNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1sNV))
+.type glVertexAttrib1sNV,#function
+GL_PREFIX(VertexAttrib1sNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1sNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1sNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1sNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1fNV))
+.type glVertexAttrib1fNV,#function
+GL_PREFIX(VertexAttrib1fNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1fNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1fNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1fNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1dNV))
+.type glVertexAttrib1dNV,#function
+GL_PREFIX(VertexAttrib1dNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1dNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1dNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1dNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2sNV))
+.type glVertexAttrib2sNV,#function
+GL_PREFIX(VertexAttrib2sNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2sNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2sNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2sNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2fNV))
+.type glVertexAttrib2fNV,#function
+GL_PREFIX(VertexAttrib2fNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2fNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2fNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2fNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2dNV))
+.type glVertexAttrib2dNV,#function
+GL_PREFIX(VertexAttrib2dNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2dNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2dNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2dNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3sNV))
+.type glVertexAttrib3sNV,#function
+GL_PREFIX(VertexAttrib3sNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3sNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3sNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3sNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3fNV))
+.type glVertexAttrib3fNV,#function
+GL_PREFIX(VertexAttrib3fNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3fNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3fNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3fNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3dNV))
+.type glVertexAttrib3dNV,#function
+GL_PREFIX(VertexAttrib3dNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3dNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3dNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3dNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4sNV))
+.type glVertexAttrib4sNV,#function
+GL_PREFIX(VertexAttrib4sNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4sNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4sNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4sNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4fNV))
+.type glVertexAttrib4fNV,#function
+GL_PREFIX(VertexAttrib4fNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4fNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4fNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4fNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4dNV))
+.type glVertexAttrib4dNV,#function
+GL_PREFIX(VertexAttrib4dNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4dNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4dNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4dNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4ubNV))
+.type glVertexAttrib4ubNV,#function
+GL_PREFIX(VertexAttrib4ubNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4ubNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4ubNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4ubNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1svNV))
+.type glVertexAttrib1svNV,#function
+GL_PREFIX(VertexAttrib1svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1fvNV))
+.type glVertexAttrib1fvNV,#function
+GL_PREFIX(VertexAttrib1fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib1dvNV))
+.type glVertexAttrib1dvNV,#function
+GL_PREFIX(VertexAttrib1dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib1dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib1dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib1dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2svNV))
+.type glVertexAttrib2svNV,#function
+GL_PREFIX(VertexAttrib2svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2fvNV))
+.type glVertexAttrib2fvNV,#function
+GL_PREFIX(VertexAttrib2fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib2dvNV))
+.type glVertexAttrib2dvNV,#function
+GL_PREFIX(VertexAttrib2dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib2dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib2dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib2dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3svNV))
+.type glVertexAttrib3svNV,#function
+GL_PREFIX(VertexAttrib3svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3fvNV))
+.type glVertexAttrib3fvNV,#function
+GL_PREFIX(VertexAttrib3fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib3dvNV))
+.type glVertexAttrib3dvNV,#function
+GL_PREFIX(VertexAttrib3dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib3dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib3dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib3dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4svNV))
+.type glVertexAttrib4svNV,#function
+GL_PREFIX(VertexAttrib4svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4fvNV))
+.type glVertexAttrib4fvNV,#function
+GL_PREFIX(VertexAttrib4fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4dvNV))
+.type glVertexAttrib4dvNV,#function
+GL_PREFIX(VertexAttrib4dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttrib4ubvNV))
+.type glVertexAttrib4ubvNV,#function
+GL_PREFIX(VertexAttrib4ubvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttrib4ubvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttrib4ubvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttrib4ubvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs1svNV))
+.type glVertexAttribs1svNV,#function
+GL_PREFIX(VertexAttribs1svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs1svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs1svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs1svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs1fvNV))
+.type glVertexAttribs1fvNV,#function
+GL_PREFIX(VertexAttribs1fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs1fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs1fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs1fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs1dvNV))
+.type glVertexAttribs1dvNV,#function
+GL_PREFIX(VertexAttribs1dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs1dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs1dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs1dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs2svNV))
+.type glVertexAttribs2svNV,#function
+GL_PREFIX(VertexAttribs2svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs2svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs2svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs2svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs2fvNV))
+.type glVertexAttribs2fvNV,#function
+GL_PREFIX(VertexAttribs2fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs2fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs2fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs2fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs2dvNV))
+.type glVertexAttribs2dvNV,#function
+GL_PREFIX(VertexAttribs2dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs2dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs2dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs2dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs3svNV))
+.type glVertexAttribs3svNV,#function
+GL_PREFIX(VertexAttribs3svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs3svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs3svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs3svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs3fvNV))
+.type glVertexAttribs3fvNV,#function
+GL_PREFIX(VertexAttribs3fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs3fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs3fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs3fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs3dvNV))
+.type glVertexAttribs3dvNV,#function
+GL_PREFIX(VertexAttribs3dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs3dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs3dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs3dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs4svNV))
+.type glVertexAttribs4svNV,#function
+GL_PREFIX(VertexAttribs4svNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs4svNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs4svNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs4svNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs4fvNV))
+.type glVertexAttribs4fvNV,#function
+GL_PREFIX(VertexAttribs4fvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs4fvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs4fvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs4fvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs4dvNV))
+.type glVertexAttribs4dvNV,#function
+GL_PREFIX(VertexAttribs4dvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs4dvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs4dvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs4dvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+GLOBL_FN(GL_PREFIX(VertexAttribs4ubvNV))
+.type glVertexAttribs4ubvNV,#function
+GL_PREFIX(VertexAttribs4ubvNV):
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexAttribs4ubvNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexAttribs4ubvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexAttribs4ubvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
 	 nop
 
 .globl _mesa_sparc_glapi_end
diff --git a/src/mesa/swrast/s_bitmap.c b/src/mesa/swrast/s_bitmap.c
index 5f12993314..6252fad771 100644
--- a/src/mesa/swrast/s_bitmap.c
+++ b/src/mesa/swrast/s_bitmap.c
@@ -1,4 +1,4 @@
-/* $Id: s_bitmap.c,v 1.12 2001/06/26 21:15:36 brianp Exp $ */
+/* $Id: s_bitmap.c,v 1.13 2001/12/14 02:50:57 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -76,7 +76,7 @@ _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
 
    if (ctx->Fog.Enabled) {
       if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
-         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.FogCoord);
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
       else
          fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
    }
diff --git a/src/mesa/swrast/s_copypix.c b/src/mesa/swrast/s_copypix.c
index 1dd570af05..f4d08f8f85 100644
--- a/src/mesa/swrast/s_copypix.c
+++ b/src/mesa/swrast/s_copypix.c
@@ -1,4 +1,4 @@
-/* $Id: s_copypix.c,v 1.24 2001/07/23 16:07:39 brianp Exp $ */
+/* $Id: s_copypix.c,v 1.25 2001/12/14 02:50:57 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -748,10 +748,16 @@ static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
 
    /* setup colors or indexes */
    if (ctx->Visual.rgbMode) {
-      GLuint *rgba32 = (GLuint *) rgba;
-      GLuint color = *(GLuint*)( ctx->Current.Color );
+      GLchan r, g, b, a;
+      UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+      UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+      UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+      UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
       for (i = 0; i < width; i++) {
-         rgba32[i] = color;
+         rgba[i][RCOMP] = r;
+         rgba[i][GCOMP] = g;
+         rgba[i][BCOMP] = b;
+         rgba[i][ACOMP] = a;
       }
    }
    else {
diff --git a/src/mesa/tnl/t_array_import.c b/src/mesa/tnl/t_array_import.c
index 513e8931fc..3393ea1a7a 100644
--- a/src/mesa/tnl/t_array_import.c
+++ b/src/mesa/tnl/t_array_import.c
@@ -1,4 +1,4 @@
-/* $Id: t_array_import.c,v 1.18 2001/08/13 22:15:54 keithw Exp $ */
+/* $Id: t_array_import.c,v 1.19 2001/12/14 02:51:42 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -247,45 +247,45 @@ static void _tnl_upgrade_client_data( GLcontext *ctx,
    if (writeable || stride) ca_flags |= CA_CLIENT_DATA;
 
    if ((required & VERT_CLIP) && VB->ClipPtr == VB->ObjPtr)
-      required |= VERT_OBJ;
+      required |= VERT_OBJ_BIT;
 
 /*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
 
-   if ((required & VERT_OBJ) && (VB->ObjPtr->flags & flags)) {
+   if ((required & VERT_OBJ_BIT) && (VB->ObjPtr->flags & flags)) {
       ASSERT(VB->ObjPtr == &inputs->Obj);
       _tnl_import_vertex( ctx, writeable, stride );
-      VB->importable_data &= ~(VERT_OBJ|VERT_CLIP);
+      VB->importable_data &= ~(VERT_OBJ_BIT|VERT_CLIP);
    }
 
-   if ((required & VERT_NORM) && (VB->NormalPtr->flags & flags)) {
+   if ((required & VERT_NORMAL_BIT) && (VB->NormalPtr->flags & flags)) {
       ASSERT(VB->NormalPtr == &inputs->Normal);
       _tnl_import_normal( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_NORM;
+      VB->importable_data &= ~VERT_NORMAL_BIT;
    }
 
-   if ((required & VERT_RGBA) && (VB->ColorPtr[0]->Flags & ca_flags)) {
+   if ((required & VERT_COLOR0_BIT) && (VB->ColorPtr[0]->Flags & ca_flags)) {
       ASSERT(VB->ColorPtr[0] == &inputs->Color);
       _tnl_import_color( ctx, GL_FLOAT, writeable, stride );
-      VB->importable_data &= ~VERT_RGBA;
+      VB->importable_data &= ~VERT_COLOR0_BIT;
    }
 
-   if ((required & VERT_SPEC_RGB) && 
+   if ((required & VERT_COLOR1_BIT) && 
        (VB->SecondaryColorPtr[0]->Flags & ca_flags)) {
       ASSERT(VB->SecondaryColorPtr[0] == &inputs->SecondaryColor);
       _tnl_import_secondarycolor( ctx, GL_FLOAT, writeable, stride );
-      VB->importable_data &= ~VERT_SPEC_RGB;
+      VB->importable_data &= ~VERT_COLOR1_BIT;
    }
 
-   if ((required & VERT_FOG_COORD) && (VB->FogCoordPtr->flags & flags)) {
+   if ((required & VERT_FOG_BIT) && (VB->FogCoordPtr->flags & flags)) {
       ASSERT(VB->FogCoordPtr == &inputs->FogCoord);
       _tnl_import_fogcoord( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_FOG_COORD;
+      VB->importable_data &= ~VERT_FOG_BIT;
    }
 
-   if ((required & VERT_INDEX) && (VB->IndexPtr[0]->flags & flags)) {
+   if ((required & VERT_INDEX_BIT) && (VB->IndexPtr[0]->flags & flags)) {
       ASSERT(VB->IndexPtr[0] == &inputs->Index);
       _tnl_import_index( ctx, writeable, stride );
-      VB->importable_data &= ~VERT_INDEX;
+      VB->importable_data &= ~VERT_INDEX_BIT;
    }
 
    if (required & VERT_TEX_ANY)
@@ -332,19 +332,19 @@ void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count )
 
    _ac_import_range( ctx, start, count );
 
-   if (inputs & VERT_OBJ) {
+   if (inputs & VERT_OBJ_BIT) {
       _tnl_import_vertex( ctx, 0, 0 );
       tmp->Obj.count = VB->Count;
       VB->ObjPtr = &tmp->Obj;
    }
 
-   if (inputs & VERT_NORM) {
+   if (inputs & VERT_NORMAL_BIT) {
       _tnl_import_normal( ctx, 0, 0 );
       tmp->Normal.count = VB->Count;
       VB->NormalPtr = &tmp->Normal;
    }
 
-   if (inputs & VERT_RGBA) {
+   if (inputs & VERT_COLOR0_BIT) {
       _tnl_import_color( ctx, 0, 0, 0 );
       VB->ColorPtr[0] = &tmp->Color;
       VB->ColorPtr[1] = 0;
@@ -360,26 +360,26 @@ void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count )
       }
    }
 
-   if (inputs & (VERT_INDEX|VERT_FOG_COORD|VERT_EDGE|VERT_SPEC_RGB)) {
-      if (inputs & VERT_INDEX) {
+   if (inputs & (VERT_INDEX_BIT|VERT_FOG_BIT|VERT_EDGEFLAG_BIT|VERT_COLOR1_BIT)) {
+      if (inputs & VERT_INDEX_BIT) {
 	 _tnl_import_index( ctx, 0, 0 );
 	 tmp->Index.count = VB->Count;
 	 VB->IndexPtr[0] = &tmp->Index;
 	 VB->IndexPtr[1] = 0;
       }
 
-      if (inputs & VERT_FOG_COORD) {
+      if (inputs & VERT_FOG_BIT) {
 	 _tnl_import_fogcoord( ctx, 0, 0 );
 	 tmp->FogCoord.count = VB->Count;
 	 VB->FogCoordPtr = &tmp->FogCoord;
       }
 
-      if (inputs & VERT_EDGE) {
+      if (inputs & VERT_EDGEFLAG_BIT) {
 	 _tnl_import_edgeflag( ctx, GL_TRUE, sizeof(GLboolean) );
 	 VB->EdgeFlag = (GLboolean *) tmp->EdgeFlag.data;
       }
 
-      if (inputs & VERT_SPEC_RGB) {
+      if (inputs & VERT_COLOR1_BIT) {
 	 _tnl_import_secondarycolor( ctx, 0, 0, 0 );
 	 VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
 	 VB->SecondaryColorPtr[1] = 0;
diff --git a/src/mesa/tnl/t_context.h b/src/mesa/tnl/t_context.h
index ed8eafe635..dd0bfad5b6 100644
--- a/src/mesa/tnl/t_context.h
+++ b/src/mesa/tnl/t_context.h
@@ -1,4 +1,4 @@
-/* $Id: t_context.h,v 1.32 2001/09/14 21:30:31 brianp Exp $ */
+/* $Id: t_context.h,v 1.33 2001/12/14 02:51:44 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -71,43 +71,45 @@
  * 5 spare flags, rearrangement of eval flags can secure at least 3
  * more.
  */
-#define VERT_OBJ             _NEW_ARRAY_VERTEX
-#define VERT_RGBA            _NEW_ARRAY_COLOR
-#define VERT_NORM            _NEW_ARRAY_NORMAL
-#define VERT_INDEX           _NEW_ARRAY_INDEX
-#define VERT_EDGE            _NEW_ARRAY_EDGEFLAG
-#define VERT_SPEC_RGB        _NEW_ARRAY_SECONDARYCOLOR
-#define VERT_FOG_COORD       _NEW_ARRAY_FOGCOORD
-#define VERT_TEX0            _NEW_ARRAY_TEXCOORD_0
-#define VERT_TEX1            _NEW_ARRAY_TEXCOORD_1
-#define VERT_TEX2            _NEW_ARRAY_TEXCOORD_2
-#define VERT_TEX3            _NEW_ARRAY_TEXCOORD_3
-#define VERT_TEX4            _NEW_ARRAY_TEXCOORD_4
-#define VERT_TEX5            _NEW_ARRAY_TEXCOORD_5
-#define VERT_TEX6            _NEW_ARRAY_TEXCOORD_6
-#define VERT_TEX7            _NEW_ARRAY_TEXCOORD_7
-#define VERT_EVAL_C1         0x8000     /* imm only */
-#define VERT_EVAL_C2         0x10000    /* imm only */
-#define VERT_EVAL_P1         0x20000    /* imm only */
-#define VERT_EVAL_P2         0x40000    /* imm only */
-#define VERT_OBJ_3           0x80000    /* imm only */
-#define VERT_OBJ_4           0x100000   /* imm only */
-#define VERT_MATERIAL        0x200000   /* imm only, but tested in vb code */
-#define VERT_ELT             0x400000   /* imm only */
-#define VERT_BEGIN           0x800000   /* imm only, but tested in vb code */
-#define VERT_END             0x1000000  /* imm only, but tested in vb code */
-#define VERT_END_VB          0x2000000  /* imm only, but tested in vb code */
-#define VERT_POINT_SIZE      0x4000000  /* vb only, could reuse a bit */
+#define VERT_OBJ_BIT         _NEW_ARRAY_VERTEX
+#define VERT_WEIGHT_BIT      _NEW_ARRAY_WEIGHT  /* unused */
+#define VERT_NORMAL_BIT      _NEW_ARRAY_NORMAL
+#define VERT_COLOR0_BIT      _NEW_ARRAY_COLOR0
+#define VERT_COLOR1_BIT      _NEW_ARRAY_COLOR1
+#define VERT_FOG_BIT         _NEW_ARRAY_FOGCOORD
+#define VERT_INDEX_BIT       _NEW_ARRAY_INDEX
+#define VERT_EDGEFLAG_BIT    _NEW_ARRAY_EDGEFLAG
+#define VERT_TEX0_BIT        _NEW_ARRAY_TEXCOORD_0
+#define VERT_TEX1_BIT        _NEW_ARRAY_TEXCOORD_1
+#define VERT_TEX2_BIT        _NEW_ARRAY_TEXCOORD_2
+#define VERT_TEX3_BIT        _NEW_ARRAY_TEXCOORD_3
+#define VERT_TEX4_BIT        _NEW_ARRAY_TEXCOORD_4
+#define VERT_TEX5_BIT        _NEW_ARRAY_TEXCOORD_5
+#define VERT_TEX6_BIT        _NEW_ARRAY_TEXCOORD_6
+#define VERT_TEX7_BIT        _NEW_ARRAY_TEXCOORD_7
+#define VERT_EVAL_C1         0x10000    /* imm only */
+#define VERT_EVAL_C2         0x20000    /* imm only */
+#define VERT_EVAL_P1         0x40000    /* imm only */
+#define VERT_EVAL_P2         0x80000    /* imm only */
+#define VERT_OBJ_3           0x100000   /* imm only */
+#define VERT_OBJ_4           0x200000   /* imm only */
+#define VERT_MATERIAL        0x400000   /* imm only, but tested in vb code */
+#define VERT_ELT             0x800000   /* imm only */
+#define VERT_BEGIN           0x1000000  /* imm only, but tested in vb code */
+#define VERT_END             0x2000000  /* imm only, but tested in vb code */
+#define VERT_END_VB          0x4000000  /* imm only, but tested in vb code */
+#define VERT_POINT_SIZE      0x8000000  /* vb only, could reuse a bit */
 #define VERT_EYE             VERT_BEGIN /* vb only, reuse imm bit */
 #define VERT_CLIP            VERT_END   /* vb only, reuse imm bit*/
 
 
+
 /* Flags for IM->TexCoordSize.  Enough flags for 16 units.
  */
-#define TEX_0_SIZE_3          (GLuint) 0x1
-#define TEX_0_SIZE_4          (GLuint) 0x1001
-#define TEX_SIZE_3(unit)      (TEX_0_SIZE_3<<unit)
-#define TEX_SIZE_4(unit)      (TEX_0_SIZE_4<<unit)
+#define TEX_0_SIZE_3          0x1
+#define TEX_0_SIZE_4          0x10001
+#define TEX_SIZE_3(unit)      (TEX_0_SIZE_3 << (unit))
+#define TEX_SIZE_4(unit)      (TEX_0_SIZE_4 << (unit))
 
 
 /* Shorthands.
@@ -115,41 +117,41 @@
 #define VERT_EVAL_ANY      (VERT_EVAL_C1|VERT_EVAL_P1|	\
                             VERT_EVAL_C2|VERT_EVAL_P2)
 
-#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ)
+#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ_BIT)
 #define VERT_OBJ_234      (VERT_OBJ_4|VERT_OBJ_23)
 
-#define VERT_TEX0_SHIFT 11
+#define VERT_TEX0_BIT_SHIFT 11
 
-#define VERT_TEX(i)        (VERT_TEX0 << i)
+#define VERT_TEX(i)        (VERT_TEX0_BIT << (i))
 
-#define VERT_TEX_ANY       (VERT_TEX0 |		\
-                            VERT_TEX1 |		\
-                            VERT_TEX2 |		\
-                            VERT_TEX3 |		\
-                            VERT_TEX4 |		\
-                            VERT_TEX5 |		\
-                            VERT_TEX6 |		\
-                            VERT_TEX7)
+#define VERT_TEX_ANY       (VERT_TEX0_BIT |		\
+                            VERT_TEX1_BIT |		\
+                            VERT_TEX2_BIT |		\
+                            VERT_TEX3_BIT |		\
+                            VERT_TEX4_BIT |		\
+                            VERT_TEX5_BIT |		\
+                            VERT_TEX6_BIT |		\
+                            VERT_TEX7_BIT)
 
 #define VERT_FIXUP        (VERT_TEX_ANY |	\
-                           VERT_RGBA |		\
-                           VERT_SPEC_RGB |	\
-                           VERT_FOG_COORD |	\
-			   VERT_INDEX |		\
-                           VERT_EDGE |		\
-                           VERT_NORM)
+                           VERT_COLOR0_BIT |		\
+                           VERT_COLOR1_BIT |	\
+                           VERT_FOG_BIT |	\
+			   VERT_INDEX_BIT |		\
+                           VERT_EDGEFLAG_BIT |		\
+                           VERT_NORMAL_BIT)
 
 #define VERT_CURRENT_DATA  (VERT_FIXUP |	\
 			    VERT_MATERIAL)
 
 #define VERT_DATA          (VERT_TEX_ANY |	\
-			    VERT_RGBA |		\
-			    VERT_SPEC_RGB |	\
-			    VERT_FOG_COORD |	\
-                            VERT_INDEX |	\
-                            VERT_EDGE |		\
-                            VERT_NORM |		\
-	                    VERT_OBJ |	\
+			    VERT_COLOR0_BIT |		\
+			    VERT_COLOR1_BIT |	\
+			    VERT_FOG_BIT |	\
+                            VERT_INDEX_BIT |	\
+                            VERT_EDGEFLAG_BIT |		\
+                            VERT_NORMAL_BIT |		\
+	                    VERT_OBJ_BIT |	\
                             VERT_MATERIAL |	\
                             VERT_ELT |		\
 	                    VERT_EVAL_ANY)
@@ -200,21 +202,24 @@ struct immediate
    GLuint MaterialOrMask;
    GLuint MaterialAndMask;
 
-   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
-
    GLuint  Primitive[IMM_SIZE];	    /* BEGIN/END */
    GLuint  PrimitiveLength[IMM_SIZE]; /* BEGIN/END */
    GLuint  Flag[IMM_SIZE];	    /* VERT_* flags */
-   GLfloat Color[IMM_SIZE][4];
-   GLfloat Obj[IMM_SIZE][4];
-   GLfloat Normal[IMM_SIZE][3];
+
+   GLfloat Obj[IMM_SIZE][4];             /* attrib 0 */
+   GLfloat Normal[IMM_SIZE][3];          /* attrib 2 */
    GLfloat *NormalLengthPtr;
-   GLfloat TexCoord0[IMM_SIZE][4];  /* just VERT_TEX0 */
+   GLfloat Color[IMM_SIZE][4];           /* attrib 3 */
+   GLfloat SecondaryColor[IMM_SIZE][4];  /* attrib 4 */
+   GLfloat FogCoord[IMM_SIZE];           /* attrib 5 */
+   GLfloat TexCoord0[IMM_SIZE][4];  /* just VERT_TEX0_BIT */
+   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];  /* attribs 8..15 */
+
    GLuint  Elt[IMM_SIZE];
    GLubyte EdgeFlag[IMM_SIZE];
    GLuint  Index[IMM_SIZE];
-   GLfloat SecondaryColor[IMM_SIZE][4];
-   GLfloat FogCoord[IMM_SIZE];
+
+   GLfloat Attrib[16][IMM_SIZE][4];  /* GL_NV_vertex_program */
 };
 
 
@@ -229,6 +234,7 @@ struct vertex_arrays
    GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
    GLvector1ui Elt;
    GLvector1f  FogCoord;
+   GLvector4f  Attribs[16];
 };
 
 
@@ -244,27 +250,27 @@ typedef struct vertex_buffer
 
    /* Constant over the pipeline.
     */
-   GLuint     Count;		                /* for everything except Elts */
-   GLuint     FirstClipped;	                /* temp verts for clipping */
-   GLuint     FirstPrimitive;	                /* usually zero */
+   GLuint     Count;		              /* for everything except Elts */
+   GLuint     FirstClipped;	              /* temp verts for clipping */
+   GLuint     FirstPrimitive;	              /* usually zero */
 
    /* Pointers to current data.
     */
    GLuint      *Elts;		                /* VERT_ELT */
-   GLvector4f  *ObjPtr;		                /* VERT_OBJ */
+   GLvector4f  *ObjPtr;		                /* VERT_OBJ_BIT */
    GLvector4f  *EyePtr;		                /* VERT_EYE */
    GLvector4f  *ClipPtr;	                /* VERT_CLIP */
    GLvector4f  *ProjectedClipPtr;               /* VERT_CLIP (2) */
    GLubyte     ClipOrMask;	                /* VERT_CLIP (3) */
    GLubyte     *ClipMask;		        /* VERT_CLIP (4) */
-   GLvector3f  *NormalPtr;	                /* VERT_NORM */
-   GLfloat     *NormalLengthPtr;	        /* VERT_NORM */
-   GLboolean   *EdgeFlag;	                /* VERT_EDGE */
+   GLvector3f  *NormalPtr;	                /* VERT_NORMAL_BIT */
+   GLfloat     *NormalLengthPtr;	        /* VERT_NORMAL_BIT */
+   GLboolean   *EdgeFlag;	                /* VERT_EDGEFLAG_BIT */
    GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];	/* VERT_TEX_0..n */
-   GLvector1ui *IndexPtr[2];	                /* VERT_INDEX */
-   struct gl_client_array *ColorPtr[2];	                /* VERT_RGBA */
-   struct gl_client_array *SecondaryColorPtr[2];         /* VERT_SPEC_RGB */
-   GLvector1f  *FogCoordPtr;	                /* VERT_FOG_COORD */
+   GLvector1ui *IndexPtr[2];	                /* VERT_INDEX_BIT */
+   struct gl_client_array *ColorPtr[2];	        /* VERT_COLOR0_BIT */
+   struct gl_client_array *SecondaryColorPtr[2];/* VERT_COLOR1_BIT */
+   GLvector1f  *FogCoordPtr;	                /* VERT_FOG_BIT */
    GLvector1f  *PointSizePtr;	                /* VERT_POINT_SIZE */
    GLmaterial (*Material)[2];                   /* VERT_MATERIAL, optional */
    GLuint      *MaterialMask;	                /* VERT_MATERIAL, optional */
@@ -272,6 +278,7 @@ typedef struct vertex_buffer
    GLuint      *Primitive;	                /* GL_(mode)|PRIM_* flags */
    GLuint      *PrimitiveLength;	        /* integers */
 
+   GLvector4f *AttribPtr[16];                   /* GL_NV_vertex_program */
 
    GLuint importable_data;
    void *import_source;
diff --git a/src/mesa/tnl/t_imm_alloc.c b/src/mesa/tnl/t_imm_alloc.c
index 302d739c7f..ff9c902171 100644
--- a/src/mesa/tnl/t_imm_alloc.c
+++ b/src/mesa/tnl/t_imm_alloc.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_alloc.c,v 1.10 2001/09/07 06:55:59 joukj Exp $ */
+/* $Id: t_imm_alloc.c,v 1.11 2001/12/14 02:51:44 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -62,7 +62,6 @@ static struct immediate *real_alloc_immediate( GLcontext *ctx )
    IM->CopyTexSize = 0;
    IM->CopyStart = IM->Start;
 
-
    /* TexCoord0 is special.
     */
    IM->TexCoord[0] = IM->TexCoord0;
diff --git a/src/mesa/tnl/t_imm_api.c b/src/mesa/tnl/t_imm_api.c
index c4e7cfcb2e..a4cb4845be 100644
--- a/src/mesa/tnl/t_imm_api.c
+++ b/src/mesa/tnl/t_imm_api.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_api.c,v 1.19 2001/12/04 23:43:31 brianp Exp $ */
+/* $Id: t_imm_api.c,v 1.20 2001/12/14 02:51:44 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -46,6 +46,9 @@
 #include "t_imm_dlist.h"
 
 
+extern void _tnl_vprog_vtxfmt_init( GLcontext *ctx );
+
+
 /* A cassette is full or flushed on a statechange.
  */
 void _tnl_flush_immediate( struct immediate *IM )
@@ -96,6 +99,13 @@ _tnl_begin( GLcontext *ctx, GLenum p )
    if (ctx->NewState)
       _mesa_update_state(ctx);
 
+   /* Either install the normal vertex functions or the vertex program funcs */
+   if (ctx->VertexProgram.Enabled)
+      _tnl_vprog_vtxfmt_init(ctx);
+   else
+      _tnl_imm_vtxfmt_init(ctx);
+   _mesa_init_exec_vtxfmt(ctx);
+
    /* if only a very few slots left, might as well flush now
     */
    if (IM->Count > IMM_MAXDATA-8) {
@@ -161,7 +171,8 @@ _tnl_save_Begin( GLenum mode )
       ctx->Driver.CurrentSavePrimitive = mode;
 }
 
-static void
+
+void
 _tnl_Begin( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -313,11 +324,11 @@ _tnl_end( GLcontext *ctx )
    /* You can set this flag to get the old 'flush_vb on glEnd()'
     * behaviour.
     */
-   if (1/*(MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH)*/)
+   if (1 /*(MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH)*/ )
       _tnl_flush_immediate( IM );
 }
 
-static void
+void
 _tnl_End(void)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -335,7 +346,7 @@ _tnl_End(void)
 #define COLOR( IM, r, g, b, a )			\
 {						\
    GLuint count = IM->Count;			\
-   IM->Flag[count] |= VERT_RGBA;		\
+   IM->Flag[count] |= VERT_COLOR0_BIT;		\
    IM->Color[count][0] = r;			\
    IM->Color[count][1] = g;			\
    IM->Color[count][2] = b;			\
@@ -420,7 +431,7 @@ _tnl_Color4ubv( const GLubyte *v)
 #define SECONDARY_COLOR( IM, r, g, b )		\
 {						\
    GLuint count = IM->Count;			\
-   IM->Flag[count] |= VERT_SPEC_RGB;		\
+   IM->Flag[count] |= VERT_COLOR1_BIT;		\
    IM->SecondaryColor[count][0] = r;		\
    IM->SecondaryColor[count][1] = g;		\
    IM->SecondaryColor[count][2] = b;		\
@@ -470,7 +481,7 @@ _tnl_EdgeFlag( GLboolean flag )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->EdgeFlag[count] = flag;
-   IM->Flag[count] |= VERT_EDGE;
+   IM->Flag[count] |= VERT_EDGEFLAG_BIT;
 }
 
 
@@ -481,7 +492,7 @@ _tnl_EdgeFlagv( const GLboolean *flag )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->EdgeFlag[count] = *flag;
-   IM->Flag[count] |= VERT_EDGE;
+   IM->Flag[count] |= VERT_EDGEFLAG_BIT;
 }
 
 
@@ -492,7 +503,7 @@ _tnl_FogCoordfEXT( GLfloat f )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->FogCoord[count] = f;
-   IM->Flag[count] |= VERT_FOG_COORD;
+   IM->Flag[count] |= VERT_FOG_BIT;
 }
 
 static void
@@ -502,7 +513,7 @@ _tnl_FogCoordfvEXT( const GLfloat *v )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->FogCoord[count] = v[0];
-   IM->Flag[count] |= VERT_FOG_COORD;
+   IM->Flag[count] |= VERT_FOG_BIT;
 }
 
 
@@ -513,7 +524,7 @@ _tnl_Indexi( GLint c )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->Index[count] = c;
-   IM->Flag[count] |= VERT_INDEX;
+   IM->Flag[count] |= VERT_INDEX_BIT;
 }
 
 
@@ -524,7 +535,7 @@ _tnl_Indexiv( const GLint *c )
    GET_IMMEDIATE;
    count = IM->Count;
    IM->Index[count] = *c;
-   IM->Flag[count] |= VERT_INDEX;
+   IM->Flag[count] |= VERT_INDEX_BIT;
 }
 
 
@@ -534,7 +545,7 @@ _tnl_Indexiv( const GLint *c )
    GLfloat *normal;				\
    GET_IMMEDIATE;				\
    count = IM->Count;				\
-   IM->Flag[count] |= VERT_NORM;		\
+   IM->Flag[count] |= VERT_NORMAL_BIT;		\
    normal = IM->Normal[count];			\
    ASSIGN_3V(normal, x,y,z);			\
 }
@@ -546,7 +557,7 @@ _tnl_Indexiv( const GLint *c )
    fi_type *normal;						\
    GET_IMMEDIATE;						\
    count = IM->Count;						\
-   IM->Flag[count] |= VERT_NORM;				\
+   IM->Flag[count] |= VERT_NORMAL_BIT;				\
    normal = (fi_type *)IM->Normal[count];			\
    normal[0].i = ((fi_type *)&(x))->i;				\
    normal[1].i = ((fi_type *)&(y))->i;				\
@@ -577,7 +588,7 @@ _tnl_Normal3fv( const GLfloat *v )
    GLfloat *tc;					\
    GET_IMMEDIATE;				\
    count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0;		\
+   IM->Flag[count] |= VERT_TEX0_BIT;		\
    tc = IM->TexCoord0[count];			\
    ASSIGN_4V(tc,s,0,0,1);			\
 }
@@ -588,7 +599,7 @@ _tnl_Normal3fv( const GLfloat *v )
    GLfloat *tc;					\
    GET_IMMEDIATE;				\
    count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0;		\
+   IM->Flag[count] |= VERT_TEX0_BIT;		\
    tc = IM->TexCoord0[count];			\
    ASSIGN_4V(tc, s,t,0,1);		        \
 }
@@ -599,7 +610,7 @@ _tnl_Normal3fv( const GLfloat *v )
    GLfloat *tc;					\
    GET_IMMEDIATE;				\
    count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0;		\
+   IM->Flag[count] |= VERT_TEX0_BIT;		\
    IM->TexSize |= TEX_0_SIZE_3;		\
    tc = IM->TexCoord0[count];			\
    ASSIGN_4V(tc, s,t,u,1);			\
@@ -611,7 +622,7 @@ _tnl_Normal3fv( const GLfloat *v )
    GLfloat *tc;					\
    GET_IMMEDIATE;				\
    count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0;		\
+   IM->Flag[count] |= VERT_TEX0_BIT;		\
    IM->TexSize |= TEX_0_SIZE_4;		\
    tc = IM->TexCoord0[count];			\
    ASSIGN_4V(tc, s,t,u,v);			\
@@ -624,7 +635,7 @@ _tnl_Normal3fv( const GLfloat *v )
    fi_type *tc;						\
    GET_IMMEDIATE;					\
    count = IM->Count;					\
-   IM->Flag[count] |= VERT_TEX0;			\
+   IM->Flag[count] |= VERT_TEX0_BIT;			\
    tc = (fi_type *)IM->TexCoord0[count];		\
    tc[0].i = ((fi_type *)&(s))->i;			\
    tc[1].i = ((fi_type *)&(t))->i;			\
@@ -694,7 +705,7 @@ _tnl_TexCoord4fv( const GLfloat *v )
 {						\
    GLuint count = IM->Count++;			\
    GLfloat *dest = IM->Obj[count];		\
-   IM->Flag[count] |= VERT_OBJ;			\
+   IM->Flag[count] |= VERT_OBJ_BIT;			\
    ASSIGN_4V(dest, x, y, 0, 1);			\
 /*     ASSERT(IM->Flag[IM->Count]==0);		 */\
    if (count == IMM_MAXDATA - 1)		\
@@ -727,7 +738,7 @@ _tnl_TexCoord4fv( const GLfloat *v )
 {							\
    GLuint count = IM->Count++;				\
    fi_type *dest = (fi_type *)IM->Obj[count];		\
-   IM->Flag[count] |= VERT_OBJ; 			\
+   IM->Flag[count] |= VERT_OBJ_BIT; 			\
    dest[0].i = ((fi_type *)&(x))->i;			\
    dest[1].i = ((fi_type *)&(y))->i;			\
    dest[2].i = 0;					\
@@ -1100,6 +1111,30 @@ _tnl_vertex2f( GLcontext *ctx, GLfloat x, GLfloat y )
 
 
 
+/*
+ * NV_vertex_program
+ */
+
+static void
+_tnl_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+   /* no-op? */
+   printf("%s(%d, %f, %f, %f, %f)\n", __FUNCTION__, index, x, y, z, w);
+   (void) index;
+   (void) x;
+   (void) y;
+   (void) z;
+   (void) w;
+}
+
+static void
+_tnl_VertexAttrib4fvNV(GLuint index, const GLfloat *v)
+{
+   /* no-op? */
+   (void) index;
+   (void) v;
+}
+
 
 
 /* Execute a glRectf() function.  _tnl_hard_begin() ensures the check
@@ -1206,6 +1241,8 @@ void _tnl_imm_vtxfmt_init( GLcontext *ctx )
 {
    GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
 
+   printf("%s()\n", __FUNCTION__);
+
    /* All begin/end operations are handled by this vertex format:
     */
    vfmt->ArrayElement = _tnl_ArrayElement;
@@ -1260,6 +1297,8 @@ void _tnl_imm_vtxfmt_init( GLcontext *ctx )
    vfmt->Vertex3fv = _tnl_Vertex3fv;
    vfmt->Vertex4f = _tnl_Vertex4f;
    vfmt->Vertex4fv = _tnl_Vertex4fv;
+   vfmt->VertexAttrib4fNV = _tnl_VertexAttrib4fNV;
+   vfmt->VertexAttrib4fvNV = _tnl_VertexAttrib4fvNV;
 
    /* Outside begin/end functions (from t_varray.c, t_eval.c, ...):
     */
diff --git a/src/mesa/tnl/t_imm_api.h b/src/mesa/tnl/t_imm_api.h
index ad1827f1f8..c13dde77aa 100644
--- a/src/mesa/tnl/t_imm_api.h
+++ b/src/mesa/tnl/t_imm_api.h
@@ -1,8 +1,8 @@
-/* $Id: t_imm_api.h,v 1.3 2001/03/12 00:48:43 gareth Exp $ */
+/* $Id: t_imm_api.h,v 1.4 2001/12/14 02:51:44 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
@@ -34,6 +34,11 @@
 
 extern void _tnl_save_Begin( GLenum mode );
 
+extern void _tnl_Begin( GLenum mode );
+
+extern void _tnl_End(void);
+
+
 /* TNL-private internal functions for building higher-level operations:
  */
 extern GLboolean _tnl_hard_begin( GLcontext *ctx, GLenum p );
diff --git a/src/mesa/tnl/t_imm_debug.c b/src/mesa/tnl/t_imm_debug.c
index 78121f9e5a..2bd36aa16e 100644
--- a/src/mesa/tnl/t_imm_debug.c
+++ b/src/mesa/tnl/t_imm_debug.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_debug.c,v 1.4 2001/08/01 05:10:42 keithw Exp $ */
+/* $Id: t_imm_debug.c,v 1.5 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -35,29 +35,29 @@ void _tnl_print_vert_flags( const char *name, GLuint flags )
 	   name,
 	   flags,
 	   (flags & VERT_CLIP)       ? "clip/proj-clip/glend, " : "",
-	   (flags & VERT_EDGE)       ? "edgeflag, " : "",
+	   (flags & VERT_EDGEFLAG_BIT)       ? "edgeflag, " : "",
 	   (flags & VERT_ELT)        ? "array-elt, " : "",
 	   (flags & VERT_END_VB)     ? "end-vb, " : "",
 	   (flags & VERT_EVAL_ANY)   ? "eval-coord, " : "",
 	   (flags & VERT_EYE)        ? "eye/glbegin, " : "",
-	   (flags & VERT_FOG_COORD)  ? "fog-coord, " : "",
-	   (flags & VERT_INDEX)      ? "index, " : "",
+	   (flags & VERT_FOG_BIT)  ? "fog-coord, " : "",
+	   (flags & VERT_INDEX_BIT)      ? "index, " : "",
 	   (flags & VERT_MATERIAL)   ? "material, " : "",
-	   (flags & VERT_NORM)       ? "normals, " : "",
-	   (flags & VERT_OBJ)        ? "obj, " : "",
+	   (flags & VERT_NORMAL_BIT)       ? "normals, " : "",
+	   (flags & VERT_OBJ_BIT)        ? "obj, " : "",
 	   (flags & VERT_OBJ_3)      ? "obj-3, " : "",
 	   (flags & VERT_OBJ_4)      ? "obj-4, " : "",
 	   (flags & VERT_POINT_SIZE) ? "point-size, " : "",
-	   (flags & VERT_RGBA)       ? "colors, " : "",
-	   (flags & VERT_SPEC_RGB)   ? "specular, " : "",
-	   (flags & VERT_TEX0)       ? "texcoord0, " : "",
-	   (flags & VERT_TEX1)       ? "texcoord1, " : "",
-	   (flags & VERT_TEX2)       ? "texcoord2, " : "",
-	   (flags & VERT_TEX3)       ? "texcoord3, " : "",
-	   (flags & VERT_TEX4)       ? "texcoord4, " : "",
-	   (flags & VERT_TEX5)       ? "texcoord5, " : "",
-	   (flags & VERT_TEX6)       ? "texcoord6, " : "",
-	   (flags & VERT_TEX7)       ? "texcoord7, " : ""
+	   (flags & VERT_COLOR0_BIT)       ? "colors, " : "",
+	   (flags & VERT_COLOR1_BIT)   ? "specular, " : "",
+	   (flags & VERT_TEX0_BIT)       ? "texcoord0, " : "",
+	   (flags & VERT_TEX1_BIT)       ? "texcoord1, " : "",
+	   (flags & VERT_TEX2_BIT)       ? "texcoord2, " : "",
+	   (flags & VERT_TEX3_BIT)       ? "texcoord3, " : "",
+	   (flags & VERT_TEX4_BIT)       ? "texcoord4, " : "",
+	   (flags & VERT_TEX5_BIT)       ? "texcoord5, " : "",
+	   (flags & VERT_TEX6_BIT)       ? "texcoord6, " : "",
+	   (flags & VERT_TEX7_BIT)       ? "texcoord7, " : ""
       );
 }
 
@@ -107,7 +107,7 @@ void _tnl_print_cassette( struct immediate *IM )
       if (req & flags[i] & VERT_ELT)
 	 fprintf(stderr, " Elt %u\t", IM->Elt[i]);
 
-      if (req & flags[i] & VERT_NORM)
+      if (req & flags[i] & VERT_NORMAL_BIT)
 	 fprintf(stderr, " Norm %f %f %f ",
 		IM->Normal[i][0], IM->Normal[i][1], IM->Normal[i][2]);
 
@@ -124,23 +124,23 @@ void _tnl_print_cassette( struct immediate *IM )
 	 }
       }
 
-      if (req & flags[i] & VERT_RGBA)
+      if (req & flags[i] & VERT_COLOR0_BIT)
 	 fprintf(stderr, " Rgba %f %f %f %f ",
 		IM->Color[i][0], IM->Color[i][1],
 		IM->Color[i][2], IM->Color[i][3]);
 
-      if (req & flags[i] & VERT_SPEC_RGB)
+      if (req & flags[i] & VERT_COLOR1_BIT)
 	 fprintf(stderr, " Spec %f %f %f ",
 		IM->SecondaryColor[i][0], IM->SecondaryColor[i][1],
 		IM->SecondaryColor[i][2]);
 
-      if (req & flags[i] & VERT_FOG_COORD)
+      if (req & flags[i] & VERT_FOG_BIT)
 	 fprintf(stderr, " Fog %f ", IM->FogCoord[i]);
 
-      if (req & flags[i] & VERT_INDEX)
+      if (req & flags[i] & VERT_INDEX_BIT)
 	 fprintf(stderr, " Index %u ", IM->Index[i]);
 
-      if (req & flags[i] & VERT_EDGE)
+      if (req & flags[i] & VERT_EDGEFLAG_BIT)
 	 fprintf(stderr, " Edgeflag %d ", IM->EdgeFlag[i]);
 
       if (req & flags[i] & VERT_MATERIAL)
diff --git a/src/mesa/tnl/t_imm_dlist.c b/src/mesa/tnl/t_imm_dlist.c
index d89d9292df..04212a6480 100644
--- a/src/mesa/tnl/t_imm_dlist.c
+++ b/src/mesa/tnl/t_imm_dlist.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_dlist.c,v 1.32 2001/12/13 10:49:04 keithw Exp $ */
+/* $Id: t_imm_dlist.c,v 1.33 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -86,7 +86,7 @@ static void build_normal_lengths( struct immediate *IM )
    
    for (i = 0 ; i < count ; ) {
       dest[i] = len;
-      if (flags[++i] & VERT_NORM) {
+      if (flags[++i] & VERT_NORMAL_BIT) {
 	 len = (GLfloat) LEN_3FV( data[i] );
 	 if (len > 0.0F) len = 1.0F / len;
       }
@@ -108,7 +108,7 @@ static void fixup_normal_lengths( struct immediate *IM )
    } 
 
    if (i < IM->Count) {
-      while (!(flags[i] & (VERT_NORM|VERT_END_VB))) {
+      while (!(flags[i] & (VERT_NORMAL_BIT|VERT_END_VB))) {
 	 dest[i] = len;
 	 i++;
       }
@@ -611,28 +611,28 @@ static void loopback_compiled_cassette( GLcontext *ctx, struct immediate *IM )
 	    }
 	 }
 
-	 if (flags[i] & VERT_NORM) {
+	 if (flags[i] & VERT_NORMAL_BIT) {
 /*  	       fprintf(stderr, "normal %d: %f %f %f\n", i, */
 /*  		       IM->Normal[i][0], IM->Normal[i][1], IM->Normal[i][2]);  */
 	    glNormal3fv(IM->Normal[i]);
 	 }
 
-	 if (flags[i] & VERT_RGBA) {
+	 if (flags[i] & VERT_COLOR0_BIT) {
 /*  	       fprintf(stderr, "color %d: %f %f %f\n", i, */
 /*  		       IM->Color[i][0], IM->Color[i][1], IM->Color[i][2]);  */
 	    glColor4fv( IM->Color[i] );
 	 }
 
-	 if (flags[i] & VERT_SPEC_RGB)
+	 if (flags[i] & VERT_COLOR1_BIT)
 	    glSecondaryColor3fvEXT( IM->SecondaryColor[i] );
 
-	 if (flags[i] & VERT_FOG_COORD)
+	 if (flags[i] & VERT_FOG_BIT)
 	    glFogCoordfEXT( IM->FogCoord[i] );
 
-	 if (flags[i] & VERT_INDEX)
+	 if (flags[i] & VERT_INDEX_BIT)
 	    glIndexi( IM->Index[i] );
 
-	 if (flags[i] & VERT_EDGE)
+	 if (flags[i] & VERT_EDGEFLAG_BIT)
 	    glEdgeFlag( IM->EdgeFlag[i] );
 
 	 if (flags[i] & VERT_MATERIAL) 
diff --git a/src/mesa/tnl/t_imm_elt.c b/src/mesa/tnl/t_imm_elt.c
index 0a891733e9..d585f63c47 100644
--- a/src/mesa/tnl/t_imm_elt.c
+++ b/src/mesa/tnl/t_imm_elt.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_elt.c,v 1.12 2001/09/14 21:30:31 brianp Exp $ */
+/* $Id: t_imm_elt.c,v 1.13 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -757,10 +757,10 @@ void _tnl_translate_array_elts( GLcontext *ctx, struct immediate *IM,
    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
       fprintf(stderr, "exec_array_elements %d .. %d\n", start, count);
 
-   if (translate & VERT_OBJ) {
+   if (translate & VERT_OBJ_BIT) {
       _tnl_trans_elt_4f( IM->Obj,
 			 &ctx->Array.Vertex,
-			 flags, elts, (VERT_ELT|VERT_OBJ),
+			 flags, elts, (VERT_ELT|VERT_OBJ_BIT),
 			 start, count);
 
       if (ctx->Array.Vertex.Size == 4)
@@ -770,42 +770,42 @@ void _tnl_translate_array_elts( GLcontext *ctx, struct immediate *IM,
    }
 
 
-   if (translate & VERT_NORM)
+   if (translate & VERT_NORMAL_BIT)
       _tnl_trans_elt_3f( IM->Normal,
 			 &ctx->Array.Normal,
-			 flags, elts, (VERT_ELT|VERT_NORM),
+			 flags, elts, (VERT_ELT|VERT_NORMAL_BIT),
 			 start, count);
 
-   if (translate & VERT_EDGE)
+   if (translate & VERT_EDGEFLAG_BIT)
       _tnl_trans_elt_1ub( IM->EdgeFlag,
 			  &ctx->Array.EdgeFlag,
-			  flags, elts, (VERT_ELT|VERT_EDGE),
+			  flags, elts, (VERT_ELT|VERT_EDGEFLAG_BIT),
 			  start, count);
 
-   if (translate & VERT_RGBA) {
+   if (translate & VERT_COLOR0_BIT) {
       _tnl_trans_elt_4f( IM->Color,
 			 &ctx->Array.Color,
-			 flags, elts, (VERT_ELT|VERT_RGBA),
+			 flags, elts, (VERT_ELT|VERT_COLOR0_BIT),
 			 start, count);
    }
 
-   if (translate & VERT_SPEC_RGB) {
+   if (translate & VERT_COLOR1_BIT) {
       _tnl_trans_elt_4f( IM->SecondaryColor,
 			 &ctx->Array.SecondaryColor,
-			 flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+			 flags, elts, (VERT_ELT|VERT_COLOR1_BIT),
 			 start, count);
    }
 
-   if (translate & VERT_FOG_COORD)
+   if (translate & VERT_FOG_BIT)
       _tnl_trans_elt_1f( IM->FogCoord,
 			 &ctx->Array.FogCoord,
-			 flags, elts, (VERT_ELT|VERT_FOG_COORD),
+			 flags, elts, (VERT_ELT|VERT_FOG_BIT),
 			 start, count);
 
-   if (translate & VERT_INDEX)
+   if (translate & VERT_INDEX_BIT)
       _tnl_trans_elt_1ui( IM->Index,
 			  &ctx->Array.Index,
-			  flags, elts, (VERT_ELT|VERT_INDEX),
+			  flags, elts, (VERT_ELT|VERT_INDEX_BIT),
 			  start, count);
 
    if (translate & VERT_TEX_ANY) {
diff --git a/src/mesa/tnl/t_imm_eval.c b/src/mesa/tnl/t_imm_eval.c
index d90884d942..662cfb936a 100644
--- a/src/mesa/tnl/t_imm_eval.c
+++ b/src/mesa/tnl/t_imm_eval.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_eval.c,v 1.18 2001/09/14 21:30:31 brianp Exp $ */
+/* $Id: t_imm_eval.c,v 1.19 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -379,34 +379,34 @@ static void update_eval( GLcontext *ctx )
    GLuint eval1 = 0, eval2 = 0;
 
    if (ctx->Eval.Map1Index)
-      eval1 |= VERT_INDEX;
+      eval1 |= VERT_INDEX_BIT;
 
    if (ctx->Eval.Map2Index)
-      eval2 |= VERT_INDEX;
+      eval2 |= VERT_INDEX_BIT;
 
    if (ctx->Eval.Map1Color4)
-      eval1 |= VERT_RGBA;
+      eval1 |= VERT_COLOR0_BIT;
 
    if (ctx->Eval.Map2Color4)
-      eval2 |= VERT_RGBA;
+      eval2 |= VERT_COLOR0_BIT;
 
    if (ctx->Eval.Map1Normal)
-      eval1 |= VERT_NORM;
+      eval1 |= VERT_NORMAL_BIT;
 
    if (ctx->Eval.Map2Normal)
-      eval2 |= VERT_NORM;
+      eval2 |= VERT_NORMAL_BIT;
 
    if (ctx->Eval.Map1TextureCoord4 ||
        ctx->Eval.Map1TextureCoord3 ||
        ctx->Eval.Map1TextureCoord2 ||
        ctx->Eval.Map1TextureCoord1)
-      eval1 |= VERT_TEX0;
+      eval1 |= VERT_TEX0_BIT;
 
    if (ctx->Eval.Map2TextureCoord4 ||
        ctx->Eval.Map2TextureCoord3 ||
        ctx->Eval.Map2TextureCoord2 ||
        ctx->Eval.Map2TextureCoord1)
-      eval2 |= VERT_TEX0;
+      eval2 |= VERT_TEX0_BIT;
 
    if (ctx->Eval.Map1Vertex4)
       eval1 |= VERT_OBJ_234;
@@ -416,13 +416,13 @@ static void update_eval( GLcontext *ctx )
 
    if (ctx->Eval.Map2Vertex4) {
       if (ctx->Eval.AutoNormal)
-	 eval2 |= VERT_OBJ_234 | VERT_NORM;
+	 eval2 |= VERT_OBJ_234 | VERT_NORMAL_BIT;
       else
 	 eval2 |= VERT_OBJ_234;
    }
    else if (ctx->Eval.Map2Vertex3) {
       if (ctx->Eval.AutoNormal)
-	 eval2 |= VERT_OBJ_23 | VERT_NORM;
+	 eval2 |= VERT_OBJ_23 | VERT_NORMAL_BIT;
       else
 	 eval2 |= VERT_OBJ_23;
    }
@@ -507,7 +507,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
 
    /* Perform the evaluations on active data elements.
     */
-   if (req & VERT_INDEX)
+   if (req & VERT_INDEX_BIT)
    {
       GLuint generated = 0;
 
@@ -528,7 +528,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
       }
    }
 
-   if (req & VERT_RGBA)
+   if (req & VERT_COLOR0_BIT)
    {
       GLuint generated = 0;
 
@@ -541,7 +541,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
       tmp->Color.Ptr = store->Color + IM->CopyStart;
       tmp->Color.StrideB = 4 * sizeof(GLfloat);
       tmp->Color.Flags = 0;
-      tnl->vb.importable_data &= ~VERT_RGBA;
+      tnl->vb.importable_data &= ~VERT_COLOR0_BIT;
 
       if (ctx->Eval.Map1Color4 && any_eval1) {
 	 eval1_4f_ca( &tmp->Color, coord, flags, 4, &ctx->EvalMap.Map1Color4 );
@@ -616,7 +616,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
    }
 
 
-   if (req & VERT_NORM)
+   if (req & VERT_NORMAL_BIT)
    {
       GLuint generated = 0;
 
@@ -647,7 +647,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
    /* In the AutoNormal case, the copy and assignment of tmp->NormalPtr
     * are done above.
     */
-   if (req & VERT_OBJ)
+   if (req & VERT_OBJ_BIT)
    {
       if (copycount) {
 	 /* This copy may already have occurred when eliminating
@@ -678,7 +678,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
       if (any_eval2) {
 	 if (ctx->Eval.Map2Vertex4)
 	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM))
+	    if (ctx->Eval.AutoNormal && (req & VERT_NORMAL_BIT))
 	       eval2_obj_norm( &tmp->Obj, &tmp->Normal, coord, flags, 4,
 			       &ctx->EvalMap.Map2Vertex4 );
 	    else
@@ -687,7 +687,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
 	 }
 	 else if (ctx->Eval.Map2Vertex3)
 	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM))
+	    if (ctx->Eval.AutoNormal && (req & VERT_NORMAL_BIT))
 	       eval2_obj_norm( &tmp->Obj, &tmp->Normal, coord, flags, 3,
 			       &ctx->EvalMap.Map2Vertex3 );
 	    else
@@ -704,7 +704,7 @@ void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
     * must be ignored.
     */
    if (purge_flags) {
-      GLuint vertex = VERT_OBJ|(VERT_EVAL_ANY & ~purge_flags);
+      GLuint vertex = VERT_OBJ_BIT|(VERT_EVAL_ANY & ~purge_flags);
       GLuint last_new_prim = 0;
       GLuint new_prim_length = 0;
       GLuint next_old_prim = 0;
diff --git a/src/mesa/tnl/t_imm_exec.c b/src/mesa/tnl/t_imm_exec.c
index 5b6d5d3d3c..58c46c4777 100644
--- a/src/mesa/tnl/t_imm_exec.c
+++ b/src/mesa/tnl/t_imm_exec.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_exec.c,v 1.30 2001/11/30 15:43:53 alanh Exp $ */
+/* $Id: t_imm_exec.c,v 1.31 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -96,6 +96,7 @@ void _tnl_reset_exec_input( GLcontext *ctx,
    reset_input( ctx, start, beginstate, savedbeginstate );
 
    IM->CopyStart = start - tnl->ExecCopyCount;
+
    IM->Primitive[IM->CopyStart] = ctx->Driver.CurrentExecPrimitive;
    if (tnl->ExecParity)
       IM->Primitive[IM->CopyStart] |= PRIM_PARITY;
@@ -117,40 +118,44 @@ void _tnl_reset_compile_input( GLcontext *ctx,
 }
   
 
+/*
+ * Copy the last specified normal, color, texcoord, edge flag, etc
+ * from the immediate struct into the ctx->Current attribute group.
+ */
 void _tnl_copy_to_current( GLcontext *ctx, struct immediate *IM,
 			   GLuint flag, GLuint count )
 {
    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
       _tnl_print_vert_flags("copy to current", flag);
 
-   if (flag & VERT_NORM)
-      COPY_3FV( ctx->Current.Normal, IM->Normal[count]);
+   if (flag & VERT_NORMAL_BIT)
+      COPY_3FV( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], IM->Normal[count]);
 
-   if (flag & VERT_INDEX)
+   if (flag & VERT_INDEX_BIT)
       ctx->Current.Index = IM->Index[count];
 
-   if (flag & VERT_EDGE)
+   if (flag & VERT_EDGEFLAG_BIT)
       ctx->Current.EdgeFlag = IM->EdgeFlag[count];
 
-   if (flag & VERT_RGBA) {
-      COPY_4FV(ctx->Current.Color, IM->Color[count]);
+   if (flag & VERT_COLOR0_BIT) {
+      COPY_4FV(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], IM->Color[count]);
       if (ctx->Light.ColorMaterialEnabled) {
-	 _mesa_update_color_material( ctx, ctx->Current.Color );
+	 _mesa_update_color_material( ctx, ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 	 _mesa_validate_all_lighting_tables( ctx );
       }
    }
 
-   if (flag & VERT_SPEC_RGB)
-      COPY_4FV(ctx->Current.SecondaryColor, IM->SecondaryColor[count]);
+   if (flag & VERT_COLOR1_BIT)
+      COPY_4FV(ctx->Current.Attrib[VERT_ATTRIB_COLOR1], IM->SecondaryColor[count]);
 
-   if (flag & VERT_FOG_COORD)
-      ctx->Current.FogCoord = IM->FogCoord[count];
+   if (flag & VERT_FOG_BIT)
+      ctx->Current.Attrib[VERT_ATTRIB_FOG][0] = IM->FogCoord[count];
 
    if (flag & VERT_TEX_ANY) {
       GLuint i;
       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
 	 if (flag & VERT_TEX(i)) {
-	    COPY_4FV( ctx->Current.Texcoord[0], IM->TexCoord[0][count]);
+	    COPY_4FV( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], IM->TexCoord[i][count]);
 	 }
       }
    }
@@ -202,13 +207,11 @@ void _tnl_compute_orflag( struct immediate *IM, GLuint start )
 }
 
 
-
-
-
-
-
-
-/* Note: The 'start' member of the GLvector structs is now redundant
+/*
+ * This is where the vertex data is transfered from the 'struct immediate
+ * into the 'struct vertex_buffer'.
+ *
+ * Note: The 'start' member of the GLvector structs is now redundant
  * because we always re-transform copied vertices, and the vectors
  * below are set up so that the first copied vertex (if any) appears
  * at position zero.
@@ -263,7 +266,7 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
 
    /* Setup the initial values of array pointers in the vb.
     */
-   if (inputs & VERT_OBJ) {
+   if (inputs & VERT_OBJ_BIT) {
       tmp->Obj.data = IM->Obj + start;
       tmp->Obj.start = (GLfloat *)(IM->Obj + start);
       tmp->Obj.count = count;
@@ -276,7 +279,7 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
 	 tmp->Obj.size = 2;
    }
 
-   if (inputs & VERT_NORM) {
+   if (inputs & VERT_NORMAL_BIT) {
       tmp->Normal.data = IM->Normal + start;
       tmp->Normal.start = (GLfloat *)(IM->Normal + start);
       tmp->Normal.count = count;
@@ -285,40 +288,41 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
 	 VB->NormalLengthPtr = IM->NormalLengthPtr + start;
    }
 
-   if (inputs & VERT_INDEX) {
+   if (inputs & VERT_INDEX_BIT) {
       tmp->Index.count = count;
       tmp->Index.data = IM->Index + start;
       tmp->Index.start = IM->Index + start;
       VB->IndexPtr[0] = &tmp->Index;
    }
 
-   if (inputs & VERT_FOG_COORD) {
+   if (inputs & VERT_FOG_BIT) {
       tmp->FogCoord.data = IM->FogCoord + start;
       tmp->FogCoord.start = IM->FogCoord + start;
       tmp->FogCoord.count = count;
       VB->FogCoordPtr = &tmp->FogCoord;
    }
 
-   if (inputs & VERT_SPEC_RGB) {
+   if (inputs & VERT_COLOR1_BIT) {
       tmp->SecondaryColor.Ptr = IM->SecondaryColor + start;
       VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
    }
 
-   if (inputs & VERT_EDGE) {
+   if (inputs & VERT_EDGEFLAG_BIT) {
       VB->EdgeFlag = IM->EdgeFlag + start;
    }
 
-   if (inputs & VERT_RGBA) {
-      if (IM->CopyOrFlag & VERT_RGBA) {
+   if (inputs & VERT_COLOR0_BIT) {
+      if (IM->CopyOrFlag & VERT_COLOR0_BIT) {
 	 tmp->Color.Ptr = IM->Color + start;
 	 tmp->Color.StrideB = 4 * sizeof(GLfloat);
 	 tmp->Color.Flags = 0;
-      } else {
-	 tmp->Color.Ptr = ctx->Current.Color;
+      }
+      else {
+	 tmp->Color.Ptr = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
 	 tmp->Color.StrideB = 0;
 	 tmp->Color.Flags = CA_CLIENT_DATA; /* hack */
 	 VB->import_source = IM;
-	 VB->importable_data |= VERT_RGBA;
+	 VB->importable_data |= VERT_COLOR0_BIT;
 	 VB->import_data = _tnl_upgrade_current_data;
       }
       VB->ColorPtr[0] = &tmp->Color;
@@ -347,6 +351,18 @@ static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
       VB->MaterialMask = IM->MaterialMask + start;
       VB->Material = IM->Material + start;
    }
+
+   /* GL_NV_vertex_program */
+   if (ctx->VertexProgram.Enabled) {
+      GLuint attr;
+      for (attr = 0; attr < 16; attr++) {
+         tmp->Attribs[attr].count = count;
+         tmp->Attribs[attr].data = IM->Attrib[attr] + start;
+         tmp->Attribs[attr].start = (GLfloat *) (IM->Attrib[attr] + start);
+         tmp->Attribs[attr].size = 4;
+         VB->AttribPtr[attr] = &(tmp->Attribs[attr]);
+      }
+   }
 }
 
 
@@ -359,8 +375,6 @@ void _tnl_run_cassette( GLcontext *ctx, struct immediate *IM )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
 
-/*     fprintf(stderr, "%s\n", __FUNCTION__); */
-
    _tnl_vb_bind_immediate( ctx, IM );
 
    if (IM->OrFlag & VERT_EVAL_ANY)
@@ -449,6 +463,7 @@ void _tnl_execute_cassette( GLcontext *ctx, struct immediate *IM )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
 
+   printf("enter %s()\n", __FUNCTION__);
    _tnl_compute_orflag( IM, IM->Start );
    _tnl_copy_immediate_vertices( ctx, IM ); 
    _tnl_get_exec_copy_verts( ctx, IM );
@@ -456,6 +471,7 @@ void _tnl_execute_cassette( GLcontext *ctx, struct immediate *IM )
    if (tnl->pipeline.build_state_changes)
       _tnl_validate_pipeline( ctx );
 
+   printf("  CopyStart %d == Count %d ?\n", IM->CopyStart, IM->Count);
    if (IM->CopyStart == IM->Count) {
       exec_empty_cassette( ctx, IM );
    }
@@ -488,6 +504,7 @@ void _tnl_execute_cassette( GLcontext *ctx, struct immediate *IM )
 
    if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1)
       ctx->Driver.NeedFlush &= ~FLUSH_STORED_VERTICES;
+   printf("leave %s()\n", __FUNCTION__);
 }
 
 
diff --git a/src/mesa/tnl/t_imm_fixup.c b/src/mesa/tnl/t_imm_fixup.c
index ce593343a9..8da694a9e3 100644
--- a/src/mesa/tnl/t_imm_fixup.c
+++ b/src/mesa/tnl/t_imm_fixup.c
@@ -1,4 +1,4 @@
-/* $Id: t_imm_fixup.c,v 1.28 2001/12/03 17:47:04 keithw Exp $ */
+/* $Id: t_imm_fixup.c,v 1.29 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -194,37 +194,41 @@ fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
       data[i] = dflt;
 }
 
+/*
+ * Copy vertex attributes from the ctx->Current group into the immediate
+ * struct at the given position according to copyMask.
+ */
 static void copy_from_current( GLcontext *ctx, struct immediate *IM, 
-			      GLuint start, GLuint copy )
+			      GLuint pos, GLuint copyMask )
 {
    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      _tnl_print_vert_flags("copy from current", copy); 
+      _tnl_print_vert_flags("copy from current", copyMask); 
 
-   if (copy & VERT_NORM) {
-      COPY_3V( IM->Normal[start], ctx->Current.Normal );
+   if (copyMask & VERT_NORMAL_BIT) {
+      COPY_3V(IM->Normal[pos], ctx->Current.Attrib[VERT_ATTRIB_NORMAL]);
    }
 
-   if (copy & VERT_RGBA) {
-      COPY_4FV( IM->Color[start], ctx->Current.Color);
+   if (copyMask & VERT_COLOR0_BIT) {
+      COPY_4FV( IM->Color[pos], ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
    }
 
-   if (copy & VERT_SPEC_RGB)
-      COPY_4FV( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
+   if (copyMask & VERT_COLOR1_BIT)
+      COPY_4FV( IM->SecondaryColor[pos], ctx->Current.Attrib[VERT_ATTRIB_COLOR1]);
 
-   if (copy & VERT_FOG_COORD)
-      IM->FogCoord[start] = ctx->Current.FogCoord;
+   if (copyMask & VERT_FOG_BIT)
+      IM->FogCoord[pos] = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
 
-   if (copy & VERT_INDEX)
-      IM->Index[start] = ctx->Current.Index;
+   if (copyMask & VERT_INDEX_BIT)
+      IM->Index[pos] = ctx->Current.Index;
 
-   if (copy & VERT_EDGE)
-      IM->EdgeFlag[start] = ctx->Current.EdgeFlag;
+   if (copyMask & VERT_EDGEFLAG_BIT)
+      IM->EdgeFlag[pos] = ctx->Current.EdgeFlag;
 
-   if (copy & VERT_TEX_ANY) {
+   if (copyMask & VERT_TEX_ANY) {
       GLuint i;
       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
-	 if (copy & VERT_TEX(i))
-	    COPY_4FV( IM->TexCoord[i][start], ctx->Current.Texcoord[i] );
+	 if (copyMask & VERT_TEX(i))
+            COPY_4FV(IM->TexCoord[i][pos], ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i]);
       }
    }
 }
@@ -254,7 +258,7 @@ void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
    if (!ctx->ExecuteFlag)
       fixup &= orflag;
 
-   if ((orflag & (VERT_OBJ|VERT_EVAL_ANY)) == 0)
+   if ((orflag & (VERT_OBJ_BIT|VERT_EVAL_ANY)) == 0)
       fixup = 0;
 
    if (fixup) {
@@ -285,50 +289,50 @@ void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
       }
    
 
-      if (fixup & VERT_EDGE) {
-	 if (orflag & VERT_EDGE)
-	    _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_EDGE );
+      if (fixup & VERT_EDGEFLAG_BIT) {
+	 if (orflag & VERT_EDGEFLAG_BIT)
+	    _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_EDGEFLAG_BIT );
 	 else
 	    fixup_first_1ub( IM->EdgeFlag, IM->Flag, VERT_END_VB, start,
 			     IM->EdgeFlag[start] );
       }
 
-      if (fixup & VERT_INDEX) {
-	 if (orflag & VERT_INDEX)
-	    _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_INDEX );
+      if (fixup & VERT_INDEX_BIT) {
+	 if (orflag & VERT_INDEX_BIT)
+	    _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_INDEX_BIT );
 	 else
 	    fixup_first_1ui( IM->Index, IM->Flag, VERT_END_VB, start, 
 			     IM->Index[start] );
       }
 
-      if (fixup & VERT_RGBA) {
-	 if (orflag & VERT_RGBA)
-	    _tnl_fixup_4f( IM->Color, IM->Flag, start, VERT_RGBA );
+      if (fixup & VERT_COLOR0_BIT) {
+	 if (orflag & VERT_COLOR0_BIT)
+	    _tnl_fixup_4f( IM->Color, IM->Flag, start, VERT_COLOR0_BIT );
 	 /* No need for else case as the drivers understand stride
 	  * zero here.  (TODO - propogate this)
 	  */
       }
       
-      if (fixup & VERT_SPEC_RGB) {
-	 if (orflag & VERT_SPEC_RGB)
+      if (fixup & VERT_COLOR1_BIT) {
+	 if (orflag & VERT_COLOR1_BIT)
 	    _tnl_fixup_4f( IM->SecondaryColor, IM->Flag, start, 
-			   VERT_SPEC_RGB );
+			   VERT_COLOR1_BIT );
 	 else
 	    fixup_first_4f( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
 			    IM->SecondaryColor[start] );
       }
       
-      if (fixup & VERT_FOG_COORD) {
-	 if (orflag & VERT_FOG_COORD)
-	    _tnl_fixup_1f( IM->FogCoord, IM->Flag, start, VERT_FOG_COORD );
+      if (fixup & VERT_FOG_BIT) {
+	 if (orflag & VERT_FOG_BIT)
+	    _tnl_fixup_1f( IM->FogCoord, IM->Flag, start, VERT_FOG_BIT );
 	 else
 	    fixup_first_1f( IM->FogCoord, IM->Flag, VERT_END_VB, start,
 			    IM->FogCoord[start] );
       }
 
-      if (fixup & VERT_NORM) {
-	 if (orflag & VERT_NORM)
-	    _tnl_fixup_3f( IM->Normal, IM->Flag, start, VERT_NORM );
+      if (fixup & VERT_NORMAL_BIT) {
+	 if (orflag & VERT_NORMAL_BIT)
+	    _tnl_fixup_3f( IM->Normal, IM->Flag, start, VERT_NORMAL_BIT );
 	 else
 	    fixup_first_3f( IM->Normal, IM->Flag, VERT_END_VB, start,
 			    IM->Normal[start] );
@@ -417,6 +421,7 @@ void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
    }
 
    next->CopyStart = next->Start - count;
+   printf("%s() CopyStart = %d\n", __FUNCTION__, next->CopyStart);
 
    if ((prev->CopyOrFlag & VERT_DATA) == VERT_ELT &&
        ctx->Array.LockCount &&
@@ -472,7 +477,7 @@ void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
 	  */
 	 COPY_4FV( next->Obj[dst], inputs->Obj.data[isrc] );
 
-	 if (copy & VERT_NORM) {
+	 if (copy & VERT_NORMAL_BIT) {
 /*  	    fprintf(stderr, "copy vert norm %d to %d (%p): %f %f %f\n", */
 /*  		    isrc, dst,  */
 /*  		    next->Normal[dst], */
@@ -482,11 +487,11 @@ void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
 	    COPY_3FV( next->Normal[dst], inputs->Normal.data[isrc] );
 	 }
 
-	 if (copy & VERT_RGBA)
+	 if (copy & VERT_COLOR0_BIT)
 	    COPY_4FV( next->Color[dst], 
 		      ((GLfloat (*)[4])inputs->Color.Ptr)[isrc] );
 
-	 if (copy & VERT_INDEX)
+	 if (copy & VERT_INDEX_BIT)
 	    next->Index[dst] = inputs->Index.data[isrc];
 
 	 if (copy & VERT_TEX_ANY) {
@@ -501,7 +506,7 @@ void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
 	 /* Remaining values should be the same in the 'input' struct and the
 	  * original immediate.
 	  */
-	 if (copy & (VERT_ELT|VERT_EDGE|VERT_SPEC_RGB|VERT_FOG_COORD|
+	 if (copy & (VERT_ELT|VERT_EDGEFLAG_BIT|VERT_COLOR1_BIT|VERT_FOG_BIT|
 		     VERT_MATERIAL)) {
 
 	    if (prev->Flag[src] & VERT_MATERIAL)
@@ -516,7 +521,7 @@ void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
 	 next->Flag[dst] = flag;
 	 next->CopyOrFlag |= prev->Flag[src] & (VERT_FIXUP|
 						VERT_MATERIAL|
-						VERT_OBJ);
+						VERT_OBJ_BIT);
       }
    }
 
@@ -580,37 +585,37 @@ void _tnl_fixup_compiled_cassette( GLcontext *ctx, struct immediate *IM )
 	 for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
 	    if (fixup & VERT_TEX(i))
 	       fixup_first_4f( IM->TexCoord[i], IM->Flag, VERT_TEX(i), start,
-			       ctx->Current.Texcoord[i] );
+			       ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i] );
 	 }
       }
 
-      if (fixup & VERT_EDGE)
-	 fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_EDGE, start,
+      if (fixup & VERT_EDGEFLAG_BIT)
+	 fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_EDGEFLAG_BIT, start,
 			 ctx->Current.EdgeFlag );
 
-      if (fixup & VERT_INDEX)
-	 fixup_first_1ui(IM->Index, IM->Flag, VERT_INDEX, start,
+      if (fixup & VERT_INDEX_BIT)
+	 fixup_first_1ui(IM->Index, IM->Flag, VERT_INDEX_BIT, start,
 			 ctx->Current.Index );
 
-      if (fixup & VERT_RGBA) {
-	 if (IM->CopyOrFlag & VERT_RGBA)
-	    fixup_first_4f(IM->Color, IM->Flag, VERT_RGBA, start,
-			   ctx->Current.Color );
+      if (fixup & VERT_COLOR0_BIT) {
+	 if (IM->CopyOrFlag & VERT_COLOR0_BIT)
+	    fixup_first_4f(IM->Color, IM->Flag, VERT_COLOR0_BIT, start,
+			   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 	 else
-	    fixup &= ~VERT_RGBA;
+	    fixup &= ~VERT_COLOR0_BIT;
       }
 
-      if (fixup & VERT_SPEC_RGB)
-	 fixup_first_4f(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
-			ctx->Current.SecondaryColor );
+      if (fixup & VERT_COLOR1_BIT)
+	 fixup_first_4f(IM->SecondaryColor, IM->Flag, VERT_COLOR1_BIT, start,
+			ctx->Current.Attrib[VERT_ATTRIB_COLOR1] );
 
-      if (fixup & VERT_FOG_COORD)
-	 fixup_first_1f(IM->FogCoord, IM->Flag, VERT_FOG_COORD, start,
-			 ctx->Current.FogCoord );
+      if (fixup & VERT_FOG_BIT)
+	 fixup_first_1f(IM->FogCoord, IM->Flag, VERT_FOG_BIT, start,
+			 ctx->Current.Attrib[VERT_ATTRIB_FOG][0] );
 
-      if (fixup & VERT_NORM) {
-	 fixup_first_3f(IM->Normal, IM->Flag, VERT_NORM, start,
-			ctx->Current.Normal );
+      if (fixup & VERT_NORMAL_BIT) {
+	 fixup_first_3f(IM->Normal, IM->Flag, VERT_NORMAL_BIT, start,
+			ctx->Current.Attrib[VERT_ATTRIB_NORMAL] );
       }
 
       IM->CopyOrFlag |= fixup;
@@ -795,7 +800,7 @@ void _tnl_upgrade_current_data( GLcontext *ctx,
 
 /*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
 
-   if ((required & VERT_RGBA) && (VB->ColorPtr[0]->Flags & CA_CLIENT_DATA)) {
+   if ((required & VERT_COLOR0_BIT) && (VB->ColorPtr[0]->Flags & CA_CLIENT_DATA)) {
       struct gl_client_array *tmp = &tnl->imm_inputs.Color;
       GLuint start = IM->CopyStart;
 
@@ -803,7 +808,7 @@ void _tnl_upgrade_current_data( GLcontext *ctx,
       tmp->StrideB = 4 * sizeof(GLfloat);
       tmp->Flags = 0;
 
-      COPY_4FV( IM->Color[start], ctx->Current.Color);   
+      COPY_4FV( IM->Color[start], ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);   
 
       /*
       ASSERT(IM->Flag[IM->LastData+1] & VERT_END_VB);
@@ -812,7 +817,7 @@ void _tnl_upgrade_current_data( GLcontext *ctx,
       fixup_first_4f( IM->Color, IM->Flag, VERT_END_VB, start, 
 		      IM->Color[start] );
 
-      VB->importable_data &= ~VERT_RGBA;
+      VB->importable_data &= ~VERT_COLOR0_BIT;
    }
 }
  
diff --git a/src/mesa/tnl/t_pipeline.c b/src/mesa/tnl/t_pipeline.c
index acca9d85b6..6e39788f9d 100644
--- a/src/mesa/tnl/t_pipeline.c
+++ b/src/mesa/tnl/t_pipeline.c
@@ -1,4 +1,4 @@
-/* $Id: t_pipeline.c,v 1.19 2001/05/21 16:33:41 gareth Exp $ */
+/* $Id: t_pipeline.c,v 1.20 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -131,6 +131,8 @@ void _tnl_run_pipeline( GLcontext *ctx )
    pipe->run_state_changes = 0;
    pipe->run_input_changes = 0;
 
+   printf("%s()\n", __FUNCTION__);
+
    /* Done elsewhere.
     */
    ASSERT(pipe->build_state_changes == 0);
@@ -203,6 +205,7 @@ const struct gl_pipeline_stage *_tnl_default_pipeline[] = {
    &_tnl_texgen_stage,
    &_tnl_texture_transform_stage,
    &_tnl_point_attenuation_stage,
+   &_tnl_vertex_program_stage,
    &_tnl_render_stage,
    0
 };
diff --git a/src/mesa/tnl/t_pipeline.h b/src/mesa/tnl/t_pipeline.h
index cb057df810..6138df32d5 100644
--- a/src/mesa/tnl/t_pipeline.h
+++ b/src/mesa/tnl/t_pipeline.h
@@ -1,4 +1,4 @@
-/* $Id: t_pipeline.h,v 1.8 2001/07/12 22:09:22 keithw Exp $ */
+/* $Id: t_pipeline.h,v 1.9 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -54,6 +54,7 @@ extern const struct gl_pipeline_stage _tnl_fog_coordinate_stage;
 extern const struct gl_pipeline_stage _tnl_texgen_stage;
 extern const struct gl_pipeline_stage _tnl_texture_transform_stage;
 extern const struct gl_pipeline_stage _tnl_point_attenuation_stage;
+extern const struct gl_pipeline_stage _tnl_vertex_program_stage;
 extern const struct gl_pipeline_stage _tnl_render_stage;
 
 /* Shorthand to plug in the default pipeline:
diff --git a/src/mesa/tnl/t_vb_fog.c b/src/mesa/tnl/t_vb_fog.c
index 6fad9528cd..9e3d440b6a 100644
--- a/src/mesa/tnl/t_vb_fog.c
+++ b/src/mesa/tnl/t_vb_fog.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_fog.c,v 1.12 2001/09/14 21:30:31 brianp Exp $ */
+/* $Id: t_vb_fog.c,v 1.13 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -166,8 +166,7 @@ static GLboolean run_fog_stage( GLcontext *ctx,
 
 	 input->count = VB->ObjPtr->count;
       }
-      else
-      {
+      else {
 	 input = &store->input;
 
 	 if (VB->EyePtr->size < 2)
@@ -178,7 +177,8 @@ static GLboolean run_fog_stage( GLcontext *ctx,
 	 input->stride = VB->EyePtr->stride;
 	 input->count = VB->EyePtr->count;
       }
-   } else {
+   }
+   else {
       /* use glFogCoord() coordinates */
       /* source = VB->FogCoordPtr */
       input = VB->FogCoordPtr;
@@ -190,14 +190,15 @@ static GLboolean run_fog_stage( GLcontext *ctx,
    return GL_TRUE;
 }
 
+
 static void check_fog_stage( GLcontext *ctx, struct gl_pipeline_stage *stage )
 {
-   stage->active = ctx->Fog.Enabled;
+   stage->active = ctx->Fog.Enabled && !ctx->VertexProgram.Enabled;
 
    if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
       stage->inputs = VERT_EYE;
    else
-      stage->inputs = VERT_FOG_COORD;
+      stage->inputs = VERT_FOG_BIT;
 }
 
 
@@ -239,11 +240,14 @@ static void free_fog_data( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_fog_coordinate_stage =
 {
-   "build fog coordinates",
-   _NEW_FOG,
-   _NEW_FOG,
-   0, 0, VERT_FOG_COORD,	/* active, inputs, outputs */
-   0, 0,			/* changed_inputs, private_data */
+   "build fog coordinates",	/* name */
+   _NEW_FOG,			/* check_state */
+   _NEW_FOG,			/* run_state */
+   GL_FALSE,			/* active? */
+   0,				/* inputs */
+   VERT_FOG_BIT,		/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private_data */
    free_fog_data,		/* dtr */
    check_fog_stage,		/* check */
    alloc_fog_data		/* run -- initially set to init. */
diff --git a/src/mesa/tnl/t_vb_light.c b/src/mesa/tnl/t_vb_light.c
index d0f4981cbd..bbf43468c0 100644
--- a/src/mesa/tnl/t_vb_light.c
+++ b/src/mesa/tnl/t_vb_light.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_light.c,v 1.15 2001/07/17 19:39:32 keithw Exp $ */
+/* $Id: t_vb_light.c,v 1.16 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -168,12 +168,12 @@ static GLboolean run_lighting( GLcontext *ctx, struct gl_pipeline_stage *stage )
    /* Make sure we can talk about elements 0..2 in the vector we are
     * lighting.
     */
-   if (stage->changed_inputs & (VERT_EYE|VERT_OBJ)) {
+   if (stage->changed_inputs & (VERT_EYE|VERT_OBJ_BIT)) {
       if (input->size <= 2) {
 	 if (input->flags & VEC_NOT_WRITEABLE) {
-	    ASSERT(VB->importable_data & VERT_OBJ);
+	    ASSERT(VB->importable_data & VERT_OBJ_BIT);
 
-	    VB->import_data( ctx, VERT_OBJ, VEC_NOT_WRITEABLE );
+	    VB->import_data( ctx, VERT_OBJ_BIT, VEC_NOT_WRITEABLE );
 	    input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
 
 	    ASSERT((input->flags & VEC_NOT_WRITEABLE) == 0);
@@ -295,19 +295,19 @@ static GLboolean run_init_lighting( GLcontext *ctx,
  */
 static void check_lighting( GLcontext *ctx, struct gl_pipeline_stage *stage )
 {
-   stage->active = ctx->Light.Enabled;
+   stage->active = ctx->Light.Enabled && !ctx->VertexProgram.Enabled;
    if (stage->active) {
       if (stage->privatePtr)
 	 stage->run = run_validate_lighting;
-      stage->inputs = VERT_NORM|VERT_MATERIAL;
+      stage->inputs = VERT_NORMAL_BIT|VERT_MATERIAL;
       if (ctx->Light._NeedVertices)
 	 stage->inputs |= VERT_EYE; /* effectively, even when lighting in obj */
       if (ctx->Light.ColorMaterialEnabled)
-	 stage->inputs |= VERT_RGBA;
+	 stage->inputs |= VERT_COLOR0_BIT;
 
-      stage->outputs = VERT_RGBA;
+      stage->outputs = VERT_COLOR0_BIT;
       if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-	 stage->outputs |= VERT_SPEC_RGB;
+	 stage->outputs |= VERT_COLOR1_BIT;
    }
 }
 
@@ -334,13 +334,16 @@ static void dtr( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_lighting_stage =
 {
-   "lighting",
+   "lighting",			/* name */
    _NEW_LIGHT,			/* recheck */
    _NEW_LIGHT|_NEW_MODELVIEW,	/* recalc -- modelview dependency
 				 * otherwise not captured by inputs
-				 * (which may be VERT_OBJ) */
-   0,0,0,			/* active, inputs, outputs */
-   0,0,				/* changed_inputs, private_data */
+				 * (which may be VERT_OBJ_BIT) */
+   GL_FALSE,			/* active? */
+   0,				/* inputs */
+   0,				/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private_data */
    dtr,				/* destroy */
    check_lighting,		/* check */
    run_init_lighting		/* run -- initially set to ctr */
diff --git a/src/mesa/tnl/t_vb_lighttmp.h b/src/mesa/tnl/t_vb_lighttmp.h
index 25e29ce606..691d9716ac 100644
--- a/src/mesa/tnl/t_vb_lighttmp.h
+++ b/src/mesa/tnl/t_vb_lighttmp.h
@@ -1,4 +1,4 @@
-/* $Id: t_vb_lighttmp.h,v 1.19 2001/10/20 00:13:45 keithw Exp $ */
+/* $Id: t_vb_lighttmp.h,v 1.20 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -37,20 +37,20 @@
 #  define CHECK_END_VB(x)    (flags[x] & VERT_END_VB)
 #  if (IDX & LIGHT_COLORMATERIAL)
 #    define CMSTRIDE STRIDE_F(CMcolor, CMstride)
-#    define CHECK_COLOR_MATERIAL(x) (flags[x] & VERT_RGBA)
-#    define CHECK_VALIDATE(x) (flags[x] & (VERT_RGBA|VERT_MATERIAL))
+#    define CHECK_COLOR_MATERIAL(x) (flags[x] & VERT_COLOR0_BIT)
+#    define CHECK_VALIDATE(x) (flags[x] & (VERT_COLOR0_BIT|VERT_MATERIAL))
 #    define DO_ANOTHER_NORMAL(x) \
-     ((flags[x] & (VERT_RGBA|VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == VERT_NORM)
+     ((flags[x] & (VERT_COLOR0_BIT|VERT_NORMAL_BIT|VERT_END_VB|VERT_MATERIAL)) == VERT_NORMAL_BIT)
 #    define REUSE_LIGHT_RESULTS(x) \
-     ((flags[x] & (VERT_RGBA|VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == 0)
+     ((flags[x] & (VERT_COLOR0_BIT|VERT_NORMAL_BIT|VERT_END_VB|VERT_MATERIAL)) == 0)
 #  else
 #    define CMSTRIDE (void)0
 #    define CHECK_COLOR_MATERIAL(x) 0
 #    define CHECK_VALIDATE(x) (flags[x] & (VERT_MATERIAL))
 #    define DO_ANOTHER_NORMAL(x) \
-      ((flags[x] & (VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == VERT_NORM)
+      ((flags[x] & (VERT_NORMAL_BIT|VERT_END_VB|VERT_MATERIAL)) == VERT_NORMAL_BIT)
 #    define REUSE_LIGHT_RESULTS(x) \
-      ((flags[x] & (VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == 0)
+      ((flags[x] & (VERT_NORMAL_BIT|VERT_END_VB|VERT_MATERIAL)) == 0)
 #  endif
 #else
 #  define VSTRIDE vstride
diff --git a/src/mesa/tnl/t_vb_normals.c b/src/mesa/tnl/t_vb_normals.c
index 1a71b13be3..aff84b0848 100644
--- a/src/mesa/tnl/t_vb_normals.c
+++ b/src/mesa/tnl/t_vb_normals.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_normals.c,v 1.9 2001/06/28 17:34:14 keithw Exp $ */
+/* $Id: t_vb_normals.c,v 1.10 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -128,7 +128,7 @@ static GLboolean run_validate_normal_stage( GLcontext *ctx,
 static void check_normal_transform( GLcontext *ctx,
 				    struct gl_pipeline_stage *stage )
 {
-   stage->active = ctx->_NeedNormals;
+   stage->active = ctx->_NeedNormals && !ctx->VertexProgram.Enabled;
    /* Don't clobber the initialize function:
     */
    if (stage->privatePtr)
@@ -175,11 +175,14 @@ static void free_normal_data( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_normal_transform_stage =
 {
-   "normal transform",
+   "normal transform",		/* name */
    _TNL_NEW_NORMAL_TRANSFORM,	/* re-check */
    _TNL_NEW_NORMAL_TRANSFORM,	/* re-run */
-   0,VERT_NORM,VERT_NORM,	/* active, inputs, outputs */
-   0, 0,			/* changed_inputs, private */
+   GL_FALSE,			/* active? */
+   VERT_NORMAL_BIT,		/* inputs */
+   VERT_NORMAL_BIT,		/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private data */
    free_normal_data,		/* destructor */
    check_normal_transform,	/* check */
    alloc_normal_data		/* run -- initially set to alloc */
diff --git a/src/mesa/tnl/t_vb_points.c b/src/mesa/tnl/t_vb_points.c
index 2c35d43610..c60a0f56b1 100644
--- a/src/mesa/tnl/t_vb_points.c
+++ b/src/mesa/tnl/t_vb_points.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_points.c,v 1.4 2001/03/12 00:48:44 gareth Exp $ */
+/* $Id: t_vb_points.c,v 1.5 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -113,11 +113,11 @@ const struct gl_pipeline_stage _tnl_point_attenuation_stage =
    "point size attenuation",	/* name */
    _NEW_POINT,			/* build_state_change */
    _NEW_POINT,			/* run_state_change */
-   0,				/* active */
+   GL_FALSE,			/* active */
    VERT_EYE,			/* inputs */
    VERT_POINT_SIZE,		/* outputs */
    0,				/* changed_inputs (temporary value) */
-   0,				/* stage private data */
+   NULL,			/* stage private data */
    free_point_data,		/* destructor */
    check_point_size,		/* check */
    alloc_point_data		/* run -- initially set to alloc data */
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
new file mode 100644
index 0000000000..29a6ca5e65
--- /dev/null
+++ b/src/mesa/tnl/t_vb_program.c
@@ -0,0 +1,1028 @@
+/* $Id: t_vb_program.c,v 1.1 2001/12/14 02:51:45 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.1
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * -------- Regarding NV_vertex_program --------
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * o Redistribution of the source code must contain a copyright notice
+ *   and this list of conditions;
+ * 
+ * o Redistribution in binary and source code form must contain the
+ *   following Notice in the software and any documentation and/or other
+ *   materials provided with the distribution; and
+ * 
+ * o The name of Nvidia may not be used to promote or endorse software
+ *   derived from the software.
+ * 
+ * NOTICE: Nvidia hereby grants to each recipient a non-exclusive worldwide
+ * royalty free patent license under patent claims that are licensable by
+ * Nvidia and which are necessarily required and for which no commercially
+ * viable non infringing alternative exists to make, use, sell, offer to sell,
+ * import and otherwise transfer the vertex extension for the Mesa 3D Graphics
+ * Library as distributed in source code and object code form.  No hardware or
+ * hardware implementation (including a semiconductor implementation and chips)
+ * are licensed hereunder. If a recipient makes a patent claim or institutes
+ * patent litigation against Nvidia or Nvidia's customers for use or sale of
+ * Nvidia products, then this license grant as to such recipient shall
+ * immediately terminate and recipient immediately agrees to cease use and
+ * distribution of the Mesa Program and derivatives thereof. 
+ * 
+ * THE MESA 3D GRAPHICS LIBRARY IS PROVIDED ON AN "AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+ * WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-NFRINGEMENT
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * NVIDIA SHALL NOT HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
+ * LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE MESA 3D GRAPHICS
+ * LIBRARY OR EVIDENCE OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDR, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * If you do not comply with this agreement, then Nvidia may cancel the license
+ * and rights granted herein.
+ * ---------------------------------------------
+ */
+
+/*
+ * Authors:
+ *    Brian Paul
+ */
+
+
+#include "glheader.h"
+#include "api_noop.h"
+#include "colormac.h"
+#include "context.h"
+#include "dlist.h"
+#include "hash.h"
+#include "light.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "simple_list.h"
+#include "mtypes.h"
+#include "vpexec.h"
+
+#include "math/m_translate.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+#include "t_imm_api.h"
+#include "t_imm_exec.h"
+
+
+
+static void
+_vp_ArrayElement( GLint i )
+{
+   /* XXX to do */
+}
+
+static void
+_vp_Color3f( GLfloat r, GLfloat g, GLfloat b )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   ASSIGN_4V(attrib, r, g, b, 1.0F);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color3fv( const GLfloat *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   ASSIGN_4V(attrib, color[0], color[1], color[2], 1.0F);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color3ub( GLubyte r, GLubyte g, GLubyte b )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(r);
+   attrib[1] = UBYTE_TO_FLOAT(g);
+   attrib[2] = UBYTE_TO_FLOAT(b);
+   attrib[3] = 1.0F;
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color3ubv( const GLubyte *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(color[0]);
+   attrib[1] = UBYTE_TO_FLOAT(color[1]);
+   attrib[2] = UBYTE_TO_FLOAT(color[2]);
+   attrib[3] = 1.0F;
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color4f( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   ASSIGN_4V(attrib, r, g, b, a);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color4fv( const GLfloat *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   COPY_4V(attrib, color);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color4ub( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(r);
+   attrib[1] = UBYTE_TO_FLOAT(g);
+   attrib[2] = UBYTE_TO_FLOAT(b);
+   attrib[3] = UBYTE_TO_FLOAT(a);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_Color4ubv( const GLubyte *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR0][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(color[0]);
+   attrib[1] = UBYTE_TO_FLOAT(color[1]);
+   attrib[2] = UBYTE_TO_FLOAT(color[2]);
+   attrib[3] = UBYTE_TO_FLOAT(color[3]);
+   IM->Flag[IM->Count] |= VERT_COLOR0_BIT;
+}
+
+static void
+_vp_EdgeFlag( GLboolean flag )
+{
+   GET_IMMEDIATE;
+   IM->EdgeFlag[IM->Count] = flag;
+   IM->Flag[IM->Count] |= VERT_EDGEFLAG_BIT;
+}
+
+static void
+_vp_EdgeFlagv( const GLboolean *flag )
+{
+   GET_IMMEDIATE;
+   IM->EdgeFlag[IM->Count] = *flag;
+   IM->Flag[IM->Count] |= VERT_EDGEFLAG_BIT;
+}
+
+static void
+_vp_EvalCoord1f( GLfloat s )
+{
+   (void) s;
+   /* XXX no-op? */
+}
+
+static void
+_vp_EvalCoord1fv( const GLfloat *v )
+{
+   (void) v;
+   /* XXX no-op? */
+}
+
+static void
+_vp_EvalCoord2f( GLfloat s, GLfloat t )
+{
+   (void) s;
+   (void )t;
+   /* XXX no-op? */
+}
+
+static void
+_vp_EvalCoord2fv( const GLfloat *v )
+{
+   (void) v;
+   /* XXX no-op? */
+}
+
+static void
+_vp_EvalPoint1( GLint i )
+{
+   (void) i;
+}
+
+static void
+_vp_EvalPoint2( GLint i, GLint j )
+{
+   (void) i;
+   (void) j;
+}
+
+static void
+_vp_FogCoordf( GLfloat f )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_FOG][IM->Count];
+   ASSIGN_4V(attrib, f, 0.0F, 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_FOG_BIT;
+}
+
+static void
+_vp_FogCoordfv( const GLfloat *f )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_FOG][IM->Count];
+   ASSIGN_4V(attrib, f[0], 0.0F, 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_FOG_BIT;
+}
+
+static void
+_vp_Indexi( GLint i )
+{
+   (void) i;
+}
+
+static void
+_vp_Indexiv( const GLint *i )
+{
+   (void) i;
+}
+
+static void
+_vp_Materialfv( GLenum face, GLenum pname, const GLfloat *v)
+{
+   /* XXX no-op? */
+}
+
+static void
+_vp_MultiTexCoord1f( GLenum unit, GLfloat s )
+{
+   const GLint u = (GLint) unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, s, 0.0F, 0.0F, 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord1fv( GLenum unit, const GLfloat *c )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, c[0], 0.0F, 0.0F, 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord2f( GLenum unit, GLfloat s, GLfloat t )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, s, t, 0.0F, 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord2fv( GLenum unit, const GLfloat *c )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, c[0], c[1], 0.0F, 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord3f( GLenum unit, GLfloat s, GLfloat t, GLfloat r )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, s, t, r, 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord3fv( GLenum unit, const GLfloat *c )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, c[0], c[1], c[2], 1.0F);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord4f( GLenum unit, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      ASSIGN_4V(attrib, s, t, r, q);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_MultiTexCoord4fv( GLenum unit, const GLfloat *c )
+{
+   const GLint u = unit - GL_TEXTURE0_ARB;
+   if (u >=0 && u < 8) {
+      GET_IMMEDIATE;
+      GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0 + u][IM->Count];
+      COPY_4V(attrib, c);
+      IM->Flag[IM->Count] |= (VERT_TEX0_BIT << u);
+   }
+}
+
+static void
+_vp_Normal3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_NORMAL][IM->Count];
+   ASSIGN_4V(attrib, x, y, z, 1.0F);
+   IM->Flag[IM->Count] |= VERT_NORMAL_BIT;
+}
+
+static void
+_vp_Normal3fv( const GLfloat *n )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_NORMAL][IM->Count];
+   ASSIGN_4V(attrib, n[0], n[1], n[2], 1.0F);
+   IM->Flag[IM->Count] |= VERT_NORMAL_BIT;
+}
+
+static void
+_vp_SecondaryColor3f( GLfloat r, GLfloat g, GLfloat b )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR1][IM->Count];
+   ASSIGN_4V(attrib, r, g, b, 1.0F);
+   IM->Flag[IM->Count] |= VERT_COLOR1_BIT;
+}
+
+static void
+_vp_SecondaryColor3fv( const GLfloat *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR1][IM->Count];
+   ASSIGN_4V(attrib, color[0], color[1], color[2], 1.0F);
+   IM->Flag[IM->Count] |= VERT_COLOR1_BIT;
+}
+
+static void
+_vp_SecondaryColor3ub( GLubyte r, GLubyte g, GLubyte b )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR1][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(r);
+   attrib[1] = UBYTE_TO_FLOAT(g);
+   attrib[2] = UBYTE_TO_FLOAT(b);
+   attrib[3] = 1.0F;
+   IM->Flag[IM->Count] |= VERT_COLOR1_BIT;
+}
+
+static void
+_vp_SecondaryColor3ubv( const GLubyte *color )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_COLOR1][IM->Count];
+   attrib[0] = UBYTE_TO_FLOAT(color[0]);
+   attrib[1] = UBYTE_TO_FLOAT(color[1]);
+   attrib[2] = UBYTE_TO_FLOAT(color[2]);
+   attrib[3] = 1.0F;
+   IM->Flag[IM->Count] |= VERT_COLOR1_BIT;
+}
+
+static void
+_vp_TexCoord1f( GLfloat s )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, s, 0.0F, 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord1fv( const GLfloat *c )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, c[0], 0.0F, 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord2f( GLfloat s, GLfloat t )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, s, t, 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord2fv( const GLfloat *c )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, c[0], c[1], 0.0F, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord3f( GLfloat s, GLfloat t, GLfloat r )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, s, t, r, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord3fv( const GLfloat *c )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, c[0], c[1], c[2], 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   ASSIGN_4V(attrib, s, t, r, 1.0F);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_TexCoord4fv( const GLfloat *c )
+{
+   GET_IMMEDIATE;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_TEX0][IM->Count];
+   COPY_4V(attrib, c);
+   IM->Flag[IM->Count] |= VERT_TEX0_BIT;
+}
+
+static void
+_vp_Vertex2f( GLfloat x, GLfloat y )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   ASSIGN_4V(attrib, x, y, 0.0F, 1.0F);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_Vertex2fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   ASSIGN_4V(attrib, v[0], v[1], 0.0F, 1.0F);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   ASSIGN_4V(attrib, x, y, z, 1.0F);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_Vertex3fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   ASSIGN_4V(attrib, v[0], v[1], v[2], 1.0F);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   ASSIGN_4V(attrib, x, y, z, w);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_Vertex4fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   const GLuint count = IM->Count++;
+   GLfloat *attrib = IM->Attrib[VERT_ATTRIB_POS][count];
+   COPY_4V(attrib, v);
+   IM->Flag[count] |= VERT_OBJ_BIT;
+   if (count == IMM_MAXDATA - 1)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_vp_VertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   if (index < 16) {
+      GET_IMMEDIATE;
+      const GLuint count = IM->Count;
+      GLfloat *attrib = IM->Attrib[index][count];
+      ASSIGN_4V(attrib, x, y, z, w);
+      IM->Flag[count] |= (1 << index);
+      if (index == 0) {
+         IM->Count++;
+         if (count == IMM_MAXDATA - 1)
+            _tnl_flush_immediate( IM );
+      }
+   }
+}   
+
+static void
+_vp_VertexAttrib4fv( GLuint index, const GLfloat *v )
+{
+   if (index < 16) {
+      GET_IMMEDIATE;
+      const GLuint count = IM->Count;
+      GLfloat *attrib = IM->Attrib[index][count];
+      COPY_4V(attrib, v);
+      IM->Flag[count] |= (1 << index);
+      if (index == 0) {
+         IM->Count++;
+         if (count == IMM_MAXDATA - 1)
+            _tnl_flush_immediate( IM );
+      }
+   }
+}   
+
+
+/*
+ * When vertex program mode is enabled we hook in different per-vertex
+ * functions.
+ */
+void _tnl_vprog_vtxfmt_init( GLcontext *ctx )
+{
+   GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
+
+   printf("%s()\n", __FUNCTION__);
+
+   /* All begin/end operations are handled by this vertex format:
+    */
+   vfmt->ArrayElement = _vp_ArrayElement;
+   vfmt->Begin = _tnl_Begin;
+   vfmt->Color3f = _vp_Color3f;
+   vfmt->Color3fv = _vp_Color3fv;
+   vfmt->Color3ub = _vp_Color3ub;
+   vfmt->Color3ubv = _vp_Color3ubv;
+   vfmt->Color4f = _vp_Color4f;
+   vfmt->Color4fv = _vp_Color4fv;
+   vfmt->Color4ub = _vp_Color4ub;
+   vfmt->Color4ubv = _vp_Color4ubv;
+   vfmt->EdgeFlag = _vp_EdgeFlag;
+   vfmt->EdgeFlagv = _vp_EdgeFlagv;
+   vfmt->End = _tnl_End;
+   vfmt->EvalCoord1f = _vp_EvalCoord1f;
+   vfmt->EvalCoord1fv = _vp_EvalCoord1fv;
+   vfmt->EvalCoord2f = _vp_EvalCoord2f;
+   vfmt->EvalCoord2fv = _vp_EvalCoord2fv;
+   vfmt->EvalPoint1 = _vp_EvalPoint1;
+   vfmt->EvalPoint2 = _vp_EvalPoint2;
+   vfmt->FogCoordfEXT = _vp_FogCoordf;
+   vfmt->FogCoordfvEXT = _vp_FogCoordfv;
+   vfmt->Indexi = _vp_Indexi;
+   vfmt->Indexiv = _vp_Indexiv;
+   vfmt->Materialfv = _vp_Materialfv;
+   vfmt->MultiTexCoord1fARB = _vp_MultiTexCoord1f;
+   vfmt->MultiTexCoord1fvARB = _vp_MultiTexCoord1fv;
+   vfmt->MultiTexCoord2fARB = _vp_MultiTexCoord2f;
+   vfmt->MultiTexCoord2fvARB = _vp_MultiTexCoord2fv;
+   vfmt->MultiTexCoord3fARB = _vp_MultiTexCoord3f;
+   vfmt->MultiTexCoord3fvARB = _vp_MultiTexCoord3fv;
+   vfmt->MultiTexCoord4fARB = _vp_MultiTexCoord4f;
+   vfmt->MultiTexCoord4fvARB = _vp_MultiTexCoord4fv;
+   vfmt->Normal3f = _vp_Normal3f;
+   vfmt->Normal3fv = _vp_Normal3fv;
+   vfmt->SecondaryColor3fEXT = _vp_SecondaryColor3f;
+   vfmt->SecondaryColor3fvEXT = _vp_SecondaryColor3fv;
+   vfmt->SecondaryColor3ubEXT = _vp_SecondaryColor3ub;
+   vfmt->SecondaryColor3ubvEXT = _vp_SecondaryColor3ubv;
+   vfmt->TexCoord1f = _vp_TexCoord1f;
+   vfmt->TexCoord1fv = _vp_TexCoord1fv;
+   vfmt->TexCoord2f = _vp_TexCoord2f;
+   vfmt->TexCoord2fv = _vp_TexCoord2fv;
+   vfmt->TexCoord3f = _vp_TexCoord3f;
+   vfmt->TexCoord3fv = _vp_TexCoord3fv;
+   vfmt->TexCoord4f = _vp_TexCoord4f;
+   vfmt->TexCoord4fv = _vp_TexCoord4fv;
+   vfmt->Vertex2f = _vp_Vertex2f;
+   vfmt->Vertex2fv = _vp_Vertex2fv;
+   vfmt->Vertex3f = _vp_Vertex3f;
+   vfmt->Vertex3fv = _vp_Vertex3fv;
+   vfmt->Vertex4f = _vp_Vertex4f;
+   vfmt->Vertex4fv = _vp_Vertex4fv;
+   vfmt->VertexAttrib4fNV = _vp_VertexAttrib4f;
+   vfmt->VertexAttrib4fvNV = _vp_VertexAttrib4fv;
+
+   /* Outside begin/end functions (from t_varray.c, t_eval.c, ...):
+    */
+   vfmt->Rectf = _mesa_noop_Rectf;
+
+   /* Just use the core function:
+    */
+   vfmt->CallList = _mesa_CallList;
+
+   vfmt->prefer_float_colors = GL_TRUE;
+}
+
+
+
+struct vp_stage_data {
+   GLvector4f clipCoords;             /* resulting vertex positions */
+   struct gl_client_array color0[2];  /* front and back */
+   struct gl_client_array color1[2];  /* front and back */
+   GLvector4f texCoord[MAX_TEXTURE_UNITS];
+   GLvector1f fogCoord;
+   GLvector1f pointSize;
+};
+
+
+#define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
+
+
+static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vp_stage_data *store = VP_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct vp_machine *machine = &(ctx->VertexProgram.Machine);
+   struct vp_program *program;
+   GLfloat (*clip)[4];
+   GLfloat (*color0)[4], (*color1)[4];
+   GLfloat (*bfcolor0)[4], (*bfcolor1)[4];
+   GLfloat *fog, *pointSize;
+   GLfloat (*texture0)[4];
+   GLfloat (*texture1)[4];
+   GLfloat (*texture2)[4];
+   GLfloat (*texture3)[4];
+   GLint i;
+
+   /* convenience pointers */
+   store->clipCoords.size = 4;
+   clip = (GLfloat (*)[4]) store->clipCoords.data;
+   color0 = (GLfloat (*)[4]) store->color0[0].Ptr;
+   color1 = (GLfloat (*)[4]) store->color1[0].Ptr;
+   bfcolor0 = (GLfloat (*)[4]) store->color0[1].Ptr;
+   bfcolor1 = (GLfloat (*)[4]) store->color1[1].Ptr;
+   fog = (GLfloat *) store->fogCoord.data;
+   pointSize = (GLfloat *) store->pointSize.data;
+   texture0 = (GLfloat (*)[4]) store->texCoord[0].data;
+   texture1 = (GLfloat (*)[4]) store->texCoord[1].data;
+   texture2 = (GLfloat (*)[4]) store->texCoord[2].data;
+   texture3 = (GLfloat (*)[4]) store->texCoord[3].data;
+
+
+   printf("In %s()\n", __FUNCTION__);
+
+   program = (struct vp_program *) _mesa_HashLookup(ctx->VertexProgram.HashTable, ctx->VertexProgram.Binding);
+   assert(program);
+
+   _mesa_init_tracked_matrices(ctx);
+   _mesa_init_vp_registers(ctx);  /* sets temp regs to (0,0,0,1) */
+
+   for (i = 0; i < VB->Count; i++) {
+      GLuint attr;
+
+      printf("Input  %d: %f, %f, %f, %f\n", i,
+             VB->AttribPtr[0]->data[i][0],
+             VB->AttribPtr[0]->data[i][1],
+             VB->AttribPtr[0]->data[i][2],
+             VB->AttribPtr[0]->data[i][3]);
+      printf("   color: %f, %f, %f, %f\n",
+             VB->AttribPtr[3]->data[i][0],
+             VB->AttribPtr[3]->data[i][1],
+             VB->AttribPtr[3]->data[i][2],
+             VB->AttribPtr[3]->data[i][3]);
+
+      /* load the input attribute registers */
+      for (attr = 0; attr < 16; attr++) {
+         if (VB->Flag[i] & (1 << attr)) {
+            COPY_4V(machine->Registers[VP_INPUT_REG_START + attr],
+                    VB->AttribPtr[attr]->data[i]);
+         }
+      }
+
+      /* execute the program */
+      _mesa_exec_program(ctx, program);
+
+      printf("Output %d: %f, %f, %f, %f\n", i,
+             machine->Registers[VP_OUTPUT_REG_START + 0][0],
+             machine->Registers[VP_OUTPUT_REG_START + 0][1],
+             machine->Registers[VP_OUTPUT_REG_START + 0][2],
+             machine->Registers[VP_OUTPUT_REG_START + 0][3]);
+      printf("   color: %f, %f, %f, %f\n",
+             machine->Registers[VP_OUTPUT_REG_START + 1][0],
+             machine->Registers[VP_OUTPUT_REG_START + 1][1],
+             machine->Registers[VP_OUTPUT_REG_START + 1][2],
+             machine->Registers[VP_OUTPUT_REG_START + 1][3]);
+
+      /* store the attribute output registers into the VB arrays */
+      COPY_4V(clip[i], machine->Registers[VP_OUT_HPOS]);
+      COPY_4V(color0[i], machine->Registers[VP_OUT_COL0]);
+      COPY_4V(color1[i], machine->Registers[VP_OUT_COL1]);
+      COPY_4V(bfcolor0[i], machine->Registers[VP_OUT_BFC0]);
+      COPY_4V(bfcolor1[i], machine->Registers[VP_OUT_BFC1]);
+      fog[i] = machine->Registers[VP_OUT_FOGC][0];
+      pointSize[i] = machine->Registers[VP_OUT_PSIZ][0];
+      COPY_4V(texture0[i], machine->Registers[VP_OUT_TEX0]);
+      COPY_4V(texture1[i], machine->Registers[VP_OUT_TEX0]);
+      COPY_4V(texture2[i], machine->Registers[VP_OUT_TEX0]);
+      COPY_4V(texture3[i], machine->Registers[VP_OUT_TEX0]);
+   }
+
+   VB->ColorPtr[0] = &store->color0[0];
+   VB->ColorPtr[1] = &store->color0[1];
+   VB->SecondaryColorPtr[0] = &store->color1[0];
+   VB->SecondaryColorPtr[1] = &store->color1[1];
+   VB->ProjectedClipPtr = &store->clipCoords;
+   VB->FogCoordPtr = &store->fogCoord;
+   VB->PointSizePtr = &store->pointSize;
+   VB->TexCoordPtr[0] = &store->texCoord[0];
+   VB->TexCoordPtr[1] = &store->texCoord[1];
+   VB->TexCoordPtr[2] = &store->texCoord[2];
+   VB->TexCoordPtr[3] = &store->texCoord[3];
+
+#if 000
+
+   GLvector4f *input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
+   GLuint ind;
+
+/*     _tnl_print_vert_flags( __FUNCTION__, stage->changed_inputs ); */
+
+   /* Make sure we can talk about elements 0..2 in the vector we are
+    * lighting.
+    */
+   if (stage->changed_inputs & (VERT_EYE|VERT_OBJ_BIT)) {
+      if (input->size <= 2) {
+	 if (input->flags & VEC_NOT_WRITEABLE) {
+	    ASSERT(VB->importable_data & VERT_OBJ_BIT);
+
+	    VB->import_data( ctx, VERT_OBJ_BIT, VEC_NOT_WRITEABLE );
+	    input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
+
+	    ASSERT((input->flags & VEC_NOT_WRITEABLE) == 0);
+	 }
+
+	 _mesa_vector4f_clean_elem(input, VB->Count, 2);
+      }
+   }
+
+   if (VB->Flag)
+      ind = LIGHT_FLAGS;
+   else
+      ind = 0;
+
+   /* The individual functions know about replaying side-effects
+    * vs. full re-execution. 
+    */
+   store->light_func_tab[ind]( ctx, VB, stage, input );
+#endif
+
+   return GL_TRUE;
+}
+
+
+/* Called in place of do_lighting when the light table may have changed.
+ */
+static GLboolean run_validate_program( GLcontext *ctx,
+					struct gl_pipeline_stage *stage )
+{
+#if 000
+   GLuint ind = 0;
+   light_func *tab;
+
+   if (ctx->Visual.rgbMode) {
+      if (ctx->Light._NeedVertices) {
+	 if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+	    tab = _tnl_light_spec_tab;
+	 else
+	    tab = _tnl_light_tab;
+      }
+      else {
+	 if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev)
+	    tab = _tnl_light_fast_single_tab;
+	 else
+	    tab = _tnl_light_fast_tab;
+      }
+   }
+   else
+      tab = _tnl_light_ci_tab;
+
+   if (ctx->Light.ColorMaterialEnabled)
+      ind |= LIGHT_COLORMATERIAL;
+
+   if (ctx->Light.Model.TwoSide)
+      ind |= LIGHT_TWOSIDE;
+
+   VP_STAGE_DATA(stage)->light_func_tab = &tab[ind];
+
+   /* This and the above should only be done on _NEW_LIGHT:
+    */
+   _mesa_validate_all_lighting_tables( ctx );
+#endif
+
+   /* Now run the stage...
+    */
+   stage->run = run_vp;
+   return stage->run( ctx, stage );
+}
+
+
+
+#if 0
+static void alloc_4chan( struct gl_client_array *a, GLuint sz )
+{
+   a->Ptr = ALIGN_MALLOC( sz * sizeof(GLchan) * 4, 32 );
+   a->Size = 4;
+   a->Type = CHAN_TYPE;
+   a->Stride = 0;
+   a->StrideB = sizeof(GLchan) * 4;
+   a->Enabled = 0;
+   a->Flags = 0;
+}
+#endif
+
+static void alloc_4float( struct gl_client_array *a, GLuint sz )
+{
+   a->Ptr = ALIGN_MALLOC( sz * sizeof(GLfloat) * 4, 32 );
+   a->Size = 4;
+   a->Type = GL_FLOAT;
+   a->Stride = 0;
+   a->StrideB = sizeof(GLfloat) * 4;
+   a->Enabled = 0;
+   a->Flags = 0;
+}
+
+
+/* Called the first time stage->run is called.  In effect, don't
+ * allocate data until the first time the stage is run.
+ */
+static GLboolean run_init_vp( GLcontext *ctx,
+                              struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &(tnl->vb);
+   struct vp_stage_data *store;
+   const GLuint size = VB->Size;
+   GLuint i;
+
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = VP_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   /* The output of a vertex program is: */
+   _mesa_vector4f_alloc( &store->clipCoords, 0, size, 32 );
+   alloc_4float( &store->color0[0], size );
+   alloc_4float( &store->color0[1], size );
+   alloc_4float( &store->color1[0], size );
+   alloc_4float( &store->color1[1], size );
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      _mesa_vector4f_alloc( &store->texCoord[i], 0, VB->Size, 32 );
+   _mesa_vector1f_alloc( &store->fogCoord, 0, size, 32 );
+   _mesa_vector1f_alloc( &store->pointSize, 0, size, 32 );
+
+
+   /* Now validate the stage derived data...
+    */
+   stage->run = run_validate_program;
+   return stage->run( ctx, stage );
+}
+
+
+
+/*
+ * Check if vertex program mode is enabled. 
+ * If so, configure the pipeline stage's type, inputs, and outputs.
+ */
+static void check_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   stage->active = ctx->VertexProgram.Enabled;
+   printf("check_vp() active = %d\n", stage->active);
+   if (stage->active) {
+#if 000
+      if (stage->privatePtr)
+	 stage->run = run_validate_program;
+      stage->inputs = VERT_NORMAL_BIT|VERT_MATERIAL;
+      if (ctx->Light._NeedVertices)
+	 stage->inputs |= VERT_EYE; /* effectively, even when lighting in obj */
+      if (ctx->Light.ColorMaterialEnabled)
+	 stage->inputs |= VERT_COLOR0_BIT;
+
+      stage->outputs = VERT_COLOR0_BIT;
+      if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+	 stage->outputs |= VERT_COLOR1_BIT;
+#endif
+   }
+}
+
+
+static void dtr( struct gl_pipeline_stage *stage )
+{
+   struct vp_stage_data *store = VP_STAGE_DATA(stage);
+
+   if (store) {
+      GLuint i;
+      _mesa_vector4f_free( &store->clipCoords );
+      ALIGN_FREE( store->color0[0].Ptr );
+      ALIGN_FREE( store->color0[1].Ptr );
+      ALIGN_FREE( store->color1[0].Ptr );
+      ALIGN_FREE( store->color1[1].Ptr );
+      for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
+	 if (store->texCoord[i].data)
+            _mesa_vector4f_free( &store->texCoord[i] );
+      _mesa_vector1f_free( &store->fogCoord );
+      _mesa_vector1f_free( &store->pointSize );
+
+      FREE( store );
+      stage->privatePtr = 0;
+   }
+}
+
+const struct gl_pipeline_stage _tnl_vertex_program_stage =
+{
+   "vertex-program",
+   _NEW_ALL,	/*XXX FIX */	/* recheck */
+   _NEW_ALL,	/*XXX FIX */    /* recalc -- modelview dependency
+				 * otherwise not captured by inputs
+				 * (which may be VERT_OBJ_BIT) */
+   GL_FALSE,			/* active */
+   0,				/* inputs */
+   VERT_CLIP | VERT_COLOR0_BIT,			/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private_data */
+   dtr,				/* destroy */
+   check_vp,			/* check */
+   run_init_vp			/* run -- initially set to ctr */
+};
diff --git a/src/mesa/tnl/t_vb_render.c b/src/mesa/tnl/t_vb_render.c
index de57eaf202..cc8deff464 100644
--- a/src/mesa/tnl/t_vb_render.c
+++ b/src/mesa/tnl/t_vb_render.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_render.c,v 1.24 2001/12/03 17:48:58 keithw Exp $ */
+/* $Id: t_vb_render.c,v 1.25 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -282,7 +282,6 @@ static GLboolean run_render( GLcontext *ctx,
    render_func *tab;
    GLint pass = 0;
 
-
    /* Allow the drivers to lock before projected verts are built so
     * that window coordinates are guarenteed not to change before
     * rendering.
@@ -354,10 +353,10 @@ static void check_render( GLcontext *ctx, struct gl_pipeline_stage *stage )
    GLuint i;
 
    if (ctx->Visual.rgbMode) {
-      inputs |= VERT_RGBA;
+      inputs |= VERT_COLOR0_BIT;
 
       if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
-	 inputs |= VERT_SPEC_RGB;
+	 inputs |= VERT_COLOR1_BIT;
 
       if (ctx->Texture._ReallyEnabled) {
 	 for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
@@ -367,7 +366,7 @@ static void check_render( GLcontext *ctx, struct gl_pipeline_stage *stage )
       }
    }
    else {
-      inputs |= VERT_INDEX;
+      inputs |= VERT_INDEX_BIT;
    }
 
    if (ctx->Point._Attenuated)
@@ -376,10 +375,10 @@ static void check_render( GLcontext *ctx, struct gl_pipeline_stage *stage )
    /* How do drivers turn this off?
     */
    if (ctx->Fog.Enabled)
-      inputs |= VERT_FOG_COORD;
+      inputs |= VERT_FOG_BIT;
 
    if (ctx->_TriangleCaps & DD_TRI_UNFILLED)
-      inputs |= VERT_EDGE;
+      inputs |= VERT_EDGEFLAG_BIT;
 
    if (ctx->RenderMode==GL_FEEDBACK)
       inputs |= VERT_TEX_ANY;
@@ -397,7 +396,7 @@ static void dtr( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_render_stage =
 {
-   "render",
+   "render",			/* name */
    (_NEW_BUFFERS |
     _DD_NEW_SEPARATE_SPECULAR |
     _DD_NEW_FLATSHADE |
@@ -408,9 +407,11 @@ const struct gl_pipeline_stage _tnl_render_stage =
     _DD_NEW_TRI_UNFILLED |
     _NEW_RENDERMODE),		/* re-check (new inputs, interp function) */
    0,				/* re-run (always runs) */
-   GL_TRUE,			/* active */
-   0, 0,			/* inputs (set in check_render), outputs */
-   0, 0,			/* changed_inputs, private */
+   GL_TRUE,			/* active? */
+   0,				/* inputs (set in check_render) */
+   0,				/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private data */
    dtr,				/* destructor */
    check_render,		/* check */
    run_render			/* run */
diff --git a/src/mesa/tnl/t_vb_texgen.c b/src/mesa/tnl/t_vb_texgen.c
index bdf5c63786..90dff30752 100644
--- a/src/mesa/tnl/t_vb_texgen.c
+++ b/src/mesa/tnl/t_vb_texgen.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_texgen.c,v 1.9 2001/04/26 14:53:48 keithw Exp $ */
+/* $Id: t_vb_texgen.c,v 1.10 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -529,7 +529,7 @@ static GLboolean run_texgen_stage( GLcontext *ctx,
 
    for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
       if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i)) {
-	 if (stage->changed_inputs & (VERT_EYE | VERT_NORM | VERT_TEX(i)))
+	 if (stage->changed_inputs & (VERT_EYE | VERT_NORMAL_BIT | VERT_TEX(i)))
 	    store->TexgenFunc[i]( ctx, store, i );
 
 	 VB->TexCoordPtr[i] = &store->texcoord[i];
@@ -591,18 +591,18 @@ static void check_texgen( GLcontext *ctx, struct gl_pipeline_stage *stage )
    GLuint i;
    stage->active = 0;
 
-   if (ctx->Texture._TexGenEnabled) {
+   if (ctx->Texture._TexGenEnabled && !ctx->VertexProgram.Enabled) {
       GLuint inputs = 0;
       GLuint outputs = 0;
 
       if (ctx->Texture._GenFlags & TEXGEN_OBJ_LINEAR)
-	 inputs |= VERT_OBJ;
+	 inputs |= VERT_OBJ_BIT;
 
       if (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)
 	 inputs |= VERT_EYE;
 
       if (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS)
-	 inputs |= VERT_NORM;
+	 inputs |= VERT_NORMAL_BIT;
 
       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
 	 if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i))
@@ -678,11 +678,14 @@ static void free_texgen_data( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_texgen_stage =
 {
-   "texgen",
+   "texgen",			/* name */
    _NEW_TEXTURE,		/* when to call check() */
    _NEW_TEXTURE,		/* when to invalidate stored data */
-   0,0,0,			/* active, inputs, outputs */
-   0,0,				/* changed_inputs, private */
+   GL_FALSE,			/* active? */
+   0,				/* inputs */
+   0,				/* outputs */
+   0,				/* changed_inputs */
+   NULL,			/* private data */
    free_texgen_data,		/* destructor */
    check_texgen,		/* check */
    alloc_texgen_data		/* run -- initially set to alloc data */
diff --git a/src/mesa/tnl/t_vb_texmat.c b/src/mesa/tnl/t_vb_texmat.c
index 2eb6c943d7..a0ed3e5899 100644
--- a/src/mesa/tnl/t_vb_texmat.c
+++ b/src/mesa/tnl/t_vb_texmat.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_texmat.c,v 1.5 2001/03/29 21:16:26 keithw Exp $ */
+/* $Id: t_vb_texmat.c,v 1.6 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -60,7 +60,7 @@ static void check_texmat( GLcontext *ctx, struct gl_pipeline_stage *stage )
    GLuint i;
    stage->active = 0;
 
-   if (ctx->Texture._TexMatEnabled) {
+   if (ctx->Texture._TexMatEnabled && !ctx->VertexProgram.Enabled) {
       GLuint flags = 0;
 
       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
@@ -137,12 +137,15 @@ static void free_texmat_data( struct gl_pipeline_stage *stage )
 
 const struct gl_pipeline_stage _tnl_texture_transform_stage =
 {
-   "texture transform",
-   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,
-   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,
-   0,0,0,			/* active, inputs, outputs */
-   0,0,				/* changed_inputs, private */
-   free_texmat_data,		/* destructor */
-   check_texmat,		/* check */
-   alloc_texmat_data,		/* run -- initially set to init */
+   "texture transform",			/* name */
+   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,	/* check_state */
+   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,	/* run_state */
+   GL_FALSE,				/* active? */
+   0,					/* inputs */
+   0,					/* outputs */
+   0,					/* changed_inputs */
+   NULL,				/* private data */
+   free_texmat_data,			/* destructor */
+   check_texmat,			/* check */
+   alloc_texmat_data,			/* run -- initially set to init */
 };
diff --git a/src/mesa/tnl/t_vb_vertex.c b/src/mesa/tnl/t_vb_vertex.c
index d9baed3b0c..f54d73bd62 100644
--- a/src/mesa/tnl/t_vb_vertex.c
+++ b/src/mesa/tnl/t_vb_vertex.c
@@ -1,4 +1,4 @@
-/* $Id: t_vb_vertex.c,v 1.9 2001/05/30 10:01:41 keithw Exp $ */
+/* $Id: t_vb_vertex.c,v 1.10 2001/12/14 02:51:45 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -170,7 +170,7 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
       if (VB->ClipPtr->size < 4) {
 	 if (VB->ClipPtr->flags & VEC_NOT_WRITEABLE) {
 	    ASSERT(VB->ClipPtr == VB->ObjPtr);
-	    VB->import_data( ctx, VERT_OBJ, VEC_NOT_WRITEABLE );
+	    VB->import_data( ctx, VERT_OBJ_BIT, VEC_NOT_WRITEABLE );
 	    VB->ClipPtr = VB->ObjPtr;
 	 }
 	 if (VB->ClipPtr->size == 2)
@@ -222,7 +222,7 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
       VB->ClipOrMask = store->ormask;
       VB->ClipMask = store->clipmask;
 
-      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ))
+      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ_BIT))
 	 VB->importable_data |= VERT_CLIP;
 
       store->save_eyeptr = VB->EyePtr;
@@ -237,7 +237,7 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
       VB->ProjectedClipPtr = store->save_projptr;
       VB->ClipMask = store->clipmask;
       VB->ClipOrMask = store->ormask;
-      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ))
+      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ_BIT))
 	 VB->importable_data |= VERT_CLIP;
       if (store->andmask)
 	 return GL_FALSE;
@@ -249,8 +249,7 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
 
 static void check_vertex( GLcontext *ctx, struct gl_pipeline_stage *stage )
 {
-   (void) ctx;
-   (void) stage;
+   stage->active = !ctx->VertexProgram.Enabled;
 }
 
 static GLboolean init_vertex_stage( GLcontext *ctx,
@@ -308,9 +307,10 @@ const struct gl_pipeline_stage _tnl_vertex_transform_stage =
    _NEW_PROJECTION|
    _NEW_TRANSFORM,		/* re-run */
    GL_TRUE,			/* active */
-   VERT_OBJ,		/* inputs */
+   VERT_OBJ_BIT,		/* inputs */
    VERT_EYE|VERT_CLIP,		/* outputs */
-   0, 0,			/* changed_inputs, private */
+   0,				/* changed_inputs */
+   NULL,			/* private data */
    dtr,				/* destructor */
    check_vertex,		/* check */
    init_vertex_stage		/* run -- initially set to init */
diff --git a/src/mesa/x86/glapi_x86.S b/src/mesa/x86/glapi_x86.S
index 1b43923886..82d72ab835 100644
--- a/src/mesa/x86/glapi_x86.S
+++ b/src/mesa/x86/glapi_x86.S
@@ -4123,5 +4123,389 @@ GL_PREFIX(WindowPos3svARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
 	JMP(GL_OFFSET(_gloffset_WindowPos3svARB))
 
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(BindProgramNV))
+GL_PREFIX(BindProgramNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_BindProgramNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(DeleteProgramsNV))
+GL_PREFIX(DeleteProgramsNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_DeleteProgramsNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ExecuteProgramNV))
+GL_PREFIX(ExecuteProgramNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ExecuteProgramNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GenProgramsNV))
+GL_PREFIX(GenProgramsNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GenProgramsNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(AreProgramsResidentNV))
+GL_PREFIX(AreProgramsResidentNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_AreProgramsResidentNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(RequestResidentProgramsNV))
+GL_PREFIX(RequestResidentProgramsNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_RequestResidentProgramsNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetProgramParameterfvNV))
+GL_PREFIX(GetProgramParameterfvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetProgramParameterfvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetProgramParameterdvNV))
+GL_PREFIX(GetProgramParameterdvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetProgramParameterdvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetProgramivNV))
+GL_PREFIX(GetProgramivNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetProgramivNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetProgramStringNV))
+GL_PREFIX(GetProgramStringNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetProgramStringNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetTrackMatrixivNV))
+GL_PREFIX(GetTrackMatrixivNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetTrackMatrixivNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetVertexAttribdvNV))
+GL_PREFIX(GetVertexAttribdvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetVertexAttribdvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetVertexAttribfvNV))
+GL_PREFIX(GetVertexAttribfvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetVertexAttribfvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetVertexAttribivNV))
+GL_PREFIX(GetVertexAttribivNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetVertexAttribivNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetVertexAttribPointervNV))
+GL_PREFIX(GetVertexAttribPointervNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetVertexAttribPointervNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(IsProgramNV))
+GL_PREFIX(IsProgramNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_IsProgramNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(LoadProgramNV))
+GL_PREFIX(LoadProgramNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_LoadProgramNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameter4fNV))
+GL_PREFIX(ProgramParameter4fNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameter4fNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameter4dNV))
+GL_PREFIX(ProgramParameter4dNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameter4dNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameter4dvNV))
+GL_PREFIX(ProgramParameter4dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameter4dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameter4fvNV))
+GL_PREFIX(ProgramParameter4fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameter4fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameters4dvNV))
+GL_PREFIX(ProgramParameters4dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameters4dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ProgramParameters4fvNV))
+GL_PREFIX(ProgramParameters4fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ProgramParameters4fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(TrackMatrixNV))
+GL_PREFIX(TrackMatrixNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_TrackMatrixNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribPointerNV))
+GL_PREFIX(VertexAttribPointerNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribPointerNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1sNV))
+GL_PREFIX(VertexAttrib1sNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1sNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1fNV))
+GL_PREFIX(VertexAttrib1fNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1fNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1dNV))
+GL_PREFIX(VertexAttrib1dNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1dNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2sNV))
+GL_PREFIX(VertexAttrib2sNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2sNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2fNV))
+GL_PREFIX(VertexAttrib2fNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2fNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2dNV))
+GL_PREFIX(VertexAttrib2dNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2dNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3sNV))
+GL_PREFIX(VertexAttrib3sNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3sNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3fNV))
+GL_PREFIX(VertexAttrib3fNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3fNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3dNV))
+GL_PREFIX(VertexAttrib3dNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3dNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4sNV))
+GL_PREFIX(VertexAttrib4sNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4sNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4fNV))
+GL_PREFIX(VertexAttrib4fNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4fNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4dNV))
+GL_PREFIX(VertexAttrib4dNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4dNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4ubNV))
+GL_PREFIX(VertexAttrib4ubNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4ubNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1svNV))
+GL_PREFIX(VertexAttrib1svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1fvNV))
+GL_PREFIX(VertexAttrib1fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib1dvNV))
+GL_PREFIX(VertexAttrib1dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib1dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2svNV))
+GL_PREFIX(VertexAttrib2svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2fvNV))
+GL_PREFIX(VertexAttrib2fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib2dvNV))
+GL_PREFIX(VertexAttrib2dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib2dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3svNV))
+GL_PREFIX(VertexAttrib3svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3fvNV))
+GL_PREFIX(VertexAttrib3fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib3dvNV))
+GL_PREFIX(VertexAttrib3dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib3dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4svNV))
+GL_PREFIX(VertexAttrib4svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4fvNV))
+GL_PREFIX(VertexAttrib4fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4dvNV))
+GL_PREFIX(VertexAttrib4dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttrib4ubvNV))
+GL_PREFIX(VertexAttrib4ubvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttrib4ubvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs1svNV))
+GL_PREFIX(VertexAttribs1svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs1svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs1fvNV))
+GL_PREFIX(VertexAttribs1fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs1fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs1dvNV))
+GL_PREFIX(VertexAttribs1dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs1dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs2svNV))
+GL_PREFIX(VertexAttribs2svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs2svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs2fvNV))
+GL_PREFIX(VertexAttribs2fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs2fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs2dvNV))
+GL_PREFIX(VertexAttribs2dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs2dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs3svNV))
+GL_PREFIX(VertexAttribs3svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs3svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs3fvNV))
+GL_PREFIX(VertexAttribs3fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs3fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs3dvNV))
+GL_PREFIX(VertexAttribs3dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs3dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs4svNV))
+GL_PREFIX(VertexAttribs4svNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs4svNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs4fvNV))
+GL_PREFIX(VertexAttribs4fvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs4fvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs4dvNV))
+GL_PREFIX(VertexAttribs4dvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs4dvNV))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(VertexAttribs4ubvNV))
+GL_PREFIX(VertexAttribs4ubvNV):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_VertexAttribs4ubvNV))
+
 
 #endif  /* __WIN32__ */