Add GLX protocol support for ARB_fragement_program,
authorIan Romanick <idr@us.ibm.com>
Fri, 25 Feb 2005 22:46:30 +0000 (22:46 +0000)
committerIan Romanick <idr@us.ibm.com>
Fri, 25 Feb 2005 22:46:30 +0000 (22:46 +0000)
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.

src/glx/x11/Makefile
src/glx/x11/glxextensions.c
src/glx/x11/glxextensions.h
src/glx/x11/indirect.c
src/glx/x11/indirect.h
src/glx/x11/indirect_init.c
src/glx/x11/indirect_vertex_array.c
src/glx/x11/indirect_vertex_array.h
src/glx/x11/indirect_vertex_program.c [new file with mode: 0644]
src/mesa/glapi/gl_API.xml

index bf629ed8ba38a1cc0249c861ff2f63f2d9139ff3..dbd1f13422ef2a82d8bc673e78a8cfd2ddfe2d53 100644 (file)
@@ -33,6 +33,7 @@ C_SOURCES = \
          indirect_window_pos.c \
          indirect_transpose_matrix.c \
          indirect_vertex_array.c \
+         indirect_vertex_program.c \
          pixel.c \
          pixelstore.c \
          render2.c \
index f4e07efeb075892a859ebd16b59730ffa0ed98a6..166dd18c041c9c3df34043f10a1ec8c5dbdc792d 100644 (file)
@@ -112,7 +112,8 @@ static const struct extension_info known_glx_extensions[] = {
 
 static const struct extension_info known_gl_extensions[] = {
    { GL(ARB_depth_texture),              VER(1,4), Y, N, N, N },
-   { GL(ARB_fragment_program),           VER(0,0), N, N, N, N },
+   { GL(ARB_fragment_program),           VER(0,0), Y, N, N, N },
+   { GL(ARB_fragment_program_shadow),    VER(0,0), Y, N, N, N },
    { GL(ARB_imaging),                    VER(0,0), Y, N, N, N },
    { GL(ARB_multisample),                VER(1,3), Y, N, N, N },
    { GL(ARB_multitexture),               VER(1,3), Y, N, N, N },
@@ -133,6 +134,7 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(ARB_texture_rectangle),          VER(0,0), Y, N, N, N },
    { GL(ARB_transpose_matrix),           VER(1,3), Y, N, Y, N },
    { GL(ARB_vertex_buffer_object),       VER(1,5), N, N, N, N },
+   { GL(ARB_vertex_program),             VER(0,0), Y, N, N, N },
    { GL(ARB_window_pos),                 VER(1,4), Y, N, N, N },
    { GL(EXT_abgr),                       VER(0,0), Y, N, N, N },
    { GL(EXT_bgra),                       VER(1,2), Y, N, N, N },
@@ -182,6 +184,7 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(3DFX_texture_compression_FXT1),  VER(0,0), Y, N, N, N },
    { GL(APPLE_packed_pixels),            VER(1,2), Y, N, N, N },
    { GL(APPLE_ycbcr_422),                VER(0,0), Y, N, N, N },
+   { GL(ATI_text_fragment_shader),       VER(0,0), Y, N, N, N },
    { GL(ATI_texture_env_combine3),       VER(0,0), Y, N, N, N },
    { GL(ATI_texture_float),              VER(0,0), Y, N, N, N },
    { GL(ATI_texture_mirror_once),        VER(0,0), Y, N, N, N },
@@ -201,6 +204,9 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(NV_copy_depth_to_color),         VER(0,0), Y, N, N, N },
    { GL(NV_depth_clamp),                 VER(0,0), Y, N, N, N },
    { GL(NV_fog_distance),                VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program),            VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program_option),     VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program2),           VER(0,0), Y, N, N, N },
    { GL(NV_light_max_exponent),          VER(0,0), Y, N, N, N },
    { GL(NV_multisample_filter_hint),     VER(0,0), Y, N, N, N },
    { GL(NV_point_sprite),                VER(0,0), Y, N, N, N },
@@ -208,6 +214,11 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(NV_texture_compression_vtc),     VER(0,0), Y, N, N, N },
    { GL(NV_texture_env_combine4),        VER(0,0), Y, N, N, N },
    { GL(NV_texture_rectangle),           VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program),              VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program1_1),           VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program2),             VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program2_option),      VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program3),             VER(0,0), Y, N, N, N },
    { GL(OES_read_format),                VER(0,0), Y, N, N, N },
    { GL(OES_compressed_paletted_texture),VER(0,0), Y, N, N, N },
    { GL(SGI_color_matrix),               VER(0,0), Y, N, N, N },
index c64561b5c8e65b5f1dc8628ba705be99b6bfea1a..e374161168a87a0b12a9d21def57282b70fd810d 100644 (file)
@@ -75,6 +75,7 @@ enum {
 enum {
    GL_ARB_depth_texture_bit = 0,
    GL_ARB_fragment_program_bit,
+   GL_ARB_fragment_program_shadow_bit,
    GL_ARB_imaging_bit,
    GL_ARB_multisample_bit,
    GL_ARB_multitexture_bit,
@@ -142,6 +143,7 @@ enum {
    GL_3DFX_texture_compression_FXT1_bit,
    GL_APPLE_packed_pixels_bit,
    GL_APPLE_ycbcr_422_bit,
+   GL_ATI_text_fragment_shader_bit,
    GL_ATI_texture_env_combine3_bit,
    GL_ATI_texture_float_bit,
    GL_ATI_texture_mirror_once_bit,
@@ -158,12 +160,20 @@ enum {
    GL_NV_copy_depth_to_color_bit,
    GL_NV_depth_clamp_bit,
    GL_NV_fog_distance_bit,
+   GL_NV_fragment_program_bit,
+   GL_NV_fragment_program_option_bit,
+   GL_NV_fragment_program2_bit,
    GL_NV_light_max_exponent_bit,
    GL_NV_multisample_filter_hint_bit,
    GL_NV_point_sprite_bit,
    GL_NV_texgen_reflection_bit,
    GL_NV_texture_compression_vtc_bit,
    GL_NV_texture_env_combine4_bit,
+   GL_NV_vertex_program_bit,
+   GL_NV_vertex_program1_1_bit,
+   GL_NV_vertex_program2_bit,
+   GL_NV_vertex_program2_option_bit,
+   GL_NV_vertex_program3_bit,
    GL_OES_compressed_paletted_texture_bit,
    GL_OES_read_format_bit,
    GL_SGI_color_matrix_bit,
index a92722a1043794d60b577eeb07254fe2a6914241..33fc9f9a3c774db731ef48628e92f2bd21c52fa8 100644 (file)
@@ -5796,41 +5796,1739 @@ __indirect_glSecondaryColor3usvEXT(const GLushort * v)
     generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
 }
 
-#define X_GLrop_PointParameteriNV 4221
+#define X_GLvop_AreProgramsResidentNV 1293
+GLboolean
+__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+        retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_BindProgramNV 4180
 void
-__indirect_glPointParameteriNV(GLenum pname, GLint params)
+__indirect_glBindProgramNV(GLenum target, GLuint id)
 {
     __GLXcontext * const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
-    emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
+    emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
     gc->pc += cmdlen;
     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 }
 
-#define X_GLrop_PointParameterivNV 4222
+#define X_GLvop_DeleteProgramsNV 1294
 void
-__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+__indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids)
 {
     __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = __glPointParameterivNV_size(pname);
-    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
-    emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_ExecuteProgramNV 4181
+void
+__indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
     gc->pc += cmdlen;
     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 }
 
-#define X_GLrop_ActiveStencilFaceEXT 4220
+#define X_GLvop_GenProgramsNV 1295
 void
-__indirect_glActiveStencilFaceEXT(GLenum face)
+__indirect_glGenProgramsNV(GLsizei n, GLuint * ids)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, ids, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramParameterdvNV 1297
+void
+__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramParameterfvNV 1296
+void
+__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramivNV 1298
+void
+__indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
 {
     __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
-    emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramStringNV 1299
+void
+__indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 1, program, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetTrackMatrixivNV 1300
+void
+__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_IsProgramNV 1304
+GLboolean
+__indirect_glIsProgramNV(GLuint id)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_LoadProgramNV 4183
+void
+__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(program), (len * 1));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4dvNV 4187
+void
+__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(params), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&num), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4fvNV 4186
+void
+__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD((num * 4));
+    if (__builtin_expect(num >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_RequestResidentProgramsNV 4182
+void
+__indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_TrackMatrixNV 4188
+void
+__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs1dvNV 4210
+void
+__indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs1fvNV 4206
+void
+__indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs1svNV 4202
+void
+__indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs2dvNV 4211
+void
+__indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs2fvNV 4207
+void
+__indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs2svNV 4203
+void
+__indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3dvNV 4212
+void
+__indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3fvNV 4208
+void
+__indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3svNV 4204
+void
+__indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4dvNV 4213
+void
+__indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4fvNV 4209
+void
+__indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4svNV 4205
+void
+__indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4ubvNV 4214
+void
+__indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameteriNV 4221
+void
+__indirect_glPointParameteriNV(GLenum pname, GLint params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterivNV 4222
+void
+__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glPointParameterivNV_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ActiveStencilFaceEXT 4220
+void
+__indirect_glActiveStencilFaceEXT(GLenum face)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ivARB 4231
+void
+__indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvARB 4232
+void
+__indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4usvARB 4233
+void
+__indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4uivARB 4234
+void
+__indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NbvARB 4235
+void
+__indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NsvARB 4236
+void
+__indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NivARB 4237
+void
+__indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NusvARB 4238
+void
+__indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NuivARB 4239
+void
+__indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramStringARB 4217
+void
+__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
+    if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+            (void) memcpy((void *)(gc->pc + 16), (void *)(string), (len * 1));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_ProgramStringARB;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
+            __glXSendLargeCommand(gc, pc, 20, string, (len * 1));
+        }
+    }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetProgramivARB 1307
+void
+__indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramStringARB 1308
+void
+__indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 0, string, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+        (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLvop_GetProgramNamedParameterfvNV 1310
+void
+__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
+    if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
+        (void) __glXReadReply(dpy, 4, params, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramNamedParameterdvNV 1311
+void
+__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
+    if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
+        (void) __glXReadReply(dpy, 8, params, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribdvNV 1301
+void
+__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribfvNV 1302
+void
+__indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribivNV 1303
+void
+__indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
     gc->pc += cmdlen;
     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 }
index 93bab10bf6fcb8aa35803912344fb2910d93477b..51228465d41a16912e779388da30ca89e38f9498 100644 (file)
@@ -541,11 +541,137 @@ extern HIDDEN void __indirect_glSecondaryColor3uivEXT(const GLuint * v);
 extern HIDDEN void __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
 extern HIDDEN void __indirect_glSecondaryColor3usvEXT(const GLushort * v);
 extern HIDDEN void __indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences);
+extern HIDDEN void __indirect_glBindProgramNV(GLenum target, GLuint id);
+extern HIDDEN void __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids);
+extern HIDDEN void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params);
+extern HIDDEN void __indirect_glGenProgramsNV(GLsizei n, GLuint * ids);
+extern HIDDEN void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program);
+extern HIDDEN void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid ** pointer);
+extern HIDDEN GLboolean __indirect_glIsProgramNV(GLuint id);
+extern HIDDEN void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program);
+extern HIDDEN void __indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params);
+extern HIDDEN void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids);
+extern HIDDEN void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
+extern HIDDEN void __indirect_glVertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sARB(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v);
 extern HIDDEN void __indirect_glPointParameteriNV(GLenum pname, GLint params);
 extern HIDDEN void __indirect_glPointParameterivNV(GLenum pname, const GLint * params);
 extern HIDDEN void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount);
 extern HIDDEN void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount);
 extern HIDDEN void __indirect_glActiveStencilFaceEXT(GLenum face);
+extern HIDDEN void __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glEnableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glDisableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string);
+extern HIDDEN void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string);
+extern HIDDEN void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v);
+extern HIDDEN void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v);
+extern HIDDEN void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v);
 
 #  undef HIDDEN
 #  undef FASTCALL
