Home | History | Annotate | Download | only in main
      1 /*
      2  * Mesa 3-D graphics library
      3  * Version:  7.7
      4  *
      5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
      6  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
      7  *
      8  * Permission is hereby granted, free of charge, to any person obtaining a
      9  * copy of this software and associated documentation files (the "Software"),
     10  * to deal in the Software without restriction, including without limitation
     11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     12  * and/or sell copies of the Software, and to permit persons to whom the
     13  * Software is furnished to do so, subject to the following conditions:
     14  *
     15  * The above copyright notice and this permission notice shall be included
     16  * in all copies or substantial portions of the Software.
     17  *
     18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
     22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
     23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     24  */
     25 
     26 
     27 /**
     28  * \file dlist.c
     29  * Display lists management functions.
     30  */
     31 
     32 #include "glheader.h"
     33 #include "imports.h"
     34 #include "api_arrayelt.h"
     35 #include "api_exec.h"
     36 #include "api_loopback.h"
     37 #include "api_validate.h"
     38 #if FEATURE_ATI_fragment_shader
     39 #include "atifragshader.h"
     40 #endif
     41 #include "config.h"
     42 #include "mfeatures.h"
     43 #include "bufferobj.h"
     44 #include "arrayobj.h"
     45 #include "context.h"
     46 #include "dlist.h"
     47 #include "enums.h"
     48 #include "eval.h"
     49 #if FEATURE_EXT_framebuffer_object
     50 #include "fbobject.h"
     51 #endif
     52 #include "framebuffer.h"
     53 #include "glapi/glapi.h"
     54 #include "glformats.h"
     55 #include "hash.h"
     56 #include "image.h"
     57 #include "light.h"
     58 #include "macros.h"
     59 #include "pack.h"
     60 #include "pbo.h"
     61 #include "queryobj.h"
     62 #include "samplerobj.h"
     63 #include "shaderapi.h"
     64 #include "syncobj.h"
     65 #include "teximage.h"
     66 #include "texstorage.h"
     67 #include "mtypes.h"
     68 #include "varray.h"
     69 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
     70 #include "arbprogram.h"
     71 #endif
     72 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
     73 #include "nvprogram.h"
     74 #endif
     75 #if FEATURE_EXT_transform_feedback
     76 #include "transformfeedback.h"
     77 #endif
     78 
     79 #include "math/m_matrix.h"
     80 
     81 #include "main/dispatch.h"
     82 
     83 
     84 
     85 /**
     86  * Other parts of Mesa (such as the VBO module) can plug into the display
     87  * list system.  This structure describes new display list instructions.
     88  */
     89 struct gl_list_instruction
     90 {
     91    GLuint Size;
     92    void (*Execute)( struct gl_context *ctx, void *data );
     93    void (*Destroy)( struct gl_context *ctx, void *data );
     94    void (*Print)( struct gl_context *ctx, void *data );
     95 };
     96 
     97 
     98 #define MAX_DLIST_EXT_OPCODES 16
     99 
    100 /**
    101  * Used by device drivers to hook new commands into display lists.
    102  */
    103 struct gl_list_extensions
    104 {
    105    struct gl_list_instruction Opcode[MAX_DLIST_EXT_OPCODES];
    106    GLuint NumOpcodes;
    107 };
    108 
    109 
    110 
    111 /**
    112  * Flush vertices.
    113  *
    114  * \param ctx GL context.
    115  *
    116  * Checks if dd_function_table::SaveNeedFlush is marked to flush
    117  * stored (save) vertices, and calls
    118  * dd_function_table::SaveFlushVertices if so.
    119  */
    120 #define SAVE_FLUSH_VERTICES(ctx)		\
    121 do {						\
    122    if (ctx->Driver.SaveNeedFlush)		\
    123       ctx->Driver.SaveFlushVertices(ctx);	\
    124 } while (0)
    125 
    126 
    127 /**
    128  * Macro to assert that the API call was made outside the
    129  * glBegin()/glEnd() pair, with return value.
    130  *
    131  * \param ctx GL context.
    132  * \param retval value to return value in case the assertion fails.
    133  */
    134 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
    135 do {									\
    136    if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
    137        ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
    138       _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" );	\
    139       return retval;							\
    140    }									\
    141 } while (0)
    142 
    143 /**
    144  * Macro to assert that the API call was made outside the
    145  * glBegin()/glEnd() pair.
    146  *
    147  * \param ctx GL context.
    148  */
    149 #define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx)				\
    150 do {									\
    151    if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
    152        ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
    153       _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" );	\
    154       return;								\
    155    }									\
    156 } while (0)
    157 
    158 /**
    159  * Macro to assert that the API call was made outside the
    160  * glBegin()/glEnd() pair and flush the vertices.
    161  *
    162  * \param ctx GL context.
    163  */
    164 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx)			\
    165 do {									\
    166    ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);					\
    167    SAVE_FLUSH_VERTICES(ctx);						\
    168 } while (0)
    169 
    170 /**
    171  * Macro to assert that the API call was made outside the
    172  * glBegin()/glEnd() pair and flush the vertices, with return value.
    173  *
    174  * \param ctx GL context.
    175  * \param retval value to return value in case the assertion fails.
    176  */
    177 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)\
    178 do {									\
    179    ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval);		\
    180    SAVE_FLUSH_VERTICES(ctx);						\
    181 } while (0)
    182 
    183 
    184 
    185 /**
    186  * Display list opcodes.
    187  *
    188  * The fact that these identifiers are assigned consecutive
    189  * integer values starting at 0 is very important, see InstSize array usage)
    190  */
    191 typedef enum
    192 {
    193    OPCODE_INVALID = -1,         /* Force signed enum */
    194    OPCODE_ACCUM,
    195    OPCODE_ALPHA_FUNC,
    196    OPCODE_BIND_TEXTURE,
    197    OPCODE_BITMAP,
    198    OPCODE_BLEND_COLOR,
    199    OPCODE_BLEND_EQUATION,
    200    OPCODE_BLEND_EQUATION_SEPARATE,
    201    OPCODE_BLEND_FUNC_SEPARATE,
    202 
    203    OPCODE_BLEND_EQUATION_I,
    204    OPCODE_BLEND_EQUATION_SEPARATE_I,
    205    OPCODE_BLEND_FUNC_I,
    206    OPCODE_BLEND_FUNC_SEPARATE_I,
    207 
    208    OPCODE_CALL_LIST,
    209    OPCODE_CALL_LIST_OFFSET,
    210    OPCODE_CLEAR,
    211    OPCODE_CLEAR_ACCUM,
    212    OPCODE_CLEAR_COLOR,
    213    OPCODE_CLEAR_DEPTH,
    214    OPCODE_CLEAR_INDEX,
    215    OPCODE_CLEAR_STENCIL,
    216    OPCODE_CLEAR_BUFFER_IV,
    217    OPCODE_CLEAR_BUFFER_UIV,
    218    OPCODE_CLEAR_BUFFER_FV,
    219    OPCODE_CLEAR_BUFFER_FI,
    220    OPCODE_CLIP_PLANE,
    221    OPCODE_COLOR_MASK,
    222    OPCODE_COLOR_MASK_INDEXED,
    223    OPCODE_COLOR_MATERIAL,
    224    OPCODE_COLOR_TABLE,
    225    OPCODE_COLOR_TABLE_PARAMETER_FV,
    226    OPCODE_COLOR_TABLE_PARAMETER_IV,
    227    OPCODE_COLOR_SUB_TABLE,
    228    OPCODE_CONVOLUTION_FILTER_1D,
    229    OPCODE_CONVOLUTION_FILTER_2D,
    230    OPCODE_CONVOLUTION_PARAMETER_I,
    231    OPCODE_CONVOLUTION_PARAMETER_IV,
    232    OPCODE_CONVOLUTION_PARAMETER_F,
    233    OPCODE_CONVOLUTION_PARAMETER_FV,
    234    OPCODE_COPY_COLOR_SUB_TABLE,
    235    OPCODE_COPY_COLOR_TABLE,
    236    OPCODE_COPY_PIXELS,
    237    OPCODE_COPY_TEX_IMAGE1D,
    238    OPCODE_COPY_TEX_IMAGE2D,
    239    OPCODE_COPY_TEX_SUB_IMAGE1D,
    240    OPCODE_COPY_TEX_SUB_IMAGE2D,
    241    OPCODE_COPY_TEX_SUB_IMAGE3D,
    242    OPCODE_CULL_FACE,
    243    OPCODE_DEPTH_FUNC,
    244    OPCODE_DEPTH_MASK,
    245    OPCODE_DEPTH_RANGE,
    246    OPCODE_DISABLE,
    247    OPCODE_DISABLE_INDEXED,
    248    OPCODE_DRAW_BUFFER,
    249    OPCODE_DRAW_PIXELS,
    250    OPCODE_ENABLE,
    251    OPCODE_ENABLE_INDEXED,
    252    OPCODE_EVALMESH1,
    253    OPCODE_EVALMESH2,
    254    OPCODE_FOG,
    255    OPCODE_FRONT_FACE,
    256    OPCODE_FRUSTUM,
    257    OPCODE_HINT,
    258    OPCODE_HISTOGRAM,
    259    OPCODE_INDEX_MASK,
    260    OPCODE_INIT_NAMES,
    261    OPCODE_LIGHT,
    262    OPCODE_LIGHT_MODEL,
    263    OPCODE_LINE_STIPPLE,
    264    OPCODE_LINE_WIDTH,
    265    OPCODE_LIST_BASE,
    266    OPCODE_LOAD_IDENTITY,
    267    OPCODE_LOAD_MATRIX,
    268    OPCODE_LOAD_NAME,
    269    OPCODE_LOGIC_OP,
    270    OPCODE_MAP1,
    271    OPCODE_MAP2,
    272    OPCODE_MAPGRID1,
    273    OPCODE_MAPGRID2,
    274    OPCODE_MATRIX_MODE,
    275    OPCODE_MIN_MAX,
    276    OPCODE_MULT_MATRIX,
    277    OPCODE_ORTHO,
    278    OPCODE_PASSTHROUGH,
    279    OPCODE_PIXEL_MAP,
    280    OPCODE_PIXEL_TRANSFER,
    281    OPCODE_PIXEL_ZOOM,
    282    OPCODE_POINT_SIZE,
    283    OPCODE_POINT_PARAMETERS,
    284    OPCODE_POLYGON_MODE,
    285    OPCODE_POLYGON_STIPPLE,
    286    OPCODE_POLYGON_OFFSET,
    287    OPCODE_POP_ATTRIB,
    288    OPCODE_POP_MATRIX,
    289    OPCODE_POP_NAME,
    290    OPCODE_PRIORITIZE_TEXTURE,
    291    OPCODE_PUSH_ATTRIB,
    292    OPCODE_PUSH_MATRIX,
    293    OPCODE_PUSH_NAME,
    294    OPCODE_RASTER_POS,
    295    OPCODE_READ_BUFFER,
    296    OPCODE_RESET_HISTOGRAM,
    297    OPCODE_RESET_MIN_MAX,
    298    OPCODE_ROTATE,
    299    OPCODE_SCALE,
    300    OPCODE_SCISSOR,
    301    OPCODE_SELECT_TEXTURE_SGIS,
    302    OPCODE_SELECT_TEXTURE_COORD_SET,
    303    OPCODE_SHADE_MODEL,
    304    OPCODE_STENCIL_FUNC,
    305    OPCODE_STENCIL_MASK,
    306    OPCODE_STENCIL_OP,
    307    OPCODE_TEXENV,
    308    OPCODE_TEXGEN,
    309    OPCODE_TEXPARAMETER,
    310    OPCODE_TEX_IMAGE1D,
    311    OPCODE_TEX_IMAGE2D,
    312    OPCODE_TEX_IMAGE3D,
    313    OPCODE_TEX_SUB_IMAGE1D,
    314    OPCODE_TEX_SUB_IMAGE2D,
    315    OPCODE_TEX_SUB_IMAGE3D,
    316    OPCODE_TRANSLATE,
    317    OPCODE_VIEWPORT,
    318    OPCODE_WINDOW_POS,
    319    /* GL_ARB_multitexture */
    320    OPCODE_ACTIVE_TEXTURE,
    321    /* GL_ARB_texture_compression */
    322    OPCODE_COMPRESSED_TEX_IMAGE_1D,
    323    OPCODE_COMPRESSED_TEX_IMAGE_2D,
    324    OPCODE_COMPRESSED_TEX_IMAGE_3D,
    325    OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
    326    OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
    327    OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
    328    /* GL_ARB_multisample */
    329    OPCODE_SAMPLE_COVERAGE,
    330    /* GL_ARB_window_pos */
    331    OPCODE_WINDOW_POS_ARB,
    332    /* GL_NV_vertex_program */
    333    OPCODE_BIND_PROGRAM_NV,
    334    OPCODE_EXECUTE_PROGRAM_NV,
    335    OPCODE_REQUEST_RESIDENT_PROGRAMS_NV,
    336    OPCODE_LOAD_PROGRAM_NV,
    337    OPCODE_TRACK_MATRIX_NV,
    338    /* GL_NV_fragment_program */
    339    OPCODE_PROGRAM_LOCAL_PARAMETER_ARB,
    340    OPCODE_PROGRAM_NAMED_PARAMETER_NV,
    341    /* GL_EXT_stencil_two_side */
    342    OPCODE_ACTIVE_STENCIL_FACE_EXT,
    343    /* GL_EXT_depth_bounds_test */
    344    OPCODE_DEPTH_BOUNDS_EXT,
    345    /* GL_ARB_vertex/fragment_program */
    346    OPCODE_PROGRAM_STRING_ARB,
    347    OPCODE_PROGRAM_ENV_PARAMETER_ARB,
    348    /* GL_ARB_occlusion_query */
    349    OPCODE_BEGIN_QUERY_ARB,
    350    OPCODE_END_QUERY_ARB,
    351    /* GL_ARB_draw_buffers */
    352    OPCODE_DRAW_BUFFERS_ARB,
    353    /* GL_ATI_fragment_shader */
    354    OPCODE_TEX_BUMP_PARAMETER_ATI,
    355    /* GL_ATI_fragment_shader */
    356    OPCODE_BIND_FRAGMENT_SHADER_ATI,
    357    OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,
    358    /* OpenGL 2.0 */
    359    OPCODE_STENCIL_FUNC_SEPARATE,
    360    OPCODE_STENCIL_OP_SEPARATE,
    361    OPCODE_STENCIL_MASK_SEPARATE,
    362 
    363    /* GL_ARB_shader_objects */
    364    OPCODE_USE_PROGRAM,
    365    OPCODE_UNIFORM_1F,
    366    OPCODE_UNIFORM_2F,
    367    OPCODE_UNIFORM_3F,
    368    OPCODE_UNIFORM_4F,
    369    OPCODE_UNIFORM_1FV,
    370    OPCODE_UNIFORM_2FV,
    371    OPCODE_UNIFORM_3FV,
    372    OPCODE_UNIFORM_4FV,
    373    OPCODE_UNIFORM_1I,
    374    OPCODE_UNIFORM_2I,
    375    OPCODE_UNIFORM_3I,
    376    OPCODE_UNIFORM_4I,
    377    OPCODE_UNIFORM_1IV,
    378    OPCODE_UNIFORM_2IV,
    379    OPCODE_UNIFORM_3IV,
    380    OPCODE_UNIFORM_4IV,
    381    OPCODE_UNIFORM_MATRIX22,
    382    OPCODE_UNIFORM_MATRIX33,
    383    OPCODE_UNIFORM_MATRIX44,
    384    OPCODE_UNIFORM_MATRIX23,
    385    OPCODE_UNIFORM_MATRIX32,
    386    OPCODE_UNIFORM_MATRIX24,
    387    OPCODE_UNIFORM_MATRIX42,
    388    OPCODE_UNIFORM_MATRIX34,
    389    OPCODE_UNIFORM_MATRIX43,
    390 
    391    /* OpenGL 3.0 */
    392    OPCODE_UNIFORM_1UI,
    393    OPCODE_UNIFORM_2UI,
    394    OPCODE_UNIFORM_3UI,
    395    OPCODE_UNIFORM_4UI,
    396    OPCODE_UNIFORM_1UIV,
    397    OPCODE_UNIFORM_2UIV,
    398    OPCODE_UNIFORM_3UIV,
    399    OPCODE_UNIFORM_4UIV,
    400 
    401    /* GL_ARB_color_buffer_float */
    402    OPCODE_CLAMP_COLOR,
    403 
    404    /* GL_EXT_framebuffer_blit */
    405    OPCODE_BLIT_FRAMEBUFFER,
    406 
    407    /* Vertex attributes -- fallback for when optimized display
    408     * list build isn't active.
    409     */
    410    OPCODE_ATTR_1F_NV,
    411    OPCODE_ATTR_2F_NV,
    412    OPCODE_ATTR_3F_NV,
    413    OPCODE_ATTR_4F_NV,
    414    OPCODE_ATTR_1F_ARB,
    415    OPCODE_ATTR_2F_ARB,
    416    OPCODE_ATTR_3F_ARB,
    417    OPCODE_ATTR_4F_ARB,
    418    OPCODE_MATERIAL,
    419    OPCODE_BEGIN,
    420    OPCODE_END,
    421    OPCODE_RECTF,
    422    OPCODE_EVAL_C1,
    423    OPCODE_EVAL_C2,
    424    OPCODE_EVAL_P1,
    425    OPCODE_EVAL_P2,
    426 
    427    /* GL_EXT_provoking_vertex */
    428    OPCODE_PROVOKING_VERTEX,
    429 
    430    /* GL_EXT_transform_feedback */
    431    OPCODE_BEGIN_TRANSFORM_FEEDBACK,
    432    OPCODE_END_TRANSFORM_FEEDBACK,
    433    OPCODE_BIND_TRANSFORM_FEEDBACK,
    434    OPCODE_PAUSE_TRANSFORM_FEEDBACK,
    435    OPCODE_RESUME_TRANSFORM_FEEDBACK,
    436    OPCODE_DRAW_TRANSFORM_FEEDBACK,
    437 
    438    /* GL_EXT_texture_integer */
    439    OPCODE_CLEARCOLOR_I,
    440    OPCODE_CLEARCOLOR_UI,
    441    OPCODE_TEXPARAMETER_I,
    442    OPCODE_TEXPARAMETER_UI,
    443 
    444    /* GL_EXT_separate_shader_objects */
    445    OPCODE_ACTIVE_PROGRAM_EXT,
    446    OPCODE_USE_SHADER_PROGRAM_EXT,
    447 
    448    /* GL_ARB_instanced_arrays */
    449    OPCODE_VERTEX_ATTRIB_DIVISOR,
    450 
    451    /* GL_NV_texture_barrier */
    452    OPCODE_TEXTURE_BARRIER_NV,
    453 
    454    /* GL_ARB_sampler_object */
    455    OPCODE_BIND_SAMPLER,
    456    OPCODE_SAMPLER_PARAMETERIV,
    457    OPCODE_SAMPLER_PARAMETERFV,
    458    OPCODE_SAMPLER_PARAMETERIIV,
    459    OPCODE_SAMPLER_PARAMETERUIV,
    460 
    461    /* GL_ARB_geometry_shader4 */
    462    OPCODE_PROGRAM_PARAMETERI,
    463    OPCODE_FRAMEBUFFER_TEXTURE,
    464    OPCODE_FRAMEBUFFER_TEXTURE_FACE,
    465 
    466    /* GL_ARB_sync */
    467    OPCODE_WAIT_SYNC,
    468 
    469    /* GL_NV_conditional_render */
    470    OPCODE_BEGIN_CONDITIONAL_RENDER,
    471    OPCODE_END_CONDITIONAL_RENDER,
    472 
    473    /* ARB_timer_query */
    474    OPCODE_QUERY_COUNTER,
    475 
    476    /* ARB_transform_feedback3 */
    477    OPCODE_BEGIN_QUERY_INDEXED,
    478    OPCODE_END_QUERY_INDEXED,
    479    OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM,
    480 
    481    /* ARB_transform_feedback_instanced */
    482    OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED,
    483    OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED,
    484 
    485    /* ARB_uniform_buffer_object */
    486    OPCODE_UNIFORM_BLOCK_BINDING,
    487 
    488    /* The following three are meta instructions */
    489    OPCODE_ERROR,                /* raise compiled-in error */
    490    OPCODE_CONTINUE,
    491    OPCODE_END_OF_LIST,
    492    OPCODE_EXT_0
    493 } OpCode;
    494 
    495 
    496 
    497 /**
    498  * Display list node.
    499  *
    500  * Display list instructions are stored as sequences of "nodes".  Nodes
    501  * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks
    502  * are linked together with a pointer.
    503  *
    504  * Each instruction in the display list is stored as a sequence of
    505  * contiguous nodes in memory.
    506  * Each node is the union of a variety of data types.
    507  */
    508 union gl_dlist_node
    509 {
    510    OpCode opcode;
    511    GLboolean b;
    512    GLbitfield bf;
    513    GLubyte ub;
    514    GLshort s;
    515    GLushort us;
    516    GLint i;
    517    GLuint ui;
    518    GLenum e;
    519    GLfloat f;
    520    GLsizei si;
    521    GLvoid *data;
    522    void *next;                  /* If prev node's opcode==OPCODE_CONTINUE */
    523 };
    524 
    525 
    526 typedef union gl_dlist_node Node;
    527 
    528 
    529 /**
    530  * Used to store a 64-bit uint in a pair of "Nodes" for the sake of 32-bit
    531  * environment.  In 64-bit env, sizeof(Node)==8 anyway.
    532  */
    533 union uint64_pair
    534 {
    535    GLuint64 uint64;
    536    GLuint uint32[2];
    537 };
    538 
    539 
    540 /**
    541  * How many nodes to allocate at a time.
    542  *
    543  * \note Reduced now that we hold vertices etc. elsewhere.
    544  */
    545 #define BLOCK_SIZE 256
    546 
    547 
    548 
    549 /**
    550  * Number of nodes of storage needed for each instruction.
    551  * Sizes for dynamically allocated opcodes are stored in the context struct.
    552  */
    553 static GLuint InstSize[OPCODE_END_OF_LIST + 1];
    554 
    555 
    556 #if FEATURE_dlist
    557 
    558 
    559 void mesa_print_display_list(GLuint list);
    560 
    561 
    562 /**********************************************************************/
    563 /*****                           Private                          *****/
    564 /**********************************************************************/
    565 
    566 
    567 /**
    568  * Make an empty display list.  This is used by glGenLists() to
    569  * reserve display list IDs.
    570  */
    571 static struct gl_display_list *
    572 make_list(GLuint name, GLuint count)
    573 {
    574    struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);
    575    dlist->Name = name;
    576    dlist->Head = (Node *) malloc(sizeof(Node) * count);
    577    dlist->Head[0].opcode = OPCODE_END_OF_LIST;
    578    return dlist;
    579 }
    580 
    581 
    582 /**
    583  * Lookup function to just encapsulate casting.
    584  */
    585 static inline struct gl_display_list *
    586 lookup_list(struct gl_context *ctx, GLuint list)
    587 {
    588    return (struct gl_display_list *)
    589       _mesa_HashLookup(ctx->Shared->DisplayList, list);
    590 }
    591 
    592 
    593 /** Is the given opcode an extension code? */
    594 static inline GLboolean
    595 is_ext_opcode(OpCode opcode)
    596 {
    597    return (opcode >= OPCODE_EXT_0);
    598 }
    599 
    600 
    601 /** Destroy an extended opcode instruction */
    602 static GLint
    603 ext_opcode_destroy(struct gl_context *ctx, Node *node)
    604 {
    605    const GLint i = node[0].opcode - OPCODE_EXT_0;
    606    GLint step;
    607    ctx->ListExt->Opcode[i].Destroy(ctx, &node[1]);
    608    step = ctx->ListExt->Opcode[i].Size;
    609    return step;
    610 }
    611 
    612 
    613 /** Execute an extended opcode instruction */
    614 static GLint
    615 ext_opcode_execute(struct gl_context *ctx, Node *node)
    616 {
    617    const GLint i = node[0].opcode - OPCODE_EXT_0;
    618    GLint step;
    619    ctx->ListExt->Opcode[i].Execute(ctx, &node[1]);
    620    step = ctx->ListExt->Opcode[i].Size;
    621    return step;
    622 }
    623 
    624 
    625 /** Print an extended opcode instruction */
    626 static GLint
    627 ext_opcode_print(struct gl_context *ctx, Node *node)
    628 {
    629    const GLint i = node[0].opcode - OPCODE_EXT_0;
    630    GLint step;
    631    ctx->ListExt->Opcode[i].Print(ctx, &node[1]);
    632    step = ctx->ListExt->Opcode[i].Size;
    633    return step;
    634 }
    635 
    636 
    637 /**
    638  * Delete the named display list, but don't remove from hash table.
    639  * \param dlist - display list pointer
    640  */
    641 void
    642 _mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)
    643 {
    644    Node *n, *block;
    645    GLboolean done;
    646 
    647    n = block = dlist->Head;
    648 
    649    done = block ? GL_FALSE : GL_TRUE;
    650    while (!done) {
    651       const OpCode opcode = n[0].opcode;
    652 
    653       /* check for extension opcodes first */
    654       if (is_ext_opcode(opcode)) {
    655          n += ext_opcode_destroy(ctx, n);
    656       }
    657       else {
    658          switch (opcode) {
    659             /* for some commands, we need to free malloc'd memory */
    660          case OPCODE_MAP1:
    661             free(n[6].data);
    662             n += InstSize[n[0].opcode];
    663             break;
    664          case OPCODE_MAP2:
    665             free(n[10].data);
    666             n += InstSize[n[0].opcode];
    667             break;
    668          case OPCODE_DRAW_PIXELS:
    669             free(n[5].data);
    670             n += InstSize[n[0].opcode];
    671             break;
    672          case OPCODE_BITMAP:
    673             free(n[7].data);
    674             n += InstSize[n[0].opcode];
    675             break;
    676          case OPCODE_COLOR_TABLE:
    677             free(n[6].data);
    678             n += InstSize[n[0].opcode];
    679             break;
    680          case OPCODE_COLOR_SUB_TABLE:
    681             free(n[6].data);
    682             n += InstSize[n[0].opcode];
    683             break;
    684          case OPCODE_CONVOLUTION_FILTER_1D:
    685             free(n[6].data);
    686             n += InstSize[n[0].opcode];
    687             break;
    688          case OPCODE_CONVOLUTION_FILTER_2D:
    689             free(n[7].data);
    690             n += InstSize[n[0].opcode];
    691             break;
    692          case OPCODE_POLYGON_STIPPLE:
    693             free(n[1].data);
    694             n += InstSize[n[0].opcode];
    695             break;
    696          case OPCODE_TEX_IMAGE1D:
    697             free(n[8].data);
    698             n += InstSize[n[0].opcode];
    699             break;
    700          case OPCODE_TEX_IMAGE2D:
    701             free(n[9].data);
    702             n += InstSize[n[0].opcode];
    703             break;
    704          case OPCODE_TEX_IMAGE3D:
    705             free(n[10].data);
    706             n += InstSize[n[0].opcode];
    707             break;
    708          case OPCODE_TEX_SUB_IMAGE1D:
    709             free(n[7].data);
    710             n += InstSize[n[0].opcode];
    711             break;
    712          case OPCODE_TEX_SUB_IMAGE2D:
    713             free(n[9].data);
    714             n += InstSize[n[0].opcode];
    715             break;
    716          case OPCODE_TEX_SUB_IMAGE3D:
    717             free(n[11].data);
    718             n += InstSize[n[0].opcode];
    719             break;
    720          case OPCODE_COMPRESSED_TEX_IMAGE_1D:
    721             free(n[7].data);
    722             n += InstSize[n[0].opcode];
    723             break;
    724          case OPCODE_COMPRESSED_TEX_IMAGE_2D:
    725             free(n[8].data);
    726             n += InstSize[n[0].opcode];
    727             break;
    728          case OPCODE_COMPRESSED_TEX_IMAGE_3D:
    729             free(n[9].data);
    730             n += InstSize[n[0].opcode];
    731             break;
    732          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
    733             free(n[7].data);
    734             n += InstSize[n[0].opcode];
    735             break;
    736          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
    737             free(n[9].data);
    738             n += InstSize[n[0].opcode];
    739             break;
    740          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
    741             free(n[11].data);
    742             n += InstSize[n[0].opcode];
    743             break;
    744 #if FEATURE_NV_vertex_program
    745          case OPCODE_LOAD_PROGRAM_NV:
    746             free(n[4].data);      /* program string */
    747             n += InstSize[n[0].opcode];
    748             break;
    749          case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
    750             free(n[2].data);      /* array of program ids */
    751             n += InstSize[n[0].opcode];
    752             break;
    753 #endif
    754 #if FEATURE_NV_fragment_program
    755          case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
    756             free(n[3].data);      /* parameter name */
    757             n += InstSize[n[0].opcode];
    758             break;
    759 #endif
    760 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
    761          case OPCODE_PROGRAM_STRING_ARB:
    762             free(n[4].data);      /* program string */
    763             n += InstSize[n[0].opcode];
    764             break;
    765 #endif
    766          case OPCODE_UNIFORM_1FV:
    767          case OPCODE_UNIFORM_2FV:
    768          case OPCODE_UNIFORM_3FV:
    769          case OPCODE_UNIFORM_4FV:
    770          case OPCODE_UNIFORM_1IV:
    771          case OPCODE_UNIFORM_2IV:
    772          case OPCODE_UNIFORM_3IV:
    773          case OPCODE_UNIFORM_4IV:
    774          case OPCODE_UNIFORM_1UIV:
    775          case OPCODE_UNIFORM_2UIV:
    776          case OPCODE_UNIFORM_3UIV:
    777          case OPCODE_UNIFORM_4UIV:
    778             free(n[3].data);
    779             n += InstSize[n[0].opcode];
    780             break;
    781          case OPCODE_UNIFORM_MATRIX22:
    782          case OPCODE_UNIFORM_MATRIX33:
    783          case OPCODE_UNIFORM_MATRIX44:
    784          case OPCODE_UNIFORM_MATRIX24:
    785          case OPCODE_UNIFORM_MATRIX42:
    786          case OPCODE_UNIFORM_MATRIX23:
    787          case OPCODE_UNIFORM_MATRIX32:
    788          case OPCODE_UNIFORM_MATRIX34:
    789          case OPCODE_UNIFORM_MATRIX43:
    790             free(n[4].data);
    791             n += InstSize[n[0].opcode];
    792             break;
    793 
    794          case OPCODE_CONTINUE:
    795             n = (Node *) n[1].next;
    796             free(block);
    797             block = n;
    798             break;
    799          case OPCODE_END_OF_LIST:
    800             free(block);
    801             done = GL_TRUE;
    802             break;
    803          default:
    804             /* Most frequent case */
    805             n += InstSize[n[0].opcode];
    806             break;
    807          }
    808       }
    809    }
    810 
    811    free(dlist);
    812 }
    813 
    814 
    815 /**
    816  * Destroy a display list and remove from hash table.
    817  * \param list - display list number
    818  */
    819 static void
    820 destroy_list(struct gl_context *ctx, GLuint list)
    821 {
    822    struct gl_display_list *dlist;
    823 
    824    if (list == 0)
    825       return;
    826 
    827    dlist = lookup_list(ctx, list);
    828    if (!dlist)
    829       return;
    830 
    831    _mesa_delete_list(ctx, dlist);
    832    _mesa_HashRemove(ctx->Shared->DisplayList, list);
    833 }
    834 
    835 
    836 /*
    837  * Translate the nth element of list from <type> to GLint.
    838  */
    839 static GLint
    840 translate_id(GLsizei n, GLenum type, const GLvoid * list)
    841 {
    842    GLbyte *bptr;
    843    GLubyte *ubptr;
    844    GLshort *sptr;
    845    GLushort *usptr;
    846    GLint *iptr;
    847    GLuint *uiptr;
    848    GLfloat *fptr;
    849 
    850    switch (type) {
    851    case GL_BYTE:
    852       bptr = (GLbyte *) list;
    853       return (GLint) bptr[n];
    854    case GL_UNSIGNED_BYTE:
    855       ubptr = (GLubyte *) list;
    856       return (GLint) ubptr[n];
    857    case GL_SHORT:
    858       sptr = (GLshort *) list;
    859       return (GLint) sptr[n];
    860    case GL_UNSIGNED_SHORT:
    861       usptr = (GLushort *) list;
    862       return (GLint) usptr[n];
    863    case GL_INT:
    864       iptr = (GLint *) list;
    865       return iptr[n];
    866    case GL_UNSIGNED_INT:
    867       uiptr = (GLuint *) list;
    868       return (GLint) uiptr[n];
    869    case GL_FLOAT:
    870       fptr = (GLfloat *) list;
    871       return (GLint) FLOORF(fptr[n]);
    872    case GL_2_BYTES:
    873       ubptr = ((GLubyte *) list) + 2 * n;
    874       return (GLint) ubptr[0] * 256
    875            + (GLint) ubptr[1];
    876    case GL_3_BYTES:
    877       ubptr = ((GLubyte *) list) + 3 * n;
    878       return (GLint) ubptr[0] * 65536
    879            + (GLint) ubptr[1] * 256
    880            + (GLint) ubptr[2];
    881    case GL_4_BYTES:
    882       ubptr = ((GLubyte *) list) + 4 * n;
    883       return (GLint) ubptr[0] * 16777216
    884            + (GLint) ubptr[1] * 65536
    885            + (GLint) ubptr[2] * 256
    886            + (GLint) ubptr[3];
    887    default:
    888       return 0;
    889    }
    890 }
    891 
    892 
    893 
    894 
    895 /**********************************************************************/
    896 /*****                        Public                              *****/
    897 /**********************************************************************/
    898 
    899 /**
    900  * Wrapper for _mesa_unpack_image/bitmap() that handles pixel buffer objects.
    901  * If width < 0 or height < 0 or format or type are invalid we'll just
    902  * return NULL.  We will not generate an error since OpenGL command
    903  * arguments aren't error-checked until the command is actually executed
    904  * (not when they're compiled).
    905  * But if we run out of memory, GL_OUT_OF_MEMORY will be recorded.
    906  */
    907 static GLvoid *
    908 unpack_image(struct gl_context *ctx, GLuint dimensions,
    909              GLsizei width, GLsizei height, GLsizei depth,
    910              GLenum format, GLenum type, const GLvoid * pixels,
    911              const struct gl_pixelstore_attrib *unpack)
    912 {
    913    if (width <= 0 || height <= 0) {
    914       return NULL;
    915    }
    916 
    917    if (_mesa_bytes_per_pixel(format, type) < 0) {
    918       /* bad format and/or type */
    919       return NULL;
    920    }
    921 
    922    if (!_mesa_is_bufferobj(unpack->BufferObj)) {
    923       /* no PBO */
    924       GLvoid *image;
    925 
    926       if (type == GL_BITMAP)
    927          image = _mesa_unpack_bitmap(width, height, pixels, unpack);
    928       else
    929          image = _mesa_unpack_image(dimensions, width, height, depth,
    930                                     format, type, pixels, unpack);
    931       if (pixels && !image) {
    932          _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
    933       }
    934       return image;
    935    }
    936    else if (_mesa_validate_pbo_access(dimensions, unpack, width, height,
    937                                       depth, format, type, INT_MAX, pixels)) {
    938       const GLubyte *map, *src;
    939       GLvoid *image;
    940 
    941       map = (GLubyte *)
    942          ctx->Driver.MapBufferRange(ctx, 0, unpack->BufferObj->Size,
    943 				    GL_MAP_READ_BIT, unpack->BufferObj);
    944       if (!map) {
    945          /* unable to map src buffer! */
    946          _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");
    947          return NULL;
    948       }
    949 
    950       src = ADD_POINTERS(map, pixels);
    951       if (type == GL_BITMAP)
    952          image = _mesa_unpack_bitmap(width, height, src, unpack);
    953       else
    954          image = _mesa_unpack_image(dimensions, width, height, depth,
    955                                     format, type, src, unpack);
    956 
    957       ctx->Driver.UnmapBuffer(ctx, unpack->BufferObj);
    958 
    959       if (!image) {
    960          _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
    961       }
    962       return image;
    963    }
    964 
    965    /* bad access! */
    966    _mesa_error(ctx, GL_INVALID_OPERATION, "invalid PBO access");
    967    return NULL;
    968 }
    969 
    970 /**
    971  * Allocate space for a display list instruction (opcode + payload space).
    972  * \param opcode  the instruction opcode (OPCODE_* value)
    973  * \param bytes   instruction payload size (not counting opcode)
    974  * \return pointer to allocated memory (the opcode space)
    975  */
    976 static Node *
    977 dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes)
    978 {
    979    const GLuint numNodes = 1 + (bytes + sizeof(Node) - 1) / sizeof(Node);
    980    Node *n;
    981 
    982    if (opcode < (GLuint) OPCODE_EXT_0) {
    983       if (InstSize[opcode] == 0) {
    984          /* save instruction size now */
    985          InstSize[opcode] = numNodes;
    986       }
    987       else {
    988          /* make sure instruction size agrees */
    989          ASSERT(numNodes == InstSize[opcode]);
    990       }
    991    }
    992 
    993    if (ctx->ListState.CurrentPos + numNodes + 2 > BLOCK_SIZE) {
    994       /* This block is full.  Allocate a new block and chain to it */
    995       Node *newblock;
    996       n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
    997       n[0].opcode = OPCODE_CONTINUE;
    998       newblock = (Node *) malloc(sizeof(Node) * BLOCK_SIZE);
    999       if (!newblock) {
   1000          _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
   1001          return NULL;
   1002       }
   1003       n[1].next = (Node *) newblock;
   1004       ctx->ListState.CurrentBlock = newblock;
   1005       ctx->ListState.CurrentPos = 0;
   1006    }
   1007 
   1008    n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
   1009    ctx->ListState.CurrentPos += numNodes;
   1010 
   1011    n[0].opcode = opcode;
   1012 
   1013    return n;
   1014 }
   1015 
   1016 
   1017 
   1018 /**
   1019  * Allocate space for a display list instruction.  Used by callers outside
   1020  * this file for things like VBO vertex data.
   1021  *
   1022  * \param opcode  the instruction opcode (OPCODE_* value)
   1023  * \param bytes   instruction size in bytes, not counting opcode.
   1024  * \return pointer to the usable data area (not including the internal
   1025  *         opcode).
   1026  */
   1027 void *
   1028 _mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint bytes)
   1029 {
   1030    Node *n = dlist_alloc(ctx, (OpCode) opcode, bytes);
   1031    if (n)
   1032       return n + 1;  /* return pointer to payload area, after opcode */
   1033    else
   1034       return NULL;
   1035 }
   1036 
   1037 
   1038 /**
   1039  * This function allows modules and drivers to get their own opcodes
   1040  * for extending display list functionality.
   1041  * \param ctx  the rendering context
   1042  * \param size  number of bytes for storing the new display list command
   1043  * \param execute  function to execute the new display list command
   1044  * \param destroy  function to destroy the new display list command
   1045  * \param print  function to print the new display list command
   1046  * \return  the new opcode number or -1 if error
   1047  */
   1048 GLint
   1049 _mesa_dlist_alloc_opcode(struct gl_context *ctx,
   1050                          GLuint size,
   1051                          void (*execute) (struct gl_context *, void *),
   1052                          void (*destroy) (struct gl_context *, void *),
   1053                          void (*print) (struct gl_context *, void *))
   1054 {
   1055    if (ctx->ListExt->NumOpcodes < MAX_DLIST_EXT_OPCODES) {
   1056       const GLuint i = ctx->ListExt->NumOpcodes++;
   1057       ctx->ListExt->Opcode[i].Size =
   1058          1 + (size + sizeof(Node) - 1) / sizeof(Node);
   1059       ctx->ListExt->Opcode[i].Execute = execute;
   1060       ctx->ListExt->Opcode[i].Destroy = destroy;
   1061       ctx->ListExt->Opcode[i].Print = print;
   1062       return i + OPCODE_EXT_0;
   1063    }
   1064    return -1;
   1065 }
   1066 
   1067 
   1068 /**
   1069  * Allocate space for a display list instruction.  The space is basically
   1070  * an array of Nodes where node[0] holds the opcode, node[1] is the first
   1071  * function parameter, node[2] is the second parameter, etc.
   1072  *
   1073  * \param opcode  one of OPCODE_x
   1074  * \param nparams  number of function parameters
   1075  * \return  pointer to start of instruction space
   1076  */
   1077 static inline Node *
   1078 alloc_instruction(struct gl_context *ctx, OpCode opcode, GLuint nparams)
   1079 {
   1080    return dlist_alloc(ctx, opcode, nparams * sizeof(Node));
   1081 }
   1082 
   1083 
   1084 
   1085 /*
   1086  * Display List compilation functions
   1087  */
   1088 static void GLAPIENTRY
   1089 save_Accum(GLenum op, GLfloat value)
   1090 {
   1091    GET_CURRENT_CONTEXT(ctx);
   1092    Node *n;
   1093    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1094    n = alloc_instruction(ctx, OPCODE_ACCUM, 2);
   1095    if (n) {
   1096       n[1].e = op;
   1097       n[2].f = value;
   1098    }
   1099    if (ctx->ExecuteFlag) {
   1100       CALL_Accum(ctx->Exec, (op, value));
   1101    }
   1102 }
   1103 
   1104 
   1105 static void GLAPIENTRY
   1106 save_AlphaFunc(GLenum func, GLclampf ref)
   1107 {
   1108    GET_CURRENT_CONTEXT(ctx);
   1109    Node *n;
   1110    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1111    n = alloc_instruction(ctx, OPCODE_ALPHA_FUNC, 2);
   1112    if (n) {
   1113       n[1].e = func;
   1114       n[2].f = (GLfloat) ref;
   1115    }
   1116    if (ctx->ExecuteFlag) {
   1117       CALL_AlphaFunc(ctx->Exec, (func, ref));
   1118    }
   1119 }
   1120 
   1121 
   1122 static void GLAPIENTRY
   1123 save_BindTexture(GLenum target, GLuint texture)
   1124 {
   1125    GET_CURRENT_CONTEXT(ctx);
   1126    Node *n;
   1127    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1128    n = alloc_instruction(ctx, OPCODE_BIND_TEXTURE, 2);
   1129    if (n) {
   1130       n[1].e = target;
   1131       n[2].ui = texture;
   1132    }
   1133    if (ctx->ExecuteFlag) {
   1134       CALL_BindTexture(ctx->Exec, (target, texture));
   1135    }
   1136 }
   1137 
   1138 
   1139 static void GLAPIENTRY
   1140 save_Bitmap(GLsizei width, GLsizei height,
   1141             GLfloat xorig, GLfloat yorig,
   1142             GLfloat xmove, GLfloat ymove, const GLubyte * pixels)
   1143 {
   1144    GET_CURRENT_CONTEXT(ctx);
   1145    Node *n;
   1146    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1147    n = alloc_instruction(ctx, OPCODE_BITMAP, 7);
   1148    if (n) {
   1149       n[1].i = (GLint) width;
   1150       n[2].i = (GLint) height;
   1151       n[3].f = xorig;
   1152       n[4].f = yorig;
   1153       n[5].f = xmove;
   1154       n[6].f = ymove;
   1155       n[7].data = unpack_image(ctx, 2, width, height, 1, GL_COLOR_INDEX,
   1156                                GL_BITMAP, pixels, &ctx->Unpack);
   1157    }
   1158    if (ctx->ExecuteFlag) {
   1159       CALL_Bitmap(ctx->Exec, (width, height,
   1160                               xorig, yorig, xmove, ymove, pixels));
   1161    }
   1162 }
   1163 
   1164 
   1165 static void GLAPIENTRY
   1166 save_BlendEquation(GLenum mode)
   1167 {
   1168    GET_CURRENT_CONTEXT(ctx);
   1169    Node *n;
   1170    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1171    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION, 1);
   1172    if (n) {
   1173       n[1].e = mode;
   1174    }
   1175    if (ctx->ExecuteFlag) {
   1176       CALL_BlendEquation(ctx->Exec, (mode));
   1177    }
   1178 }
   1179 
   1180 
   1181 static void GLAPIENTRY
   1182 save_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
   1183 {
   1184    GET_CURRENT_CONTEXT(ctx);
   1185    Node *n;
   1186    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1187    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);
   1188    if (n) {
   1189       n[1].e = modeRGB;
   1190       n[2].e = modeA;
   1191    }
   1192    if (ctx->ExecuteFlag) {
   1193       CALL_BlendEquationSeparateEXT(ctx->Exec, (modeRGB, modeA));
   1194    }
   1195 }
   1196 
   1197 
   1198 static void GLAPIENTRY
   1199 save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
   1200                           GLenum sfactorA, GLenum dfactorA)
   1201 {
   1202    GET_CURRENT_CONTEXT(ctx);
   1203    Node *n;
   1204    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1205    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);
   1206    if (n) {
   1207       n[1].e = sfactorRGB;
   1208       n[2].e = dfactorRGB;
   1209       n[3].e = sfactorA;
   1210       n[4].e = dfactorA;
   1211    }
   1212    if (ctx->ExecuteFlag) {
   1213       CALL_BlendFuncSeparateEXT(ctx->Exec,
   1214                                 (sfactorRGB, dfactorRGB, sfactorA, dfactorA));
   1215    }
   1216 }
   1217 
   1218 
   1219 static void GLAPIENTRY
   1220 save_BlendFunc(GLenum srcfactor, GLenum dstfactor)
   1221 {
   1222    save_BlendFuncSeparateEXT(srcfactor, dstfactor, srcfactor, dstfactor);
   1223 }
   1224 
   1225 
   1226 static void GLAPIENTRY
   1227 save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
   1228 {
   1229    GET_CURRENT_CONTEXT(ctx);
   1230    Node *n;
   1231    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1232    n = alloc_instruction(ctx, OPCODE_BLEND_COLOR, 4);
   1233    if (n) {
   1234       n[1].f = red;
   1235       n[2].f = green;
   1236       n[3].f = blue;
   1237       n[4].f = alpha;
   1238    }
   1239    if (ctx->ExecuteFlag) {
   1240       CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));
   1241    }
   1242 }
   1243 
   1244 /* GL_ARB_draw_buffers_blend */
   1245 static void GLAPIENTRY
   1246 save_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
   1247                         GLenum sfactorA, GLenum dfactorA)
   1248 {
   1249    GET_CURRENT_CONTEXT(ctx);
   1250    Node *n;
   1251    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1252    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 5);
   1253    if (n) {
   1254       n[1].ui = buf;
   1255       n[2].e = sfactorRGB;
   1256       n[3].e = dfactorRGB;
   1257       n[4].e = sfactorA;
   1258       n[5].e = dfactorA;
   1259    }
   1260    if (ctx->ExecuteFlag) {
   1261       CALL_BlendFuncSeparateiARB(ctx->Exec, (buf, sfactorRGB, dfactorRGB,
   1262                                              sfactorA, dfactorA));
   1263    }
   1264 }
   1265 
   1266 /* GL_ARB_draw_buffers_blend */
   1267 static void GLAPIENTRY
   1268 save_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
   1269 {
   1270    GET_CURRENT_CONTEXT(ctx);
   1271    Node *n;
   1272    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1273    n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 3);
   1274    if (n) {
   1275       n[1].ui = buf;
   1276       n[2].e = sfactor;
   1277       n[3].e = dfactor;
   1278    }
   1279    if (ctx->ExecuteFlag) {
   1280       CALL_BlendFunciARB(ctx->Exec, (buf, sfactor, dfactor));
   1281    }
   1282 }
   1283 
   1284 /* GL_ARB_draw_buffers_blend */
   1285 static void GLAPIENTRY
   1286 save_BlendEquationi(GLuint buf, GLenum mode)
   1287 {
   1288    GET_CURRENT_CONTEXT(ctx);
   1289    Node *n;
   1290    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1291    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_I, 2);
   1292    if (n) {
   1293       n[1].ui = buf;
   1294       n[2].e = mode;
   1295    }
   1296    if (ctx->ExecuteFlag) {
   1297       CALL_BlendEquationiARB(ctx->Exec, (buf, mode));
   1298    }
   1299 }
   1300 
   1301 /* GL_ARB_draw_buffers_blend */
   1302 static void GLAPIENTRY
   1303 save_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
   1304 {
   1305    GET_CURRENT_CONTEXT(ctx);
   1306    Node *n;
   1307    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1308    n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE_I, 3);
   1309    if (n) {
   1310       n[1].ui = buf;
   1311       n[2].e = modeRGB;
   1312       n[3].e = modeA;
   1313    }
   1314    if (ctx->ExecuteFlag) {
   1315       CALL_BlendEquationSeparateiARB(ctx->Exec, (buf, modeRGB, modeA));
   1316    }
   1317 }
   1318 
   1319 
   1320 /* GL_ARB_draw_instanced. */
   1321 static void GLAPIENTRY
   1322 save_DrawArraysInstancedARB(GLenum mode,
   1323 			    GLint first,
   1324 			    GLsizei count,
   1325 			    GLsizei primcount)
   1326 {
   1327    GET_CURRENT_CONTEXT(ctx);
   1328    _mesa_error(ctx, GL_INVALID_OPERATION,
   1329 	       "glDrawArraysInstanced() during display list compile");
   1330 }
   1331 
   1332 static void GLAPIENTRY
   1333 save_DrawElementsInstancedARB(GLenum mode,
   1334 			      GLsizei count,
   1335 			      GLenum type,
   1336 			      const GLvoid *indices,
   1337 			      GLsizei primcount)
   1338 {
   1339    GET_CURRENT_CONTEXT(ctx);
   1340    _mesa_error(ctx, GL_INVALID_OPERATION,
   1341 	       "glDrawElementsInstanced() during display list compile");
   1342 }
   1343 
   1344 static void GLAPIENTRY
   1345 save_DrawElementsInstancedBaseVertexARB(GLenum mode,
   1346 					GLsizei count,
   1347 					GLenum type,
   1348 					const GLvoid *indices,
   1349 					GLsizei primcount,
   1350 					GLint basevertex)
   1351 {
   1352    GET_CURRENT_CONTEXT(ctx);
   1353    _mesa_error(ctx, GL_INVALID_OPERATION,
   1354 	       "glDrawElementsInstancedBaseVertex() during display list compile");
   1355 }
   1356 
   1357 /* GL_ARB_base_instance. */
   1358 static void GLAPIENTRY
   1359 save_DrawArraysInstancedBaseInstance(GLenum mode,
   1360                                      GLint first,
   1361                                      GLsizei count,
   1362                                      GLsizei primcount,
   1363                                      GLuint baseinstance)
   1364 {
   1365    GET_CURRENT_CONTEXT(ctx);
   1366    _mesa_error(ctx, GL_INVALID_OPERATION,
   1367 	       "glDrawArraysInstancedBaseInstance() during display list compile");
   1368 }
   1369 
   1370 static void APIENTRY
   1371 save_DrawElementsInstancedBaseInstance(GLenum mode,
   1372                                        GLsizei count,
   1373                                        GLenum type,
   1374                                        const void *indices,
   1375                                        GLsizei primcount,
   1376                                        GLuint baseinstance)
   1377 {
   1378    GET_CURRENT_CONTEXT(ctx);
   1379    _mesa_error(ctx, GL_INVALID_OPERATION,
   1380 	       "glDrawElementsInstancedBaseInstance() during display list compile");
   1381 }
   1382 
   1383 static void APIENTRY
   1384 save_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode,
   1385                                                  GLsizei count,
   1386                                                  GLenum type,
   1387                                                  const void *indices,
   1388                                                  GLsizei primcount,
   1389                                                  GLint basevertex,
   1390                                                  GLuint baseinstance)
   1391 {
   1392    GET_CURRENT_CONTEXT(ctx);
   1393    _mesa_error(ctx, GL_INVALID_OPERATION,
   1394 	       "glDrawElementsInstancedBaseVertexBaseInstance() during display list compile");
   1395 }
   1396 
   1397 static void invalidate_saved_current_state( struct gl_context *ctx )
   1398 {
   1399    GLint i;
   1400 
   1401    for (i = 0; i < VERT_ATTRIB_MAX; i++)
   1402       ctx->ListState.ActiveAttribSize[i] = 0;
   1403 
   1404    for (i = 0; i < MAT_ATTRIB_MAX; i++)
   1405       ctx->ListState.ActiveMaterialSize[i] = 0;
   1406 
   1407    memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);
   1408 
   1409    ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
   1410 }
   1411 
   1412 static void GLAPIENTRY
   1413 save_CallList(GLuint list)
   1414 {
   1415    GET_CURRENT_CONTEXT(ctx);
   1416    Node *n;
   1417    SAVE_FLUSH_VERTICES(ctx);
   1418 
   1419    n = alloc_instruction(ctx, OPCODE_CALL_LIST, 1);
   1420    if (n) {
   1421       n[1].ui = list;
   1422    }
   1423 
   1424    /* After this, we don't know what state we're in.  Invalidate all
   1425     * cached information previously gathered:
   1426     */
   1427    invalidate_saved_current_state( ctx );
   1428 
   1429    if (ctx->ExecuteFlag) {
   1430       _mesa_CallList(list);
   1431    }
   1432 }
   1433 
   1434 
   1435 static void GLAPIENTRY
   1436 save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)
   1437 {
   1438    GET_CURRENT_CONTEXT(ctx);
   1439    GLint i;
   1440    GLboolean typeErrorFlag;
   1441 
   1442    SAVE_FLUSH_VERTICES(ctx);
   1443 
   1444    switch (type) {
   1445    case GL_BYTE:
   1446    case GL_UNSIGNED_BYTE:
   1447    case GL_SHORT:
   1448    case GL_UNSIGNED_SHORT:
   1449    case GL_INT:
   1450    case GL_UNSIGNED_INT:
   1451    case GL_FLOAT:
   1452    case GL_2_BYTES:
   1453    case GL_3_BYTES:
   1454    case GL_4_BYTES:
   1455       typeErrorFlag = GL_FALSE;
   1456       break;
   1457    default:
   1458       typeErrorFlag = GL_TRUE;
   1459    }
   1460 
   1461    for (i = 0; i < num; i++) {
   1462       GLint list = translate_id(i, type, lists);
   1463       Node *n = alloc_instruction(ctx, OPCODE_CALL_LIST_OFFSET, 2);
   1464       if (n) {
   1465          n[1].i = list;
   1466          n[2].b = typeErrorFlag;
   1467       }
   1468    }
   1469 
   1470    /* After this, we don't know what state we're in.  Invalidate all
   1471     * cached information previously gathered:
   1472     */
   1473    invalidate_saved_current_state( ctx );
   1474 
   1475    if (ctx->ExecuteFlag) {
   1476       CALL_CallLists(ctx->Exec, (num, type, lists));
   1477    }
   1478 }
   1479 
   1480 
   1481 static void GLAPIENTRY
   1482 save_Clear(GLbitfield mask)
   1483 {
   1484    GET_CURRENT_CONTEXT(ctx);
   1485    Node *n;
   1486    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1487    n = alloc_instruction(ctx, OPCODE_CLEAR, 1);
   1488    if (n) {
   1489       n[1].bf = mask;
   1490    }
   1491    if (ctx->ExecuteFlag) {
   1492       CALL_Clear(ctx->Exec, (mask));
   1493    }
   1494 }
   1495 
   1496 
   1497 static void GLAPIENTRY
   1498 save_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
   1499 {
   1500    GET_CURRENT_CONTEXT(ctx);
   1501    Node *n;
   1502    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1503    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_IV, 6);
   1504    if (n) {
   1505       n[1].e = buffer;
   1506       n[2].i = drawbuffer;
   1507       n[3].i = value[0];
   1508       if (buffer == GL_COLOR) {
   1509          n[4].i = value[1];
   1510          n[5].i = value[2];
   1511          n[6].i = value[3];
   1512       }
   1513       else {
   1514          n[4].i = 0;
   1515          n[5].i = 0;
   1516          n[6].i = 0;
   1517       }
   1518    }
   1519    if (ctx->ExecuteFlag) {
   1520       CALL_ClearBufferiv(ctx->Exec, (buffer, drawbuffer, value));
   1521    }
   1522 }
   1523 
   1524 
   1525 static void GLAPIENTRY
   1526 save_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
   1527 {
   1528    GET_CURRENT_CONTEXT(ctx);
   1529    Node *n;
   1530    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1531    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_UIV, 6);
   1532    if (n) {
   1533       n[1].e = buffer;
   1534       n[2].i = drawbuffer;
   1535       n[3].ui = value[0];
   1536       if (buffer == GL_COLOR) {
   1537          n[4].ui = value[1];
   1538          n[5].ui = value[2];
   1539          n[6].ui = value[3];
   1540       }
   1541       else {
   1542          n[4].ui = 0;
   1543          n[5].ui = 0;
   1544          n[6].ui = 0;
   1545       }
   1546    }
   1547    if (ctx->ExecuteFlag) {
   1548       CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));
   1549    }
   1550 }
   1551 
   1552 
   1553 static void GLAPIENTRY
   1554 save_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
   1555 {
   1556    GET_CURRENT_CONTEXT(ctx);
   1557    Node *n;
   1558    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1559    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FV, 6);
   1560    if (n) {
   1561       n[1].e = buffer;
   1562       n[2].i = drawbuffer;
   1563       n[3].f = value[0];
   1564       if (buffer == GL_COLOR) {
   1565          n[4].f = value[1];
   1566          n[5].f = value[2];
   1567          n[6].f = value[3];
   1568       }
   1569       else {
   1570          n[4].f = 0.0F;
   1571          n[5].f = 0.0F;
   1572          n[6].f = 0.0F;
   1573       }
   1574    }
   1575    if (ctx->ExecuteFlag) {
   1576       CALL_ClearBufferfv(ctx->Exec, (buffer, drawbuffer, value));
   1577    }
   1578 }
   1579 
   1580 
   1581 static void GLAPIENTRY
   1582 save_ClearBufferfi(GLenum buffer, GLint drawbuffer,
   1583                    GLfloat depth, GLint stencil)
   1584 {
   1585    GET_CURRENT_CONTEXT(ctx);
   1586    Node *n;
   1587    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1588    n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FI, 4);
   1589    if (n) {
   1590       n[1].e = buffer;
   1591       n[2].i = drawbuffer;
   1592       n[3].f = depth;
   1593       n[4].i = stencil;
   1594    }
   1595    if (ctx->ExecuteFlag) {
   1596       CALL_ClearBufferfi(ctx->Exec, (buffer, drawbuffer, depth, stencil));
   1597    }
   1598 }
   1599 
   1600 
   1601 static void GLAPIENTRY
   1602 save_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
   1603 {
   1604    GET_CURRENT_CONTEXT(ctx);
   1605    Node *n;
   1606    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1607    n = alloc_instruction(ctx, OPCODE_CLEAR_ACCUM, 4);
   1608    if (n) {
   1609       n[1].f = red;
   1610       n[2].f = green;
   1611       n[3].f = blue;
   1612       n[4].f = alpha;
   1613    }
   1614    if (ctx->ExecuteFlag) {
   1615       CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));
   1616    }
   1617 }
   1618 
   1619 
   1620 static void GLAPIENTRY
   1621 save_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
   1622 {
   1623    GET_CURRENT_CONTEXT(ctx);
   1624    Node *n;
   1625    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1626    n = alloc_instruction(ctx, OPCODE_CLEAR_COLOR, 4);
   1627    if (n) {
   1628       n[1].f = red;
   1629       n[2].f = green;
   1630       n[3].f = blue;
   1631       n[4].f = alpha;
   1632    }
   1633    if (ctx->ExecuteFlag) {
   1634       CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));
   1635    }
   1636 }
   1637 
   1638 
   1639 static void GLAPIENTRY
   1640 save_ClearDepth(GLclampd depth)
   1641 {
   1642    GET_CURRENT_CONTEXT(ctx);
   1643    Node *n;
   1644    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1645    n = alloc_instruction(ctx, OPCODE_CLEAR_DEPTH, 1);
   1646    if (n) {
   1647       n[1].f = (GLfloat) depth;
   1648    }
   1649    if (ctx->ExecuteFlag) {
   1650       CALL_ClearDepth(ctx->Exec, (depth));
   1651    }
   1652 }
   1653 
   1654 
   1655 static void GLAPIENTRY
   1656 save_ClearIndex(GLfloat c)
   1657 {
   1658    GET_CURRENT_CONTEXT(ctx);
   1659    Node *n;
   1660    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1661    n = alloc_instruction(ctx, OPCODE_CLEAR_INDEX, 1);
   1662    if (n) {
   1663       n[1].f = c;
   1664    }
   1665    if (ctx->ExecuteFlag) {
   1666       CALL_ClearIndex(ctx->Exec, (c));
   1667    }
   1668 }
   1669 
   1670 
   1671 static void GLAPIENTRY
   1672 save_ClearStencil(GLint s)
   1673 {
   1674    GET_CURRENT_CONTEXT(ctx);
   1675    Node *n;
   1676    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1677    n = alloc_instruction(ctx, OPCODE_CLEAR_STENCIL, 1);
   1678    if (n) {
   1679       n[1].i = s;
   1680    }
   1681    if (ctx->ExecuteFlag) {
   1682       CALL_ClearStencil(ctx->Exec, (s));
   1683    }
   1684 }
   1685 
   1686 
   1687 static void GLAPIENTRY
   1688 save_ClipPlane(GLenum plane, const GLdouble * equ)
   1689 {
   1690    GET_CURRENT_CONTEXT(ctx);
   1691    Node *n;
   1692    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1693    n = alloc_instruction(ctx, OPCODE_CLIP_PLANE, 5);
   1694    if (n) {
   1695       n[1].e = plane;
   1696       n[2].f = (GLfloat) equ[0];
   1697       n[3].f = (GLfloat) equ[1];
   1698       n[4].f = (GLfloat) equ[2];
   1699       n[5].f = (GLfloat) equ[3];
   1700    }
   1701    if (ctx->ExecuteFlag) {
   1702       CALL_ClipPlane(ctx->Exec, (plane, equ));
   1703    }
   1704 }
   1705 
   1706 
   1707 
   1708 static void GLAPIENTRY
   1709 save_ColorMask(GLboolean red, GLboolean green,
   1710                GLboolean blue, GLboolean alpha)
   1711 {
   1712    GET_CURRENT_CONTEXT(ctx);
   1713    Node *n;
   1714    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1715    n = alloc_instruction(ctx, OPCODE_COLOR_MASK, 4);
   1716    if (n) {
   1717       n[1].b = red;
   1718       n[2].b = green;
   1719       n[3].b = blue;
   1720       n[4].b = alpha;
   1721    }
   1722    if (ctx->ExecuteFlag) {
   1723       CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));
   1724    }
   1725 }
   1726 
   1727 
   1728 static void GLAPIENTRY
   1729 save_ColorMaskIndexed(GLuint buf, GLboolean red, GLboolean green,
   1730                       GLboolean blue, GLboolean alpha)
   1731 {
   1732    GET_CURRENT_CONTEXT(ctx);
   1733    Node *n;
   1734    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1735    n = alloc_instruction(ctx, OPCODE_COLOR_MASK_INDEXED, 5);
   1736    if (n) {
   1737       n[1].ui = buf;
   1738       n[2].b = red;
   1739       n[3].b = green;
   1740       n[4].b = blue;
   1741       n[5].b = alpha;
   1742    }
   1743    if (ctx->ExecuteFlag) {
   1744       /*CALL_ColorMaskIndexedEXT(ctx->Exec, (buf, red, green, blue, alpha));*/
   1745    }
   1746 }
   1747 
   1748 
   1749 static void GLAPIENTRY
   1750 save_ColorMaterial(GLenum face, GLenum mode)
   1751 {
   1752    GET_CURRENT_CONTEXT(ctx);
   1753    Node *n;
   1754    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1755 
   1756    n = alloc_instruction(ctx, OPCODE_COLOR_MATERIAL, 2);
   1757    if (n) {
   1758       n[1].e = face;
   1759       n[2].e = mode;
   1760    }
   1761    if (ctx->ExecuteFlag) {
   1762       CALL_ColorMaterial(ctx->Exec, (face, mode));
   1763    }
   1764 }
   1765 
   1766 
   1767 static void GLAPIENTRY
   1768 save_ColorTable(GLenum target, GLenum internalFormat,
   1769                 GLsizei width, GLenum format, GLenum type,
   1770                 const GLvoid * table)
   1771 {
   1772    GET_CURRENT_CONTEXT(ctx);
   1773    if (_mesa_is_proxy_texture(target)) {
   1774       /* execute immediately */
   1775       CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
   1776                                   format, type, table));
   1777    }
   1778    else {
   1779       Node *n;
   1780       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1781       n = alloc_instruction(ctx, OPCODE_COLOR_TABLE, 6);
   1782       if (n) {
   1783          n[1].e = target;
   1784          n[2].e = internalFormat;
   1785          n[3].i = width;
   1786          n[4].e = format;
   1787          n[5].e = type;
   1788          n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, table,
   1789                                   &ctx->Unpack);
   1790       }
   1791       if (ctx->ExecuteFlag) {
   1792          CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
   1793                                      format, type, table));
   1794       }
   1795    }
   1796 }
   1797 
   1798 
   1799 
   1800 static void GLAPIENTRY
   1801 save_ColorTableParameterfv(GLenum target, GLenum pname,
   1802                            const GLfloat *params)
   1803 {
   1804    GET_CURRENT_CONTEXT(ctx);
   1805    Node *n;
   1806 
   1807    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1808 
   1809    n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6);
   1810    if (n) {
   1811       n[1].e = target;
   1812       n[2].e = pname;
   1813       n[3].f = params[0];
   1814       if (pname == GL_COLOR_TABLE_SGI ||
   1815           pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
   1816           pname == GL_TEXTURE_COLOR_TABLE_SGI) {
   1817          n[4].f = params[1];
   1818          n[5].f = params[2];
   1819          n[6].f = params[3];
   1820       }
   1821    }
   1822 
   1823    if (ctx->ExecuteFlag) {
   1824       CALL_ColorTableParameterfv(ctx->Exec, (target, pname, params));
   1825    }
   1826 }
   1827 
   1828 
   1829 static void GLAPIENTRY
   1830 save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
   1831 {
   1832    GET_CURRENT_CONTEXT(ctx);
   1833    Node *n;
   1834 
   1835    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1836 
   1837    n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6);
   1838    if (n) {
   1839       n[1].e = target;
   1840       n[2].e = pname;
   1841       n[3].i = params[0];
   1842       if (pname == GL_COLOR_TABLE_SGI ||
   1843           pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
   1844           pname == GL_TEXTURE_COLOR_TABLE_SGI) {
   1845          n[4].i = params[1];
   1846          n[5].i = params[2];
   1847          n[6].i = params[3];
   1848       }
   1849    }
   1850 
   1851    if (ctx->ExecuteFlag) {
   1852       CALL_ColorTableParameteriv(ctx->Exec, (target, pname, params));
   1853    }
   1854 }
   1855 
   1856 
   1857 
   1858 static void GLAPIENTRY
   1859 save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,
   1860                    GLenum format, GLenum type, const GLvoid * table)
   1861 {
   1862    GET_CURRENT_CONTEXT(ctx);
   1863    Node *n;
   1864    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1865    n = alloc_instruction(ctx, OPCODE_COLOR_SUB_TABLE, 6);
   1866    if (n) {
   1867       n[1].e = target;
   1868       n[2].i = start;
   1869       n[3].i = count;
   1870       n[4].e = format;
   1871       n[5].e = type;
   1872       n[6].data = unpack_image(ctx, 1, count, 1, 1, format, type, table,
   1873                                &ctx->Unpack);
   1874    }
   1875    if (ctx->ExecuteFlag) {
   1876       CALL_ColorSubTable(ctx->Exec,
   1877                          (target, start, count, format, type, table));
   1878    }
   1879 }
   1880 
   1881 
   1882 static void GLAPIENTRY
   1883 save_CopyColorSubTable(GLenum target, GLsizei start,
   1884                        GLint x, GLint y, GLsizei width)
   1885 {
   1886    GET_CURRENT_CONTEXT(ctx);
   1887    Node *n;
   1888 
   1889    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1890    n = alloc_instruction(ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5);
   1891    if (n) {
   1892       n[1].e = target;
   1893       n[2].i = start;
   1894       n[3].i = x;
   1895       n[4].i = y;
   1896       n[5].i = width;
   1897    }
   1898    if (ctx->ExecuteFlag) {
   1899       CALL_CopyColorSubTable(ctx->Exec, (target, start, x, y, width));
   1900    }
   1901 }
   1902 
   1903 
   1904 static void GLAPIENTRY
   1905 save_CopyColorTable(GLenum target, GLenum internalformat,
   1906                     GLint x, GLint y, GLsizei width)
   1907 {
   1908    GET_CURRENT_CONTEXT(ctx);
   1909    Node *n;
   1910 
   1911    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1912    n = alloc_instruction(ctx, OPCODE_COPY_COLOR_TABLE, 5);
   1913    if (n) {
   1914       n[1].e = target;
   1915       n[2].e = internalformat;
   1916       n[3].i = x;
   1917       n[4].i = y;
   1918       n[5].i = width;
   1919    }
   1920    if (ctx->ExecuteFlag) {
   1921       CALL_CopyColorTable(ctx->Exec, (target, internalformat, x, y, width));
   1922    }
   1923 }
   1924 
   1925 
   1926 static void GLAPIENTRY
   1927 save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
   1928                          GLenum format, GLenum type, const GLvoid * filter)
   1929 {
   1930    GET_CURRENT_CONTEXT(ctx);
   1931    Node *n;
   1932 
   1933    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1934 
   1935    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_1D, 6);
   1936    if (n) {
   1937       n[1].e = target;
   1938       n[2].e = internalFormat;
   1939       n[3].i = width;
   1940       n[4].e = format;
   1941       n[5].e = type;
   1942       n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, filter,
   1943                                &ctx->Unpack);
   1944    }
   1945    if (ctx->ExecuteFlag) {
   1946       CALL_ConvolutionFilter1D(ctx->Exec, (target, internalFormat, width,
   1947                                            format, type, filter));
   1948    }
   1949 }
   1950 
   1951 
   1952 static void GLAPIENTRY
   1953 save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
   1954                          GLsizei width, GLsizei height, GLenum format,
   1955                          GLenum type, const GLvoid * filter)
   1956 {
   1957    GET_CURRENT_CONTEXT(ctx);
   1958    Node *n;
   1959 
   1960    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1961 
   1962    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_2D, 7);
   1963    if (n) {
   1964       n[1].e = target;
   1965       n[2].e = internalFormat;
   1966       n[3].i = width;
   1967       n[4].i = height;
   1968       n[5].e = format;
   1969       n[6].e = type;
   1970       n[7].data = unpack_image(ctx, 2, width, height, 1, format, type, filter,
   1971                                &ctx->Unpack);
   1972    }
   1973    if (ctx->ExecuteFlag) {
   1974       CALL_ConvolutionFilter2D(ctx->Exec,
   1975                                (target, internalFormat, width, height, format,
   1976                                 type, filter));
   1977    }
   1978 }
   1979 
   1980 
   1981 static void GLAPIENTRY
   1982 save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
   1983 {
   1984    GET_CURRENT_CONTEXT(ctx);
   1985    Node *n;
   1986    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   1987    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3);
   1988    if (n) {
   1989       n[1].e = target;
   1990       n[2].e = pname;
   1991       n[3].i = param;
   1992    }
   1993    if (ctx->ExecuteFlag) {
   1994       CALL_ConvolutionParameteri(ctx->Exec, (target, pname, param));
   1995    }
   1996 }
   1997 
   1998 
   1999 static void GLAPIENTRY
   2000 save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
   2001 {
   2002    GET_CURRENT_CONTEXT(ctx);
   2003    Node *n;
   2004    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2005    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6);
   2006    if (n) {
   2007       n[1].e = target;
   2008       n[2].e = pname;
   2009       n[3].i = params[0];
   2010       if (pname == GL_CONVOLUTION_BORDER_COLOR ||
   2011           pname == GL_CONVOLUTION_FILTER_SCALE ||
   2012           pname == GL_CONVOLUTION_FILTER_BIAS) {
   2013          n[4].i = params[1];
   2014          n[5].i = params[2];
   2015          n[6].i = params[3];
   2016       }
   2017       else {
   2018          n[4].i = n[5].i = n[6].i = 0;
   2019       }
   2020    }
   2021    if (ctx->ExecuteFlag) {
   2022       CALL_ConvolutionParameteriv(ctx->Exec, (target, pname, params));
   2023    }
   2024 }
   2025 
   2026 
   2027 static void GLAPIENTRY
   2028 save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
   2029 {
   2030    GET_CURRENT_CONTEXT(ctx);
   2031    Node *n;
   2032    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2033    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3);
   2034    if (n) {
   2035       n[1].e = target;
   2036       n[2].e = pname;
   2037       n[3].f = param;
   2038    }
   2039    if (ctx->ExecuteFlag) {
   2040       CALL_ConvolutionParameterf(ctx->Exec, (target, pname, param));
   2041    }
   2042 }
   2043 
   2044 
   2045 static void GLAPIENTRY
   2046 save_ConvolutionParameterfv(GLenum target, GLenum pname,
   2047                             const GLfloat *params)
   2048 {
   2049    GET_CURRENT_CONTEXT(ctx);
   2050    Node *n;
   2051    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2052    n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6);
   2053    if (n) {
   2054       n[1].e = target;
   2055       n[2].e = pname;
   2056       n[3].f = params[0];
   2057       if (pname == GL_CONVOLUTION_BORDER_COLOR ||
   2058           pname == GL_CONVOLUTION_FILTER_SCALE ||
   2059           pname == GL_CONVOLUTION_FILTER_BIAS) {
   2060          n[4].f = params[1];
   2061          n[5].f = params[2];
   2062          n[6].f = params[3];
   2063       }
   2064       else {
   2065          n[4].f = n[5].f = n[6].f = 0.0F;
   2066       }
   2067    }
   2068    if (ctx->ExecuteFlag) {
   2069       CALL_ConvolutionParameterfv(ctx->Exec, (target, pname, params));
   2070    }
   2071 }
   2072 
   2073 
   2074 static void GLAPIENTRY
   2075 save_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
   2076 {
   2077    GET_CURRENT_CONTEXT(ctx);
   2078    Node *n;
   2079    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2080    n = alloc_instruction(ctx, OPCODE_COPY_PIXELS, 5);
   2081    if (n) {
   2082       n[1].i = x;
   2083       n[2].i = y;
   2084       n[3].i = (GLint) width;
   2085       n[4].i = (GLint) height;
   2086       n[5].e = type;
   2087    }
   2088    if (ctx->ExecuteFlag) {
   2089       CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));
   2090    }
   2091 }
   2092 
   2093 
   2094 
   2095 static void GLAPIENTRY
   2096 save_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
   2097                     GLint x, GLint y, GLsizei width, GLint border)
   2098 {
   2099    GET_CURRENT_CONTEXT(ctx);
   2100    Node *n;
   2101    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2102    n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);
   2103    if (n) {
   2104       n[1].e = target;
   2105       n[2].i = level;
   2106       n[3].e = internalformat;
   2107       n[4].i = x;
   2108       n[5].i = y;
   2109       n[6].i = width;
   2110       n[7].i = border;
   2111    }
   2112    if (ctx->ExecuteFlag) {
   2113       CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,
   2114                                       x, y, width, border));
   2115    }
   2116 }
   2117 
   2118 
   2119 static void GLAPIENTRY
   2120 save_CopyTexImage2D(GLenum target, GLint level,
   2121                     GLenum internalformat,
   2122                     GLint x, GLint y, GLsizei width,
   2123                     GLsizei height, GLint border)
   2124 {
   2125    GET_CURRENT_CONTEXT(ctx);
   2126    Node *n;
   2127    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2128    n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);
   2129    if (n) {
   2130       n[1].e = target;
   2131       n[2].i = level;
   2132       n[3].e = internalformat;
   2133       n[4].i = x;
   2134       n[5].i = y;
   2135       n[6].i = width;
   2136       n[7].i = height;
   2137       n[8].i = border;
   2138    }
   2139    if (ctx->ExecuteFlag) {
   2140       CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,
   2141                                       x, y, width, height, border));
   2142    }
   2143 }
   2144 
   2145 
   2146 
   2147 static void GLAPIENTRY
   2148 save_CopyTexSubImage1D(GLenum target, GLint level,
   2149                        GLint xoffset, GLint x, GLint y, GLsizei width)
   2150 {
   2151    GET_CURRENT_CONTEXT(ctx);
   2152    Node *n;
   2153    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2154    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);
   2155    if (n) {
   2156       n[1].e = target;
   2157       n[2].i = level;
   2158       n[3].i = xoffset;
   2159       n[4].i = x;
   2160       n[5].i = y;
   2161       n[6].i = width;
   2162    }
   2163    if (ctx->ExecuteFlag) {
   2164       CALL_CopyTexSubImage1D(ctx->Exec,
   2165                              (target, level, xoffset, x, y, width));
   2166    }
   2167 }
   2168 
   2169 
   2170 static void GLAPIENTRY
   2171 save_CopyTexSubImage2D(GLenum target, GLint level,
   2172                        GLint xoffset, GLint yoffset,
   2173                        GLint x, GLint y, GLsizei width, GLint height)
   2174 {
   2175    GET_CURRENT_CONTEXT(ctx);
   2176    Node *n;
   2177    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2178    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);
   2179    if (n) {
   2180       n[1].e = target;
   2181       n[2].i = level;
   2182       n[3].i = xoffset;
   2183       n[4].i = yoffset;
   2184       n[5].i = x;
   2185       n[6].i = y;
   2186       n[7].i = width;
   2187       n[8].i = height;
   2188    }
   2189    if (ctx->ExecuteFlag) {
   2190       CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
   2191                                          x, y, width, height));
   2192    }
   2193 }
   2194 
   2195 
   2196 static void GLAPIENTRY
   2197 save_CopyTexSubImage3D(GLenum target, GLint level,
   2198                        GLint xoffset, GLint yoffset, GLint zoffset,
   2199                        GLint x, GLint y, GLsizei width, GLint height)
   2200 {
   2201    GET_CURRENT_CONTEXT(ctx);
   2202    Node *n;
   2203    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2204    n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);
   2205    if (n) {
   2206       n[1].e = target;
   2207       n[2].i = level;
   2208       n[3].i = xoffset;
   2209       n[4].i = yoffset;
   2210       n[5].i = zoffset;
   2211       n[6].i = x;
   2212       n[7].i = y;
   2213       n[8].i = width;
   2214       n[9].i = height;
   2215    }
   2216    if (ctx->ExecuteFlag) {
   2217       CALL_CopyTexSubImage3D(ctx->Exec, (target, level,
   2218                                          xoffset, yoffset, zoffset,
   2219                                          x, y, width, height));
   2220    }
   2221 }
   2222 
   2223 
   2224 static void GLAPIENTRY
   2225 save_CullFace(GLenum mode)
   2226 {
   2227    GET_CURRENT_CONTEXT(ctx);
   2228    Node *n;
   2229    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2230    n = alloc_instruction(ctx, OPCODE_CULL_FACE, 1);
   2231    if (n) {
   2232       n[1].e = mode;
   2233    }
   2234    if (ctx->ExecuteFlag) {
   2235       CALL_CullFace(ctx->Exec, (mode));
   2236    }
   2237 }
   2238 
   2239 
   2240 static void GLAPIENTRY
   2241 save_DepthFunc(GLenum func)
   2242 {
   2243    GET_CURRENT_CONTEXT(ctx);
   2244    Node *n;
   2245    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2246    n = alloc_instruction(ctx, OPCODE_DEPTH_FUNC, 1);
   2247    if (n) {
   2248       n[1].e = func;
   2249    }
   2250    if (ctx->ExecuteFlag) {
   2251       CALL_DepthFunc(ctx->Exec, (func));
   2252    }
   2253 }
   2254 
   2255 
   2256 static void GLAPIENTRY
   2257 save_DepthMask(GLboolean mask)
   2258 {
   2259    GET_CURRENT_CONTEXT(ctx);
   2260    Node *n;
   2261    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2262    n = alloc_instruction(ctx, OPCODE_DEPTH_MASK, 1);
   2263    if (n) {
   2264       n[1].b = mask;
   2265    }
   2266    if (ctx->ExecuteFlag) {
   2267       CALL_DepthMask(ctx->Exec, (mask));
   2268    }
   2269 }
   2270 
   2271 
   2272 static void GLAPIENTRY
   2273 save_DepthRange(GLclampd nearval, GLclampd farval)
   2274 {
   2275    GET_CURRENT_CONTEXT(ctx);
   2276    Node *n;
   2277    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2278    n = alloc_instruction(ctx, OPCODE_DEPTH_RANGE, 2);
   2279    if (n) {
   2280       n[1].f = (GLfloat) nearval;
   2281       n[2].f = (GLfloat) farval;
   2282    }
   2283    if (ctx->ExecuteFlag) {
   2284       CALL_DepthRange(ctx->Exec, (nearval, farval));
   2285    }
   2286 }
   2287 
   2288 
   2289 static void GLAPIENTRY
   2290 save_Disable(GLenum cap)
   2291 {
   2292    GET_CURRENT_CONTEXT(ctx);
   2293    Node *n;
   2294    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2295    n = alloc_instruction(ctx, OPCODE_DISABLE, 1);
   2296    if (n) {
   2297       n[1].e = cap;
   2298    }
   2299    if (ctx->ExecuteFlag) {
   2300       CALL_Disable(ctx->Exec, (cap));
   2301    }
   2302 }
   2303 
   2304 
   2305 static void GLAPIENTRY
   2306 save_DisableIndexed(GLuint index, GLenum cap)
   2307 {
   2308    GET_CURRENT_CONTEXT(ctx);
   2309    Node *n;
   2310    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2311    n = alloc_instruction(ctx, OPCODE_DISABLE_INDEXED, 2);
   2312    if (n) {
   2313       n[1].ui = index;
   2314       n[2].e = cap;
   2315    }
   2316    if (ctx->ExecuteFlag) {
   2317       CALL_DisableIndexedEXT(ctx->Exec, (index, cap));
   2318    }
   2319 }
   2320 
   2321 
   2322 static void GLAPIENTRY
   2323 save_DrawBuffer(GLenum mode)
   2324 {
   2325    GET_CURRENT_CONTEXT(ctx);
   2326    Node *n;
   2327    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2328    n = alloc_instruction(ctx, OPCODE_DRAW_BUFFER, 1);
   2329    if (n) {
   2330       n[1].e = mode;
   2331    }
   2332    if (ctx->ExecuteFlag) {
   2333       CALL_DrawBuffer(ctx->Exec, (mode));
   2334    }
   2335 }
   2336 
   2337 
   2338 static void GLAPIENTRY
   2339 save_DrawPixels(GLsizei width, GLsizei height,
   2340                 GLenum format, GLenum type, const GLvoid * pixels)
   2341 {
   2342    GET_CURRENT_CONTEXT(ctx);
   2343    Node *n;
   2344 
   2345    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2346 
   2347    n = alloc_instruction(ctx, OPCODE_DRAW_PIXELS, 5);
   2348    if (n) {
   2349       n[1].i = width;
   2350       n[2].i = height;
   2351       n[3].e = format;
   2352       n[4].e = type;
   2353       n[5].data = unpack_image(ctx, 2, width, height, 1, format, type,
   2354                                pixels, &ctx->Unpack);
   2355    }
   2356    if (ctx->ExecuteFlag) {
   2357       CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
   2358    }
   2359 }
   2360 
   2361 
   2362 
   2363 static void GLAPIENTRY
   2364 save_Enable(GLenum cap)
   2365 {
   2366    GET_CURRENT_CONTEXT(ctx);
   2367    Node *n;
   2368    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2369    n = alloc_instruction(ctx, OPCODE_ENABLE, 1);
   2370    if (n) {
   2371       n[1].e = cap;
   2372    }
   2373    if (ctx->ExecuteFlag) {
   2374       CALL_Enable(ctx->Exec, (cap));
   2375    }
   2376 }
   2377 
   2378 
   2379 
   2380 static void GLAPIENTRY
   2381 save_EnableIndexed(GLuint index, GLenum cap)
   2382 {
   2383    GET_CURRENT_CONTEXT(ctx);
   2384    Node *n;
   2385    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2386    n = alloc_instruction(ctx, OPCODE_ENABLE_INDEXED, 2);
   2387    if (n) {
   2388       n[1].ui = index;
   2389       n[2].e = cap;
   2390    }
   2391    if (ctx->ExecuteFlag) {
   2392       CALL_EnableIndexedEXT(ctx->Exec, (index, cap));
   2393    }
   2394 }
   2395 
   2396 
   2397 
   2398 static void GLAPIENTRY
   2399 save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
   2400 {
   2401    GET_CURRENT_CONTEXT(ctx);
   2402    Node *n;
   2403    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2404    n = alloc_instruction(ctx, OPCODE_EVALMESH1, 3);
   2405    if (n) {
   2406       n[1].e = mode;
   2407       n[2].i = i1;
   2408       n[3].i = i2;
   2409    }
   2410    if (ctx->ExecuteFlag) {
   2411       CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));
   2412    }
   2413 }
   2414 
   2415 
   2416 static void GLAPIENTRY
   2417 save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
   2418 {
   2419    GET_CURRENT_CONTEXT(ctx);
   2420    Node *n;
   2421    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2422    n = alloc_instruction(ctx, OPCODE_EVALMESH2, 5);
   2423    if (n) {
   2424       n[1].e = mode;
   2425       n[2].i = i1;
   2426       n[3].i = i2;
   2427       n[4].i = j1;
   2428       n[5].i = j2;
   2429    }
   2430    if (ctx->ExecuteFlag) {
   2431       CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));
   2432    }
   2433 }
   2434 
   2435 
   2436 
   2437 
   2438 static void GLAPIENTRY
   2439 save_Fogfv(GLenum pname, const GLfloat *params)
   2440 {
   2441    GET_CURRENT_CONTEXT(ctx);
   2442    Node *n;
   2443    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2444    n = alloc_instruction(ctx, OPCODE_FOG, 5);
   2445    if (n) {
   2446       n[1].e = pname;
   2447       n[2].f = params[0];
   2448       n[3].f = params[1];
   2449       n[4].f = params[2];
   2450       n[5].f = params[3];
   2451    }
   2452    if (ctx->ExecuteFlag) {
   2453       CALL_Fogfv(ctx->Exec, (pname, params));
   2454    }
   2455 }
   2456 
   2457 
   2458 static void GLAPIENTRY
   2459 save_Fogf(GLenum pname, GLfloat param)
   2460 {
   2461    GLfloat parray[4];
   2462    parray[0] = param;
   2463    parray[1] = parray[2] = parray[3] = 0.0F;
   2464    save_Fogfv(pname, parray);
   2465 }
   2466 
   2467 
   2468 static void GLAPIENTRY
   2469 save_Fogiv(GLenum pname, const GLint *params)
   2470 {
   2471    GLfloat p[4];
   2472    switch (pname) {
   2473    case GL_FOG_MODE:
   2474    case GL_FOG_DENSITY:
   2475    case GL_FOG_START:
   2476    case GL_FOG_END:
   2477    case GL_FOG_INDEX:
   2478       p[0] = (GLfloat) *params;
   2479       p[1] = 0.0f;
   2480       p[2] = 0.0f;
   2481       p[3] = 0.0f;
   2482       break;
   2483    case GL_FOG_COLOR:
   2484       p[0] = INT_TO_FLOAT(params[0]);
   2485       p[1] = INT_TO_FLOAT(params[1]);
   2486       p[2] = INT_TO_FLOAT(params[2]);
   2487       p[3] = INT_TO_FLOAT(params[3]);
   2488       break;
   2489    default:
   2490       /* Error will be caught later in gl_Fogfv */
   2491       ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
   2492    }
   2493    save_Fogfv(pname, p);
   2494 }
   2495 
   2496 
   2497 static void GLAPIENTRY
   2498 save_Fogi(GLenum pname, GLint param)
   2499 {
   2500    GLint parray[4];
   2501    parray[0] = param;
   2502    parray[1] = parray[2] = parray[3] = 0;
   2503    save_Fogiv(pname, parray);
   2504 }
   2505 
   2506 
   2507 static void GLAPIENTRY
   2508 save_FrontFace(GLenum mode)
   2509 {
   2510    GET_CURRENT_CONTEXT(ctx);
   2511    Node *n;
   2512    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2513    n = alloc_instruction(ctx, OPCODE_FRONT_FACE, 1);
   2514    if (n) {
   2515       n[1].e = mode;
   2516    }
   2517    if (ctx->ExecuteFlag) {
   2518       CALL_FrontFace(ctx->Exec, (mode));
   2519    }
   2520 }
   2521 
   2522 
   2523 static void GLAPIENTRY
   2524 save_Frustum(GLdouble left, GLdouble right,
   2525              GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
   2526 {
   2527    GET_CURRENT_CONTEXT(ctx);
   2528    Node *n;
   2529    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2530    n = alloc_instruction(ctx, OPCODE_FRUSTUM, 6);
   2531    if (n) {
   2532       n[1].f = (GLfloat) left;
   2533       n[2].f = (GLfloat) right;
   2534       n[3].f = (GLfloat) bottom;
   2535       n[4].f = (GLfloat) top;
   2536       n[5].f = (GLfloat) nearval;
   2537       n[6].f = (GLfloat) farval;
   2538    }
   2539    if (ctx->ExecuteFlag) {
   2540       CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));
   2541    }
   2542 }
   2543 
   2544 
   2545 static void GLAPIENTRY
   2546 save_Hint(GLenum target, GLenum mode)
   2547 {
   2548    GET_CURRENT_CONTEXT(ctx);
   2549    Node *n;
   2550    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2551    n = alloc_instruction(ctx, OPCODE_HINT, 2);
   2552    if (n) {
   2553       n[1].e = target;
   2554       n[2].e = mode;
   2555    }
   2556    if (ctx->ExecuteFlag) {
   2557       CALL_Hint(ctx->Exec, (target, mode));
   2558    }
   2559 }
   2560 
   2561 
   2562 static void GLAPIENTRY
   2563 save_Histogram(GLenum target, GLsizei width, GLenum internalFormat,
   2564                GLboolean sink)
   2565 {
   2566    GET_CURRENT_CONTEXT(ctx);
   2567    Node *n;
   2568 
   2569    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2570    n = alloc_instruction(ctx, OPCODE_HISTOGRAM, 4);
   2571    if (n) {
   2572       n[1].e = target;
   2573       n[2].i = width;
   2574       n[3].e = internalFormat;
   2575       n[4].b = sink;
   2576    }
   2577    if (ctx->ExecuteFlag) {
   2578       CALL_Histogram(ctx->Exec, (target, width, internalFormat, sink));
   2579    }
   2580 }
   2581 
   2582 
   2583 static void GLAPIENTRY
   2584 save_IndexMask(GLuint mask)
   2585 {
   2586    GET_CURRENT_CONTEXT(ctx);
   2587    Node *n;
   2588    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2589    n = alloc_instruction(ctx, OPCODE_INDEX_MASK, 1);
   2590    if (n) {
   2591       n[1].ui = mask;
   2592    }
   2593    if (ctx->ExecuteFlag) {
   2594       CALL_IndexMask(ctx->Exec, (mask));
   2595    }
   2596 }
   2597 
   2598 
   2599 static void GLAPIENTRY
   2600 save_InitNames(void)
   2601 {
   2602    GET_CURRENT_CONTEXT(ctx);
   2603    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2604    (void) alloc_instruction(ctx, OPCODE_INIT_NAMES, 0);
   2605    if (ctx->ExecuteFlag) {
   2606       CALL_InitNames(ctx->Exec, ());
   2607    }
   2608 }
   2609 
   2610 
   2611 static void GLAPIENTRY
   2612 save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
   2613 {
   2614    GET_CURRENT_CONTEXT(ctx);
   2615    Node *n;
   2616    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2617    n = alloc_instruction(ctx, OPCODE_LIGHT, 6);
   2618    if (n) {
   2619       GLint i, nParams;
   2620       n[1].e = light;
   2621       n[2].e = pname;
   2622       switch (pname) {
   2623       case GL_AMBIENT:
   2624          nParams = 4;
   2625          break;
   2626       case GL_DIFFUSE:
   2627          nParams = 4;
   2628          break;
   2629       case GL_SPECULAR:
   2630          nParams = 4;
   2631          break;
   2632       case GL_POSITION:
   2633          nParams = 4;
   2634          break;
   2635       case GL_SPOT_DIRECTION:
   2636          nParams = 3;
   2637          break;
   2638       case GL_SPOT_EXPONENT:
   2639          nParams = 1;
   2640          break;
   2641       case GL_SPOT_CUTOFF:
   2642          nParams = 1;
   2643          break;
   2644       case GL_CONSTANT_ATTENUATION:
   2645          nParams = 1;
   2646          break;
   2647       case GL_LINEAR_ATTENUATION:
   2648          nParams = 1;
   2649          break;
   2650       case GL_QUADRATIC_ATTENUATION:
   2651          nParams = 1;
   2652          break;
   2653       default:
   2654          nParams = 0;
   2655       }
   2656       for (i = 0; i < nParams; i++) {
   2657          n[3 + i].f = params[i];
   2658       }
   2659    }
   2660    if (ctx->ExecuteFlag) {
   2661       CALL_Lightfv(ctx->Exec, (light, pname, params));
   2662    }
   2663 }
   2664 
   2665 
   2666 static void GLAPIENTRY
   2667 save_Lightf(GLenum light, GLenum pname, GLfloat param)
   2668 {
   2669    GLfloat parray[4];
   2670    parray[0] = param;
   2671    parray[1] = parray[2] = parray[3] = 0.0F;
   2672    save_Lightfv(light, pname, parray);
   2673 }
   2674 
   2675 
   2676 static void GLAPIENTRY
   2677 save_Lightiv(GLenum light, GLenum pname, const GLint *params)
   2678 {
   2679    GLfloat fparam[4];
   2680    switch (pname) {
   2681    case GL_AMBIENT:
   2682    case GL_DIFFUSE:
   2683    case GL_SPECULAR:
   2684       fparam[0] = INT_TO_FLOAT(params[0]);
   2685       fparam[1] = INT_TO_FLOAT(params[1]);
   2686       fparam[2] = INT_TO_FLOAT(params[2]);
   2687       fparam[3] = INT_TO_FLOAT(params[3]);
   2688       break;
   2689    case GL_POSITION:
   2690       fparam[0] = (GLfloat) params[0];
   2691       fparam[1] = (GLfloat) params[1];
   2692       fparam[2] = (GLfloat) params[2];
   2693       fparam[3] = (GLfloat) params[3];
   2694       break;
   2695    case GL_SPOT_DIRECTION:
   2696       fparam[0] = (GLfloat) params[0];
   2697       fparam[1] = (GLfloat) params[1];
   2698       fparam[2] = (GLfloat) params[2];
   2699       break;
   2700    case GL_SPOT_EXPONENT:
   2701    case GL_SPOT_CUTOFF:
   2702    case GL_CONSTANT_ATTENUATION:
   2703    case GL_LINEAR_ATTENUATION:
   2704    case GL_QUADRATIC_ATTENUATION:
   2705       fparam[0] = (GLfloat) params[0];
   2706       break;
   2707    default:
   2708       /* error will be caught later in gl_Lightfv */
   2709       ;
   2710    }
   2711    save_Lightfv(light, pname, fparam);
   2712 }
   2713 
   2714 
   2715 static void GLAPIENTRY
   2716 save_Lighti(GLenum light, GLenum pname, GLint param)
   2717 {
   2718    GLint parray[4];
   2719    parray[0] = param;
   2720    parray[1] = parray[2] = parray[3] = 0;
   2721    save_Lightiv(light, pname, parray);
   2722 }
   2723 
   2724 
   2725 static void GLAPIENTRY
   2726 save_LightModelfv(GLenum pname, const GLfloat *params)
   2727 {
   2728    GET_CURRENT_CONTEXT(ctx);
   2729    Node *n;
   2730    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2731    n = alloc_instruction(ctx, OPCODE_LIGHT_MODEL, 5);
   2732    if (n) {
   2733       n[1].e = pname;
   2734       n[2].f = params[0];
   2735       n[3].f = params[1];
   2736       n[4].f = params[2];
   2737       n[5].f = params[3];
   2738    }
   2739    if (ctx->ExecuteFlag) {
   2740       CALL_LightModelfv(ctx->Exec, (pname, params));
   2741    }
   2742 }
   2743 
   2744 
   2745 static void GLAPIENTRY
   2746 save_LightModelf(GLenum pname, GLfloat param)
   2747 {
   2748    GLfloat parray[4];
   2749    parray[0] = param;
   2750    parray[1] = parray[2] = parray[3] = 0.0F;
   2751    save_LightModelfv(pname, parray);
   2752 }
   2753 
   2754 
   2755 static void GLAPIENTRY
   2756 save_LightModeliv(GLenum pname, const GLint *params)
   2757 {
   2758    GLfloat fparam[4];
   2759    switch (pname) {
   2760    case GL_LIGHT_MODEL_AMBIENT:
   2761       fparam[0] = INT_TO_FLOAT(params[0]);
   2762       fparam[1] = INT_TO_FLOAT(params[1]);
   2763       fparam[2] = INT_TO_FLOAT(params[2]);
   2764       fparam[3] = INT_TO_FLOAT(params[3]);
   2765       break;
   2766    case GL_LIGHT_MODEL_LOCAL_VIEWER:
   2767    case GL_LIGHT_MODEL_TWO_SIDE:
   2768    case GL_LIGHT_MODEL_COLOR_CONTROL:
   2769       fparam[0] = (GLfloat) params[0];
   2770       fparam[1] = 0.0F;
   2771       fparam[2] = 0.0F;
   2772       fparam[3] = 0.0F;
   2773       break;
   2774    default:
   2775       /* Error will be caught later in gl_LightModelfv */
   2776       ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);
   2777    }
   2778    save_LightModelfv(pname, fparam);
   2779 }
   2780 
   2781 
   2782 static void GLAPIENTRY
   2783 save_LightModeli(GLenum pname, GLint param)
   2784 {
   2785    GLint parray[4];
   2786    parray[0] = param;
   2787    parray[1] = parray[2] = parray[3] = 0;
   2788    save_LightModeliv(pname, parray);
   2789 }
   2790 
   2791 
   2792 static void GLAPIENTRY
   2793 save_LineStipple(GLint factor, GLushort pattern)
   2794 {
   2795    GET_CURRENT_CONTEXT(ctx);
   2796    Node *n;
   2797    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2798    n = alloc_instruction(ctx, OPCODE_LINE_STIPPLE, 2);
   2799    if (n) {
   2800       n[1].i = factor;
   2801       n[2].us = pattern;
   2802    }
   2803    if (ctx->ExecuteFlag) {
   2804       CALL_LineStipple(ctx->Exec, (factor, pattern));
   2805    }
   2806 }
   2807 
   2808 
   2809 static void GLAPIENTRY
   2810 save_LineWidth(GLfloat width)
   2811 {
   2812    GET_CURRENT_CONTEXT(ctx);
   2813    Node *n;
   2814    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2815    n = alloc_instruction(ctx, OPCODE_LINE_WIDTH, 1);
   2816    if (n) {
   2817       n[1].f = width;
   2818    }
   2819    if (ctx->ExecuteFlag) {
   2820       CALL_LineWidth(ctx->Exec, (width));
   2821    }
   2822 }
   2823 
   2824 
   2825 static void GLAPIENTRY
   2826 save_ListBase(GLuint base)
   2827 {
   2828    GET_CURRENT_CONTEXT(ctx);
   2829    Node *n;
   2830    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2831    n = alloc_instruction(ctx, OPCODE_LIST_BASE, 1);
   2832    if (n) {
   2833       n[1].ui = base;
   2834    }
   2835    if (ctx->ExecuteFlag) {
   2836       CALL_ListBase(ctx->Exec, (base));
   2837    }
   2838 }
   2839 
   2840 
   2841 static void GLAPIENTRY
   2842 save_LoadIdentity(void)
   2843 {
   2844    GET_CURRENT_CONTEXT(ctx);
   2845    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2846    (void) alloc_instruction(ctx, OPCODE_LOAD_IDENTITY, 0);
   2847    if (ctx->ExecuteFlag) {
   2848       CALL_LoadIdentity(ctx->Exec, ());
   2849    }
   2850 }
   2851 
   2852 
   2853 static void GLAPIENTRY
   2854 save_LoadMatrixf(const GLfloat * m)
   2855 {
   2856    GET_CURRENT_CONTEXT(ctx);
   2857    Node *n;
   2858    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2859    n = alloc_instruction(ctx, OPCODE_LOAD_MATRIX, 16);
   2860    if (n) {
   2861       GLuint i;
   2862       for (i = 0; i < 16; i++) {
   2863          n[1 + i].f = m[i];
   2864       }
   2865    }
   2866    if (ctx->ExecuteFlag) {
   2867       CALL_LoadMatrixf(ctx->Exec, (m));
   2868    }
   2869 }
   2870 
   2871 
   2872 static void GLAPIENTRY
   2873 save_LoadMatrixd(const GLdouble * m)
   2874 {
   2875    GLfloat f[16];
   2876    GLint i;
   2877    for (i = 0; i < 16; i++) {
   2878       f[i] = (GLfloat) m[i];
   2879    }
   2880    save_LoadMatrixf(f);
   2881 }
   2882 
   2883 
   2884 static void GLAPIENTRY
   2885 save_LoadName(GLuint name)
   2886 {
   2887    GET_CURRENT_CONTEXT(ctx);
   2888    Node *n;
   2889    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2890    n = alloc_instruction(ctx, OPCODE_LOAD_NAME, 1);
   2891    if (n) {
   2892       n[1].ui = name;
   2893    }
   2894    if (ctx->ExecuteFlag) {
   2895       CALL_LoadName(ctx->Exec, (name));
   2896    }
   2897 }
   2898 
   2899 
   2900 static void GLAPIENTRY
   2901 save_LogicOp(GLenum opcode)
   2902 {
   2903    GET_CURRENT_CONTEXT(ctx);
   2904    Node *n;
   2905    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2906    n = alloc_instruction(ctx, OPCODE_LOGIC_OP, 1);
   2907    if (n) {
   2908       n[1].e = opcode;
   2909    }
   2910    if (ctx->ExecuteFlag) {
   2911       CALL_LogicOp(ctx->Exec, (opcode));
   2912    }
   2913 }
   2914 
   2915 
   2916 static void GLAPIENTRY
   2917 save_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
   2918            GLint order, const GLdouble * points)
   2919 {
   2920    GET_CURRENT_CONTEXT(ctx);
   2921    Node *n;
   2922    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2923    n = alloc_instruction(ctx, OPCODE_MAP1, 6);
   2924    if (n) {
   2925       GLfloat *pnts = _mesa_copy_map_points1d(target, stride, order, points);
   2926       n[1].e = target;
   2927       n[2].f = (GLfloat) u1;
   2928       n[3].f = (GLfloat) u2;
   2929       n[4].i = _mesa_evaluator_components(target);      /* stride */
   2930       n[5].i = order;
   2931       n[6].data = (void *) pnts;
   2932    }
   2933    if (ctx->ExecuteFlag) {
   2934       CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));
   2935    }
   2936 }
   2937 
   2938 static void GLAPIENTRY
   2939 save_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
   2940            GLint order, const GLfloat * points)
   2941 {
   2942    GET_CURRENT_CONTEXT(ctx);
   2943    Node *n;
   2944    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2945    n = alloc_instruction(ctx, OPCODE_MAP1, 6);
   2946    if (n) {
   2947       GLfloat *pnts = _mesa_copy_map_points1f(target, stride, order, points);
   2948       n[1].e = target;
   2949       n[2].f = u1;
   2950       n[3].f = u2;
   2951       n[4].i = _mesa_evaluator_components(target);      /* stride */
   2952       n[5].i = order;
   2953       n[6].data = (void *) pnts;
   2954    }
   2955    if (ctx->ExecuteFlag) {
   2956       CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));
   2957    }
   2958 }
   2959 
   2960 
   2961 static void GLAPIENTRY
   2962 save_Map2d(GLenum target,
   2963            GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
   2964            GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
   2965            const GLdouble * points)
   2966 {
   2967    GET_CURRENT_CONTEXT(ctx);
   2968    Node *n;
   2969    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   2970    n = alloc_instruction(ctx, OPCODE_MAP2, 10);
   2971    if (n) {
   2972       GLfloat *pnts = _mesa_copy_map_points2d(target, ustride, uorder,
   2973                                               vstride, vorder, points);
   2974       n[1].e = target;
   2975       n[2].f = (GLfloat) u1;
   2976       n[3].f = (GLfloat) u2;
   2977       n[4].f = (GLfloat) v1;
   2978       n[5].f = (GLfloat) v2;
   2979       /* XXX verify these strides are correct */
   2980       n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */
   2981       n[7].i = _mesa_evaluator_components(target);      /*vstride */
   2982       n[8].i = uorder;
   2983       n[9].i = vorder;
   2984       n[10].data = (void *) pnts;
   2985    }
   2986    if (ctx->ExecuteFlag) {
   2987       CALL_Map2d(ctx->Exec, (target,
   2988                              u1, u2, ustride, uorder,
   2989                              v1, v2, vstride, vorder, points));
   2990    }
   2991 }
   2992 
   2993 
   2994 static void GLAPIENTRY
   2995 save_Map2f(GLenum target,
   2996            GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
   2997            GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
   2998            const GLfloat * points)
   2999 {
   3000    GET_CURRENT_CONTEXT(ctx);
   3001    Node *n;
   3002    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3003    n = alloc_instruction(ctx, OPCODE_MAP2, 10);
   3004    if (n) {
   3005       GLfloat *pnts = _mesa_copy_map_points2f(target, ustride, uorder,
   3006                                               vstride, vorder, points);
   3007       n[1].e = target;
   3008       n[2].f = u1;
   3009       n[3].f = u2;
   3010       n[4].f = v1;
   3011       n[5].f = v2;
   3012       /* XXX verify these strides are correct */
   3013       n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */
   3014       n[7].i = _mesa_evaluator_components(target);      /*vstride */
   3015       n[8].i = uorder;
   3016       n[9].i = vorder;
   3017       n[10].data = (void *) pnts;
   3018    }
   3019    if (ctx->ExecuteFlag) {
   3020       CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
   3021                              v1, v2, vstride, vorder, points));
   3022    }
   3023 }
   3024 
   3025 
   3026 static void GLAPIENTRY
   3027 save_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
   3028 {
   3029    GET_CURRENT_CONTEXT(ctx);
   3030    Node *n;
   3031    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3032    n = alloc_instruction(ctx, OPCODE_MAPGRID1, 3);
   3033    if (n) {
   3034       n[1].i = un;
   3035       n[2].f = u1;
   3036       n[3].f = u2;
   3037    }
   3038    if (ctx->ExecuteFlag) {
   3039       CALL_MapGrid1f(ctx->Exec, (un, u1, u2));
   3040    }
   3041 }
   3042 
   3043 
   3044 static void GLAPIENTRY
   3045 save_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
   3046 {
   3047    save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
   3048 }
   3049 
   3050 
   3051 static void GLAPIENTRY
   3052 save_MapGrid2f(GLint un, GLfloat u1, GLfloat u2,
   3053                GLint vn, GLfloat v1, GLfloat v2)
   3054 {
   3055    GET_CURRENT_CONTEXT(ctx);
   3056    Node *n;
   3057    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3058    n = alloc_instruction(ctx, OPCODE_MAPGRID2, 6);
   3059    if (n) {
   3060       n[1].i = un;
   3061       n[2].f = u1;
   3062       n[3].f = u2;
   3063       n[4].i = vn;
   3064       n[5].f = v1;
   3065       n[6].f = v2;
   3066    }
   3067    if (ctx->ExecuteFlag) {
   3068       CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));
   3069    }
   3070 }
   3071 
   3072 
   3073 
   3074 static void GLAPIENTRY
   3075 save_MapGrid2d(GLint un, GLdouble u1, GLdouble u2,
   3076                GLint vn, GLdouble v1, GLdouble v2)
   3077 {
   3078    save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,
   3079                   vn, (GLfloat) v1, (GLfloat) v2);
   3080 }
   3081 
   3082 
   3083 static void GLAPIENTRY
   3084 save_MatrixMode(GLenum mode)
   3085 {
   3086    GET_CURRENT_CONTEXT(ctx);
   3087    Node *n;
   3088    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3089    n = alloc_instruction(ctx, OPCODE_MATRIX_MODE, 1);
   3090    if (n) {
   3091       n[1].e = mode;
   3092    }
   3093    if (ctx->ExecuteFlag) {
   3094       CALL_MatrixMode(ctx->Exec, (mode));
   3095    }
   3096 }
   3097 
   3098 
   3099 static void GLAPIENTRY
   3100 save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
   3101 {
   3102    GET_CURRENT_CONTEXT(ctx);
   3103    Node *n;
   3104 
   3105    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3106    n = alloc_instruction(ctx, OPCODE_MIN_MAX, 3);
   3107    if (n) {
   3108       n[1].e = target;
   3109       n[2].e = internalFormat;
   3110       n[3].b = sink;
   3111    }
   3112    if (ctx->ExecuteFlag) {
   3113       CALL_Minmax(ctx->Exec, (target, internalFormat, sink));
   3114    }
   3115 }
   3116 
   3117 
   3118 static void GLAPIENTRY
   3119 save_MultMatrixf(const GLfloat * m)
   3120 {
   3121    GET_CURRENT_CONTEXT(ctx);
   3122    Node *n;
   3123    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3124    n = alloc_instruction(ctx, OPCODE_MULT_MATRIX, 16);
   3125    if (n) {
   3126       GLuint i;
   3127       for (i = 0; i < 16; i++) {
   3128          n[1 + i].f = m[i];
   3129       }
   3130    }
   3131    if (ctx->ExecuteFlag) {
   3132       CALL_MultMatrixf(ctx->Exec, (m));
   3133    }
   3134 }
   3135 
   3136 
   3137 static void GLAPIENTRY
   3138 save_MultMatrixd(const GLdouble * m)
   3139 {
   3140    GLfloat f[16];
   3141    GLint i;
   3142    for (i = 0; i < 16; i++) {
   3143       f[i] = (GLfloat) m[i];
   3144    }
   3145    save_MultMatrixf(f);
   3146 }
   3147 
   3148 
   3149 static void GLAPIENTRY
   3150 save_NewList(GLuint name, GLenum mode)
   3151 {
   3152    GET_CURRENT_CONTEXT(ctx);
   3153    /* It's an error to call this function while building a display list */
   3154    _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
   3155    (void) name;
   3156    (void) mode;
   3157 }
   3158 
   3159 
   3160 
   3161 static void GLAPIENTRY
   3162 save_Ortho(GLdouble left, GLdouble right,
   3163            GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
   3164 {
   3165    GET_CURRENT_CONTEXT(ctx);
   3166    Node *n;
   3167    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3168    n = alloc_instruction(ctx, OPCODE_ORTHO, 6);
   3169    if (n) {
   3170       n[1].f = (GLfloat) left;
   3171       n[2].f = (GLfloat) right;
   3172       n[3].f = (GLfloat) bottom;
   3173       n[4].f = (GLfloat) top;
   3174       n[5].f = (GLfloat) nearval;
   3175       n[6].f = (GLfloat) farval;
   3176    }
   3177    if (ctx->ExecuteFlag) {
   3178       CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));
   3179    }
   3180 }
   3181 
   3182 
   3183 static void GLAPIENTRY
   3184 save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
   3185 {
   3186    GET_CURRENT_CONTEXT(ctx);
   3187    Node *n;
   3188    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3189    n = alloc_instruction(ctx, OPCODE_PIXEL_MAP, 3);
   3190    if (n) {
   3191       n[1].e = map;
   3192       n[2].i = mapsize;
   3193       n[3].data = (void *) malloc(mapsize * sizeof(GLfloat));
   3194       memcpy(n[3].data, (void *) values, mapsize * sizeof(GLfloat));
   3195    }
   3196    if (ctx->ExecuteFlag) {
   3197       CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));
   3198    }
   3199 }
   3200 
   3201 
   3202 static void GLAPIENTRY
   3203 save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
   3204 {
   3205    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
   3206    GLint i;
   3207    if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
   3208       for (i = 0; i < mapsize; i++) {
   3209          fvalues[i] = (GLfloat) values[i];
   3210       }
   3211    }
   3212    else {
   3213       for (i = 0; i < mapsize; i++) {
   3214          fvalues[i] = UINT_TO_FLOAT(values[i]);
   3215       }
   3216    }
   3217    save_PixelMapfv(map, mapsize, fvalues);
   3218 }
   3219 
   3220 
   3221 static void GLAPIENTRY
   3222 save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
   3223 {
   3224    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
   3225    GLint i;
   3226    if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
   3227       for (i = 0; i < mapsize; i++) {
   3228          fvalues[i] = (GLfloat) values[i];
   3229       }
   3230    }
   3231    else {
   3232       for (i = 0; i < mapsize; i++) {
   3233          fvalues[i] = USHORT_TO_FLOAT(values[i]);
   3234       }
   3235    }
   3236    save_PixelMapfv(map, mapsize, fvalues);
   3237 }
   3238 
   3239 
   3240 static void GLAPIENTRY
   3241 save_PixelTransferf(GLenum pname, GLfloat param)
   3242 {
   3243    GET_CURRENT_CONTEXT(ctx);
   3244    Node *n;
   3245    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3246    n = alloc_instruction(ctx, OPCODE_PIXEL_TRANSFER, 2);
   3247    if (n) {
   3248       n[1].e = pname;
   3249       n[2].f = param;
   3250    }
   3251    if (ctx->ExecuteFlag) {
   3252       CALL_PixelTransferf(ctx->Exec, (pname, param));
   3253    }
   3254 }
   3255 
   3256 
   3257 static void GLAPIENTRY
   3258 save_PixelTransferi(GLenum pname, GLint param)
   3259 {
   3260    save_PixelTransferf(pname, (GLfloat) param);
   3261 }
   3262 
   3263 
   3264 static void GLAPIENTRY
   3265 save_PixelZoom(GLfloat xfactor, GLfloat yfactor)
   3266 {
   3267    GET_CURRENT_CONTEXT(ctx);
   3268    Node *n;
   3269    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3270    n = alloc_instruction(ctx, OPCODE_PIXEL_ZOOM, 2);
   3271    if (n) {
   3272       n[1].f = xfactor;
   3273       n[2].f = yfactor;
   3274    }
   3275    if (ctx->ExecuteFlag) {
   3276       CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));
   3277    }
   3278 }
   3279 
   3280 
   3281 static void GLAPIENTRY
   3282 save_PointParameterfvEXT(GLenum pname, const GLfloat *params)
   3283 {
   3284    GET_CURRENT_CONTEXT(ctx);
   3285    Node *n;
   3286    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3287    n = alloc_instruction(ctx, OPCODE_POINT_PARAMETERS, 4);
   3288    if (n) {
   3289       n[1].e = pname;
   3290       n[2].f = params[0];
   3291       n[3].f = params[1];
   3292       n[4].f = params[2];
   3293    }
   3294    if (ctx->ExecuteFlag) {
   3295       CALL_PointParameterfvEXT(ctx->Exec, (pname, params));
   3296    }
   3297 }
   3298 
   3299 
   3300 static void GLAPIENTRY
   3301 save_PointParameterfEXT(GLenum pname, GLfloat param)
   3302 {
   3303    GLfloat parray[3];
   3304    parray[0] = param;
   3305    parray[1] = parray[2] = 0.0F;
   3306    save_PointParameterfvEXT(pname, parray);
   3307 }
   3308 
   3309 static void GLAPIENTRY
   3310 save_PointParameteriNV(GLenum pname, GLint param)
   3311 {
   3312    GLfloat parray[3];
   3313    parray[0] = (GLfloat) param;
   3314    parray[1] = parray[2] = 0.0F;
   3315    save_PointParameterfvEXT(pname, parray);
   3316 }
   3317 
   3318 static void GLAPIENTRY
   3319 save_PointParameterivNV(GLenum pname, const GLint * param)
   3320 {
   3321    GLfloat parray[3];
   3322    parray[0] = (GLfloat) param[0];
   3323    parray[1] = parray[2] = 0.0F;
   3324    save_PointParameterfvEXT(pname, parray);
   3325 }
   3326 
   3327 
   3328 static void GLAPIENTRY
   3329 save_PointSize(GLfloat size)
   3330 {
   3331    GET_CURRENT_CONTEXT(ctx);
   3332    Node *n;
   3333    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3334    n = alloc_instruction(ctx, OPCODE_POINT_SIZE, 1);
   3335    if (n) {
   3336       n[1].f = size;
   3337    }
   3338    if (ctx->ExecuteFlag) {
   3339       CALL_PointSize(ctx->Exec, (size));
   3340    }
   3341 }
   3342 
   3343 
   3344 static void GLAPIENTRY
   3345 save_PolygonMode(GLenum face, GLenum mode)
   3346 {
   3347    GET_CURRENT_CONTEXT(ctx);
   3348    Node *n;
   3349    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3350    n = alloc_instruction(ctx, OPCODE_POLYGON_MODE, 2);
   3351    if (n) {
   3352       n[1].e = face;
   3353       n[2].e = mode;
   3354    }
   3355    if (ctx->ExecuteFlag) {
   3356       CALL_PolygonMode(ctx->Exec, (face, mode));
   3357    }
   3358 }
   3359 
   3360 
   3361 static void GLAPIENTRY
   3362 save_PolygonStipple(const GLubyte * pattern)
   3363 {
   3364    GET_CURRENT_CONTEXT(ctx);
   3365    Node *n;
   3366 
   3367    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3368 
   3369    n = alloc_instruction(ctx, OPCODE_POLYGON_STIPPLE, 1);
   3370    if (n) {
   3371       n[1].data = unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
   3372                                pattern, &ctx->Unpack);
   3373    }
   3374    if (ctx->ExecuteFlag) {
   3375       CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
   3376    }
   3377 }
   3378 
   3379 
   3380 static void GLAPIENTRY
   3381 save_PolygonOffset(GLfloat factor, GLfloat units)
   3382 {
   3383    GET_CURRENT_CONTEXT(ctx);
   3384    Node *n;
   3385    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3386    n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET, 2);
   3387    if (n) {
   3388       n[1].f = factor;
   3389       n[2].f = units;
   3390    }
   3391    if (ctx->ExecuteFlag) {
   3392       CALL_PolygonOffset(ctx->Exec, (factor, units));
   3393    }
   3394 }
   3395 
   3396 
   3397 static void GLAPIENTRY
   3398 save_PolygonOffsetEXT(GLfloat factor, GLfloat bias)
   3399 {
   3400    GET_CURRENT_CONTEXT(ctx);
   3401    /* XXX mult by DepthMaxF here??? */
   3402    save_PolygonOffset(factor, ctx->DrawBuffer->_DepthMaxF * bias);
   3403 }
   3404 
   3405 
   3406 static void GLAPIENTRY
   3407 save_PopAttrib(void)
   3408 {
   3409    GET_CURRENT_CONTEXT(ctx);
   3410    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3411    (void) alloc_instruction(ctx, OPCODE_POP_ATTRIB, 0);
   3412    if (ctx->ExecuteFlag) {
   3413       CALL_PopAttrib(ctx->Exec, ());
   3414    }
   3415 }
   3416 
   3417 
   3418 static void GLAPIENTRY
   3419 save_PopMatrix(void)
   3420 {
   3421    GET_CURRENT_CONTEXT(ctx);
   3422    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3423    (void) alloc_instruction(ctx, OPCODE_POP_MATRIX, 0);
   3424    if (ctx->ExecuteFlag) {
   3425       CALL_PopMatrix(ctx->Exec, ());
   3426    }
   3427 }
   3428 
   3429 
   3430 static void GLAPIENTRY
   3431 save_PopName(void)
   3432 {
   3433    GET_CURRENT_CONTEXT(ctx);
   3434    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3435    (void) alloc_instruction(ctx, OPCODE_POP_NAME, 0);
   3436    if (ctx->ExecuteFlag) {
   3437       CALL_PopName(ctx->Exec, ());
   3438    }
   3439 }
   3440 
   3441 
   3442 static void GLAPIENTRY
   3443 save_PrioritizeTextures(GLsizei num, const GLuint * textures,
   3444                         const GLclampf * priorities)
   3445 {
   3446    GET_CURRENT_CONTEXT(ctx);
   3447    GLint i;
   3448    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3449 
   3450    for (i = 0; i < num; i++) {
   3451       Node *n;
   3452       n = alloc_instruction(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);
   3453       if (n) {
   3454          n[1].ui = textures[i];
   3455          n[2].f = priorities[i];
   3456       }
   3457    }
   3458    if (ctx->ExecuteFlag) {
   3459       CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));
   3460    }
   3461 }
   3462 
   3463 
   3464 static void GLAPIENTRY
   3465 save_PushAttrib(GLbitfield mask)
   3466 {
   3467    GET_CURRENT_CONTEXT(ctx);
   3468    Node *n;
   3469    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3470    n = alloc_instruction(ctx, OPCODE_PUSH_ATTRIB, 1);
   3471    if (n) {
   3472       n[1].bf = mask;
   3473    }
   3474    if (ctx->ExecuteFlag) {
   3475       CALL_PushAttrib(ctx->Exec, (mask));
   3476    }
   3477 }
   3478 
   3479 
   3480 static void GLAPIENTRY
   3481 save_PushMatrix(void)
   3482 {
   3483    GET_CURRENT_CONTEXT(ctx);
   3484    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3485    (void) alloc_instruction(ctx, OPCODE_PUSH_MATRIX, 0);
   3486    if (ctx->ExecuteFlag) {
   3487       CALL_PushMatrix(ctx->Exec, ());
   3488    }
   3489 }
   3490 
   3491 
   3492 static void GLAPIENTRY
   3493 save_PushName(GLuint name)
   3494 {
   3495    GET_CURRENT_CONTEXT(ctx);
   3496    Node *n;
   3497    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3498    n = alloc_instruction(ctx, OPCODE_PUSH_NAME, 1);
   3499    if (n) {
   3500       n[1].ui = name;
   3501    }
   3502    if (ctx->ExecuteFlag) {
   3503       CALL_PushName(ctx->Exec, (name));
   3504    }
   3505 }
   3506 
   3507 
   3508 static void GLAPIENTRY
   3509 save_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   3510 {
   3511    GET_CURRENT_CONTEXT(ctx);
   3512    Node *n;
   3513    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3514    n = alloc_instruction(ctx, OPCODE_RASTER_POS, 4);
   3515    if (n) {
   3516       n[1].f = x;
   3517       n[2].f = y;
   3518       n[3].f = z;
   3519       n[4].f = w;
   3520    }
   3521    if (ctx->ExecuteFlag) {
   3522       CALL_RasterPos4f(ctx->Exec, (x, y, z, w));
   3523    }
   3524 }
   3525 
   3526 static void GLAPIENTRY
   3527 save_RasterPos2d(GLdouble x, GLdouble y)
   3528 {
   3529    save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
   3530 }
   3531 
   3532 static void GLAPIENTRY
   3533 save_RasterPos2f(GLfloat x, GLfloat y)
   3534 {
   3535    save_RasterPos4f(x, y, 0.0F, 1.0F);
   3536 }
   3537 
   3538 static void GLAPIENTRY
   3539 save_RasterPos2i(GLint x, GLint y)
   3540 {
   3541    save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
   3542 }
   3543 
   3544 static void GLAPIENTRY
   3545 save_RasterPos2s(GLshort x, GLshort y)
   3546 {
   3547    save_RasterPos4f(x, y, 0.0F, 1.0F);
   3548 }
   3549 
   3550 static void GLAPIENTRY
   3551 save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
   3552 {
   3553    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
   3554 }
   3555 
   3556 static void GLAPIENTRY
   3557 save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
   3558 {
   3559    save_RasterPos4f(x, y, z, 1.0F);
   3560 }
   3561 
   3562 static void GLAPIENTRY
   3563 save_RasterPos3i(GLint x, GLint y, GLint z)
   3564 {
   3565    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
   3566 }
   3567 
   3568 static void GLAPIENTRY
   3569 save_RasterPos3s(GLshort x, GLshort y, GLshort z)
   3570 {
   3571    save_RasterPos4f(x, y, z, 1.0F);
   3572 }
   3573 
   3574 static void GLAPIENTRY
   3575 save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
   3576 {
   3577    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
   3578 }
   3579 
   3580 static void GLAPIENTRY
   3581 save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
   3582 {
   3583    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
   3584 }
   3585 
   3586 static void GLAPIENTRY
   3587 save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
   3588 {
   3589    save_RasterPos4f(x, y, z, w);
   3590 }
   3591 
   3592 static void GLAPIENTRY
   3593 save_RasterPos2dv(const GLdouble * v)
   3594 {
   3595    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
   3596 }
   3597 
   3598 static void GLAPIENTRY
   3599 save_RasterPos2fv(const GLfloat * v)
   3600 {
   3601    save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
   3602 }
   3603 
   3604 static void GLAPIENTRY
   3605 save_RasterPos2iv(const GLint * v)
   3606 {
   3607    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
   3608 }
   3609 
   3610 static void GLAPIENTRY
   3611 save_RasterPos2sv(const GLshort * v)
   3612 {
   3613    save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
   3614 }
   3615 
   3616 static void GLAPIENTRY
   3617 save_RasterPos3dv(const GLdouble * v)
   3618 {
   3619    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
   3620 }
   3621 
   3622 static void GLAPIENTRY
   3623 save_RasterPos3fv(const GLfloat * v)
   3624 {
   3625    save_RasterPos4f(v[0], v[1], v[2], 1.0F);
   3626 }
   3627 
   3628 static void GLAPIENTRY
   3629 save_RasterPos3iv(const GLint * v)
   3630 {
   3631    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
   3632 }
   3633 
   3634 static void GLAPIENTRY
   3635 save_RasterPos3sv(const GLshort * v)
   3636 {
   3637    save_RasterPos4f(v[0], v[1], v[2], 1.0F);
   3638 }
   3639 
   3640 static void GLAPIENTRY
   3641 save_RasterPos4dv(const GLdouble * v)
   3642 {
   3643    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
   3644                     (GLfloat) v[2], (GLfloat) v[3]);
   3645 }
   3646 
   3647 static void GLAPIENTRY
   3648 save_RasterPos4fv(const GLfloat * v)
   3649 {
   3650    save_RasterPos4f(v[0], v[1], v[2], v[3]);
   3651 }
   3652 
   3653 static void GLAPIENTRY
   3654 save_RasterPos4iv(const GLint * v)
   3655 {
   3656    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
   3657                     (GLfloat) v[2], (GLfloat) v[3]);
   3658 }
   3659 
   3660 static void GLAPIENTRY
   3661 save_RasterPos4sv(const GLshort * v)
   3662 {
   3663    save_RasterPos4f(v[0], v[1], v[2], v[3]);
   3664 }
   3665 
   3666 
   3667 static void GLAPIENTRY
   3668 save_PassThrough(GLfloat token)
   3669 {
   3670    GET_CURRENT_CONTEXT(ctx);
   3671    Node *n;
   3672    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3673    n = alloc_instruction(ctx, OPCODE_PASSTHROUGH, 1);
   3674    if (n) {
   3675       n[1].f = token;
   3676    }
   3677    if (ctx->ExecuteFlag) {
   3678       CALL_PassThrough(ctx->Exec, (token));
   3679    }
   3680 }
   3681 
   3682 
   3683 static void GLAPIENTRY
   3684 save_ReadBuffer(GLenum mode)
   3685 {
   3686    GET_CURRENT_CONTEXT(ctx);
   3687    Node *n;
   3688    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3689    n = alloc_instruction(ctx, OPCODE_READ_BUFFER, 1);
   3690    if (n) {
   3691       n[1].e = mode;
   3692    }
   3693    if (ctx->ExecuteFlag) {
   3694       CALL_ReadBuffer(ctx->Exec, (mode));
   3695    }
   3696 }
   3697 
   3698 
   3699 static void GLAPIENTRY
   3700 save_ResetHistogram(GLenum target)
   3701 {
   3702    GET_CURRENT_CONTEXT(ctx);
   3703    Node *n;
   3704    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3705    n = alloc_instruction(ctx, OPCODE_RESET_HISTOGRAM, 1);
   3706    if (n) {
   3707       n[1].e = target;
   3708    }
   3709    if (ctx->ExecuteFlag) {
   3710       CALL_ResetHistogram(ctx->Exec, (target));
   3711    }
   3712 }
   3713 
   3714 
   3715 static void GLAPIENTRY
   3716 save_ResetMinmax(GLenum target)
   3717 {
   3718    GET_CURRENT_CONTEXT(ctx);
   3719    Node *n;
   3720    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3721    n = alloc_instruction(ctx, OPCODE_RESET_MIN_MAX, 1);
   3722    if (n) {
   3723       n[1].e = target;
   3724    }
   3725    if (ctx->ExecuteFlag) {
   3726       CALL_ResetMinmax(ctx->Exec, (target));
   3727    }
   3728 }
   3729 
   3730 
   3731 static void GLAPIENTRY
   3732 save_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
   3733 {
   3734    GET_CURRENT_CONTEXT(ctx);
   3735    Node *n;
   3736    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3737    n = alloc_instruction(ctx, OPCODE_ROTATE, 4);
   3738    if (n) {
   3739       n[1].f = angle;
   3740       n[2].f = x;
   3741       n[3].f = y;
   3742       n[4].f = z;
   3743    }
   3744    if (ctx->ExecuteFlag) {
   3745       CALL_Rotatef(ctx->Exec, (angle, x, y, z));
   3746    }
   3747 }
   3748 
   3749 
   3750 static void GLAPIENTRY
   3751 save_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
   3752 {
   3753    save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
   3754 }
   3755 
   3756 
   3757 static void GLAPIENTRY
   3758 save_Scalef(GLfloat x, GLfloat y, GLfloat z)
   3759 {
   3760    GET_CURRENT_CONTEXT(ctx);
   3761    Node *n;
   3762    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3763    n = alloc_instruction(ctx, OPCODE_SCALE, 3);
   3764    if (n) {
   3765       n[1].f = x;
   3766       n[2].f = y;
   3767       n[3].f = z;
   3768    }
   3769    if (ctx->ExecuteFlag) {
   3770       CALL_Scalef(ctx->Exec, (x, y, z));
   3771    }
   3772 }
   3773 
   3774 
   3775 static void GLAPIENTRY
   3776 save_Scaled(GLdouble x, GLdouble y, GLdouble z)
   3777 {
   3778    save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
   3779 }
   3780 
   3781 
   3782 static void GLAPIENTRY
   3783 save_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
   3784 {
   3785    GET_CURRENT_CONTEXT(ctx);
   3786    Node *n;
   3787    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3788    n = alloc_instruction(ctx, OPCODE_SCISSOR, 4);
   3789    if (n) {
   3790       n[1].i = x;
   3791       n[2].i = y;
   3792       n[3].i = width;
   3793       n[4].i = height;
   3794    }
   3795    if (ctx->ExecuteFlag) {
   3796       CALL_Scissor(ctx->Exec, (x, y, width, height));
   3797    }
   3798 }
   3799 
   3800 
   3801 static void GLAPIENTRY
   3802 save_ShadeModel(GLenum mode)
   3803 {
   3804    GET_CURRENT_CONTEXT(ctx);
   3805    Node *n;
   3806    ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);
   3807 
   3808    if (ctx->ExecuteFlag) {
   3809       CALL_ShadeModel(ctx->Exec, (mode));
   3810    }
   3811 
   3812    if (ctx->ListState.Current.ShadeModel == mode)
   3813       return;
   3814 
   3815    SAVE_FLUSH_VERTICES(ctx);
   3816 
   3817    /* Only save the value if we know the statechange will take effect:
   3818     */
   3819    if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)
   3820       ctx->ListState.Current.ShadeModel = mode;
   3821 
   3822    n = alloc_instruction(ctx, OPCODE_SHADE_MODEL, 1);
   3823    if (n) {
   3824       n[1].e = mode;
   3825    }
   3826 }
   3827 
   3828 
   3829 static void GLAPIENTRY
   3830 save_StencilFunc(GLenum func, GLint ref, GLuint mask)
   3831 {
   3832    GET_CURRENT_CONTEXT(ctx);
   3833    Node *n;
   3834    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3835    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC, 3);
   3836    if (n) {
   3837       n[1].e = func;
   3838       n[2].i = ref;
   3839       n[3].ui = mask;
   3840    }
   3841    if (ctx->ExecuteFlag) {
   3842       CALL_StencilFunc(ctx->Exec, (func, ref, mask));
   3843    }
   3844 }
   3845 
   3846 
   3847 static void GLAPIENTRY
   3848 save_StencilMask(GLuint mask)
   3849 {
   3850    GET_CURRENT_CONTEXT(ctx);
   3851    Node *n;
   3852    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3853    n = alloc_instruction(ctx, OPCODE_STENCIL_MASK, 1);
   3854    if (n) {
   3855       n[1].ui = mask;
   3856    }
   3857    if (ctx->ExecuteFlag) {
   3858       CALL_StencilMask(ctx->Exec, (mask));
   3859    }
   3860 }
   3861 
   3862 
   3863 static void GLAPIENTRY
   3864 save_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
   3865 {
   3866    GET_CURRENT_CONTEXT(ctx);
   3867    Node *n;
   3868    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3869    n = alloc_instruction(ctx, OPCODE_STENCIL_OP, 3);
   3870    if (n) {
   3871       n[1].e = fail;
   3872       n[2].e = zfail;
   3873       n[3].e = zpass;
   3874    }
   3875    if (ctx->ExecuteFlag) {
   3876       CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));
   3877    }
   3878 }
   3879 
   3880 
   3881 static void GLAPIENTRY
   3882 save_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
   3883 {
   3884    GET_CURRENT_CONTEXT(ctx);
   3885    Node *n;
   3886    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3887    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
   3888    if (n) {
   3889       n[1].e = face;
   3890       n[2].e = func;
   3891       n[3].i = ref;
   3892       n[4].ui = mask;
   3893    }
   3894    if (ctx->ExecuteFlag) {
   3895       CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
   3896    }
   3897 }
   3898 
   3899 
   3900 static void GLAPIENTRY
   3901 save_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref,
   3902                             GLuint mask)
   3903 {
   3904    GET_CURRENT_CONTEXT(ctx);
   3905    Node *n;
   3906    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3907    /* GL_FRONT */
   3908    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
   3909    if (n) {
   3910       n[1].e = GL_FRONT;
   3911       n[2].e = frontfunc;
   3912       n[3].i = ref;
   3913       n[4].ui = mask;
   3914    }
   3915    /* GL_BACK */
   3916    n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
   3917    if (n) {
   3918       n[1].e = GL_BACK;
   3919       n[2].e = backfunc;
   3920       n[3].i = ref;
   3921       n[4].ui = mask;
   3922    }
   3923    if (ctx->ExecuteFlag) {
   3924       CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));
   3925       CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));
   3926    }
   3927 }
   3928 
   3929 
   3930 static void GLAPIENTRY
   3931 save_StencilMaskSeparate(GLenum face, GLuint mask)
   3932 {
   3933    GET_CURRENT_CONTEXT(ctx);
   3934    Node *n;
   3935    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3936    n = alloc_instruction(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);
   3937    if (n) {
   3938       n[1].e = face;
   3939       n[2].ui = mask;
   3940    }
   3941    if (ctx->ExecuteFlag) {
   3942       CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
   3943    }
   3944 }
   3945 
   3946 
   3947 static void GLAPIENTRY
   3948 save_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
   3949 {
   3950    GET_CURRENT_CONTEXT(ctx);
   3951    Node *n;
   3952    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3953    n = alloc_instruction(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);
   3954    if (n) {
   3955       n[1].e = face;
   3956       n[2].e = fail;
   3957       n[3].e = zfail;
   3958       n[4].e = zpass;
   3959    }
   3960    if (ctx->ExecuteFlag) {
   3961       CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
   3962    }
   3963 }
   3964 
   3965 
   3966 static void GLAPIENTRY
   3967 save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
   3968 {
   3969    GET_CURRENT_CONTEXT(ctx);
   3970    Node *n;
   3971    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   3972    n = alloc_instruction(ctx, OPCODE_TEXENV, 6);
   3973    if (n) {
   3974       n[1].e = target;
   3975       n[2].e = pname;
   3976       if (pname == GL_TEXTURE_ENV_COLOR) {
   3977          n[3].f = params[0];
   3978          n[4].f = params[1];
   3979          n[5].f = params[2];
   3980          n[6].f = params[3];
   3981       }
   3982       else {
   3983          n[3].f = params[0];
   3984          n[4].f = n[5].f = n[6].f = 0.0F;
   3985       }
   3986    }
   3987    if (ctx->ExecuteFlag) {
   3988       CALL_TexEnvfv(ctx->Exec, (target, pname, params));
   3989    }
   3990 }
   3991 
   3992 
   3993 static void GLAPIENTRY
   3994 save_TexEnvf(GLenum target, GLenum pname, GLfloat param)
   3995 {
   3996    GLfloat parray[4];
   3997    parray[0] = (GLfloat) param;
   3998    parray[1] = parray[2] = parray[3] = 0.0F;
   3999    save_TexEnvfv(target, pname, parray);
   4000 }
   4001 
   4002 
   4003 static void GLAPIENTRY
   4004 save_TexEnvi(GLenum target, GLenum pname, GLint param)
   4005 {
   4006    GLfloat p[4];
   4007    p[0] = (GLfloat) param;
   4008    p[1] = p[2] = p[3] = 0.0F;
   4009    save_TexEnvfv(target, pname, p);
   4010 }
   4011 
   4012 
   4013 static void GLAPIENTRY
   4014 save_TexEnviv(GLenum target, GLenum pname, const GLint * param)
   4015 {
   4016    GLfloat p[4];
   4017    if (pname == GL_TEXTURE_ENV_COLOR) {
   4018       p[0] = INT_TO_FLOAT(param[0]);
   4019       p[1] = INT_TO_FLOAT(param[1]);
   4020       p[2] = INT_TO_FLOAT(param[2]);
   4021       p[3] = INT_TO_FLOAT(param[3]);
   4022    }
   4023    else {
   4024       p[0] = (GLfloat) param[0];
   4025       p[1] = p[2] = p[3] = 0.0F;
   4026    }
   4027    save_TexEnvfv(target, pname, p);
   4028 }
   4029 
   4030 
   4031 static void GLAPIENTRY
   4032 save_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
   4033 {
   4034    GET_CURRENT_CONTEXT(ctx);
   4035    Node *n;
   4036    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4037    n = alloc_instruction(ctx, OPCODE_TEXGEN, 6);
   4038    if (n) {
   4039       n[1].e = coord;
   4040       n[2].e = pname;
   4041       n[3].f = params[0];
   4042       n[4].f = params[1];
   4043       n[5].f = params[2];
   4044       n[6].f = params[3];
   4045    }
   4046    if (ctx->ExecuteFlag) {
   4047       CALL_TexGenfv(ctx->Exec, (coord, pname, params));
   4048    }
   4049 }
   4050 
   4051 
   4052 static void GLAPIENTRY
   4053 save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
   4054 {
   4055    GLfloat p[4];
   4056    p[0] = (GLfloat) params[0];
   4057    p[1] = (GLfloat) params[1];
   4058    p[2] = (GLfloat) params[2];
   4059    p[3] = (GLfloat) params[3];
   4060    save_TexGenfv(coord, pname, p);
   4061 }
   4062 
   4063 
   4064 static void GLAPIENTRY
   4065 save_TexGend(GLenum coord, GLenum pname, GLdouble param)
   4066 {
   4067    GLfloat parray[4];
   4068    parray[0] = (GLfloat) param;
   4069    parray[1] = parray[2] = parray[3] = 0.0F;
   4070    save_TexGenfv(coord, pname, parray);
   4071 }
   4072 
   4073 
   4074 static void GLAPIENTRY
   4075 save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
   4076 {
   4077    GLfloat p[4];
   4078    p[0] = (GLfloat) params[0];
   4079    p[1] = (GLfloat) params[1];
   4080    p[2] = (GLfloat) params[2];
   4081    p[3] = (GLfloat) params[3];
   4082    save_TexGenfv(coord, pname, p);
   4083 }
   4084 
   4085 
   4086 static void GLAPIENTRY
   4087 save_TexGenf(GLenum coord, GLenum pname, GLfloat param)
   4088 {
   4089    GLfloat parray[4];
   4090    parray[0] = param;
   4091    parray[1] = parray[2] = parray[3] = 0.0F;
   4092    save_TexGenfv(coord, pname, parray);
   4093 }
   4094 
   4095 
   4096 static void GLAPIENTRY
   4097 save_TexGeni(GLenum coord, GLenum pname, GLint param)
   4098 {
   4099    GLint parray[4];
   4100    parray[0] = param;
   4101    parray[1] = parray[2] = parray[3] = 0;
   4102    save_TexGeniv(coord, pname, parray);
   4103 }
   4104 
   4105 
   4106 static void GLAPIENTRY
   4107 save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
   4108 {
   4109    GET_CURRENT_CONTEXT(ctx);
   4110    Node *n;
   4111    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4112    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER, 6);
   4113    if (n) {
   4114       n[1].e = target;
   4115       n[2].e = pname;
   4116       n[3].f = params[0];
   4117       n[4].f = params[1];
   4118       n[5].f = params[2];
   4119       n[6].f = params[3];
   4120    }
   4121    if (ctx->ExecuteFlag) {
   4122       CALL_TexParameterfv(ctx->Exec, (target, pname, params));
   4123    }
   4124 }
   4125 
   4126 
   4127 static void GLAPIENTRY
   4128 save_TexParameterf(GLenum target, GLenum pname, GLfloat param)
   4129 {
   4130    GLfloat parray[4];
   4131    parray[0] = param;
   4132    parray[1] = parray[2] = parray[3] = 0.0F;
   4133    save_TexParameterfv(target, pname, parray);
   4134 }
   4135 
   4136 
   4137 static void GLAPIENTRY
   4138 save_TexParameteri(GLenum target, GLenum pname, GLint param)
   4139 {
   4140    GLfloat fparam[4];
   4141    fparam[0] = (GLfloat) param;
   4142    fparam[1] = fparam[2] = fparam[3] = 0.0F;
   4143    save_TexParameterfv(target, pname, fparam);
   4144 }
   4145 
   4146 
   4147 static void GLAPIENTRY
   4148 save_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
   4149 {
   4150    GLfloat fparam[4];
   4151    fparam[0] = (GLfloat) params[0];
   4152    fparam[1] = fparam[2] = fparam[3] = 0.0F;
   4153    save_TexParameterfv(target, pname, fparam);
   4154 }
   4155 
   4156 
   4157 static void GLAPIENTRY
   4158 save_TexImage1D(GLenum target,
   4159                 GLint level, GLint components,
   4160                 GLsizei width, GLint border,
   4161                 GLenum format, GLenum type, const GLvoid * pixels)
   4162 {
   4163    GET_CURRENT_CONTEXT(ctx);
   4164    if (target == GL_PROXY_TEXTURE_1D) {
   4165       /* don't compile, execute immediately */
   4166       CALL_TexImage1D(ctx->Exec, (target, level, components, width,
   4167                                   border, format, type, pixels));
   4168    }
   4169    else {
   4170       Node *n;
   4171       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4172       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE1D, 8);
   4173       if (n) {
   4174          n[1].e = target;
   4175          n[2].i = level;
   4176          n[3].i = components;
   4177          n[4].i = (GLint) width;
   4178          n[5].i = border;
   4179          n[6].e = format;
   4180          n[7].e = type;
   4181          n[8].data = unpack_image(ctx, 1, width, 1, 1, format, type,
   4182                                   pixels, &ctx->Unpack);
   4183       }
   4184       if (ctx->ExecuteFlag) {
   4185          CALL_TexImage1D(ctx->Exec, (target, level, components, width,
   4186                                      border, format, type, pixels));
   4187       }
   4188    }
   4189 }
   4190 
   4191 
   4192 static void GLAPIENTRY
   4193 save_TexImage2D(GLenum target,
   4194                 GLint level, GLint components,
   4195                 GLsizei width, GLsizei height, GLint border,
   4196                 GLenum format, GLenum type, const GLvoid * pixels)
   4197 {
   4198    GET_CURRENT_CONTEXT(ctx);
   4199    if (target == GL_PROXY_TEXTURE_2D) {
   4200       /* don't compile, execute immediately */
   4201       CALL_TexImage2D(ctx->Exec, (target, level, components, width,
   4202                                   height, border, format, type, pixels));
   4203    }
   4204    else {
   4205       Node *n;
   4206       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4207       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE2D, 9);
   4208       if (n) {
   4209          n[1].e = target;
   4210          n[2].i = level;
   4211          n[3].i = components;
   4212          n[4].i = (GLint) width;
   4213          n[5].i = (GLint) height;
   4214          n[6].i = border;
   4215          n[7].e = format;
   4216          n[8].e = type;
   4217          n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
   4218                                   pixels, &ctx->Unpack);
   4219       }
   4220       if (ctx->ExecuteFlag) {
   4221          CALL_TexImage2D(ctx->Exec, (target, level, components, width,
   4222                                      height, border, format, type, pixels));
   4223       }
   4224    }
   4225 }
   4226 
   4227 
   4228 static void GLAPIENTRY
   4229 save_TexImage3D(GLenum target,
   4230                 GLint level, GLint internalFormat,
   4231                 GLsizei width, GLsizei height, GLsizei depth,
   4232                 GLint border,
   4233                 GLenum format, GLenum type, const GLvoid * pixels)
   4234 {
   4235    GET_CURRENT_CONTEXT(ctx);
   4236    if (target == GL_PROXY_TEXTURE_3D) {
   4237       /* don't compile, execute immediately */
   4238       CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
   4239                                   height, depth, border, format, type,
   4240                                   pixels));
   4241    }
   4242    else {
   4243       Node *n;
   4244       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4245       n = alloc_instruction(ctx, OPCODE_TEX_IMAGE3D, 10);
   4246       if (n) {
   4247          n[1].e = target;
   4248          n[2].i = level;
   4249          n[3].i = (GLint) internalFormat;
   4250          n[4].i = (GLint) width;
   4251          n[5].i = (GLint) height;
   4252          n[6].i = (GLint) depth;
   4253          n[7].i = border;
   4254          n[8].e = format;
   4255          n[9].e = type;
   4256          n[10].data = unpack_image(ctx, 3, width, height, depth, format, type,
   4257                                    pixels, &ctx->Unpack);
   4258       }
   4259       if (ctx->ExecuteFlag) {
   4260          CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
   4261                                      height, depth, border, format, type,
   4262                                      pixels));
   4263       }
   4264    }
   4265 }
   4266 
   4267 
   4268 static void GLAPIENTRY
   4269 save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
   4270                    GLsizei width, GLenum format, GLenum type,
   4271                    const GLvoid * pixels)
   4272 {
   4273    GET_CURRENT_CONTEXT(ctx);
   4274    Node *n;
   4275 
   4276    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4277 
   4278    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE1D, 7);
   4279    if (n) {
   4280       n[1].e = target;
   4281       n[2].i = level;
   4282       n[3].i = xoffset;
   4283       n[4].i = (GLint) width;
   4284       n[5].e = format;
   4285       n[6].e = type;
   4286       n[7].data = unpack_image(ctx, 1, width, 1, 1, format, type,
   4287                                pixels, &ctx->Unpack);
   4288    }
   4289    if (ctx->ExecuteFlag) {
   4290       CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
   4291                                      format, type, pixels));
   4292    }
   4293 }
   4294 
   4295 
   4296 static void GLAPIENTRY
   4297 save_TexSubImage2D(GLenum target, GLint level,
   4298                    GLint xoffset, GLint yoffset,
   4299                    GLsizei width, GLsizei height,
   4300                    GLenum format, GLenum type, const GLvoid * pixels)
   4301 {
   4302    GET_CURRENT_CONTEXT(ctx);
   4303    Node *n;
   4304 
   4305    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4306 
   4307    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE2D, 9);
   4308    if (n) {
   4309       n[1].e = target;
   4310       n[2].i = level;
   4311       n[3].i = xoffset;
   4312       n[4].i = yoffset;
   4313       n[5].i = (GLint) width;
   4314       n[6].i = (GLint) height;
   4315       n[7].e = format;
   4316       n[8].e = type;
   4317       n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
   4318                                pixels, &ctx->Unpack);
   4319    }
   4320    if (ctx->ExecuteFlag) {
   4321       CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
   4322                                      width, height, format, type, pixels));
   4323    }
   4324 }
   4325 
   4326 
   4327 static void GLAPIENTRY
   4328 save_TexSubImage3D(GLenum target, GLint level,
   4329                    GLint xoffset, GLint yoffset, GLint zoffset,
   4330                    GLsizei width, GLsizei height, GLsizei depth,
   4331                    GLenum format, GLenum type, const GLvoid * pixels)
   4332 {
   4333    GET_CURRENT_CONTEXT(ctx);
   4334    Node *n;
   4335 
   4336    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4337 
   4338    n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE3D, 11);
   4339    if (n) {
   4340       n[1].e = target;
   4341       n[2].i = level;
   4342       n[3].i = xoffset;
   4343       n[4].i = yoffset;
   4344       n[5].i = zoffset;
   4345       n[6].i = (GLint) width;
   4346       n[7].i = (GLint) height;
   4347       n[8].i = (GLint) depth;
   4348       n[9].e = format;
   4349       n[10].e = type;
   4350       n[11].data = unpack_image(ctx, 3, width, height, depth, format, type,
   4351                                 pixels, &ctx->Unpack);
   4352    }
   4353    if (ctx->ExecuteFlag) {
   4354       CALL_TexSubImage3D(ctx->Exec, (target, level,
   4355                                      xoffset, yoffset, zoffset,
   4356                                      width, height, depth, format, type,
   4357                                      pixels));
   4358    }
   4359 }
   4360 
   4361 
   4362 static void GLAPIENTRY
   4363 save_Translatef(GLfloat x, GLfloat y, GLfloat z)
   4364 {
   4365    GET_CURRENT_CONTEXT(ctx);
   4366    Node *n;
   4367    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4368    n = alloc_instruction(ctx, OPCODE_TRANSLATE, 3);
   4369    if (n) {
   4370       n[1].f = x;
   4371       n[2].f = y;
   4372       n[3].f = z;
   4373    }
   4374    if (ctx->ExecuteFlag) {
   4375       CALL_Translatef(ctx->Exec, (x, y, z));
   4376    }
   4377 }
   4378 
   4379 
   4380 static void GLAPIENTRY
   4381 save_Translated(GLdouble x, GLdouble y, GLdouble z)
   4382 {
   4383    save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
   4384 }
   4385 
   4386 
   4387 
   4388 static void GLAPIENTRY
   4389 save_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
   4390 {
   4391    GET_CURRENT_CONTEXT(ctx);
   4392    Node *n;
   4393    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4394    n = alloc_instruction(ctx, OPCODE_VIEWPORT, 4);
   4395    if (n) {
   4396       n[1].i = x;
   4397       n[2].i = y;
   4398       n[3].i = (GLint) width;
   4399       n[4].i = (GLint) height;
   4400    }
   4401    if (ctx->ExecuteFlag) {
   4402       CALL_Viewport(ctx->Exec, (x, y, width, height));
   4403    }
   4404 }
   4405 
   4406 
   4407 static void GLAPIENTRY
   4408 save_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   4409 {
   4410    GET_CURRENT_CONTEXT(ctx);
   4411    Node *n;
   4412    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4413    n = alloc_instruction(ctx, OPCODE_WINDOW_POS, 4);
   4414    if (n) {
   4415       n[1].f = x;
   4416       n[2].f = y;
   4417       n[3].f = z;
   4418       n[4].f = w;
   4419    }
   4420    if (ctx->ExecuteFlag) {
   4421       CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));
   4422    }
   4423 }
   4424 
   4425 static void GLAPIENTRY
   4426 save_WindowPos2dMESA(GLdouble x, GLdouble y)
   4427 {
   4428    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
   4429 }
   4430 
   4431 static void GLAPIENTRY
   4432 save_WindowPos2fMESA(GLfloat x, GLfloat y)
   4433 {
   4434    save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
   4435 }
   4436 
   4437 static void GLAPIENTRY
   4438 save_WindowPos2iMESA(GLint x, GLint y)
   4439 {
   4440    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
   4441 }
   4442 
   4443 static void GLAPIENTRY
   4444 save_WindowPos2sMESA(GLshort x, GLshort y)
   4445 {
   4446    save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
   4447 }
   4448 
   4449 static void GLAPIENTRY
   4450 save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
   4451 {
   4452    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
   4453 }
   4454 
   4455 static void GLAPIENTRY
   4456 save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
   4457 {
   4458    save_WindowPos4fMESA(x, y, z, 1.0F);
   4459 }
   4460 
   4461 static void GLAPIENTRY
   4462 save_WindowPos3iMESA(GLint x, GLint y, GLint z)
   4463 {
   4464    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
   4465 }
   4466 
   4467 static void GLAPIENTRY
   4468 save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
   4469 {
   4470    save_WindowPos4fMESA(x, y, z, 1.0F);
   4471 }
   4472 
   4473 static void GLAPIENTRY
   4474 save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
   4475 {
   4476    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
   4477 }
   4478 
   4479 static void GLAPIENTRY
   4480 save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
   4481 {
   4482    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
   4483 }
   4484 
   4485 static void GLAPIENTRY
   4486 save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
   4487 {
   4488    save_WindowPos4fMESA(x, y, z, w);
   4489 }
   4490 
   4491 static void GLAPIENTRY
   4492 save_WindowPos2dvMESA(const GLdouble * v)
   4493 {
   4494    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
   4495 }
   4496 
   4497 static void GLAPIENTRY
   4498 save_WindowPos2fvMESA(const GLfloat * v)
   4499 {
   4500    save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
   4501 }
   4502 
   4503 static void GLAPIENTRY
   4504 save_WindowPos2ivMESA(const GLint * v)
   4505 {
   4506    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
   4507 }
   4508 
   4509 static void GLAPIENTRY
   4510 save_WindowPos2svMESA(const GLshort * v)
   4511 {
   4512    save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
   4513 }
   4514 
   4515 static void GLAPIENTRY
   4516 save_WindowPos3dvMESA(const GLdouble * v)
   4517 {
   4518    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
   4519 }
   4520 
   4521 static void GLAPIENTRY
   4522 save_WindowPos3fvMESA(const GLfloat * v)
   4523 {
   4524    save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
   4525 }
   4526 
   4527 static void GLAPIENTRY
   4528 save_WindowPos3ivMESA(const GLint * v)
   4529 {
   4530    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
   4531 }
   4532 
   4533 static void GLAPIENTRY
   4534 save_WindowPos3svMESA(const GLshort * v)
   4535 {
   4536    save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
   4537 }
   4538 
   4539 static void GLAPIENTRY
   4540 save_WindowPos4dvMESA(const GLdouble * v)
   4541 {
   4542    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
   4543                         (GLfloat) v[2], (GLfloat) v[3]);
   4544 }
   4545 
   4546 static void GLAPIENTRY
   4547 save_WindowPos4fvMESA(const GLfloat * v)
   4548 {
   4549    save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
   4550 }
   4551 
   4552 static void GLAPIENTRY
   4553 save_WindowPos4ivMESA(const GLint * v)
   4554 {
   4555    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
   4556                         (GLfloat) v[2], (GLfloat) v[3]);
   4557 }
   4558 
   4559 static void GLAPIENTRY
   4560 save_WindowPos4svMESA(const GLshort * v)
   4561 {
   4562    save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
   4563 }
   4564 
   4565 
   4566 
   4567 /* GL_ARB_multitexture */
   4568 static void GLAPIENTRY
   4569 save_ActiveTextureARB(GLenum target)
   4570 {
   4571    GET_CURRENT_CONTEXT(ctx);
   4572    Node *n;
   4573    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4574    n = alloc_instruction(ctx, OPCODE_ACTIVE_TEXTURE, 1);
   4575    if (n) {
   4576       n[1].e = target;
   4577    }
   4578    if (ctx->ExecuteFlag) {
   4579       CALL_ActiveTextureARB(ctx->Exec, (target));
   4580    }
   4581 }
   4582 
   4583 
   4584 /* GL_ARB_transpose_matrix */
   4585 
   4586 static void GLAPIENTRY
   4587 save_LoadTransposeMatrixdARB(const GLdouble m[16])
   4588 {
   4589    GLfloat tm[16];
   4590    _math_transposefd(tm, m);
   4591    save_LoadMatrixf(tm);
   4592 }
   4593 
   4594 
   4595 static void GLAPIENTRY
   4596 save_LoadTransposeMatrixfARB(const GLfloat m[16])
   4597 {
   4598    GLfloat tm[16];
   4599    _math_transposef(tm, m);
   4600    save_LoadMatrixf(tm);
   4601 }
   4602 
   4603 
   4604 static void GLAPIENTRY
   4605 save_MultTransposeMatrixdARB(const GLdouble m[16])
   4606 {
   4607    GLfloat tm[16];
   4608    _math_transposefd(tm, m);
   4609    save_MultMatrixf(tm);
   4610 }
   4611 
   4612 
   4613 static void GLAPIENTRY
   4614 save_MultTransposeMatrixfARB(const GLfloat m[16])
   4615 {
   4616    GLfloat tm[16];
   4617    _math_transposef(tm, m);
   4618    save_MultMatrixf(tm);
   4619 }
   4620 
   4621 static GLvoid *copy_data(const GLvoid *data, GLsizei size, const char *func)
   4622 {
   4623    GET_CURRENT_CONTEXT(ctx);
   4624    GLvoid *image;
   4625 
   4626    if (!data)
   4627       return NULL;
   4628 
   4629    image = malloc(size);
   4630    if (!image) {
   4631       _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
   4632       return NULL;
   4633    }
   4634    memcpy(image, data, size);
   4635 
   4636    return image;
   4637 }
   4638 
   4639 
   4640 /* GL_ARB_texture_compression */
   4641 static void GLAPIENTRY
   4642 save_CompressedTexImage1DARB(GLenum target, GLint level,
   4643                              GLenum internalFormat, GLsizei width,
   4644                              GLint border, GLsizei imageSize,
   4645                              const GLvoid * data)
   4646 {
   4647    GET_CURRENT_CONTEXT(ctx);
   4648    if (target == GL_PROXY_TEXTURE_1D) {
   4649       /* don't compile, execute immediately */
   4650       CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,
   4651                                                width, border, imageSize,
   4652                                                data));
   4653    }
   4654    else {
   4655       Node *n;
   4656       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4657 
   4658       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7);
   4659       if (n) {
   4660          n[1].e = target;
   4661          n[2].i = level;
   4662          n[3].e = internalFormat;
   4663          n[4].i = (GLint) width;
   4664          n[5].i = border;
   4665          n[6].i = imageSize;
   4666          n[7].data = copy_data(data, imageSize, "glCompressedTexImage1DARB");
   4667       }
   4668       if (ctx->ExecuteFlag) {
   4669          CALL_CompressedTexImage1DARB(ctx->Exec,
   4670                                       (target, level, internalFormat, width,
   4671                                        border, imageSize, data));
   4672       }
   4673    }
   4674 }
   4675 
   4676 
   4677 static void GLAPIENTRY
   4678 save_CompressedTexImage2DARB(GLenum target, GLint level,
   4679                              GLenum internalFormat, GLsizei width,
   4680                              GLsizei height, GLint border, GLsizei imageSize,
   4681                              const GLvoid * data)
   4682 {
   4683    GET_CURRENT_CONTEXT(ctx);
   4684    if (target == GL_PROXY_TEXTURE_2D) {
   4685       /* don't compile, execute immediately */
   4686       CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,
   4687                                                width, height, border,
   4688                                                imageSize, data));
   4689    }
   4690    else {
   4691       Node *n;
   4692       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4693 
   4694       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8);
   4695       if (n) {
   4696          n[1].e = target;
   4697          n[2].i = level;
   4698          n[3].e = internalFormat;
   4699          n[4].i = (GLint) width;
   4700          n[5].i = (GLint) height;
   4701          n[6].i = border;
   4702          n[7].i = imageSize;
   4703          n[8].data = copy_data(data, imageSize, "glCompressedTexImage2DARB");
   4704       }
   4705       if (ctx->ExecuteFlag) {
   4706          CALL_CompressedTexImage2DARB(ctx->Exec,
   4707                                       (target, level, internalFormat, width,
   4708                                        height, border, imageSize, data));
   4709       }
   4710    }
   4711 }
   4712 
   4713 
   4714 static void GLAPIENTRY
   4715 save_CompressedTexImage3DARB(GLenum target, GLint level,
   4716                              GLenum internalFormat, GLsizei width,
   4717                              GLsizei height, GLsizei depth, GLint border,
   4718                              GLsizei imageSize, const GLvoid * data)
   4719 {
   4720    GET_CURRENT_CONTEXT(ctx);
   4721    if (target == GL_PROXY_TEXTURE_3D) {
   4722       /* don't compile, execute immediately */
   4723       CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,
   4724                                                width, height, depth, border,
   4725                                                imageSize, data));
   4726    }
   4727    else {
   4728       Node *n;
   4729       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4730 
   4731       n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9);
   4732       if (n) {
   4733          n[1].e = target;
   4734          n[2].i = level;
   4735          n[3].e = internalFormat;
   4736          n[4].i = (GLint) width;
   4737          n[5].i = (GLint) height;
   4738          n[6].i = (GLint) depth;
   4739          n[7].i = border;
   4740          n[8].i = imageSize;
   4741          n[9].data = copy_data(data, imageSize, "glCompressedTexImage3DARB");
   4742       }
   4743       if (ctx->ExecuteFlag) {
   4744          CALL_CompressedTexImage3DARB(ctx->Exec,
   4745                                       (target, level, internalFormat, width,
   4746                                        height, depth, border, imageSize,
   4747                                        data));
   4748       }
   4749    }
   4750 }
   4751 
   4752 
   4753 static void GLAPIENTRY
   4754 save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
   4755                                 GLsizei width, GLenum format,
   4756                                 GLsizei imageSize, const GLvoid * data)
   4757 {
   4758    Node *n;
   4759    GET_CURRENT_CONTEXT(ctx);
   4760    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4761 
   4762    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7);
   4763    if (n) {
   4764       n[1].e = target;
   4765       n[2].i = level;
   4766       n[3].i = xoffset;
   4767       n[4].i = (GLint) width;
   4768       n[5].e = format;
   4769       n[6].i = imageSize;
   4770       n[7].data = copy_data(data, imageSize, "glCompressedTexSubImage1DARB");
   4771    }
   4772    if (ctx->ExecuteFlag) {
   4773       CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,
   4774                                                   width, format, imageSize,
   4775                                                   data));
   4776    }
   4777 }
   4778 
   4779 
   4780 static void GLAPIENTRY
   4781 save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
   4782                                 GLint yoffset, GLsizei width, GLsizei height,
   4783                                 GLenum format, GLsizei imageSize,
   4784                                 const GLvoid * data)
   4785 {
   4786    Node *n;
   4787    GET_CURRENT_CONTEXT(ctx);
   4788    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4789 
   4790    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9);
   4791    if (n) {
   4792       n[1].e = target;
   4793       n[2].i = level;
   4794       n[3].i = xoffset;
   4795       n[4].i = yoffset;
   4796       n[5].i = (GLint) width;
   4797       n[6].i = (GLint) height;
   4798       n[7].e = format;
   4799       n[8].i = imageSize;
   4800       n[9].data = copy_data(data, imageSize, "glCompressedTexSubImage2DARB");
   4801    }
   4802    if (ctx->ExecuteFlag) {
   4803       CALL_CompressedTexSubImage2DARB(ctx->Exec,
   4804                                       (target, level, xoffset, yoffset, width,
   4805                                        height, format, imageSize, data));
   4806    }
   4807 }
   4808 
   4809 
   4810 static void GLAPIENTRY
   4811 save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
   4812                                 GLint yoffset, GLint zoffset, GLsizei width,
   4813                                 GLsizei height, GLsizei depth, GLenum format,
   4814                                 GLsizei imageSize, const GLvoid * data)
   4815 {
   4816    Node *n;
   4817    GET_CURRENT_CONTEXT(ctx);
   4818    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4819 
   4820    n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11);
   4821    if (n) {
   4822       n[1].e = target;
   4823       n[2].i = level;
   4824       n[3].i = xoffset;
   4825       n[4].i = yoffset;
   4826       n[5].i = zoffset;
   4827       n[6].i = (GLint) width;
   4828       n[7].i = (GLint) height;
   4829       n[8].i = (GLint) depth;
   4830       n[9].e = format;
   4831       n[10].i = imageSize;
   4832       n[11].data = copy_data(data, imageSize, "glCompressedTexSubImage3DARB");
   4833    }
   4834    if (ctx->ExecuteFlag) {
   4835       CALL_CompressedTexSubImage3DARB(ctx->Exec,
   4836                                       (target, level, xoffset, yoffset,
   4837                                        zoffset, width, height, depth, format,
   4838                                        imageSize, data));
   4839    }
   4840 }
   4841 
   4842 
   4843 /* GL_ARB_multisample */
   4844 static void GLAPIENTRY
   4845 save_SampleCoverageARB(GLclampf value, GLboolean invert)
   4846 {
   4847    GET_CURRENT_CONTEXT(ctx);
   4848    Node *n;
   4849    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4850    n = alloc_instruction(ctx, OPCODE_SAMPLE_COVERAGE, 2);
   4851    if (n) {
   4852       n[1].f = value;
   4853       n[2].b = invert;
   4854    }
   4855    if (ctx->ExecuteFlag) {
   4856       CALL_SampleCoverageARB(ctx->Exec, (value, invert));
   4857    }
   4858 }
   4859 
   4860 
   4861 /*
   4862  * GL_NV_vertex_program
   4863  */
   4864 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   4865 static void GLAPIENTRY
   4866 save_BindProgramNV(GLenum target, GLuint id)
   4867 {
   4868    GET_CURRENT_CONTEXT(ctx);
   4869    Node *n;
   4870    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4871    n = alloc_instruction(ctx, OPCODE_BIND_PROGRAM_NV, 2);
   4872    if (n) {
   4873       n[1].e = target;
   4874       n[2].ui = id;
   4875    }
   4876    if (ctx->ExecuteFlag) {
   4877       CALL_BindProgramNV(ctx->Exec, (target, id));
   4878    }
   4879 }
   4880 
   4881 static void GLAPIENTRY
   4882 save_ProgramEnvParameter4fARB(GLenum target, GLuint index,
   4883                               GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   4884 {
   4885    GET_CURRENT_CONTEXT(ctx);
   4886    Node *n;
   4887    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4888    n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
   4889    if (n) {
   4890       n[1].e = target;
   4891       n[2].ui = index;
   4892       n[3].f = x;
   4893       n[4].f = y;
   4894       n[5].f = z;
   4895       n[6].f = w;
   4896    }
   4897    if (ctx->ExecuteFlag) {
   4898       CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
   4899    }
   4900 }
   4901 
   4902 
   4903 static void GLAPIENTRY
   4904 save_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
   4905                                const GLfloat *params)
   4906 {
   4907    save_ProgramEnvParameter4fARB(target, index, params[0], params[1],
   4908                                  params[2], params[3]);
   4909 }
   4910 
   4911 
   4912 static void GLAPIENTRY
   4913 save_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
   4914 				const GLfloat * params)
   4915 {
   4916    GET_CURRENT_CONTEXT(ctx);
   4917    Node *n;
   4918    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4919 
   4920    if (count > 0) {
   4921       GLint i;
   4922       const GLfloat * p = params;
   4923 
   4924       for (i = 0 ; i < count ; i++) {
   4925 	 n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
   4926 	 if (n) {
   4927 	    n[1].e = target;
   4928 	    n[2].ui = index;
   4929 	    n[3].f = p[0];
   4930 	    n[4].f = p[1];
   4931 	    n[5].f = p[2];
   4932 	    n[6].f = p[3];
   4933 	    p += 4;
   4934 	 }
   4935       }
   4936    }
   4937 
   4938    if (ctx->ExecuteFlag) {
   4939       CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));
   4940    }
   4941 }
   4942 
   4943 
   4944 static void GLAPIENTRY
   4945 save_ProgramEnvParameter4dARB(GLenum target, GLuint index,
   4946                               GLdouble x, GLdouble y, GLdouble z, GLdouble w)
   4947 {
   4948    save_ProgramEnvParameter4fARB(target, index,
   4949                                  (GLfloat) x,
   4950                                  (GLfloat) y, (GLfloat) z, (GLfloat) w);
   4951 }
   4952 
   4953 
   4954 static void GLAPIENTRY
   4955 save_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
   4956                                const GLdouble *params)
   4957 {
   4958    save_ProgramEnvParameter4fARB(target, index,
   4959                                  (GLfloat) params[0],
   4960                                  (GLfloat) params[1],
   4961                                  (GLfloat) params[2], (GLfloat) params[3]);
   4962 }
   4963 
   4964 #endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program */
   4965 
   4966 #if FEATURE_NV_vertex_program
   4967 static void GLAPIENTRY
   4968 save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
   4969 {
   4970    GET_CURRENT_CONTEXT(ctx);
   4971    Node *n;
   4972    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   4973    n = alloc_instruction(ctx, OPCODE_EXECUTE_PROGRAM_NV, 6);
   4974    if (n) {
   4975       n[1].e = target;
   4976       n[2].ui = id;
   4977       n[3].f = params[0];
   4978       n[4].f = params[1];
   4979       n[5].f = params[2];
   4980       n[6].f = params[3];
   4981    }
   4982    if (ctx->ExecuteFlag) {
   4983       CALL_ExecuteProgramNV(ctx->Exec, (target, id, params));
   4984    }
   4985 }
   4986 
   4987 
   4988 static void GLAPIENTRY
   4989 save_ProgramParameters4dvNV(GLenum target, GLuint index,
   4990                             GLsizei num, const GLdouble *params)
   4991 {
   4992    GLint i;
   4993    for (i = 0; i < num; i++) {
   4994       save_ProgramEnvParameter4dvARB(target, index + i, params + 4 * i);
   4995    }
   4996 }
   4997 
   4998 
   4999 static void GLAPIENTRY
   5000 save_ProgramParameters4fvNV(GLenum target, GLuint index,
   5001                             GLsizei num, const GLfloat *params)
   5002 {
   5003    GLint i;
   5004    for (i = 0; i < num; i++) {
   5005       save_ProgramEnvParameter4fvARB(target, index + i, params + 4 * i);
   5006    }
   5007 }
   5008 
   5009 
   5010 static void GLAPIENTRY
   5011 save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
   5012                    const GLubyte * program)
   5013 {
   5014    GET_CURRENT_CONTEXT(ctx);
   5015    Node *n;
   5016 
   5017    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5018 
   5019    n = alloc_instruction(ctx, OPCODE_LOAD_PROGRAM_NV, 4);
   5020    if (n) {
   5021       GLubyte *programCopy = (GLubyte *) malloc(len);
   5022       if (!programCopy) {
   5023          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
   5024          return;
   5025       }
   5026       memcpy(programCopy, program, len);
   5027       n[1].e = target;
   5028       n[2].ui = id;
   5029       n[3].i = len;
   5030       n[4].data = programCopy;
   5031    }
   5032    if (ctx->ExecuteFlag) {
   5033       CALL_LoadProgramNV(ctx->Exec, (target, id, len, program));
   5034    }
   5035 }
   5036 
   5037 
   5038 static void GLAPIENTRY
   5039 save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)
   5040 {
   5041    GET_CURRENT_CONTEXT(ctx);
   5042    Node *n;
   5043 
   5044    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5045 
   5046    n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 2);
   5047    if (n) {
   5048       GLuint *idCopy = (GLuint *) malloc(num * sizeof(GLuint));
   5049       if (!idCopy) {
   5050          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
   5051          return;
   5052       }
   5053       memcpy(idCopy, ids, num * sizeof(GLuint));
   5054       n[1].i = num;
   5055       n[2].data = idCopy;
   5056    }
   5057    if (ctx->ExecuteFlag) {
   5058       CALL_RequestResidentProgramsNV(ctx->Exec, (num, ids));
   5059    }
   5060 }
   5061 
   5062 
   5063 static void GLAPIENTRY
   5064 save_TrackMatrixNV(GLenum target, GLuint address,
   5065                    GLenum matrix, GLenum transform)
   5066 {
   5067    GET_CURRENT_CONTEXT(ctx);
   5068    Node *n;
   5069    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5070    n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 4);
   5071    if (n) {
   5072       n[1].e = target;
   5073       n[2].ui = address;
   5074       n[3].e = matrix;
   5075       n[4].e = transform;
   5076    }
   5077    if (ctx->ExecuteFlag) {
   5078       CALL_TrackMatrixNV(ctx->Exec, (target, address, matrix, transform));
   5079    }
   5080 }
   5081 #endif /* FEATURE_NV_vertex_program */
   5082 
   5083 
   5084 /*
   5085  * GL_NV_fragment_program
   5086  */
   5087 #if FEATURE_NV_fragment_program
   5088 static void GLAPIENTRY
   5089 save_ProgramLocalParameter4fARB(GLenum target, GLuint index,
   5090                                 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   5091 {
   5092    GET_CURRENT_CONTEXT(ctx);
   5093    Node *n;
   5094    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5095    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
   5096    if (n) {
   5097       n[1].e = target;
   5098       n[2].ui = index;
   5099       n[3].f = x;
   5100       n[4].f = y;
   5101       n[5].f = z;
   5102       n[6].f = w;
   5103    }
   5104    if (ctx->ExecuteFlag) {
   5105       CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
   5106    }
   5107 }
   5108 
   5109 
   5110 static void GLAPIENTRY
   5111 save_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
   5112                                  const GLfloat *params)
   5113 {
   5114    GET_CURRENT_CONTEXT(ctx);
   5115    Node *n;
   5116    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5117    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
   5118    if (n) {
   5119       n[1].e = target;
   5120       n[2].ui = index;
   5121       n[3].f = params[0];
   5122       n[4].f = params[1];
   5123       n[5].f = params[2];
   5124       n[6].f = params[3];
   5125    }
   5126    if (ctx->ExecuteFlag) {
   5127       CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
   5128    }
   5129 }
   5130 
   5131 
   5132 static void GLAPIENTRY
   5133 save_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
   5134 				  const GLfloat *params)
   5135 {
   5136    GET_CURRENT_CONTEXT(ctx);
   5137    Node *n;
   5138    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5139 
   5140    if (count > 0) {
   5141       GLint i;
   5142       const GLfloat * p = params;
   5143 
   5144       for (i = 0 ; i < count ; i++) {
   5145 	 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
   5146 	 if (n) {
   5147 	    n[1].e = target;
   5148 	    n[2].ui = index;
   5149 	    n[3].f = p[0];
   5150 	    n[4].f = p[1];
   5151 	    n[5].f = p[2];
   5152 	    n[6].f = p[3];
   5153 	    p += 4;
   5154 	 }
   5155       }
   5156    }
   5157 
   5158    if (ctx->ExecuteFlag) {
   5159       CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));
   5160    }
   5161 }
   5162 
   5163 
   5164 static void GLAPIENTRY
   5165 save_ProgramLocalParameter4dARB(GLenum target, GLuint index,
   5166                                 GLdouble x, GLdouble y,
   5167                                 GLdouble z, GLdouble w)
   5168 {
   5169    GET_CURRENT_CONTEXT(ctx);
   5170    Node *n;
   5171    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5172    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
   5173    if (n) {
   5174       n[1].e = target;
   5175       n[2].ui = index;
   5176       n[3].f = (GLfloat) x;
   5177       n[4].f = (GLfloat) y;
   5178       n[5].f = (GLfloat) z;
   5179       n[6].f = (GLfloat) w;
   5180    }
   5181    if (ctx->ExecuteFlag) {
   5182       CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
   5183    }
   5184 }
   5185 
   5186 
   5187 static void GLAPIENTRY
   5188 save_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
   5189                                  const GLdouble *params)
   5190 {
   5191    GET_CURRENT_CONTEXT(ctx);
   5192    Node *n;
   5193    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5194    n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
   5195    if (n) {
   5196       n[1].e = target;
   5197       n[2].ui = index;
   5198       n[3].f = (GLfloat) params[0];
   5199       n[4].f = (GLfloat) params[1];
   5200       n[5].f = (GLfloat) params[2];
   5201       n[6].f = (GLfloat) params[3];
   5202    }
   5203    if (ctx->ExecuteFlag) {
   5204       CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
   5205    }
   5206 }
   5207 
   5208 static void GLAPIENTRY
   5209 save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,
   5210                                GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   5211 {
   5212    GET_CURRENT_CONTEXT(ctx);
   5213    Node *n;
   5214 
   5215    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5216 
   5217    n = alloc_instruction(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);
   5218    if (n) {
   5219       GLubyte *nameCopy = (GLubyte *) malloc(len);
   5220       if (!nameCopy) {
   5221          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
   5222          return;
   5223       }
   5224       memcpy(nameCopy, name, len);
   5225       n[1].ui = id;
   5226       n[2].i = len;
   5227       n[3].data = nameCopy;
   5228       n[4].f = x;
   5229       n[5].f = y;
   5230       n[6].f = z;
   5231       n[7].f = w;
   5232    }
   5233    if (ctx->ExecuteFlag) {
   5234       CALL_ProgramNamedParameter4fNV(ctx->Exec, (id, len, name, x, y, z, w));
   5235    }
   5236 }
   5237 
   5238 
   5239 static void GLAPIENTRY
   5240 save_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name,
   5241                                 const float v[])
   5242 {
   5243    save_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
   5244 }
   5245 
   5246 
   5247 static void GLAPIENTRY
   5248 save_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name,
   5249                                GLdouble x, GLdouble y, GLdouble z, GLdouble w)
   5250 {
   5251    save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) x, (GLfloat) y,
   5252                                   (GLfloat) z, (GLfloat) w);
   5253 }
   5254 
   5255 
   5256 static void GLAPIENTRY
   5257 save_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name,
   5258                                 const double v[])
   5259 {
   5260    save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) v[0],
   5261                                   (GLfloat) v[1], (GLfloat) v[2],
   5262                                   (GLfloat) v[3]);
   5263 }
   5264 
   5265 #endif /* FEATURE_NV_fragment_program */
   5266 
   5267 
   5268 
   5269 /* GL_EXT_stencil_two_side */
   5270 static void GLAPIENTRY
   5271 save_ActiveStencilFaceEXT(GLenum face)
   5272 {
   5273    GET_CURRENT_CONTEXT(ctx);
   5274    Node *n;
   5275    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5276    n = alloc_instruction(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);
   5277    if (n) {
   5278       n[1].e = face;
   5279    }
   5280    if (ctx->ExecuteFlag) {
   5281       CALL_ActiveStencilFaceEXT(ctx->Exec, (face));
   5282    }
   5283 }
   5284 
   5285 
   5286 /* GL_EXT_depth_bounds_test */
   5287 static void GLAPIENTRY
   5288 save_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
   5289 {
   5290    GET_CURRENT_CONTEXT(ctx);
   5291    Node *n;
   5292    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5293    n = alloc_instruction(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);
   5294    if (n) {
   5295       n[1].f = (GLfloat) zmin;
   5296       n[2].f = (GLfloat) zmax;
   5297    }
   5298    if (ctx->ExecuteFlag) {
   5299       CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));
   5300    }
   5301 }
   5302 
   5303 
   5304 
   5305 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   5306 
   5307 static void GLAPIENTRY
   5308 save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
   5309                       const GLvoid * string)
   5310 {
   5311    GET_CURRENT_CONTEXT(ctx);
   5312    Node *n;
   5313 
   5314    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5315 
   5316    n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 4);
   5317    if (n) {
   5318       GLubyte *programCopy = (GLubyte *) malloc(len);
   5319       if (!programCopy) {
   5320          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
   5321          return;
   5322       }
   5323       memcpy(programCopy, string, len);
   5324       n[1].e = target;
   5325       n[2].e = format;
   5326       n[3].i = len;
   5327       n[4].data = programCopy;
   5328    }
   5329    if (ctx->ExecuteFlag) {
   5330       CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
   5331    }
   5332 }
   5333 
   5334 #endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */
   5335 
   5336 
   5337 #if FEATURE_queryobj
   5338 
   5339 static void GLAPIENTRY
   5340 save_BeginQueryARB(GLenum target, GLuint id)
   5341 {
   5342    GET_CURRENT_CONTEXT(ctx);
   5343    Node *n;
   5344    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5345    n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_ARB, 2);
   5346    if (n) {
   5347       n[1].e = target;
   5348       n[2].ui = id;
   5349    }
   5350    if (ctx->ExecuteFlag) {
   5351       CALL_BeginQueryARB(ctx->Exec, (target, id));
   5352    }
   5353 }
   5354 
   5355 static void GLAPIENTRY
   5356 save_EndQueryARB(GLenum target)
   5357 {
   5358    GET_CURRENT_CONTEXT(ctx);
   5359    Node *n;
   5360    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5361    n = alloc_instruction(ctx, OPCODE_END_QUERY_ARB, 1);
   5362    if (n) {
   5363       n[1].e = target;
   5364    }
   5365    if (ctx->ExecuteFlag) {
   5366       CALL_EndQueryARB(ctx->Exec, (target));
   5367    }
   5368 }
   5369 
   5370 static void GLAPIENTRY
   5371 save_QueryCounter(GLuint id, GLenum target)
   5372 {
   5373    GET_CURRENT_CONTEXT(ctx);
   5374    Node *n;
   5375    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5376    n = alloc_instruction(ctx, OPCODE_QUERY_COUNTER, 2);
   5377    if (n) {
   5378       n[1].ui = id;
   5379       n[2].e = target;
   5380    }
   5381    if (ctx->ExecuteFlag) {
   5382       CALL_QueryCounter(ctx->Exec, (id, target));
   5383    }
   5384 }
   5385 
   5386 static void GLAPIENTRY
   5387 save_BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
   5388 {
   5389    GET_CURRENT_CONTEXT(ctx);
   5390    Node *n;
   5391    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5392    n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_INDEXED, 3);
   5393    if (n) {
   5394       n[1].e = target;
   5395       n[2].ui = index;
   5396       n[3].ui = id;
   5397    }
   5398    if (ctx->ExecuteFlag) {
   5399       CALL_BeginQueryIndexed(ctx->Exec, (target, index, id));
   5400    }
   5401 }
   5402 
   5403 static void GLAPIENTRY
   5404 save_EndQueryIndexed(GLenum target, GLuint index)
   5405 {
   5406    GET_CURRENT_CONTEXT(ctx);
   5407    Node *n;
   5408    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5409    n = alloc_instruction(ctx, OPCODE_END_QUERY_INDEXED, 2);
   5410    if (n) {
   5411       n[1].e = target;
   5412       n[2].ui = index;
   5413    }
   5414    if (ctx->ExecuteFlag) {
   5415       CALL_EndQueryIndexed(ctx->Exec, (target, index));
   5416    }
   5417 }
   5418 
   5419 #endif /* FEATURE_queryobj */
   5420 
   5421 
   5422 static void GLAPIENTRY
   5423 save_DrawBuffersARB(GLsizei count, const GLenum * buffers)
   5424 {
   5425    GET_CURRENT_CONTEXT(ctx);
   5426    Node *n;
   5427    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   5428    n = alloc_instruction(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);
   5429    if (n) {
   5430       GLint i;
   5431       n[1].i = count;
   5432       if (count > MAX_DRAW_BUFFERS)
   5433          count = MAX_DRAW_BUFFERS;
   5434       for (i = 0; i < count; i++) {
   5435          n[2 + i].e = buffers[i];
   5436       }
   5437    }
   5438    if (ctx->ExecuteFlag) {
   5439       CALL_DrawBuffersARB(ctx->Exec, (count, buffers));
   5440    }
   5441 }
   5442 
   5443 static void GLAPIENTRY
   5444 save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param)
   5445 {
   5446    GET_CURRENT_CONTEXT(ctx);
   5447    Node *n;
   5448 
   5449    n = alloc_instruction(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5);
   5450    if (n) {
   5451       n[1].ui = pname;
   5452       n[2].f = param[0];
   5453       n[3].f = param[1];
   5454       n[4].f = param[2];
   5455       n[5].f = param[3];
   5456    }
   5457    if (ctx->ExecuteFlag) {
   5458       CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param));
   5459    }
   5460 }
   5461 
   5462 static void GLAPIENTRY
   5463 save_TexBumpParameterivATI(GLenum pname, const GLint *param)
   5464 {
   5465    GLfloat p[4];
   5466    p[0] = INT_TO_FLOAT(param[0]);
   5467    p[1] = INT_TO_FLOAT(param[1]);
   5468    p[2] = INT_TO_FLOAT(param[2]);
   5469    p[3] = INT_TO_FLOAT(param[3]);
   5470    save_TexBumpParameterfvATI(pname, p);
   5471 }
   5472 
   5473 #if FEATURE_ATI_fragment_shader
   5474 static void GLAPIENTRY
   5475 save_BindFragmentShaderATI(GLuint id)
   5476 {
   5477    GET_CURRENT_CONTEXT(ctx);
   5478    Node *n;
   5479 
   5480    n = alloc_instruction(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);
   5481    if (n) {
   5482       n[1].ui = id;
   5483    }
   5484    if (ctx->ExecuteFlag) {
   5485       CALL_BindFragmentShaderATI(ctx->Exec, (id));
   5486    }
   5487 }
   5488 
   5489 static void GLAPIENTRY
   5490 save_SetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
   5491 {
   5492    GET_CURRENT_CONTEXT(ctx);
   5493    Node *n;
   5494 
   5495    n = alloc_instruction(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);
   5496    if (n) {
   5497       n[1].ui = dst;
   5498       n[2].f = value[0];
   5499       n[3].f = value[1];
   5500       n[4].f = value[2];
   5501       n[5].f = value[3];
   5502    }
   5503    if (ctx->ExecuteFlag) {
   5504       CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
   5505    }
   5506 }
   5507 #endif
   5508 
   5509 static void GLAPIENTRY
   5510 save_Attr1fNV(GLenum attr, GLfloat x)
   5511 {
   5512    GET_CURRENT_CONTEXT(ctx);
   5513    Node *n;
   5514    SAVE_FLUSH_VERTICES(ctx);
   5515    n = alloc_instruction(ctx, OPCODE_ATTR_1F_NV, 2);
   5516    if (n) {
   5517       n[1].e = attr;
   5518       n[2].f = x;
   5519    }
   5520 
   5521    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5522    ctx->ListState.ActiveAttribSize[attr] = 1;
   5523    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
   5524 
   5525    if (ctx->ExecuteFlag) {
   5526       CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));
   5527    }
   5528 }
   5529 
   5530 static void GLAPIENTRY
   5531 save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
   5532 {
   5533    GET_CURRENT_CONTEXT(ctx);
   5534    Node *n;
   5535    SAVE_FLUSH_VERTICES(ctx);
   5536    n = alloc_instruction(ctx, OPCODE_ATTR_2F_NV, 3);
   5537    if (n) {
   5538       n[1].e = attr;
   5539       n[2].f = x;
   5540       n[3].f = y;
   5541    }
   5542 
   5543    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5544    ctx->ListState.ActiveAttribSize[attr] = 2;
   5545    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
   5546 
   5547    if (ctx->ExecuteFlag) {
   5548       CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));
   5549    }
   5550 }
   5551 
   5552 static void GLAPIENTRY
   5553 save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
   5554 {
   5555    GET_CURRENT_CONTEXT(ctx);
   5556    Node *n;
   5557    SAVE_FLUSH_VERTICES(ctx);
   5558    n = alloc_instruction(ctx, OPCODE_ATTR_3F_NV, 4);
   5559    if (n) {
   5560       n[1].e = attr;
   5561       n[2].f = x;
   5562       n[3].f = y;
   5563       n[4].f = z;
   5564    }
   5565 
   5566    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5567    ctx->ListState.ActiveAttribSize[attr] = 3;
   5568    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
   5569 
   5570    if (ctx->ExecuteFlag) {
   5571       CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));
   5572    }
   5573 }
   5574 
   5575 static void GLAPIENTRY
   5576 save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   5577 {
   5578    GET_CURRENT_CONTEXT(ctx);
   5579    Node *n;
   5580    SAVE_FLUSH_VERTICES(ctx);
   5581    n = alloc_instruction(ctx, OPCODE_ATTR_4F_NV, 5);
   5582    if (n) {
   5583       n[1].e = attr;
   5584       n[2].f = x;
   5585       n[3].f = y;
   5586       n[4].f = z;
   5587       n[5].f = w;
   5588    }
   5589 
   5590    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5591    ctx->ListState.ActiveAttribSize[attr] = 4;
   5592    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
   5593 
   5594    if (ctx->ExecuteFlag) {
   5595       CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));
   5596    }
   5597 }
   5598 
   5599 
   5600 static void GLAPIENTRY
   5601 save_Attr1fARB(GLenum attr, GLfloat x)
   5602 {
   5603    GET_CURRENT_CONTEXT(ctx);
   5604    Node *n;
   5605    SAVE_FLUSH_VERTICES(ctx);
   5606    n = alloc_instruction(ctx, OPCODE_ATTR_1F_ARB, 2);
   5607    if (n) {
   5608       n[1].e = attr;
   5609       n[2].f = x;
   5610    }
   5611 
   5612    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5613    ctx->ListState.ActiveAttribSize[attr] = 1;
   5614    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
   5615 
   5616    if (ctx->ExecuteFlag) {
   5617       CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));
   5618    }
   5619 }
   5620 
   5621 static void GLAPIENTRY
   5622 save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
   5623 {
   5624    GET_CURRENT_CONTEXT(ctx);
   5625    Node *n;
   5626    SAVE_FLUSH_VERTICES(ctx);
   5627    n = alloc_instruction(ctx, OPCODE_ATTR_2F_ARB, 3);
   5628    if (n) {
   5629       n[1].e = attr;
   5630       n[2].f = x;
   5631       n[3].f = y;
   5632    }
   5633 
   5634    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5635    ctx->ListState.ActiveAttribSize[attr] = 2;
   5636    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
   5637 
   5638    if (ctx->ExecuteFlag) {
   5639       CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));
   5640    }
   5641 }
   5642 
   5643 static void GLAPIENTRY
   5644 save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
   5645 {
   5646    GET_CURRENT_CONTEXT(ctx);
   5647    Node *n;
   5648    SAVE_FLUSH_VERTICES(ctx);
   5649    n = alloc_instruction(ctx, OPCODE_ATTR_3F_ARB, 4);
   5650    if (n) {
   5651       n[1].e = attr;
   5652       n[2].f = x;
   5653       n[3].f = y;
   5654       n[4].f = z;
   5655    }
   5656 
   5657    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5658    ctx->ListState.ActiveAttribSize[attr] = 3;
   5659    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
   5660 
   5661    if (ctx->ExecuteFlag) {
   5662       CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));
   5663    }
   5664 }
   5665 
   5666 static void GLAPIENTRY
   5667 save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   5668 {
   5669    GET_CURRENT_CONTEXT(ctx);
   5670    Node *n;
   5671    SAVE_FLUSH_VERTICES(ctx);
   5672    n = alloc_instruction(ctx, OPCODE_ATTR_4F_ARB, 5);
   5673    if (n) {
   5674       n[1].e = attr;
   5675       n[2].f = x;
   5676       n[3].f = y;
   5677       n[4].f = z;
   5678       n[5].f = w;
   5679    }
   5680 
   5681    ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
   5682    ctx->ListState.ActiveAttribSize[attr] = 4;
   5683    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
   5684 
   5685    if (ctx->ExecuteFlag) {
   5686       CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));
   5687    }
   5688 }
   5689 
   5690 
   5691 static void GLAPIENTRY
   5692 save_EvalCoord1f(GLfloat x)
   5693 {
   5694    GET_CURRENT_CONTEXT(ctx);
   5695    Node *n;
   5696    SAVE_FLUSH_VERTICES(ctx);
   5697    n = alloc_instruction(ctx, OPCODE_EVAL_C1, 1);
   5698    if (n) {
   5699       n[1].f = x;
   5700    }
   5701    if (ctx->ExecuteFlag) {
   5702       CALL_EvalCoord1f(ctx->Exec, (x));
   5703    }
   5704 }
   5705 
   5706 static void GLAPIENTRY
   5707 save_EvalCoord1fv(const GLfloat * v)
   5708 {
   5709    save_EvalCoord1f(v[0]);
   5710 }
   5711 
   5712 static void GLAPIENTRY
   5713 save_EvalCoord2f(GLfloat x, GLfloat y)
   5714 {
   5715    GET_CURRENT_CONTEXT(ctx);
   5716    Node *n;
   5717    SAVE_FLUSH_VERTICES(ctx);
   5718    n = alloc_instruction(ctx, OPCODE_EVAL_C2, 2);
   5719    if (n) {
   5720       n[1].f = x;
   5721       n[2].f = y;
   5722    }
   5723    if (ctx->ExecuteFlag) {
   5724       CALL_EvalCoord2f(ctx->Exec, (x, y));
   5725    }
   5726 }
   5727 
   5728 static void GLAPIENTRY
   5729 save_EvalCoord2fv(const GLfloat * v)
   5730 {
   5731    save_EvalCoord2f(v[0], v[1]);
   5732 }
   5733 
   5734 
   5735 static void GLAPIENTRY
   5736 save_EvalPoint1(GLint x)
   5737 {
   5738    GET_CURRENT_CONTEXT(ctx);
   5739    Node *n;
   5740    SAVE_FLUSH_VERTICES(ctx);
   5741    n = alloc_instruction(ctx, OPCODE_EVAL_P1, 1);
   5742    if (n) {
   5743       n[1].i = x;
   5744    }
   5745    if (ctx->ExecuteFlag) {
   5746       CALL_EvalPoint1(ctx->Exec, (x));
   5747    }
   5748 }
   5749 
   5750 static void GLAPIENTRY
   5751 save_EvalPoint2(GLint x, GLint y)
   5752 {
   5753    GET_CURRENT_CONTEXT(ctx);
   5754    Node *n;
   5755    SAVE_FLUSH_VERTICES(ctx);
   5756    n = alloc_instruction(ctx, OPCODE_EVAL_P2, 2);
   5757    if (n) {
   5758       n[1].i = x;
   5759       n[2].i = y;
   5760    }
   5761    if (ctx->ExecuteFlag) {
   5762       CALL_EvalPoint2(ctx->Exec, (x, y));
   5763    }
   5764 }
   5765 
   5766 static void GLAPIENTRY
   5767 save_Indexf(GLfloat x)
   5768 {
   5769    save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);
   5770 }
   5771 
   5772 static void GLAPIENTRY
   5773 save_Indexfv(const GLfloat * v)
   5774 {
   5775    save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);
   5776 }
   5777 
   5778 static void GLAPIENTRY
   5779 save_EdgeFlag(GLboolean x)
   5780 {
   5781    save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? 1.0f : 0.0f);
   5782 }
   5783 
   5784 
   5785 /**
   5786  * Compare 'count' elements of vectors 'a' and 'b'.
   5787  * \return GL_TRUE if equal, GL_FALSE if different.
   5788  */
   5789 static inline GLboolean
   5790 compare_vec(const GLfloat *a, const GLfloat *b, GLuint count)
   5791 {
   5792    return memcmp( a, b, count * sizeof(GLfloat) ) == 0;
   5793 }
   5794 
   5795 
   5796 /**
   5797  * This glMaterial function is used for glMaterial calls that are outside
   5798  * a glBegin/End pair.  For glMaterial inside glBegin/End, see the VBO code.
   5799  */
   5800 static void GLAPIENTRY
   5801 save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
   5802 {
   5803    GET_CURRENT_CONTEXT(ctx);
   5804    Node *n;
   5805    int args, i;
   5806    GLuint bitmask;
   5807 
   5808    switch (face) {
   5809    case GL_BACK:
   5810    case GL_FRONT:
   5811    case GL_FRONT_AND_BACK:
   5812       break;
   5813    default:
   5814       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
   5815       return;
   5816    }
   5817 
   5818    switch (pname) {
   5819    case GL_EMISSION:
   5820    case GL_AMBIENT:
   5821    case GL_DIFFUSE:
   5822    case GL_SPECULAR:
   5823    case GL_AMBIENT_AND_DIFFUSE:
   5824       args = 4;
   5825       break;
   5826    case GL_SHININESS:
   5827       args = 1;
   5828       break;
   5829    case GL_COLOR_INDEXES:
   5830       args = 3;
   5831       break;
   5832    default:
   5833       _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
   5834       return;
   5835    }
   5836 
   5837    if (ctx->ExecuteFlag) {
   5838       CALL_Materialfv(ctx->Exec, (face, pname, param));
   5839    }
   5840 
   5841    bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
   5842 
   5843    /* Try to eliminate redundant statechanges.  Because it is legal to
   5844     * call glMaterial even inside begin/end calls, don't need to worry
   5845     * about ctx->Driver.CurrentSavePrimitive here.
   5846     */
   5847    for (i = 0; i < MAT_ATTRIB_MAX; i++) {
   5848       if (bitmask & (1 << i)) {
   5849          if (ctx->ListState.ActiveMaterialSize[i] == args &&
   5850              compare_vec(ctx->ListState.CurrentMaterial[i], param, args)) {
   5851             /* no change in material value */
   5852             bitmask &= ~(1 << i);
   5853          }
   5854          else {
   5855             ctx->ListState.ActiveMaterialSize[i] = args;
   5856             COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
   5857          }
   5858       }
   5859    }
   5860 
   5861    /* If this call has no effect, return early */
   5862    if (bitmask == 0)
   5863       return;
   5864 
   5865    SAVE_FLUSH_VERTICES(ctx);
   5866 
   5867    n = alloc_instruction(ctx, OPCODE_MATERIAL, 6);
   5868    if (n) {
   5869       n[1].e = face;
   5870       n[2].e = pname;
   5871       for (i = 0; i < args; i++)
   5872          n[3 + i].f = param[i];
   5873    }
   5874 }
   5875 
   5876 static void GLAPIENTRY
   5877 save_Begin(GLenum mode)
   5878 {
   5879    GET_CURRENT_CONTEXT(ctx);
   5880    Node *n;
   5881    GLboolean error = GL_FALSE;
   5882 
   5883    if (mode > GL_POLYGON) {
   5884       _mesa_error(ctx, GL_INVALID_ENUM, "glBegin(mode=%x)", mode);
   5885       error = GL_TRUE;
   5886    }
   5887    if (ctx->ExecuteFlag) {
   5888       if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
   5889 	 error = GL_TRUE;
   5890       }
   5891    }
   5892 
   5893    else if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN) {
   5894       /* Typically the first begin.  This may raise an error on
   5895        * playback, depending on whether CallList is issued from inside
   5896        * a begin/end or not.
   5897        */
   5898       ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;
   5899    }
   5900    else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END) {
   5901       ctx->Driver.CurrentSavePrimitive = mode;
   5902    }
   5903    else {
   5904       _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive begin");
   5905       error = GL_TRUE;
   5906    }
   5907 
   5908    if (!error) {
   5909       /* Give the driver an opportunity to hook in an optimized
   5910        * display list compiler.
   5911        */
   5912       if (ctx->Driver.NotifySaveBegin(ctx, mode))
   5913          return;
   5914 
   5915       SAVE_FLUSH_VERTICES(ctx);
   5916       n = alloc_instruction(ctx, OPCODE_BEGIN, 1);
   5917       if (n) {
   5918          n[1].e = mode;
   5919       }
   5920    }
   5921 
   5922    if (ctx->ExecuteFlag) {
   5923       CALL_Begin(ctx->Exec, (mode));
   5924    }
   5925 }
   5926 
   5927 static void GLAPIENTRY
   5928 save_End(void)
   5929 {
   5930    GET_CURRENT_CONTEXT(ctx);
   5931    SAVE_FLUSH_VERTICES(ctx);
   5932    (void) alloc_instruction(ctx, OPCODE_END, 0);
   5933    ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
   5934    if (ctx->ExecuteFlag) {
   5935       CALL_End(ctx->Exec, ());
   5936    }
   5937 }
   5938 
   5939 static void GLAPIENTRY
   5940 save_Rectf(GLfloat a, GLfloat b, GLfloat c, GLfloat d)
   5941 {
   5942    GET_CURRENT_CONTEXT(ctx);
   5943    Node *n;
   5944    SAVE_FLUSH_VERTICES(ctx);
   5945    n = alloc_instruction(ctx, OPCODE_RECTF, 4);
   5946    if (n) {
   5947       n[1].f = a;
   5948       n[2].f = b;
   5949       n[3].f = c;
   5950       n[4].f = d;
   5951    }
   5952    if (ctx->ExecuteFlag) {
   5953       CALL_Rectf(ctx->Exec, (a, b, c, d));
   5954    }
   5955 }
   5956 
   5957 
   5958 static void GLAPIENTRY
   5959 save_Vertex2f(GLfloat x, GLfloat y)
   5960 {
   5961    save_Attr2fNV(VERT_ATTRIB_POS, x, y);
   5962 }
   5963 
   5964 static void GLAPIENTRY
   5965 save_Vertex2fv(const GLfloat * v)
   5966 {
   5967    save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);
   5968 }
   5969 
   5970 static void GLAPIENTRY
   5971 save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
   5972 {
   5973    save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);
   5974 }
   5975 
   5976 static void GLAPIENTRY
   5977 save_Vertex3fv(const GLfloat * v)
   5978 {
   5979    save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);
   5980 }
   5981 
   5982 static void GLAPIENTRY
   5983 save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   5984 {
   5985    save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);
   5986 }
   5987 
   5988 static void GLAPIENTRY
   5989 save_Vertex4fv(const GLfloat * v)
   5990 {
   5991    save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);
   5992 }
   5993 
   5994 static void GLAPIENTRY
   5995 save_TexCoord1f(GLfloat x)
   5996 {
   5997    save_Attr1fNV(VERT_ATTRIB_TEX0, x);
   5998 }
   5999 
   6000 static void GLAPIENTRY
   6001 save_TexCoord1fv(const GLfloat * v)
   6002 {
   6003    save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);
   6004 }
   6005 
   6006 static void GLAPIENTRY
   6007 save_TexCoord2f(GLfloat x, GLfloat y)
   6008 {
   6009    save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);
   6010 }
   6011 
   6012 static void GLAPIENTRY
   6013 save_TexCoord2fv(const GLfloat * v)
   6014 {
   6015    save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);
   6016 }
   6017 
   6018 static void GLAPIENTRY
   6019 save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)
   6020 {
   6021    save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);
   6022 }
   6023 
   6024 static void GLAPIENTRY
   6025 save_TexCoord3fv(const GLfloat * v)
   6026 {
   6027    save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);
   6028 }
   6029 
   6030 static void GLAPIENTRY
   6031 save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   6032 {
   6033    save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);
   6034 }
   6035 
   6036 static void GLAPIENTRY
   6037 save_TexCoord4fv(const GLfloat * v)
   6038 {
   6039    save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);
   6040 }
   6041 
   6042 static void GLAPIENTRY
   6043 save_Normal3f(GLfloat x, GLfloat y, GLfloat z)
   6044 {
   6045    save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);
   6046 }
   6047 
   6048 static void GLAPIENTRY
   6049 save_Normal3fv(const GLfloat * v)
   6050 {
   6051    save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);
   6052 }
   6053 
   6054 static void GLAPIENTRY
   6055 save_FogCoordfEXT(GLfloat x)
   6056 {
   6057    save_Attr1fNV(VERT_ATTRIB_FOG, x);
   6058 }
   6059 
   6060 static void GLAPIENTRY
   6061 save_FogCoordfvEXT(const GLfloat * v)
   6062 {
   6063    save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);
   6064 }
   6065 
   6066 static void GLAPIENTRY
   6067 save_Color3f(GLfloat x, GLfloat y, GLfloat z)
   6068 {
   6069    save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);
   6070 }
   6071 
   6072 static void GLAPIENTRY
   6073 save_Color3fv(const GLfloat * v)
   6074 {
   6075    save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);
   6076 }
   6077 
   6078 static void GLAPIENTRY
   6079 save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   6080 {
   6081    save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);
   6082 }
   6083 
   6084 static void GLAPIENTRY
   6085 save_Color4fv(const GLfloat * v)
   6086 {
   6087    save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);
   6088 }
   6089 
   6090 static void GLAPIENTRY
   6091 save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)
   6092 {
   6093    save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);
   6094 }
   6095 
   6096 static void GLAPIENTRY
   6097 save_SecondaryColor3fvEXT(const GLfloat * v)
   6098 {
   6099    save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);
   6100 }
   6101 
   6102 
   6103 /* Just call the respective ATTR for texcoord
   6104  */
   6105 static void GLAPIENTRY
   6106 save_MultiTexCoord1f(GLenum target, GLfloat x)
   6107 {
   6108    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6109    save_Attr1fNV(attr, x);
   6110 }
   6111 
   6112 static void GLAPIENTRY
   6113 save_MultiTexCoord1fv(GLenum target, const GLfloat * v)
   6114 {
   6115    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6116    save_Attr1fNV(attr, v[0]);
   6117 }
   6118 
   6119 static void GLAPIENTRY
   6120 save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)
   6121 {
   6122    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6123    save_Attr2fNV(attr, x, y);
   6124 }
   6125 
   6126 static void GLAPIENTRY
   6127 save_MultiTexCoord2fv(GLenum target, const GLfloat * v)
   6128 {
   6129    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6130    save_Attr2fNV(attr, v[0], v[1]);
   6131 }
   6132 
   6133 static void GLAPIENTRY
   6134 save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)
   6135 {
   6136    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6137    save_Attr3fNV(attr, x, y, z);
   6138 }
   6139 
   6140 static void GLAPIENTRY
   6141 save_MultiTexCoord3fv(GLenum target, const GLfloat * v)
   6142 {
   6143    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6144    save_Attr3fNV(attr, v[0], v[1], v[2]);
   6145 }
   6146 
   6147 static void GLAPIENTRY
   6148 save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,
   6149                      GLfloat z, GLfloat w)
   6150 {
   6151    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6152    save_Attr4fNV(attr, x, y, z, w);
   6153 }
   6154 
   6155 static void GLAPIENTRY
   6156 save_MultiTexCoord4fv(GLenum target, const GLfloat * v)
   6157 {
   6158    GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
   6159    save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);
   6160 }
   6161 
   6162 
   6163 /**
   6164  * Record a GL_INVALID_VALUE error when a invalid vertex attribute
   6165  * index is found.
   6166  */
   6167 static void
   6168 index_error(void)
   6169 {
   6170    GET_CURRENT_CONTEXT(ctx);
   6171    _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");
   6172 }
   6173 
   6174 
   6175 /* First level for NV_vertex_program:
   6176  *
   6177  * Check for errors at compile time?.
   6178  */
   6179 static void GLAPIENTRY
   6180 save_VertexAttrib1fNV(GLuint index, GLfloat x)
   6181 {
   6182    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6183       save_Attr1fNV(index, x);
   6184    else
   6185       index_error();
   6186 }
   6187 
   6188 static void GLAPIENTRY
   6189 save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
   6190 {
   6191    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6192       save_Attr1fNV(index, v[0]);
   6193    else
   6194       index_error();
   6195 }
   6196 
   6197 static void GLAPIENTRY
   6198 save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
   6199 {
   6200    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6201       save_Attr2fNV(index, x, y);
   6202    else
   6203       index_error();
   6204 }
   6205 
   6206 static void GLAPIENTRY
   6207 save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
   6208 {
   6209    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6210       save_Attr2fNV(index, v[0], v[1]);
   6211    else
   6212       index_error();
   6213 }
   6214 
   6215 static void GLAPIENTRY
   6216 save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
   6217 {
   6218    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6219       save_Attr3fNV(index, x, y, z);
   6220    else
   6221       index_error();
   6222 }
   6223 
   6224 static void GLAPIENTRY
   6225 save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
   6226 {
   6227    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6228       save_Attr3fNV(index, v[0], v[1], v[2]);
   6229    else
   6230       index_error();
   6231 }
   6232 
   6233 static void GLAPIENTRY
   6234 save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
   6235                       GLfloat z, GLfloat w)
   6236 {
   6237    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6238       save_Attr4fNV(index, x, y, z, w);
   6239    else
   6240       index_error();
   6241 }
   6242 
   6243 static void GLAPIENTRY
   6244 save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
   6245 {
   6246    if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
   6247       save_Attr4fNV(index, v[0], v[1], v[2], v[3]);
   6248    else
   6249       index_error();
   6250 }
   6251 
   6252 
   6253 
   6254 
   6255 static void GLAPIENTRY
   6256 save_VertexAttrib1fARB(GLuint index, GLfloat x)
   6257 {
   6258    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6259       save_Attr1fARB(index, x);
   6260    else
   6261       index_error();
   6262 }
   6263 
   6264 static void GLAPIENTRY
   6265 save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
   6266 {
   6267    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6268       save_Attr1fARB(index, v[0]);
   6269    else
   6270       index_error();
   6271 }
   6272 
   6273 static void GLAPIENTRY
   6274 save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
   6275 {
   6276    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6277       save_Attr2fARB(index, x, y);
   6278    else
   6279       index_error();
   6280 }
   6281 
   6282 static void GLAPIENTRY
   6283 save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
   6284 {
   6285    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6286       save_Attr2fARB(index, v[0], v[1]);
   6287    else
   6288       index_error();
   6289 }
   6290 
   6291 static void GLAPIENTRY
   6292 save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
   6293 {
   6294    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6295       save_Attr3fARB(index, x, y, z);
   6296    else
   6297       index_error();
   6298 }
   6299 
   6300 static void GLAPIENTRY
   6301 save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
   6302 {
   6303    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6304       save_Attr3fARB(index, v[0], v[1], v[2]);
   6305    else
   6306       index_error();
   6307 }
   6308 
   6309 static void GLAPIENTRY
   6310 save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
   6311                        GLfloat w)
   6312 {
   6313    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6314       save_Attr4fARB(index, x, y, z, w);
   6315    else
   6316       index_error();
   6317 }
   6318 
   6319 static void GLAPIENTRY
   6320 save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
   6321 {
   6322    if (index < MAX_VERTEX_GENERIC_ATTRIBS)
   6323       save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
   6324    else
   6325       index_error();
   6326 }
   6327 
   6328 
   6329 /* GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
   6330 
   6331 static void GLAPIENTRY
   6332 exec_BindAttribLocationARB(GLuint program, GLuint index, const GLchar *name)
   6333 {
   6334    GET_CURRENT_CONTEXT(ctx);
   6335    FLUSH_VERTICES(ctx, 0);
   6336    CALL_BindAttribLocationARB(ctx->Exec, (program, index, name));
   6337 }
   6338 
   6339 static GLint GLAPIENTRY
   6340 exec_GetAttribLocationARB(GLuint program, const GLchar *name)
   6341 {
   6342    GET_CURRENT_CONTEXT(ctx);
   6343    FLUSH_VERTICES(ctx, 0);
   6344    return CALL_GetAttribLocationARB(ctx->Exec, (program, name));
   6345 }
   6346 
   6347 static GLint GLAPIENTRY
   6348 exec_GetUniformLocationARB(GLuint program, const GLchar *name)
   6349 {
   6350    GET_CURRENT_CONTEXT(ctx);
   6351    FLUSH_VERTICES(ctx, 0);
   6352    return CALL_GetUniformLocationARB(ctx->Exec, (program, name));
   6353 }
   6354 /* XXX more shader functions needed here */
   6355 
   6356 
   6357 #if FEATURE_EXT_framebuffer_blit
   6358 static void GLAPIENTRY
   6359 save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
   6360                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
   6361                         GLbitfield mask, GLenum filter)
   6362 {
   6363    GET_CURRENT_CONTEXT(ctx);
   6364    Node *n;
   6365    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6366    n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
   6367    if (n) {
   6368       n[1].i = srcX0;
   6369       n[2].i = srcY0;
   6370       n[3].i = srcX1;
   6371       n[4].i = srcY1;
   6372       n[5].i = dstX0;
   6373       n[6].i = dstY0;
   6374       n[7].i = dstX1;
   6375       n[8].i = dstY1;
   6376       n[9].i = mask;
   6377       n[10].e = filter;
   6378    }
   6379    if (ctx->ExecuteFlag) {
   6380       CALL_BlitFramebufferEXT(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
   6381                                           dstX0, dstY0, dstX1, dstY1,
   6382                                           mask, filter));
   6383    }
   6384 }
   6385 #endif
   6386 
   6387 
   6388 /** GL_EXT_provoking_vertex */
   6389 static void GLAPIENTRY
   6390 save_ProvokingVertexEXT(GLenum mode)
   6391 {
   6392    GET_CURRENT_CONTEXT(ctx);
   6393    Node *n;
   6394    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6395    n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
   6396    if (n) {
   6397       n[1].e = mode;
   6398    }
   6399    if (ctx->ExecuteFlag) {
   6400       /*CALL_ProvokingVertexEXT(ctx->Exec, (mode));*/
   6401       _mesa_ProvokingVertexEXT(mode);
   6402    }
   6403 }
   6404 
   6405 
   6406 /** GL_EXT_transform_feedback */
   6407 static void GLAPIENTRY
   6408 save_BeginTransformFeedback(GLenum mode)
   6409 {
   6410    GET_CURRENT_CONTEXT(ctx);
   6411    Node *n;
   6412    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6413    n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
   6414    if (n) {
   6415       n[1].e = mode;
   6416    }
   6417    if (ctx->ExecuteFlag) {
   6418       CALL_BeginTransformFeedbackEXT(ctx->Exec, (mode));
   6419    }
   6420 }
   6421 
   6422 
   6423 /** GL_EXT_transform_feedback */
   6424 static void GLAPIENTRY
   6425 save_EndTransformFeedback(void)
   6426 {
   6427    GET_CURRENT_CONTEXT(ctx);
   6428    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6429    (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
   6430    if (ctx->ExecuteFlag) {
   6431       CALL_EndTransformFeedbackEXT(ctx->Exec, ());
   6432    }
   6433 }
   6434 
   6435 static void GLAPIENTRY
   6436 save_BindTransformFeedback(GLenum target, GLuint name)
   6437 {
   6438    GET_CURRENT_CONTEXT(ctx);
   6439    Node *n;
   6440    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6441    n = alloc_instruction(ctx, OPCODE_BIND_TRANSFORM_FEEDBACK, 2);
   6442    if (n) {
   6443       n[1].e = target;
   6444       n[2].ui = name;
   6445    }
   6446    if (ctx->ExecuteFlag) {
   6447       CALL_BindTransformFeedback(ctx->Exec, (target, name));
   6448    }
   6449 }
   6450 
   6451 static void GLAPIENTRY
   6452 save_PauseTransformFeedback(void)
   6453 {
   6454    GET_CURRENT_CONTEXT(ctx);
   6455    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6456    (void) alloc_instruction(ctx, OPCODE_PAUSE_TRANSFORM_FEEDBACK, 0);
   6457    if (ctx->ExecuteFlag) {
   6458       CALL_PauseTransformFeedback(ctx->Exec, ());
   6459    }
   6460 }
   6461 
   6462 static void GLAPIENTRY
   6463 save_ResumeTransformFeedback(void)
   6464 {
   6465    GET_CURRENT_CONTEXT(ctx);
   6466    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6467    (void) alloc_instruction(ctx, OPCODE_RESUME_TRANSFORM_FEEDBACK, 0);
   6468    if (ctx->ExecuteFlag) {
   6469       CALL_ResumeTransformFeedback(ctx->Exec, ());
   6470    }
   6471 }
   6472 
   6473 static void GLAPIENTRY
   6474 save_DrawTransformFeedback(GLenum mode, GLuint name)
   6475 {
   6476    GET_CURRENT_CONTEXT(ctx);
   6477    Node *n;
   6478    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6479    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK, 2);
   6480    if (n) {
   6481       n[1].e = mode;
   6482       n[2].ui = name;
   6483    }
   6484    if (ctx->ExecuteFlag) {
   6485       CALL_DrawTransformFeedback(ctx->Exec, (mode, name));
   6486    }
   6487 }
   6488 
   6489 static void GLAPIENTRY
   6490 save_DrawTransformFeedbackStream(GLenum mode, GLuint name, GLuint stream)
   6491 {
   6492    GET_CURRENT_CONTEXT(ctx);
   6493    Node *n;
   6494    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6495    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM, 3);
   6496    if (n) {
   6497       n[1].e = mode;
   6498       n[2].ui = name;
   6499       n[3].ui = stream;
   6500    }
   6501    if (ctx->ExecuteFlag) {
   6502       CALL_DrawTransformFeedbackStream(ctx->Exec, (mode, name, stream));
   6503    }
   6504 }
   6505 
   6506 static void GLAPIENTRY
   6507 save_DrawTransformFeedbackInstanced(GLenum mode, GLuint name,
   6508                                     GLsizei primcount)
   6509 {
   6510    GET_CURRENT_CONTEXT(ctx);
   6511    Node *n;
   6512    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6513    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED, 3);
   6514    if (n) {
   6515       n[1].e = mode;
   6516       n[2].ui = name;
   6517       n[3].si = primcount;
   6518    }
   6519    if (ctx->ExecuteFlag) {
   6520       CALL_DrawTransformFeedbackInstanced(ctx->Exec, (mode, name, primcount));
   6521    }
   6522 }
   6523 
   6524 static void GLAPIENTRY
   6525 save_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint name,
   6526                                           GLuint stream, GLsizei primcount)
   6527 {
   6528    GET_CURRENT_CONTEXT(ctx);
   6529    Node *n;
   6530    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6531    n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED, 4);
   6532    if (n) {
   6533       n[1].e = mode;
   6534       n[2].ui = name;
   6535       n[3].ui = stream;
   6536       n[4].si = primcount;
   6537    }
   6538    if (ctx->ExecuteFlag) {
   6539       CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec, (mode, name, stream,
   6540                                                             primcount));
   6541    }
   6542 }
   6543 
   6544 /* aka UseProgram() */
   6545 static void GLAPIENTRY
   6546 save_UseProgramObjectARB(GLhandleARB program)
   6547 {
   6548    GET_CURRENT_CONTEXT(ctx);
   6549    Node *n;
   6550    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6551    n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
   6552    if (n) {
   6553       n[1].ui = program;
   6554    }
   6555    if (ctx->ExecuteFlag) {
   6556       CALL_UseProgramObjectARB(ctx->Exec, (program));
   6557    }
   6558 }
   6559 
   6560 
   6561 static void GLAPIENTRY
   6562 save_Uniform1fARB(GLint location, GLfloat x)
   6563 {
   6564    GET_CURRENT_CONTEXT(ctx);
   6565    Node *n;
   6566    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6567    n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
   6568    if (n) {
   6569       n[1].i = location;
   6570       n[2].f = x;
   6571    }
   6572    if (ctx->ExecuteFlag) {
   6573       CALL_Uniform1fARB(ctx->Exec, (location, x));
   6574    }
   6575 }
   6576 
   6577 
   6578 static void GLAPIENTRY
   6579 save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
   6580 {
   6581    GET_CURRENT_CONTEXT(ctx);
   6582    Node *n;
   6583    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6584    n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
   6585    if (n) {
   6586       n[1].i = location;
   6587       n[2].f = x;
   6588       n[3].f = y;
   6589    }
   6590    if (ctx->ExecuteFlag) {
   6591       CALL_Uniform2fARB(ctx->Exec, (location, x, y));
   6592    }
   6593 }
   6594 
   6595 
   6596 static void GLAPIENTRY
   6597 save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
   6598 {
   6599    GET_CURRENT_CONTEXT(ctx);
   6600    Node *n;
   6601    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6602    n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
   6603    if (n) {
   6604       n[1].i = location;
   6605       n[2].f = x;
   6606       n[3].f = y;
   6607       n[4].f = z;
   6608    }
   6609    if (ctx->ExecuteFlag) {
   6610       CALL_Uniform3fARB(ctx->Exec, (location, x, y, z));
   6611    }
   6612 }
   6613 
   6614 
   6615 static void GLAPIENTRY
   6616 save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
   6617 {
   6618    GET_CURRENT_CONTEXT(ctx);
   6619    Node *n;
   6620    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6621    n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
   6622    if (n) {
   6623       n[1].i = location;
   6624       n[2].f = x;
   6625       n[3].f = y;
   6626       n[4].f = z;
   6627       n[5].f = w;
   6628    }
   6629    if (ctx->ExecuteFlag) {
   6630       CALL_Uniform4fARB(ctx->Exec, (location, x, y, z, w));
   6631    }
   6632 }
   6633 
   6634 
   6635 /** Return copy of memory */
   6636 static void *
   6637 memdup(const void *src, GLsizei bytes)
   6638 {
   6639    void *b = bytes >= 0 ? malloc(bytes) : NULL;
   6640    if (b)
   6641       memcpy(b, src, bytes);
   6642    return b;
   6643 }
   6644 
   6645 
   6646 static void GLAPIENTRY
   6647 save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
   6648 {
   6649    GET_CURRENT_CONTEXT(ctx);
   6650    Node *n;
   6651    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6652    n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 3);
   6653    if (n) {
   6654       n[1].i = location;
   6655       n[2].i = count;
   6656       n[3].data = memdup(v, count * 1 * sizeof(GLfloat));
   6657    }
   6658    if (ctx->ExecuteFlag) {
   6659       CALL_Uniform1fvARB(ctx->Exec, (location, count, v));
   6660    }
   6661 }
   6662 
   6663 static void GLAPIENTRY
   6664 save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
   6665 {
   6666    GET_CURRENT_CONTEXT(ctx);
   6667    Node *n;
   6668    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6669    n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 3);
   6670    if (n) {
   6671       n[1].i = location;
   6672       n[2].i = count;
   6673       n[3].data = memdup(v, count * 2 * sizeof(GLfloat));
   6674    }
   6675    if (ctx->ExecuteFlag) {
   6676       CALL_Uniform2fvARB(ctx->Exec, (location, count, v));
   6677    }
   6678 }
   6679 
   6680 static void GLAPIENTRY
   6681 save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
   6682 {
   6683    GET_CURRENT_CONTEXT(ctx);
   6684    Node *n;
   6685    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6686    n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 3);
   6687    if (n) {
   6688       n[1].i = location;
   6689       n[2].i = count;
   6690       n[3].data = memdup(v, count * 3 * sizeof(GLfloat));
   6691    }
   6692    if (ctx->ExecuteFlag) {
   6693       CALL_Uniform3fvARB(ctx->Exec, (location, count, v));
   6694    }
   6695 }
   6696 
   6697 static void GLAPIENTRY
   6698 save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
   6699 {
   6700    GET_CURRENT_CONTEXT(ctx);
   6701    Node *n;
   6702    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6703    n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 3);
   6704    if (n) {
   6705       n[1].i = location;
   6706       n[2].i = count;
   6707       n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
   6708    }
   6709    if (ctx->ExecuteFlag) {
   6710       CALL_Uniform4fvARB(ctx->Exec, (location, count, v));
   6711    }
   6712 }
   6713 
   6714 
   6715 static void GLAPIENTRY
   6716 save_Uniform1iARB(GLint location, GLint x)
   6717 {
   6718    GET_CURRENT_CONTEXT(ctx);
   6719    Node *n;
   6720    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6721    n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
   6722    if (n) {
   6723       n[1].i = location;
   6724       n[2].i = x;
   6725    }
   6726    if (ctx->ExecuteFlag) {
   6727       CALL_Uniform1iARB(ctx->Exec, (location, x));
   6728    }
   6729 }
   6730 
   6731 static void GLAPIENTRY
   6732 save_Uniform2iARB(GLint location, GLint x, GLint y)
   6733 {
   6734    GET_CURRENT_CONTEXT(ctx);
   6735    Node *n;
   6736    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6737    n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
   6738    if (n) {
   6739       n[1].i = location;
   6740       n[2].i = x;
   6741       n[3].i = y;
   6742    }
   6743    if (ctx->ExecuteFlag) {
   6744       CALL_Uniform2iARB(ctx->Exec, (location, x, y));
   6745    }
   6746 }
   6747 
   6748 static void GLAPIENTRY
   6749 save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
   6750 {
   6751    GET_CURRENT_CONTEXT(ctx);
   6752    Node *n;
   6753    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6754    n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
   6755    if (n) {
   6756       n[1].i = location;
   6757       n[2].i = x;
   6758       n[3].i = y;
   6759       n[4].i = z;
   6760    }
   6761    if (ctx->ExecuteFlag) {
   6762       CALL_Uniform3iARB(ctx->Exec, (location, x, y, z));
   6763    }
   6764 }
   6765 
   6766 static void GLAPIENTRY
   6767 save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
   6768 {
   6769    GET_CURRENT_CONTEXT(ctx);
   6770    Node *n;
   6771    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6772    n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
   6773    if (n) {
   6774       n[1].i = location;
   6775       n[2].i = x;
   6776       n[3].i = y;
   6777       n[4].i = z;
   6778       n[5].i = w;
   6779    }
   6780    if (ctx->ExecuteFlag) {
   6781       CALL_Uniform4iARB(ctx->Exec, (location, x, y, z, w));
   6782    }
   6783 }
   6784 
   6785 
   6786 
   6787 static void GLAPIENTRY
   6788 save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
   6789 {
   6790    GET_CURRENT_CONTEXT(ctx);
   6791    Node *n;
   6792    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6793    n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 3);
   6794    if (n) {
   6795       n[1].i = location;
   6796       n[2].i = count;
   6797       n[3].data = memdup(v, count * 1 * sizeof(GLint));
   6798    }
   6799    if (ctx->ExecuteFlag) {
   6800       CALL_Uniform1ivARB(ctx->Exec, (location, count, v));
   6801    }
   6802 }
   6803 
   6804 static void GLAPIENTRY
   6805 save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
   6806 {
   6807    GET_CURRENT_CONTEXT(ctx);
   6808    Node *n;
   6809    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6810    n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 3);
   6811    if (n) {
   6812       n[1].i = location;
   6813       n[2].i = count;
   6814       n[3].data = memdup(v, count * 2 * sizeof(GLint));
   6815    }
   6816    if (ctx->ExecuteFlag) {
   6817       CALL_Uniform2ivARB(ctx->Exec, (location, count, v));
   6818    }
   6819 }
   6820 
   6821 static void GLAPIENTRY
   6822 save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
   6823 {
   6824    GET_CURRENT_CONTEXT(ctx);
   6825    Node *n;
   6826    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6827    n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 3);
   6828    if (n) {
   6829       n[1].i = location;
   6830       n[2].i = count;
   6831       n[3].data = memdup(v, count * 3 * sizeof(GLint));
   6832    }
   6833    if (ctx->ExecuteFlag) {
   6834       CALL_Uniform3ivARB(ctx->Exec, (location, count, v));
   6835    }
   6836 }
   6837 
   6838 static void GLAPIENTRY
   6839 save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
   6840 {
   6841    GET_CURRENT_CONTEXT(ctx);
   6842    Node *n;
   6843    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6844    n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 3);
   6845    if (n) {
   6846       n[1].i = location;
   6847       n[2].i = count;
   6848       n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
   6849    }
   6850    if (ctx->ExecuteFlag) {
   6851       CALL_Uniform4ivARB(ctx->Exec, (location, count, v));
   6852    }
   6853 }
   6854 
   6855 
   6856 
   6857 static void GLAPIENTRY
   6858 save_Uniform1ui(GLint location, GLuint x)
   6859 {
   6860    GET_CURRENT_CONTEXT(ctx);
   6861    Node *n;
   6862    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6863    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
   6864    if (n) {
   6865       n[1].i = location;
   6866       n[2].i = x;
   6867    }
   6868    if (ctx->ExecuteFlag) {
   6869       /*CALL_Uniform1ui(ctx->Exec, (location, x));*/
   6870    }
   6871 }
   6872 
   6873 static void GLAPIENTRY
   6874 save_Uniform2ui(GLint location, GLuint x, GLuint y)
   6875 {
   6876    GET_CURRENT_CONTEXT(ctx);
   6877    Node *n;
   6878    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6879    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
   6880    if (n) {
   6881       n[1].i = location;
   6882       n[2].i = x;
   6883       n[3].i = y;
   6884    }
   6885    if (ctx->ExecuteFlag) {
   6886       /*CALL_Uniform2ui(ctx->Exec, (location, x, y));*/
   6887    }
   6888 }
   6889 
   6890 static void GLAPIENTRY
   6891 save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
   6892 {
   6893    GET_CURRENT_CONTEXT(ctx);
   6894    Node *n;
   6895    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6896    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
   6897    if (n) {
   6898       n[1].i = location;
   6899       n[2].i = x;
   6900       n[3].i = y;
   6901       n[4].i = z;
   6902    }
   6903    if (ctx->ExecuteFlag) {
   6904       /*CALL_Uniform3ui(ctx->Exec, (location, x, y, z));*/
   6905    }
   6906 }
   6907 
   6908 static void GLAPIENTRY
   6909 save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
   6910 {
   6911    GET_CURRENT_CONTEXT(ctx);
   6912    Node *n;
   6913    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6914    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
   6915    if (n) {
   6916       n[1].i = location;
   6917       n[2].i = x;
   6918       n[3].i = y;
   6919       n[4].i = z;
   6920       n[5].i = w;
   6921    }
   6922    if (ctx->ExecuteFlag) {
   6923       /*CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));*/
   6924    }
   6925 }
   6926 
   6927 
   6928 
   6929 static void GLAPIENTRY
   6930 save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)
   6931 {
   6932    GET_CURRENT_CONTEXT(ctx);
   6933    Node *n;
   6934    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6935    n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 3);
   6936    if (n) {
   6937       n[1].i = location;
   6938       n[2].i = count;
   6939       n[3].data = memdup(v, count * 1 * sizeof(*v));
   6940    }
   6941    if (ctx->ExecuteFlag) {
   6942       /*CALL_Uniform1uiv(ctx->Exec, (location, count, v));*/
   6943    }
   6944 }
   6945 
   6946 static void GLAPIENTRY
   6947 save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)
   6948 {
   6949    GET_CURRENT_CONTEXT(ctx);
   6950    Node *n;
   6951    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6952    n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 3);
   6953    if (n) {
   6954       n[1].i = location;
   6955       n[2].i = count;
   6956       n[3].data = memdup(v, count * 2 * sizeof(*v));
   6957    }
   6958    if (ctx->ExecuteFlag) {
   6959       /*CALL_Uniform2uiv(ctx->Exec, (location, count, v));*/
   6960    }
   6961 }
   6962 
   6963 static void GLAPIENTRY
   6964 save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)
   6965 {
   6966    GET_CURRENT_CONTEXT(ctx);
   6967    Node *n;
   6968    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6969    n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 3);
   6970    if (n) {
   6971       n[1].i = location;
   6972       n[2].i = count;
   6973       n[3].data = memdup(v, count * 3 * sizeof(*v));
   6974    }
   6975    if (ctx->ExecuteFlag) {
   6976       /*CALL_Uniform3uiv(ctx->Exec, (location, count, v));*/
   6977    }
   6978 }
   6979 
   6980 static void GLAPIENTRY
   6981 save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)
   6982 {
   6983    GET_CURRENT_CONTEXT(ctx);
   6984    Node *n;
   6985    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   6986    n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 3);
   6987    if (n) {
   6988       n[1].i = location;
   6989       n[2].i = count;
   6990       n[3].data = memdup(v, count * 4 * sizeof(*v));
   6991    }
   6992    if (ctx->ExecuteFlag) {
   6993       /*CALL_Uniform4uiv(ctx->Exec, (location, count, v));*/
   6994    }
   6995 }
   6996 
   6997 
   6998 
   6999 static void GLAPIENTRY
   7000 save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
   7001                          const GLfloat *m)
   7002 {
   7003    GET_CURRENT_CONTEXT(ctx);
   7004    Node *n;
   7005    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7006    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 4);
   7007    if (n) {
   7008       n[1].i = location;
   7009       n[2].i = count;
   7010       n[3].b = transpose;
   7011       n[4].data = memdup(m, count * 2 * 2 * sizeof(GLfloat));
   7012    }
   7013    if (ctx->ExecuteFlag) {
   7014       CALL_UniformMatrix2fvARB(ctx->Exec, (location, count, transpose, m));
   7015    }
   7016 }
   7017 
   7018 static void GLAPIENTRY
   7019 save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
   7020                          const GLfloat *m)
   7021 {
   7022    GET_CURRENT_CONTEXT(ctx);
   7023    Node *n;
   7024    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7025    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 4);
   7026    if (n) {
   7027       n[1].i = location;
   7028       n[2].i = count;
   7029       n[3].b = transpose;
   7030       n[4].data = memdup(m, count * 3 * 3 * sizeof(GLfloat));
   7031    }
   7032    if (ctx->ExecuteFlag) {
   7033       CALL_UniformMatrix3fvARB(ctx->Exec, (location, count, transpose, m));
   7034    }
   7035 }
   7036 
   7037 static void GLAPIENTRY
   7038 save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
   7039                          const GLfloat *m)
   7040 {
   7041    GET_CURRENT_CONTEXT(ctx);
   7042    Node *n;
   7043    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7044    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 4);
   7045    if (n) {
   7046       n[1].i = location;
   7047       n[2].i = count;
   7048       n[3].b = transpose;
   7049       n[4].data = memdup(m, count * 4 * 4 * sizeof(GLfloat));
   7050    }
   7051    if (ctx->ExecuteFlag) {
   7052       CALL_UniformMatrix4fvARB(ctx->Exec, (location, count, transpose, m));
   7053    }
   7054 }
   7055 
   7056 
   7057 static void GLAPIENTRY
   7058 save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
   7059                         const GLfloat *m)
   7060 {
   7061    GET_CURRENT_CONTEXT(ctx);
   7062    Node *n;
   7063    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7064    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 4);
   7065    if (n) {
   7066       n[1].i = location;
   7067       n[2].i = count;
   7068       n[3].b = transpose;
   7069       n[4].data = memdup(m, count * 2 * 3 * sizeof(GLfloat));
   7070    }
   7071    if (ctx->ExecuteFlag) {
   7072       CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
   7073    }
   7074 }
   7075 
   7076 static void GLAPIENTRY
   7077 save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
   7078                         const GLfloat *m)
   7079 {
   7080    GET_CURRENT_CONTEXT(ctx);
   7081    Node *n;
   7082    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7083    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 4);
   7084    if (n) {
   7085       n[1].i = location;
   7086       n[2].i = count;
   7087       n[3].b = transpose;
   7088       n[4].data = memdup(m, count * 3 * 2 * sizeof(GLfloat));
   7089    }
   7090    if (ctx->ExecuteFlag) {
   7091       CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
   7092    }
   7093 }
   7094 
   7095 
   7096 static void GLAPIENTRY
   7097 save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
   7098                         const GLfloat *m)
   7099 {
   7100    GET_CURRENT_CONTEXT(ctx);
   7101    Node *n;
   7102    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7103    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 4);
   7104    if (n) {
   7105       n[1].i = location;
   7106       n[2].i = count;
   7107       n[3].b = transpose;
   7108       n[4].data = memdup(m, count * 2 * 4 * sizeof(GLfloat));
   7109    }
   7110    if (ctx->ExecuteFlag) {
   7111       CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
   7112    }
   7113 }
   7114 
   7115 static void GLAPIENTRY
   7116 save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
   7117                         const GLfloat *m)
   7118 {
   7119    GET_CURRENT_CONTEXT(ctx);
   7120    Node *n;
   7121    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7122    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 4);
   7123    if (n) {
   7124       n[1].i = location;
   7125       n[2].i = count;
   7126       n[3].b = transpose;
   7127       n[4].data = memdup(m, count * 4 * 2 * sizeof(GLfloat));
   7128    }
   7129    if (ctx->ExecuteFlag) {
   7130       CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
   7131    }
   7132 }
   7133 
   7134 
   7135 static void GLAPIENTRY
   7136 save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
   7137                         const GLfloat *m)
   7138 {
   7139    GET_CURRENT_CONTEXT(ctx);
   7140    Node *n;
   7141    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7142    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 4);
   7143    if (n) {
   7144       n[1].i = location;
   7145       n[2].i = count;
   7146       n[3].b = transpose;
   7147       n[4].data = memdup(m, count * 3 * 4 * sizeof(GLfloat));
   7148    }
   7149    if (ctx->ExecuteFlag) {
   7150       CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
   7151    }
   7152 }
   7153 
   7154 static void GLAPIENTRY
   7155 save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
   7156                         const GLfloat *m)
   7157 {
   7158    GET_CURRENT_CONTEXT(ctx);
   7159    Node *n;
   7160    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7161    n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 4);
   7162    if (n) {
   7163       n[1].i = location;
   7164       n[2].i = count;
   7165       n[3].b = transpose;
   7166       n[4].data = memdup(m, count * 4 * 3 * sizeof(GLfloat));
   7167    }
   7168    if (ctx->ExecuteFlag) {
   7169       CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
   7170    }
   7171 }
   7172 
   7173 static void GLAPIENTRY
   7174 save_ClampColorARB(GLenum target, GLenum clamp)
   7175 {
   7176    GET_CURRENT_CONTEXT(ctx);
   7177    Node *n;
   7178    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7179    n = alloc_instruction(ctx, OPCODE_CLAMP_COLOR, 2);
   7180    if (n) {
   7181       n[1].e = target;
   7182       n[2].e = clamp;
   7183    }
   7184    if (ctx->ExecuteFlag) {
   7185       CALL_ClampColorARB(ctx->Exec, (target, clamp));
   7186    }
   7187 }
   7188 
   7189 static void GLAPIENTRY
   7190 save_UseShaderProgramEXT(GLenum type, GLuint program)
   7191 {
   7192    GET_CURRENT_CONTEXT(ctx);
   7193    Node *n;
   7194    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7195    n = alloc_instruction(ctx, OPCODE_USE_SHADER_PROGRAM_EXT, 2);
   7196    if (n) {
   7197       n[1].ui = type;
   7198       n[2].ui = program;
   7199    }
   7200    if (ctx->ExecuteFlag) {
   7201       CALL_UseShaderProgramEXT(ctx->Exec, (type, program));
   7202    }
   7203 }
   7204 
   7205 static void GLAPIENTRY
   7206 save_ActiveProgramEXT(GLuint program)
   7207 {
   7208    GET_CURRENT_CONTEXT(ctx);
   7209    Node *n;
   7210    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7211    n = alloc_instruction(ctx, OPCODE_ACTIVE_PROGRAM_EXT, 1);
   7212    if (n) {
   7213       n[1].ui = program;
   7214    }
   7215    if (ctx->ExecuteFlag) {
   7216       CALL_ActiveProgramEXT(ctx->Exec, (program));
   7217    }
   7218 }
   7219 
   7220 /** GL_EXT_texture_integer */
   7221 static void GLAPIENTRY
   7222 save_ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)
   7223 {
   7224    GET_CURRENT_CONTEXT(ctx);
   7225    Node *n;
   7226    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7227    n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_I, 4);
   7228    if (n) {
   7229       n[1].i = red;
   7230       n[2].i = green;
   7231       n[3].i = blue;
   7232       n[4].i = alpha;
   7233    }
   7234    if (ctx->ExecuteFlag) {
   7235       CALL_ClearColorIiEXT(ctx->Exec, (red, green, blue, alpha));
   7236    }
   7237 }
   7238 
   7239 /** GL_EXT_texture_integer */
   7240 static void GLAPIENTRY
   7241 save_ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
   7242 {
   7243    GET_CURRENT_CONTEXT(ctx);
   7244    Node *n;
   7245    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7246    n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_UI, 4);
   7247    if (n) {
   7248       n[1].ui = red;
   7249       n[2].ui = green;
   7250       n[3].ui = blue;
   7251       n[4].ui = alpha;
   7252    }
   7253    if (ctx->ExecuteFlag) {
   7254       CALL_ClearColorIuiEXT(ctx->Exec, (red, green, blue, alpha));
   7255    }
   7256 }
   7257 
   7258 /** GL_EXT_texture_integer */
   7259 static void GLAPIENTRY
   7260 save_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
   7261 {
   7262    GET_CURRENT_CONTEXT(ctx);
   7263    Node *n;
   7264    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7265    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_I, 6);
   7266    if (n) {
   7267       n[1].e = target;
   7268       n[2].e = pname;
   7269       n[3].i = params[0];
   7270       n[4].i = params[1];
   7271       n[5].i = params[2];
   7272       n[6].i = params[3];
   7273    }
   7274    if (ctx->ExecuteFlag) {
   7275       CALL_TexParameterIivEXT(ctx->Exec, (target, pname, params));
   7276    }
   7277 }
   7278 
   7279 /** GL_EXT_texture_integer */
   7280 static void GLAPIENTRY
   7281 save_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
   7282 {
   7283    GET_CURRENT_CONTEXT(ctx);
   7284    Node *n;
   7285    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7286    n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_UI, 6);
   7287    if (n) {
   7288       n[1].e = target;
   7289       n[2].e = pname;
   7290       n[3].ui = params[0];
   7291       n[4].ui = params[1];
   7292       n[5].ui = params[2];
   7293       n[6].ui = params[3];
   7294    }
   7295    if (ctx->ExecuteFlag) {
   7296       CALL_TexParameterIuivEXT(ctx->Exec, (target, pname, params));
   7297    }
   7298 }
   7299 
   7300 /** GL_EXT_texture_integer */
   7301 static void GLAPIENTRY
   7302 exec_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
   7303 {
   7304    GET_CURRENT_CONTEXT(ctx);
   7305    FLUSH_VERTICES(ctx, 0);
   7306    CALL_GetTexParameterIivEXT(ctx->Exec, (target, pname, params));
   7307 }
   7308 
   7309 /** GL_EXT_texture_integer */
   7310 static void GLAPIENTRY
   7311 exec_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
   7312 {
   7313    GET_CURRENT_CONTEXT(ctx);
   7314    FLUSH_VERTICES(ctx, 0);
   7315    CALL_GetTexParameterIuivEXT(ctx->Exec, (target, pname, params));
   7316 }
   7317 
   7318 
   7319 /* GL_ARB_instanced_arrays */
   7320 static void GLAPIENTRY
   7321 save_VertexAttribDivisor(GLuint index, GLuint divisor)
   7322 {
   7323    GET_CURRENT_CONTEXT(ctx);
   7324    Node *n;
   7325    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7326    n = alloc_instruction(ctx, OPCODE_VERTEX_ATTRIB_DIVISOR, 2);
   7327    if (n) {
   7328       n[1].ui = index;
   7329       n[2].ui = divisor;
   7330    }
   7331    if (ctx->ExecuteFlag) {
   7332       CALL_VertexAttribDivisorARB(ctx->Exec, (index, divisor));
   7333    }
   7334 }
   7335 
   7336 
   7337 /* GL_NV_texture_barrier */
   7338 static void GLAPIENTRY
   7339 save_TextureBarrierNV(void)
   7340 {
   7341    GET_CURRENT_CONTEXT(ctx);
   7342    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7343    alloc_instruction(ctx, OPCODE_TEXTURE_BARRIER_NV, 0);
   7344    if (ctx->ExecuteFlag) {
   7345       CALL_TextureBarrierNV(ctx->Exec, ());
   7346    }
   7347 }
   7348 
   7349 
   7350 /* GL_ARB_sampler_objects */
   7351 static void GLAPIENTRY
   7352 save_BindSampler(GLuint unit, GLuint sampler)
   7353 {
   7354    Node *n;
   7355    GET_CURRENT_CONTEXT(ctx);
   7356    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7357    n = alloc_instruction(ctx, OPCODE_BIND_SAMPLER, 2);
   7358    if (n) {
   7359       n[1].ui = unit;
   7360       n[2].ui = sampler;
   7361    }
   7362    if (ctx->ExecuteFlag) {
   7363       CALL_BindSampler(ctx->Exec, (unit, sampler));
   7364    }
   7365 }
   7366 
   7367 static void GLAPIENTRY
   7368 save_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params)
   7369 {
   7370    Node *n;
   7371    GET_CURRENT_CONTEXT(ctx);
   7372    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7373    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIV, 6);
   7374    if (n) {
   7375       n[1].ui = sampler;
   7376       n[2].e = pname;
   7377       n[3].i = params[0];
   7378       if (pname == GL_TEXTURE_BORDER_COLOR) {
   7379          n[4].i = params[1];
   7380          n[5].i = params[2];
   7381          n[6].i = params[3];
   7382       }
   7383       else {
   7384          n[4].i = n[5].i = n[6].i = 0;
   7385       }
   7386    }
   7387    if (ctx->ExecuteFlag) {
   7388       CALL_SamplerParameteriv(ctx->Exec, (sampler, pname, params));
   7389    }
   7390 }
   7391 
   7392 static void GLAPIENTRY
   7393 save_SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
   7394 {
   7395    save_SamplerParameteriv(sampler, pname, &param);
   7396 }
   7397 
   7398 static void GLAPIENTRY
   7399 save_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params)
   7400 {
   7401    Node *n;
   7402    GET_CURRENT_CONTEXT(ctx);
   7403    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7404    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERFV, 6);
   7405    if (n) {
   7406       n[1].ui = sampler;
   7407       n[2].e = pname;
   7408       n[3].f = params[0];
   7409       if (pname == GL_TEXTURE_BORDER_COLOR) {
   7410          n[4].f = params[1];
   7411          n[5].f = params[2];
   7412          n[6].f = params[3];
   7413       }
   7414       else {
   7415          n[4].f = n[5].f = n[6].f = 0.0F;
   7416       }
   7417    }
   7418    if (ctx->ExecuteFlag) {
   7419       CALL_SamplerParameterfv(ctx->Exec, (sampler, pname, params));
   7420    }
   7421 }
   7422 
   7423 static void GLAPIENTRY
   7424 save_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
   7425 {
   7426    save_SamplerParameterfv(sampler, pname, &param);
   7427 }
   7428 
   7429 static void GLAPIENTRY
   7430 save_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params)
   7431 {
   7432    Node *n;
   7433    GET_CURRENT_CONTEXT(ctx);
   7434    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7435    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIIV, 6);
   7436    if (n) {
   7437       n[1].ui = sampler;
   7438       n[2].e = pname;
   7439       n[3].i = params[0];
   7440       if (pname == GL_TEXTURE_BORDER_COLOR) {
   7441          n[4].i = params[1];
   7442          n[5].i = params[2];
   7443          n[6].i = params[3];
   7444       }
   7445       else {
   7446          n[4].i = n[5].i = n[6].i = 0;
   7447       }
   7448    }
   7449    if (ctx->ExecuteFlag) {
   7450       CALL_SamplerParameterIiv(ctx->Exec, (sampler, pname, params));
   7451    }
   7452 }
   7453 
   7454 static void GLAPIENTRY
   7455 save_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params)
   7456 {
   7457    Node *n;
   7458    GET_CURRENT_CONTEXT(ctx);
   7459    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7460    n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERUIV, 6);
   7461    if (n) {
   7462       n[1].ui = sampler;
   7463       n[2].e = pname;
   7464       n[3].ui = params[0];
   7465       if (pname == GL_TEXTURE_BORDER_COLOR) {
   7466          n[4].ui = params[1];
   7467          n[5].ui = params[2];
   7468          n[6].ui = params[3];
   7469       }
   7470       else {
   7471          n[4].ui = n[5].ui = n[6].ui = 0;
   7472       }
   7473    }
   7474    if (ctx->ExecuteFlag) {
   7475       CALL_SamplerParameterIuiv(ctx->Exec, (sampler, pname, params));
   7476    }
   7477 }
   7478 
   7479 /* GL_ARB_geometry_shader4 */
   7480 static void GLAPIENTRY
   7481 save_ProgramParameteri(GLuint program, GLenum pname, GLint value)
   7482 {
   7483    Node *n;
   7484    GET_CURRENT_CONTEXT(ctx);
   7485    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7486    n = alloc_instruction(ctx, OPCODE_PROGRAM_PARAMETERI, 3);
   7487    if (n) {
   7488       n[1].ui = program;
   7489       n[2].e = pname;
   7490       n[3].i = value;
   7491    }
   7492    if (ctx->ExecuteFlag) {
   7493       CALL_ProgramParameteriARB(ctx->Exec, (program, pname, value));
   7494    }
   7495 }
   7496 
   7497 static void GLAPIENTRY
   7498 save_FramebufferTexture(GLenum target, GLenum attachment,
   7499                         GLuint texture, GLint level)
   7500 {
   7501    Node *n;
   7502    GET_CURRENT_CONTEXT(ctx);
   7503    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7504    n = alloc_instruction(ctx, OPCODE_FRAMEBUFFER_TEXTURE, 4);
   7505    if (n) {
   7506       n[1].e = target;
   7507       n[2].e = attachment;
   7508       n[3].ui = texture;
   7509       n[4].i = level;
   7510    }
   7511    if (ctx->ExecuteFlag) {
   7512       CALL_FramebufferTextureARB(ctx->Exec, (target, attachment, texture, level));
   7513    }
   7514 }
   7515 
   7516 static void GLAPIENTRY
   7517 save_FramebufferTextureFace(GLenum target, GLenum attachment,
   7518                             GLuint texture, GLint level, GLenum face)
   7519 {
   7520    Node *n;
   7521    GET_CURRENT_CONTEXT(ctx);
   7522    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7523    n = alloc_instruction(ctx, OPCODE_FRAMEBUFFER_TEXTURE_FACE, 5);
   7524    if (n) {
   7525       n[1].e = target;
   7526       n[2].e = attachment;
   7527       n[3].ui = texture;
   7528       n[4].i = level;
   7529       n[5].e = face;
   7530    }
   7531    if (ctx->ExecuteFlag) {
   7532       CALL_FramebufferTextureFaceARB(ctx->Exec, (target, attachment, texture,
   7533                                                  level, face));
   7534    }
   7535 }
   7536 
   7537 
   7538 
   7539 static void GLAPIENTRY
   7540 save_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
   7541 {
   7542    Node *n;
   7543    GET_CURRENT_CONTEXT(ctx);
   7544    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7545    n = alloc_instruction(ctx, OPCODE_WAIT_SYNC, 4);
   7546    if (n) {
   7547       union uint64_pair p;
   7548       p.uint64 = timeout;
   7549       n[1].data = sync;
   7550       n[2].e = flags;
   7551       n[3].ui = p.uint32[0];
   7552       n[4].ui = p.uint32[1];
   7553    }
   7554    if (ctx->ExecuteFlag) {
   7555       CALL_WaitSync(ctx->Exec, (sync, flags, timeout));
   7556    }
   7557 }
   7558 
   7559 
   7560 /** GL_NV_conditional_render */
   7561 static void GLAPIENTRY
   7562 save_BeginConditionalRender(GLuint queryId, GLenum mode)
   7563 {
   7564    GET_CURRENT_CONTEXT(ctx);
   7565    Node *n;
   7566    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7567    n = alloc_instruction(ctx, OPCODE_BEGIN_CONDITIONAL_RENDER, 2);
   7568    if (n) {
   7569       n[1].i = queryId;
   7570       n[2].e = mode;
   7571    }
   7572    if (ctx->ExecuteFlag) {
   7573       CALL_BeginConditionalRenderNV(ctx->Exec, (queryId, mode));
   7574    }
   7575 }
   7576 
   7577 static void GLAPIENTRY
   7578 save_EndConditionalRender(void)
   7579 {
   7580    GET_CURRENT_CONTEXT(ctx);
   7581    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7582    alloc_instruction(ctx, OPCODE_END_CONDITIONAL_RENDER, 0);
   7583    if (ctx->ExecuteFlag) {
   7584       CALL_EndConditionalRenderNV(ctx->Exec, ());
   7585    }
   7586 }
   7587 
   7588 static void GLAPIENTRY
   7589 save_UniformBlockBinding(GLuint prog, GLuint index, GLuint binding)
   7590 {
   7591    GET_CURRENT_CONTEXT(ctx);
   7592    Node *n;
   7593    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
   7594    n = alloc_instruction(ctx, OPCODE_UNIFORM_BLOCK_BINDING, 3);
   7595    if (n) {
   7596       n[1].ui = prog;
   7597       n[2].ui = index;
   7598       n[3].ui = binding;
   7599    }
   7600    if (ctx->ExecuteFlag) {
   7601       CALL_UniformBlockBinding(ctx->Exec, (prog, index, binding));
   7602    }
   7603 }
   7604 
   7605 
   7606 /**
   7607  * Save an error-generating command into display list.
   7608  *
   7609  * KW: Will appear in the list before the vertex buffer containing the
   7610  * command that provoked the error.  I don't see this as a problem.
   7611  */
   7612 static void
   7613 save_error(struct gl_context *ctx, GLenum error, const char *s)
   7614 {
   7615    Node *n;
   7616    n = alloc_instruction(ctx, OPCODE_ERROR, 2);
   7617    if (n) {
   7618       n[1].e = error;
   7619       n[2].data = (void *) s;
   7620    }
   7621 }
   7622 
   7623 
   7624 /**
   7625  * Compile an error into current display list.
   7626  */
   7627 void
   7628 _mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s)
   7629 {
   7630    if (ctx->CompileFlag)
   7631       save_error(ctx, error, s);
   7632    if (ctx->ExecuteFlag)
   7633       _mesa_error(ctx, error, "%s", s);
   7634 }
   7635 
   7636 
   7637 /**
   7638  * Test if ID names a display list.
   7639  */
   7640 static GLboolean
   7641 islist(struct gl_context *ctx, GLuint list)
   7642 {
   7643    if (list > 0 && lookup_list(ctx, list)) {
   7644       return GL_TRUE;
   7645    }
   7646    else {
   7647       return GL_FALSE;
   7648    }
   7649 }
   7650 
   7651 
   7652 
   7653 /**********************************************************************/
   7654 /*                     Display list execution                         */
   7655 /**********************************************************************/
   7656 
   7657 
   7658 /*
   7659  * Execute a display list.  Note that the ListBase offset must have already
   7660  * been added before calling this function.  I.e. the list argument is
   7661  * the absolute list number, not relative to ListBase.
   7662  * \param list - display list number
   7663  */
   7664 static void
   7665 execute_list(struct gl_context *ctx, GLuint list)
   7666 {
   7667    struct gl_display_list *dlist;
   7668    Node *n;
   7669    GLboolean done;
   7670 
   7671    if (list == 0 || !islist(ctx, list))
   7672       return;
   7673 
   7674    if (ctx->ListState.CallDepth == MAX_LIST_NESTING) {
   7675       /* raise an error? */
   7676       return;
   7677    }
   7678 
   7679    dlist = lookup_list(ctx, list);
   7680    if (!dlist)
   7681       return;
   7682 
   7683    ctx->ListState.CallDepth++;
   7684 
   7685    if (ctx->Driver.BeginCallList)
   7686       ctx->Driver.BeginCallList(ctx, dlist);
   7687 
   7688    n = dlist->Head;
   7689 
   7690    done = GL_FALSE;
   7691    while (!done) {
   7692       const OpCode opcode = n[0].opcode;
   7693 
   7694       if (is_ext_opcode(opcode)) {
   7695          n += ext_opcode_execute(ctx, n);
   7696       }
   7697       else {
   7698          switch (opcode) {
   7699          case OPCODE_ERROR:
   7700             _mesa_error(ctx, n[1].e, "%s", (const char *) n[2].data);
   7701             break;
   7702          case OPCODE_ACCUM:
   7703             CALL_Accum(ctx->Exec, (n[1].e, n[2].f));
   7704             break;
   7705          case OPCODE_ALPHA_FUNC:
   7706             CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));
   7707             break;
   7708          case OPCODE_BIND_TEXTURE:
   7709             CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));
   7710             break;
   7711          case OPCODE_BITMAP:
   7712             {
   7713                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7714                ctx->Unpack = ctx->DefaultPacking;
   7715                CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,
   7716                                        n[3].f, n[4].f, n[5].f, n[6].f,
   7717                                        (const GLubyte *) n[7].data));
   7718                ctx->Unpack = save;      /* restore */
   7719             }
   7720             break;
   7721          case OPCODE_BLEND_COLOR:
   7722             CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   7723             break;
   7724          case OPCODE_BLEND_EQUATION:
   7725             CALL_BlendEquation(ctx->Exec, (n[1].e));
   7726             break;
   7727          case OPCODE_BLEND_EQUATION_SEPARATE:
   7728             CALL_BlendEquationSeparateEXT(ctx->Exec, (n[1].e, n[2].e));
   7729             break;
   7730          case OPCODE_BLEND_FUNC_SEPARATE:
   7731             CALL_BlendFuncSeparateEXT(ctx->Exec,
   7732                                       (n[1].e, n[2].e, n[3].e, n[4].e));
   7733             break;
   7734 
   7735          case OPCODE_BLEND_FUNC_I:
   7736             /* GL_ARB_draw_buffers_blend */
   7737             CALL_BlendFunciARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e));
   7738             break;
   7739          case OPCODE_BLEND_FUNC_SEPARATE_I:
   7740             /* GL_ARB_draw_buffers_blend */
   7741             CALL_BlendFuncSeparateiARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e,
   7742                                                    n[4].e, n[5].e));
   7743             break;
   7744          case OPCODE_BLEND_EQUATION_I:
   7745             /* GL_ARB_draw_buffers_blend */
   7746             CALL_BlendEquationiARB(ctx->Exec, (n[1].ui, n[2].e));
   7747             break;
   7748          case OPCODE_BLEND_EQUATION_SEPARATE_I:
   7749             /* GL_ARB_draw_buffers_blend */
   7750             CALL_BlendEquationSeparateiARB(ctx->Exec,
   7751                                            (n[1].ui, n[2].e, n[3].e));
   7752             break;
   7753 
   7754          case OPCODE_CALL_LIST:
   7755             /* Generated by glCallList(), don't add ListBase */
   7756             if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
   7757                execute_list(ctx, n[1].ui);
   7758             }
   7759             break;
   7760          case OPCODE_CALL_LIST_OFFSET:
   7761             /* Generated by glCallLists() so we must add ListBase */
   7762             if (n[2].b) {
   7763                /* user specified a bad data type at compile time */
   7764                _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
   7765             }
   7766             else if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
   7767                GLuint list = (GLuint) (ctx->List.ListBase + n[1].i);
   7768                execute_list(ctx, list);
   7769             }
   7770             break;
   7771          case OPCODE_CLEAR:
   7772             CALL_Clear(ctx->Exec, (n[1].bf));
   7773             break;
   7774          case OPCODE_CLEAR_BUFFER_IV:
   7775             {
   7776                GLint value[4];
   7777                value[0] = n[3].i;
   7778                value[1] = n[4].i;
   7779                value[2] = n[5].i;
   7780                value[3] = n[6].i;
   7781                CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));
   7782             }
   7783             break;
   7784          case OPCODE_CLEAR_BUFFER_UIV:
   7785             {
   7786                GLuint value[4];
   7787                value[0] = n[3].ui;
   7788                value[1] = n[4].ui;
   7789                value[2] = n[5].ui;
   7790                value[3] = n[6].ui;
   7791                CALL_ClearBufferuiv(ctx->Exec, (n[1].e, n[2].i, value));
   7792             }
   7793             break;
   7794          case OPCODE_CLEAR_BUFFER_FV:
   7795             {
   7796                GLfloat value[4];
   7797                value[0] = n[3].f;
   7798                value[1] = n[4].f;
   7799                value[2] = n[5].f;
   7800                value[3] = n[6].f;
   7801                CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));
   7802             }
   7803             break;
   7804          case OPCODE_CLEAR_BUFFER_FI:
   7805             CALL_ClearBufferfi(ctx->Exec, (n[1].e, n[2].i, n[3].f, n[4].i));
   7806             break;
   7807          case OPCODE_CLEAR_COLOR:
   7808             CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   7809             break;
   7810          case OPCODE_CLEAR_ACCUM:
   7811             CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   7812             break;
   7813          case OPCODE_CLEAR_DEPTH:
   7814             CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));
   7815             break;
   7816          case OPCODE_CLEAR_INDEX:
   7817             CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));
   7818             break;
   7819          case OPCODE_CLEAR_STENCIL:
   7820             CALL_ClearStencil(ctx->Exec, (n[1].i));
   7821             break;
   7822          case OPCODE_CLIP_PLANE:
   7823             {
   7824                GLdouble eq[4];
   7825                eq[0] = n[2].f;
   7826                eq[1] = n[3].f;
   7827                eq[2] = n[4].f;
   7828                eq[3] = n[5].f;
   7829                CALL_ClipPlane(ctx->Exec, (n[1].e, eq));
   7830             }
   7831             break;
   7832          case OPCODE_COLOR_MASK:
   7833             CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));
   7834             break;
   7835          case OPCODE_COLOR_MASK_INDEXED:
   7836             CALL_ColorMaskIndexedEXT(ctx->Exec, (n[1].ui, n[2].b, n[3].b,
   7837                                                  n[4].b, n[5].b));
   7838             break;
   7839          case OPCODE_COLOR_MATERIAL:
   7840             CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));
   7841             break;
   7842          case OPCODE_COLOR_TABLE:
   7843             {
   7844                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7845                ctx->Unpack = ctx->DefaultPacking;
   7846                CALL_ColorTable(ctx->Exec, (n[1].e, n[2].e, n[3].i, n[4].e,
   7847                                            n[5].e, n[6].data));
   7848                ctx->Unpack = save;      /* restore */
   7849             }
   7850             break;
   7851          case OPCODE_COLOR_TABLE_PARAMETER_FV:
   7852             {
   7853                GLfloat params[4];
   7854                params[0] = n[3].f;
   7855                params[1] = n[4].f;
   7856                params[2] = n[5].f;
   7857                params[3] = n[6].f;
   7858                CALL_ColorTableParameterfv(ctx->Exec,
   7859                                           (n[1].e, n[2].e, params));
   7860             }
   7861             break;
   7862          case OPCODE_COLOR_TABLE_PARAMETER_IV:
   7863             {
   7864                GLint params[4];
   7865                params[0] = n[3].i;
   7866                params[1] = n[4].i;
   7867                params[2] = n[5].i;
   7868                params[3] = n[6].i;
   7869                CALL_ColorTableParameteriv(ctx->Exec,
   7870                                           (n[1].e, n[2].e, params));
   7871             }
   7872             break;
   7873          case OPCODE_COLOR_SUB_TABLE:
   7874             {
   7875                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7876                ctx->Unpack = ctx->DefaultPacking;
   7877                CALL_ColorSubTable(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7878                                               n[4].e, n[5].e, n[6].data));
   7879                ctx->Unpack = save;      /* restore */
   7880             }
   7881             break;
   7882          case OPCODE_CONVOLUTION_FILTER_1D:
   7883             {
   7884                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7885                ctx->Unpack = ctx->DefaultPacking;
   7886                CALL_ConvolutionFilter1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7887                                                     n[4].e, n[5].e,
   7888                                                     n[6].data));
   7889                ctx->Unpack = save;      /* restore */
   7890             }
   7891             break;
   7892          case OPCODE_CONVOLUTION_FILTER_2D:
   7893             {
   7894                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7895                ctx->Unpack = ctx->DefaultPacking;
   7896                CALL_ConvolutionFilter2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7897                                                     n[4].i, n[5].e, n[6].e,
   7898                                                     n[7].data));
   7899                ctx->Unpack = save;      /* restore */
   7900             }
   7901             break;
   7902          case OPCODE_CONVOLUTION_PARAMETER_I:
   7903             CALL_ConvolutionParameteri(ctx->Exec, (n[1].e, n[2].e, n[3].i));
   7904             break;
   7905          case OPCODE_CONVOLUTION_PARAMETER_IV:
   7906             {
   7907                GLint params[4];
   7908                params[0] = n[3].i;
   7909                params[1] = n[4].i;
   7910                params[2] = n[5].i;
   7911                params[3] = n[6].i;
   7912                CALL_ConvolutionParameteriv(ctx->Exec,
   7913                                            (n[1].e, n[2].e, params));
   7914             }
   7915             break;
   7916          case OPCODE_CONVOLUTION_PARAMETER_F:
   7917             CALL_ConvolutionParameterf(ctx->Exec, (n[1].e, n[2].e, n[3].f));
   7918             break;
   7919          case OPCODE_CONVOLUTION_PARAMETER_FV:
   7920             {
   7921                GLfloat params[4];
   7922                params[0] = n[3].f;
   7923                params[1] = n[4].f;
   7924                params[2] = n[5].f;
   7925                params[3] = n[6].f;
   7926                CALL_ConvolutionParameterfv(ctx->Exec,
   7927                                            (n[1].e, n[2].e, params));
   7928             }
   7929             break;
   7930          case OPCODE_COPY_COLOR_SUB_TABLE:
   7931             CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
   7932                                                n[3].i, n[4].i, n[5].i));
   7933             break;
   7934          case OPCODE_COPY_COLOR_TABLE:
   7935             CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
   7936                                                n[3].i, n[4].i, n[5].i));
   7937             break;
   7938          case OPCODE_COPY_PIXELS:
   7939             CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,
   7940                                         (GLsizei) n[3].i, (GLsizei) n[4].i,
   7941                                         n[5].e));
   7942             break;
   7943          case OPCODE_COPY_TEX_IMAGE1D:
   7944             CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
   7945                                             n[5].i, n[6].i, n[7].i));
   7946             break;
   7947          case OPCODE_COPY_TEX_IMAGE2D:
   7948             CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
   7949                                             n[5].i, n[6].i, n[7].i, n[8].i));
   7950             break;
   7951          case OPCODE_COPY_TEX_SUB_IMAGE1D:
   7952             CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7953                                                n[4].i, n[5].i, n[6].i));
   7954             break;
   7955          case OPCODE_COPY_TEX_SUB_IMAGE2D:
   7956             CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7957                                                n[4].i, n[5].i, n[6].i, n[7].i,
   7958                                                n[8].i));
   7959             break;
   7960          case OPCODE_COPY_TEX_SUB_IMAGE3D:
   7961             CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   7962                                                n[4].i, n[5].i, n[6].i, n[7].i,
   7963                                                n[8].i, n[9].i));
   7964             break;
   7965          case OPCODE_CULL_FACE:
   7966             CALL_CullFace(ctx->Exec, (n[1].e));
   7967             break;
   7968          case OPCODE_DEPTH_FUNC:
   7969             CALL_DepthFunc(ctx->Exec, (n[1].e));
   7970             break;
   7971          case OPCODE_DEPTH_MASK:
   7972             CALL_DepthMask(ctx->Exec, (n[1].b));
   7973             break;
   7974          case OPCODE_DEPTH_RANGE:
   7975             CALL_DepthRange(ctx->Exec,
   7976                             ((GLclampd) n[1].f, (GLclampd) n[2].f));
   7977             break;
   7978          case OPCODE_DISABLE:
   7979             CALL_Disable(ctx->Exec, (n[1].e));
   7980             break;
   7981          case OPCODE_DISABLE_INDEXED:
   7982             CALL_DisableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));
   7983             break;
   7984          case OPCODE_DRAW_BUFFER:
   7985             CALL_DrawBuffer(ctx->Exec, (n[1].e));
   7986             break;
   7987          case OPCODE_DRAW_PIXELS:
   7988             {
   7989                const struct gl_pixelstore_attrib save = ctx->Unpack;
   7990                ctx->Unpack = ctx->DefaultPacking;
   7991                CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,
   7992                                            n[5].data));
   7993                ctx->Unpack = save;      /* restore */
   7994             }
   7995             break;
   7996          case OPCODE_ENABLE:
   7997             CALL_Enable(ctx->Exec, (n[1].e));
   7998             break;
   7999          case OPCODE_ENABLE_INDEXED:
   8000             CALL_EnableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));
   8001             break;
   8002          case OPCODE_EVALMESH1:
   8003             CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));
   8004             break;
   8005          case OPCODE_EVALMESH2:
   8006             CALL_EvalMesh2(ctx->Exec,
   8007                            (n[1].e, n[2].i, n[3].i, n[4].i, n[5].i));
   8008             break;
   8009          case OPCODE_FOG:
   8010             {
   8011                GLfloat p[4];
   8012                p[0] = n[2].f;
   8013                p[1] = n[3].f;
   8014                p[2] = n[4].f;
   8015                p[3] = n[5].f;
   8016                CALL_Fogfv(ctx->Exec, (n[1].e, p));
   8017             }
   8018             break;
   8019          case OPCODE_FRONT_FACE:
   8020             CALL_FrontFace(ctx->Exec, (n[1].e));
   8021             break;
   8022          case OPCODE_FRUSTUM:
   8023             CALL_Frustum(ctx->Exec,
   8024                          (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
   8025             break;
   8026          case OPCODE_HINT:
   8027             CALL_Hint(ctx->Exec, (n[1].e, n[2].e));
   8028             break;
   8029          case OPCODE_HISTOGRAM:
   8030             CALL_Histogram(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].b));
   8031             break;
   8032          case OPCODE_INDEX_MASK:
   8033             CALL_IndexMask(ctx->Exec, (n[1].ui));
   8034             break;
   8035          case OPCODE_INIT_NAMES:
   8036             CALL_InitNames(ctx->Exec, ());
   8037             break;
   8038          case OPCODE_LIGHT:
   8039             {
   8040                GLfloat p[4];
   8041                p[0] = n[3].f;
   8042                p[1] = n[4].f;
   8043                p[2] = n[5].f;
   8044                p[3] = n[6].f;
   8045                CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));
   8046             }
   8047             break;
   8048          case OPCODE_LIGHT_MODEL:
   8049             {
   8050                GLfloat p[4];
   8051                p[0] = n[2].f;
   8052                p[1] = n[3].f;
   8053                p[2] = n[4].f;
   8054                p[3] = n[5].f;
   8055                CALL_LightModelfv(ctx->Exec, (n[1].e, p));
   8056             }
   8057             break;
   8058          case OPCODE_LINE_STIPPLE:
   8059             CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));
   8060             break;
   8061          case OPCODE_LINE_WIDTH:
   8062             CALL_LineWidth(ctx->Exec, (n[1].f));
   8063             break;
   8064          case OPCODE_LIST_BASE:
   8065             CALL_ListBase(ctx->Exec, (n[1].ui));
   8066             break;
   8067          case OPCODE_LOAD_IDENTITY:
   8068             CALL_LoadIdentity(ctx->Exec, ());
   8069             break;
   8070          case OPCODE_LOAD_MATRIX:
   8071             if (sizeof(Node) == sizeof(GLfloat)) {
   8072                CALL_LoadMatrixf(ctx->Exec, (&n[1].f));
   8073             }
   8074             else {
   8075                GLfloat m[16];
   8076                GLuint i;
   8077                for (i = 0; i < 16; i++) {
   8078                   m[i] = n[1 + i].f;
   8079                }
   8080                CALL_LoadMatrixf(ctx->Exec, (m));
   8081             }
   8082             break;
   8083          case OPCODE_LOAD_NAME:
   8084             CALL_LoadName(ctx->Exec, (n[1].ui));
   8085             break;
   8086          case OPCODE_LOGIC_OP:
   8087             CALL_LogicOp(ctx->Exec, (n[1].e));
   8088             break;
   8089          case OPCODE_MAP1:
   8090             {
   8091                GLenum target = n[1].e;
   8092                GLint ustride = _mesa_evaluator_components(target);
   8093                GLint uorder = n[5].i;
   8094                GLfloat u1 = n[2].f;
   8095                GLfloat u2 = n[3].f;
   8096                CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,
   8097                                       (GLfloat *) n[6].data));
   8098             }
   8099             break;
   8100          case OPCODE_MAP2:
   8101             {
   8102                GLenum target = n[1].e;
   8103                GLfloat u1 = n[2].f;
   8104                GLfloat u2 = n[3].f;
   8105                GLfloat v1 = n[4].f;
   8106                GLfloat v2 = n[5].f;
   8107                GLint ustride = n[6].i;
   8108                GLint vstride = n[7].i;
   8109                GLint uorder = n[8].i;
   8110                GLint vorder = n[9].i;
   8111                CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
   8112                                       v1, v2, vstride, vorder,
   8113                                       (GLfloat *) n[10].data));
   8114             }
   8115             break;
   8116          case OPCODE_MAPGRID1:
   8117             CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
   8118             break;
   8119          case OPCODE_MAPGRID2:
   8120             CALL_MapGrid2f(ctx->Exec,
   8121                            (n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));
   8122             break;
   8123          case OPCODE_MATRIX_MODE:
   8124             CALL_MatrixMode(ctx->Exec, (n[1].e));
   8125             break;
   8126          case OPCODE_MIN_MAX:
   8127             CALL_Minmax(ctx->Exec, (n[1].e, n[2].e, n[3].b));
   8128             break;
   8129          case OPCODE_MULT_MATRIX:
   8130             if (sizeof(Node) == sizeof(GLfloat)) {
   8131                CALL_MultMatrixf(ctx->Exec, (&n[1].f));
   8132             }
   8133             else {
   8134                GLfloat m[16];
   8135                GLuint i;
   8136                for (i = 0; i < 16; i++) {
   8137                   m[i] = n[1 + i].f;
   8138                }
   8139                CALL_MultMatrixf(ctx->Exec, (m));
   8140             }
   8141             break;
   8142          case OPCODE_ORTHO:
   8143             CALL_Ortho(ctx->Exec,
   8144                        (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
   8145             break;
   8146          case OPCODE_PASSTHROUGH:
   8147             CALL_PassThrough(ctx->Exec, (n[1].f));
   8148             break;
   8149          case OPCODE_PIXEL_MAP:
   8150             CALL_PixelMapfv(ctx->Exec,
   8151                             (n[1].e, n[2].i, (GLfloat *) n[3].data));
   8152             break;
   8153          case OPCODE_PIXEL_TRANSFER:
   8154             CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));
   8155             break;
   8156          case OPCODE_PIXEL_ZOOM:
   8157             CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));
   8158             break;
   8159          case OPCODE_POINT_SIZE:
   8160             CALL_PointSize(ctx->Exec, (n[1].f));
   8161             break;
   8162          case OPCODE_POINT_PARAMETERS:
   8163             {
   8164                GLfloat params[3];
   8165                params[0] = n[2].f;
   8166                params[1] = n[3].f;
   8167                params[2] = n[4].f;
   8168                CALL_PointParameterfvEXT(ctx->Exec, (n[1].e, params));
   8169             }
   8170             break;
   8171          case OPCODE_POLYGON_MODE:
   8172             CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));
   8173             break;
   8174          case OPCODE_POLYGON_STIPPLE:
   8175             {
   8176                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8177                ctx->Unpack = ctx->DefaultPacking;
   8178                CALL_PolygonStipple(ctx->Exec, ((GLubyte *) n[1].data));
   8179                ctx->Unpack = save;      /* restore */
   8180             }
   8181             break;
   8182          case OPCODE_POLYGON_OFFSET:
   8183             CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));
   8184             break;
   8185          case OPCODE_POP_ATTRIB:
   8186             CALL_PopAttrib(ctx->Exec, ());
   8187             break;
   8188          case OPCODE_POP_MATRIX:
   8189             CALL_PopMatrix(ctx->Exec, ());
   8190             break;
   8191          case OPCODE_POP_NAME:
   8192             CALL_PopName(ctx->Exec, ());
   8193             break;
   8194          case OPCODE_PRIORITIZE_TEXTURE:
   8195             CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));
   8196             break;
   8197          case OPCODE_PUSH_ATTRIB:
   8198             CALL_PushAttrib(ctx->Exec, (n[1].bf));
   8199             break;
   8200          case OPCODE_PUSH_MATRIX:
   8201             CALL_PushMatrix(ctx->Exec, ());
   8202             break;
   8203          case OPCODE_PUSH_NAME:
   8204             CALL_PushName(ctx->Exec, (n[1].ui));
   8205             break;
   8206          case OPCODE_RASTER_POS:
   8207             CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   8208             break;
   8209          case OPCODE_READ_BUFFER:
   8210             CALL_ReadBuffer(ctx->Exec, (n[1].e));
   8211             break;
   8212          case OPCODE_RESET_HISTOGRAM:
   8213             CALL_ResetHistogram(ctx->Exec, (n[1].e));
   8214             break;
   8215          case OPCODE_RESET_MIN_MAX:
   8216             CALL_ResetMinmax(ctx->Exec, (n[1].e));
   8217             break;
   8218          case OPCODE_ROTATE:
   8219             CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   8220             break;
   8221          case OPCODE_SCALE:
   8222             CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
   8223             break;
   8224          case OPCODE_SCISSOR:
   8225             CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
   8226             break;
   8227          case OPCODE_SHADE_MODEL:
   8228             CALL_ShadeModel(ctx->Exec, (n[1].e));
   8229             break;
   8230          case OPCODE_PROVOKING_VERTEX:
   8231             CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e));
   8232             break;
   8233          case OPCODE_STENCIL_FUNC:
   8234             CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
   8235             break;
   8236          case OPCODE_STENCIL_MASK:
   8237             CALL_StencilMask(ctx->Exec, (n[1].ui));
   8238             break;
   8239          case OPCODE_STENCIL_OP:
   8240             CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));
   8241             break;
   8242          case OPCODE_STENCIL_FUNC_SEPARATE:
   8243             CALL_StencilFuncSeparate(ctx->Exec,
   8244                                      (n[1].e, n[2].e, n[3].i, n[4].ui));
   8245             break;
   8246          case OPCODE_STENCIL_MASK_SEPARATE:
   8247             CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));
   8248             break;
   8249          case OPCODE_STENCIL_OP_SEPARATE:
   8250             CALL_StencilOpSeparate(ctx->Exec,
   8251                                    (n[1].e, n[2].e, n[3].e, n[4].e));
   8252             break;
   8253          case OPCODE_TEXENV:
   8254             {
   8255                GLfloat params[4];
   8256                params[0] = n[3].f;
   8257                params[1] = n[4].f;
   8258                params[2] = n[5].f;
   8259                params[3] = n[6].f;
   8260                CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));
   8261             }
   8262             break;
   8263          case OPCODE_TEXGEN:
   8264             {
   8265                GLfloat params[4];
   8266                params[0] = n[3].f;
   8267                params[1] = n[4].f;
   8268                params[2] = n[5].f;
   8269                params[3] = n[6].f;
   8270                CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));
   8271             }
   8272             break;
   8273          case OPCODE_TEXPARAMETER:
   8274             {
   8275                GLfloat params[4];
   8276                params[0] = n[3].f;
   8277                params[1] = n[4].f;
   8278                params[2] = n[5].f;
   8279                params[3] = n[6].f;
   8280                CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));
   8281             }
   8282             break;
   8283          case OPCODE_TEX_IMAGE1D:
   8284             {
   8285                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8286                ctx->Unpack = ctx->DefaultPacking;
   8287                CALL_TexImage1D(ctx->Exec, (n[1].e,      /* target */
   8288                                            n[2].i,      /* level */
   8289                                            n[3].i,      /* components */
   8290                                            n[4].i,      /* width */
   8291                                            n[5].e,      /* border */
   8292                                            n[6].e,      /* format */
   8293                                            n[7].e,      /* type */
   8294                                            n[8].data));
   8295                ctx->Unpack = save;      /* restore */
   8296             }
   8297             break;
   8298          case OPCODE_TEX_IMAGE2D:
   8299             {
   8300                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8301                ctx->Unpack = ctx->DefaultPacking;
   8302                CALL_TexImage2D(ctx->Exec, (n[1].e,      /* target */
   8303                                            n[2].i,      /* level */
   8304                                            n[3].i,      /* components */
   8305                                            n[4].i,      /* width */
   8306                                            n[5].i,      /* height */
   8307                                            n[6].e,      /* border */
   8308                                            n[7].e,      /* format */
   8309                                            n[8].e,      /* type */
   8310                                            n[9].data));
   8311                ctx->Unpack = save;      /* restore */
   8312             }
   8313             break;
   8314          case OPCODE_TEX_IMAGE3D:
   8315             {
   8316                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8317                ctx->Unpack = ctx->DefaultPacking;
   8318                CALL_TexImage3D(ctx->Exec, (n[1].e,      /* target */
   8319                                            n[2].i,      /* level */
   8320                                            n[3].i,      /* components */
   8321                                            n[4].i,      /* width */
   8322                                            n[5].i,      /* height */
   8323                                            n[6].i,      /* depth  */
   8324                                            n[7].e,      /* border */
   8325                                            n[8].e,      /* format */
   8326                                            n[9].e,      /* type */
   8327                                            n[10].data));
   8328                ctx->Unpack = save;      /* restore */
   8329             }
   8330             break;
   8331          case OPCODE_TEX_SUB_IMAGE1D:
   8332             {
   8333                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8334                ctx->Unpack = ctx->DefaultPacking;
   8335                CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   8336                                               n[4].i, n[5].e,
   8337                                               n[6].e, n[7].data));
   8338                ctx->Unpack = save;      /* restore */
   8339             }
   8340             break;
   8341          case OPCODE_TEX_SUB_IMAGE2D:
   8342             {
   8343                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8344                ctx->Unpack = ctx->DefaultPacking;
   8345                CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   8346                                               n[4].i, n[5].e,
   8347                                               n[6].i, n[7].e, n[8].e,
   8348                                               n[9].data));
   8349                ctx->Unpack = save;      /* restore */
   8350             }
   8351             break;
   8352          case OPCODE_TEX_SUB_IMAGE3D:
   8353             {
   8354                const struct gl_pixelstore_attrib save = ctx->Unpack;
   8355                ctx->Unpack = ctx->DefaultPacking;
   8356                CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
   8357                                               n[4].i, n[5].i, n[6].i, n[7].i,
   8358                                               n[8].i, n[9].e, n[10].e,
   8359                                               n[11].data));
   8360                ctx->Unpack = save;      /* restore */
   8361             }
   8362             break;
   8363          case OPCODE_TRANSLATE:
   8364             CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
   8365             break;
   8366          case OPCODE_VIEWPORT:
   8367             CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
   8368                                       (GLsizei) n[3].i, (GLsizei) n[4].i));
   8369             break;
   8370          case OPCODE_WINDOW_POS:
   8371             CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   8372             break;
   8373          case OPCODE_ACTIVE_TEXTURE:   /* GL_ARB_multitexture */
   8374             CALL_ActiveTextureARB(ctx->Exec, (n[1].e));
   8375             break;
   8376          case OPCODE_COMPRESSED_TEX_IMAGE_1D:  /* GL_ARB_texture_compression */
   8377             CALL_CompressedTexImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
   8378                                                      n[4].i, n[5].i, n[6].i,
   8379                                                      n[7].data));
   8380             break;
   8381          case OPCODE_COMPRESSED_TEX_IMAGE_2D:  /* GL_ARB_texture_compression */
   8382             CALL_CompressedTexImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
   8383                                                      n[4].i, n[5].i, n[6].i,
   8384                                                      n[7].i, n[8].data));
   8385             break;
   8386          case OPCODE_COMPRESSED_TEX_IMAGE_3D:  /* GL_ARB_texture_compression */
   8387             CALL_CompressedTexImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
   8388                                                      n[4].i, n[5].i, n[6].i,
   8389                                                      n[7].i, n[8].i,
   8390                                                      n[9].data));
   8391             break;
   8392          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:      /* GL_ARB_texture_compress */
   8393             CALL_CompressedTexSubImage1DARB(ctx->Exec,
   8394                                             (n[1].e, n[2].i, n[3].i, n[4].i,
   8395                                              n[5].e, n[6].i, n[7].data));
   8396             break;
   8397          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:      /* GL_ARB_texture_compress */
   8398             CALL_CompressedTexSubImage2DARB(ctx->Exec,
   8399                                             (n[1].e, n[2].i, n[3].i, n[4].i,
   8400                                              n[5].i, n[6].i, n[7].e, n[8].i,
   8401                                              n[9].data));
   8402             break;
   8403          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:      /* GL_ARB_texture_compress */
   8404             CALL_CompressedTexSubImage3DARB(ctx->Exec,
   8405                                             (n[1].e, n[2].i, n[3].i, n[4].i,
   8406                                              n[5].i, n[6].i, n[7].i, n[8].i,
   8407                                              n[9].e, n[10].i, n[11].data));
   8408             break;
   8409          case OPCODE_SAMPLE_COVERAGE:  /* GL_ARB_multisample */
   8410             CALL_SampleCoverageARB(ctx->Exec, (n[1].f, n[2].b));
   8411             break;
   8412          case OPCODE_WINDOW_POS_ARB:   /* GL_ARB_window_pos */
   8413             CALL_WindowPos3fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f));
   8414             break;
   8415 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   8416          case OPCODE_BIND_PROGRAM_NV:  /* GL_NV_vertex_program */
   8417             CALL_BindProgramNV(ctx->Exec, (n[1].e, n[2].ui));
   8418             break;
   8419 #endif
   8420 #if FEATURE_NV_vertex_program
   8421          case OPCODE_EXECUTE_PROGRAM_NV:
   8422             {
   8423                GLfloat v[4];
   8424                v[0] = n[3].f;
   8425                v[1] = n[4].f;
   8426                v[2] = n[5].f;
   8427                v[3] = n[6].f;
   8428                CALL_ExecuteProgramNV(ctx->Exec, (n[1].e, n[2].ui, v));
   8429             }
   8430             break;
   8431          case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
   8432             CALL_RequestResidentProgramsNV(ctx->Exec, (n[1].ui,
   8433                                                        (GLuint *) n[2].data));
   8434             break;
   8435          case OPCODE_LOAD_PROGRAM_NV:
   8436             CALL_LoadProgramNV(ctx->Exec, (n[1].e, n[2].ui, n[3].i,
   8437                                            (const GLubyte *) n[4].data));
   8438             break;
   8439          case OPCODE_TRACK_MATRIX_NV:
   8440             CALL_TrackMatrixNV(ctx->Exec, (n[1].e, n[2].ui, n[3].e, n[4].e));
   8441             break;
   8442 #endif
   8443 
   8444 #if FEATURE_NV_fragment_program
   8445          case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:
   8446             CALL_ProgramLocalParameter4fARB(ctx->Exec,
   8447                                             (n[1].e, n[2].ui, n[3].f, n[4].f,
   8448                                              n[5].f, n[6].f));
   8449             break;
   8450          case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
   8451             CALL_ProgramNamedParameter4fNV(ctx->Exec, (n[1].ui, n[2].i,
   8452                                                        (const GLubyte *) n[3].
   8453                                                        data, n[4].f, n[5].f,
   8454                                                        n[6].f, n[7].f));
   8455             break;
   8456 #endif
   8457 
   8458          case OPCODE_ACTIVE_STENCIL_FACE_EXT:
   8459             CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
   8460             break;
   8461          case OPCODE_DEPTH_BOUNDS_EXT:
   8462             CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
   8463             break;
   8464 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   8465          case OPCODE_PROGRAM_STRING_ARB:
   8466             CALL_ProgramStringARB(ctx->Exec,
   8467                                   (n[1].e, n[2].e, n[3].i, n[4].data));
   8468             break;
   8469 #endif
   8470 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program
   8471          case OPCODE_PROGRAM_ENV_PARAMETER_ARB:
   8472             CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
   8473                                                       n[4].f, n[5].f,
   8474                                                       n[6].f));
   8475             break;
   8476 #endif
   8477 #if FEATURE_queryobj
   8478          case OPCODE_BEGIN_QUERY_ARB:
   8479             CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));
   8480             break;
   8481          case OPCODE_END_QUERY_ARB:
   8482             CALL_EndQueryARB(ctx->Exec, (n[1].e));
   8483             break;
   8484          case OPCODE_QUERY_COUNTER:
   8485             CALL_QueryCounter(ctx->Exec, (n[1].ui, n[2].e));
   8486             break;
   8487          case OPCODE_BEGIN_QUERY_INDEXED:
   8488             CALL_BeginQueryIndexed(ctx->Exec, (n[1].e, n[2].ui, n[3].ui));
   8489             break;
   8490          case OPCODE_END_QUERY_INDEXED:
   8491             CALL_EndQueryIndexed(ctx->Exec, (n[1].e, n[2].ui));
   8492             break;
   8493 #endif
   8494          case OPCODE_DRAW_BUFFERS_ARB:
   8495             {
   8496                GLenum buffers[MAX_DRAW_BUFFERS];
   8497                GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);
   8498                for (i = 0; i < count; i++)
   8499                   buffers[i] = n[2 + i].e;
   8500                CALL_DrawBuffersARB(ctx->Exec, (n[1].i, buffers));
   8501             }
   8502             break;
   8503 #if FEATURE_EXT_framebuffer_blit
   8504 	 case OPCODE_BLIT_FRAMEBUFFER:
   8505 	    CALL_BlitFramebufferEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,
   8506                                                 n[5].i, n[6].i, n[7].i, n[8].i,
   8507                                                 n[9].i, n[10].e));
   8508 	    break;
   8509 #endif
   8510 
   8511 	 case OPCODE_USE_PROGRAM:
   8512 	    CALL_UseProgramObjectARB(ctx->Exec, (n[1].ui));
   8513 	    break;
   8514 	 case OPCODE_USE_SHADER_PROGRAM_EXT:
   8515 	    CALL_UseShaderProgramEXT(ctx->Exec, (n[1].ui, n[2].ui));
   8516 	    break;
   8517 	 case OPCODE_ACTIVE_PROGRAM_EXT:
   8518 	    CALL_ActiveProgramEXT(ctx->Exec, (n[1].ui));
   8519 	    break;
   8520 	 case OPCODE_UNIFORM_1F:
   8521 	    CALL_Uniform1fARB(ctx->Exec, (n[1].i, n[2].f));
   8522 	    break;
   8523 	 case OPCODE_UNIFORM_2F:
   8524 	    CALL_Uniform2fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f));
   8525 	    break;
   8526 	 case OPCODE_UNIFORM_3F:
   8527 	    CALL_Uniform3fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));
   8528 	    break;
   8529 	 case OPCODE_UNIFORM_4F:
   8530 	    CALL_Uniform4fARB(ctx->Exec,
   8531                               (n[1].i, n[2].f, n[3].f, n[4].f, n[5].f));
   8532 	    break;
   8533 	 case OPCODE_UNIFORM_1FV:
   8534 	    CALL_Uniform1fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8535 	    break;
   8536 	 case OPCODE_UNIFORM_2FV:
   8537 	    CALL_Uniform2fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8538 	    break;
   8539 	 case OPCODE_UNIFORM_3FV:
   8540 	    CALL_Uniform3fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8541 	    break;
   8542 	 case OPCODE_UNIFORM_4FV:
   8543 	    CALL_Uniform4fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8544 	    break;
   8545 	 case OPCODE_UNIFORM_1I:
   8546 	    CALL_Uniform1iARB(ctx->Exec, (n[1].i, n[2].i));
   8547 	    break;
   8548 	 case OPCODE_UNIFORM_2I:
   8549 	    CALL_Uniform2iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));
   8550 	    break;
   8551 	 case OPCODE_UNIFORM_3I:
   8552 	    CALL_Uniform3iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
   8553 	    break;
   8554 	 case OPCODE_UNIFORM_4I:
   8555 	    CALL_Uniform4iARB(ctx->Exec,
   8556                               (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
   8557 	    break;
   8558 	 case OPCODE_UNIFORM_1IV:
   8559 	    CALL_Uniform1ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8560 	    break;
   8561 	 case OPCODE_UNIFORM_2IV:
   8562 	    CALL_Uniform2ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8563 	    break;
   8564 	 case OPCODE_UNIFORM_3IV:
   8565 	    CALL_Uniform3ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8566 	    break;
   8567 	 case OPCODE_UNIFORM_4IV:
   8568 	    CALL_Uniform4ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
   8569 	    break;
   8570 	 case OPCODE_UNIFORM_1UI:
   8571 	    /*CALL_Uniform1uiARB(ctx->Exec, (n[1].i, n[2].i));*/
   8572 	    break;
   8573 	 case OPCODE_UNIFORM_2UI:
   8574 	    /*CALL_Uniform2uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));*/
   8575 	    break;
   8576 	 case OPCODE_UNIFORM_3UI:
   8577 	    /*CALL_Uniform3uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));*/
   8578 	    break;
   8579 	 case OPCODE_UNIFORM_4UI:
   8580 	    /*CALL_Uniform4uiARB(ctx->Exec,
   8581                               (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
   8582             */
   8583 	    break;
   8584 	 case OPCODE_UNIFORM_1UIV:
   8585 	    /*CALL_Uniform1uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
   8586 	    break;
   8587 	 case OPCODE_UNIFORM_2UIV:
   8588 	    /*CALL_Uniform2uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
   8589 	    break;
   8590 	 case OPCODE_UNIFORM_3UIV:
   8591 	    /*CALL_Uniform3uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
   8592 	    break;
   8593 	 case OPCODE_UNIFORM_4UIV:
   8594 	    /*CALL_Uniform4uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
   8595 	    break;
   8596 	 case OPCODE_UNIFORM_MATRIX22:
   8597 	    CALL_UniformMatrix2fvARB(ctx->Exec,
   8598                                      (n[1].i, n[2].i, n[3].b, n[4].data));
   8599 	    break;
   8600 	 case OPCODE_UNIFORM_MATRIX33:
   8601 	    CALL_UniformMatrix3fvARB(ctx->Exec,
   8602                                      (n[1].i, n[2].i, n[3].b, n[4].data));
   8603 	    break;
   8604 	 case OPCODE_UNIFORM_MATRIX44:
   8605 	    CALL_UniformMatrix4fvARB(ctx->Exec,
   8606                                      (n[1].i, n[2].i, n[3].b, n[4].data));
   8607 	    break;
   8608 	 case OPCODE_UNIFORM_MATRIX23:
   8609 	    CALL_UniformMatrix2x3fv(ctx->Exec,
   8610                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8611 	    break;
   8612 	 case OPCODE_UNIFORM_MATRIX32:
   8613 	    CALL_UniformMatrix3x2fv(ctx->Exec,
   8614                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8615 	    break;
   8616 	 case OPCODE_UNIFORM_MATRIX24:
   8617 	    CALL_UniformMatrix2x4fv(ctx->Exec,
   8618                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8619 	    break;
   8620 	 case OPCODE_UNIFORM_MATRIX42:
   8621 	    CALL_UniformMatrix4x2fv(ctx->Exec,
   8622                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8623 	    break;
   8624 	 case OPCODE_UNIFORM_MATRIX34:
   8625 	    CALL_UniformMatrix3x4fv(ctx->Exec,
   8626                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8627 	    break;
   8628 	 case OPCODE_UNIFORM_MATRIX43:
   8629 	    CALL_UniformMatrix4x3fv(ctx->Exec,
   8630                                     (n[1].i, n[2].i, n[3].b, n[4].data));
   8631 	    break;
   8632 
   8633          case OPCODE_CLAMP_COLOR:
   8634             CALL_ClampColorARB(ctx->Exec, (n[1].e, n[2].e));
   8635             break;
   8636 
   8637          case OPCODE_TEX_BUMP_PARAMETER_ATI:
   8638             {
   8639                GLfloat values[4];
   8640                GLuint i, pname = n[1].ui;
   8641 
   8642                for (i = 0; i < 4; i++)
   8643                   values[i] = n[1 + i].f;
   8644                CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values));
   8645             }
   8646             break;
   8647 #if FEATURE_ATI_fragment_shader
   8648          case OPCODE_BIND_FRAGMENT_SHADER_ATI:
   8649             CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
   8650             break;
   8651          case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:
   8652             {
   8653                GLfloat values[4];
   8654                GLuint i, dst = n[1].ui;
   8655 
   8656                for (i = 0; i < 4; i++)
   8657                   values[i] = n[1 + i].f;
   8658                CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, values));
   8659             }
   8660             break;
   8661 #endif
   8662          case OPCODE_ATTR_1F_NV:
   8663             CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
   8664             break;
   8665          case OPCODE_ATTR_2F_NV:
   8666             /* Really shouldn't have to do this - the Node structure
   8667              * is convenient, but it would be better to store the data
   8668              * packed appropriately so that it can be sent directly
   8669              * on.  With x86_64 becoming common, this will start to
   8670              * matter more.
   8671              */
   8672             if (sizeof(Node) == sizeof(GLfloat))
   8673                CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
   8674             else
   8675                CALL_VertexAttrib2fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f));
   8676             break;
   8677          case OPCODE_ATTR_3F_NV:
   8678             if (sizeof(Node) == sizeof(GLfloat))
   8679                CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
   8680             else
   8681                CALL_VertexAttrib3fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
   8682                                                  n[4].f));
   8683             break;
   8684          case OPCODE_ATTR_4F_NV:
   8685             if (sizeof(Node) == sizeof(GLfloat))
   8686                CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));
   8687             else
   8688                CALL_VertexAttrib4fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
   8689                                                  n[4].f, n[5].f));
   8690             break;
   8691          case OPCODE_ATTR_1F_ARB:
   8692             CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
   8693             break;
   8694          case OPCODE_ATTR_2F_ARB:
   8695             /* Really shouldn't have to do this - the Node structure
   8696              * is convenient, but it would be better to store the data
   8697              * packed appropriately so that it can be sent directly
   8698              * on.  With x86_64 becoming common, this will start to
   8699              * matter more.
   8700              */
   8701             if (sizeof(Node) == sizeof(GLfloat))
   8702                CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
   8703             else
   8704                CALL_VertexAttrib2fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f));
   8705             break;
   8706          case OPCODE_ATTR_3F_ARB:
   8707             if (sizeof(Node) == sizeof(GLfloat))
   8708                CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
   8709             else
   8710                CALL_VertexAttrib3fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
   8711                                                   n[4].f));
   8712             break;
   8713          case OPCODE_ATTR_4F_ARB:
   8714             if (sizeof(Node) == sizeof(GLfloat))
   8715                CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
   8716             else
   8717                CALL_VertexAttrib4fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
   8718                                                   n[4].f, n[5].f));
   8719             break;
   8720          case OPCODE_MATERIAL:
   8721             if (sizeof(Node) == sizeof(GLfloat))
   8722                CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
   8723             else {
   8724                GLfloat f[4];
   8725                f[0] = n[3].f;
   8726                f[1] = n[4].f;
   8727                f[2] = n[5].f;
   8728                f[3] = n[6].f;
   8729                CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, f));
   8730             }
   8731             break;
   8732          case OPCODE_BEGIN:
   8733             CALL_Begin(ctx->Exec, (n[1].e));
   8734             break;
   8735          case OPCODE_END:
   8736             CALL_End(ctx->Exec, ());
   8737             break;
   8738          case OPCODE_RECTF:
   8739             CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
   8740             break;
   8741          case OPCODE_EVAL_C1:
   8742             CALL_EvalCoord1f(ctx->Exec, (n[1].f));
   8743             break;
   8744          case OPCODE_EVAL_C2:
   8745             CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
   8746             break;
   8747          case OPCODE_EVAL_P1:
   8748             CALL_EvalPoint1(ctx->Exec, (n[1].i));
   8749             break;
   8750          case OPCODE_EVAL_P2:
   8751             CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
   8752             break;
   8753 
   8754          /* GL_EXT_texture_integer */
   8755          case OPCODE_CLEARCOLOR_I:
   8756             CALL_ClearColorIiEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
   8757             break;
   8758          case OPCODE_CLEARCOLOR_UI:
   8759             CALL_ClearColorIuiEXT(ctx->Exec,
   8760                                   (n[1].ui, n[2].ui, n[3].ui, n[4].ui));
   8761             break;
   8762          case OPCODE_TEXPARAMETER_I:
   8763             {
   8764                GLint params[4];
   8765                params[0] = n[3].i;
   8766                params[1] = n[4].i;
   8767                params[2] = n[5].i;
   8768                params[3] = n[6].i;
   8769                CALL_TexParameterIivEXT(ctx->Exec, (n[1].e, n[2].e, params));
   8770             }
   8771             break;
   8772          case OPCODE_TEXPARAMETER_UI:
   8773             {
   8774                GLuint params[4];
   8775                params[0] = n[3].ui;
   8776                params[1] = n[4].ui;
   8777                params[2] = n[5].ui;
   8778                params[3] = n[6].ui;
   8779                CALL_TexParameterIuivEXT(ctx->Exec, (n[1].e, n[2].e, params));
   8780             }
   8781             break;
   8782 
   8783          case OPCODE_VERTEX_ATTRIB_DIVISOR:
   8784             /* GL_ARB_instanced_arrays */
   8785             CALL_VertexAttribDivisorARB(ctx->Exec, (n[1].ui, n[2].ui));
   8786             break;
   8787 
   8788          case OPCODE_TEXTURE_BARRIER_NV:
   8789             CALL_TextureBarrierNV(ctx->Exec, ());
   8790             break;
   8791 
   8792          /* GL_EXT/ARB_transform_feedback */
   8793          case OPCODE_BEGIN_TRANSFORM_FEEDBACK:
   8794             CALL_BeginTransformFeedbackEXT(ctx->Exec, (n[1].e));
   8795             break;
   8796          case OPCODE_END_TRANSFORM_FEEDBACK:
   8797             CALL_EndTransformFeedbackEXT(ctx->Exec, ());
   8798             break;
   8799          case OPCODE_BIND_TRANSFORM_FEEDBACK:
   8800             CALL_BindTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
   8801             break;
   8802          case OPCODE_PAUSE_TRANSFORM_FEEDBACK:
   8803             CALL_PauseTransformFeedback(ctx->Exec, ());
   8804             break;
   8805          case OPCODE_RESUME_TRANSFORM_FEEDBACK:
   8806             CALL_ResumeTransformFeedback(ctx->Exec, ());
   8807             break;
   8808          case OPCODE_DRAW_TRANSFORM_FEEDBACK:
   8809             CALL_DrawTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
   8810             break;
   8811          case OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM:
   8812             CALL_DrawTransformFeedbackStream(ctx->Exec,
   8813                                              (n[1].e, n[2].ui, n[3].ui));
   8814             break;
   8815          case OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED:
   8816             CALL_DrawTransformFeedbackInstanced(ctx->Exec,
   8817                                                 (n[1].e, n[2].ui, n[3].si));
   8818             break;
   8819          case OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED:
   8820             CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec,
   8821                                        (n[1].e, n[2].ui, n[3].ui, n[4].si));
   8822             break;
   8823 
   8824 
   8825          case OPCODE_BIND_SAMPLER:
   8826             CALL_BindSampler(ctx->Exec, (n[1].ui, n[2].ui));
   8827             break;
   8828          case OPCODE_SAMPLER_PARAMETERIV:
   8829             {
   8830                GLint params[4];
   8831                params[0] = n[3].i;
   8832                params[1] = n[4].i;
   8833                params[2] = n[5].i;
   8834                params[3] = n[6].i;
   8835                CALL_SamplerParameteriv(ctx->Exec, (n[1].ui, n[2].e, params));
   8836             }
   8837             break;
   8838          case OPCODE_SAMPLER_PARAMETERFV:
   8839             {
   8840                GLfloat params[4];
   8841                params[0] = n[3].f;
   8842                params[1] = n[4].f;
   8843                params[2] = n[5].f;
   8844                params[3] = n[6].f;
   8845                CALL_SamplerParameterfv(ctx->Exec, (n[1].ui, n[2].e, params));
   8846             }
   8847             break;
   8848          case OPCODE_SAMPLER_PARAMETERIIV:
   8849             {
   8850                GLint params[4];
   8851                params[0] = n[3].i;
   8852                params[1] = n[4].i;
   8853                params[2] = n[5].i;
   8854                params[3] = n[6].i;
   8855                CALL_SamplerParameterIiv(ctx->Exec, (n[1].ui, n[2].e, params));
   8856             }
   8857             break;
   8858          case OPCODE_SAMPLER_PARAMETERUIV:
   8859             {
   8860                GLuint params[4];
   8861                params[0] = n[3].ui;
   8862                params[1] = n[4].ui;
   8863                params[2] = n[5].ui;
   8864                params[3] = n[6].ui;
   8865                CALL_SamplerParameterIuiv(ctx->Exec, (n[1].ui, n[2].e, params));
   8866             }
   8867             break;
   8868 
   8869          /* GL_ARB_geometry_shader4 */
   8870          case OPCODE_PROGRAM_PARAMETERI:
   8871             CALL_ProgramParameteriARB(ctx->Exec, (n[1].ui, n[2].e, n[3].i));
   8872             break;
   8873          case OPCODE_FRAMEBUFFER_TEXTURE:
   8874             CALL_FramebufferTextureARB(ctx->Exec, (n[1].e, n[2].e,
   8875                                                    n[3].ui, n[4].i));
   8876             break;
   8877          case OPCODE_FRAMEBUFFER_TEXTURE_FACE:
   8878             CALL_FramebufferTextureFaceARB(ctx->Exec, (n[1].e, n[2].e,
   8879                                                        n[3].ui, n[4].i, n[5].e));
   8880             break;
   8881 
   8882          /* GL_ARB_sync */
   8883          case OPCODE_WAIT_SYNC:
   8884             {
   8885                union uint64_pair p;
   8886                p.uint32[0] = n[3].ui;
   8887                p.uint32[1] = n[4].ui;
   8888                CALL_WaitSync(ctx->Exec, (n[1].data, n[2].bf, p.uint64));
   8889             }
   8890             break;
   8891 
   8892          /* GL_NV_conditional_render */
   8893          case OPCODE_BEGIN_CONDITIONAL_RENDER:
   8894             CALL_BeginConditionalRenderNV(ctx->Exec, (n[1].i, n[2].e));
   8895             break;
   8896          case OPCODE_END_CONDITIONAL_RENDER:
   8897             CALL_EndConditionalRenderNV(ctx->Exec, ());
   8898             break;
   8899 
   8900          case OPCODE_UNIFORM_BLOCK_BINDING:
   8901             CALL_UniformBlockBinding(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
   8902             break;
   8903 
   8904          case OPCODE_CONTINUE:
   8905             n = (Node *) n[1].next;
   8906             break;
   8907          case OPCODE_END_OF_LIST:
   8908             done = GL_TRUE;
   8909             break;
   8910          default:
   8911             {
   8912                char msg[1000];
   8913                _mesa_snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",
   8914                              (int) opcode);
   8915                _mesa_problem(ctx, "%s", msg);
   8916             }
   8917             done = GL_TRUE;
   8918          }
   8919 
   8920          /* increment n to point to next compiled command */
   8921          if (opcode != OPCODE_CONTINUE) {
   8922             n += InstSize[opcode];
   8923          }
   8924       }
   8925    }
   8926 
   8927    if (ctx->Driver.EndCallList)
   8928       ctx->Driver.EndCallList(ctx);
   8929 
   8930    ctx->ListState.CallDepth--;
   8931 }
   8932 
   8933 
   8934 
   8935 /**********************************************************************/
   8936 /*                           GL functions                             */
   8937 /**********************************************************************/
   8938 
   8939 /**
   8940  * Test if a display list number is valid.
   8941  */
   8942 static GLboolean GLAPIENTRY
   8943 _mesa_IsList(GLuint list)
   8944 {
   8945    GET_CURRENT_CONTEXT(ctx);
   8946    FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
   8947    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
   8948    return islist(ctx, list);
   8949 }
   8950 
   8951 
   8952 /**
   8953  * Delete a sequence of consecutive display lists.
   8954  */
   8955 static void GLAPIENTRY
   8956 _mesa_DeleteLists(GLuint list, GLsizei range)
   8957 {
   8958    GET_CURRENT_CONTEXT(ctx);
   8959    GLuint i;
   8960    FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
   8961    ASSERT_OUTSIDE_BEGIN_END(ctx);
   8962 
   8963    if (range < 0) {
   8964       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");
   8965       return;
   8966    }
   8967    for (i = list; i < list + range; i++) {
   8968       destroy_list(ctx, i);
   8969    }
   8970 }
   8971 
   8972 
   8973 /**
   8974  * Return a display list number, n, such that lists n through n+range-1
   8975  * are free.
   8976  */
   8977 static GLuint GLAPIENTRY
   8978 _mesa_GenLists(GLsizei range)
   8979 {
   8980    GET_CURRENT_CONTEXT(ctx);
   8981    GLuint base;
   8982    FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
   8983    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
   8984 
   8985    if (range < 0) {
   8986       _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");
   8987       return 0;
   8988    }
   8989    if (range == 0) {
   8990       return 0;
   8991    }
   8992 
   8993    /*
   8994     * Make this an atomic operation
   8995     */
   8996    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
   8997 
   8998    base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
   8999    if (base) {
   9000       /* reserve the list IDs by with empty/dummy lists */
   9001       GLint i;
   9002       for (i = 0; i < range; i++) {
   9003          _mesa_HashInsert(ctx->Shared->DisplayList, base + i,
   9004                           make_list(base + i, 1));
   9005       }
   9006    }
   9007 
   9008    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
   9009 
   9010    return base;
   9011 }
   9012 
   9013 
   9014 /**
   9015  * Begin a new display list.
   9016  */
   9017 static void GLAPIENTRY
   9018 _mesa_NewList(GLuint name, GLenum mode)
   9019 {
   9020    GET_CURRENT_CONTEXT(ctx);
   9021 
   9022    FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
   9023    ASSERT_OUTSIDE_BEGIN_END(ctx);
   9024 
   9025    if (MESA_VERBOSE & VERBOSE_API)
   9026       _mesa_debug(ctx, "glNewList %u %s\n", name,
   9027                   _mesa_lookup_enum_by_nr(mode));
   9028 
   9029    if (name == 0) {
   9030       _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
   9031       return;
   9032    }
   9033 
   9034    if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) {
   9035       _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");
   9036       return;
   9037    }
   9038 
   9039    if (ctx->ListState.CurrentList) {
   9040       /* already compiling a display list */
   9041       _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
   9042       return;
   9043    }
   9044 
   9045    ctx->CompileFlag = GL_TRUE;
   9046    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
   9047 
   9048    /* Reset acumulated list state:
   9049     */
   9050    invalidate_saved_current_state( ctx );
   9051 
   9052    /* Allocate new display list */
   9053    ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);
   9054    ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;
   9055    ctx->ListState.CurrentPos = 0;
   9056 
   9057    ctx->Driver.NewList(ctx, name, mode);
   9058 
   9059    ctx->CurrentDispatch = ctx->Save;
   9060    _glapi_set_dispatch(ctx->CurrentDispatch);
   9061 }
   9062 
   9063 
   9064 /**
   9065  * End definition of current display list.
   9066  */
   9067 static void GLAPIENTRY
   9068 _mesa_EndList(void)
   9069 {
   9070    GET_CURRENT_CONTEXT(ctx);
   9071    SAVE_FLUSH_VERTICES(ctx);
   9072    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
   9073 
   9074    if (MESA_VERBOSE & VERBOSE_API)
   9075       _mesa_debug(ctx, "glEndList\n");
   9076 
   9077    /* Check that a list is under construction */
   9078    if (!ctx->ListState.CurrentList) {
   9079       _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
   9080       return;
   9081    }
   9082 
   9083    /* Call before emitting END_OF_LIST, in case the driver wants to
   9084     * emit opcodes itself.
   9085     */
   9086    ctx->Driver.EndList(ctx);
   9087 
   9088    (void) alloc_instruction(ctx, OPCODE_END_OF_LIST, 0);
   9089 
   9090    /* Destroy old list, if any */
   9091    destroy_list(ctx, ctx->ListState.CurrentList->Name);
   9092 
   9093    /* Install the new list */
   9094    _mesa_HashInsert(ctx->Shared->DisplayList,
   9095                     ctx->ListState.CurrentList->Name,
   9096                     ctx->ListState.CurrentList);
   9097 
   9098 
   9099    if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
   9100       mesa_print_display_list(ctx->ListState.CurrentList->Name);
   9101 
   9102    ctx->ListState.CurrentList = NULL;
   9103    ctx->ExecuteFlag = GL_TRUE;
   9104    ctx->CompileFlag = GL_FALSE;
   9105 
   9106    ctx->CurrentDispatch = ctx->Exec;
   9107    _glapi_set_dispatch(ctx->CurrentDispatch);
   9108 }
   9109 
   9110 
   9111 void GLAPIENTRY
   9112 _mesa_CallList(GLuint list)
   9113 {
   9114    GLboolean save_compile_flag;
   9115    GET_CURRENT_CONTEXT(ctx);
   9116    FLUSH_CURRENT(ctx, 0);
   9117 
   9118    if (MESA_VERBOSE & VERBOSE_API)
   9119       _mesa_debug(ctx, "glCallList %d\n", list);
   9120 
   9121    if (list == 0) {
   9122       _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");
   9123       return;
   9124    }
   9125 
   9126    if (0)
   9127       mesa_print_display_list( list );
   9128 
   9129    /* VERY IMPORTANT:  Save the CompileFlag status, turn it off,
   9130     * execute the display list, and restore the CompileFlag.
   9131     */
   9132    save_compile_flag = ctx->CompileFlag;
   9133    if (save_compile_flag) {
   9134       ctx->CompileFlag = GL_FALSE;
   9135    }
   9136 
   9137    execute_list(ctx, list);
   9138    ctx->CompileFlag = save_compile_flag;
   9139 
   9140    /* also restore API function pointers to point to "save" versions */
   9141    if (save_compile_flag) {
   9142       ctx->CurrentDispatch = ctx->Save;
   9143       _glapi_set_dispatch(ctx->CurrentDispatch);
   9144    }
   9145 }
   9146 
   9147 
   9148 /**
   9149  * Execute glCallLists:  call multiple display lists.
   9150  */
   9151 void GLAPIENTRY
   9152 _mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
   9153 {
   9154    GET_CURRENT_CONTEXT(ctx);
   9155    GLint i;
   9156    GLboolean save_compile_flag;
   9157 
   9158    if (MESA_VERBOSE & VERBOSE_API)
   9159       _mesa_debug(ctx, "glCallLists %d\n", n);
   9160 
   9161    switch (type) {
   9162    case GL_BYTE:
   9163    case GL_UNSIGNED_BYTE:
   9164    case GL_SHORT:
   9165    case GL_UNSIGNED_SHORT:
   9166    case GL_INT:
   9167    case GL_UNSIGNED_INT:
   9168    case GL_FLOAT:
   9169    case GL_2_BYTES:
   9170    case GL_3_BYTES:
   9171    case GL_4_BYTES:
   9172       /* OK */
   9173       break;
   9174    default:
   9175       _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
   9176       return;
   9177    }
   9178 
   9179    /* Save the CompileFlag status, turn it off, execute display list,
   9180     * and restore the CompileFlag.
   9181     */
   9182    save_compile_flag = ctx->CompileFlag;
   9183    ctx->CompileFlag = GL_FALSE;
   9184 
   9185    for (i = 0; i < n; i++) {
   9186       GLuint list = (GLuint) (ctx->List.ListBase + translate_id(i, type, lists));
   9187       execute_list(ctx, list);
   9188    }
   9189 
   9190    ctx->CompileFlag = save_compile_flag;
   9191 
   9192    /* also restore API function pointers to point to "save" versions */
   9193    if (save_compile_flag) {
   9194       ctx->CurrentDispatch = ctx->Save;
   9195       _glapi_set_dispatch(ctx->CurrentDispatch);
   9196    }
   9197 }
   9198 
   9199 
   9200 /**
   9201  * Set the offset added to list numbers in glCallLists.
   9202  */
   9203 static void GLAPIENTRY
   9204 _mesa_ListBase(GLuint base)
   9205 {
   9206    GET_CURRENT_CONTEXT(ctx);
   9207    FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
   9208    ASSERT_OUTSIDE_BEGIN_END(ctx);
   9209    ctx->List.ListBase = base;
   9210 }
   9211 
   9212 
   9213 /* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
   9214  */
   9215 static void GLAPIENTRY
   9216 exec_Finish(void)
   9217 {
   9218    GET_CURRENT_CONTEXT(ctx);
   9219    FLUSH_VERTICES(ctx, 0);
   9220    CALL_Finish(ctx->Exec, ());
   9221 }
   9222 
   9223 static void GLAPIENTRY
   9224 exec_Flush(void)
   9225 {
   9226    GET_CURRENT_CONTEXT(ctx);
   9227    FLUSH_VERTICES(ctx, 0);
   9228    CALL_Flush(ctx->Exec, ());
   9229 }
   9230 
   9231 static void GLAPIENTRY
   9232 exec_GetBooleanv(GLenum pname, GLboolean *params)
   9233 {
   9234    GET_CURRENT_CONTEXT(ctx);
   9235    FLUSH_VERTICES(ctx, 0);
   9236    CALL_GetBooleanv(ctx->Exec, (pname, params));
   9237 }
   9238 
   9239 static void GLAPIENTRY
   9240 exec_GetClipPlane(GLenum plane, GLdouble * equation)
   9241 {
   9242    GET_CURRENT_CONTEXT(ctx);
   9243    FLUSH_VERTICES(ctx, 0);
   9244    CALL_GetClipPlane(ctx->Exec, (plane, equation));
   9245 }
   9246 
   9247 static void GLAPIENTRY
   9248 exec_GetDoublev(GLenum pname, GLdouble *params)
   9249 {
   9250    GET_CURRENT_CONTEXT(ctx);
   9251    FLUSH_VERTICES(ctx, 0);
   9252    CALL_GetDoublev(ctx->Exec, (pname, params));
   9253 }
   9254 
   9255 static GLenum GLAPIENTRY
   9256 exec_GetError(void)
   9257 {
   9258    GET_CURRENT_CONTEXT(ctx);
   9259    FLUSH_VERTICES(ctx, 0);
   9260    return CALL_GetError(ctx->Exec, ());
   9261 }
   9262 
   9263 static void GLAPIENTRY
   9264 exec_GetFloatv(GLenum pname, GLfloat *params)
   9265 {
   9266    GET_CURRENT_CONTEXT(ctx);
   9267    FLUSH_VERTICES(ctx, 0);
   9268    CALL_GetFloatv(ctx->Exec, (pname, params));
   9269 }
   9270 
   9271 static void GLAPIENTRY
   9272 exec_GetIntegerv(GLenum pname, GLint *params)
   9273 {
   9274    GET_CURRENT_CONTEXT(ctx);
   9275    FLUSH_VERTICES(ctx, 0);
   9276    CALL_GetIntegerv(ctx->Exec, (pname, params));
   9277 }
   9278 
   9279 static void GLAPIENTRY
   9280 exec_GetLightfv(GLenum light, GLenum pname, GLfloat *params)
   9281 {
   9282    GET_CURRENT_CONTEXT(ctx);
   9283    FLUSH_VERTICES(ctx, 0);
   9284    CALL_GetLightfv(ctx->Exec, (light, pname, params));
   9285 }
   9286 
   9287 static void GLAPIENTRY
   9288 exec_GetLightiv(GLenum light, GLenum pname, GLint *params)
   9289 {
   9290    GET_CURRENT_CONTEXT(ctx);
   9291    FLUSH_VERTICES(ctx, 0);
   9292    CALL_GetLightiv(ctx->Exec, (light, pname, params));
   9293 }
   9294 
   9295 static void GLAPIENTRY
   9296 exec_GetMapdv(GLenum target, GLenum query, GLdouble * v)
   9297 {
   9298    GET_CURRENT_CONTEXT(ctx);
   9299    FLUSH_VERTICES(ctx, 0);
   9300    CALL_GetMapdv(ctx->Exec, (target, query, v));
   9301 }
   9302 
   9303 static void GLAPIENTRY
   9304 exec_GetMapfv(GLenum target, GLenum query, GLfloat * v)
   9305 {
   9306    GET_CURRENT_CONTEXT(ctx);
   9307    FLUSH_VERTICES(ctx, 0);
   9308    CALL_GetMapfv(ctx->Exec, (target, query, v));
   9309 }
   9310 
   9311 static void GLAPIENTRY
   9312 exec_GetMapiv(GLenum target, GLenum query, GLint * v)
   9313 {
   9314    GET_CURRENT_CONTEXT(ctx);
   9315    FLUSH_VERTICES(ctx, 0);
   9316    CALL_GetMapiv(ctx->Exec, (target, query, v));
   9317 }
   9318 
   9319 static void GLAPIENTRY
   9320 exec_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
   9321 {
   9322    GET_CURRENT_CONTEXT(ctx);
   9323    FLUSH_VERTICES(ctx, 0);
   9324    CALL_GetMaterialfv(ctx->Exec, (face, pname, params));
   9325 }
   9326 
   9327 static void GLAPIENTRY
   9328 exec_GetMaterialiv(GLenum face, GLenum pname, GLint *params)
   9329 {
   9330    GET_CURRENT_CONTEXT(ctx);
   9331    FLUSH_VERTICES(ctx, 0);
   9332    CALL_GetMaterialiv(ctx->Exec, (face, pname, params));
   9333 }
   9334 
   9335 static void GLAPIENTRY
   9336 exec_GetPixelMapfv(GLenum map, GLfloat *values)
   9337 {
   9338    GET_CURRENT_CONTEXT(ctx);
   9339    FLUSH_VERTICES(ctx, 0);
   9340    CALL_GetPixelMapfv(ctx->Exec, (map, values));
   9341 }
   9342 
   9343 static void GLAPIENTRY
   9344 exec_GetPixelMapuiv(GLenum map, GLuint *values)
   9345 {
   9346    GET_CURRENT_CONTEXT(ctx);
   9347    FLUSH_VERTICES(ctx, 0);
   9348    CALL_GetPixelMapuiv(ctx->Exec, (map, values));
   9349 }
   9350 
   9351 static void GLAPIENTRY
   9352 exec_GetPixelMapusv(GLenum map, GLushort *values)
   9353 {
   9354    GET_CURRENT_CONTEXT(ctx);
   9355    FLUSH_VERTICES(ctx, 0);
   9356    CALL_GetPixelMapusv(ctx->Exec, (map, values));
   9357 }
   9358 
   9359 static void GLAPIENTRY
   9360 exec_GetPolygonStipple(GLubyte * dest)
   9361 {
   9362    GET_CURRENT_CONTEXT(ctx);
   9363    FLUSH_VERTICES(ctx, 0);
   9364    CALL_GetPolygonStipple(ctx->Exec, (dest));
   9365 }
   9366 
   9367 static const GLubyte *GLAPIENTRY
   9368 exec_GetString(GLenum name)
   9369 {
   9370    GET_CURRENT_CONTEXT(ctx);
   9371    FLUSH_VERTICES(ctx, 0);
   9372    return CALL_GetString(ctx->Exec, (name));
   9373 }
   9374 
   9375 static void GLAPIENTRY
   9376 exec_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
   9377 {
   9378    GET_CURRENT_CONTEXT(ctx);
   9379    FLUSH_VERTICES(ctx, 0);
   9380    CALL_GetTexEnvfv(ctx->Exec, (target, pname, params));
   9381 }
   9382 
   9383 static void GLAPIENTRY
   9384 exec_GetTexEnviv(GLenum target, GLenum pname, GLint *params)
   9385 {
   9386    GET_CURRENT_CONTEXT(ctx);
   9387    FLUSH_VERTICES(ctx, 0);
   9388    CALL_GetTexEnviv(ctx->Exec, (target, pname, params));
   9389 }
   9390 
   9391 static void GLAPIENTRY
   9392 exec_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
   9393 {
   9394    GET_CURRENT_CONTEXT(ctx);
   9395    FLUSH_VERTICES(ctx, 0);
   9396    CALL_GetTexGendv(ctx->Exec, (coord, pname, params));
   9397 }
   9398 
   9399 static void GLAPIENTRY
   9400 exec_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
   9401 {
   9402    GET_CURRENT_CONTEXT(ctx);
   9403    FLUSH_VERTICES(ctx, 0);
   9404    CALL_GetTexGenfv(ctx->Exec, (coord, pname, params));
   9405 }
   9406 
   9407 static void GLAPIENTRY
   9408 exec_GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
   9409 {
   9410    GET_CURRENT_CONTEXT(ctx);
   9411    FLUSH_VERTICES(ctx, 0);
   9412    CALL_GetTexGeniv(ctx->Exec, (coord, pname, params));
   9413 }
   9414 
   9415 static void GLAPIENTRY
   9416 exec_GetTexImage(GLenum target, GLint level, GLenum format,
   9417                  GLenum type, GLvoid * pixels)
   9418 {
   9419    GET_CURRENT_CONTEXT(ctx);
   9420    FLUSH_VERTICES(ctx, 0);
   9421    CALL_GetTexImage(ctx->Exec, (target, level, format, type, pixels));
   9422 }
   9423 
   9424 static void GLAPIENTRY
   9425 exec_GetTexLevelParameterfv(GLenum target, GLint level,
   9426                             GLenum pname, GLfloat *params)
   9427 {
   9428    GET_CURRENT_CONTEXT(ctx);
   9429    FLUSH_VERTICES(ctx, 0);
   9430    CALL_GetTexLevelParameterfv(ctx->Exec, (target, level, pname, params));
   9431 }
   9432 
   9433 static void GLAPIENTRY
   9434 exec_GetTexLevelParameteriv(GLenum target, GLint level,
   9435                             GLenum pname, GLint *params)
   9436 {
   9437    GET_CURRENT_CONTEXT(ctx);
   9438    FLUSH_VERTICES(ctx, 0);
   9439    CALL_GetTexLevelParameteriv(ctx->Exec, (target, level, pname, params));
   9440 }
   9441 
   9442 static void GLAPIENTRY
   9443 exec_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
   9444 {
   9445    GET_CURRENT_CONTEXT(ctx);
   9446    FLUSH_VERTICES(ctx, 0);
   9447    CALL_GetTexParameterfv(ctx->Exec, (target, pname, params));
   9448 }
   9449 
   9450 static void GLAPIENTRY
   9451 exec_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
   9452 {
   9453    GET_CURRENT_CONTEXT(ctx);
   9454    FLUSH_VERTICES(ctx, 0);
   9455    CALL_GetTexParameteriv(ctx->Exec, (target, pname, params));
   9456 }
   9457 
   9458 static GLboolean GLAPIENTRY
   9459 exec_IsEnabled(GLenum cap)
   9460 {
   9461    GET_CURRENT_CONTEXT(ctx);
   9462    FLUSH_VERTICES(ctx, 0);
   9463    return CALL_IsEnabled(ctx->Exec, (cap));
   9464 }
   9465 
   9466 static void GLAPIENTRY
   9467 exec_PixelStoref(GLenum pname, GLfloat param)
   9468 {
   9469    GET_CURRENT_CONTEXT(ctx);
   9470    FLUSH_VERTICES(ctx, 0);
   9471    CALL_PixelStoref(ctx->Exec, (pname, param));
   9472 }
   9473 
   9474 static void GLAPIENTRY
   9475 exec_PixelStorei(GLenum pname, GLint param)
   9476 {
   9477    GET_CURRENT_CONTEXT(ctx);
   9478    FLUSH_VERTICES(ctx, 0);
   9479    CALL_PixelStorei(ctx->Exec, (pname, param));
   9480 }
   9481 
   9482 static void GLAPIENTRY
   9483 exec_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
   9484                 GLenum format, GLenum type, GLvoid * pixels)
   9485 {
   9486    GET_CURRENT_CONTEXT(ctx);
   9487    FLUSH_VERTICES(ctx, 0);
   9488    CALL_ReadPixels(ctx->Exec, (x, y, width, height, format, type, pixels));
   9489 }
   9490 
   9491 static GLint GLAPIENTRY
   9492 exec_RenderMode(GLenum mode)
   9493 {
   9494    GET_CURRENT_CONTEXT(ctx);
   9495    FLUSH_VERTICES(ctx, 0);
   9496    return CALL_RenderMode(ctx->Exec, (mode));
   9497 }
   9498 
   9499 static void GLAPIENTRY
   9500 exec_FeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
   9501 {
   9502    GET_CURRENT_CONTEXT(ctx);
   9503    FLUSH_VERTICES(ctx, 0);
   9504    CALL_FeedbackBuffer(ctx->Exec, (size, type, buffer));
   9505 }
   9506 
   9507 static void GLAPIENTRY
   9508 exec_SelectBuffer(GLsizei size, GLuint * buffer)
   9509 {
   9510    GET_CURRENT_CONTEXT(ctx);
   9511    FLUSH_VERTICES(ctx, 0);
   9512    CALL_SelectBuffer(ctx->Exec, (size, buffer));
   9513 }
   9514 
   9515 static GLboolean GLAPIENTRY
   9516 exec_AreTexturesResident(GLsizei n, const GLuint * texName,
   9517                          GLboolean * residences)
   9518 {
   9519    GET_CURRENT_CONTEXT(ctx);
   9520    FLUSH_VERTICES(ctx, 0);
   9521    return CALL_AreTexturesResident(ctx->Exec, (n, texName, residences));
   9522 }
   9523 
   9524 static void GLAPIENTRY
   9525 exec_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
   9526 {
   9527    GET_CURRENT_CONTEXT(ctx);
   9528    FLUSH_VERTICES(ctx, 0);
   9529    CALL_ColorPointer(ctx->Exec, (size, type, stride, ptr));
   9530 }
   9531 
   9532 static void GLAPIENTRY
   9533 exec_DeleteTextures(GLsizei n, const GLuint * texName)
   9534 {
   9535    GET_CURRENT_CONTEXT(ctx);
   9536    FLUSH_VERTICES(ctx, 0);
   9537    CALL_DeleteTextures(ctx->Exec, (n, texName));
   9538 }
   9539 
   9540 static void GLAPIENTRY
   9541 exec_DisableClientState(GLenum cap)
   9542 {
   9543    GET_CURRENT_CONTEXT(ctx);
   9544    FLUSH_VERTICES(ctx, 0);
   9545    CALL_DisableClientState(ctx->Exec, (cap));
   9546 }
   9547 
   9548 static void GLAPIENTRY
   9549 exec_EdgeFlagPointer(GLsizei stride, const GLvoid * vptr)
   9550 {
   9551    GET_CURRENT_CONTEXT(ctx);
   9552    FLUSH_VERTICES(ctx, 0);
   9553    CALL_EdgeFlagPointer(ctx->Exec, (stride, vptr));
   9554 }
   9555 
   9556 static void GLAPIENTRY
   9557 exec_EnableClientState(GLenum cap)
   9558 {
   9559    GET_CURRENT_CONTEXT(ctx);
   9560    FLUSH_VERTICES(ctx, 0);
   9561    CALL_EnableClientState(ctx->Exec, (cap));
   9562 }
   9563 
   9564 static void GLAPIENTRY
   9565 exec_GenTextures(GLsizei n, GLuint * texName)
   9566 {
   9567    GET_CURRENT_CONTEXT(ctx);
   9568    FLUSH_VERTICES(ctx, 0);
   9569    CALL_GenTextures(ctx->Exec, (n, texName));
   9570 }
   9571 
   9572 static void GLAPIENTRY
   9573 exec_GetPointerv(GLenum pname, GLvoid **params)
   9574 {
   9575    GET_CURRENT_CONTEXT(ctx);
   9576    FLUSH_VERTICES(ctx, 0);
   9577    CALL_GetPointerv(ctx->Exec, (pname, params));
   9578 }
   9579 
   9580 static void GLAPIENTRY
   9581 exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
   9582 {
   9583    GET_CURRENT_CONTEXT(ctx);
   9584    FLUSH_VERTICES(ctx, 0);
   9585    CALL_IndexPointer(ctx->Exec, (type, stride, ptr));
   9586 }
   9587 
   9588 static void GLAPIENTRY
   9589 exec_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)
   9590 {
   9591    GET_CURRENT_CONTEXT(ctx);
   9592    FLUSH_VERTICES(ctx, 0);
   9593    CALL_InterleavedArrays(ctx->Exec, (format, stride, pointer));
   9594 }
   9595 
   9596 static GLboolean GLAPIENTRY
   9597 exec_IsTexture(GLuint texture)
   9598 {
   9599    GET_CURRENT_CONTEXT(ctx);
   9600    FLUSH_VERTICES(ctx, 0);
   9601    return CALL_IsTexture(ctx->Exec, (texture));
   9602 }
   9603 
   9604 static void GLAPIENTRY
   9605 exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
   9606 {
   9607    GET_CURRENT_CONTEXT(ctx);
   9608    FLUSH_VERTICES(ctx, 0);
   9609    CALL_NormalPointer(ctx->Exec, (type, stride, ptr));
   9610 }
   9611 
   9612 static void GLAPIENTRY
   9613 exec_PopClientAttrib(void)
   9614 {
   9615    GET_CURRENT_CONTEXT(ctx);
   9616    FLUSH_VERTICES(ctx, 0);
   9617    CALL_PopClientAttrib(ctx->Exec, ());
   9618 }
   9619 
   9620 static void GLAPIENTRY
   9621 exec_PushClientAttrib(GLbitfield mask)
   9622 {
   9623    GET_CURRENT_CONTEXT(ctx);
   9624    FLUSH_VERTICES(ctx, 0);
   9625    CALL_PushClientAttrib(ctx->Exec, (mask));
   9626 }
   9627 
   9628 static void GLAPIENTRY
   9629 exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
   9630                      const GLvoid *ptr)
   9631 {
   9632    GET_CURRENT_CONTEXT(ctx);
   9633    FLUSH_VERTICES(ctx, 0);
   9634    CALL_TexCoordPointer(ctx->Exec, (size, type, stride, ptr));
   9635 }
   9636 
   9637 static void GLAPIENTRY
   9638 exec_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img)
   9639 {
   9640    GET_CURRENT_CONTEXT(ctx);
   9641    FLUSH_VERTICES(ctx, 0);
   9642    CALL_GetCompressedTexImageARB(ctx->Exec, (target, level, img));
   9643 }
   9644 
   9645 static void GLAPIENTRY
   9646 exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
   9647                    const GLvoid *ptr)
   9648 {
   9649    GET_CURRENT_CONTEXT(ctx);
   9650    FLUSH_VERTICES(ctx, 0);
   9651    CALL_VertexPointer(ctx->Exec, (size, type, stride, ptr));
   9652 }
   9653 
   9654 static void GLAPIENTRY
   9655 exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
   9656                              GLint x, GLint y, GLsizei width)
   9657 {
   9658    GET_CURRENT_CONTEXT(ctx);
   9659    FLUSH_VERTICES(ctx, 0);
   9660    CALL_CopyConvolutionFilter1D(ctx->Exec,
   9661                                 (target, internalFormat, x, y, width));
   9662 }
   9663 
   9664 static void GLAPIENTRY
   9665 exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
   9666                              GLint x, GLint y, GLsizei width, GLsizei height)
   9667 {
   9668    GET_CURRENT_CONTEXT(ctx);
   9669    FLUSH_VERTICES(ctx, 0);
   9670    CALL_CopyConvolutionFilter2D(ctx->Exec,
   9671                                 (target, internalFormat, x, y, width,
   9672                                  height));
   9673 }
   9674 
   9675 static void GLAPIENTRY
   9676 exec_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * data)
   9677 {
   9678    GET_CURRENT_CONTEXT(ctx);
   9679    FLUSH_VERTICES(ctx, 0);
   9680    CALL_GetColorTable(ctx->Exec, (target, format, type, data));
   9681 }
   9682 
   9683 static void GLAPIENTRY
   9684 exec_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
   9685 {
   9686    GET_CURRENT_CONTEXT(ctx);
   9687    FLUSH_VERTICES(ctx, 0);
   9688    CALL_GetColorTableParameterfv(ctx->Exec, (target, pname, params));
   9689 }
   9690 
   9691 static void GLAPIENTRY
   9692 exec_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
   9693 {
   9694    GET_CURRENT_CONTEXT(ctx);
   9695    FLUSH_VERTICES(ctx, 0);
   9696    CALL_GetColorTableParameteriv(ctx->Exec, (target, pname, params));
   9697 }
   9698 
   9699 static void GLAPIENTRY
   9700 exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
   9701                           GLvoid * image)
   9702 {
   9703    GET_CURRENT_CONTEXT(ctx);
   9704    FLUSH_VERTICES(ctx, 0);
   9705    CALL_GetConvolutionFilter(ctx->Exec, (target, format, type, image));
   9706 }
   9707 
   9708 static void GLAPIENTRY
   9709 exec_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
   9710 {
   9711    GET_CURRENT_CONTEXT(ctx);
   9712    FLUSH_VERTICES(ctx, 0);
   9713    CALL_GetConvolutionParameterfv(ctx->Exec, (target, pname, params));
   9714 }
   9715 
   9716 static void GLAPIENTRY
   9717 exec_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
   9718 {
   9719    GET_CURRENT_CONTEXT(ctx);
   9720    FLUSH_VERTICES(ctx, 0);
   9721    CALL_GetConvolutionParameteriv(ctx->Exec, (target, pname, params));
   9722 }
   9723 
   9724 static void GLAPIENTRY
   9725 exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
   9726                   GLenum type, GLvoid *values)
   9727 {
   9728    GET_CURRENT_CONTEXT(ctx);
   9729    FLUSH_VERTICES(ctx, 0);
   9730    CALL_GetHistogram(ctx->Exec, (target, reset, format, type, values));
   9731 }
   9732 
   9733 static void GLAPIENTRY
   9734 exec_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
   9735 {
   9736    GET_CURRENT_CONTEXT(ctx);
   9737    FLUSH_VERTICES(ctx, 0);
   9738    CALL_GetHistogramParameterfv(ctx->Exec, (target, pname, params));
   9739 }
   9740 
   9741 static void GLAPIENTRY
   9742 exec_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
   9743 {
   9744    GET_CURRENT_CONTEXT(ctx);
   9745    FLUSH_VERTICES(ctx, 0);
   9746    CALL_GetHistogramParameteriv(ctx->Exec, (target, pname, params));
   9747 }
   9748 
   9749 static void GLAPIENTRY
   9750 exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
   9751                GLenum type, GLvoid *values)
   9752 {
   9753    GET_CURRENT_CONTEXT(ctx);
   9754    FLUSH_VERTICES(ctx, 0);
   9755    CALL_GetMinmax(ctx->Exec, (target, reset, format, type, values));
   9756 }
   9757 
   9758 static void GLAPIENTRY
   9759 exec_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
   9760 {
   9761    GET_CURRENT_CONTEXT(ctx);
   9762    FLUSH_VERTICES(ctx, 0);
   9763    CALL_GetMinmaxParameterfv(ctx->Exec, (target, pname, params));
   9764 }
   9765 
   9766 static void GLAPIENTRY
   9767 exec_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
   9768 {
   9769    GET_CURRENT_CONTEXT(ctx);
   9770    FLUSH_VERTICES(ctx, 0);
   9771    CALL_GetMinmaxParameteriv(ctx->Exec, (target, pname, params));
   9772 }
   9773 
   9774 static void GLAPIENTRY
   9775 exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
   9776                         GLvoid *row, GLvoid *column, GLvoid *span)
   9777 {
   9778    GET_CURRENT_CONTEXT(ctx);
   9779    FLUSH_VERTICES(ctx, 0);
   9780    CALL_GetSeparableFilter(ctx->Exec,
   9781                            (target, format, type, row, column, span));
   9782 }
   9783 
   9784 static void GLAPIENTRY
   9785 exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
   9786                        GLsizei width, GLsizei height, GLenum format,
   9787                        GLenum type, const GLvoid *row, const GLvoid *column)
   9788 {
   9789    GET_CURRENT_CONTEXT(ctx);
   9790    FLUSH_VERTICES(ctx, 0);
   9791    CALL_SeparableFilter2D(ctx->Exec,
   9792                           (target, internalFormat, width, height, format,
   9793                            type, row, column));
   9794 }
   9795 
   9796 static void GLAPIENTRY
   9797 exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
   9798                      GLsizei count, const GLvoid *ptr)
   9799 {
   9800    GET_CURRENT_CONTEXT(ctx);
   9801    FLUSH_VERTICES(ctx, 0);
   9802    CALL_ColorPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
   9803 }
   9804 
   9805 static void GLAPIENTRY
   9806 exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
   9807 {
   9808    GET_CURRENT_CONTEXT(ctx);
   9809    FLUSH_VERTICES(ctx, 0);
   9810    CALL_EdgeFlagPointerEXT(ctx->Exec, (stride, count, ptr));
   9811 }
   9812 
   9813 static void GLAPIENTRY
   9814 exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
   9815                      const GLvoid *ptr)
   9816 {
   9817    GET_CURRENT_CONTEXT(ctx);
   9818    FLUSH_VERTICES(ctx, 0);
   9819    CALL_IndexPointerEXT(ctx->Exec, (type, stride, count, ptr));
   9820 }
   9821 
   9822 static void GLAPIENTRY
   9823 exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
   9824                       const GLvoid *ptr)
   9825 {
   9826    GET_CURRENT_CONTEXT(ctx);
   9827    FLUSH_VERTICES(ctx, 0);
   9828    CALL_NormalPointerEXT(ctx->Exec, (type, stride, count, ptr));
   9829 }
   9830 
   9831 static void GLAPIENTRY
   9832 exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
   9833                         GLsizei count, const GLvoid *ptr)
   9834 {
   9835    GET_CURRENT_CONTEXT(ctx);
   9836    FLUSH_VERTICES(ctx, 0);
   9837    CALL_TexCoordPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
   9838 }
   9839 
   9840 static void GLAPIENTRY
   9841 exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
   9842                       GLsizei count, const GLvoid *ptr)
   9843 {
   9844    GET_CURRENT_CONTEXT(ctx);
   9845    FLUSH_VERTICES(ctx, 0);
   9846    CALL_VertexPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
   9847 }
   9848 
   9849 static void GLAPIENTRY
   9850 exec_LockArraysEXT(GLint first, GLsizei count)
   9851 {
   9852    GET_CURRENT_CONTEXT(ctx);
   9853    FLUSH_VERTICES(ctx, 0);
   9854    CALL_LockArraysEXT(ctx->Exec, (first, count));
   9855 }
   9856 
   9857 static void GLAPIENTRY
   9858 exec_UnlockArraysEXT(void)
   9859 {
   9860    GET_CURRENT_CONTEXT(ctx);
   9861    FLUSH_VERTICES(ctx, 0);
   9862    CALL_UnlockArraysEXT(ctx->Exec, ());
   9863 }
   9864 
   9865 static void GLAPIENTRY
   9866 exec_ClientActiveTextureARB(GLenum target)
   9867 {
   9868    GET_CURRENT_CONTEXT(ctx);
   9869    FLUSH_VERTICES(ctx, 0);
   9870    CALL_ClientActiveTextureARB(ctx->Exec, (target));
   9871 }
   9872 
   9873 static void GLAPIENTRY
   9874 exec_SecondaryColorPointerEXT(GLint size, GLenum type,
   9875                               GLsizei stride, const GLvoid *ptr)
   9876 {
   9877    GET_CURRENT_CONTEXT(ctx);
   9878    FLUSH_VERTICES(ctx, 0);
   9879    CALL_SecondaryColorPointerEXT(ctx->Exec, (size, type, stride, ptr));
   9880 }
   9881 
   9882 static void GLAPIENTRY
   9883 exec_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
   9884 {
   9885    GET_CURRENT_CONTEXT(ctx);
   9886    FLUSH_VERTICES(ctx, 0);
   9887    CALL_FogCoordPointerEXT(ctx->Exec, (type, stride, ptr));
   9888 }
   9889 
   9890 /* GL_EXT_multi_draw_arrays */
   9891 static void GLAPIENTRY
   9892 exec_MultiDrawArraysEXT(GLenum mode, const GLint *first,
   9893                         const GLsizei *count, GLsizei primcount)
   9894 {
   9895    GET_CURRENT_CONTEXT(ctx);
   9896    FLUSH_VERTICES(ctx, 0);
   9897    CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount));
   9898 }
   9899 
   9900 /* GL_IBM_multimode_draw_arrays */
   9901 static void GLAPIENTRY
   9902 exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first,
   9903                             const GLsizei * count, GLsizei primcount,
   9904                             GLint modestride)
   9905 {
   9906    GET_CURRENT_CONTEXT(ctx);
   9907    FLUSH_VERTICES(ctx, 0);
   9908    CALL_MultiModeDrawArraysIBM(ctx->Exec,
   9909                                (mode, first, count, primcount, modestride));
   9910 }
   9911 
   9912 /* GL_IBM_multimode_draw_arrays */
   9913 static void GLAPIENTRY
   9914 exec_MultiModeDrawElementsIBM(const GLenum * mode,
   9915                               const GLsizei * count,
   9916                               GLenum type,
   9917                               const GLvoid * const *indices,
   9918                               GLsizei primcount, GLint modestride)
   9919 {
   9920    GET_CURRENT_CONTEXT(ctx);
   9921    FLUSH_VERTICES(ctx, 0);
   9922    CALL_MultiModeDrawElementsIBM(ctx->Exec,
   9923                                  (mode, count, type, indices, primcount,
   9924                                   modestride));
   9925 }
   9926 
   9927 /**
   9928  * Setup the given dispatch table to point to Mesa's display list
   9929  * building functions.
   9930  *
   9931  * This does not include any of the tnl functions - they are
   9932  * initialized from _mesa_init_api_defaults and from the active vtxfmt
   9933  * struct.
   9934  */
   9935 struct _glapi_table *
   9936 _mesa_create_save_table(const struct gl_context *ctx)
   9937 {
   9938    struct _glapi_table *table;
   9939 
   9940    table = _mesa_alloc_dispatch_table(_gloffset_COUNT);
   9941    if (table == NULL)
   9942       return NULL;
   9943 
   9944    _mesa_loopback_init_api_table(ctx, table);
   9945 
   9946    /* GL 1.0 */
   9947    SET_Accum(table, save_Accum);
   9948    SET_AlphaFunc(table, save_AlphaFunc);
   9949    SET_Bitmap(table, save_Bitmap);
   9950    SET_BlendFunc(table, save_BlendFunc);
   9951    SET_CallList(table, save_CallList);
   9952    SET_CallLists(table, save_CallLists);
   9953    SET_Clear(table, save_Clear);
   9954    SET_ClearAccum(table, save_ClearAccum);
   9955    SET_ClearColor(table, save_ClearColor);
   9956    SET_ClearDepth(table, save_ClearDepth);
   9957    SET_ClearIndex(table, save_ClearIndex);
   9958    SET_ClearStencil(table, save_ClearStencil);
   9959    SET_ClipPlane(table, save_ClipPlane);
   9960    SET_ColorMask(table, save_ColorMask);
   9961    SET_ColorMaskIndexedEXT(table, save_ColorMaskIndexed);
   9962    SET_ColorMaterial(table, save_ColorMaterial);
   9963    SET_CopyPixels(table, save_CopyPixels);
   9964    SET_CullFace(table, save_CullFace);
   9965    SET_DeleteLists(table, _mesa_DeleteLists);
   9966    SET_DepthFunc(table, save_DepthFunc);
   9967    SET_DepthMask(table, save_DepthMask);
   9968    SET_DepthRange(table, save_DepthRange);
   9969    SET_Disable(table, save_Disable);
   9970    SET_DisableIndexedEXT(table, save_DisableIndexed);
   9971    SET_DrawBuffer(table, save_DrawBuffer);
   9972    SET_DrawPixels(table, save_DrawPixels);
   9973    SET_Enable(table, save_Enable);
   9974    SET_EnableIndexedEXT(table, save_EnableIndexed);
   9975    SET_EndList(table, _mesa_EndList);
   9976    SET_EvalMesh1(table, save_EvalMesh1);
   9977    SET_EvalMesh2(table, save_EvalMesh2);
   9978    SET_Finish(table, exec_Finish);
   9979    SET_Flush(table, exec_Flush);
   9980    SET_Fogf(table, save_Fogf);
   9981    SET_Fogfv(table, save_Fogfv);
   9982    SET_Fogi(table, save_Fogi);
   9983    SET_Fogiv(table, save_Fogiv);
   9984    SET_FrontFace(table, save_FrontFace);
   9985    SET_Frustum(table, save_Frustum);
   9986    SET_GenLists(table, _mesa_GenLists);
   9987    SET_GetBooleanv(table, exec_GetBooleanv);
   9988    SET_GetClipPlane(table, exec_GetClipPlane);
   9989    SET_GetDoublev(table, exec_GetDoublev);
   9990    SET_GetError(table, exec_GetError);
   9991    SET_GetFloatv(table, exec_GetFloatv);
   9992    SET_GetIntegerv(table, exec_GetIntegerv);
   9993    SET_GetLightfv(table, exec_GetLightfv);
   9994    SET_GetLightiv(table, exec_GetLightiv);
   9995    SET_GetMapdv(table, exec_GetMapdv);
   9996    SET_GetMapfv(table, exec_GetMapfv);
   9997    SET_GetMapiv(table, exec_GetMapiv);
   9998    SET_GetMaterialfv(table, exec_GetMaterialfv);
   9999    SET_GetMaterialiv(table, exec_GetMaterialiv);
   10000    SET_GetPixelMapfv(table, exec_GetPixelMapfv);
   10001    SET_GetPixelMapuiv(table, exec_GetPixelMapuiv);
   10002    SET_GetPixelMapusv(table, exec_GetPixelMapusv);
   10003    SET_GetPolygonStipple(table, exec_GetPolygonStipple);
   10004    SET_GetString(table, exec_GetString);
   10005    SET_GetTexEnvfv(table, exec_GetTexEnvfv);
   10006    SET_GetTexEnviv(table, exec_GetTexEnviv);
   10007    SET_GetTexGendv(table, exec_GetTexGendv);
   10008    SET_GetTexGenfv(table, exec_GetTexGenfv);
   10009    SET_GetTexGeniv(table, exec_GetTexGeniv);
   10010    SET_GetTexImage(table, exec_GetTexImage);
   10011    SET_GetTexLevelParameterfv(table, exec_GetTexLevelParameterfv);
   10012    SET_GetTexLevelParameteriv(table, exec_GetTexLevelParameteriv);
   10013    SET_GetTexParameterfv(table, exec_GetTexParameterfv);
   10014    SET_GetTexParameteriv(table, exec_GetTexParameteriv);
   10015    SET_Hint(table, save_Hint);
   10016    SET_IndexMask(table, save_IndexMask);
   10017    SET_InitNames(table, save_InitNames);
   10018    SET_IsEnabled(table, exec_IsEnabled);
   10019    SET_IsList(table, _mesa_IsList);
   10020    SET_LightModelf(table, save_LightModelf);
   10021    SET_LightModelfv(table, save_LightModelfv);
   10022    SET_LightModeli(table, save_LightModeli);
   10023    SET_LightModeliv(table, save_LightModeliv);
   10024    SET_Lightf(table, save_Lightf);
   10025    SET_Lightfv(table, save_Lightfv);
   10026    SET_Lighti(table, save_Lighti);
   10027    SET_Lightiv(table, save_Lightiv);
   10028    SET_LineStipple(table, save_LineStipple);
   10029    SET_LineWidth(table, save_LineWidth);
   10030    SET_ListBase(table, save_ListBase);
   10031    SET_LoadIdentity(table, save_LoadIdentity);
   10032    SET_LoadMatrixd(table, save_LoadMatrixd);
   10033    SET_LoadMatrixf(table, save_LoadMatrixf);
   10034    SET_LoadName(table, save_LoadName);
   10035    SET_LogicOp(table, save_LogicOp);
   10036    SET_Map1d(table, save_Map1d);
   10037    SET_Map1f(table, save_Map1f);
   10038    SET_Map2d(table, save_Map2d);
   10039    SET_Map2f(table, save_Map2f);
   10040    SET_MapGrid1d(table, save_MapGrid1d);
   10041    SET_MapGrid1f(table, save_MapGrid1f);
   10042    SET_MapGrid2d(table, save_MapGrid2d);
   10043    SET_MapGrid2f(table, save_MapGrid2f);
   10044    SET_MatrixMode(table, save_MatrixMode);
   10045    SET_MultMatrixd(table, save_MultMatrixd);
   10046    SET_MultMatrixf(table, save_MultMatrixf);
   10047    SET_NewList(table, save_NewList);
   10048    SET_Ortho(table, save_Ortho);
   10049    SET_PassThrough(table, save_PassThrough);
   10050    SET_PixelMapfv(table, save_PixelMapfv);
   10051    SET_PixelMapuiv(table, save_PixelMapuiv);
   10052    SET_PixelMapusv(table, save_PixelMapusv);
   10053    SET_PixelStoref(table, exec_PixelStoref);
   10054    SET_PixelStorei(table, exec_PixelStorei);
   10055    SET_PixelTransferf(table, save_PixelTransferf);
   10056    SET_PixelTransferi(table, save_PixelTransferi);
   10057    SET_PixelZoom(table, save_PixelZoom);
   10058    SET_PointSize(table, save_PointSize);
   10059    SET_PolygonMode(table, save_PolygonMode);
   10060    SET_PolygonOffset(table, save_PolygonOffset);
   10061    SET_PolygonStipple(table, save_PolygonStipple);
   10062    SET_PopAttrib(table, save_PopAttrib);
   10063    SET_PopMatrix(table, save_PopMatrix);
   10064    SET_PopName(table, save_PopName);
   10065    SET_PushAttrib(table, save_PushAttrib);
   10066    SET_PushMatrix(table, save_PushMatrix);
   10067    SET_PushName(table, save_PushName);
   10068    SET_RasterPos2d(table, save_RasterPos2d);
   10069    SET_RasterPos2dv(table, save_RasterPos2dv);
   10070    SET_RasterPos2f(table, save_RasterPos2f);
   10071    SET_RasterPos2fv(table, save_RasterPos2fv);
   10072    SET_RasterPos2i(table, save_RasterPos2i);
   10073    SET_RasterPos2iv(table, save_RasterPos2iv);
   10074    SET_RasterPos2s(table, save_RasterPos2s);
   10075    SET_RasterPos2sv(table, save_RasterPos2sv);
   10076    SET_RasterPos3d(table, save_RasterPos3d);
   10077    SET_RasterPos3dv(table, save_RasterPos3dv);
   10078    SET_RasterPos3f(table, save_RasterPos3f);
   10079    SET_RasterPos3fv(table, save_RasterPos3fv);
   10080    SET_RasterPos3i(table, save_RasterPos3i);
   10081    SET_RasterPos3iv(table, save_RasterPos3iv);
   10082    SET_RasterPos3s(table, save_RasterPos3s);
   10083    SET_RasterPos3sv(table, save_RasterPos3sv);
   10084    SET_RasterPos4d(table, save_RasterPos4d);
   10085    SET_RasterPos4dv(table, save_RasterPos4dv);
   10086    SET_RasterPos4f(table, save_RasterPos4f);
   10087    SET_RasterPos4fv(table, save_RasterPos4fv);
   10088    SET_RasterPos4i(table, save_RasterPos4i);
   10089    SET_RasterPos4iv(table, save_RasterPos4iv);
   10090    SET_RasterPos4s(table, save_RasterPos4s);
   10091    SET_RasterPos4sv(table, save_RasterPos4sv);
   10092    SET_ReadBuffer(table, save_ReadBuffer);
   10093    SET_ReadPixels(table, exec_ReadPixels);
   10094    SET_RenderMode(table, exec_RenderMode);
   10095    SET_Rotated(table, save_Rotated);
   10096    SET_Rotatef(table, save_Rotatef);
   10097    SET_Scaled(table, save_Scaled);
   10098    SET_Scalef(table, save_Scalef);
   10099    SET_Scissor(table, save_Scissor);
   10100    SET_FeedbackBuffer(table, exec_FeedbackBuffer);
   10101    SET_SelectBuffer(table, exec_SelectBuffer);
   10102    SET_ShadeModel(table, save_ShadeModel);
   10103    SET_StencilFunc(table, save_StencilFunc);
   10104    SET_StencilMask(table, save_StencilMask);
   10105    SET_StencilOp(table, save_StencilOp);
   10106    SET_TexEnvf(table, save_TexEnvf);
   10107    SET_TexEnvfv(table, save_TexEnvfv);
   10108    SET_TexEnvi(table, save_TexEnvi);
   10109    SET_TexEnviv(table, save_TexEnviv);
   10110    SET_TexGend(table, save_TexGend);
   10111    SET_TexGendv(table, save_TexGendv);
   10112    SET_TexGenf(table, save_TexGenf);
   10113    SET_TexGenfv(table, save_TexGenfv);
   10114    SET_TexGeni(table, save_TexGeni);
   10115    SET_TexGeniv(table, save_TexGeniv);
   10116    SET_TexImage1D(table, save_TexImage1D);
   10117    SET_TexImage2D(table, save_TexImage2D);
   10118    SET_TexParameterf(table, save_TexParameterf);
   10119    SET_TexParameterfv(table, save_TexParameterfv);
   10120    SET_TexParameteri(table, save_TexParameteri);
   10121    SET_TexParameteriv(table, save_TexParameteriv);
   10122    SET_Translated(table, save_Translated);
   10123    SET_Translatef(table, save_Translatef);
   10124    SET_Viewport(table, save_Viewport);
   10125 
   10126    /* GL 1.1 */
   10127    SET_AreTexturesResident(table, exec_AreTexturesResident);
   10128    SET_BindTexture(table, save_BindTexture);
   10129    SET_ColorPointer(table, exec_ColorPointer);
   10130    SET_CopyTexImage1D(table, save_CopyTexImage1D);
   10131    SET_CopyTexImage2D(table, save_CopyTexImage2D);
   10132    SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);
   10133    SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);
   10134    SET_DeleteTextures(table, exec_DeleteTextures);
   10135    SET_DisableClientState(table, exec_DisableClientState);
   10136    SET_EdgeFlagPointer(table, exec_EdgeFlagPointer);
   10137    SET_EnableClientState(table, exec_EnableClientState);
   10138    SET_GenTextures(table, exec_GenTextures);
   10139    SET_GetPointerv(table, exec_GetPointerv);
   10140    SET_IndexPointer(table, exec_IndexPointer);
   10141    SET_InterleavedArrays(table, exec_InterleavedArrays);
   10142    SET_IsTexture(table, exec_IsTexture);
   10143    SET_NormalPointer(table, exec_NormalPointer);
   10144    SET_PopClientAttrib(table, exec_PopClientAttrib);
   10145    SET_PrioritizeTextures(table, save_PrioritizeTextures);
   10146    SET_PushClientAttrib(table, exec_PushClientAttrib);
   10147    SET_TexCoordPointer(table, exec_TexCoordPointer);
   10148    SET_TexSubImage1D(table, save_TexSubImage1D);
   10149    SET_TexSubImage2D(table, save_TexSubImage2D);
   10150    SET_VertexPointer(table, exec_VertexPointer);
   10151 
   10152    /* GL 1.2 */
   10153    SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);
   10154    SET_TexImage3D(table, save_TexImage3D);
   10155    SET_TexSubImage3D(table, save_TexSubImage3D);
   10156 
   10157    /* GL 2.0 */
   10158    SET_StencilFuncSeparate(table, save_StencilFuncSeparate);
   10159    SET_StencilMaskSeparate(table, save_StencilMaskSeparate);
   10160    SET_StencilOpSeparate(table, save_StencilOpSeparate);
   10161 
   10162    /* ATI_separate_stencil */
   10163    SET_StencilFuncSeparateATI(table, save_StencilFuncSeparateATI);
   10164 
   10165    /* GL_ARB_imaging */
   10166    /* Not all are supported */
   10167    SET_BlendColor(table, save_BlendColor);
   10168    SET_BlendEquation(table, save_BlendEquation);
   10169    SET_ColorSubTable(table, save_ColorSubTable);
   10170    SET_ColorTable(table, save_ColorTable);
   10171    SET_ColorTableParameterfv(table, save_ColorTableParameterfv);
   10172    SET_ColorTableParameteriv(table, save_ColorTableParameteriv);
   10173    SET_ConvolutionFilter1D(table, save_ConvolutionFilter1D);
   10174    SET_ConvolutionFilter2D(table, save_ConvolutionFilter2D);
   10175    SET_ConvolutionParameterf(table, save_ConvolutionParameterf);
   10176    SET_ConvolutionParameterfv(table, save_ConvolutionParameterfv);
   10177    SET_ConvolutionParameteri(table, save_ConvolutionParameteri);
   10178    SET_ConvolutionParameteriv(table, save_ConvolutionParameteriv);
   10179    SET_CopyColorSubTable(table, save_CopyColorSubTable);
   10180    SET_CopyColorTable(table, save_CopyColorTable);
   10181    SET_CopyConvolutionFilter1D(table, exec_CopyConvolutionFilter1D);
   10182    SET_CopyConvolutionFilter2D(table, exec_CopyConvolutionFilter2D);
   10183    SET_GetColorTable(table, exec_GetColorTable);
   10184    SET_GetColorTableParameterfv(table, exec_GetColorTableParameterfv);
   10185    SET_GetColorTableParameteriv(table, exec_GetColorTableParameteriv);
   10186    SET_GetConvolutionFilter(table, exec_GetConvolutionFilter);
   10187    SET_GetConvolutionParameterfv(table, exec_GetConvolutionParameterfv);
   10188    SET_GetConvolutionParameteriv(table, exec_GetConvolutionParameteriv);
   10189    SET_GetHistogram(table, exec_GetHistogram);
   10190    SET_GetHistogramParameterfv(table, exec_GetHistogramParameterfv);
   10191    SET_GetHistogramParameteriv(table, exec_GetHistogramParameteriv);
   10192    SET_GetMinmax(table, exec_GetMinmax);
   10193    SET_GetMinmaxParameterfv(table, exec_GetMinmaxParameterfv);
   10194    SET_GetMinmaxParameteriv(table, exec_GetMinmaxParameteriv);
   10195    SET_GetSeparableFilter(table, exec_GetSeparableFilter);
   10196    SET_Histogram(table, save_Histogram);
   10197    SET_Minmax(table, save_Minmax);
   10198    SET_ResetHistogram(table, save_ResetHistogram);
   10199    SET_ResetMinmax(table, save_ResetMinmax);
   10200    SET_SeparableFilter2D(table, exec_SeparableFilter2D);
   10201 
   10202    /* 2. GL_EXT_blend_color */
   10203 #if 0
   10204    SET_BlendColorEXT(table, save_BlendColorEXT);
   10205 #endif
   10206 
   10207    /* 3. GL_EXT_polygon_offset */
   10208    SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);
   10209 
   10210    /* 6. GL_EXT_texture3d */
   10211 #if 0
   10212    SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);
   10213    SET_TexImage3DEXT(table, save_TexImage3DEXT);
   10214    SET_TexSubImage3DEXT(table, save_TexSubImage3D);
   10215 #endif
   10216 
   10217    /* 14. GL_SGI_color_table */
   10218 #if 0
   10219    SET_ColorTableSGI(table, save_ColorTable);
   10220    SET_ColorSubTableSGI(table, save_ColorSubTable);
   10221    SET_GetColorTableSGI(table, exec_GetColorTable);
   10222    SET_GetColorTableParameterfvSGI(table, exec_GetColorTableParameterfv);
   10223    SET_GetColorTableParameterivSGI(table, exec_GetColorTableParameteriv);
   10224 #endif
   10225 
   10226    /* 30. GL_EXT_vertex_array */
   10227    SET_ColorPointerEXT(table, exec_ColorPointerEXT);
   10228    SET_EdgeFlagPointerEXT(table, exec_EdgeFlagPointerEXT);
   10229    SET_IndexPointerEXT(table, exec_IndexPointerEXT);
   10230    SET_NormalPointerEXT(table, exec_NormalPointerEXT);
   10231    SET_TexCoordPointerEXT(table, exec_TexCoordPointerEXT);
   10232    SET_VertexPointerEXT(table, exec_VertexPointerEXT);
   10233 
   10234    /* 37. GL_EXT_blend_minmax */
   10235 #if 0
   10236    SET_BlendEquationEXT(table, save_BlendEquationEXT);
   10237 #endif
   10238 
   10239    /* 54. GL_EXT_point_parameters */
   10240    SET_PointParameterfEXT(table, save_PointParameterfEXT);
   10241    SET_PointParameterfvEXT(table, save_PointParameterfvEXT);
   10242 
   10243    /* 97. GL_EXT_compiled_vertex_array */
   10244    SET_LockArraysEXT(table, exec_LockArraysEXT);
   10245    SET_UnlockArraysEXT(table, exec_UnlockArraysEXT);
   10246 
   10247    /* 145. GL_EXT_secondary_color */
   10248    SET_SecondaryColorPointerEXT(table, exec_SecondaryColorPointerEXT);
   10249 
   10250    /* 148. GL_EXT_multi_draw_arrays */
   10251    SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);
   10252 
   10253    /* 149. GL_EXT_fog_coord */
   10254    SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);
   10255 
   10256    /* 173. GL_EXT_blend_func_separate */
   10257    SET_BlendFuncSeparateEXT(table, save_BlendFuncSeparateEXT);
   10258 
   10259    /* 196. GL_MESA_resize_buffers */
   10260    SET_ResizeBuffersMESA(table, _mesa_ResizeBuffersMESA);
   10261 
   10262    /* 197. GL_MESA_window_pos */
   10263    SET_WindowPos2dMESA(table, save_WindowPos2dMESA);
   10264    SET_WindowPos2dvMESA(table, save_WindowPos2dvMESA);
   10265    SET_WindowPos2fMESA(table, save_WindowPos2fMESA);
   10266    SET_WindowPos2fvMESA(table, save_WindowPos2fvMESA);
   10267    SET_WindowPos2iMESA(table, save_WindowPos2iMESA);
   10268    SET_WindowPos2ivMESA(table, save_WindowPos2ivMESA);
   10269    SET_WindowPos2sMESA(table, save_WindowPos2sMESA);
   10270    SET_WindowPos2svMESA(table, save_WindowPos2svMESA);
   10271    SET_WindowPos3dMESA(table, save_WindowPos3dMESA);
   10272    SET_WindowPos3dvMESA(table, save_WindowPos3dvMESA);
   10273    SET_WindowPos3fMESA(table, save_WindowPos3fMESA);
   10274    SET_WindowPos3fvMESA(table, save_WindowPos3fvMESA);
   10275    SET_WindowPos3iMESA(table, save_WindowPos3iMESA);
   10276    SET_WindowPos3ivMESA(table, save_WindowPos3ivMESA);
   10277    SET_WindowPos3sMESA(table, save_WindowPos3sMESA);
   10278    SET_WindowPos3svMESA(table, save_WindowPos3svMESA);
   10279    SET_WindowPos4dMESA(table, save_WindowPos4dMESA);
   10280    SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);
   10281    SET_WindowPos4fMESA(table, save_WindowPos4fMESA);
   10282    SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);
   10283    SET_WindowPos4iMESA(table, save_WindowPos4iMESA);
   10284    SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);
   10285    SET_WindowPos4sMESA(table, save_WindowPos4sMESA);
   10286    SET_WindowPos4svMESA(table, save_WindowPos4svMESA);
   10287 
   10288    /* 200. GL_IBM_multimode_draw_arrays */
   10289    SET_MultiModeDrawArraysIBM(table, exec_MultiModeDrawArraysIBM);
   10290    SET_MultiModeDrawElementsIBM(table, exec_MultiModeDrawElementsIBM);
   10291 
   10292 #if FEATURE_NV_vertex_program
   10293    /* 233. GL_NV_vertex_program */
   10294    /* The following commands DO NOT go into display lists:
   10295     * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
   10296     * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
   10297     */
   10298    SET_BindProgramNV(table, save_BindProgramNV);
   10299    SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
   10300    SET_ExecuteProgramNV(table, save_ExecuteProgramNV);
   10301    SET_GenProgramsNV(table, _mesa_GenPrograms);
   10302    SET_AreProgramsResidentNV(table, _mesa_AreProgramsResidentNV);
   10303    SET_RequestResidentProgramsNV(table, save_RequestResidentProgramsNV);
   10304    SET_GetProgramParameterfvNV(table, _mesa_GetProgramParameterfvNV);
   10305    SET_GetProgramParameterdvNV(table, _mesa_GetProgramParameterdvNV);
   10306    SET_GetProgramivNV(table, _mesa_GetProgramivNV);
   10307    SET_GetProgramStringNV(table, _mesa_GetProgramStringNV);
   10308    SET_GetTrackMatrixivNV(table, _mesa_GetTrackMatrixivNV);
   10309    SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
   10310    SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
   10311    SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
   10312    SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
   10313    SET_IsProgramNV(table, _mesa_IsProgramARB);
   10314    SET_LoadProgramNV(table, save_LoadProgramNV);
   10315    SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
   10316    SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
   10317    SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
   10318    SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
   10319    SET_ProgramParameters4dvNV(table, save_ProgramParameters4dvNV);
   10320    SET_ProgramParameters4fvNV(table, save_ProgramParameters4fvNV);
   10321    SET_TrackMatrixNV(table, save_TrackMatrixNV);
   10322    SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);
   10323 #endif
   10324 
   10325    /* 244. GL_ATI_envmap_bumpmap */
   10326    SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI);
   10327    SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI);
   10328 
   10329    /* 245. GL_ATI_fragment_shader */
   10330 #if FEATURE_ATI_fragment_shader
   10331    SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
   10332    SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);
   10333 #endif
   10334 
   10335    /* 282. GL_NV_fragment_program */
   10336 #if FEATURE_NV_fragment_program
   10337    SET_ProgramNamedParameter4fNV(table, save_ProgramNamedParameter4fNV);
   10338    SET_ProgramNamedParameter4dNV(table, save_ProgramNamedParameter4dNV);
   10339    SET_ProgramNamedParameter4fvNV(table, save_ProgramNamedParameter4fvNV);
   10340    SET_ProgramNamedParameter4dvNV(table, save_ProgramNamedParameter4dvNV);
   10341    SET_GetProgramNamedParameterfvNV(table,
   10342                                     _mesa_GetProgramNamedParameterfvNV);
   10343    SET_GetProgramNamedParameterdvNV(table,
   10344                                     _mesa_GetProgramNamedParameterdvNV);
   10345    SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
   10346    SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
   10347    SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
   10348    SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
   10349    SET_GetProgramLocalParameterdvARB(table,
   10350                                      _mesa_GetProgramLocalParameterdvARB);
   10351    SET_GetProgramLocalParameterfvARB(table,
   10352                                      _mesa_GetProgramLocalParameterfvARB);
   10353 #endif
   10354 
   10355    /* 262. GL_NV_point_sprite */
   10356    SET_PointParameteriNV(table, save_PointParameteriNV);
   10357    SET_PointParameterivNV(table, save_PointParameterivNV);
   10358 
   10359    /* 268. GL_EXT_stencil_two_side */
   10360    SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);
   10361 
   10362    /* 273. GL_APPLE_vertex_array_object */
   10363    SET_BindVertexArrayAPPLE(table, _mesa_BindVertexArrayAPPLE);
   10364    SET_DeleteVertexArraysAPPLE(table, _mesa_DeleteVertexArraysAPPLE);
   10365    SET_GenVertexArraysAPPLE(table, _mesa_GenVertexArraysAPPLE);
   10366    SET_IsVertexArrayAPPLE(table, _mesa_IsVertexArrayAPPLE);
   10367 
   10368    /* 310. GL_EXT_framebuffer_object */
   10369    SET_GenFramebuffersEXT(table, _mesa_GenFramebuffersEXT);
   10370    SET_BindFramebufferEXT(table, _mesa_BindFramebufferEXT);
   10371    SET_DeleteFramebuffersEXT(table, _mesa_DeleteFramebuffersEXT);
   10372    SET_CheckFramebufferStatusEXT(table, _mesa_CheckFramebufferStatusEXT);
   10373    SET_GenRenderbuffersEXT(table, _mesa_GenRenderbuffersEXT);
   10374    SET_BindRenderbufferEXT(table, _mesa_BindRenderbufferEXT);
   10375    SET_DeleteRenderbuffersEXT(table, _mesa_DeleteRenderbuffersEXT);
   10376    SET_RenderbufferStorageEXT(table, _mesa_RenderbufferStorageEXT);
   10377    SET_FramebufferTexture1DEXT(table, _mesa_FramebufferTexture1DEXT);
   10378    SET_FramebufferTexture2DEXT(table, _mesa_FramebufferTexture2DEXT);
   10379    SET_FramebufferTexture3DEXT(table, _mesa_FramebufferTexture3DEXT);
   10380    SET_FramebufferRenderbufferEXT(table, _mesa_FramebufferRenderbufferEXT);
   10381    SET_GenerateMipmapEXT(table, _mesa_GenerateMipmapEXT);
   10382 
   10383    /* 317. GL_EXT_framebuffer_multisample */
   10384    SET_RenderbufferStorageMultisample(table, _mesa_RenderbufferStorageMultisample);
   10385 
   10386    /* GL_ARB_vertex_array_object */
   10387    SET_BindVertexArray(table, _mesa_BindVertexArray);
   10388    SET_GenVertexArrays(table, _mesa_GenVertexArrays);
   10389 
   10390    /* ???. GL_EXT_depth_bounds_test */
   10391    SET_DepthBoundsEXT(table, save_DepthBoundsEXT);
   10392 
   10393    /* ARB 1. GL_ARB_multitexture */
   10394    SET_ActiveTextureARB(table, save_ActiveTextureARB);
   10395    SET_ClientActiveTextureARB(table, exec_ClientActiveTextureARB);
   10396 
   10397    /* ARB 3. GL_ARB_transpose_matrix */
   10398    SET_LoadTransposeMatrixdARB(table, save_LoadTransposeMatrixdARB);
   10399    SET_LoadTransposeMatrixfARB(table, save_LoadTransposeMatrixfARB);
   10400    SET_MultTransposeMatrixdARB(table, save_MultTransposeMatrixdARB);
   10401    SET_MultTransposeMatrixfARB(table, save_MultTransposeMatrixfARB);
   10402 
   10403    /* ARB 5. GL_ARB_multisample */
   10404    SET_SampleCoverageARB(table, save_SampleCoverageARB);
   10405 
   10406    /* ARB 12. GL_ARB_texture_compression */
   10407    SET_CompressedTexImage3DARB(table, save_CompressedTexImage3DARB);
   10408    SET_CompressedTexImage2DARB(table, save_CompressedTexImage2DARB);
   10409    SET_CompressedTexImage1DARB(table, save_CompressedTexImage1DARB);
   10410    SET_CompressedTexSubImage3DARB(table, save_CompressedTexSubImage3DARB);
   10411    SET_CompressedTexSubImage2DARB(table, save_CompressedTexSubImage2DARB);
   10412    SET_CompressedTexSubImage1DARB(table, save_CompressedTexSubImage1DARB);
   10413    SET_GetCompressedTexImageARB(table, exec_GetCompressedTexImageARB);
   10414 
   10415    /* ARB 14. GL_ARB_point_parameters */
   10416    /* aliased with EXT_point_parameters functions */
   10417 
   10418    /* ARB 25. GL_ARB_window_pos */
   10419    /* aliased with MESA_window_pos functions */
   10420 
   10421    /* ARB 26. GL_ARB_vertex_program */
   10422    /* ARB 27. GL_ARB_fragment_program */
   10423 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   10424    /* glVertexAttrib* functions alias the NV ones, handled elsewhere */
   10425    SET_VertexAttribPointerARB(table, _mesa_VertexAttribPointerARB);
   10426    SET_EnableVertexAttribArrayARB(table, _mesa_EnableVertexAttribArrayARB);
   10427    SET_DisableVertexAttribArrayARB(table, _mesa_DisableVertexAttribArrayARB);
   10428    SET_ProgramStringARB(table, save_ProgramStringARB);
   10429    SET_BindProgramNV(table, save_BindProgramNV);
   10430    SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
   10431    SET_GenProgramsNV(table, _mesa_GenPrograms);
   10432    SET_IsProgramNV(table, _mesa_IsProgramARB);
   10433    SET_GetVertexAttribdvARB(table, _mesa_GetVertexAttribdvARB);
   10434    SET_GetVertexAttribfvARB(table, _mesa_GetVertexAttribfvARB);
   10435    SET_GetVertexAttribivARB(table, _mesa_GetVertexAttribivARB);
   10436    SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
   10437    SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
   10438    SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
   10439    SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
   10440    SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
   10441    SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
   10442    SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
   10443    SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
   10444    SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
   10445    SET_GetProgramEnvParameterdvARB(table, _mesa_GetProgramEnvParameterdvARB);
   10446    SET_GetProgramEnvParameterfvARB(table, _mesa_GetProgramEnvParameterfvARB);
   10447    SET_GetProgramLocalParameterdvARB(table,
   10448                                      _mesa_GetProgramLocalParameterdvARB);
   10449    SET_GetProgramLocalParameterfvARB(table,
   10450                                      _mesa_GetProgramLocalParameterfvARB);
   10451    SET_GetProgramivARB(table, _mesa_GetProgramivARB);
   10452    SET_GetProgramStringARB(table, _mesa_GetProgramStringARB);
   10453 #endif
   10454 
   10455    /* ARB 28. GL_ARB_vertex_buffer_object */
   10456    /* None of the extension's functions get compiled */
   10457    SET_BindBufferARB(table, _mesa_BindBufferARB);
   10458    SET_BufferDataARB(table, _mesa_BufferDataARB);
   10459    SET_BufferSubDataARB(table, _mesa_BufferSubDataARB);
   10460    SET_DeleteBuffersARB(table, _mesa_DeleteBuffersARB);
   10461    SET_GenBuffersARB(table, _mesa_GenBuffersARB);
   10462    SET_GetBufferParameterivARB(table, _mesa_GetBufferParameterivARB);
   10463    SET_GetBufferPointervARB(table, _mesa_GetBufferPointervARB);
   10464    SET_GetBufferSubDataARB(table, _mesa_GetBufferSubDataARB);
   10465    SET_IsBufferARB(table, _mesa_IsBufferARB);
   10466    SET_MapBufferARB(table, _mesa_MapBufferARB);
   10467    SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);
   10468 
   10469 #if FEATURE_queryobj
   10470    _mesa_init_queryobj_dispatch(table); /* glGetQuery, etc */
   10471    SET_BeginQueryARB(table, save_BeginQueryARB);
   10472    SET_EndQueryARB(table, save_EndQueryARB);
   10473    SET_QueryCounter(table, save_QueryCounter);
   10474 #endif
   10475 
   10476    SET_DrawBuffersARB(table, save_DrawBuffersARB);
   10477 
   10478 #if FEATURE_EXT_framebuffer_blit
   10479    SET_BlitFramebufferEXT(table, save_BlitFramebufferEXT);
   10480 #endif
   10481 
   10482    /* GL_ARB_shader_objects */
   10483    _mesa_init_shader_dispatch(ctx, table); /* Plug in glCreate/Delete/Get, etc */
   10484    SET_UseProgramObjectARB(table, save_UseProgramObjectARB);
   10485    SET_Uniform1fARB(table, save_Uniform1fARB);
   10486    SET_Uniform2fARB(table, save_Uniform2fARB);
   10487    SET_Uniform3fARB(table, save_Uniform3fARB);
   10488    SET_Uniform4fARB(table, save_Uniform4fARB);
   10489    SET_Uniform1fvARB(table, save_Uniform1fvARB);
   10490    SET_Uniform2fvARB(table, save_Uniform2fvARB);
   10491    SET_Uniform3fvARB(table, save_Uniform3fvARB);
   10492    SET_Uniform4fvARB(table, save_Uniform4fvARB);
   10493    SET_Uniform1iARB(table, save_Uniform1iARB);
   10494    SET_Uniform2iARB(table, save_Uniform2iARB);
   10495    SET_Uniform3iARB(table, save_Uniform3iARB);
   10496    SET_Uniform4iARB(table, save_Uniform4iARB);
   10497    SET_Uniform1ivARB(table, save_Uniform1ivARB);
   10498    SET_Uniform2ivARB(table, save_Uniform2ivARB);
   10499    SET_Uniform3ivARB(table, save_Uniform3ivARB);
   10500    SET_Uniform4ivARB(table, save_Uniform4ivARB);
   10501    SET_UniformMatrix2fvARB(table, save_UniformMatrix2fvARB);
   10502    SET_UniformMatrix3fvARB(table, save_UniformMatrix3fvARB);
   10503    SET_UniformMatrix4fvARB(table, save_UniformMatrix4fvARB);
   10504    SET_UniformMatrix2x3fv(table, save_UniformMatrix2x3fv);
   10505    SET_UniformMatrix3x2fv(table, save_UniformMatrix3x2fv);
   10506    SET_UniformMatrix2x4fv(table, save_UniformMatrix2x4fv);
   10507    SET_UniformMatrix4x2fv(table, save_UniformMatrix4x2fv);
   10508    SET_UniformMatrix3x4fv(table, save_UniformMatrix3x4fv);
   10509    SET_UniformMatrix4x3fv(table, save_UniformMatrix4x3fv);
   10510 
   10511    /* ARB 30/31/32. GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
   10512    SET_BindAttribLocationARB(table, exec_BindAttribLocationARB);
   10513    SET_GetAttribLocationARB(table, exec_GetAttribLocationARB);
   10514    SET_GetUniformLocationARB(table, exec_GetUniformLocationARB);
   10515    /* XXX additional functions need to be implemented here! */
   10516 
   10517    /* 299. GL_EXT_blend_equation_separate */
   10518    SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);
   10519 
   10520    /* GL_EXT_gpu_program_parameters */
   10521 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
   10522    SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
   10523    SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
   10524 #endif
   10525 
   10526    /* ARB 50. GL_ARB_map_buffer_range */
   10527 #if FEATURE_ARB_map_buffer_range
   10528    SET_MapBufferRange(table, _mesa_MapBufferRange); /* no dlist save */
   10529    SET_FlushMappedBufferRange(table, _mesa_FlushMappedBufferRange); /* no dl */
   10530 #endif
   10531 
   10532    /* ARB 51. GL_ARB_texture_buffer_object */
   10533    SET_TexBufferARB(table, _mesa_TexBuffer); /* no dlist save */
   10534 
   10535    /* ARB 59. GL_ARB_copy_buffer */
   10536    SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */
   10537 
   10538    /* 364. GL_EXT_provoking_vertex */
   10539    SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT);
   10540 
   10541    /* 371. GL_APPLE_object_purgeable */
   10542 #if FEATURE_APPLE_object_purgeable
   10543    SET_ObjectPurgeableAPPLE(table, _mesa_ObjectPurgeableAPPLE);
   10544    SET_ObjectUnpurgeableAPPLE(table, _mesa_ObjectUnpurgeableAPPLE);
   10545    SET_GetObjectParameterivAPPLE(table, _mesa_GetObjectParameterivAPPLE);
   10546 #endif
   10547 
   10548    /* GL_EXT_texture_integer */
   10549    SET_ClearColorIiEXT(table, save_ClearColorIi);
   10550    SET_ClearColorIuiEXT(table, save_ClearColorIui);
   10551    SET_TexParameterIivEXT(table, save_TexParameterIiv);
   10552    SET_TexParameterIuivEXT(table, save_TexParameterIuiv);
   10553    SET_GetTexParameterIivEXT(table, exec_GetTexParameterIiv);
   10554    SET_GetTexParameterIuivEXT(table, exec_GetTexParameterIuiv);
   10555 
   10556    /* 377. GL_EXT_separate_shader_objects */
   10557    SET_UseShaderProgramEXT(table, save_UseShaderProgramEXT);
   10558    SET_ActiveProgramEXT(table, save_ActiveProgramEXT);
   10559 
   10560    /* GL_ARB_color_buffer_float */
   10561    SET_ClampColorARB(table, save_ClampColorARB);
   10562    SET_ClampColor(table, save_ClampColorARB);
   10563 
   10564    /* GL 3.0 */
   10565    SET_ClearBufferiv(table, save_ClearBufferiv);
   10566    SET_ClearBufferuiv(table, save_ClearBufferuiv);
   10567    SET_ClearBufferfv(table, save_ClearBufferfv);
   10568    SET_ClearBufferfi(table, save_ClearBufferfi);
   10569 #if 0
   10570    SET_Uniform1ui(table, save_Uniform1ui);
   10571    SET_Uniform2ui(table, save_Uniform2ui);
   10572    SET_Uniform3ui(table, save_Uniform3ui);
   10573    SET_Uniform4ui(table, save_Uniform4ui);
   10574    SET_Uniform1uiv(table, save_Uniform1uiv);
   10575    SET_Uniform2uiv(table, save_Uniform2uiv);
   10576    SET_Uniform3uiv(table, save_Uniform3uiv);
   10577    SET_Uniform4uiv(table, save_Uniform4uiv);
   10578 #else
   10579    (void) save_Uniform1ui;
   10580    (void) save_Uniform2ui;
   10581    (void) save_Uniform3ui;
   10582    (void) save_Uniform4ui;
   10583    (void) save_Uniform1uiv;
   10584    (void) save_Uniform2uiv;
   10585    (void) save_Uniform3uiv;
   10586    (void) save_Uniform4uiv;
   10587 #endif
   10588 
   10589 #if FEATURE_EXT_transform_feedback
   10590    /* These are not compiled into display lists: */
   10591    SET_BindBufferBaseEXT(table, _mesa_BindBufferBase);
   10592    SET_BindBufferOffsetEXT(table, _mesa_BindBufferOffsetEXT);
   10593    SET_BindBufferRangeEXT(table, _mesa_BindBufferRange);
   10594    SET_TransformFeedbackVaryingsEXT(table, _mesa_TransformFeedbackVaryings);
   10595    /* These are: */
   10596    SET_BeginTransformFeedbackEXT(table, save_BeginTransformFeedback);
   10597    SET_EndTransformFeedbackEXT(table, save_EndTransformFeedback);
   10598    SET_BindTransformFeedback(table, save_BindTransformFeedback);
   10599    SET_PauseTransformFeedback(table, save_PauseTransformFeedback);
   10600    SET_ResumeTransformFeedback(table, save_ResumeTransformFeedback);
   10601    SET_DrawTransformFeedback(table, save_DrawTransformFeedback);
   10602    SET_DrawTransformFeedbackStream(table, save_DrawTransformFeedbackStream);
   10603    SET_DrawTransformFeedbackInstanced(table,
   10604                                       save_DrawTransformFeedbackInstanced);
   10605    SET_DrawTransformFeedbackStreamInstanced(table,
   10606                                 save_DrawTransformFeedbackStreamInstanced);
   10607 #if FEATURE_queryobj
   10608    SET_BeginQueryIndexed(table, save_BeginQueryIndexed);
   10609    SET_EndQueryIndexed(table, save_EndQueryIndexed);
   10610 #endif
   10611 #endif
   10612 
   10613    /* GL_ARB_instanced_arrays */
   10614    SET_VertexAttribDivisorARB(table, save_VertexAttribDivisor);
   10615 
   10616    /* GL_NV_texture_barrier */
   10617    SET_TextureBarrierNV(table, save_TextureBarrierNV);
   10618 
   10619    /* GL_ARB_sampler_objects */
   10620    _mesa_init_sampler_object_dispatch(table); /* plug in Gen/Get/etc functions */
   10621    SET_BindSampler(table, save_BindSampler);
   10622    SET_SamplerParameteri(table, save_SamplerParameteri);
   10623    SET_SamplerParameterf(table, save_SamplerParameterf);
   10624    SET_SamplerParameteriv(table, save_SamplerParameteriv);
   10625    SET_SamplerParameterfv(table, save_SamplerParameterfv);
   10626    SET_SamplerParameterIiv(table, save_SamplerParameterIiv);
   10627    SET_SamplerParameterIuiv(table, save_SamplerParameterIuiv);
   10628 
   10629    /* GL_ARB_draw_buffer_blend */
   10630    SET_BlendFunciARB(table, save_BlendFunci);
   10631    SET_BlendFuncSeparateiARB(table, save_BlendFuncSeparatei);
   10632    SET_BlendEquationiARB(table, save_BlendEquationi);
   10633    SET_BlendEquationSeparateiARB(table, save_BlendEquationSeparatei);
   10634 
   10635    /* GL_ARB_geometry_shader4 */
   10636    SET_ProgramParameteriARB(table, save_ProgramParameteri);
   10637    SET_FramebufferTextureARB(table, save_FramebufferTexture);
   10638    SET_FramebufferTextureFaceARB(table, save_FramebufferTextureFace);
   10639 
   10640    /* GL_NV_conditional_render */
   10641    SET_BeginConditionalRenderNV(table, save_BeginConditionalRender);
   10642    SET_EndConditionalRenderNV(table, save_EndConditionalRender);
   10643 
   10644    /* GL_ARB_sync */
   10645    _mesa_init_sync_dispatch(table);
   10646    SET_WaitSync(table, save_WaitSync);
   10647 
   10648    /* GL_ARB_texture_storage (no dlist support) */
   10649    SET_TexStorage1D(table, _mesa_TexStorage1D);
   10650    SET_TexStorage2D(table, _mesa_TexStorage2D);
   10651    SET_TexStorage3D(table, _mesa_TexStorage3D);
   10652    SET_TextureStorage1DEXT(table, _mesa_TextureStorage1DEXT);
   10653    SET_TextureStorage2DEXT(table, _mesa_TextureStorage2DEXT);
   10654    SET_TextureStorage3DEXT(table, _mesa_TextureStorage3DEXT);
   10655 
   10656    /* GL_ARB_debug_output (no dlist support) */
   10657    _mesa_init_errors_dispatch(table);
   10658 
   10659    /* GL_ARB_uniform_buffer_object */
   10660    SET_UniformBlockBinding(table, save_UniformBlockBinding);
   10661 
   10662    /* GL_NV_primitive_restart */
   10663    SET_PrimitiveRestartIndexNV(table, _mesa_PrimitiveRestartIndex);
   10664 
   10665    return table;
   10666 }
   10667 
   10668 
   10669 
   10670 static const char *
   10671 enum_string(GLenum k)
   10672 {
   10673    return _mesa_lookup_enum_by_nr(k);
   10674 }
   10675 
   10676 
   10677 /**
   10678  * Print the commands in a display list.  For debugging only.
   10679  * TODO: many commands aren't handled yet.
   10680  */
   10681 static void GLAPIENTRY
   10682 print_list(struct gl_context *ctx, GLuint list)
   10683 {
   10684    struct gl_display_list *dlist;
   10685    Node *n;
   10686    GLboolean done;
   10687 
   10688    if (!islist(ctx, list)) {
   10689       printf("%u is not a display list ID\n", list);
   10690       return;
   10691    }
   10692 
   10693    dlist = lookup_list(ctx, list);
   10694    if (!dlist)
   10695       return;
   10696 
   10697    n = dlist->Head;
   10698 
   10699    printf("START-LIST %u, address %p\n", list, (void *) n);
   10700 
   10701    done = n ? GL_FALSE : GL_TRUE;
   10702    while (!done) {
   10703       const OpCode opcode = n[0].opcode;
   10704 
   10705       if (is_ext_opcode(opcode)) {
   10706          n += ext_opcode_print(ctx, n);
   10707       }
   10708       else {
   10709          switch (opcode) {
   10710          case OPCODE_ACCUM:
   10711             printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);
   10712             break;
   10713          case OPCODE_BITMAP:
   10714             printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
   10715                          n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data);
   10716             break;
   10717          case OPCODE_CALL_LIST:
   10718             printf("CallList %d\n", (int) n[1].ui);
   10719             break;
   10720          case OPCODE_CALL_LIST_OFFSET:
   10721             printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
   10722                          ctx->List.ListBase, ctx->List.ListBase + n[1].ui);
   10723             break;
   10724          case OPCODE_COLOR_TABLE_PARAMETER_FV:
   10725             printf("ColorTableParameterfv %s %s %f %f %f %f\n",
   10726                          enum_string(n[1].e), enum_string(n[2].e),
   10727                          n[3].f, n[4].f, n[5].f, n[6].f);
   10728             break;
   10729          case OPCODE_COLOR_TABLE_PARAMETER_IV:
   10730             printf("ColorTableParameteriv %s %s %d %d %d %d\n",
   10731                          enum_string(n[1].e), enum_string(n[2].e),
   10732                          n[3].i, n[4].i, n[5].i, n[6].i);
   10733             break;
   10734          case OPCODE_DISABLE:
   10735             printf("Disable %s\n", enum_string(n[1].e));
   10736             break;
   10737          case OPCODE_ENABLE:
   10738             printf("Enable %s\n", enum_string(n[1].e));
   10739             break;
   10740          case OPCODE_FRUSTUM:
   10741             printf("Frustum %g %g %g %g %g %g\n",
   10742                          n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
   10743             break;
   10744          case OPCODE_LINE_STIPPLE:
   10745             printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);
   10746             break;
   10747          case OPCODE_LOAD_IDENTITY:
   10748             printf("LoadIdentity\n");
   10749             break;
   10750          case OPCODE_LOAD_MATRIX:
   10751             printf("LoadMatrix\n");
   10752             printf("  %8f %8f %8f %8f\n",
   10753                          n[1].f, n[5].f, n[9].f, n[13].f);
   10754             printf("  %8f %8f %8f %8f\n",
   10755                          n[2].f, n[6].f, n[10].f, n[14].f);
   10756             printf("  %8f %8f %8f %8f\n",
   10757                          n[3].f, n[7].f, n[11].f, n[15].f);
   10758             printf("  %8f %8f %8f %8f\n",
   10759                          n[4].f, n[8].f, n[12].f, n[16].f);
   10760             break;
   10761          case OPCODE_MULT_MATRIX:
   10762             printf("MultMatrix (or Rotate)\n");
   10763             printf("  %8f %8f %8f %8f\n",
   10764                          n[1].f, n[5].f, n[9].f, n[13].f);
   10765             printf("  %8f %8f %8f %8f\n",
   10766                          n[2].f, n[6].f, n[10].f, n[14].f);
   10767             printf("  %8f %8f %8f %8f\n",
   10768                          n[3].f, n[7].f, n[11].f, n[15].f);
   10769             printf("  %8f %8f %8f %8f\n",
   10770                          n[4].f, n[8].f, n[12].f, n[16].f);
   10771             break;
   10772          case OPCODE_ORTHO:
   10773             printf("Ortho %g %g %g %g %g %g\n",
   10774                          n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
   10775             break;
   10776          case OPCODE_POP_ATTRIB:
   10777             printf("PopAttrib\n");
   10778             break;
   10779          case OPCODE_POP_MATRIX:
   10780             printf("PopMatrix\n");
   10781             break;
   10782          case OPCODE_POP_NAME:
   10783             printf("PopName\n");
   10784             break;
   10785          case OPCODE_PUSH_ATTRIB:
   10786             printf("PushAttrib %x\n", n[1].bf);
   10787             break;
   10788          case OPCODE_PUSH_MATRIX:
   10789             printf("PushMatrix\n");
   10790             break;
   10791          case OPCODE_PUSH_NAME:
   10792             printf("PushName %d\n", (int) n[1].ui);
   10793             break;
   10794          case OPCODE_RASTER_POS:
   10795             printf("RasterPos %g %g %g %g\n",
   10796                          n[1].f, n[2].f, n[3].f, n[4].f);
   10797             break;
   10798          case OPCODE_ROTATE:
   10799             printf("Rotate %g %g %g %g\n",
   10800                          n[1].f, n[2].f, n[3].f, n[4].f);
   10801             break;
   10802          case OPCODE_SCALE:
   10803             printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
   10804             break;
   10805          case OPCODE_TRANSLATE:
   10806             printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
   10807             break;
   10808          case OPCODE_BIND_TEXTURE:
   10809             printf("BindTexture %s %d\n",
   10810                          _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
   10811             break;
   10812          case OPCODE_SHADE_MODEL:
   10813             printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
   10814             break;
   10815          case OPCODE_MAP1:
   10816             printf("Map1 %s %.3f %.3f %d %d\n",
   10817                          _mesa_lookup_enum_by_nr(n[1].ui),
   10818                          n[2].f, n[3].f, n[4].i, n[5].i);
   10819             break;
   10820          case OPCODE_MAP2:
   10821             printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
   10822                          _mesa_lookup_enum_by_nr(n[1].ui),
   10823                          n[2].f, n[3].f, n[4].f, n[5].f,
   10824                          n[6].i, n[7].i, n[8].i, n[9].i);
   10825             break;
   10826          case OPCODE_MAPGRID1:
   10827             printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
   10828             break;
   10829          case OPCODE_MAPGRID2:
   10830             printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
   10831                          n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
   10832             break;
   10833          case OPCODE_EVALMESH1:
   10834             printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
   10835             break;
   10836          case OPCODE_EVALMESH2:
   10837             printf("EvalMesh2 %d %d %d %d\n",
   10838                          n[1].i, n[2].i, n[3].i, n[4].i);
   10839             break;
   10840 
   10841          case OPCODE_ATTR_1F_NV:
   10842             printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
   10843             break;
   10844          case OPCODE_ATTR_2F_NV:
   10845             printf("ATTR_2F_NV attr %d: %f %f\n",
   10846                          n[1].i, n[2].f, n[3].f);
   10847             break;
   10848          case OPCODE_ATTR_3F_NV:
   10849             printf("ATTR_3F_NV attr %d: %f %f %f\n",
   10850                          n[1].i, n[2].f, n[3].f, n[4].f);
   10851             break;
   10852          case OPCODE_ATTR_4F_NV:
   10853             printf("ATTR_4F_NV attr %d: %f %f %f %f\n",
   10854                          n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
   10855             break;
   10856          case OPCODE_ATTR_1F_ARB:
   10857             printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
   10858             break;
   10859          case OPCODE_ATTR_2F_ARB:
   10860             printf("ATTR_2F_ARB attr %d: %f %f\n",
   10861                          n[1].i, n[2].f, n[3].f);
   10862             break;
   10863          case OPCODE_ATTR_3F_ARB:
   10864             printf("ATTR_3F_ARB attr %d: %f %f %f\n",
   10865                          n[1].i, n[2].f, n[3].f, n[4].f);
   10866             break;
   10867          case OPCODE_ATTR_4F_ARB:
   10868             printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",
   10869                          n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
   10870             break;
   10871 
   10872          case OPCODE_MATERIAL:
   10873             printf("MATERIAL %x %x: %f %f %f %f\n",
   10874                          n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);
   10875             break;
   10876          case OPCODE_BEGIN:
   10877             printf("BEGIN %x\n", n[1].i);
   10878             break;
   10879          case OPCODE_END:
   10880             printf("END\n");
   10881             break;
   10882          case OPCODE_RECTF:
   10883             printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
   10884                          n[4].f);
   10885             break;
   10886          case OPCODE_EVAL_C1:
   10887             printf("EVAL_C1 %f\n", n[1].f);
   10888             break;
   10889          case OPCODE_EVAL_C2:
   10890             printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);
   10891             break;
   10892          case OPCODE_EVAL_P1:
   10893             printf("EVAL_P1 %d\n", n[1].i);
   10894             break;
   10895          case OPCODE_EVAL_P2:
   10896             printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
   10897             break;
   10898 
   10899          case OPCODE_PROVOKING_VERTEX:
   10900             printf("ProvokingVertex %s\n",
   10901                          _mesa_lookup_enum_by_nr(n[1].ui));
   10902             break;
   10903 
   10904             /*
   10905              * meta opcodes/commands
   10906              */
   10907          case OPCODE_ERROR:
   10908             printf("Error: %s %s\n",
   10909                          enum_string(n[1].e), (const char *) n[2].data);
   10910             break;
   10911          case OPCODE_CONTINUE:
   10912             printf("DISPLAY-LIST-CONTINUE\n");
   10913             n = (Node *) n[1].next;
   10914             break;
   10915          case OPCODE_END_OF_LIST:
   10916             printf("END-LIST %u\n", list);
   10917             done = GL_TRUE;
   10918             break;
   10919          default:
   10920             if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
   10921                printf
   10922                   ("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
   10923                    opcode, (void *) n);
   10924                return;
   10925             }
   10926             else {
   10927                printf("command %d, %u operands\n", opcode,
   10928                             InstSize[opcode]);
   10929             }
   10930          }
   10931          /* increment n to point to next compiled command */
   10932          if (opcode != OPCODE_CONTINUE) {
   10933             n += InstSize[opcode];
   10934          }
   10935       }
   10936    }
   10937 }
   10938 
   10939 
   10940 
   10941 /**
   10942  * Clients may call this function to help debug display list problems.
   10943  * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,
   10944  * changed, or break in the future without notice.
   10945  */
   10946 void
   10947 mesa_print_display_list(GLuint list)
   10948 {
   10949    GET_CURRENT_CONTEXT(ctx);
   10950    print_list(ctx, list);
   10951 }
   10952 
   10953 
   10954 /**********************************************************************/
   10955 /*****                      Initialization                        *****/
   10956 /**********************************************************************/
   10957 
   10958 void
   10959 _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
   10960 {
   10961    _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
   10962 
   10963    vfmt->Begin = save_Begin;
   10964 
   10965    _MESA_INIT_DLIST_VTXFMT(vfmt, save_);
   10966 
   10967    vfmt->Color3f = save_Color3f;
   10968    vfmt->Color3fv = save_Color3fv;
   10969    vfmt->Color4f = save_Color4f;
   10970    vfmt->Color4fv = save_Color4fv;
   10971    vfmt->EdgeFlag = save_EdgeFlag;
   10972    vfmt->End = save_End;
   10973 
   10974    _MESA_INIT_EVAL_VTXFMT(vfmt, save_);
   10975 
   10976    vfmt->FogCoordfEXT = save_FogCoordfEXT;
   10977    vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
   10978    vfmt->Indexf = save_Indexf;
   10979    vfmt->Indexfv = save_Indexfv;
   10980    vfmt->Materialfv = save_Materialfv;
   10981    vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;
   10982    vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;
   10983    vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;
   10984    vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;
   10985    vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;
   10986    vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;
   10987    vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;
   10988    vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;
   10989    vfmt->Normal3f = save_Normal3f;
   10990    vfmt->Normal3fv = save_Normal3fv;
   10991    vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;
   10992    vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;
   10993    vfmt->TexCoord1f = save_TexCoord1f;
   10994    vfmt->TexCoord1fv = save_TexCoord1fv;
   10995    vfmt->TexCoord2f = save_TexCoord2f;
   10996    vfmt->TexCoord2fv = save_TexCoord2fv;
   10997    vfmt->TexCoord3f = save_TexCoord3f;
   10998    vfmt->TexCoord3fv = save_TexCoord3fv;
   10999    vfmt->TexCoord4f = save_TexCoord4f;
   11000    vfmt->TexCoord4fv = save_TexCoord4fv;
   11001    vfmt->Vertex2f = save_Vertex2f;
   11002    vfmt->Vertex2fv = save_Vertex2fv;
   11003    vfmt->Vertex3f = save_Vertex3f;
   11004    vfmt->Vertex3fv = save_Vertex3fv;
   11005    vfmt->Vertex4f = save_Vertex4f;
   11006    vfmt->Vertex4fv = save_Vertex4fv;
   11007    vfmt->VertexAttrib1fNV = save_VertexAttrib1fNV;
   11008    vfmt->VertexAttrib1fvNV = save_VertexAttrib1fvNV;
   11009    vfmt->VertexAttrib2fNV = save_VertexAttrib2fNV;
   11010    vfmt->VertexAttrib2fvNV = save_VertexAttrib2fvNV;
   11011    vfmt->VertexAttrib3fNV = save_VertexAttrib3fNV;
   11012    vfmt->VertexAttrib3fvNV = save_VertexAttrib3fvNV;
   11013    vfmt->VertexAttrib4fNV = save_VertexAttrib4fNV;
   11014    vfmt->VertexAttrib4fvNV = save_VertexAttrib4fvNV;
   11015    vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;
   11016    vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;
   11017    vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;
   11018    vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;
   11019    vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;
   11020    vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;
   11021    vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
   11022    vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
   11023 
   11024    vfmt->Rectf = save_Rectf;
   11025 
   11026    /* GL_ARB_draw_instanced */
   11027    vfmt->DrawArraysInstanced = save_DrawArraysInstancedARB;
   11028    vfmt->DrawElementsInstanced = save_DrawElementsInstancedARB;
   11029 
   11030    /* GL_ARB_draw_elements_base_vertex */
   11031    vfmt->DrawElementsInstancedBaseVertex = save_DrawElementsInstancedBaseVertexARB;
   11032 
   11033    /* GL_ARB_base_instance */
   11034    vfmt->DrawArraysInstancedBaseInstance = save_DrawArraysInstancedBaseInstance;
   11035    vfmt->DrawElementsInstancedBaseInstance = save_DrawElementsInstancedBaseInstance;
   11036    vfmt->DrawElementsInstancedBaseVertexBaseInstance = save_DrawElementsInstancedBaseVertexBaseInstance;
   11037 
   11038    /* The driver is required to implement these as
   11039     * 1) They can probably do a better job.
   11040     * 2) A lot of new mechanisms would have to be added to this module
   11041     *     to support it.  That code would probably never get used,
   11042     *     because of (1).
   11043     */
   11044 #if 0
   11045    vfmt->DrawArrays = 0;
   11046    vfmt->DrawElements = 0;
   11047    vfmt->DrawRangeElements = 0;
   11048    vfmt->MultiDrawElemementsEXT = 0;
   11049    vfmt->DrawElementsBaseVertex = 0;
   11050    vfmt->DrawRangeElementsBaseVertex = 0;
   11051    vfmt->MultiDrawElemementsBaseVertex = 0;
   11052 #endif
   11053 }
   11054 
   11055 
   11056 void
   11057 _mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
   11058                            const GLvertexformat *vfmt)
   11059 {
   11060    SET_CallList(disp, vfmt->CallList);
   11061    SET_CallLists(disp, vfmt->CallLists);
   11062 }
   11063 
   11064 
   11065 void _mesa_init_dlist_dispatch(struct _glapi_table *disp)
   11066 {
   11067    SET_CallList(disp, _mesa_CallList);
   11068    SET_CallLists(disp, _mesa_CallLists);
   11069 
   11070    SET_DeleteLists(disp, _mesa_DeleteLists);
   11071    SET_EndList(disp, _mesa_EndList);
   11072    SET_GenLists(disp, _mesa_GenLists);
   11073    SET_IsList(disp, _mesa_IsList);
   11074    SET_ListBase(disp, _mesa_ListBase);
   11075    SET_NewList(disp, _mesa_NewList);
   11076 }
   11077 
   11078 
   11079 #endif /* FEATURE_dlist */
   11080 
   11081 
   11082 /**
   11083  * Initialize display list state for given context.
   11084  */
   11085 void
   11086 _mesa_init_display_list(struct gl_context *ctx)
   11087 {
   11088    static GLboolean tableInitialized = GL_FALSE;
   11089 
   11090    /* zero-out the instruction size table, just once */
   11091    if (!tableInitialized) {
   11092       memset(InstSize, 0, sizeof(InstSize));
   11093       tableInitialized = GL_TRUE;
   11094    }
   11095 
   11096    /* extension info */
   11097    ctx->ListExt = CALLOC_STRUCT(gl_list_extensions);
   11098 
   11099    /* Display list */
   11100    ctx->ListState.CallDepth = 0;
   11101    ctx->ExecuteFlag = GL_TRUE;
   11102    ctx->CompileFlag = GL_FALSE;
   11103    ctx->ListState.CurrentBlock = NULL;
   11104    ctx->ListState.CurrentPos = 0;
   11105 
   11106    /* Display List group */
   11107    ctx->List.ListBase = 0;
   11108 
   11109 #if FEATURE_dlist
   11110    _mesa_save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
   11111 #endif
   11112 }
   11113 
   11114 
   11115 void
   11116 _mesa_free_display_list_data(struct gl_context *ctx)
   11117 {
   11118    free(ctx->ListExt);
   11119    ctx->ListExt = NULL;
   11120 }
   11121