index a153e1bf05fa92ee4531ba59b18ab91c68c7d619..5e2fc0437e7a356925f647a56b4a0a0d4d7d7a37 100644 (file)
@@ -589,6 +589,85 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->SecondaryColor3usvEXT = __indirect_glSecondaryColor3usvEXT;
     glAPI->SecondaryColorPointerEXT = __indirect_glSecondaryColorPointerEXT;
 
+    /* GL_NV_vertex_program */
+
+    glAPI->AreProgramsResidentNV = __indirect_glAreProgramsResidentNV;
+    glAPI->BindProgramNV = __indirect_glBindProgramNV;
+    glAPI->DeleteProgramsNV = __indirect_glDeleteProgramsNV;
+    glAPI->ExecuteProgramNV = __indirect_glExecuteProgramNV;
+    glAPI->GenProgramsNV = __indirect_glGenProgramsNV;
+    glAPI->GetProgramParameterdvNV = __indirect_glGetProgramParameterdvNV;
+    glAPI->GetProgramParameterfvNV = __indirect_glGetProgramParameterfvNV;
+    glAPI->GetProgramivNV = __indirect_glGetProgramivNV;
+    glAPI->GetProgramStringNV = __indirect_glGetProgramStringNV;
+    glAPI->GetTrackMatrixivNV = __indirect_glGetTrackMatrixivNV;
+
+    /* GL_ARB_vertex_program */
+
+    glAPI->GetVertexAttribdvARB = __indirect_glGetVertexAttribdvARB;
+    glAPI->GetVertexAttribfvARB = __indirect_glGetVertexAttribfvARB;
+    glAPI->GetVertexAttribivARB = __indirect_glGetVertexAttribivARB;
+
+    /* GL_NV_vertex_program */
+
+    glAPI->GetVertexAttribPointervNV = __indirect_glGetVertexAttribPointervNV;
+    glAPI->IsProgramNV = __indirect_glIsProgramNV;
+    glAPI->LoadProgramNV = __indirect_glLoadProgramNV;
+    glAPI->ProgramParameter4dNV = __indirect_glProgramParameter4dNV;
+    glAPI->ProgramParameter4dvNV = __indirect_glProgramParameter4dvNV;
+    glAPI->ProgramParameter4fNV = __indirect_glProgramParameter4fNV;
+    glAPI->ProgramParameter4fvNV = __indirect_glProgramParameter4fvNV;
+    glAPI->ProgramParameters4dvNV = __indirect_glProgramParameters4dvNV;
+    glAPI->ProgramParameters4fvNV = __indirect_glProgramParameters4fvNV;
+    glAPI->RequestResidentProgramsNV = __indirect_glRequestResidentProgramsNV;
+    glAPI->TrackMatrixNV = __indirect_glTrackMatrixNV;
+    glAPI->VertexAttribPointerNV = __indirect_glVertexAttribPointerNV;
+
+    /* GL_ARB_vertex_program */
+
+    glAPI->VertexAttrib1dARB = __indirect_glVertexAttrib1dARB;
+    glAPI->VertexAttrib1dvARB = __indirect_glVertexAttrib1dvARB;
+    glAPI->VertexAttrib1fARB = __indirect_glVertexAttrib1fARB;
+    glAPI->VertexAttrib1fvARB = __indirect_glVertexAttrib1fvARB;
+    glAPI->VertexAttrib1sARB = __indirect_glVertexAttrib1sARB;
+    glAPI->VertexAttrib1svARB = __indirect_glVertexAttrib1svARB;
+    glAPI->VertexAttrib2dARB = __indirect_glVertexAttrib2dARB;
+    glAPI->VertexAttrib2dvARB = __indirect_glVertexAttrib2dvARB;
+    glAPI->VertexAttrib2fARB = __indirect_glVertexAttrib2fARB;
+    glAPI->VertexAttrib2fvARB = __indirect_glVertexAttrib2fvARB;
+    glAPI->VertexAttrib2sARB = __indirect_glVertexAttrib2sARB;
+    glAPI->VertexAttrib2svARB = __indirect_glVertexAttrib2svARB;
+    glAPI->VertexAttrib3dARB = __indirect_glVertexAttrib3dARB;
+    glAPI->VertexAttrib3dvARB = __indirect_glVertexAttrib3dvARB;
+    glAPI->VertexAttrib3fARB = __indirect_glVertexAttrib3fARB;
+    glAPI->VertexAttrib3fvARB = __indirect_glVertexAttrib3fvARB;
+    glAPI->VertexAttrib3sARB = __indirect_glVertexAttrib3sARB;
+    glAPI->VertexAttrib3svARB = __indirect_glVertexAttrib3svARB;
+    glAPI->VertexAttrib4dARB = __indirect_glVertexAttrib4dARB;
+    glAPI->VertexAttrib4dvARB = __indirect_glVertexAttrib4dvARB;
+    glAPI->VertexAttrib4fARB = __indirect_glVertexAttrib4fARB;
+    glAPI->VertexAttrib4fvARB = __indirect_glVertexAttrib4fvARB;
+    glAPI->VertexAttrib4sARB = __indirect_glVertexAttrib4sARB;
+    glAPI->VertexAttrib4svARB = __indirect_glVertexAttrib4svARB;
+    glAPI->VertexAttrib4NubARB = __indirect_glVertexAttrib4NubARB;
+    glAPI->VertexAttrib4NubvARB = __indirect_glVertexAttrib4NubvARB;
+
+    /* GL_NV_vertex_program */
+
+    glAPI->VertexAttribs1dvNV = __indirect_glVertexAttribs1dvNV;
+    glAPI->VertexAttribs1fvNV = __indirect_glVertexAttribs1fvNV;
+    glAPI->VertexAttribs1svNV = __indirect_glVertexAttribs1svNV;
+    glAPI->VertexAttribs2dvNV = __indirect_glVertexAttribs2dvNV;
+    glAPI->VertexAttribs2fvNV = __indirect_glVertexAttribs2fvNV;
+    glAPI->VertexAttribs2svNV = __indirect_glVertexAttribs2svNV;
+    glAPI->VertexAttribs3dvNV = __indirect_glVertexAttribs3dvNV;
+    glAPI->VertexAttribs3fvNV = __indirect_glVertexAttribs3fvNV;
+    glAPI->VertexAttribs3svNV = __indirect_glVertexAttribs3svNV;
+    glAPI->VertexAttribs4dvNV = __indirect_glVertexAttribs4dvNV;
+    glAPI->VertexAttribs4fvNV = __indirect_glVertexAttribs4fvNV;
+    glAPI->VertexAttribs4svNV = __indirect_glVertexAttribs4svNV;
+    glAPI->VertexAttribs4ubvNV = __indirect_glVertexAttribs4ubvNV;
+
     /* GL_NV_point_sprite */
 
     glAPI->PointParameteriNV = __indirect_glPointParameteriNV;
@@ -603,6 +682,77 @@ __GLapi * __glXNewIndirectAPI( void )
 
     glAPI->ActiveStencilFaceEXT = __indirect_glActiveStencilFaceEXT;
 
+    /* GL_ARB_vertex_program */
+
+    glAPI->VertexAttrib4ivARB = __indirect_glVertexAttrib4ivARB;
+    glAPI->VertexAttrib4ubvARB = __indirect_glVertexAttrib4ubvARB;
+    glAPI->VertexAttrib4usvARB = __indirect_glVertexAttrib4usvARB;
+    glAPI->VertexAttrib4uivARB = __indirect_glVertexAttrib4uivARB;
+    glAPI->VertexAttrib4NbvARB = __indirect_glVertexAttrib4NbvARB;
+    glAPI->VertexAttrib4NsvARB = __indirect_glVertexAttrib4NsvARB;
+    glAPI->VertexAttrib4NivARB = __indirect_glVertexAttrib4NivARB;
+    glAPI->VertexAttrib4NusvARB = __indirect_glVertexAttrib4NusvARB;
+    glAPI->VertexAttrib4NuivARB = __indirect_glVertexAttrib4NuivARB;
+    glAPI->VertexAttribPointerARB = __indirect_glVertexAttribPointerARB;
+    glAPI->EnableVertexAttribArrayARB = __indirect_glEnableVertexAttribArrayARB;
+    glAPI->DisableVertexAttribArrayARB = __indirect_glDisableVertexAttribArrayARB;
+    glAPI->ProgramStringARB = __indirect_glProgramStringARB;
+    glAPI->ProgramEnvParameter4dARB = __indirect_glProgramEnvParameter4dARB;
+    glAPI->ProgramEnvParameter4dvARB = __indirect_glProgramEnvParameter4dvARB;
+    glAPI->ProgramEnvParameter4fARB = __indirect_glProgramEnvParameter4fARB;
+    glAPI->ProgramEnvParameter4fvARB = __indirect_glProgramEnvParameter4fvARB;
+    glAPI->ProgramLocalParameter4dARB = __indirect_glProgramLocalParameter4dARB;
+    glAPI->ProgramLocalParameter4dvARB = __indirect_glProgramLocalParameter4dvARB;
+    glAPI->ProgramLocalParameter4fARB = __indirect_glProgramLocalParameter4fARB;
+    glAPI->ProgramLocalParameter4fvARB = __indirect_glProgramLocalParameter4fvARB;
+    glAPI->GetProgramEnvParameterdvARB = __indirect_glGetProgramEnvParameterdvARB;
+    glAPI->GetProgramEnvParameterfvARB = __indirect_glGetProgramEnvParameterfvARB;
+    glAPI->GetProgramLocalParameterdvARB = __indirect_glGetProgramLocalParameterdvARB;
+    glAPI->GetProgramLocalParameterfvARB = __indirect_glGetProgramLocalParameterfvARB;
+    glAPI->GetProgramivARB = __indirect_glGetProgramivARB;
+    glAPI->GetProgramStringARB = __indirect_glGetProgramStringARB;
+
+    /* GL_NV_fragment_program */
+
+    glAPI->ProgramNamedParameter4fNV = __indirect_glProgramNamedParameter4fNV;
+    glAPI->ProgramNamedParameter4dNV = __indirect_glProgramNamedParameter4dNV;
+    glAPI->ProgramNamedParameter4fvNV = __indirect_glProgramNamedParameter4fvNV;
+    glAPI->ProgramNamedParameter4dvNV = __indirect_glProgramNamedParameter4dvNV;
+    glAPI->GetProgramNamedParameterfvNV = __indirect_glGetProgramNamedParameterfvNV;
+    glAPI->GetProgramNamedParameterdvNV = __indirect_glGetProgramNamedParameterdvNV;
+
+    /* GL_NV_vertex_program */
+
+    glAPI->GetVertexAttribdvNV = __indirect_glGetVertexAttribdvNV;
+    glAPI->GetVertexAttribfvNV = __indirect_glGetVertexAttribfvNV;
+    glAPI->GetVertexAttribivNV = __indirect_glGetVertexAttribivNV;
+    glAPI->VertexAttrib1dNV = __indirect_glVertexAttrib1dNV;
+    glAPI->VertexAttrib1dvNV = __indirect_glVertexAttrib1dvNV;
+    glAPI->VertexAttrib1fNV = __indirect_glVertexAttrib1fNV;
+    glAPI->VertexAttrib1fvNV = __indirect_glVertexAttrib1fvNV;
+    glAPI->VertexAttrib1sNV = __indirect_glVertexAttrib1sNV;
+    glAPI->VertexAttrib1svNV = __indirect_glVertexAttrib1svNV;
+    glAPI->VertexAttrib2dNV = __indirect_glVertexAttrib2dNV;
+    glAPI->VertexAttrib2dvNV = __indirect_glVertexAttrib2dvNV;
+    glAPI->VertexAttrib2fNV = __indirect_glVertexAttrib2fNV;
+    glAPI->VertexAttrib2fvNV = __indirect_glVertexAttrib2fvNV;
+    glAPI->VertexAttrib2sNV = __indirect_glVertexAttrib2sNV;
+    glAPI->VertexAttrib2svNV = __indirect_glVertexAttrib2svNV;
+    glAPI->VertexAttrib3dNV = __indirect_glVertexAttrib3dNV;
+    glAPI->VertexAttrib3dvNV = __indirect_glVertexAttrib3dvNV;
+    glAPI->VertexAttrib3fNV = __indirect_glVertexAttrib3fNV;
+    glAPI->VertexAttrib3fvNV = __indirect_glVertexAttrib3fvNV;
+    glAPI->VertexAttrib3sNV = __indirect_glVertexAttrib3sNV;
+    glAPI->VertexAttrib3svNV = __indirect_glVertexAttrib3svNV;
+    glAPI->VertexAttrib4dNV = __indirect_glVertexAttrib4dNV;
+    glAPI->VertexAttrib4dvNV = __indirect_glVertexAttrib4dvNV;
+    glAPI->VertexAttrib4fNV = __indirect_glVertexAttrib4fNV;
+    glAPI->VertexAttrib4fvNV = __indirect_glVertexAttrib4fvNV;
+    glAPI->VertexAttrib4sNV = __indirect_glVertexAttrib4sNV;
+    glAPI->VertexAttrib4svNV = __indirect_glVertexAttrib4svNV;
+    glAPI->VertexAttrib4ubNV = __indirect_glVertexAttrib4ubNV;
+    glAPI->VertexAttrib4ubvNV = __indirect_glVertexAttrib4ubvNV;
+
     return glAPI;
 }
 
index 8bc7e449021294047005c0f6dd88c0db9ea7d8cc..fece228209871e992aa78392e73a4ad804399553 100644 (file)
@@ -103,6 +103,12 @@ struct array_state {
      */
     GLint count;
 
+    /**
+     * "Normalized" data is on the range [0,1] (unsigned) or [-1,1] (signed).
+     * This is used for mapping integral types to floating point types.
+     */
+    GLboolean normalized;
+
     /**
      * Pre-calculated GLX protocol command header.
      */
@@ -296,6 +302,14 @@ struct array_state_vector {
      */
     unsigned num_texture_units;
 
+    /**
+     * Number of generic vertex program attribs.  If GL_ARB_vertex_program
+     * is not supported, this will be zero.  Otherwise it will be the value
+     * queries by calling \c glGetProgramiv with \c GL_VERTEX_PROGRAM_ARB
+     * and \c GL_MAX_PROGRAM_ATTRIBS_ARB.
+     */
+    unsigned num_vertex_program_attribs;
+
     /**
      * \n Methods for implementing various GL functions.
      * 
@@ -337,8 +351,8 @@ static GLubyte * emit_element_old( GLubyte * dst,
 static struct array_state * get_array_entry(
     const struct array_state_vector * arrays, GLenum key, unsigned index );
 static void fill_array_info_cache( struct array_state_vector * arrays );
-static GLboolean glx_validate_array_args(__GLXcontext *gc, GLenum mode,
-    GLsizei count);
+static GLboolean validate_mode(__GLXcontext *gc, GLenum mode);
+static GLboolean validate_count(__GLXcontext *gc, GLsizei count);
 
 
 /**
@@ -380,6 +394,8 @@ __glXInitVertexArrayState( __GLXcontext * gc )
     unsigned array_count;
     unsigned texture_units = 1;
     unsigned i;
+    unsigned j;
+    unsigned vertex_program_attribs;
 
     GLboolean got_fog = GL_FALSE;
     GLboolean got_secondary_color = GL_FALSE;
@@ -432,8 +448,14 @@ __glXInitVertexArrayState( __GLXcontext * gc )
        texture_units = 1;
     }
 
+    if ( __glExtensionBitIsEnabled( gc, GL_ARB_vertex_program_bit ) ) {
+       glGetProgramivARB( GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ATTRIBS_ARB,
+                          & vertex_program_attribs );
+    }
+
     arrays->num_texture_units = texture_units;
-    array_count += texture_units;
+    arrays->num_vertex_program_attribs = vertex_program_attribs;
+    array_count += texture_units + vertex_program_attribs;
     arrays->num_arrays = array_count;
     arrays->arrays = malloc( sizeof( struct array_state ) * array_count );
     
@@ -444,11 +466,13 @@ __glXInitVertexArrayState( __GLXcontext * gc )
     arrays->arrays[0].data_type = GL_FLOAT;
     arrays->arrays[0].count = 3;
     arrays->arrays[0].key = GL_NORMAL_ARRAY;
+    arrays->arrays[0].normalized = GL_TRUE;
     arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
 
     arrays->arrays[1].data_type = GL_FLOAT;
     arrays->arrays[1].count = 4;
     arrays->arrays[1].key = GL_COLOR_ARRAY;
+    arrays->arrays[1].normalized = GL_TRUE;
     arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
 
     arrays->arrays[2].data_type = GL_FLOAT;
@@ -465,7 +489,7 @@ __glXInitVertexArrayState( __GLXcontext * gc )
        arrays->arrays[4 + i].data_type = GL_FLOAT;
        arrays->arrays[4 + i].count = 4;
        arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
-       
+
        arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
        arrays->arrays[4 + i].index = i;
 
@@ -487,10 +511,28 @@ __glXInitVertexArrayState( __GLXcontext * gc )
        arrays->arrays[i].count = 3;
        arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
        arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
+       arrays->arrays[i].normalized = GL_TRUE;
        i++;
     }
 
 
+    for ( j = 0 ; j < vertex_program_attribs ; j++ ) {
+       const unsigned idx = (vertex_program_attribs - (j + 1));
+
+
+       arrays->arrays[idx + i].data_type = GL_FLOAT;
+       arrays->arrays[idx + i].count = 4;
+       arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
+
+       arrays->arrays[idx + i].old_DrawArrays_possible = 0;
+       arrays->arrays[idx + i].index = idx;
+
+       arrays->arrays[idx + i].header[1] = idx;
+    }
+
+    i += vertex_program_attribs;
+
+
     /* Vertex array *must* be last becuase of the way that
      * emit_DrawArrays_none works.
      */
@@ -521,8 +563,7 @@ calculate_single_vertex_size_none( const struct array_state_vector * arrays )
 
     for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
        if ( arrays->arrays[i].enabled ) {
-           single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size)
-             + arrays->arrays[i].header_size;
+           single_vertex_size += ((uint16_t *)arrays->arrays[i].header)[0];
        }
     }
     
@@ -545,6 +586,15 @@ emit_element_none( GLubyte * dst,
        if ( arrays->arrays[i].enabled ) {
            const size_t offset = index * arrays->arrays[i].true_stride;
 
+           /* The generic attributes can have more data than is in the
+            * elements.  This is because a vertex array can be a 2 element,
+            * normalized, unsigned short, but the "closest" immediate mode
+            * protocol is for a 4Nus.  Since the sizes are small, the
+            * performance impact on modern processors should be negligible.
+            */
+           (void) memset( dst, 0,
+                          ((uint16_t *)arrays->arrays[i].header)[0] );
+
            (void) memcpy( dst, arrays->arrays[i].header, 
                           arrays->arrays[i].header_size );
 
@@ -1635,6 +1685,139 @@ void __indirect_glFogCoordPointerEXT( GLenum type, GLsizei stride,
 }
 
 
+void __indirect_glVertexAttribPointerARB(GLuint index, GLint size,
+                                        GLenum type, GLboolean normalized,
+                                        GLsizei stride,
+                                        const GLvoid * pointer)
+{
+    static const uint16_t short_ops[5]  = { 0, 4189, 4190, 4191, 4192 };
+    static const uint16_t float_ops[5]  = { 0, 4193, 4194, 4195, 4196 };
+    static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 };
+
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+    unsigned true_immediate_count;
+    unsigned true_immediate_size;
+
+
+    if ( (size < 1) || (size > 4) || (stride < 0) 
+        || (index > arrays->num_vertex_program_attribs) ){
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+
+    if ( normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) {
+       switch( type ) {
+       case GL_BYTE:           opcode = X_GLrop_VertexAttrib4NbvARB;  break;
+       case GL_UNSIGNED_BYTE:  opcode = X_GLrop_VertexAttrib4NubvARB; break;
+       case GL_SHORT:          opcode = X_GLrop_VertexAttrib4NsvARB;  break;
+       case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4NusvARB; break;
+       case GL_INT:            opcode = X_GLrop_VertexAttrib4NivARB;  break;
+       case GL_UNSIGNED_INT:   opcode = X_GLrop_VertexAttrib4NuivARB; break;
+       default:
+           __glXSetError(gc, GL_INVALID_ENUM);
+           return;
+       }
+       
+       true_immediate_count = 4;
+    }
+    else {
+       switch( type ) {
+       case GL_BYTE:
+           opcode = X_GLrop_VertexAttrib4bvARB;
+           true_immediate_count = 4;
+           break;
+       case GL_UNSIGNED_BYTE:
+           opcode = X_GLrop_VertexAttrib4ubvARB;
+           true_immediate_count = 4;
+           break;
+       case GL_SHORT:
+           opcode = short_ops[size];
+           break;
+       case GL_UNSIGNED_SHORT:
+           opcode = X_GLrop_VertexAttrib4usvARB;
+           true_immediate_count = 4;
+           break;
+       case GL_INT:
+            opcode = X_GLrop_VertexAttrib4ivARB;
+           true_immediate_count = 4;
+           break;
+       case GL_UNSIGNED_INT:
+           opcode = X_GLrop_VertexAttrib4uivARB;
+           true_immediate_count = 4;
+           break;
+       case GL_FLOAT:
+           opcode = float_ops[size];
+           break;
+       case GL_DOUBLE:
+           opcode = double_ops[size];
+           break;
+       default:
+           __glXSetError(gc, GL_INVALID_ENUM);
+           return;
+       }
+    }
+
+    a = get_array_entry( arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index );
+    if ( a == NULL ) {
+        __glXSetError(gc, GL_INVALID_OPERATION);
+        return;
+    }
+
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, 8, opcode );
+
+    true_immediate_size = __glXTypeSize(type) * true_immediate_count;
+    ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size 
+                                             + true_immediate_size);
+
+    if ( a->enabled ) {
+       arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+/**
+ * I don't have 100% confidence that this is correct.  The different rules
+ * about whether or not generic vertex attributes alias "classic" vertex
+ * attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program,
+ * ARB_vertex_shader, and NV_vertex_program are a bit confusing.  My
+ * feeling is that the client-side doesn't have to worry about it.  The
+ * client just sends all the data to the server and lets the server deal
+ * with it.
+ */
+void __indirect_glVertexAttribPointerNV( GLuint index, GLint size,
+                                        GLenum type, GLsizei stride,
+                                        const GLvoid * pointer)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    GLboolean normalized = GL_FALSE;
+
+
+    switch( type ) {
+    case GL_UNSIGNED_BYTE:
+       if ( size != 4 ) {
+           __glXSetError(gc, GL_INVALID_VALUE);
+           return;
+       }
+       normalized = GL_TRUE;
+
+    case GL_SHORT:
+    case GL_FLOAT:
+    case GL_DOUBLE:
+       __indirect_glVertexAttribPointerARB(index, size, type,
+                                           normalized,
+                                           stride, pointer);
+       return;
+    default:
+       __glXSetError(gc, GL_INVALID_ENUM);
+       return;
+    }
+}
+
+
 void __indirect_glClientActiveTextureARB(GLenum texture)
 {
     __GLXcontext * const gc = __glXGetCurrentContext();
@@ -1776,7 +1959,26 @@ __glXGetArrayPointer( const __GLXattribute * const state,
 
 
     if ( a != NULL ) {
-       *dest = a->data;
+       *dest = (void *) (a->data);
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayNormalized( const __GLXattribute * const state,
+                        GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+                                                   key, index );
+
+
+    if ( a != NULL ) {
+       *dest = (GLintptr) a->normalized;
     }
 
     return (a != NULL);
index 5eae8a5a6e95d29e26b86239c4a4b7ac02168d45..caab62b672e9ea86c9c69ab6c7491bec8c1b0101 100644 (file)
@@ -46,6 +46,8 @@ extern GLboolean __glXGetArrayStride( const __GLXattribute * const state,
     GLenum key, unsigned index, GLintptr * dest );
 extern GLboolean __glXGetArrayPointer( const __GLXattribute * const state,
     GLenum key, unsigned index, void ** dest );
+extern GLboolean __glXGetArrayNormalized( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
 
 extern void __glXPushArrayState( __GLXattribute * state );
 extern void __glXPopArrayState( __GLXattribute * state );
diff --git a/src/glx/x11/indirect_vertex_program.c b/src/glx/x11/indirect_vertex_program.c
new file mode 100644 (file)
index 0000000..93fd9a3
--- /dev/null
@@ -0,0 +1,272 @@
+/*
+ * (C) Copyright IBM Corporation 2005
+ * 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, sub license,
+ * 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <inttypes.h>
+#include <GL/gl.h>
+#include "indirect.h"
+#include "glxclient.h"
+#include "indirect_vertex_array.h"
+#include <GL/glxproto.h>
+
+void do_vertex_attrib_enable( GLuint index, GLboolean val )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+    if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+                               index, val ) ) {
+       __glXSetError(gc, GL_INVALID_ENUM);
+    }
+}
+
+
+void __indirect_glEnableVertexAttribArrayARB( GLuint index )
+{
+    do_vertex_attrib_enable( index, GL_TRUE );
+}
+
+
+void __indirect_glDisableVertexAttribArrayARB( GLuint index )
+{
+    do_vertex_attrib_enable( index, GL_FALSE );
+}
+
+
+static void
+get_parameter( unsigned opcode, unsigned size, GLenum target, GLuint index,
+                 GLfloat * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc,
+                                                    X_GLXVendorPrivateWithReply,
+                                                    opcode, cmdlen);
+
+       *((GLenum *)(pc +  0)) = target;
+       *((GLuint *)(pc +  4)) = index;
+       *((GLuint *)(pc +  8)) = 0;
+
+        (void) __glXReadReply(dpy, size, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+
+void __indirect_glGetProgramEnvParameterfvARB( GLenum target, GLuint index,
+                                              GLfloat * params )
+{
+    get_parameter( 1296, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramEnvParameterdvARB( GLenum target, GLuint index,
+                                              GLdouble * params )
+{
+    get_parameter( 1297, 8, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterfvARB( GLenum target, GLuint index,
+                                                GLfloat * params )
+{
+    get_parameter( 1305, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterdvARB( GLenum target, GLuint index,
+                                                GLdouble * params )
+{
+    get_parameter( 1306, 8, target, index, params );
+}
+
+
+void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname,
+                                            GLvoid ** pointer )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) {
+       __glXSetError( gc, GL_INVALID_ENUM );
+    }
+    
+    if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+                                index, pointer ) ) {
+       __glXSetError( gc, GL_INVALID_VALUE );
+    }
+}
+
+
+/**
+ * Get the selected attribute from the vertex array state vector.
+ * 
+ * \returns
+ * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
+ */
+static GLboolean
+get_attrib_array_data( __GLXattribute * state, GLuint index, GLenum cap,
+                      GLintptr * data )
+{
+    GLboolean retval = GL_FALSE;
+    const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;
+
+    switch( cap ) {
+    case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
+       retval = __glXGetArrayEnable( state, attrib, index, data );
+       break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
+       retval = __glXGetArraySize( state, attrib, index, data );
+       break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
+       retval = __glXGetArrayStride( state, attrib, index, data );
+       break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
+       retval = __glXGetArrayType( state, attrib, index, data );
+       break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
+       retval = __glXGetArrayNormalized( state, attrib, index, data );
+       break;
+    }
+
+    
+    return retval;
+}
+
+
+static void get_vertex_attrib( __GLXcontext * gc, unsigned vop,
+                              GLuint index, GLenum pname,
+                              xReply * reply )
+{
+    Display * const dpy = gc->currentDpy;
+    GLubyte * const pc = __glXSetupVendorRequest(gc,
+                                                X_GLXVendorPrivateWithReply,
+                                                vop, 8);
+                                                    
+    *((uint32_t *)(pc +  0)) = index;
+    *((uint32_t *)(pc +  4)) = pname;
+
+    (void) _XReply( dpy, reply, 0, False );
+}
+
+
+void __indirect_glGetVertexAttribivARB( GLuint index, GLenum pname,
+                                       GLint * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1303, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+       if ( ! get_attrib_array_data( state, index, pname, params ) ) {
+           if (reply.size == 1) {
+               *params = (GLint) reply.pad3;
+           } 
+           else {
+               _XRead(dpy, (void *) params, 4 * reply.size);
+           }
+       }
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribfvARB( GLuint index, GLenum pname,
+                                       GLfloat * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1302, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+       GLintptr data;
+
+
+       if ( get_attrib_array_data( state, index, pname, & data ) ) {
+           *params = (GLfloat) data;
+       }
+       else {
+           if (reply.size == 1) {
+               (void) memcpy( params, & reply.pad3, sizeof( GLfloat ) );
+           } 
+           else {
+               _XRead(dpy, (void *) params, 4 * reply.size);
+           }
+       }
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribdvARB( GLuint index, GLenum pname,
+                                       GLdouble * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1301, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+       GLintptr data;
+
+
+       if ( get_attrib_array_data( state, index, pname, & data ) ) {
+           *params = (GLdouble) data;
+       }
+       else {
+           if (reply.size == 1) {
+               (void) memcpy( params, & reply.pad3, sizeof( GLdouble ) );
+           } 
+           else {
+               _XRead(dpy, (void *) params, 8 * reply.size);
+           }
+       }
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
index b4c568b05e5bb50fd028a4436761bad5bd604796..47896d898d7aef87b4fca5052363f94c7ec2dead 100644 (file)
@@ -5317,13 +5317,39 @@ glx:
 
 <category name="GL_ARB_vertex_program" number="26">
     <enum name="COLOR_SUM_ARB"                            value="0x8458"/>
-    <enum name="VERTEX_PROGRAM_ARB"                       value="0x8620"/>
-    <enum name="VERTEX_ATTRIB_ARRAY_ENABLED_ARB"          value="0x8622"/>
-    <enum name="VERTEX_ATTRIB_ARRAY_SIZE_ARB"             value="0x8623"/>
-    <enum name="VERTEX_ATTRIB_ARRAY_STRIDE_ARB"           value="0x8624"/>
-    <enum name="VERTEX_ATTRIB_ARRAY_TYPE_ARB"             value="0x8625"/>
-    <enum name="CURRENT_VERTEX_ATTRIB_ARB"                value="0x8626"/>
-    <enum name="PROGRAM_LENGTH_ARB"                       value="0x8627"/>
+    <enum name="VERTEX_PROGRAM_ARB"            count="1"  value="0x8620">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="VERTEX_ATTRIB_ARRAY_ENABLED_ARB" count="1" value="0x8622">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="VERTEX_ATTRIB_ARRAY_SIZE_ARB"  count="1"  value="0x8623">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="VERTEX_ATTRIB_ARRAY_STRIDE_ARB" count="1" value="0x8624">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="VERTEX_ATTRIB_ARRAY_TYPE_ARB"  count="1"  value="0x8625">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="CURRENT_VERTEX_ATTRIB_ARB"     count="1"  value="0x8626">
+        <size name="GetVertexAttribdvARB" mode="get"/>
+        <size name="GetVertexAttribfvARB" mode="get"/>
+        <size name="GetVertexAttribivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_LENGTH_ARB"            count="1"  value="0x8627">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
     <enum name="PROGRAM_STRING_ARB"                       value="0x8628"/>
     <enum name="MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB"       value="0x862E"/>
     <enum name="MAX_PROGRAM_MATRICES_ARB"                 value="0x862F"/>
@@ -5333,35 +5359,85 @@ glx:
     <enum name="VERTEX_PROGRAM_TWO_SIDE_ARB"              value="0x8643"/>
     <enum name="VERTEX_ATTRIB_ARRAY_POINTER_ARB"          value="0x8645"/>
     <enum name="PROGRAM_ERROR_POSITION_ARB"               value="0x864B"/>
-    <enum name="PROGRAM_BINDING_ARB"                      value="0x8677"/>
+    <enum name="PROGRAM_BINDING_ARB"           count="1"  value="0x8677">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
     <enum name="MAX_VERTEX_ATTRIBS_ARB"                   value="0x8869"/>
     <enum name="VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB"       value="0x886A"/>
     <enum name="PROGRAM_ERROR_STRING_ARB"                 value="0x8874"/>
     <enum name="PROGRAM_FORMAT_ASCII_ARB"                 value="0x8875"/>
-    <enum name="PROGRAM_FORMAT_ARB"                       value="0x8876"/>
-    <enum name="PROGRAM_INSTRUCTIONS_ARB"                 value="0x88A0"/>
-    <enum name="MAX_PROGRAM_INSTRUCTIONS_ARB"             value="0x88A1"/>
-    <enum name="PROGRAM_NATIVE_INSTRUCTIONS_ARB"          value="0x88A2"/>
-    <enum name="MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB"      value="0x88A3"/>
-    <enum name="PROGRAM_TEMPORARIES_ARB"                  value="0x88A4"/>
-    <enum name="MAX_PROGRAM_TEMPORARIES_ARB"              value="0x88A5"/>
-    <enum name="PROGRAM_NATIVE_TEMPORARIES_ARB"           value="0x88A6"/>
-    <enum name="MAX_PROGRAM_NATIVE_TEMPORARIES_ARB"       value="0x88A7"/>
-    <enum name="PROGRAM_PARAMETERS_ARB"                   value="0x88A8"/>
-    <enum name="MAX_PROGRAM_PARAMETERS_ARB"               value="0x88A9"/>
-    <enum name="PROGRAM_NATIVE_PARAMETERS_ARB"            value="0x88AA"/>
-    <enum name="MAX_PROGRAM_NATIVE_PARAMETERS_ARB"        value="0x88AB"/>
-    <enum name="PROGRAM_ATTRIBS_ARB"                      value="0x88AC"/>
-    <enum name="MAX_PROGRAM_ATTRIBS_ARB"                  value="0x88AD"/>
-    <enum name="PROGRAM_NATIVE_ATTRIBS_ARB"               value="0x88AE"/>
-    <enum name="MAX_PROGRAM_NATIVE_ATTRIBS_ARB"           value="0x88AF"/>
-    <enum name="PROGRAM_ADDRESS_REGISTERS_ARB"            value="0x88B0"/>
-    <enum name="MAX_PROGRAM_ADDRESS_REGISTERS_ARB"        value="0x88B1"/>
-    <enum name="PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB"     value="0x88B2"/>
-    <enum name="MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" value="0x88B3"/>
-    <enum name="MAX_PROGRAM_LOCAL_PARAMETERS_ARB"         value="0x88B4"/>
-    <enum name="MAX_PROGRAM_ENV_PARAMETERS_ARB"           value="0x88B5"/>
-    <enum name="PROGRAM_UNDER_NATIVE_LIMITS_ARB"          value="0x88B6"/>
+    <enum name="PROGRAM_FORMAT_ARB"            count="1"  value="0x8876">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_INSTRUCTIONS_ARB"      count="1"  value="0x88A0">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_INSTRUCTIONS_ARB"  count="1"  value="0x88A1">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_NATIVE_INSTRUCTIONS_ARB" count="1" value="0x88A2">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" count="1" value="0x88A3">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_TEMPORARIES_ARB"       count="1"  value="0x88A4">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_TEMPORARIES_ARB"   count="1"  value="0x88A5">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_NATIVE_TEMPORARIES_ARB" count="1" value="0x88A6">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" count="1" value="0x88A7">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_PARAMETERS_ARB"        count="1"  value="0x88A8">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_PARAMETERS_ARB"    count="1"  value="0x88A9">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_NATIVE_PARAMETERS_ARB" count="1"  value="0x88AA">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_NATIVE_PARAMETERS_ARB" count="1" value="0x88AB">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_ATTRIBS_ARB"           count="1"  value="0x88AC">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_ATTRIBS_ARB"       count="1"  value="0x88AD">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_NATIVE_ATTRIBS_ARB"    count="1"  value="0x88AE">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_NATIVE_ATTRIBS_ARB" count="1" value="0x88AF">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_ADDRESS_REGISTERS_ARB" count="1"  value="0x88B0">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_ADDRESS_REGISTERS_ARB" count="1" value="0x88B1">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" count="1" value="0x88B2">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" count="1" value="0x88B3">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_LOCAL_PARAMETERS_ARB" count="1" value="0x88B4">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_ENV_PARAMETERS_ARB" count="1" value="0x88B5">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_UNDER_NATIVE_LIMITS_ARB" count="1" value="0x88B6">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
     <enum name="TRANSPOSE_CURRENT_MATRIX_ARB"             value="0x88B7"/>
     <enum name="MATRIX0_ARB"                              value="0x88C0"/>
     <enum name="MATRIX1_ARB"                              value="0x88C1"/>
@@ -5399,97 +5475,91 @@ glx:
     <function name="GetVertexAttribdvARB" offset="588">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLdouble *" output="true"/>
-        <glx ignore="true"/>
+        <param name="params" type="GLdouble *" output="true" variable_param="pname"/>
+        <glx handcode="client" vendorpriv="1301"/>
     </function>
 
     <function name="GetVertexAttribfvARB" offset="589">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLfloat *" output="true"/>
-        <glx ignore="true"/>
+        <param name="params" type="GLfloat *" output="true" variable_param="pname"/>
+        <glx handcode="client" vendorpriv="1302"/>
     </function>
 
     <function name="GetVertexAttribivARB" offset="590">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLint *" output="true"/>
-        <glx ignore="true"/>
+        <param name="params" type="GLint *" output="true" variable_param="pname"/>
+        <glx handcode="client" vendorpriv="1303"/>
     </function>
 
     <function name="VertexAttrib1dARB" offset="603" vectorequiv="VertexAttrib1dvARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib1dvARB" offset="604">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLdouble *" count="1"/>
-        <glx ignore="true"/>
+        <glx rop="4197"/>
     </function>
 
     <function name="VertexAttrib1fARB" offset="605" vectorequiv="VertexAttrib1fvARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib1fvARB" offset="606">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLfloat *" count="1"/>
-        <glx ignore="true"/>
+        <glx rop="4193"/>
     </function>
 
     <function name="VertexAttrib1sARB" offset="607" vectorequiv="VertexAttrib1svARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLshort"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib1svARB" offset="608">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLshort *" count="1"/>
-        <glx ignore="true"/>
+        <glx rop="4189"/>
     </function>
 
     <function name="VertexAttrib2dARB" offset="609" vectorequiv="VertexAttrib2dvARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLdouble"/>
         <param name="y" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib2dvARB" offset="610">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLdouble *" count="2"/>
-        <glx ignore="true"/>
+        <glx rop="4198"/>
     </function>
 
     <function name="VertexAttrib2fARB" offset="611" vectorequiv="VertexAttrib2fvARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLfloat"/>
         <param name="y" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib2fvARB" offset="612">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLfloat *" count="2"/>
-        <glx ignore="true"/>
+        <glx rop="4194"/>
     </function>
 
     <function name="VertexAttrib2sARB" offset="613" vectorequiv="VertexAttrib2svARB">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLshort"/>
         <param name="y" type="GLshort"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib2svARB" offset="614">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLshort *" count="2"/>
-        <glx ignore="true"/>
+        <glx rop="4190"/>
     </function>
 
     <function name="VertexAttrib3dARB" offset="615" vectorequiv="VertexAttrib3dvARB">
@@ -5497,13 +5567,12 @@ glx:
         <param name="x" type="GLdouble"/>
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib3dvARB" offset="616">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLdouble *" count="3"/>
-        <glx ignore="true"/>
+        <glx rop="4199"/>
     </function>
 
     <function name="VertexAttrib3fARB" offset="617" vectorequiv="VertexAttrib3fvARB">
@@ -5511,13 +5580,12 @@ glx:
         <param name="x" type="GLfloat"/>
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib3fvARB" offset="618">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLfloat *" count="3"/>
-        <glx ignore="true"/>
+        <glx rop="4195"/>
     </function>
 
     <function name="VertexAttrib3sARB" offset="619" vectorequiv="VertexAttrib3svARB">
@@ -5525,13 +5593,12 @@ glx:
         <param name="x" type="GLshort"/>
         <param name="y" type="GLshort"/>
         <param name="z" type="GLshort"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib3svARB" offset="620">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLshort *" count="3"/>
-        <glx ignore="true"/>
+        <glx rop="4191"/>
     </function>
 
     <function name="VertexAttrib4dARB" offset="621" vectorequiv="VertexAttrib4dvARB">
@@ -5540,13 +5607,12 @@ glx:
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
         <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib4dvARB" offset="622">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLdouble *" count="4"/>
-        <glx ignore="true"/>
+        <glx rop="4200"/>
     </function>
 
     <function name="VertexAttrib4fARB" offset="623" vectorequiv="VertexAttrib4fvARB">
@@ -5555,13 +5621,12 @@ glx:
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
         <param name="w" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib4fvARB" offset="624">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLfloat *" count="4"/>
-        <glx ignore="true"/>
+        <glx rop="4196"/>
     </function>
 
     <function name="VertexAttrib4sARB" offset="625" vectorequiv="VertexAttrib4svARB">
@@ -5570,13 +5635,12 @@ glx:
         <param name="y" type="GLshort"/>
         <param name="z" type="GLshort"/>
         <param name="w" type="GLshort"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib4svARB" offset="626">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLshort *" count="4"/>
-        <glx ignore="true"/>
+        <glx rop="4192"/>
     </function>
 
     <function name="VertexAttrib4NubARB" offset="627" vectorequiv="VertexAttrib4NubvARB">
@@ -5585,13 +5649,12 @@ glx:
         <param name="y" type="GLubyte"/>
         <param name="z" type="GLubyte"/>
         <param name="w" type="GLubyte"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib4NubvARB" offset="628">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLubyte *" count="4"/>
-        <glx ignore="true"/>
+        <glx rop="4201"/>
     </function>
 
     <function name="VertexAttrib4bvARB" offset="654">
@@ -5603,55 +5666,55 @@ glx:
     <function name="VertexAttrib4ivARB" offset="655">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLint *" count="4"/>
-        <glx rop="4231" ignore="true"/>
+        <glx rop="4231"/>
     </function>
 
     <function name="VertexAttrib4ubvARB" offset="656">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLubyte *" count="4"/>
-        <glx rop="4232" ignore="true"/>
+        <glx rop="4232"/>
     </function>
 
     <function name="VertexAttrib4usvARB" offset="657">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLushort *" count="4"/>
-        <glx rop="4233" ignore="true"/>
+        <glx rop="4233"/>
     </function>
 
     <function name="VertexAttrib4uivARB" offset="658">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLuint *" count="4"/>
-        <glx rop="4234" ignore="true"/>
+        <glx rop="4234"/>
     </function>
 
     <function name="VertexAttrib4NbvARB" offset="659">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLbyte *" count="4"/>
-        <glx rop="4235" ignore="true"/>
+        <glx rop="4235"/>
     </function>
 
     <function name="VertexAttrib4NsvARB" offset="660">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLshort *" count="4"/>
-        <glx rop="4236" ignore="true"/>
+        <glx rop="4236"/>
     </function>
 
     <function name="VertexAttrib4NivARB" offset="661">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLint *" count="4"/>
-        <glx rop="4237" ignore="true"/>
+        <glx rop="4237"/>
     </function>
 
     <function name="VertexAttrib4NusvARB" offset="662">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLushort *" count="4"/>
-        <glx rop="4238" ignore="true"/>
+        <glx rop="4238"/>
     </function>
 
     <function name="VertexAttrib4NuivARB" offset="663">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLuint *" count="4"/>
-        <glx rop="4239" ignore="true"/>
+        <glx rop="4239"/>
     </function>
 
     <function name="VertexAttribPointerARB" offset="664">
@@ -5661,25 +5724,25 @@ glx:
         <param name="normalized" type="GLboolean"/>
         <param name="stride" type="GLsizei"/>
         <param name="pointer" type="const GLvoid *"/>
-        <glx handcode="true" ignore="true"/>
+        <glx handcode="true"/>
     </function>
 
     <function name="EnableVertexAttribArrayARB" offset="665">
         <param name="index" type="GLuint"/>
-        <glx handcode="true" ignore="true"/>
+        <glx handcode="true"/>
     </function>
 
     <function name="DisableVertexAttribArrayARB" offset="666">
         <param name="index" type="GLuint"/>
-        <glx handcode="true" ignore="true"/>
+        <glx handcode="true"/>
     </function>
 
     <function name="ProgramStringARB" offset="667">
         <param name="target" type="GLenum"/>
         <param name="format" type="GLenum"/>
-        <param name="len" type="GLsizei"/>
-        <param name="string" type="const GLvoid *"/>
-        <glx rop="4217" handcode="true" ignore="true"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="string" type="const GLvoid *" count="len"/>
+        <glx rop="4217" large="true"/>
     </function>
 
     <function name="BindProgramARB" alias="BindProgramNV">
@@ -5702,7 +5765,6 @@ glx:
         <return type="GLboolean"/>
     </function>
 
-    <!-- FIXME: This should alias to ProgramParameter*NV -->
     <function name="ProgramEnvParameter4dARB" offset="668" vectorequiv="ProgramEnvParameter4dvARB">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
@@ -5710,18 +5772,15 @@ glx:
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
         <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
-    <!-- FIXME: This should alias to ProgramParameter*NV -->
     <function name="ProgramEnvParameter4dvARB" offset="669">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLdouble *" count="4"/>
-        <glx rop="4185" doubles_in_order="true" ignore="true"/>
+        <glx rop="4185" doubles_in_order="true"/>
     </function>
 
-    <!-- FIXME: This should alias to ProgramParameter*NV -->
     <function name="ProgramEnvParameter4fARB" offset="670" vectorequiv="ProgramEnvParameter4fvARB">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
@@ -5729,15 +5788,13 @@ glx:
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
         <param name="w" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
-    <!-- FIXME: This should alias to ProgramParameter*NV -->
     <function name="ProgramEnvParameter4fvARB" offset="671">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLfloat *" count="4"/>
-        <glx rop="4184" ignore="true"/>
+        <glx rop="4184"/>
     </function>
 
     <function name="ProgramLocalParameter4dARB" offset="672" vectorequiv="ProgramLocalParameter4dvARB">
@@ -5747,14 +5804,13 @@ glx:
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
         <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="ProgramLocalParameter4dvARB" offset="673">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLdouble *" count="4"/>
-        <glx rop="4216" doubles_in_order="true" ignore="true"/>
+        <glx rop="4216" doubles_in_order="true"/>
     </function>
 
     <function name="ProgramLocalParameter4fARB" offset="674" vectorequiv="ProgramLocalParameter4fvARB">
@@ -5764,58 +5820,68 @@ glx:
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
         <param name="w" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="ProgramLocalParameter4fvARB" offset="675">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLfloat *" count="4"/>
-        <glx rop="4215" ignore="true"/>
+        <glx rop="4215"/>
     </function>
 
-    <!-- FIXME: This should alias to GetProgramParameter*NV -->
+    <!-- The GetProgramEnvParameter[df]vARB are handcoded because there
+         is an extra CARD32 of padding after the "index" field.  Originally,
+         GetProgranEnvParameter[df]vARB and GetProgramParameter[df]vNV
+         shared the same GLX protocol.  The pad field was where the pname
+         parameter was in the NV functions.  When this error was discovered
+         and fixed, there was already at least one implementation of
+         GLX protocol for ARB_vertex_program, but there were no
+         implementations of NV_vertex_program.  The sollution was to renumber
+         the opcodes for NV_vertex_program and convert the unused field in
+         the ARB_vertex_program protocol to unused padding.
+      -->
+
     <function name="GetProgramEnvParameterdvARB" offset="676">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="GLdouble *" output="true"/>
-        <glx vendorpriv="1297" doubles_in_order="true" ignore="true"/>
+        <glx vendorpriv="1297" handcode="true" doubles_in_order="true"/>
     </function>
 
-    <!-- FIXME: This should alias to GetProgramParameter*NV -->
     <function name="GetProgramEnvParameterfvARB" offset="677">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="GLfloat *" output="true"/>
-        <glx vendorpriv="1296" ignore="true"/>
+        <glx vendorpriv="1296" handcode="true"/>
     </function>
 
     <function name="GetProgramLocalParameterdvARB" offset="678">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="GLdouble *" output="true"/>
-        <glx vendorpriv="1306" doubles_in_order="true" ignore="true"/>
+        <glx vendorpriv="1306" handcode="true" doubles_in_order="true"/>
     </function>
 
     <function name="GetProgramLocalParameterfvARB" offset="679">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="GLfloat *" output="true"/>
-        <glx vendorpriv="1305" ignore="true"/>
+        <glx vendorpriv="1305" handcode="true"/>
     </function>
 
+
     <function name="GetProgramivARB" offset="680">
         <param name="target" type="GLenum"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLint *" output="true"/>
-        <glx vendorpriv="1307" ignore="true"/>
+        <param name="params" type="GLint *" output="true" varaible_param="pname"/>
+        <glx vendorpriv="1307"/>
     </function>
 
     <function name="GetProgramStringARB" offset="681">
         <param name="target" type="GLenum"/>
         <param name="pname" type="GLenum"/>
         <param name="string" type="GLvoid *" output="true"/>
-        <glx vendorpriv="1308" handcode="true" ignore="true"/>
+        <glx vendorpriv="1308" handcode="server" always_array="true"/>
     </function>
 
     <function name="GetVertexAttribPointervARB" alias="GetVertexAttribPointervNV">
@@ -9456,109 +9522,221 @@ glx:
 </category>
 
 <category name="GL_NV_vertex_program" number="233">
+    <enum name="VERTEX_PROGRAM_NV"                        value="0x8620"/>
+    <enum name="VERTEX_STATE_PROGRAM_NV"                  value="0x8621"/>
+    <enum name="ATTRIB_ARRAY_SIZE_NV"          count="1"  value="0x8623">
+        <size name="GetVertexAttribdvNV" mode="get"/>
+        <size name="GetVertexAttribfvNV" mode="get"/>
+        <size name="GetVertexAttribivNV" mode="get"/>
+    </enum>
+    <enum name="ATTRIB_ARRAY_STRIDE_NV"        count="1"  value="0x8624">
+        <size name="GetVertexAttribdvNV" mode="get"/>
+        <size name="GetVertexAttribfvNV" mode="get"/>
+        <size name="GetVertexAttribivNV" mode="get"/>
+    </enum>
+    <enum name="ATTRIB_ARRAY_TYPE_NV"          count="1"  value="0x8625">
+        <size name="GetVertexAttribdvNV" mode="get"/>
+        <size name="GetVertexAttribfvNV" mode="get"/>
+        <size name="GetVertexAttribivNV" mode="get"/>
+    </enum>
+    <enum name="CURRENT_ATTRIB_NV"             count="1"  value="0x8626">
+        <size name="GetVertexAttribdvNV" mode="get"/>
+        <size name="GetVertexAttribfvNV" mode="get"/>
+        <size name="GetVertexAttribivNV" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_LENGTH_NV"             count="1"  value="0x8627">
+        <size name="GetProgramivNV" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_STRING_NV"                        value="0x8628"/>
+    <enum name="MODELVIEW_PROJECTION_NV"                  value="0x8629"/>
+    <enum name="IDENTITY_NV"                              value="0x862A"/>
+    <enum name="INVERSE_NV"                               value="0x862B"/>
+    <enum name="TRANSPOSE_NV"                             value="0x862C"/>
+    <enum name="INVERSE_TRANSPOSE_NV"                     value="0x862D"/>
+    <enum name="MAX_TRACK_MATRIX_STACK_DEPTH_NV"          value="0x862E"/>
+    <enum name="MAX_TRACK_MATRICES_NV"                    value="0x862F"/>
+    <enum name="MATRIX0_NV"                               value="0x8630"/>
+    <enum name="MATRIX1_NV"                               value="0x8631"/>
+    <enum name="MATRIX2_NV"                               value="0x8632"/>
+    <enum name="MATRIX3_NV"                               value="0x8633"/>
+    <enum name="MATRIX4_NV"                               value="0x8634"/>
+    <enum name="MATRIX5_NV"                               value="0x8635"/>
+    <enum name="MATRIX6_NV"                               value="0x8636"/>
+    <enum name="MATRIX7_NV"                               value="0x8637"/>
+    <enum name="CURRENT_MATRIX_STACK_DEPTH_NV"            value="0x8640"/>
+    <enum name="CURRENT_MATRIX_NV"                        value="0x8641"/>
+    <enum name="VERTEX_PROGRAM_POINT_SIZE_NV"             value="0x8642"/>
+    <enum name="VERTEX_PROGRAM_TWO_SIDE_NV"               value="0x8643"/>
+    <enum name="PROGRAM_PARAMETER_NV"                     value="0x8644"/>
+    <enum name="ATTRIB_ARRAY_POINTER_NV"                  value="0x8645"/>
+    <enum name="PROGRAM_TARGET_NV"             count="1"  value="0x8646">
+        <size name="GetProgramivNV" mode="get"/>
+    </enum>
+    <enum name="PROGRAM_RESIDENT_NV"           count="1"  value="0x8647">
+        <size name="GetProgramivNV" mode="get"/>
+    </enum>
+    <enum name="TRACK_MATRIX_NV"                          value="0x8648"/>
+    <enum name="TRACK_MATRIX_TRANSFORM_NV"                value="0x8649"/>
+    <enum name="VERTEX_PROGRAM_BINDING_NV"                value="0x864A"/>
+    <enum name="PROGRAM_ERROR_POSITION_NV"                value="0x864B"/>
+    <enum name="VERTEX_ATTRIB_ARRAY0_NV"                  value="0x8650"/>
+    <enum name="VERTEX_ATTRIB_ARRAY1_NV"                  value="0x8651"/>
+    <enum name="VERTEX_ATTRIB_ARRAY2_NV"                  value="0x8652"/>
+    <enum name="VERTEX_ATTRIB_ARRAY3_NV"                  value="0x8653"/>
+    <enum name="VERTEX_ATTRIB_ARRAY4_NV"                  value="0x8654"/>
+    <enum name="VERTEX_ATTRIB_ARRAY5_NV"                  value="0x8655"/>
+    <enum name="VERTEX_ATTRIB_ARRAY6_NV"                  value="0x8656"/>
+    <enum name="VERTEX_ATTRIB_ARRAY7_NV"                  value="0x8657"/>
+    <enum name="VERTEX_ATTRIB_ARRAY8_NV"                  value="0x8658"/>
+    <enum name="VERTEX_ATTRIB_ARRAY9_NV"                  value="0x8659"/>
+    <enum name="VERTEX_ATTRIB_ARRAY10_NV"                 value="0x865A"/>
+    <enum name="VERTEX_ATTRIB_ARRAY11_NV"                 value="0x865B"/>
+    <enum name="VERTEX_ATTRIB_ARRAY12_NV"                 value="0x865C"/>
+    <enum name="VERTEX_ATTRIB_ARRAY13_NV"                 value="0x865D"/>
+    <enum name="VERTEX_ATTRIB_ARRAY14_NV"                 value="0x865E"/>
+    <enum name="VERTEX_ATTRIB_ARRAY15_NV"                 value="0x865F"/>
+    <enum name="MAP1_VERTEX_ATTRIB0_4_NV"                 value="0x8660"/>
+    <enum name="MAP1_VERTEX_ATTRIB1_4_NV"                 value="0x8661"/>
+    <enum name="MAP1_VERTEX_ATTRIB2_4_NV"                 value="0x8662"/>
+    <enum name="MAP1_VERTEX_ATTRIB3_4_NV"                 value="0x8663"/>
+    <enum name="MAP1_VERTEX_ATTRIB4_4_NV"                 value="0x8664"/>
+    <enum name="MAP1_VERTEX_ATTRIB5_4_NV"                 value="0x8665"/>
+    <enum name="MAP1_VERTEX_ATTRIB6_4_NV"                 value="0x8666"/>
+    <enum name="MAP1_VERTEX_ATTRIB7_4_NV"                 value="0x8667"/>
+    <enum name="MAP1_VERTEX_ATTRIB8_4_NV"                 value="0x8668"/>
+    <enum name="MAP1_VERTEX_ATTRIB9_4_NV"                 value="0x8669"/>
+    <enum name="MAP1_VERTEX_ATTRIB10_4_NV"                value="0x866A"/>
+    <enum name="MAP1_VERTEX_ATTRIB11_4_NV"                value="0x866B"/>
+    <enum name="MAP1_VERTEX_ATTRIB12_4_NV"                value="0x866C"/>
+    <enum name="MAP1_VERTEX_ATTRIB13_4_NV"                value="0x866D"/>
+    <enum name="MAP1_VERTEX_ATTRIB14_4_NV"                value="0x866E"/>
+    <enum name="MAP1_VERTEX_ATTRIB15_4_NV"                value="0x866F"/>
+    <enum name="MAP2_VERTEX_ATTRIB0_4_NV"                 value="0x8670"/>
+    <enum name="MAP2_VERTEX_ATTRIB1_4_NV"                 value="0x8671"/>
+    <enum name="MAP2_VERTEX_ATTRIB2_4_NV"                 value="0x8672"/>
+    <enum name="MAP2_VERTEX_ATTRIB3_4_NV"                 value="0x8673"/>
+    <enum name="MAP2_VERTEX_ATTRIB4_4_NV"                 value="0x8674"/>
+    <enum name="MAP2_VERTEX_ATTRIB5_4_NV"                 value="0x8675"/>
+    <enum name="MAP2_VERTEX_ATTRIB6_4_NV"                 value="0x8676"/>
+    <enum name="MAP2_VERTEX_ATTRIB7_4_NV"                 value="0x8677"/>
+    <enum name="MAP2_VERTEX_ATTRIB8_4_NV"                 value="0x8678"/>
+    <enum name="MAP2_VERTEX_ATTRIB9_4_NV"                 value="0x8679"/>
+    <enum name="MAP2_VERTEX_ATTRIB10_4_NV"                value="0x867A"/>
+    <enum name="MAP2_VERTEX_ATTRIB11_4_NV"                value="0x867B"/>
+    <enum name="MAP2_VERTEX_ATTRIB12_4_NV"                value="0x867C"/>
+    <enum name="MAP2_VERTEX_ATTRIB13_4_NV"                value="0x867D"/>
+    <enum name="MAP2_VERTEX_ATTRIB14_4_NV"                value="0x867E"/>
+    <enum name="MAP2_VERTEX_ATTRIB15_4_NV"                value="0x867F"/>
+
     <function name="AreProgramsResidentNV" offset="578">
         <param name="n" type="GLsizei" counter="true"/>
         <param name="ids" type="const GLuint *" count="n"/>
         <param name="residences" type="GLboolean *" output="true"/>
         <return type="GLboolean"/>
-        <glx vendorpriv="1293" ignore="true"/>
+        <glx vendorpriv="1293"/>
     </function>
 
     <function name="BindProgramNV" offset="579">
         <param name="target" type="GLenum"/>
         <param name="id" type="GLuint"/>
-        <glx rop="4108" ignore="true"/>
+        <glx rop="4180"/>
     </function>
 
     <function name="DeleteProgramsNV" offset="580">
         <param name="n" type="GLsizei" counter="true"/>
         <param name="ids" type="const GLuint *" count="n"/>
-        <glx vendorpriv="1294" ignore="true"/>
+        <glx vendorpriv="1294"/>
     </function>
 
     <function name="ExecuteProgramNV" offset="581">
         <param name="target" type="GLenum"/>
         <param name="id" type="GLuint"/>
-        <param name="params" type="const GLfloat *" variable_param="target"/>
-        <glx rop="4181" ignore="true"/>
+        <param name="params" type="const GLfloat *" count="4"/>
+        <glx rop="4181"/>
     </function>
 
     <function name="GenProgramsNV" offset="582">
         <param name="n" type="GLsizei" counter="true"/>
-        <param name="ids" type="GLuint *" output="true" counter="n"/>
-        <glx vendorpriv="1295" ignore="true"/>
+        <param name="ids" type="GLuint *" output="true" count="n"/>
+        <glx vendorpriv="1295"/>
     </function>
 
+    <!-- This isn't 100% correct.  Currently, the only valid value of pname
+         is GL_PROGRAM_PARAMETER_NV, and the count for that pname is always
+         4.  This is why the pname parameter was removed in the ARB version
+         of these functions.
+      -->
+
     <function name="GetProgramParameterdvNV" offset="583">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLdouble *" output="true"/>
-        <glx vendorpriv="1297" ignore="true"/>
+        <param name="params" type="GLdouble *" output="true" count="4"/>
+        <glx vendorpriv="1297"/>
     </function>
 
     <function name="GetProgramParameterfvNV" offset="584">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLfloat *" output="true"/>
-        <glx vendorpriv="1296" ignore="true"/>
+        <param name="params" type="GLfloat *" output="true" count="4"/>
+        <glx vendorpriv="1296"/>
     </function>
 
     <function name="GetProgramivNV" offset="585">
         <param name="id" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLint *" output="true"/>
-        <glx vendorpriv="1307" ignore="true"/>
+        <param name="params" type="GLint *" output="true" variable_param="pname"/>
+        <glx vendorpriv="1298"/>
     </function>
 
     <function name="GetProgramStringNV" offset="586">
         <param name="id" type="GLuint"/>
         <param name="pname" type="GLenum"/>
         <param name="program" type="GLubyte *" output="true"/>
-        <glx vendorpriv="1308" handcode="true" ignore="true"/>
+        <glx vendorpriv="1299" handcode="server" always_array="true"/>
     </function>
 
     <function name="GetTrackMatrixivNV" offset="587">
         <param name="target" type="GLenum"/>
         <param name="address" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLint *" output="true"/>
-        <glx vendorpriv="1300" ignore="true"/>
+        <param name="params" type="GLint *" output="true" count="1"/>
+        <glx vendorpriv="1300"/>
     </function>
 
     <function name="GetVertexAttribdvNV" offset="753">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLdouble *" output="true"/>
-        <glx vendorpriv="1301" ignore="true"/>
+        <param name="params" type="GLdouble *" output="true" variable_param="pname"/>
+        <glx vendorpriv="1301"/>
     </function>
 
     <function name="GetVertexAttribfvNV" offset="754">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
-        <param name="params" type="GLfloat *" output="true"/>
-        <glx vendorpriv="1302" ignore="true"/>
+        <param name="params" type="GLfloat *" output="true" variable_param="pname"/>
+        <glx vendorpriv="1302"/>
     </function>
 
     <function name="GetVertexAttribivNV" offset="755">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
         <param name="params" type="GLint *" output="true"/>
-        <glx vendorpriv="1303" ignore="true"/>
+        <glx vendorpriv="1303"/>
     </function>
 
     <function name="GetVertexAttribPointervNV" offset="591">
         <param name="index" type="GLuint"/>
         <param name="pname" type="GLenum"/>
         <param name="pointer" type="GLvoid **" output="true"/>
-        <glx handcode="true" ignore="true"/>
+        <glx handcode="true"/>
     </function>
 
     <function name="IsProgramNV" offset="592">
         <param name="id" type="GLuint"/>
         <return type="GLboolean"/>
-        <glx vendorpriv="1304" ignore="true"/>
+        <glx vendorpriv="1304"/>
     </function>
 
     <function name="LoadProgramNV" offset="593">
@@ -9566,7 +9744,7 @@ glx:
         <param name="id" type="GLuint"/>
         <param name="len" type="GLsizei" counter="true"/>
         <param name="program" type="const GLubyte *" count="len"/>
-        <glx rop="4183" ignore="true"/>
+        <glx rop="4183"/>
     </function>
 
     <function name="ProgramParameter4dNV" offset="594" vectorequiv="ProgramParameter4dvNV">
@@ -9576,14 +9754,13 @@ glx:
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
         <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="ProgramParameter4dvNV" offset="595">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLdouble *" count="4"/>
-        <glx rop="4185" doubles_in_order="true" ignore="true"/>
+        <glx rop="4185" doubles_in_order="true"/>
     </function>
 
     <function name="ProgramParameter4fNV" offset="596" vectorequiv="ProgramParameter4fvNV">
@@ -9593,44 +9770,35 @@ glx:
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
         <param name="w" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="ProgramParameter4fvNV" offset="597">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="params" type="const GLfloat *" count="4"/>
-        <glx rop="4184" ignore="true"/>
+        <glx rop="4184"/>
     </function>
 
     <function name="ProgramParameters4dvNV" offset="598">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="num" type="GLuint"/>
-        <param name="params" type="const GLdouble *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'params' is 4*num.
-        -->
-        <glx rop="4187" handcode="true" ignore="true"/>
+        <param name="params" type="const GLdouble *" count="num" count_scale="4"/>
+        <glx rop="4187"/>
     </function>
 
     <function name="ProgramParameters4fvNV" offset="599">
         <param name="target" type="GLenum"/>
         <param name="index" type="GLuint"/>
         <param name="num" type="GLuint" counter="true"/>
-        <param name="params" type="const GLfloat *" count="num"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'params' is 4*num.
-        -->
-        <glx rop="4186" handcode="true" ignore="true"/>
+        <param name="params" type="const GLfloat *" count="num" count_scale="4"/>
+        <glx rop="4186"/>
     </function>
 
     <function name="RequestResidentProgramsNV" offset="600">
-        <param name="n" type="GLsizei"/>
-        <param name="ids" type="const GLuint *"/>
-        <glx rop="4182" handcode="true" ignore="true"/>
+        <param name="n" type="GLsizei" counter="true"/>
+        <param name="ids" type="const GLuint *" count="n"/>
+        <glx rop="4182"/>
     </function>
 
     <function name="TrackMatrixNV" offset="601">
@@ -9638,7 +9806,7 @@ glx:
         <param name="address" type="GLuint"/>
         <param name="matrix" type="GLenum"/>
         <param name="transform" type="GLenum"/>
-        <glx rop="4188" ignore="true"/>
+        <glx rop="4188"/>
     </function>
 
     <function name="VertexAttribPointerNV" offset="602">
@@ -9647,169 +9815,157 @@ glx:
         <param name="type" type="GLenum"/>
         <param name="stride" type="GLsizei"/>
         <param name="pointer" type="const GLvoid *"/>
-        <glx handcode="true" ignore="true"/>
+        <glx handcode="true"/>
     </function>
 
-    <function name="VertexAttrib1dNV" offset="756" vectorequiv="VertexAttrib1dvNV">
+    <function name="VertexAttrib1sNV" offset="760" vectorequiv="VertexAttrib1svNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLdouble"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLshort"/>
     </function>
 
-    <function name="VertexAttrib1dvNV" offset="757">
+    <function name="VertexAttrib1svNV" offset="761">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLdouble *" count="1"/>
-        <glx rop="4197" doubles_in_order="true" ignore="true"/>
+        <param name="v" type="const GLshort *" count="1"/>
+        <glx rop="4189"/>
     </function>
 
-    <function name="VertexAttrib1fNV" offset="758" vectorequiv="VertexAttrib1fvNV">
+    <function name="VertexAttrib2sNV" offset="766" vectorequiv="VertexAttrib2svNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLfloat"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLshort"/>
+        <param name="y" type="GLshort"/>
     </function>
 
-    <function name="VertexAttrib1fvNV" offset="759">
+    <function name="VertexAttrib2svNV" offset="767">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLfloat *" count="1"/>
-        <glx rop="4193" ignore="true"/>
+        <param name="v" type="const GLshort *" count="2"/>
+        <glx rop="4190"/>
     </function>
 
-    <function name="VertexAttrib1sNV" offset="760" vectorequiv="VertexAttrib1svNV">
+    <function name="VertexAttrib3sNV" offset="772" vectorequiv="VertexAttrib3svNV">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLshort"/>
-        <glx ignore="true"/>
+        <param name="y" type="GLshort"/>
+        <param name="z" type="GLshort"/>
     </function>
 
-    <function name="VertexAttrib1svNV" offset="761">
+    <function name="VertexAttrib3svNV" offset="773">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLshort *" count="1"/>
-        <glx rop="4189" ignore="true"/>
+        <param name="v" type="const GLshort *" count="3"/>
+        <glx rop="4191"/>
     </function>
 
-    <function name="VertexAttrib2dNV" offset="762" vectorequiv="VertexAttrib2dvNV">
+    <function name="VertexAttrib4sNV" offset="778" vectorequiv="VertexAttrib4svNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLdouble"/>
-        <param name="y" type="GLdouble"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLshort"/>
+        <param name="y" type="GLshort"/>
+        <param name="z" type="GLshort"/>
+        <param name="w" type="GLshort"/>
     </function>
 
-    <function name="VertexAttrib2dvNV" offset="763">
+    <function name="VertexAttrib4svNV" offset="779">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLdouble *" count="2"/>
-        <glx rop="4198" doubles_in_order="true" ignore="true"/>
+        <param name="v" type="const GLshort *" count="4"/>
+        <glx rop="4192"/>
     </function>
 
-    <function name="VertexAttrib2fNV" offset="764" vectorequiv="VertexAttrib2fvNV">
+    <function name="VertexAttrib1fNV" offset="758" vectorequiv="VertexAttrib1fvNV">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLfloat"/>
-        <param name="y" type="GLfloat"/>
-        <glx ignore="true"/>
     </function>
 
-    <function name="VertexAttrib2fvNV" offset="765">
+    <function name="VertexAttrib1fvNV" offset="759">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLfloat *" count="2"/>
-        <glx rop="4194" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="1"/>
+        <glx rop="4193"/>
     </function>
 
-    <function name="VertexAttrib2sNV" offset="766" vectorequiv="VertexAttrib2svNV">
+    <function name="VertexAttrib2fNV" offset="764" vectorequiv="VertexAttrib2fvNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLshort"/>
-        <param name="y" type="GLshort"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLfloat"/>
+        <param name="y" type="GLfloat"/>
     </function>
 
-    <function name="VertexAttrib2svNV" offset="767">
+    <function name="VertexAttrib2fvNV" offset="765">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLshort *" count="2"/>
-        <glx rop="4190" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="2"/>
+        <glx rop="4194"/>
     </function>
 
-    <function name="VertexAttrib3dNV" offset="768" vectorequiv="VertexAttrib3dvNV">
+    <function name="VertexAttrib3fNV" offset="770" vectorequiv="VertexAttrib3fvNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLdouble"/>
-        <param name="y" type="GLdouble"/>
-        <param name="z" type="GLdouble"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLfloat"/>
+        <param name="y" type="GLfloat"/>
+        <param name="z" type="GLfloat"/>
     </function>
 
-    <function name="VertexAttrib3dvNV" offset="769">
+    <function name="VertexAttrib3fvNV" offset="771">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLdouble *" count="3"/>
-        <glx rop="4199" doubles_in_order="true" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="3"/>
+        <glx rop="4195"/>
     </function>
 
-    <function name="VertexAttrib3fNV" offset="770" vectorequiv="VertexAttrib3fvNV">
+    <function name="VertexAttrib4fNV" offset="776" vectorequiv="VertexAttrib4fvNV">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLfloat"/>
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
-        <glx ignore="true"/>
+        <param name="w" type="GLfloat"/>
     </function>
 
-    <function name="VertexAttrib3fvNV" offset="771">
+    <function name="VertexAttrib4fvNV" offset="777">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLfloat *" count="3"/>
-        <glx rop="4195" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="4"/>
+        <glx rop="4196"/>
     </function>
 
-    <function name="VertexAttrib3sNV" offset="772" vectorequiv="VertexAttrib3svNV">
+    <function name="VertexAttrib1dNV" offset="756" vectorequiv="VertexAttrib1dvNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLshort"/>
-        <param name="y" type="GLshort"/>
-        <param name="z" type="GLshort"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLdouble"/>
     </function>
 
-    <function name="VertexAttrib3svNV" offset="773">
+    <function name="VertexAttrib1dvNV" offset="757">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLshort *" count="3"/>
-        <glx rop="4191" ignore="true"/>
+        <param name="v" type="const GLdouble *" count="1"/>
+        <glx rop="4197" doubles_in_order="true"/>
     </function>
 
-    <function name="VertexAttrib4dNV" offset="774" vectorequiv="VertexAttrib4dvNV">
+    <function name="VertexAttrib2dNV" offset="762" vectorequiv="VertexAttrib2dvNV">
         <param name="index" type="GLuint"/>
         <param name="x" type="GLdouble"/>
         <param name="y" type="GLdouble"/>
-        <param name="z" type="GLdouble"/>
-        <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
-    <function name="VertexAttrib4dvNV" offset="775">
+    <function name="VertexAttrib2dvNV" offset="763">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLdouble *" count="4"/>
-        <glx rop="4200" doubles_in_order="true" ignore="true"/>
+        <param name="v" type="const GLdouble *" count="2"/>
+        <glx rop="4198" doubles_in_order="true"/>
     </function>
 
-    <function name="VertexAttrib4fNV" offset="776" vectorequiv="VertexAttrib4fvNV">
+    <function name="VertexAttrib3dNV" offset="768" vectorequiv="VertexAttrib3dvNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLfloat"/>
-        <param name="y" type="GLfloat"/>
-        <param name="z" type="GLfloat"/>
-        <param name="w" type="GLfloat"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLdouble"/>
+        <param name="y" type="GLdouble"/>
+        <param name="z" type="GLdouble"/>
     </function>
 
-    <function name="VertexAttrib4fvNV" offset="777">
+    <function name="VertexAttrib3dvNV" offset="769">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLfloat *" count="4"/>
-        <glx rop="4196" ignore="true"/>
+        <param name="v" type="const GLdouble *" count="3"/>
+        <glx rop="4199" doubles_in_order="true"/>
     </function>
 
-    <function name="VertexAttrib4sNV" offset="778" vectorequiv="VertexAttrib4svNV">
+    <function name="VertexAttrib4dNV" offset="774" vectorequiv="VertexAttrib4dvNV">
         <param name="index" type="GLuint"/>
-        <param name="x" type="GLshort"/>
-        <param name="y" type="GLshort"/>
-        <param name="z" type="GLshort"/>
-        <param name="w" type="GLshort"/>
-        <glx ignore="true"/>
+        <param name="x" type="GLdouble"/>
+        <param name="y" type="GLdouble"/>
+        <param name="z" type="GLdouble"/>
+        <param name="w" type="GLdouble"/>
     </function>
 
-    <function name="VertexAttrib4svNV" offset="779">
+    <function name="VertexAttrib4dvNV" offset="775">
         <param name="index" type="GLuint"/>
-        <param name="v" type="const GLshort *" count="4"/>
-        <glx rop="4192" ignore="true"/>
+        <param name="v" type="const GLdouble *" count="4"/>
+        <glx rop="4200" doubles_in_order="true"/>
     </function>
 
     <function name="VertexAttrib4ubNV" offset="780" vectorequiv="VertexAttrib4ubvNV">
@@ -9818,144 +9974,103 @@ glx:
         <param name="y" type="GLubyte"/>
         <param name="z" type="GLubyte"/>
         <param name="w" type="GLubyte"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="VertexAttrib4ubvNV" offset="781">
         <param name="index" type="GLuint"/>
         <param name="v" type="const GLubyte *" count="4"/>
-        <glx rop="4201" ignore="true"/>
-    </function>
-
-    <function name="VertexAttribs1dvNV" offset="629">
-        <param name="index" type="GLuint"/>
-        <param name="n" type="GLsizei" counter="true"/>
-        <param name="v" type="const GLdouble *" count="n"/>
-        <glx rop="4210" doubles_in_order="true" ignore="true"/>
-    </function>
-
-    <function name="VertexAttribs1fvNV" offset="630">
-        <param name="index" type="GLuint"/>
-        <param name="n" type="GLsizei" counter="true"/>
-        <param name="v" type="const GLfloat *" count="n"/>
-        <glx rop="4206" ignore="true"/>
+        <glx rop="4201"/>
     </function>
 
     <function name="VertexAttribs1svNV" offset="631">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei" counter="true"/>
         <param name="v" type="const GLshort *" count="n"/>
-        <glx rop="4202" ignore="true"/>
+        <glx rop="4202"/>
     </function>
 
-    <function name="VertexAttribs2dvNV" offset="632">
+    <function name="VertexAttribs2svNV" offset="634">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLdouble *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 2*n.
-        -->
-        <glx rop="4211" handcode="true" ignore="true"/>
+        <param name="v" type="const GLshort *" count="n" count_scale="2"/>
+        <glx rop="4203"/>
     </function>
 
-    <function name="VertexAttribs2fvNV" offset="633">
+    <function name="VertexAttribs3svNV" offset="637">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLfloat *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 2*n.
-        -->
-        <glx rop="4207" handcode="true" ignore="true"/>
+        <param name="v" type="const GLshort *" count="n" count_scale="3"/>
+        <glx rop="4204"/>
     </function>
 
-    <function name="VertexAttribs2svNV" offset="634">
+    <function name="VertexAttribs4svNV" offset="640">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLshort *"/>
-        <glx rop="4203" handcode="true" ignore="true"/>
+        <param name="v" type="const GLshort *" count="n" count_scale="4"/>
+        <glx rop="4205"/>
+    </function>
 
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 2*n.
-        -->
+    <function name="VertexAttribs1fvNV" offset="630">
+        <param name="index" type="GLuint"/>
+        <param name="n" type="GLsizei" counter="true"/>
+        <param name="v" type="const GLfloat *" count="n"/>
+        <glx rop="4206"/>
     </function>
 
-    <function name="VertexAttribs3dvNV" offset="635">
+    <function name="VertexAttribs2fvNV" offset="633">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLdouble *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 3*n.
-        -->
-        <glx rop="4212" handcode="true" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="n" count_scale="2"/>
+        <glx rop="4207"/>
     </function>
 
     <function name="VertexAttribs3fvNV" offset="636">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLfloat *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 3*n.
-        -->
-        <glx rop="4208" handcode="true" ignore="true"/>
+        <param name="v" type="const GLfloat *" count="n" count_scale="3"/>
+        <glx rop="4208"/>
     </function>
 
-    <function name="VertexAttribs3svNV" offset="637">
+    <function name="VertexAttribs4fvNV" offset="639">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLshort *"/>
+        <param name="v" type="const GLfloat *" count="n" count_scale="4"/>
+        <glx rop="4209"/>
+    </function>
 
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 3*n.
-        -->
-        <glx rop="4204" handcode="true" ignore="true"/>
+    <function name="VertexAttribs1dvNV" offset="629">
+        <param name="index" type="GLuint"/>
+        <param name="n" type="GLsizei" counter="true"/>
+        <param name="v" type="const GLdouble *" count="n"/>
+        <glx rop="4210" doubles_in_order="true"/>
     </function>
 
-    <function name="VertexAttribs4dvNV" offset="638">
+    <function name="VertexAttribs2dvNV" offset="632">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLdouble *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 4*n.
-        -->
-        <glx rop="4213" handcode="true" ignore="true"/>
+        <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="2"/>
+        <glx rop="4211"/>
     </function>
 
-    <function name="VertexAttribs4fvNV" offset="639">
+    <function name="VertexAttribs3dvNV" offset="635">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLfloat *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 4*n.
-        -->
-        <glx rop="4209" handcode="true" ignore="true"/>
+        <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="3"/>
+        <glx rop="4212"/>
     </function>
 
-    <function name="VertexAttribs4svNV" offset="640">
+    <function name="VertexAttribs4dvNV" offset="638">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLshort *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 4*n.
-        -->
-        <glx rop="4205" handcode="true" ignore="true"/>
+        <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="4"/>
+        <glx rop="4213"/>
     </function>
 
     <function name="VertexAttribs4ubvNV" offset="641">
         <param name="index" type="GLuint"/>
         <param name="n" type="GLsizei"/>
-        <param name="v" type="const GLubyte *"/>
-
-        <!-- This is hand coded because the number of array elements
-             pointed to by 'v' is 4*n.
-        -->
-        <glx rop="4214" handcode="true" ignore="true"/>
+        <param name="v" type="const GLubyte *" count="n" count_scale="4"/>
+        <glx rop="4214"/>
     </function>
 </category>
 
@@ -10240,56 +10355,54 @@ glx:
 <category name="GL_NV_fragment_program" number="282">
     <function name="ProgramNamedParameter4fNV" offset="682" vectorequiv="ProgramNamedParameter4fvNV">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
         <param name="x" type="GLfloat"/>
         <param name="y" type="GLfloat"/>
         <param name="z" type="GLfloat"/>
         <param name="w" type="GLfloat"/>
-        <glx rop="4218" handcode="true" ignore="true"/>
     </function>
 
     <function name="ProgramNamedParameter4dNV" offset="683" vectorequiv="ProgramNamedParameter4dvNV">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *" variable_param="len"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
         <param name="x" type="GLdouble"/>
         <param name="y" type="GLdouble"/>
         <param name="z" type="GLdouble"/>
         <param name="w" type="GLdouble"/>
-        <glx ignore="true"/>
     </function>
 
     <function name="ProgramNamedParameter4fvNV" offset="684">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *"/>
-        <param name="v" type="const GLfloat *"/>
-        <glx rop="4218" handcode="true" ignore="true"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
+        <param name="v" type="const GLfloat *" count="4"/>
+        <glx rop="4218"/>
     </function>
 
     <function name="ProgramNamedParameter4dvNV" offset="685">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *"/>
-        <param name="v" type="const GLdouble *"/>
-        <glx rop="4219" handcode="true" ignore="true"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
+        <param name="v" type="const GLdouble *" count="4"/>
+        <glx rop="4219"/>
     </function>
 
     <function name="GetProgramNamedParameterfvNV" offset="686">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *"/>
-        <param name="params" type="GLfloat *" output="true"/>
-        <glx vendorpriv="1310" handcode="true" ignore="true"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
+        <param name="params" type="GLfloat *" output="true" count="4"/>
+        <glx vendorpriv="1310" always_array="true"/>
     </function>
 
     <function name="GetProgramNamedParameterdvNV" offset="687">
         <param name="id" type="GLuint"/>
-        <param name="len" type="GLsizei"/>
-        <param name="name" type="const GLubyte *"/>
-        <param name="params" type="GLdouble *" output="true"/>
-        <glx vendorpriv="1311" handcode="true" ignore="true"/>
+        <param name="len" type="GLsizei" counter="true"/>
+        <param name="name" type="const GLubyte *" count="len"/>
+        <param name="params" type="GLdouble *" output="true" count="4"/>
+        <glx vendorpriv="1311" always_array="true"/>
     </function>
 </category>
 
@@ -10359,6 +10472,41 @@ glx:
     <enum name="PIXEL_UNPACK_BUFFER_BINDING_EXT"          value="0x88EF"/>
 </category>
 
+<category name="GL_NV_fragment_program_option" number="303">
+    <!-- No new functions, types, enums. -->
+</category>
+
+<category name="GL_NV_fragment_program2" number="304">
+    <enum name="MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" count="1" value="0x88F4">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_CALL_DEPTH_NV"      count="1"  value="0x88F5">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_IF_DEPTH_NV"        count="1"  value="0x88F6">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_LOOP_DEPTH_NV"      count="1"  value="0x88F7">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_LOOP_COUNT_NV"      count="1"  value="0x88F8">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+</category>
+
+<category name="GL_NV_vertex_program2_option" number="305">
+    <enum name="MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" count="1" value="0x88F4">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+    <enum name="MAX_PROGRAM_CALL_DEPTH_NV"      count="1"  value="0x88F5">
+        <size name="GetProgramivARB" mode="get"/>
+    </enum>
+</category>
+
+<category name="GL_NV_vertex_program3" number="306">
+    <enum name="MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" count="1" value="0x8B4C"/>
+</category>
+
 <category name="GL_EXT_framebuffer_object" number="310">
     <enum name="FRAMEBUFFER_EXT" value="0x8D40"/>
     <enum name="RENDERBUFFER_EXT" value="0x8D41"/>