home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / MesaDLL / dlist.cpp < prev    next >
C/C++ Source or Header  |  2002-11-06  |  187KB  |  6,486 lines
  1. /* $Id: dlist.c,v 1.100 2002/11/06 15:16:23 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  5.0
  6.  *
  7.  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27. #include "glheader.h"
  28. #include "imports.h"
  29. #include "api_loopback.h"
  30. #include "attrib.h"
  31. #include "blend.h"
  32. #include "buffers.h"
  33. #include "clip.h"
  34. #include "colormac.h"
  35. #include "colortab.h"
  36. #include "context.h"
  37. #include "convolve.h"
  38. #include "depth.h"
  39. #include "dlist.h"
  40. #include "enable.h"
  41. #include "enums.h"
  42. #include "eval.h"
  43. #include "extensions.h"
  44. #include "feedback.h"
  45. #include "get.h"
  46. #include "glapi.h"
  47. #include "hash.h"
  48. #include "histogram.h"
  49. #include "image.h"
  50. #include "light.h"
  51. #include "lines.h"
  52. #include "dlist.h"
  53. #include "macros.h"
  54. #include "matrix.h"
  55. #include "pixel.h"
  56. #include "points.h"
  57. #include "polygon.h"
  58. #include "state.h"
  59. #include "texobj.h"
  60. #include "teximage.h"
  61. #include "texstate.h"
  62. #include "mtypes.h"
  63. #include "varray.h"
  64. #if FEATURE_NV_vertex_program
  65. #include "vpstate.h"
  66. #endif
  67.  
  68. #include "math/m_matrix.h"
  69. #include "math/m_xform.h"
  70.  
  71.  
  72.  
  73. /*
  74. Functions which aren't compiled but executed immediately:
  75.     glIsList
  76.     glGenLists
  77.     glDeleteLists
  78.     glEndList  --- BUT:  call ctx->Driver.EndList at end of list execution?
  79.     glFeedbackBuffer
  80.     glSelectBuffer
  81.     glRenderMode
  82.     glReadPixels
  83.     glPixelStore
  84.     glFlush
  85.     glFinish
  86.     glIsEnabled
  87.     glGet*
  88.  
  89. Functions which cause errors if called while compiling a display list:
  90.     glNewList
  91. */
  92.  
  93.  
  94.  
  95. /*
  96.  * Display list instructions are stored as sequences of "nodes".  Nodes
  97.  * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks
  98.  * are linked together with a pointer.
  99.  */
  100.  
  101.  
  102. /* How many nodes to allocate at a time:
  103.  * - reduced now that we hold vertices etc. elsewhere.
  104.  */
  105. #define BLOCK_SIZE 256
  106.  
  107.  
  108. /*
  109.  * Display list opcodes.
  110.  *
  111.  * The fact that these identifiers are assigned consecutive
  112.  * integer values starting at 0 is very important, see InstSize array usage)
  113.  *
  114.  */
  115. typedef enum {
  116.     OPCODE_ACCUM,
  117.     OPCODE_ALPHA_FUNC,
  118.         OPCODE_BIND_TEXTURE,
  119.     OPCODE_BITMAP,
  120.     OPCODE_BLEND_COLOR,
  121.     OPCODE_BLEND_EQUATION,
  122.     OPCODE_BLEND_FUNC,
  123.     OPCODE_BLEND_FUNC_SEPARATE,
  124.         OPCODE_CALL_LIST,
  125.         OPCODE_CALL_LIST_OFFSET,
  126.     OPCODE_CLEAR,
  127.     OPCODE_CLEAR_ACCUM,
  128.     OPCODE_CLEAR_COLOR,
  129.     OPCODE_CLEAR_DEPTH,
  130.     OPCODE_CLEAR_INDEX,
  131.     OPCODE_CLEAR_STENCIL,
  132.         OPCODE_CLIP_PLANE,
  133.     OPCODE_COLOR_MASK,
  134.     OPCODE_COLOR_MATERIAL,
  135.     OPCODE_COLOR_TABLE,
  136.     OPCODE_COLOR_TABLE_PARAMETER_FV,
  137.     OPCODE_COLOR_TABLE_PARAMETER_IV,
  138.     OPCODE_COLOR_SUB_TABLE,
  139.         OPCODE_CONVOLUTION_FILTER_1D,
  140.         OPCODE_CONVOLUTION_FILTER_2D,
  141.         OPCODE_CONVOLUTION_PARAMETER_I,
  142.         OPCODE_CONVOLUTION_PARAMETER_IV,
  143.         OPCODE_CONVOLUTION_PARAMETER_F,
  144.         OPCODE_CONVOLUTION_PARAMETER_FV,
  145.         OPCODE_COPY_COLOR_SUB_TABLE,
  146.         OPCODE_COPY_COLOR_TABLE,
  147.     OPCODE_COPY_PIXELS,
  148.         OPCODE_COPY_TEX_IMAGE1D,
  149.         OPCODE_COPY_TEX_IMAGE2D,
  150.         OPCODE_COPY_TEX_SUB_IMAGE1D,
  151.         OPCODE_COPY_TEX_SUB_IMAGE2D,
  152.         OPCODE_COPY_TEX_SUB_IMAGE3D,
  153.     OPCODE_CULL_FACE,
  154.     OPCODE_DEPTH_FUNC,
  155.     OPCODE_DEPTH_MASK,
  156.     OPCODE_DEPTH_RANGE,
  157.     OPCODE_DISABLE,
  158.     OPCODE_DRAW_BUFFER,
  159.     OPCODE_DRAW_PIXELS,
  160.     OPCODE_ENABLE,
  161.     OPCODE_EVALMESH1,
  162.     OPCODE_EVALMESH2,
  163.     OPCODE_FOG,
  164.     OPCODE_FRONT_FACE,
  165.     OPCODE_FRUSTUM,
  166.     OPCODE_HINT,
  167.     OPCODE_HISTOGRAM,
  168.     OPCODE_INDEX_MASK,
  169.     OPCODE_INIT_NAMES,
  170.     OPCODE_LIGHT,
  171.     OPCODE_LIGHT_MODEL,
  172.     OPCODE_LINE_STIPPLE,
  173.     OPCODE_LINE_WIDTH,
  174.     OPCODE_LIST_BASE,
  175.     OPCODE_LOAD_IDENTITY,
  176.     OPCODE_LOAD_MATRIX,
  177.     OPCODE_LOAD_NAME,
  178.     OPCODE_LOGIC_OP,
  179.     OPCODE_MAP1,
  180.     OPCODE_MAP2,
  181.     OPCODE_MAPGRID1,
  182.     OPCODE_MAPGRID2,
  183.     OPCODE_MATRIX_MODE,
  184.         OPCODE_MIN_MAX,
  185.     OPCODE_MULT_MATRIX,
  186.     OPCODE_ORTHO,
  187.     OPCODE_PASSTHROUGH,
  188.     OPCODE_PIXEL_MAP,
  189.     OPCODE_PIXEL_TRANSFER,
  190.     OPCODE_PIXEL_ZOOM,
  191.     OPCODE_POINT_SIZE,
  192.         OPCODE_POINT_PARAMETERS,
  193.     OPCODE_POLYGON_MODE,
  194.         OPCODE_POLYGON_STIPPLE,
  195.     OPCODE_POLYGON_OFFSET,
  196.     OPCODE_POP_ATTRIB,
  197.     OPCODE_POP_MATRIX,
  198.     OPCODE_POP_NAME,
  199.     OPCODE_PRIORITIZE_TEXTURE,
  200.     OPCODE_PUSH_ATTRIB,
  201.     OPCODE_PUSH_MATRIX,
  202.     OPCODE_PUSH_NAME,
  203.     OPCODE_RASTER_POS,
  204.     OPCODE_READ_BUFFER,
  205.         OPCODE_RESET_HISTOGRAM,
  206.         OPCODE_RESET_MIN_MAX,
  207.         OPCODE_ROTATE,
  208.         OPCODE_SCALE,
  209.     OPCODE_SCISSOR,
  210.     OPCODE_SELECT_TEXTURE_SGIS,
  211.     OPCODE_SELECT_TEXTURE_COORD_SET,
  212.     OPCODE_SHADE_MODEL,
  213.     OPCODE_STENCIL_FUNC,
  214.     OPCODE_STENCIL_MASK,
  215.     OPCODE_STENCIL_OP,
  216.         OPCODE_TEXENV,
  217.         OPCODE_TEXGEN,
  218.         OPCODE_TEXPARAMETER,
  219.     OPCODE_TEX_IMAGE1D,
  220.     OPCODE_TEX_IMAGE2D,
  221.     OPCODE_TEX_IMAGE3D,
  222.     OPCODE_TEX_SUB_IMAGE1D,
  223.     OPCODE_TEX_SUB_IMAGE2D,
  224.     OPCODE_TEX_SUB_IMAGE3D,
  225.         OPCODE_TRANSLATE,
  226.     OPCODE_VIEWPORT,
  227.     OPCODE_WINDOW_POS,
  228.         /* GL_ARB_multitexture */
  229.         OPCODE_ACTIVE_TEXTURE,
  230.         /* GL_SGIX/SGIS_pixel_texture */
  231.         OPCODE_PIXEL_TEXGEN_SGIX,
  232.         OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS,
  233.         /* GL_ARB_texture_compression */
  234.         OPCODE_COMPRESSED_TEX_IMAGE_1D,
  235.         OPCODE_COMPRESSED_TEX_IMAGE_2D,
  236.         OPCODE_COMPRESSED_TEX_IMAGE_3D,
  237.         OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
  238.         OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
  239.         OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
  240.         /* GL_ARB_multisample */
  241.         OPCODE_SAMPLE_COVERAGE,
  242.         /* GL_ARB_window_pos */
  243.     OPCODE_WINDOW_POS_ARB,
  244.         /* GL_NV_vertex_program */
  245.         OPCODE_BIND_PROGRAM_NV,
  246.         OPCODE_EXECUTE_PROGRAM_NV,
  247.         OPCODE_REQUEST_PROGRAMS_RESIDENT_NV,
  248.         OPCODE_LOAD_PROGRAM_NV,
  249.         OPCODE_PROGRAM_PARAMETER4F_NV,
  250.         OPCODE_TRACK_MATRIX_NV,
  251.         /* GL_EXT_stencil_two_side */
  252.         OPCODE_ACTIVE_STENCIL_FACE_EXT,
  253.     /* The following three are meta instructions */
  254.     OPCODE_ERROR,            /* raise compiled-in error */
  255.     OPCODE_CONTINUE,
  256.     OPCODE_END_OF_LIST,
  257.     OPCODE_DRV_0
  258. } OpCode;
  259.  
  260.  
  261. /*
  262.  * Each instruction in the display list is stored as a sequence of
  263.  * contiguous nodes in memory.
  264.  * Each node is the union of a variety of datatypes.
  265.  */
  266. union node {
  267.     OpCode        opcode;
  268.     GLboolean    b;
  269.     GLbitfield    bf;
  270.     GLubyte        ub;
  271.     GLshort        s;
  272.     GLushort    us;
  273.     GLint        i;
  274.     GLuint        ui;
  275.     GLenum        e;
  276.     GLfloat        f;
  277.     GLvoid        *data;
  278.     void        *next;    /* If prev node's opcode==OPCODE_CONTINUE */
  279. };
  280.  
  281.  
  282.  
  283. /* Number of nodes of storage needed for each instruction.  Sizes for
  284.  * dynamically allocated opcodes are stored in the context struct.
  285.  */
  286. static GLuint InstSize[ OPCODE_END_OF_LIST+1 ];
  287.  
  288. void mesa_print_display_list( GLuint list );
  289.  
  290.  
  291. /**********************************************************************/
  292. /*****                           Private                          *****/
  293. /**********************************************************************/
  294.  
  295.  
  296.  
  297.  
  298.  
  299. /*
  300.  * Make an empty display list.  This is used by glGenLists() to
  301.  * reserver display list IDs.
  302.  */
  303. static Node *make_empty_list( void )
  304. {
  305.    Node *n = (Node *) MALLOC( sizeof(Node) );
  306.    n[0].opcode = OPCODE_END_OF_LIST;
  307.    return n;
  308. }
  309.  
  310.  
  311.  
  312. /*
  313.  * Destroy all nodes in a display list.
  314.  * Input:  list - display list number
  315.  */
  316. void _mesa_destroy_list( GLcontext *ctx, GLuint list )
  317. {
  318.    Node *n, *block;
  319.    GLboolean done;
  320.  
  321.    if (list==0)
  322.       return;
  323.  
  324.    block = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
  325.    n = block;
  326.  
  327.    done = block ? GL_FALSE : GL_TRUE;
  328.    while (!done) {
  329.  
  330.       /* check for extension opcodes first */
  331.  
  332.       GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
  333.       if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
  334.      ctx->listext.opcode[i].destroy(ctx, &n[1]);
  335.      n += ctx->listext.opcode[i].size;
  336.       }
  337.       else {
  338.      switch (n[0].opcode) {
  339.      case OPCODE_MAP1:
  340.             FREE(n[6].data);
  341.         n += InstSize[n[0].opcode];
  342.         break;
  343.      case OPCODE_MAP2:
  344.             FREE(n[10].data);
  345.         n += InstSize[n[0].opcode];
  346.         break;
  347.      case OPCODE_DRAW_PIXELS:
  348.         FREE( n[5].data );
  349.         n += InstSize[n[0].opcode];
  350.         break;
  351.      case OPCODE_BITMAP:
  352.         FREE( n[7].data );
  353.         n += InstSize[n[0].opcode];
  354.         break;
  355.          case OPCODE_COLOR_TABLE:
  356.             FREE( n[6].data );
  357.             n += InstSize[n[0].opcode];
  358.             break;
  359.          case OPCODE_COLOR_SUB_TABLE:
  360.             FREE( n[6].data );
  361.             n += InstSize[n[0].opcode];
  362.             break;
  363.          case OPCODE_CONVOLUTION_FILTER_1D:
  364.             FREE( n[6].data );
  365.             n += InstSize[n[0].opcode];
  366.             break;
  367.          case OPCODE_CONVOLUTION_FILTER_2D:
  368.             FREE( n[7].data );
  369.             n += InstSize[n[0].opcode];
  370.             break;
  371.          case OPCODE_POLYGON_STIPPLE:
  372.             FREE( n[1].data );
  373.         n += InstSize[n[0].opcode];
  374.             break;
  375.      case OPCODE_TEX_IMAGE1D:
  376.             FREE(n[8].data);
  377.             n += InstSize[n[0].opcode];
  378.         break;
  379.      case OPCODE_TEX_IMAGE2D:
  380.             FREE( n[9]. data );
  381.             n += InstSize[n[0].opcode];
  382.         break;
  383.      case OPCODE_TEX_IMAGE3D:
  384.             FREE( n[10]. data );
  385.             n += InstSize[n[0].opcode];
  386.         break;
  387.          case OPCODE_TEX_SUB_IMAGE1D:
  388.             FREE(n[7].data);
  389.             n += InstSize[n[0].opcode];
  390.             break;
  391.          case OPCODE_TEX_SUB_IMAGE2D:
  392.             FREE(n[9].data);
  393.             n += InstSize[n[0].opcode];
  394.             break;
  395.          case OPCODE_TEX_SUB_IMAGE3D:
  396.             FREE(n[11].data);
  397.             n += InstSize[n[0].opcode];
  398.             break;
  399.          case OPCODE_COMPRESSED_TEX_IMAGE_1D:
  400.             FREE(n[7].data);
  401.             n += InstSize[n[0].opcode];
  402.             break;
  403.          case OPCODE_COMPRESSED_TEX_IMAGE_2D:
  404.             FREE(n[8].data);
  405.             n += InstSize[n[0].opcode];
  406.             break;
  407.          case OPCODE_COMPRESSED_TEX_IMAGE_3D:
  408.             FREE(n[9].data);
  409.             n += InstSize[n[0].opcode];
  410.             break;
  411.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
  412.             FREE(n[7].data);
  413.             n += InstSize[n[0].opcode];
  414.             break;
  415.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
  416.             FREE(n[9].data);
  417.             n += InstSize[n[0].opcode];
  418.             break;
  419.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
  420.             FREE(n[11].data);
  421.             n += InstSize[n[0].opcode];
  422.             break;
  423.      case OPCODE_CONTINUE:
  424.         n = (Node *) n[1].next;
  425.         FREE( block );
  426.         block = n;
  427.         break;
  428.      case OPCODE_END_OF_LIST:
  429.         FREE( block );
  430.         done = GL_TRUE;
  431.         break;
  432.      default:
  433.         /* Most frequent case */
  434.         n += InstSize[n[0].opcode];
  435.         break;
  436.      }
  437.       }
  438.    }
  439.  
  440.    _mesa_HashRemove(ctx->Shared->DisplayList, list);
  441. }
  442.  
  443.  
  444.  
  445. /*
  446.  * Translate the nth element of list from type to GLuint.
  447.  */
  448. static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list )
  449. {
  450.    GLbyte *bptr;
  451.    GLubyte *ubptr;
  452.    GLshort *sptr;
  453.    GLushort *usptr;
  454.    GLint *iptr;
  455.    GLuint *uiptr;
  456.    GLfloat *fptr;
  457.  
  458.    switch (type) {
  459.       case GL_BYTE:
  460.          bptr = (GLbyte *) list;
  461.          return (GLuint) *(bptr+n);
  462.       case GL_UNSIGNED_BYTE:
  463.          ubptr = (GLubyte *) list;
  464.          return (GLuint) *(ubptr+n);
  465.       case GL_SHORT:
  466.          sptr = (GLshort *) list;
  467.          return (GLuint) *(sptr+n);
  468.       case GL_UNSIGNED_SHORT:
  469.          usptr = (GLushort *) list;
  470.          return (GLuint) *(usptr+n);
  471.       case GL_INT:
  472.          iptr = (GLint *) list;
  473.          return (GLuint) *(iptr+n);
  474.       case GL_UNSIGNED_INT:
  475.          uiptr = (GLuint *) list;
  476.          return (GLuint) *(uiptr+n);
  477.       case GL_FLOAT:
  478.          fptr = (GLfloat *) list;
  479.          return (GLuint) *(fptr+n);
  480.       case GL_2_BYTES:
  481.          ubptr = ((GLubyte *) list) + 2*n;
  482.          return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
  483.       case GL_3_BYTES:
  484.          ubptr = ((GLubyte *) list) + 3*n;
  485.          return (GLuint) *ubptr * 65536
  486.               + (GLuint) *(ubptr+1) * 256
  487.               + (GLuint) *(ubptr+2);
  488.       case GL_4_BYTES:
  489.          ubptr = ((GLubyte *) list) + 4*n;
  490.          return (GLuint) *ubptr * 16777216
  491.               + (GLuint) *(ubptr+1) * 65536
  492.               + (GLuint) *(ubptr+2) * 256
  493.               + (GLuint) *(ubptr+3);
  494.       default:
  495.          return 0;
  496.    }
  497. }
  498.  
  499.  
  500.  
  501.  
  502. /**********************************************************************/
  503. /*****                        Public                              *****/
  504. /**********************************************************************/
  505.  
  506. void _mesa_init_lists( void )
  507. {
  508.    static int init_flag = 0;
  509.  
  510.    if (init_flag==0) {
  511.       InstSize[OPCODE_ACCUM] = 3;
  512.       InstSize[OPCODE_ALPHA_FUNC] = 3;
  513.       InstSize[OPCODE_BIND_TEXTURE] = 3;
  514.       InstSize[OPCODE_BITMAP] = 8;
  515.       InstSize[OPCODE_BLEND_COLOR] = 5;
  516.       InstSize[OPCODE_BLEND_EQUATION] = 2;
  517.       InstSize[OPCODE_BLEND_FUNC] = 3;
  518.       InstSize[OPCODE_BLEND_FUNC_SEPARATE] = 5;
  519.       InstSize[OPCODE_CALL_LIST] = 2;
  520.       InstSize[OPCODE_CALL_LIST_OFFSET] = 3;
  521.       InstSize[OPCODE_CLEAR] = 2;
  522.       InstSize[OPCODE_CLEAR_ACCUM] = 5;
  523.       InstSize[OPCODE_CLEAR_COLOR] = 5;
  524.       InstSize[OPCODE_CLEAR_DEPTH] = 2;
  525.       InstSize[OPCODE_CLEAR_INDEX] = 2;
  526.       InstSize[OPCODE_CLEAR_STENCIL] = 2;
  527.       InstSize[OPCODE_CLIP_PLANE] = 6;
  528.       InstSize[OPCODE_COLOR_MASK] = 5;
  529.       InstSize[OPCODE_COLOR_MATERIAL] = 3;
  530.       InstSize[OPCODE_COLOR_TABLE] = 7;
  531.       InstSize[OPCODE_COLOR_TABLE_PARAMETER_FV] = 7;
  532.       InstSize[OPCODE_COLOR_TABLE_PARAMETER_IV] = 7;
  533.       InstSize[OPCODE_COLOR_SUB_TABLE] = 7;
  534.       InstSize[OPCODE_CONVOLUTION_FILTER_1D] = 7;
  535.       InstSize[OPCODE_CONVOLUTION_FILTER_2D] = 8;
  536.       InstSize[OPCODE_CONVOLUTION_PARAMETER_I] = 4;
  537.       InstSize[OPCODE_CONVOLUTION_PARAMETER_IV] = 7;
  538.       InstSize[OPCODE_CONVOLUTION_PARAMETER_F] = 4;
  539.       InstSize[OPCODE_CONVOLUTION_PARAMETER_FV] = 7;
  540.       InstSize[OPCODE_COPY_PIXELS] = 6;
  541.       InstSize[OPCODE_COPY_COLOR_SUB_TABLE] = 6;
  542.       InstSize[OPCODE_COPY_COLOR_TABLE] = 6;
  543.       InstSize[OPCODE_COPY_TEX_IMAGE1D] = 8;
  544.       InstSize[OPCODE_COPY_TEX_IMAGE2D] = 9;
  545.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE1D] = 7;
  546.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE2D] = 9;
  547.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE3D] = 10;
  548.       InstSize[OPCODE_CULL_FACE] = 2;
  549.       InstSize[OPCODE_DEPTH_FUNC] = 2;
  550.       InstSize[OPCODE_DEPTH_MASK] = 2;
  551.       InstSize[OPCODE_DEPTH_RANGE] = 3;
  552.       InstSize[OPCODE_DISABLE] = 2;
  553.       InstSize[OPCODE_DRAW_BUFFER] = 2;
  554.       InstSize[OPCODE_DRAW_PIXELS] = 6;
  555.       InstSize[OPCODE_ENABLE] = 2;
  556.       InstSize[OPCODE_EVALMESH1] = 4;
  557.       InstSize[OPCODE_EVALMESH2] = 6;
  558.       InstSize[OPCODE_FOG] = 6;
  559.       InstSize[OPCODE_FRONT_FACE] = 2;
  560.       InstSize[OPCODE_FRUSTUM] = 7;
  561.       InstSize[OPCODE_HINT] = 3;
  562.       InstSize[OPCODE_HISTOGRAM] = 5;
  563.       InstSize[OPCODE_INDEX_MASK] = 2;
  564.       InstSize[OPCODE_INIT_NAMES] = 1;
  565.       InstSize[OPCODE_LIGHT] = 7;
  566.       InstSize[OPCODE_LIGHT_MODEL] = 6;
  567.       InstSize[OPCODE_LINE_STIPPLE] = 3;
  568.       InstSize[OPCODE_LINE_WIDTH] = 2;
  569.       InstSize[OPCODE_LIST_BASE] = 2;
  570.       InstSize[OPCODE_LOAD_IDENTITY] = 1;
  571.       InstSize[OPCODE_LOAD_MATRIX] = 17;
  572.       InstSize[OPCODE_LOAD_NAME] = 2;
  573.       InstSize[OPCODE_LOGIC_OP] = 2;
  574.       InstSize[OPCODE_MAP1] = 7;
  575.       InstSize[OPCODE_MAP2] = 11;
  576.       InstSize[OPCODE_MAPGRID1] = 4;
  577.       InstSize[OPCODE_MAPGRID2] = 7;
  578.       InstSize[OPCODE_MATRIX_MODE] = 2;
  579.       InstSize[OPCODE_MIN_MAX] = 4;
  580.       InstSize[OPCODE_MULT_MATRIX] = 17;
  581.       InstSize[OPCODE_ORTHO] = 7;
  582.       InstSize[OPCODE_PASSTHROUGH] = 2;
  583.       InstSize[OPCODE_PIXEL_MAP] = 4;
  584.       InstSize[OPCODE_PIXEL_TRANSFER] = 3;
  585.       InstSize[OPCODE_PIXEL_ZOOM] = 3;
  586.       InstSize[OPCODE_POINT_SIZE] = 2;
  587.       InstSize[OPCODE_POINT_PARAMETERS] = 5;
  588.       InstSize[OPCODE_POLYGON_MODE] = 3;
  589.       InstSize[OPCODE_POLYGON_STIPPLE] = 2;
  590.       InstSize[OPCODE_POLYGON_OFFSET] = 3;
  591.       InstSize[OPCODE_POP_ATTRIB] = 1;
  592.       InstSize[OPCODE_POP_MATRIX] = 1;
  593.       InstSize[OPCODE_POP_NAME] = 1;
  594.       InstSize[OPCODE_PRIORITIZE_TEXTURE] = 3;
  595.       InstSize[OPCODE_PUSH_ATTRIB] = 2;
  596.       InstSize[OPCODE_PUSH_MATRIX] = 1;
  597.       InstSize[OPCODE_PUSH_NAME] = 2;
  598.       InstSize[OPCODE_RASTER_POS] = 5;
  599.       InstSize[OPCODE_READ_BUFFER] = 2;
  600.       InstSize[OPCODE_RESET_HISTOGRAM] = 2;
  601.       InstSize[OPCODE_RESET_MIN_MAX] = 2;
  602.       InstSize[OPCODE_ROTATE] = 5;
  603.       InstSize[OPCODE_SCALE] = 4;
  604.       InstSize[OPCODE_SCISSOR] = 5;
  605.       InstSize[OPCODE_STENCIL_FUNC] = 4;
  606.       InstSize[OPCODE_STENCIL_MASK] = 2;
  607.       InstSize[OPCODE_STENCIL_OP] = 4;
  608.       InstSize[OPCODE_SHADE_MODEL] = 2;
  609.       InstSize[OPCODE_TEXENV] = 7;
  610.       InstSize[OPCODE_TEXGEN] = 7;
  611.       InstSize[OPCODE_TEXPARAMETER] = 7;
  612.       InstSize[OPCODE_TEX_IMAGE1D] = 9;
  613.       InstSize[OPCODE_TEX_IMAGE2D] = 10;
  614.       InstSize[OPCODE_TEX_IMAGE3D] = 11;
  615.       InstSize[OPCODE_TEX_SUB_IMAGE1D] = 8;
  616.       InstSize[OPCODE_TEX_SUB_IMAGE2D] = 10;
  617.       InstSize[OPCODE_TEX_SUB_IMAGE3D] = 12;
  618.       InstSize[OPCODE_TRANSLATE] = 4;
  619.       InstSize[OPCODE_VIEWPORT] = 5;
  620.       InstSize[OPCODE_WINDOW_POS] = 5;
  621.       InstSize[OPCODE_CONTINUE] = 2;
  622.       InstSize[OPCODE_ERROR] = 3;
  623.       InstSize[OPCODE_END_OF_LIST] = 1;
  624.       /* GL_SGIX/SGIS_pixel_texture */
  625.       InstSize[OPCODE_PIXEL_TEXGEN_SGIX] = 2;
  626.       InstSize[OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS] = 3;
  627.       /* GL_ARB_texture_compression */
  628.       InstSize[OPCODE_COMPRESSED_TEX_IMAGE_1D] = 8;
  629.       InstSize[OPCODE_COMPRESSED_TEX_IMAGE_2D] = 9;
  630.       InstSize[OPCODE_COMPRESSED_TEX_IMAGE_3D] = 10;
  631.       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D] = 8;
  632.       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D] = 10;
  633.       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D] = 12;
  634.       /* GL_ARB_multisample */
  635.       InstSize[OPCODE_SAMPLE_COVERAGE] = 3;
  636.       /* GL_ARB_multitexture */
  637.       InstSize[OPCODE_ACTIVE_TEXTURE] = 2;
  638.       /* GL_ARB_window_pos */
  639.       InstSize[OPCODE_WINDOW_POS_ARB] = 4;
  640.       /* GL_NV_vertex_program */
  641.       InstSize[OPCODE_BIND_PROGRAM_NV] = 3;
  642.       InstSize[OPCODE_EXECUTE_PROGRAM_NV] = 7;
  643.       InstSize[OPCODE_REQUEST_PROGRAMS_RESIDENT_NV] = 2;
  644.       InstSize[OPCODE_LOAD_PROGRAM_NV] = 4;
  645.       InstSize[OPCODE_PROGRAM_PARAMETER4F_NV] = 7;
  646.       InstSize[OPCODE_TRACK_MATRIX_NV] = 5;
  647.       /* GL_EXT_stencil_two_side */
  648.       InstSize[OPCODE_ACTIVE_STENCIL_FACE_EXT] = 2;
  649.    }
  650.    init_flag = 1;
  651. }
  652.  
  653.  
  654. /*
  655.  * Allocate space for a display list instruction.
  656.  * Input:  opcode - type of instruction
  657.  *         argcount - size in bytes of data required.
  658.  * Return: pointer to the usable data area (not including the internal
  659.  *         opcode).
  660.  */
  661. void *
  662. _mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz )
  663. {
  664.    Node *n, *newblock;
  665.    GLuint count = 1 + (sz + sizeof(Node) - 1) / sizeof(Node);
  666.  
  667. #ifdef DEBUG
  668.    if (opcode < (int) OPCODE_DRV_0) {
  669.       assert( count == InstSize[opcode] );
  670.    }
  671. #endif
  672.  
  673.    if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
  674.       /* This block is full.  Allocate a new block and chain to it */
  675.       n = ctx->CurrentBlock + ctx->CurrentPos;
  676.       n[0].opcode = OPCODE_CONTINUE;
  677.       newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
  678.       if (!newblock) {
  679.          _mesa_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
  680.          return NULL;
  681.       }
  682.       n[1].next = (Node *) newblock;
  683.       ctx->CurrentBlock = newblock;
  684.       ctx->CurrentPos = 0;
  685.    }
  686.  
  687.    n = ctx->CurrentBlock + ctx->CurrentPos;
  688.    ctx->CurrentPos += count;
  689.  
  690.    n[0].opcode = (OpCode) opcode;
  691.  
  692.    return (void *)&n[1];
  693. }
  694.  
  695.  
  696. /* Allow modules and drivers to get their own opcodes.
  697.  */
  698. int
  699. _mesa_alloc_opcode( GLcontext *ctx,
  700.             GLuint sz,
  701.             void (*execute)( GLcontext *, void * ),
  702.             void (*destroy)( GLcontext *, void * ),
  703.             void (*print)( GLcontext *, void * ) )
  704. {
  705.    if (ctx->listext.nr_opcodes < GL_MAX_EXT_OPCODES) {
  706.       GLuint i = ctx->listext.nr_opcodes++;
  707.       ctx->listext.opcode[i].size = 1 + (sz + sizeof(Node) - 1)/sizeof(Node);
  708.       ctx->listext.opcode[i].execute = execute;
  709.       ctx->listext.opcode[i].destroy = destroy;
  710.       ctx->listext.opcode[i].print = print;
  711.       return i + OPCODE_DRV_0;
  712.    }
  713.    return -1;
  714. }
  715.  
  716.  
  717.  
  718. /* Mimic the old behaviour of alloc_instruction:
  719.  *   - sz is in units of sizeof(Node)
  720.  *   - return value a pointer to sizeof(Node) before the actual
  721.  *     usable data area.
  722.  */
  723. #define ALLOC_INSTRUCTION(ctx, opcode, sz) \
  724.         ((Node *)_mesa_alloc_instruction(ctx, opcode, sz*sizeof(Node)) - 1)
  725.  
  726.  
  727.  
  728. /*
  729.  * Display List compilation functions
  730.  */
  731. static void save_Accum( GLenum op, GLfloat value )
  732. {
  733.    GET_CURRENT_CONTEXT(ctx);
  734.    Node *n;
  735.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  736.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ACCUM, 2 );
  737.    if (n) {
  738.       n[1].e = op;
  739.       n[2].f = value;
  740.    }
  741.    if (ctx->ExecuteFlag) {
  742.       (*ctx->Exec->Accum)( op, value );
  743.    }
  744. }
  745.  
  746.  
  747. static void save_AlphaFunc( GLenum func, GLclampf ref )
  748. {
  749.    GET_CURRENT_CONTEXT(ctx);
  750.    Node *n;
  751.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  752.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ALPHA_FUNC, 2 );
  753.    if (n) {
  754.       n[1].e = func;
  755.       n[2].f = (GLfloat) ref;
  756.    }
  757.    if (ctx->ExecuteFlag) {
  758.       (*ctx->Exec->AlphaFunc)( func, ref );
  759.    }
  760. }
  761.  
  762.  
  763. static void save_BindTexture( GLenum target, GLuint texture )
  764. {
  765.    GET_CURRENT_CONTEXT(ctx);
  766.    Node *n;
  767.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  768.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_TEXTURE, 2 );
  769.    if (n) {
  770.       n[1].e = target;
  771.       n[2].ui = texture;
  772.    }
  773.    if (ctx->ExecuteFlag) {
  774.       (*ctx->Exec->BindTexture)( target, texture );
  775.    }
  776. }
  777.  
  778.  
  779. static void save_Bitmap( GLsizei width, GLsizei height,
  780.                          GLfloat xorig, GLfloat yorig,
  781.                          GLfloat xmove, GLfloat ymove,
  782.                          const GLubyte *pixels )
  783. {
  784.    GET_CURRENT_CONTEXT(ctx);
  785.    GLvoid *image = _mesa_unpack_bitmap( width, height, pixels, &ctx->Unpack );
  786.    Node *n;
  787.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  788.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BITMAP, 7 );
  789.    if (n) {
  790.       n[1].i = (GLint) width;
  791.       n[2].i = (GLint) height;
  792.       n[3].f = xorig;
  793.       n[4].f = yorig;
  794.       n[5].f = xmove;
  795.       n[6].f = ymove;
  796.       n[7].data = image;
  797.    }
  798.    else if (image) {
  799.       FREE(image);
  800.    }
  801.    if (ctx->ExecuteFlag) {
  802.       (*ctx->Exec->Bitmap)( width, height,
  803.                            xorig, yorig, xmove, ymove, pixels );
  804.    }
  805. }
  806.  
  807.  
  808. static void save_BlendEquation( GLenum mode )
  809. {
  810.    GET_CURRENT_CONTEXT(ctx);
  811.    Node *n;
  812.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  813.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_EQUATION, 1 );
  814.    if (n) {
  815.       n[1].e = mode;
  816.    }
  817.    if (ctx->ExecuteFlag) {
  818.       (*ctx->Exec->BlendEquation)( mode );
  819.    }
  820. }
  821.  
  822.  
  823. static void save_BlendFunc( GLenum sfactor, GLenum dfactor )
  824. {
  825.    GET_CURRENT_CONTEXT(ctx);
  826.    Node *n;
  827.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  828.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC, 2 );
  829.    if (n) {
  830.       n[1].e = sfactor;
  831.       n[2].e = dfactor;
  832.    }
  833.    if (ctx->ExecuteFlag) {
  834.       (*ctx->Exec->BlendFunc)( sfactor, dfactor );
  835.    }
  836. }
  837.  
  838.  
  839. static void save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
  840.                                       GLenum sfactorA, GLenum dfactorA)
  841. {
  842.    GET_CURRENT_CONTEXT(ctx);
  843.    Node *n;
  844.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  845.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 );
  846.    if (n) {
  847.       n[1].e = sfactorRGB;
  848.       n[2].e = dfactorRGB;
  849.       n[3].e = sfactorA;
  850.       n[4].e = dfactorA;
  851.    }
  852.    if (ctx->ExecuteFlag) {
  853.       (*ctx->Exec->BlendFuncSeparateEXT)( sfactorRGB, dfactorRGB,
  854.                                           sfactorA, dfactorA);
  855.    }
  856. }
  857.  
  858.  
  859. static void save_BlendColor( GLfloat red, GLfloat green,
  860.                              GLfloat blue, GLfloat alpha )
  861. {
  862.    GET_CURRENT_CONTEXT(ctx);
  863.    Node *n;
  864.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  865.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_COLOR, 4 );
  866.    if (n) {
  867.       n[1].f = red;
  868.       n[2].f = green;
  869.       n[3].f = blue;
  870.       n[4].f = alpha;
  871.    }
  872.    if (ctx->ExecuteFlag) {
  873.       (*ctx->Exec->BlendColor)( red, green, blue, alpha );
  874.    }
  875. }
  876.  
  877.  
  878. void _mesa_save_CallList( GLuint list )
  879. {
  880.    GET_CURRENT_CONTEXT(ctx);
  881.    Node *n;
  882.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  883.    FLUSH_CURRENT(ctx, 0);
  884.  
  885.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST, 1 );
  886.    if (n) {
  887.       n[1].ui = list;
  888.    }
  889.    if (ctx->ExecuteFlag) {
  890.       (*ctx->Exec->CallList)( list );
  891.    }
  892. }
  893.  
  894.  
  895. void _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
  896. {
  897.    GET_CURRENT_CONTEXT(ctx);
  898.    GLint i;
  899.    GLboolean typeErrorFlag;
  900.  
  901.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  902.    FLUSH_CURRENT(ctx, 0);
  903.  
  904.    switch (type) {
  905.       case GL_BYTE:
  906.       case GL_UNSIGNED_BYTE:
  907.       case GL_SHORT:
  908.       case GL_UNSIGNED_SHORT:
  909.       case GL_INT:
  910.       case GL_UNSIGNED_INT:
  911.       case GL_FLOAT:
  912.       case GL_2_BYTES:
  913.       case GL_3_BYTES:
  914.       case GL_4_BYTES:
  915.          typeErrorFlag = GL_FALSE;
  916.          break;
  917.       default:
  918.          typeErrorFlag = GL_TRUE;
  919.    }
  920.  
  921.    for (i=0;i<n;i++) {
  922.       GLuint list = translate_id( i, type, lists );
  923.       Node *n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST_OFFSET, 2 );
  924.       if (n) {
  925.          n[1].ui = list;
  926.          n[2].b = typeErrorFlag;
  927.       }
  928.    }
  929.    if (ctx->ExecuteFlag) {
  930.       (*ctx->Exec->CallLists)( n, type, lists );
  931.    }
  932. }
  933.  
  934.  
  935. static void save_Clear( GLbitfield mask )
  936. {
  937.    GET_CURRENT_CONTEXT(ctx);
  938.    Node *n;
  939.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  940.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR, 1 );
  941.    if (n) {
  942.       n[1].bf = mask;
  943.    }
  944.    if (ctx->ExecuteFlag) {
  945.       (*ctx->Exec->Clear)( mask );
  946.    }
  947. }
  948.  
  949.  
  950. static void save_ClearAccum( GLfloat red, GLfloat green,
  951.                              GLfloat blue, GLfloat alpha )
  952. {
  953.    GET_CURRENT_CONTEXT(ctx);
  954.    Node *n;
  955.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  956.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_ACCUM, 4 );
  957.    if (n) {
  958.       n[1].f = red;
  959.       n[2].f = green;
  960.       n[3].f = blue;
  961.       n[4].f = alpha;
  962.    }
  963.    if (ctx->ExecuteFlag) {
  964.       (*ctx->Exec->ClearAccum)( red, green, blue, alpha );
  965.    }
  966. }
  967.  
  968.  
  969. static void save_ClearColor( GLclampf red, GLclampf green,
  970.                              GLclampf blue, GLclampf alpha )
  971. {
  972.    GET_CURRENT_CONTEXT(ctx);
  973.    Node *n;
  974.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  975.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_COLOR, 4 );
  976.    if (n) {
  977.       n[1].f = red;
  978.       n[2].f = green;
  979.       n[3].f = blue;
  980.       n[4].f = alpha;
  981.    }
  982.    if (ctx->ExecuteFlag) {
  983.       (*ctx->Exec->ClearColor)( red, green, blue, alpha );
  984.    }
  985. }
  986.  
  987.  
  988. static void save_ClearDepth( GLclampd depth )
  989. {
  990.    GET_CURRENT_CONTEXT(ctx);
  991.    Node *n;
  992.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  993.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_DEPTH, 1 );
  994.    if (n) {
  995.       n[1].f = (GLfloat) depth;
  996.    }
  997.    if (ctx->ExecuteFlag) {
  998.       (*ctx->Exec->ClearDepth)( depth );
  999.    }
  1000. }
  1001.  
  1002.  
  1003. static void save_ClearIndex( GLfloat c )
  1004. {
  1005.    GET_CURRENT_CONTEXT(ctx);
  1006.    Node *n;
  1007.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1008.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_INDEX, 1 );
  1009.    if (n) {
  1010.       n[1].f = c;
  1011.    }
  1012.    if (ctx->ExecuteFlag) {
  1013.       (*ctx->Exec->ClearIndex)( c );
  1014.    }
  1015. }
  1016.  
  1017.  
  1018. static void save_ClearStencil( GLint s )
  1019. {
  1020.    GET_CURRENT_CONTEXT(ctx);
  1021.    Node *n;
  1022.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1023.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_STENCIL, 1 );
  1024.    if (n) {
  1025.       n[1].i = s;
  1026.    }
  1027.    if (ctx->ExecuteFlag) {
  1028.       (*ctx->Exec->ClearStencil)( s );
  1029.    }
  1030. }
  1031.  
  1032.  
  1033. static void save_ClipPlane( GLenum plane, const GLdouble *equ )
  1034. {
  1035.    GET_CURRENT_CONTEXT(ctx);
  1036.    Node *n;
  1037.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1038.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CLIP_PLANE, 5 );
  1039.    if (n) {
  1040.       n[1].e = plane;
  1041.       n[2].f = (GLfloat) equ[0];
  1042.       n[3].f = (GLfloat) equ[1];
  1043.       n[4].f = (GLfloat) equ[2];
  1044.       n[5].f = (GLfloat) equ[3];
  1045.    }
  1046.    if (ctx->ExecuteFlag) {
  1047.       (*ctx->Exec->ClipPlane)( plane, equ );
  1048.    }
  1049. }
  1050.  
  1051.  
  1052.  
  1053. static void save_ColorMask( GLboolean red, GLboolean green,
  1054.                             GLboolean blue, GLboolean alpha )
  1055. {
  1056.    GET_CURRENT_CONTEXT(ctx);
  1057.    Node *n;
  1058.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1059.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MASK, 4 );
  1060.    if (n) {
  1061.       n[1].b = red;
  1062.       n[2].b = green;
  1063.       n[3].b = blue;
  1064.       n[4].b = alpha;
  1065.    }
  1066.    if (ctx->ExecuteFlag) {
  1067.       (*ctx->Exec->ColorMask)( red, green, blue, alpha );
  1068.    }
  1069. }
  1070.  
  1071.  
  1072. static void save_ColorMaterial( GLenum face, GLenum mode )
  1073. {
  1074.    GET_CURRENT_CONTEXT(ctx);
  1075.    Node *n;
  1076.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1077.    FLUSH_CURRENT(ctx, 0);
  1078.  
  1079.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MATERIAL, 2 );
  1080.    if (n) {
  1081.       n[1].e = face;
  1082.       n[2].e = mode;
  1083.    }
  1084.    if (ctx->ExecuteFlag) {
  1085.       (*ctx->Exec->ColorMaterial)( face, mode );
  1086.    }
  1087. }
  1088.  
  1089.  
  1090. static void save_ColorTable( GLenum target, GLenum internalFormat,
  1091.                              GLsizei width, GLenum format, GLenum type,
  1092.                              const GLvoid *table )
  1093. {
  1094.    GET_CURRENT_CONTEXT(ctx);
  1095.    if (target == GL_PROXY_TEXTURE_1D ||
  1096.        target == GL_PROXY_TEXTURE_2D ||
  1097.        target == GL_PROXY_TEXTURE_3D ||
  1098.        target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
  1099.       /* execute immediately */
  1100.       (*ctx->Exec->ColorTable)( target, internalFormat, width,
  1101.                                 format, type, table );
  1102.    }
  1103.    else {
  1104.       GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, table,
  1105.                                          &ctx->Unpack);
  1106.       Node *n;
  1107.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1108.       n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE, 6 );
  1109.       if (n) {
  1110.          n[1].e = target;
  1111.          n[2].e = internalFormat;
  1112.          n[3].i = width;
  1113.          n[4].e = format;
  1114.          n[5].e = type;
  1115.          n[6].data = image;
  1116.       }
  1117.       else if (image) {
  1118.          FREE(image);
  1119.       }
  1120.       if (ctx->ExecuteFlag) {
  1121.          (*ctx->Exec->ColorTable)( target, internalFormat, width,
  1122.                                    format, type, table );
  1123.       }
  1124.    }
  1125. }
  1126.  
  1127.  
  1128.  
  1129. static void
  1130. save_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
  1131. {
  1132.    GET_CURRENT_CONTEXT(ctx);
  1133.    Node *n;
  1134.  
  1135.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1136.  
  1137.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6 );
  1138.    if (n) {
  1139.       n[1].e = target;
  1140.       n[2].e = pname;
  1141.       n[3].f = params[0];
  1142.       if (pname == GL_COLOR_TABLE_SGI ||
  1143.           pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
  1144.           pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
  1145.          n[4].f = params[1];
  1146.          n[5].f = params[2];
  1147.          n[6].f = params[3];
  1148.       }
  1149.    }
  1150.  
  1151.    if (ctx->ExecuteFlag) {
  1152.       (*ctx->Exec->ColorTableParameterfv)( target, pname, params );
  1153.    }
  1154. }
  1155.  
  1156.  
  1157. static void
  1158. save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
  1159. {
  1160.    GET_CURRENT_CONTEXT(ctx);
  1161.    Node *n;
  1162.  
  1163.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1164.  
  1165.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6 );
  1166.    if (n) {
  1167.       n[1].e = target;
  1168.       n[2].e = pname;
  1169.       n[3].i = params[0];
  1170.       if (pname == GL_COLOR_TABLE_SGI ||
  1171.           pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
  1172.           pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
  1173.          n[4].i = params[1];
  1174.          n[5].i = params[2];
  1175.          n[6].i = params[3];
  1176.       }
  1177.    }
  1178.  
  1179.    if (ctx->ExecuteFlag) {
  1180.       (*ctx->Exec->ColorTableParameteriv)( target, pname, params );
  1181.    }
  1182. }
  1183.  
  1184.  
  1185.  
  1186. static void save_ColorSubTable( GLenum target, GLsizei start, GLsizei count,
  1187.                                 GLenum format, GLenum type,
  1188.                                 const GLvoid *table)
  1189. {
  1190.    GET_CURRENT_CONTEXT(ctx);
  1191.    GLvoid *image = _mesa_unpack_image(count, 1, 1, format, type, table,
  1192.                                       &ctx->Unpack);
  1193.    Node *n;
  1194.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1195.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_SUB_TABLE, 6 );
  1196.    if (n) {
  1197.       n[1].e = target;
  1198.       n[2].i = start;
  1199.       n[3].i = count;
  1200.       n[4].e = format;
  1201.       n[5].e = type;
  1202.       n[6].data = image;
  1203.    }
  1204.    else if (image) {
  1205.       FREE(image);
  1206.    }
  1207.    if (ctx->ExecuteFlag) {
  1208.       (*ctx->Exec->ColorSubTable)(target, start, count, format, type, table);
  1209.    }
  1210. }
  1211.  
  1212.  
  1213. static void
  1214. save_CopyColorSubTable(GLenum target, GLsizei start,
  1215.                        GLint x, GLint y, GLsizei width)
  1216. {
  1217.    GET_CURRENT_CONTEXT(ctx);
  1218.    Node *n;
  1219.  
  1220.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1221.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5 );
  1222.    if (n) {
  1223.       n[1].e = target;
  1224.       n[2].i = start;
  1225.       n[3].i = x;
  1226.       n[4].i = y;
  1227.       n[5].i = width;
  1228.    }
  1229.    if (ctx->ExecuteFlag) {
  1230.       (*ctx->Exec->CopyColorSubTable)(target, start, x, y, width);
  1231.    }
  1232. }
  1233.  
  1234.  
  1235. static void
  1236. save_CopyColorTable(GLenum target, GLenum internalformat,
  1237.                     GLint x, GLint y, GLsizei width)
  1238. {
  1239.    GET_CURRENT_CONTEXT(ctx);
  1240.    Node *n;
  1241.  
  1242.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1243.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_TABLE, 5 );
  1244.    if (n) {
  1245.       n[1].e = target;
  1246.       n[2].e = internalformat;
  1247.       n[3].i = x;
  1248.       n[4].i = y;
  1249.       n[5].i = width;
  1250.    }
  1251.    if (ctx->ExecuteFlag) {
  1252.       (*ctx->Exec->CopyColorTable)(target, internalformat, x, y, width);
  1253.    }
  1254. }
  1255.  
  1256.  
  1257. static void
  1258. save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
  1259.                          GLenum format, GLenum type, const GLvoid *filter)
  1260. {
  1261.    GET_CURRENT_CONTEXT(ctx);
  1262.    GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, filter,
  1263.                                       &ctx->Unpack);
  1264.    Node *n;
  1265.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1266.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_1D, 6 );
  1267.    if (n) {
  1268.       n[1].e = target;
  1269.       n[2].e = internalFormat;
  1270.       n[3].i = width;
  1271.       n[4].e = format;
  1272.       n[5].e = type;
  1273.       n[6].data = image;
  1274.    }
  1275.    else if (image) {
  1276.       FREE(image);
  1277.    }
  1278.    if (ctx->ExecuteFlag) {
  1279.       (*ctx->Exec->ConvolutionFilter1D)( target, internalFormat, width,
  1280.                                          format, type, filter );
  1281.    }
  1282. }
  1283.  
  1284.  
  1285. static void
  1286. save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
  1287.                          GLsizei width, GLsizei height, GLenum format,
  1288.                          GLenum type, const GLvoid *filter)
  1289. {
  1290.    GET_CURRENT_CONTEXT(ctx);
  1291.    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, filter,
  1292.                                       &ctx->Unpack);
  1293.    Node *n;
  1294.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1295.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_2D, 7 );
  1296.    if (n) {
  1297.       n[1].e = target;
  1298.       n[2].e = internalFormat;
  1299.       n[3].i = width;
  1300.       n[4].i = height;
  1301.       n[5].e = format;
  1302.       n[6].e = type;
  1303.       n[7].data = image;
  1304.    }
  1305.    else if (image) {
  1306.       FREE(image);
  1307.    }
  1308.    if (ctx->ExecuteFlag) {
  1309.       (*ctx->Exec->ConvolutionFilter2D)( target, internalFormat, width, height,
  1310.                                          format, type, filter );
  1311.    }
  1312. }
  1313.  
  1314.  
  1315. static void
  1316. save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
  1317. {
  1318.    GET_CURRENT_CONTEXT(ctx);
  1319.    Node *n;
  1320.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1321.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3 );
  1322.    if (n) {
  1323.       n[1].e = target;
  1324.       n[2].e = pname;
  1325.       n[3].i = param;
  1326.    }
  1327.    if (ctx->ExecuteFlag) {
  1328.       (*ctx->Exec->ConvolutionParameteri)( target, pname, param );
  1329.    }
  1330. }
  1331.  
  1332.  
  1333. static void
  1334. save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
  1335. {
  1336.    GET_CURRENT_CONTEXT(ctx);
  1337.    Node *n;
  1338.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1339.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6 );
  1340.    if (n) {
  1341.       n[1].e = target;
  1342.       n[2].e = pname;
  1343.       n[3].i = params[0];
  1344.       if (pname == GL_CONVOLUTION_BORDER_COLOR ||
  1345.           pname == GL_CONVOLUTION_FILTER_SCALE ||
  1346.           pname == GL_CONVOLUTION_FILTER_BIAS) {
  1347.          n[4].i = params[1];
  1348.          n[5].i = params[2];
  1349.          n[6].i = params[3];
  1350.       }
  1351.       else {
  1352.          n[4].i = n[5].i = n[6].i = 0;
  1353.       }
  1354.    }
  1355.    if (ctx->ExecuteFlag) {
  1356.       (*ctx->Exec->ConvolutionParameteriv)( target, pname, params );
  1357.    }
  1358. }
  1359.  
  1360.  
  1361. static void
  1362. save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
  1363. {
  1364.    GET_CURRENT_CONTEXT(ctx);
  1365.    Node *n;
  1366.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1367.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3 );
  1368.    if (n) {
  1369.       n[1].e = target;
  1370.       n[2].e = pname;
  1371.       n[3].f = param;
  1372.    }
  1373.    if (ctx->ExecuteFlag) {
  1374.       (*ctx->Exec->ConvolutionParameterf)( target, pname, param );
  1375.    }
  1376. }
  1377.  
  1378.  
  1379. static void
  1380. save_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
  1381. {
  1382.    GET_CURRENT_CONTEXT(ctx);
  1383.    Node *n;
  1384.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1385.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6 );
  1386.    if (n) {
  1387.       n[1].e = target;
  1388.       n[2].e = pname;
  1389.       n[3].f = params[0];
  1390.       if (pname == GL_CONVOLUTION_BORDER_COLOR ||
  1391.           pname == GL_CONVOLUTION_FILTER_SCALE ||
  1392.           pname == GL_CONVOLUTION_FILTER_BIAS) {
  1393.          n[4].f = params[1];
  1394.          n[5].f = params[2];
  1395.          n[6].f = params[3];
  1396.       }
  1397.       else {
  1398.          n[4].f = n[5].f = n[6].f = 0.0F;
  1399.       }
  1400.    }
  1401.    if (ctx->ExecuteFlag) {
  1402.       (*ctx->Exec->ConvolutionParameterfv)( target, pname, params );
  1403.    }
  1404. }
  1405.  
  1406.  
  1407. static void 
  1408. save_CopyPixels( GLint x, GLint y,
  1409.          GLsizei width, GLsizei height, GLenum type )
  1410. {
  1411.    GET_CURRENT_CONTEXT(ctx);
  1412.    Node *n;
  1413.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1414.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_PIXELS, 5 );
  1415.    if (n) {
  1416.       n[1].i = x;
  1417.       n[2].i = y;
  1418.       n[3].i = (GLint) width;
  1419.       n[4].i = (GLint) height;
  1420.       n[5].e = type;
  1421.    }
  1422.    if (ctx->ExecuteFlag) {
  1423.       (*ctx->Exec->CopyPixels)( x, y, width, height, type );
  1424.    }
  1425. }
  1426.  
  1427.  
  1428.  
  1429. static void
  1430. save_CopyTexImage1D( GLenum target, GLint level, GLenum internalformat,
  1431.                      GLint x, GLint y, GLsizei width, GLint border )
  1432. {
  1433.    GET_CURRENT_CONTEXT(ctx);
  1434.    Node *n;
  1435.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1436.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
  1437.    if (n) {
  1438.       n[1].e = target;
  1439.       n[2].i = level;
  1440.       n[3].e = internalformat;
  1441.       n[4].i = x;
  1442.       n[5].i = y;
  1443.       n[6].i = width;
  1444.       n[7].i = border;
  1445.    }
  1446.    if (ctx->ExecuteFlag) {
  1447.       (*ctx->Exec->CopyTexImage1D)( target, level, internalformat,
  1448.                                    x, y, width, border );
  1449.    }
  1450. }
  1451.  
  1452.  
  1453. static void
  1454. save_CopyTexImage2D( GLenum target, GLint level,
  1455.                      GLenum internalformat,
  1456.                      GLint x, GLint y, GLsizei width,
  1457.                      GLsizei height, GLint border )
  1458. {
  1459.    GET_CURRENT_CONTEXT(ctx);
  1460.    Node *n;
  1461.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1462.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
  1463.    if (n) {
  1464.       n[1].e = target;
  1465.       n[2].i = level;
  1466.       n[3].e = internalformat;
  1467.       n[4].i = x;
  1468.       n[5].i = y;
  1469.       n[6].i = width;
  1470.       n[7].i = height;
  1471.       n[8].i = border;
  1472.    }
  1473.    if (ctx->ExecuteFlag) {
  1474.       (*ctx->Exec->CopyTexImage2D)( target, level, internalformat,
  1475.                                    x, y, width, height, border );
  1476.    }
  1477. }
  1478.  
  1479.  
  1480.  
  1481. static void
  1482. save_CopyTexSubImage1D( GLenum target, GLint level,
  1483.                         GLint xoffset, GLint x, GLint y,
  1484.                         GLsizei width )
  1485. {
  1486.    GET_CURRENT_CONTEXT(ctx);
  1487.    Node *n;
  1488.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1489.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
  1490.    if (n) {
  1491.       n[1].e = target;
  1492.       n[2].i = level;
  1493.       n[3].i = xoffset;
  1494.       n[4].i = x;
  1495.       n[5].i = y;
  1496.       n[6].i = width;
  1497.    }
  1498.    if (ctx->ExecuteFlag) {
  1499.       (*ctx->Exec->CopyTexSubImage1D)( target, level, xoffset, x, y, width );
  1500.    }
  1501. }
  1502.  
  1503.  
  1504. static void
  1505. save_CopyTexSubImage2D( GLenum target, GLint level,
  1506.                         GLint xoffset, GLint yoffset,
  1507.                         GLint x, GLint y,
  1508.                         GLsizei width, GLint height )
  1509. {
  1510.    GET_CURRENT_CONTEXT(ctx);
  1511.    Node *n;
  1512.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1513.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
  1514.    if (n) {
  1515.       n[1].e = target;
  1516.       n[2].i = level;
  1517.       n[3].i = xoffset;
  1518.       n[4].i = yoffset;
  1519.       n[5].i = x;
  1520.       n[6].i = y;
  1521.       n[7].i = width;
  1522.       n[8].i = height;
  1523.    }
  1524.    if (ctx->ExecuteFlag) {
  1525.       (*ctx->Exec->CopyTexSubImage2D)( target, level, xoffset, yoffset,
  1526.                                x, y, width, height );
  1527.    }
  1528. }
  1529.  
  1530.  
  1531. static void
  1532. save_CopyTexSubImage3D( GLenum target, GLint level,
  1533.                         GLint xoffset, GLint yoffset, GLint zoffset,
  1534.                         GLint x, GLint y,
  1535.                         GLsizei width, GLint height )
  1536. {
  1537.    GET_CURRENT_CONTEXT(ctx);
  1538.    Node *n;
  1539.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1540.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 );
  1541.    if (n) {
  1542.       n[1].e = target;
  1543.       n[2].i = level;
  1544.       n[3].i = xoffset;
  1545.       n[4].i = yoffset;
  1546.       n[5].i = zoffset;
  1547.       n[6].i = x;
  1548.       n[7].i = y;
  1549.       n[8].i = width;
  1550.       n[9].i = height;
  1551.    }
  1552.    if (ctx->ExecuteFlag) {
  1553.       (*ctx->Exec->CopyTexSubImage3D)( target, level,
  1554.                                       xoffset, yoffset, zoffset,
  1555.                                       x, y, width, height );
  1556.    }
  1557. }
  1558.  
  1559.  
  1560. static void save_CullFace( GLenum mode )
  1561. {
  1562.    GET_CURRENT_CONTEXT(ctx);
  1563.    Node *n;
  1564.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1565.    n = ALLOC_INSTRUCTION( ctx, OPCODE_CULL_FACE, 1 );
  1566.    if (n) {
  1567.       n[1].e = mode;
  1568.    }
  1569.    if (ctx->ExecuteFlag) {
  1570.       (*ctx->Exec->CullFace)( mode );
  1571.    }
  1572. }
  1573.  
  1574.  
  1575. static void save_DepthFunc( GLenum func )
  1576. {
  1577.    GET_CURRENT_CONTEXT(ctx);
  1578.    Node *n;
  1579.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1580.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_FUNC, 1 );
  1581.    if (n) {
  1582.       n[1].e = func;
  1583.    }
  1584.    if (ctx->ExecuteFlag) {
  1585.       (*ctx->Exec->DepthFunc)( func );
  1586.    }
  1587. }
  1588.  
  1589.  
  1590. static void save_DepthMask( GLboolean mask )
  1591. {
  1592.    GET_CURRENT_CONTEXT(ctx);
  1593.    Node *n;
  1594.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1595.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_MASK, 1 );
  1596.    if (n) {
  1597.       n[1].b = mask;
  1598.    }
  1599.    if (ctx->ExecuteFlag) {
  1600.       (*ctx->Exec->DepthMask)( mask );
  1601.    }
  1602. }
  1603.  
  1604.  
  1605. static void save_DepthRange( GLclampd nearval, GLclampd farval )
  1606. {
  1607.    GET_CURRENT_CONTEXT(ctx);
  1608.    Node *n;
  1609.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1610.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_RANGE, 2 );
  1611.    if (n) {
  1612.       n[1].f = (GLfloat) nearval;
  1613.       n[2].f = (GLfloat) farval;
  1614.    }
  1615.    if (ctx->ExecuteFlag) {
  1616.       (*ctx->Exec->DepthRange)( nearval, farval );
  1617.    }
  1618. }
  1619.  
  1620.  
  1621. static void save_Disable( GLenum cap )
  1622. {
  1623.    GET_CURRENT_CONTEXT(ctx);
  1624.    Node *n;
  1625.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1626.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DISABLE, 1 );
  1627.    if (n) {
  1628.       n[1].e = cap;
  1629.    }
  1630.    if (ctx->ExecuteFlag) {
  1631.       (*ctx->Exec->Disable)( cap );
  1632.    }
  1633. }
  1634.  
  1635.  
  1636. static void save_DrawBuffer( GLenum mode )
  1637. {
  1638.    GET_CURRENT_CONTEXT(ctx);
  1639.    Node *n;
  1640.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1641.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_BUFFER, 1 );
  1642.    if (n) {
  1643.       n[1].e = mode;
  1644.    }
  1645.    if (ctx->ExecuteFlag) {
  1646.       (*ctx->Exec->DrawBuffer)( mode );
  1647.    }
  1648. }
  1649.  
  1650.  
  1651. static void save_DrawPixels( GLsizei width, GLsizei height,
  1652.                              GLenum format, GLenum type,
  1653.                              const GLvoid *pixels )
  1654. {
  1655.    GET_CURRENT_CONTEXT(ctx);
  1656.    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
  1657.                                       pixels, &ctx->Unpack);
  1658.    Node *n;
  1659.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1660.    n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_PIXELS, 5 );
  1661.    if (n) {
  1662.       n[1].i = width;
  1663.       n[2].i = height;
  1664.       n[3].e = format;
  1665.       n[4].e = type;
  1666.       n[5].data = image;
  1667.    }
  1668.    else if (image) {
  1669.       FREE(image);
  1670.    }
  1671.    if (ctx->ExecuteFlag) {
  1672.       (*ctx->Exec->DrawPixels)( width, height, format, type, pixels );
  1673.    }
  1674. }
  1675.  
  1676.  
  1677.  
  1678. static void save_Enable( GLenum cap )
  1679. {
  1680.    GET_CURRENT_CONTEXT(ctx);
  1681.    Node *n;
  1682.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1683.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ENABLE, 1 );
  1684.    if (n) {
  1685.       n[1].e = cap;
  1686.    }
  1687.    if (ctx->ExecuteFlag) {
  1688.       (*ctx->Exec->Enable)( cap );
  1689.    }
  1690. }
  1691.  
  1692.  
  1693.  
  1694. void _mesa_save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
  1695. {
  1696.    GET_CURRENT_CONTEXT(ctx);
  1697.    Node *n;
  1698.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1699.    n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH1, 3 );
  1700.    if (n) {
  1701.       n[1].e = mode;
  1702.       n[2].i = i1;
  1703.       n[3].i = i2;
  1704.    }
  1705.    if (ctx->ExecuteFlag) {
  1706.       (*ctx->Exec->EvalMesh1)( mode, i1, i2 );
  1707.    }
  1708. }
  1709.  
  1710.  
  1711. void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  1712. {
  1713.    GET_CURRENT_CONTEXT(ctx);
  1714.    Node *n;
  1715.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1716.    n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH2, 5 );
  1717.    if (n) {
  1718.       n[1].e = mode;
  1719.       n[2].i = i1;
  1720.       n[3].i = i2;
  1721.       n[4].i = j1;
  1722.       n[5].i = j2;
  1723.    }
  1724.    if (ctx->ExecuteFlag) {
  1725.       (*ctx->Exec->EvalMesh2)( mode, i1, i2, j1, j2 );
  1726.    }
  1727. }
  1728.  
  1729.  
  1730.  
  1731.  
  1732. static void save_Fogfv( GLenum pname, const GLfloat *params )
  1733. {
  1734.    GET_CURRENT_CONTEXT(ctx);
  1735.    Node *n;
  1736.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1737.    n = ALLOC_INSTRUCTION( ctx, OPCODE_FOG, 5 );
  1738.    if (n) {
  1739.       n[1].e = pname;
  1740.       n[2].f = params[0];
  1741.       n[3].f = params[1];
  1742.       n[4].f = params[2];
  1743.       n[5].f = params[3];
  1744.    }
  1745.    if (ctx->ExecuteFlag) {
  1746.       (*ctx->Exec->Fogfv)( pname, params );
  1747.    }
  1748. }
  1749.  
  1750.  
  1751. static void save_Fogf( GLenum pname, GLfloat param )
  1752. {
  1753.    save_Fogfv(pname, ¶m);
  1754. }
  1755.  
  1756.  
  1757. static void save_Fogiv(GLenum pname, const GLint *params )
  1758. {
  1759.    GLfloat p[4];
  1760.    switch (pname) {
  1761.       case GL_FOG_MODE:
  1762.       case GL_FOG_DENSITY:
  1763.       case GL_FOG_START:
  1764.       case GL_FOG_END:
  1765.       case GL_FOG_INDEX:
  1766.      p[0] = (GLfloat) *params;
  1767.      break;
  1768.       case GL_FOG_COLOR:
  1769.      p[0] = INT_TO_FLOAT( params[0] );
  1770.      p[1] = INT_TO_FLOAT( params[1] );
  1771.      p[2] = INT_TO_FLOAT( params[2] );
  1772.      p[3] = INT_TO_FLOAT( params[3] );
  1773.      break;
  1774.       default:
  1775.          /* Error will be caught later in gl_Fogfv */
  1776.          ;
  1777.    }
  1778.    save_Fogfv(pname, p);
  1779. }
  1780.  
  1781.  
  1782. static void save_Fogi(GLenum pname, GLint param )
  1783. {
  1784.    save_Fogiv(pname, ¶m);
  1785. }
  1786.  
  1787.  
  1788. static void save_FrontFace( GLenum mode )
  1789. {
  1790.    GET_CURRENT_CONTEXT(ctx);
  1791.    Node *n;
  1792.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1793.    n = ALLOC_INSTRUCTION( ctx, OPCODE_FRONT_FACE, 1 );
  1794.    if (n) {
  1795.       n[1].e = mode;
  1796.    }
  1797.    if (ctx->ExecuteFlag) {
  1798.       (*ctx->Exec->FrontFace)( mode );
  1799.    }
  1800. }
  1801.  
  1802.  
  1803. static void save_Frustum( GLdouble left, GLdouble right,
  1804.                       GLdouble bottom, GLdouble top,
  1805.                       GLdouble nearval, GLdouble farval )
  1806. {
  1807.    GET_CURRENT_CONTEXT(ctx);
  1808.    Node *n;
  1809.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1810.    n = ALLOC_INSTRUCTION( ctx, OPCODE_FRUSTUM, 6 );
  1811.    if (n) {
  1812.       n[1].f = (GLfloat) left;
  1813.       n[2].f = (GLfloat) right;
  1814.       n[3].f = (GLfloat) bottom;
  1815.       n[4].f = (GLfloat) top;
  1816.       n[5].f = (GLfloat) nearval;
  1817.       n[6].f = (GLfloat) farval;
  1818.    }
  1819.    if (ctx->ExecuteFlag) {
  1820.       (*ctx->Exec->Frustum)( left, right, bottom, top, nearval, farval );
  1821.    }
  1822. }
  1823.  
  1824.  
  1825. static void save_Hint( GLenum target, GLenum mode )
  1826. {
  1827.    GET_CURRENT_CONTEXT(ctx);
  1828.    Node *n;
  1829.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1830.    n = ALLOC_INSTRUCTION( ctx, OPCODE_HINT, 2 );
  1831.    if (n) {
  1832.       n[1].e = target;
  1833.       n[2].e = mode;
  1834.    }
  1835.    if (ctx->ExecuteFlag) {
  1836.       (*ctx->Exec->Hint)( target, mode );
  1837.    }
  1838. }
  1839.  
  1840.  
  1841. static void
  1842. save_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
  1843. {
  1844.    GET_CURRENT_CONTEXT(ctx);
  1845.    Node *n;
  1846.  
  1847.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1848.    n = ALLOC_INSTRUCTION( ctx, OPCODE_HISTOGRAM, 4 );
  1849.    if (n) {
  1850.       n[1].e = target;
  1851.       n[2].i = width;
  1852.       n[3].e = internalFormat;
  1853.       n[4].b = sink;
  1854.    }
  1855.    if (ctx->ExecuteFlag) {
  1856.       (*ctx->Exec->Histogram)( target, width, internalFormat, sink );
  1857.    }
  1858. }
  1859.  
  1860.  
  1861. static void save_IndexMask( GLuint mask )
  1862. {
  1863.    GET_CURRENT_CONTEXT(ctx);
  1864.    Node *n;
  1865.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1866.    n = ALLOC_INSTRUCTION( ctx, OPCODE_INDEX_MASK, 1 );
  1867.    if (n) {
  1868.       n[1].ui = mask;
  1869.    }
  1870.    if (ctx->ExecuteFlag) {
  1871.       (*ctx->Exec->IndexMask)( mask );
  1872.    }
  1873. }
  1874.  
  1875.  
  1876. static void save_InitNames( void )
  1877. {
  1878.    GET_CURRENT_CONTEXT(ctx);
  1879.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1880.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_INIT_NAMES, 0 );
  1881.    if (ctx->ExecuteFlag) {
  1882.       (*ctx->Exec->InitNames)();
  1883.    }
  1884. }
  1885.  
  1886.  
  1887. static void save_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
  1888. {
  1889.    GET_CURRENT_CONTEXT(ctx);
  1890.    Node *n;
  1891.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1892.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT, 6 );
  1893.    if (OPCODE_LIGHT) {
  1894.       GLint i, nParams;
  1895.       n[1].e = light;
  1896.       n[2].e = pname;
  1897.       switch (pname) {
  1898.          case GL_AMBIENT:
  1899.             nParams = 4;
  1900.             break;
  1901.          case GL_DIFFUSE:
  1902.             nParams = 4;
  1903.             break;
  1904.          case GL_SPECULAR:
  1905.             nParams = 4;
  1906.             break;
  1907.          case GL_POSITION:
  1908.             nParams = 4;
  1909.             break;
  1910.          case GL_SPOT_DIRECTION:
  1911.             nParams = 3;
  1912.             break;
  1913.          case GL_SPOT_EXPONENT:
  1914.             nParams = 1;
  1915.             break;
  1916.          case GL_SPOT_CUTOFF:
  1917.             nParams = 1;
  1918.             break;
  1919.          case GL_CONSTANT_ATTENUATION:
  1920.             nParams = 1;
  1921.             break;
  1922.          case GL_LINEAR_ATTENUATION:
  1923.             nParams = 1;
  1924.             break;
  1925.          case GL_QUADRATIC_ATTENUATION:
  1926.             nParams = 1;
  1927.             break;
  1928.          default:
  1929.             nParams = 0;
  1930.       }
  1931.       for (i = 0; i < nParams; i++) {
  1932.      n[3+i].f = params[i];
  1933.       }
  1934.    }
  1935.    if (ctx->ExecuteFlag) {
  1936.       (*ctx->Exec->Lightfv)( light, pname, params );
  1937.    }
  1938. }
  1939.  
  1940.  
  1941. static void save_Lightf( GLenum light, GLenum pname, GLfloat params )
  1942. {
  1943.    save_Lightfv(light, pname, ¶ms);
  1944. }
  1945.  
  1946.  
  1947. static void save_Lightiv( GLenum light, GLenum pname, const GLint *params )
  1948. {
  1949.    GLfloat fparam[4];
  1950.    switch (pname) {
  1951.       case GL_AMBIENT:
  1952.       case GL_DIFFUSE:
  1953.       case GL_SPECULAR:
  1954.          fparam[0] = INT_TO_FLOAT( params[0] );
  1955.          fparam[1] = INT_TO_FLOAT( params[1] );
  1956.          fparam[2] = INT_TO_FLOAT( params[2] );
  1957.          fparam[3] = INT_TO_FLOAT( params[3] );
  1958.          break;
  1959.       case GL_POSITION:
  1960.          fparam[0] = (GLfloat) params[0];
  1961.          fparam[1] = (GLfloat) params[1];
  1962.          fparam[2] = (GLfloat) params[2];
  1963.          fparam[3] = (GLfloat) params[3];
  1964.          break;
  1965.       case GL_SPOT_DIRECTION:
  1966.          fparam[0] = (GLfloat) params[0];
  1967.          fparam[1] = (GLfloat) params[1];
  1968.          fparam[2] = (GLfloat) params[2];
  1969.          break;
  1970.       case GL_SPOT_EXPONENT:
  1971.       case GL_SPOT_CUTOFF:
  1972.       case GL_CONSTANT_ATTENUATION:
  1973.       case GL_LINEAR_ATTENUATION:
  1974.       case GL_QUADRATIC_ATTENUATION:
  1975.          fparam[0] = (GLfloat) params[0];
  1976.          break;
  1977.       default:
  1978.          /* error will be caught later in gl_Lightfv */
  1979.          ;
  1980.    }
  1981.    save_Lightfv( light, pname, fparam );
  1982. }
  1983.  
  1984.  
  1985. static void save_Lighti( GLenum light, GLenum pname, GLint param )
  1986. {
  1987.    save_Lightiv( light, pname, ¶m );
  1988. }
  1989.  
  1990.  
  1991. static void save_LightModelfv( GLenum pname, const GLfloat *params )
  1992. {
  1993.    GET_CURRENT_CONTEXT(ctx);
  1994.    Node *n;
  1995.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  1996.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT_MODEL, 5 );
  1997.    if (n) {
  1998.       n[1].e = pname;
  1999.       n[2].f = params[0];
  2000.       n[3].f = params[1];
  2001.       n[4].f = params[2];
  2002.       n[5].f = params[3];
  2003.    }
  2004.    if (ctx->ExecuteFlag) {
  2005.       (*ctx->Exec->LightModelfv)( pname, params );
  2006.    }
  2007. }
  2008.  
  2009.  
  2010. static void save_LightModelf( GLenum pname, GLfloat param )
  2011. {
  2012.    save_LightModelfv(pname, ¶m);
  2013. }
  2014.  
  2015.  
  2016. static void save_LightModeliv( GLenum pname, const GLint *params )
  2017. {
  2018.    GLfloat fparam[4];
  2019.    switch (pname) {
  2020.       case GL_LIGHT_MODEL_AMBIENT:
  2021.          fparam[0] = INT_TO_FLOAT( params[0] );
  2022.          fparam[1] = INT_TO_FLOAT( params[1] );
  2023.          fparam[2] = INT_TO_FLOAT( params[2] );
  2024.          fparam[3] = INT_TO_FLOAT( params[3] );
  2025.          break;
  2026.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2027.       case GL_LIGHT_MODEL_TWO_SIDE:
  2028.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  2029.          fparam[0] = (GLfloat) params[0];
  2030.          break;
  2031.       default:
  2032.          /* Error will be caught later in gl_LightModelfv */
  2033.          ;
  2034.    }
  2035.    save_LightModelfv(pname, fparam);
  2036. }
  2037.  
  2038.  
  2039. static void save_LightModeli( GLenum pname, GLint param )
  2040. {
  2041.    save_LightModeliv(pname, ¶m);
  2042. }
  2043.  
  2044.  
  2045. static void save_LineStipple( GLint factor, GLushort pattern )
  2046. {
  2047.    GET_CURRENT_CONTEXT(ctx);
  2048.    Node *n;
  2049.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2050.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_STIPPLE, 2 );
  2051.    if (n) {
  2052.       n[1].i = factor;
  2053.       n[2].us = pattern;
  2054.    }
  2055.    if (ctx->ExecuteFlag) {
  2056.       (*ctx->Exec->LineStipple)( factor, pattern );
  2057.    }
  2058. }
  2059.  
  2060.  
  2061. static void save_LineWidth( GLfloat width )
  2062. {
  2063.    GET_CURRENT_CONTEXT(ctx);
  2064.    Node *n;
  2065.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2066.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_WIDTH, 1 );
  2067.    if (n) {
  2068.       n[1].f = width;
  2069.    }
  2070.    if (ctx->ExecuteFlag) {
  2071.       (*ctx->Exec->LineWidth)( width );
  2072.    }
  2073. }
  2074.  
  2075.  
  2076. static void save_ListBase( GLuint base )
  2077. {
  2078.    GET_CURRENT_CONTEXT(ctx);
  2079.    Node *n;
  2080.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2081.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LIST_BASE, 1 );
  2082.    if (n) {
  2083.       n[1].ui = base;
  2084.    }
  2085.    if (ctx->ExecuteFlag) {
  2086.       (*ctx->Exec->ListBase)( base );
  2087.    }
  2088. }
  2089.  
  2090.  
  2091. static void save_LoadIdentity( void )
  2092. {
  2093.    GET_CURRENT_CONTEXT(ctx);
  2094.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2095.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_IDENTITY, 0 );
  2096.    if (ctx->ExecuteFlag) {
  2097.       (*ctx->Exec->LoadIdentity)();
  2098.    }
  2099. }
  2100.  
  2101.  
  2102. static void save_LoadMatrixf( const GLfloat *m )
  2103. {
  2104.    GET_CURRENT_CONTEXT(ctx);
  2105.    Node *n;
  2106.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2107.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_MATRIX, 16 );
  2108.    if (n) {
  2109.       GLuint i;
  2110.       for (i=0;i<16;i++) {
  2111.      n[1+i].f = m[i];
  2112.       }
  2113.    }
  2114.    if (ctx->ExecuteFlag) {
  2115.       (*ctx->Exec->LoadMatrixf)( m );
  2116.    }
  2117. }
  2118.  
  2119.  
  2120. static void save_LoadMatrixd( const GLdouble *m )
  2121. {
  2122.    GLfloat f[16];
  2123.    GLint i;
  2124.    for (i = 0; i < 16; i++) {
  2125.       f[i] = (GLfloat) m[i];
  2126.    }
  2127.    save_LoadMatrixf(f);
  2128. }
  2129.  
  2130.  
  2131. static void save_LoadName( GLuint name )
  2132. {
  2133.    GET_CURRENT_CONTEXT(ctx);
  2134.    Node *n;
  2135.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2136.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_NAME, 1 );
  2137.    if (n) {
  2138.       n[1].ui = name;
  2139.    }
  2140.    if (ctx->ExecuteFlag) {
  2141.       (*ctx->Exec->LoadName)( name );
  2142.    }
  2143. }
  2144.  
  2145.  
  2146. static void save_LogicOp( GLenum opcode )
  2147. {
  2148.    GET_CURRENT_CONTEXT(ctx);
  2149.    Node *n;
  2150.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2151.    n = ALLOC_INSTRUCTION( ctx, OPCODE_LOGIC_OP, 1 );
  2152.    if (n) {
  2153.       n[1].e = opcode;
  2154.    }
  2155.    if (ctx->ExecuteFlag) {
  2156.       (*ctx->Exec->LogicOp)( opcode );
  2157.    }
  2158. }
  2159.  
  2160.  
  2161. static void save_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  2162.                         GLint order, const GLdouble *points)
  2163. {
  2164.    GET_CURRENT_CONTEXT(ctx);
  2165.    Node *n;
  2166.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2167.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
  2168.    if (n) {
  2169.       GLfloat *pnts = _mesa_copy_map_points1d( target, stride, order, points );
  2170.       n[1].e = target;
  2171.       n[2].f = (GLfloat) u1;
  2172.       n[3].f = (GLfloat) u2;
  2173.       n[4].i = _mesa_evaluator_components(target);  /* stride */
  2174.       n[5].i = order;
  2175.       n[6].data = (void *) pnts;
  2176.    }
  2177.    if (ctx->ExecuteFlag) {
  2178.       (*ctx->Exec->Map1d)( target, u1, u2, stride, order, points );
  2179.    }
  2180. }
  2181.  
  2182. static void save_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  2183.                         GLint order, const GLfloat *points)
  2184. {
  2185.    GET_CURRENT_CONTEXT(ctx);
  2186.    Node *n;
  2187.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2188.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
  2189.    if (n) {
  2190.       GLfloat *pnts = _mesa_copy_map_points1f( target, stride, order, points );
  2191.       n[1].e = target;
  2192.       n[2].f = u1;
  2193.       n[3].f = u2;
  2194.       n[4].i = _mesa_evaluator_components(target);  /* stride */
  2195.       n[5].i = order;
  2196.       n[6].data = (void *) pnts;
  2197.    }
  2198.    if (ctx->ExecuteFlag) {
  2199.       (*ctx->Exec->Map1f)( target, u1, u2, stride, order, points );
  2200.    }
  2201. }
  2202.  
  2203.  
  2204. static void save_Map2d( GLenum target,
  2205.                         GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  2206.                         GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  2207.                         const GLdouble *points )
  2208. {
  2209.    GET_CURRENT_CONTEXT(ctx);
  2210.    Node *n;
  2211.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2212.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
  2213.    if (n) {
  2214.       GLfloat *pnts = _mesa_copy_map_points2d( target, ustride, uorder,
  2215.                                             vstride, vorder, points );
  2216.       n[1].e = target;
  2217.       n[2].f = (GLfloat) u1;
  2218.       n[3].f = (GLfloat) u2;
  2219.       n[4].f = (GLfloat) v1;
  2220.       n[5].f = (GLfloat) v2;
  2221.       /* XXX verify these strides are correct */
  2222.       n[6].i = _mesa_evaluator_components(target) * vorder;  /*ustride*/
  2223.       n[7].i = _mesa_evaluator_components(target);           /*vstride*/
  2224.       n[8].i = uorder;
  2225.       n[9].i = vorder;
  2226.       n[10].data = (void *) pnts;
  2227.    }
  2228.    if (ctx->ExecuteFlag) {
  2229.       (*ctx->Exec->Map2d)( target,
  2230.                           u1, u2, ustride, uorder,
  2231.                           v1, v2, vstride, vorder, points );
  2232.    }
  2233. }
  2234.  
  2235.  
  2236. static void save_Map2f( GLenum target,
  2237.                         GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  2238.                         GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  2239.                         const GLfloat *points )
  2240. {
  2241.    GET_CURRENT_CONTEXT(ctx);
  2242.    Node *n;
  2243.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2244.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
  2245.    if (n) {
  2246.       GLfloat *pnts = _mesa_copy_map_points2f( target, ustride, uorder,
  2247.                                             vstride, vorder, points );
  2248.       n[1].e = target;
  2249.       n[2].f = u1;
  2250.       n[3].f = u2;
  2251.       n[4].f = v1;
  2252.       n[5].f = v2;
  2253.       /* XXX verify these strides are correct */
  2254.       n[6].i = _mesa_evaluator_components(target) * vorder;  /*ustride*/
  2255.       n[7].i = _mesa_evaluator_components(target);           /*vstride*/
  2256.       n[8].i = uorder;
  2257.       n[9].i = vorder;
  2258.       n[10].data = (void *) pnts;
  2259.    }
  2260.    if (ctx->ExecuteFlag) {
  2261.       (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
  2262.                           v1, v2, vstride, vorder, points );
  2263.    }
  2264. }
  2265.  
  2266.  
  2267. static void save_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
  2268. {
  2269.    GET_CURRENT_CONTEXT(ctx);
  2270.    Node *n;
  2271.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2272.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID1, 3 );
  2273.    if (n) {
  2274.       n[1].i = un;
  2275.       n[2].f = u1;
  2276.       n[3].f = u2;
  2277.    }
  2278.    if (ctx->ExecuteFlag) {
  2279.       (*ctx->Exec->MapGrid1f)( un, u1, u2 );
  2280.    }
  2281. }
  2282.  
  2283.  
  2284. static void save_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
  2285. {
  2286.    save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
  2287. }
  2288.  
  2289.  
  2290. static void save_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
  2291.                             GLint vn, GLfloat v1, GLfloat v2 )
  2292. {
  2293.    GET_CURRENT_CONTEXT(ctx);
  2294.    Node *n;
  2295.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2296.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID2, 6 );
  2297.    if (n) {
  2298.       n[1].i = un;
  2299.       n[2].f = u1;
  2300.       n[3].f = u2;
  2301.       n[4].i = vn;
  2302.       n[5].f = v1;
  2303.       n[6].f = v2;
  2304.    }
  2305.    if (ctx->ExecuteFlag) {
  2306.       (*ctx->Exec->MapGrid2f)( un, u1, u2, vn, v1, v2 );
  2307.    }
  2308. }
  2309.  
  2310.  
  2311.  
  2312. static void save_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
  2313.                             GLint vn, GLdouble v1, GLdouble v2 )
  2314. {
  2315.    save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2, 
  2316.           vn, (GLfloat) v1, (GLfloat) v2);
  2317. }
  2318.  
  2319.  
  2320. static void save_MatrixMode( GLenum mode )
  2321. {
  2322.    GET_CURRENT_CONTEXT(ctx);
  2323.    Node *n;
  2324.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2325.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MATRIX_MODE, 1 );
  2326.    if (n) {
  2327.       n[1].e = mode;
  2328.    }
  2329.    if (ctx->ExecuteFlag) {
  2330.       (*ctx->Exec->MatrixMode)( mode );
  2331.    }
  2332. }
  2333.  
  2334.  
  2335. static void
  2336. save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
  2337. {
  2338.    GET_CURRENT_CONTEXT(ctx);
  2339.    Node *n;
  2340.  
  2341.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2342.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MIN_MAX, 3 );
  2343.    if (n) {
  2344.       n[1].e = target;
  2345.       n[2].e = internalFormat;
  2346.       n[3].b = sink;
  2347.    }
  2348.    if (ctx->ExecuteFlag) {
  2349.       (*ctx->Exec->Minmax)( target, internalFormat, sink );
  2350.    }
  2351. }
  2352.  
  2353.  
  2354. static void save_MultMatrixf( const GLfloat *m )
  2355. {
  2356.    GET_CURRENT_CONTEXT(ctx);
  2357.    Node *n;
  2358.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2359.    n = ALLOC_INSTRUCTION( ctx, OPCODE_MULT_MATRIX, 16 );
  2360.    if (n) {
  2361.       GLuint i;
  2362.       for (i=0;i<16;i++) {
  2363.      n[1+i].f = m[i];
  2364.       }
  2365.    }
  2366.    if (ctx->ExecuteFlag) {
  2367.       (*ctx->Exec->MultMatrixf)( m );
  2368.    }
  2369. }
  2370.  
  2371.  
  2372. static void save_MultMatrixd( const GLdouble *m )
  2373. {
  2374.    GLfloat f[16];
  2375.    GLint i;
  2376.    for (i = 0; i < 16; i++) {
  2377.       f[i] = (GLfloat) m[i];
  2378.    }
  2379.    save_MultMatrixf(f);
  2380. }
  2381.  
  2382.  
  2383. static void save_NewList( GLuint list, GLenum mode )
  2384. {
  2385.    GET_CURRENT_CONTEXT(ctx);
  2386.    /* It's an error to call this function while building a display list */
  2387.    _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
  2388.    (void) list;
  2389.    (void) mode;
  2390. }
  2391.  
  2392.  
  2393.  
  2394. static void save_Ortho( GLdouble left, GLdouble right,
  2395.                     GLdouble bottom, GLdouble top,
  2396.                     GLdouble nearval, GLdouble farval )
  2397. {
  2398.    GET_CURRENT_CONTEXT(ctx);
  2399.    Node *n;
  2400.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2401.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ORTHO, 6 );
  2402.    if (n) {
  2403.       n[1].f = (GLfloat) left;
  2404.       n[2].f = (GLfloat) right;
  2405.       n[3].f = (GLfloat) bottom;
  2406.       n[4].f = (GLfloat) top;
  2407.       n[5].f = (GLfloat) nearval;
  2408.       n[6].f = (GLfloat) farval;
  2409.    }
  2410.    if (ctx->ExecuteFlag) {
  2411.       (*ctx->Exec->Ortho)( left, right, bottom, top, nearval, farval );
  2412.    }
  2413. }
  2414.  
  2415.  
  2416. static void
  2417. save_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
  2418. {
  2419.    GET_CURRENT_CONTEXT(ctx);
  2420.    Node *n;
  2421.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2422.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_MAP, 3 );
  2423.    if (n) {
  2424.       n[1].e = map;
  2425.       n[2].i = mapsize;
  2426.       n[3].data  = (void *) MALLOC( mapsize * sizeof(GLfloat) );
  2427.       MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
  2428.    }
  2429.    if (ctx->ExecuteFlag) {
  2430.       (*ctx->Exec->PixelMapfv)( map, mapsize, values );
  2431.    }
  2432. }
  2433.  
  2434.  
  2435. static void
  2436. save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
  2437. {
  2438.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  2439.    GLint i;
  2440.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  2441.       for (i=0;i<mapsize;i++) {
  2442.          fvalues[i] = (GLfloat) values[i];
  2443.       }
  2444.    }
  2445.    else {
  2446.       for (i=0;i<mapsize;i++) {
  2447.          fvalues[i] = UINT_TO_FLOAT( values[i] );
  2448.       }
  2449.    }
  2450.    save_PixelMapfv(map, mapsize, fvalues);
  2451. }
  2452.  
  2453.  
  2454. static void
  2455. save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
  2456. {
  2457.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  2458.    GLint i;
  2459.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  2460.       for (i=0;i<mapsize;i++) {
  2461.          fvalues[i] = (GLfloat) values[i];
  2462.       }
  2463.    }
  2464.    else {
  2465.       for (i=0;i<mapsize;i++) {
  2466.          fvalues[i] = USHORT_TO_FLOAT( values[i] );
  2467.       }
  2468.    }
  2469.    save_PixelMapfv(map, mapsize, fvalues);
  2470. }
  2471.  
  2472.  
  2473. static void
  2474. save_PixelTransferf( GLenum pname, GLfloat param )
  2475. {
  2476.    GET_CURRENT_CONTEXT(ctx);
  2477.    Node *n;
  2478.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2479.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TRANSFER, 2 );
  2480.    if (n) {
  2481.       n[1].e = pname;
  2482.       n[2].f = param;
  2483.    }
  2484.    if (ctx->ExecuteFlag) {
  2485.       (*ctx->Exec->PixelTransferf)( pname, param );
  2486.    }
  2487. }
  2488.  
  2489.  
  2490. static void
  2491. save_PixelTransferi( GLenum pname, GLint param )
  2492. {
  2493.    save_PixelTransferf( pname, (GLfloat) param );
  2494. }
  2495.  
  2496.  
  2497. static void
  2498. save_PixelZoom( GLfloat xfactor, GLfloat yfactor )
  2499. {
  2500.    GET_CURRENT_CONTEXT(ctx);
  2501.    Node *n;
  2502.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2503.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_ZOOM, 2 );
  2504.    if (n) {
  2505.       n[1].f = xfactor;
  2506.       n[2].f = yfactor;
  2507.    }
  2508.    if (ctx->ExecuteFlag) {
  2509.       (*ctx->Exec->PixelZoom)( xfactor, yfactor );
  2510.    }
  2511. }
  2512.  
  2513.  
  2514. static void
  2515. save_PointParameterfvEXT( GLenum pname, const GLfloat *params )
  2516. {
  2517.    GET_CURRENT_CONTEXT(ctx);
  2518.    Node *n;
  2519.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2520.    n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_PARAMETERS, 4 );
  2521.    if (n) {
  2522.       n[1].e = pname;
  2523.       n[2].f = params[0];
  2524.       n[3].f = params[1];
  2525.       n[4].f = params[2];
  2526.    }
  2527.    if (ctx->ExecuteFlag) {
  2528.       (*ctx->Exec->PointParameterfvEXT)( pname, params );
  2529.    }
  2530. }
  2531.  
  2532.  
  2533. static void save_PointParameterfEXT( GLenum pname, GLfloat param )
  2534. {
  2535.    save_PointParameterfvEXT(pname, ¶m);
  2536. }
  2537.  
  2538. static void save_PointParameteriNV( GLenum pname, GLint param )
  2539. {
  2540.    GLfloat p = (GLfloat) param;
  2541.    save_PointParameterfvEXT(pname, &p);
  2542. }
  2543.  
  2544. static void save_PointParameterivNV( GLenum pname, const GLint *param )
  2545. {
  2546.    GLfloat p = (GLfloat) param[0];
  2547.    save_PointParameterfvEXT(pname, &p);
  2548. }
  2549.  
  2550.  
  2551. static void save_PointSize( GLfloat size )
  2552. {
  2553.    GET_CURRENT_CONTEXT(ctx);
  2554.    Node *n;
  2555.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2556.    n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_SIZE, 1 );
  2557.    if (n) {
  2558.       n[1].f = size;
  2559.    }
  2560.    if (ctx->ExecuteFlag) {
  2561.       (*ctx->Exec->PointSize)( size );
  2562.    }
  2563. }
  2564.  
  2565.  
  2566. static void save_PolygonMode( GLenum face, GLenum mode )
  2567. {
  2568.    GET_CURRENT_CONTEXT(ctx);
  2569.    Node *n;
  2570.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2571.    n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_MODE, 2 );
  2572.    if (n) {
  2573.       n[1].e = face;
  2574.       n[2].e = mode;
  2575.    }
  2576.    if (ctx->ExecuteFlag) {
  2577.       (*ctx->Exec->PolygonMode)( face, mode );
  2578.    }
  2579. }
  2580.  
  2581.  
  2582. /*
  2583.  * Polygon stipple must have been upacked already!
  2584.  */
  2585. static void save_PolygonStipple( const GLubyte *pattern )
  2586. {
  2587.    GET_CURRENT_CONTEXT(ctx);
  2588.    Node *n;
  2589.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2590.    n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_STIPPLE, 1 );
  2591.    if (n) {
  2592.       void *data;
  2593.       n[1].data = MALLOC( 32 * 4 );
  2594.       data = n[1].data;   /* This needed for Acorn compiler */
  2595.       MEMCPY( data, pattern, 32 * 4 );
  2596.    }
  2597.    if (ctx->ExecuteFlag) {
  2598.       (*ctx->Exec->PolygonStipple)( (GLubyte*) pattern );
  2599.    }
  2600. }
  2601.  
  2602.  
  2603. static void save_PolygonOffset( GLfloat factor, GLfloat units )
  2604. {
  2605.    GET_CURRENT_CONTEXT(ctx);
  2606.    Node *n;
  2607.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2608.    n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_OFFSET, 2 );
  2609.    if (n) {
  2610.       n[1].f = factor;
  2611.       n[2].f = units;
  2612.    }
  2613.    if (ctx->ExecuteFlag) {
  2614.       (*ctx->Exec->PolygonOffset)( factor, units );
  2615.    }
  2616. }
  2617.  
  2618.  
  2619. static void save_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
  2620. {
  2621.    GET_CURRENT_CONTEXT(ctx);
  2622.    save_PolygonOffset(factor, ctx->DepthMaxF * bias);
  2623. }
  2624.  
  2625.  
  2626. static void save_PopAttrib( void )
  2627. {
  2628.    GET_CURRENT_CONTEXT(ctx);
  2629.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2630.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_ATTRIB, 0 );
  2631.    if (ctx->ExecuteFlag) {
  2632.       (*ctx->Exec->PopAttrib)();
  2633.    }
  2634. }
  2635.  
  2636.  
  2637. static void save_PopMatrix( void )
  2638. {
  2639.    GET_CURRENT_CONTEXT(ctx);
  2640.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2641.    FLUSH_CURRENT(ctx, 0);
  2642.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_MATRIX, 0 );
  2643.    if (ctx->ExecuteFlag) {
  2644.       (*ctx->Exec->PopMatrix)();
  2645.    }
  2646. }
  2647.  
  2648.  
  2649. static void save_PopName( void )
  2650. {
  2651.    GET_CURRENT_CONTEXT(ctx);
  2652.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2653.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_NAME, 0 );
  2654.    if (ctx->ExecuteFlag) {
  2655.       (*ctx->Exec->PopName)();
  2656.    }
  2657. }
  2658.  
  2659.  
  2660. static void save_PrioritizeTextures( GLsizei num, const GLuint *textures,
  2661.                                      const GLclampf *priorities )
  2662. {
  2663.    GET_CURRENT_CONTEXT(ctx);
  2664.    GLint i;
  2665.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2666.  
  2667.    for (i=0;i<num;i++) {
  2668.       Node *n;
  2669.       n = ALLOC_INSTRUCTION( ctx,  OPCODE_PRIORITIZE_TEXTURE, 2 );
  2670.       if (n) {
  2671.          n[1].ui = textures[i];
  2672.          n[2].f = priorities[i];
  2673.       }
  2674.    }
  2675.    if (ctx->ExecuteFlag) {
  2676.       (*ctx->Exec->PrioritizeTextures)( num, textures, priorities );
  2677.    }
  2678. }
  2679.  
  2680.  
  2681. static void save_PushAttrib( GLbitfield mask )
  2682. {
  2683.    GET_CURRENT_CONTEXT(ctx);
  2684.    Node *n;
  2685.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2686.    FLUSH_CURRENT(ctx, 0);
  2687.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_ATTRIB, 1 );
  2688.    if (n) {
  2689.       n[1].bf = mask;
  2690.    }
  2691.    if (ctx->ExecuteFlag) {
  2692.       (*ctx->Exec->PushAttrib)( mask );
  2693.    }
  2694. }
  2695.  
  2696.  
  2697. static void save_PushMatrix( void )
  2698. {
  2699.    GET_CURRENT_CONTEXT(ctx);
  2700.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2701.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_MATRIX, 0 );
  2702.    if (ctx->ExecuteFlag) {
  2703.       (*ctx->Exec->PushMatrix)();
  2704.    }
  2705. }
  2706.  
  2707.  
  2708. static void save_PushName( GLuint name )
  2709. {
  2710.    GET_CURRENT_CONTEXT(ctx);
  2711.    Node *n;
  2712.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2713.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_NAME, 1 );
  2714.    if (n) {
  2715.       n[1].ui = name;
  2716.    }
  2717.    if (ctx->ExecuteFlag) {
  2718.       (*ctx->Exec->PushName)( name );
  2719.    }
  2720. }
  2721.  
  2722.  
  2723. static void save_RasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  2724. {
  2725.    GET_CURRENT_CONTEXT(ctx);
  2726.    Node *n;
  2727.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2728.    FLUSH_CURRENT(ctx, 0);
  2729.    n = ALLOC_INSTRUCTION( ctx, OPCODE_RASTER_POS, 4 );
  2730.    if (n) {
  2731.       n[1].f = x;
  2732.       n[2].f = y;
  2733.       n[3].f = z;
  2734.       n[4].f = w;
  2735.    }
  2736.    if (ctx->ExecuteFlag) {
  2737.       (*ctx->Exec->RasterPos4f)( x, y, z, w );
  2738.    }
  2739. }
  2740.  
  2741. static void save_RasterPos2d(GLdouble x, GLdouble y)
  2742. {
  2743.    save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
  2744. }
  2745.  
  2746. static void save_RasterPos2f(GLfloat x, GLfloat y)
  2747. {
  2748.    save_RasterPos4f(x, y, 0.0F, 1.0F);
  2749. }
  2750.  
  2751. static void save_RasterPos2i(GLint x, GLint y)
  2752. {
  2753.    save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
  2754. }
  2755.  
  2756. static void save_RasterPos2s(GLshort x, GLshort y)
  2757. {
  2758.    save_RasterPos4f(x, y, 0.0F, 1.0F);
  2759. }
  2760.  
  2761. static void save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
  2762. {
  2763.    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
  2764. }
  2765.  
  2766. static void save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
  2767. {
  2768.    save_RasterPos4f(x, y, z, 1.0F);
  2769. }
  2770.  
  2771. static void save_RasterPos3i(GLint x, GLint y, GLint z)
  2772. {
  2773.    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
  2774. }
  2775.  
  2776. static void save_RasterPos3s(GLshort x, GLshort y, GLshort z)
  2777. {
  2778.    save_RasterPos4f(x, y, z, 1.0F);
  2779. }
  2780.  
  2781. static void save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  2782. {
  2783.    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
  2784. }
  2785.  
  2786. static void save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
  2787. {
  2788.    save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
  2789. }
  2790.  
  2791. static void save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
  2792. {
  2793.    save_RasterPos4f(x, y, z, w);
  2794. }
  2795.  
  2796. static void save_RasterPos2dv(const GLdouble *v)
  2797. {
  2798.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
  2799. }
  2800.  
  2801. static void save_RasterPos2fv(const GLfloat *v)
  2802. {
  2803.    save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
  2804. }
  2805.  
  2806. static void save_RasterPos2iv(const GLint *v)
  2807. {
  2808.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
  2809. }
  2810.  
  2811. static void save_RasterPos2sv(const GLshort *v)
  2812. {
  2813.    save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
  2814. }
  2815.  
  2816. static void save_RasterPos3dv(const GLdouble *v)
  2817. {
  2818.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
  2819. }
  2820.  
  2821. static void save_RasterPos3fv(const GLfloat *v)
  2822. {
  2823.    save_RasterPos4f(v[0], v[1], v[2], 1.0F);
  2824. }
  2825.  
  2826. static void save_RasterPos3iv(const GLint *v)
  2827. {
  2828.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
  2829. }
  2830.  
  2831. static void save_RasterPos3sv(const GLshort *v)
  2832. {
  2833.    save_RasterPos4f(v[0], v[1], v[2], 1.0F);
  2834. }
  2835.  
  2836. static void save_RasterPos4dv(const GLdouble *v)
  2837. {
  2838.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
  2839.             (GLfloat) v[2], (GLfloat) v[3]);
  2840. }
  2841.  
  2842. static void save_RasterPos4fv(const GLfloat *v)
  2843. {
  2844.    save_RasterPos4f(v[0], v[1], v[2], v[3]);
  2845. }
  2846.  
  2847. static void save_RasterPos4iv(const GLint *v)
  2848. {
  2849.    save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
  2850.             (GLfloat) v[2], (GLfloat) v[3]);
  2851. }
  2852.  
  2853. static void save_RasterPos4sv(const GLshort *v)
  2854. {
  2855.    save_RasterPos4f(v[0], v[1], v[2], v[3]);
  2856. }
  2857.  
  2858.  
  2859. static void save_PassThrough( GLfloat token )
  2860. {
  2861.    GET_CURRENT_CONTEXT(ctx);
  2862.    Node *n;
  2863.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2864.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PASSTHROUGH, 1 );
  2865.    if (n) {
  2866.       n[1].f = token;
  2867.    }
  2868.    if (ctx->ExecuteFlag) {
  2869.       (*ctx->Exec->PassThrough)( token );
  2870.    }
  2871. }
  2872.  
  2873.  
  2874. static void save_ReadBuffer( GLenum mode )
  2875. {
  2876.    GET_CURRENT_CONTEXT(ctx);
  2877.    Node *n;
  2878.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2879.    n = ALLOC_INSTRUCTION( ctx, OPCODE_READ_BUFFER, 1 );
  2880.    if (n) {
  2881.       n[1].e = mode;
  2882.    }
  2883.    if (ctx->ExecuteFlag) {
  2884.       (*ctx->Exec->ReadBuffer)( mode );
  2885.    }
  2886. }
  2887.  
  2888.  
  2889. static void
  2890. save_ResetHistogram(GLenum target)
  2891. {
  2892.    GET_CURRENT_CONTEXT(ctx);
  2893.    Node *n;
  2894.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2895.    n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_HISTOGRAM, 1 );
  2896.    if (n) {
  2897.       n[1].e = target;
  2898.    }
  2899.    if (ctx->ExecuteFlag) {
  2900.       (*ctx->Exec->ResetHistogram)( target );
  2901.    }
  2902. }
  2903.  
  2904.  
  2905. static void
  2906. save_ResetMinmax(GLenum target)
  2907. {
  2908.    GET_CURRENT_CONTEXT(ctx);
  2909.    Node *n;
  2910.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2911.    n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_MIN_MAX, 1 );
  2912.    if (n) {
  2913.       n[1].e = target;
  2914.    }
  2915.    if (ctx->ExecuteFlag) {
  2916.       (*ctx->Exec->ResetMinmax)( target );
  2917.    }
  2918. }
  2919.  
  2920.  
  2921. static void save_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
  2922. {
  2923.    GET_CURRENT_CONTEXT(ctx);
  2924.    Node *n;
  2925.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2926.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ROTATE, 4 );
  2927.    if (n) {
  2928.       n[1].f = angle;
  2929.       n[2].f = x;
  2930.       n[3].f = y;
  2931.       n[4].f = z;
  2932.    }
  2933.    if (ctx->ExecuteFlag) {
  2934.       (*ctx->Exec->Rotatef)( angle, x, y, z );
  2935.    }
  2936. }
  2937.  
  2938.  
  2939. static void save_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
  2940. {
  2941.    save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
  2942. }
  2943.  
  2944.  
  2945. static void save_Scalef( GLfloat x, GLfloat y, GLfloat z )
  2946. {
  2947.    GET_CURRENT_CONTEXT(ctx);
  2948.    Node *n;
  2949.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2950.    n = ALLOC_INSTRUCTION( ctx, OPCODE_SCALE, 3 );
  2951.    if (n) {
  2952.       n[1].f = x;
  2953.       n[2].f = y;
  2954.       n[3].f = z;
  2955.    }
  2956.    if (ctx->ExecuteFlag) {
  2957.       (*ctx->Exec->Scalef)( x, y, z );
  2958.    }
  2959. }
  2960.  
  2961.  
  2962. static void save_Scaled( GLdouble x, GLdouble y, GLdouble z )
  2963. {
  2964.    save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
  2965. }
  2966.  
  2967.  
  2968. static void save_Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
  2969. {
  2970.    GET_CURRENT_CONTEXT(ctx);
  2971.    Node *n;
  2972.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2973.    n = ALLOC_INSTRUCTION( ctx, OPCODE_SCISSOR, 4 );
  2974.    if (n) {
  2975.       n[1].i = x;
  2976.       n[2].i = y;
  2977.       n[3].i = width;
  2978.       n[4].i = height;
  2979.    }
  2980.    if (ctx->ExecuteFlag) {
  2981.       (*ctx->Exec->Scissor)( x, y, width, height );
  2982.    }
  2983. }
  2984.  
  2985.  
  2986. static void save_ShadeModel( GLenum mode )
  2987. {
  2988.    GET_CURRENT_CONTEXT(ctx);
  2989.    Node *n;
  2990.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  2991.    n = ALLOC_INSTRUCTION( ctx, OPCODE_SHADE_MODEL, 1 );
  2992.    if (n) {
  2993.       n[1].e = mode;
  2994.    }
  2995.    if (ctx->ExecuteFlag) {
  2996.       (*ctx->Exec->ShadeModel)( mode );
  2997.    }
  2998. }
  2999.  
  3000.  
  3001. static void save_StencilFunc( GLenum func, GLint ref, GLuint mask )
  3002. {
  3003.    GET_CURRENT_CONTEXT(ctx);
  3004.    Node *n;
  3005.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3006.    n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_FUNC, 3 );
  3007.    if (n) {
  3008.       n[1].e = func;
  3009.       n[2].i = ref;
  3010.       n[3].ui = mask;
  3011.    }
  3012.    if (ctx->ExecuteFlag) {
  3013.       (*ctx->Exec->StencilFunc)( func, ref, mask );
  3014.    }
  3015. }
  3016.  
  3017.  
  3018. static void save_StencilMask( GLuint mask )
  3019. {
  3020.    GET_CURRENT_CONTEXT(ctx);
  3021.    Node *n;
  3022.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3023.    n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_MASK, 1 );
  3024.    if (n) {
  3025.       n[1].ui = mask;
  3026.    }
  3027.    if (ctx->ExecuteFlag) {
  3028.       (*ctx->Exec->StencilMask)( mask );
  3029.    }
  3030. }
  3031.  
  3032.  
  3033. static void save_StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
  3034. {
  3035.    GET_CURRENT_CONTEXT(ctx);
  3036.    Node *n;
  3037.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3038.    n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_OP, 3 );
  3039.    if (n) {
  3040.       n[1].e = fail;
  3041.       n[2].e = zfail;
  3042.       n[3].e = zpass;
  3043.    }
  3044.    if (ctx->ExecuteFlag) {
  3045.       (*ctx->Exec->StencilOp)( fail, zfail, zpass );
  3046.    }
  3047. }
  3048.  
  3049.  
  3050. static void save_TexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
  3051. {
  3052.    GET_CURRENT_CONTEXT(ctx);
  3053.    Node *n;
  3054.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3055.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXENV, 6 );
  3056.    if (n) {
  3057.       n[1].e = target;
  3058.       n[2].e = pname;
  3059.       n[3].f = params[0];
  3060.       n[4].f = params[1];
  3061.       n[5].f = params[2];
  3062.       n[6].f = params[3];
  3063.    }
  3064.    if (ctx->ExecuteFlag) {
  3065.       (*ctx->Exec->TexEnvfv)( target, pname, params );
  3066.    }
  3067. }
  3068.  
  3069.  
  3070. static void save_TexEnvf( GLenum target, GLenum pname, GLfloat param )
  3071. {
  3072.    save_TexEnvfv( target, pname, ¶m );
  3073. }
  3074.  
  3075.  
  3076. static void save_TexEnvi( GLenum target, GLenum pname, GLint param )
  3077. {
  3078.    GLfloat p[4];
  3079.    p[0] = (GLfloat) param;
  3080.    p[1] = p[2] = p[3] = 0.0;
  3081.    save_TexEnvfv( target, pname, p );
  3082. }
  3083.  
  3084.  
  3085. static void save_TexEnviv( GLenum target, GLenum pname, const GLint *param )
  3086. {
  3087.    GLfloat p[4];
  3088.    p[0] = INT_TO_FLOAT( param[0] );
  3089.    p[1] = INT_TO_FLOAT( param[1] );
  3090.    p[2] = INT_TO_FLOAT( param[2] );
  3091.    p[3] = INT_TO_FLOAT( param[3] );
  3092.    save_TexEnvfv( target, pname, p );
  3093. }
  3094.  
  3095.  
  3096. static void save_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
  3097. {
  3098.    GET_CURRENT_CONTEXT(ctx);
  3099.    Node *n;
  3100.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3101.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXGEN, 6 );
  3102.    if (n) {
  3103.       n[1].e = coord;
  3104.       n[2].e = pname;
  3105.       n[3].f = params[0];
  3106.       n[4].f = params[1];
  3107.       n[5].f = params[2];
  3108.       n[6].f = params[3];
  3109.    }
  3110.    if (ctx->ExecuteFlag) {
  3111.       (*ctx->Exec->TexGenfv)( coord, pname, params );
  3112.    }
  3113. }
  3114.  
  3115.  
  3116. static void save_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
  3117. {
  3118.    GLfloat p[4];
  3119.    p[0] = (GLfloat) params[0];
  3120.    p[1] = (GLfloat) params[1];
  3121.    p[2] = (GLfloat) params[2];
  3122.    p[3] = (GLfloat) params[3];
  3123.    save_TexGenfv(coord, pname, p);
  3124. }
  3125.  
  3126.  
  3127. static void save_TexGend(GLenum coord, GLenum pname, GLdouble param )
  3128. {
  3129.    GLfloat p = (GLfloat) param;
  3130.    save_TexGenfv( coord, pname, &p );
  3131. }
  3132.  
  3133.  
  3134. static void save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
  3135. {
  3136.    GLfloat p[4];
  3137.    p[0] = (GLfloat) params[0];
  3138.    p[1] = (GLfloat) params[1];
  3139.    p[2] = (GLfloat) params[2];
  3140.    p[3] = (GLfloat) params[3];
  3141.    save_TexGenfv( coord, pname, p );
  3142. }
  3143.  
  3144.  
  3145. static void save_TexGenf( GLenum coord, GLenum pname, GLfloat param )
  3146. {
  3147.    save_TexGenfv(coord, pname, ¶m);
  3148. }
  3149.  
  3150.  
  3151. static void save_TexGeni( GLenum coord, GLenum pname, GLint param )
  3152. {
  3153.    save_TexGeniv( coord, pname, ¶m );
  3154. }
  3155.  
  3156.  
  3157. static void save_TexParameterfv( GLenum target,
  3158.                              GLenum pname, const GLfloat *params )
  3159. {
  3160.    GET_CURRENT_CONTEXT(ctx);
  3161.    Node *n;
  3162.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3163.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXPARAMETER, 6 );
  3164.    if (n) {
  3165.       n[1].e = target;
  3166.       n[2].e = pname;
  3167.       n[3].f = params[0];
  3168.       n[4].f = params[1];
  3169.       n[5].f = params[2];
  3170.       n[6].f = params[3];
  3171.    }
  3172.    if (ctx->ExecuteFlag) {
  3173.       (*ctx->Exec->TexParameterfv)( target, pname, params );
  3174.    }
  3175. }
  3176.  
  3177.  
  3178. static void save_TexParameterf( GLenum target, GLenum pname, GLfloat param )
  3179. {
  3180.    save_TexParameterfv(target, pname, ¶m);
  3181. }
  3182.  
  3183.  
  3184. static void save_TexParameteri( GLenum target, GLenum pname, GLint param )
  3185. {
  3186.    GLfloat fparam[4];
  3187.    fparam[0] = (GLfloat) param;
  3188.    fparam[1] = fparam[2] = fparam[3] = 0.0;
  3189.    save_TexParameterfv(target, pname, fparam);
  3190. }
  3191.  
  3192.  
  3193. static void save_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
  3194. {
  3195.    GLfloat fparam[4];
  3196.    fparam[0] = (GLfloat) params[0];
  3197.    fparam[1] = fparam[2] = fparam[3] = 0.0;
  3198.    save_TexParameterfv(target, pname, fparam);
  3199. }
  3200.  
  3201.  
  3202. static void save_TexImage1D( GLenum target,
  3203.                              GLint level, GLint components,
  3204.                              GLsizei width, GLint border,
  3205.                              GLenum format, GLenum type,
  3206.                              const GLvoid *pixels )
  3207. {
  3208.    GET_CURRENT_CONTEXT(ctx);
  3209.    if (target == GL_PROXY_TEXTURE_1D) {
  3210.       /* don't compile, execute immediately */
  3211.       (*ctx->Exec->TexImage1D)( target, level, components, width,
  3212.                                border, format, type, pixels );
  3213.    }
  3214.    else {
  3215.       GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
  3216.                                          pixels, &ctx->Unpack);
  3217.       Node *n;
  3218.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3219.       n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE1D, 8 );
  3220.       if (n) {
  3221.          n[1].e = target;
  3222.          n[2].i = level;
  3223.          n[3].i = components;
  3224.          n[4].i = (GLint) width;
  3225.          n[5].i = border;
  3226.          n[6].e = format;
  3227.          n[7].e = type;
  3228.          n[8].data = image;
  3229.       }
  3230.       else if (image) {
  3231.          FREE(image);
  3232.       }
  3233.       if (ctx->ExecuteFlag) {
  3234.          (*ctx->Exec->TexImage1D)( target, level, components, width,
  3235.                                   border, format, type, pixels );
  3236.       }
  3237.    }
  3238. }
  3239.  
  3240.  
  3241. static void save_TexImage2D( GLenum target,
  3242.                              GLint level, GLint components,
  3243.                              GLsizei width, GLsizei height, GLint border,
  3244.                              GLenum format, GLenum type,
  3245.                              const GLvoid *pixels)
  3246. {
  3247.    GET_CURRENT_CONTEXT(ctx);
  3248.    if (target == GL_PROXY_TEXTURE_2D) {
  3249.       /* don't compile, execute immediately */
  3250.       (*ctx->Exec->TexImage2D)( target, level, components, width,
  3251.                                height, border, format, type, pixels );
  3252.    }
  3253.    else {
  3254.       GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
  3255.                                          pixels, &ctx->Unpack);
  3256.       Node *n;
  3257.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3258.       n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE2D, 9 );
  3259.       if (n) {
  3260.          n[1].e = target;
  3261.          n[2].i = level;
  3262.          n[3].i = components;
  3263.          n[4].i = (GLint) width;
  3264.          n[5].i = (GLint) height;
  3265.          n[6].i = border;
  3266.          n[7].e = format;
  3267.          n[8].e = type;
  3268.          n[9].data = image;
  3269.       }
  3270.       else if (image) {
  3271.          FREE(image);
  3272.       }
  3273.       if (ctx->ExecuteFlag) {
  3274.          (*ctx->Exec->TexImage2D)( target, level, components, width,
  3275.                                   height, border, format, type, pixels );
  3276.       }
  3277.    }
  3278. }
  3279.  
  3280.  
  3281. static void save_TexImage3D( GLenum target,
  3282.                              GLint level, GLint internalFormat,
  3283.                              GLsizei width, GLsizei height, GLsizei depth,
  3284.                              GLint border,
  3285.                              GLenum format, GLenum type,
  3286.                              const GLvoid *pixels )
  3287. {
  3288.    GET_CURRENT_CONTEXT(ctx);
  3289.    if (target == GL_PROXY_TEXTURE_3D) {
  3290.       /* don't compile, execute immediately */
  3291.       (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
  3292.                                height, depth, border, format, type, pixels );
  3293.    }
  3294.    else {
  3295.       Node *n;
  3296.       GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
  3297.                                          pixels, &ctx->Unpack);
  3298.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3299.       n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE3D, 10 );
  3300.       if (n) {
  3301.          n[1].e = target;
  3302.          n[2].i = level;
  3303.          n[3].i = (GLint) internalFormat;
  3304.          n[4].i = (GLint) width;
  3305.          n[5].i = (GLint) height;
  3306.          n[6].i = (GLint) depth;
  3307.          n[7].i = border;
  3308.          n[8].e = format;
  3309.          n[9].e = type;
  3310.          n[10].data = image;
  3311.       }
  3312.       else if (image) {
  3313.          FREE(image);
  3314.       }
  3315.       if (ctx->ExecuteFlag) {
  3316.          (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
  3317.                                 height, depth, border, format, type, pixels );
  3318.       }
  3319.    }
  3320. }
  3321.  
  3322.  
  3323. static void save_TexSubImage1D( GLenum target, GLint level, GLint xoffset,
  3324.                                 GLsizei width, GLenum format, GLenum type,
  3325.                                 const GLvoid *pixels )
  3326. {
  3327.    GET_CURRENT_CONTEXT(ctx);
  3328.    Node *n;
  3329.    GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
  3330.                                       pixels, &ctx->Unpack);
  3331.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3332.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 );
  3333.    if (n) {
  3334.       n[1].e = target;
  3335.       n[2].i = level;
  3336.       n[3].i = xoffset;
  3337.       n[4].i = (GLint) width;
  3338.       n[5].e = format;
  3339.       n[6].e = type;
  3340.       n[7].data = image;
  3341.    }
  3342.    else if (image) {
  3343.       FREE(image);
  3344.    }
  3345.    if (ctx->ExecuteFlag) {
  3346.       (*ctx->Exec->TexSubImage1D)( target, level, xoffset, width,
  3347.                                   format, type, pixels );
  3348.    }
  3349. }
  3350.  
  3351.  
  3352. static void save_TexSubImage2D( GLenum target, GLint level,
  3353.                                 GLint xoffset, GLint yoffset,
  3354.                                 GLsizei width, GLsizei height,
  3355.                                 GLenum format, GLenum type,
  3356.                                 const GLvoid *pixels )
  3357. {
  3358.    GET_CURRENT_CONTEXT(ctx);
  3359.    Node *n;
  3360.    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
  3361.                                       pixels, &ctx->Unpack);
  3362.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3363.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 );
  3364.    if (n) {
  3365.       n[1].e = target;
  3366.       n[2].i = level;
  3367.       n[3].i = xoffset;
  3368.       n[4].i = yoffset;
  3369.       n[5].i = (GLint) width;
  3370.       n[6].i = (GLint) height;
  3371.       n[7].e = format;
  3372.       n[8].e = type;
  3373.       n[9].data = image;
  3374.    }
  3375.    else if (image) {
  3376.       FREE(image);
  3377.    }
  3378.    if (ctx->ExecuteFlag) {
  3379.       (*ctx->Exec->TexSubImage2D)( target, level, xoffset, yoffset,
  3380.                            width, height, format, type, pixels );
  3381.    }
  3382. }
  3383.  
  3384.  
  3385. static void save_TexSubImage3D( GLenum target, GLint level,
  3386.                                 GLint xoffset, GLint yoffset,GLint zoffset,
  3387.                                 GLsizei width, GLsizei height, GLsizei depth,
  3388.                                 GLenum format, GLenum type,
  3389.                                 const GLvoid *pixels )
  3390. {
  3391.    GET_CURRENT_CONTEXT(ctx);
  3392.    Node *n;
  3393.    GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
  3394.                                       pixels, &ctx->Unpack);
  3395.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3396.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 );
  3397.    if (n) {
  3398.       n[1].e = target;
  3399.       n[2].i = level;
  3400.       n[3].i = xoffset;
  3401.       n[4].i = yoffset;
  3402.       n[5].i = zoffset;
  3403.       n[6].i = (GLint) width;
  3404.       n[7].i = (GLint) height;
  3405.       n[8].i = (GLint) depth;
  3406.       n[9].e = format;
  3407.       n[10].e = type;
  3408.       n[11].data = image;
  3409.    }
  3410.    else if (image) {
  3411.       FREE(image);
  3412.    }
  3413.    if (ctx->ExecuteFlag) {
  3414.       (*ctx->Exec->TexSubImage3D)( target, level,
  3415.                                   xoffset, yoffset, zoffset,
  3416.                                   width, height, depth, format, type, pixels );
  3417.    }
  3418. }
  3419.  
  3420.  
  3421. static void save_Translatef( GLfloat x, GLfloat y, GLfloat z )
  3422. {
  3423.    GET_CURRENT_CONTEXT(ctx);
  3424.    Node *n;
  3425.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3426.    n = ALLOC_INSTRUCTION( ctx,  OPCODE_TRANSLATE, 3 );
  3427.    if (n) {
  3428.       n[1].f = x;
  3429.       n[2].f = y;
  3430.       n[3].f = z;
  3431.    }
  3432.    if (ctx->ExecuteFlag) {
  3433.       (*ctx->Exec->Translatef)( x, y, z );
  3434.    }
  3435. }
  3436.  
  3437.  
  3438. static void save_Translated( GLdouble x, GLdouble y, GLdouble z )
  3439. {
  3440.    save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
  3441. }
  3442.  
  3443.  
  3444.  
  3445. static void save_Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
  3446. {
  3447.    GET_CURRENT_CONTEXT(ctx);
  3448.    Node *n;
  3449.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3450.    n = ALLOC_INSTRUCTION( ctx,  OPCODE_VIEWPORT, 4 );
  3451.    if (n) {
  3452.       n[1].i = x;
  3453.       n[2].i = y;
  3454.       n[3].i = (GLint) width;
  3455.       n[4].i = (GLint) height;
  3456.    }
  3457.    if (ctx->ExecuteFlag) {
  3458.       (*ctx->Exec->Viewport)( x, y, width, height );
  3459.    }
  3460. }
  3461.  
  3462.  
  3463. static void save_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  3464. {
  3465.    GET_CURRENT_CONTEXT(ctx);
  3466.    Node *n;
  3467.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3468.    FLUSH_CURRENT(ctx, 0);
  3469.    n = ALLOC_INSTRUCTION( ctx,  OPCODE_WINDOW_POS, 4 );
  3470.    if (n) {
  3471.       n[1].f = x;
  3472.       n[2].f = y;
  3473.       n[3].f = z;
  3474.       n[4].f = w;
  3475.    }
  3476.    if (ctx->ExecuteFlag) {
  3477.       (*ctx->Exec->WindowPos4fMESA)( x, y, z, w );
  3478.    }
  3479. }
  3480.  
  3481. static void save_WindowPos2dMESA(GLdouble x, GLdouble y)
  3482. {
  3483.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
  3484. }
  3485.  
  3486. static void save_WindowPos2fMESA(GLfloat x, GLfloat y)
  3487. {
  3488.    save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
  3489. }
  3490.  
  3491. static void save_WindowPos2iMESA(GLint x, GLint y)
  3492. {
  3493.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
  3494. }
  3495.  
  3496. static void save_WindowPos2sMESA(GLshort x, GLshort y)
  3497. {
  3498.    save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
  3499. }
  3500.  
  3501. static void save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
  3502. {
  3503.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
  3504. }
  3505.  
  3506. static void save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
  3507. {
  3508.    save_WindowPos4fMESA(x, y, z, 1.0F);
  3509. }
  3510.  
  3511. static void save_WindowPos3iMESA(GLint x, GLint y, GLint z)
  3512. {
  3513.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
  3514. }
  3515.  
  3516. static void save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
  3517. {
  3518.    save_WindowPos4fMESA(x, y, z, 1.0F);
  3519. }
  3520.  
  3521. static void save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  3522. {
  3523.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
  3524. }
  3525.  
  3526. static void save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
  3527. {
  3528.    save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
  3529. }
  3530.  
  3531. static void save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
  3532. {
  3533.    save_WindowPos4fMESA(x, y, z, w);
  3534. }
  3535.  
  3536. static void save_WindowPos2dvMESA(const GLdouble *v)
  3537. {
  3538.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
  3539. }
  3540.  
  3541. static void save_WindowPos2fvMESA(const GLfloat *v)
  3542. {
  3543.    save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
  3544. }
  3545.  
  3546. static void save_WindowPos2ivMESA(const GLint *v)
  3547. {
  3548.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
  3549. }
  3550.  
  3551. static void save_WindowPos2svMESA(const GLshort *v)
  3552. {
  3553.    save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
  3554. }
  3555.  
  3556. static void save_WindowPos3dvMESA(const GLdouble *v)
  3557. {
  3558.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
  3559. }
  3560.  
  3561. static void save_WindowPos3fvMESA(const GLfloat *v)
  3562. {
  3563.    save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
  3564. }
  3565.  
  3566. static void save_WindowPos3ivMESA(const GLint *v)
  3567. {
  3568.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
  3569. }
  3570.  
  3571. static void save_WindowPos3svMESA(const GLshort *v)
  3572. {
  3573.    save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
  3574. }
  3575.  
  3576. static void save_WindowPos4dvMESA(const GLdouble *v)
  3577. {
  3578.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
  3579.             (GLfloat) v[2], (GLfloat) v[3]);
  3580. }
  3581.  
  3582. static void save_WindowPos4fvMESA(const GLfloat *v)
  3583. {
  3584.    save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
  3585. }
  3586.  
  3587. static void save_WindowPos4ivMESA(const GLint *v)
  3588. {
  3589.    save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
  3590.             (GLfloat) v[2], (GLfloat) v[3]);
  3591. }
  3592.  
  3593. static void save_WindowPos4svMESA(const GLshort *v)
  3594. {
  3595.    save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
  3596. }
  3597.  
  3598.  
  3599.  
  3600. /* GL_ARB_multitexture */
  3601. static void save_ActiveTextureARB( GLenum target )
  3602. {
  3603.    GET_CURRENT_CONTEXT(ctx);
  3604.    Node *n;
  3605.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3606.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_TEXTURE, 1 );
  3607.    if (n) {
  3608.       n[1].e = target;
  3609.    }
  3610.    if (ctx->ExecuteFlag) {
  3611.       (*ctx->Exec->ActiveTextureARB)( target );
  3612.    }
  3613. }
  3614.  
  3615.  
  3616. /* GL_ARB_transpose_matrix */
  3617.  
  3618. static void save_LoadTransposeMatrixdARB( const GLdouble m[16] )
  3619. {
  3620.    GLfloat tm[16];
  3621.    _math_transposefd(tm, m);
  3622.    save_LoadMatrixf(tm);
  3623. }
  3624.  
  3625.  
  3626. static void save_LoadTransposeMatrixfARB( const GLfloat m[16] )
  3627. {
  3628.    GLfloat tm[16];
  3629.    _math_transposef(tm, m);
  3630.    save_LoadMatrixf(tm);
  3631. }
  3632.  
  3633.  
  3634. static void
  3635. save_MultTransposeMatrixdARB( const GLdouble m[16] )
  3636. {
  3637.    GLfloat tm[16];
  3638.    _math_transposefd(tm, m);
  3639.    save_MultMatrixf(tm);
  3640. }
  3641.  
  3642.  
  3643. static void
  3644. save_MultTransposeMatrixfARB( const GLfloat m[16] )
  3645. {
  3646.    GLfloat tm[16];
  3647.    _math_transposef(tm, m);
  3648.    save_MultMatrixf(tm);
  3649. }
  3650.  
  3651.  
  3652. static void
  3653. save_PixelTexGenSGIX(GLenum mode)
  3654. {
  3655.    GET_CURRENT_CONTEXT(ctx);
  3656.    Node *n;
  3657.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3658.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_SGIX, 1 );
  3659.    if (n) {
  3660.       n[1].e = mode;
  3661.    }
  3662.    if (ctx->ExecuteFlag) {
  3663.       (*ctx->Exec->PixelTexGenSGIX)( mode );
  3664.    }
  3665. }
  3666.  
  3667.  
  3668. /* GL_ARB_texture_compression */
  3669. static void
  3670. save_CompressedTexImage1DARB(GLenum target, GLint level,
  3671.                              GLenum internalFormat, GLsizei width,
  3672.                              GLint border, GLsizei imageSize,
  3673.                              const GLvoid *data)
  3674. {
  3675.    GET_CURRENT_CONTEXT(ctx);
  3676.    if (target == GL_PROXY_TEXTURE_1D) {
  3677.       /* don't compile, execute immediately */
  3678.       (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
  3679.                                             width, border, imageSize, data);
  3680.    }
  3681.    else {
  3682.       Node *n;
  3683.       GLvoid *image;
  3684.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3685.       /* make copy of image */
  3686.       image = MALLOC(imageSize);
  3687.       if (!image) {
  3688.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
  3689.          return;
  3690.       }
  3691.       MEMCPY(image, data, imageSize);
  3692.       n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7 );
  3693.       if (n) {
  3694.          n[1].e = target;
  3695.          n[2].i = level;
  3696.          n[3].e = internalFormat;
  3697.          n[4].i = (GLint) width;
  3698.          n[5].i = border;
  3699.          n[6].i = imageSize;
  3700.          n[7].data = image;
  3701.       }
  3702.       else if (image) {
  3703.          FREE(image);
  3704.       }
  3705.       if (ctx->ExecuteFlag) {
  3706.          (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
  3707.                                                width, border, imageSize, data);
  3708.       }
  3709.    }
  3710. }
  3711.  
  3712.  
  3713. static void
  3714. save_CompressedTexImage2DARB(GLenum target, GLint level,
  3715.                              GLenum internalFormat, GLsizei width,
  3716.                              GLsizei height, GLint border, GLsizei imageSize,
  3717.                              const GLvoid *data)
  3718. {
  3719.    GET_CURRENT_CONTEXT(ctx);
  3720.    if (target == GL_PROXY_TEXTURE_2D) {
  3721.       /* don't compile, execute immediately */
  3722.       (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
  3723.                                        width, height, border, imageSize, data);
  3724.    }
  3725.    else {
  3726.       Node *n;
  3727.       GLvoid *image;
  3728.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3729.       /* make copy of image */
  3730.       image = MALLOC(imageSize);
  3731.       if (!image) {
  3732.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
  3733.          return;
  3734.       }
  3735.       MEMCPY(image, data, imageSize);
  3736.       n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8 );
  3737.       if (n) {
  3738.          n[1].e = target;
  3739.          n[2].i = level;
  3740.          n[3].e = internalFormat;
  3741.          n[4].i = (GLint) width;
  3742.          n[5].i = (GLint) height;
  3743.          n[6].i = border;
  3744.          n[7].i = imageSize;
  3745.          n[8].data = image;
  3746.       }
  3747.       else if (image) {
  3748.          FREE(image);
  3749.       }
  3750.       if (ctx->ExecuteFlag) {
  3751.          (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
  3752.                                       width, height, border, imageSize, data);
  3753.       }
  3754.    }
  3755. }
  3756.  
  3757.  
  3758. static void
  3759. save_CompressedTexImage3DARB(GLenum target, GLint level,
  3760.                              GLenum internalFormat, GLsizei width,
  3761.                              GLsizei height, GLsizei depth, GLint border,
  3762.                              GLsizei imageSize, const GLvoid *data)
  3763. {
  3764.    GET_CURRENT_CONTEXT(ctx);
  3765.    if (target == GL_PROXY_TEXTURE_3D) {
  3766.       /* don't compile, execute immediately */
  3767.       (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
  3768.                                 width, height, depth, border, imageSize, data);
  3769.    }
  3770.    else {
  3771.       Node *n;
  3772.       GLvoid *image;
  3773.       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3774.       /* make copy of image */
  3775.       image = MALLOC(imageSize);
  3776.       if (!image) {
  3777.          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
  3778.          return;
  3779.       }
  3780.       MEMCPY(image, data, imageSize);
  3781.       n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9 );
  3782.       if (n) {
  3783.          n[1].e = target;
  3784.          n[2].i = level;
  3785.          n[3].e = internalFormat;
  3786.          n[4].i = (GLint) width;
  3787.          n[5].i = (GLint) height;
  3788.          n[6].i = (GLint) depth;
  3789.          n[7].i = border;
  3790.          n[8].i = imageSize;
  3791.          n[9].data = image;
  3792.       }
  3793.       else if (image) {
  3794.          FREE(image);
  3795.       }
  3796.       if (ctx->ExecuteFlag) {
  3797.          (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
  3798.                                 width, height, depth, border, imageSize, data);
  3799.       }
  3800.    }
  3801. }
  3802.  
  3803.  
  3804. static void
  3805. save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
  3806.                                 GLsizei width, GLenum format,
  3807.                                 GLsizei imageSize, const GLvoid *data)
  3808. {
  3809.    Node *n;
  3810.    GLvoid *image;
  3811.  
  3812.    GET_CURRENT_CONTEXT(ctx);
  3813.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3814.  
  3815.    /* make copy of image */
  3816.    image = MALLOC(imageSize);
  3817.    if (!image) {
  3818.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
  3819.       return;
  3820.    }
  3821.    MEMCPY(image, data, imageSize);
  3822.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7 );
  3823.    if (n) {
  3824.       n[1].e = target;
  3825.       n[2].i = level;
  3826.       n[3].i = xoffset;
  3827.       n[4].i = (GLint) width;
  3828.       n[5].e = format;
  3829.       n[6].i = imageSize;
  3830.       n[7].data = image;
  3831.    }
  3832.    else if (image) {
  3833.       FREE(image);
  3834.    }
  3835.    if (ctx->ExecuteFlag) {
  3836.       (*ctx->Exec->CompressedTexSubImage1DARB)(target, level, xoffset,
  3837.                                             width, format, imageSize, data);
  3838.    }
  3839. }
  3840.  
  3841.  
  3842. static void
  3843. save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
  3844.                                 GLint yoffset, GLsizei width, GLsizei height,
  3845.                                 GLenum format, GLsizei imageSize,
  3846.                                 const GLvoid *data)
  3847. {
  3848.    Node *n;
  3849.    GLvoid *image;
  3850.  
  3851.    GET_CURRENT_CONTEXT(ctx);
  3852.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3853.  
  3854.    /* make copy of image */
  3855.    image = MALLOC(imageSize);
  3856.    if (!image) {
  3857.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
  3858.       return;
  3859.    }
  3860.    MEMCPY(image, data, imageSize);
  3861.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9 );
  3862.    if (n) {
  3863.       n[1].e = target;
  3864.       n[2].i = level;
  3865.       n[3].i = xoffset;
  3866.       n[4].i = yoffset;
  3867.       n[5].i = (GLint) width;
  3868.       n[6].i = (GLint) height;
  3869.       n[7].e = format;
  3870.       n[8].i = imageSize;
  3871.       n[9].data = image;
  3872.    }
  3873.    else if (image) {
  3874.       FREE(image);
  3875.    }
  3876.    if (ctx->ExecuteFlag) {
  3877.       (*ctx->Exec->CompressedTexSubImage2DARB)(target, level, xoffset, yoffset,
  3878.                                        width, height, format, imageSize, data);
  3879.    }
  3880. }
  3881.  
  3882.  
  3883. static void
  3884. save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
  3885.                                 GLint yoffset, GLint zoffset, GLsizei width,
  3886.                                 GLsizei height, GLsizei depth, GLenum format,
  3887.                                 GLsizei imageSize, const GLvoid *data)
  3888. {
  3889.    Node *n;
  3890.    GLvoid *image;
  3891.  
  3892.    GET_CURRENT_CONTEXT(ctx);
  3893.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3894.  
  3895.    /* make copy of image */
  3896.    image = MALLOC(imageSize);
  3897.    if (!image) {
  3898.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
  3899.       return;
  3900.    }
  3901.    MEMCPY(image, data, imageSize);
  3902.    n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11 );
  3903.    if (n) {
  3904.       n[1].e = target;
  3905.       n[2].i = level;
  3906.       n[3].i = xoffset;
  3907.       n[4].i = yoffset;
  3908.       n[5].i = zoffset;
  3909.       n[6].i = (GLint) width;
  3910.       n[7].i = (GLint) height;
  3911.       n[8].i = (GLint) depth;
  3912.       n[9].e = format;
  3913.       n[10].i = imageSize;
  3914.       n[11].data = image;
  3915.    }
  3916.    else if (image) {
  3917.       FREE(image);
  3918.    }
  3919.    if (ctx->ExecuteFlag) {
  3920.       (*ctx->Exec->CompressedTexSubImage3DARB)(target, level, xoffset, yoffset,
  3921.                        zoffset, width, height, depth, format, imageSize, data);
  3922.    }
  3923. }
  3924.  
  3925.  
  3926. /* GL_ARB_multisample */
  3927. static void
  3928. save_SampleCoverageARB(GLclampf value, GLboolean invert)
  3929. {
  3930.    GET_CURRENT_CONTEXT(ctx);
  3931.    Node *n;
  3932.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3933.    n = ALLOC_INSTRUCTION( ctx, OPCODE_SAMPLE_COVERAGE, 2 );
  3934.    if (n) {
  3935.       n[1].f = value;
  3936.       n[2].b = invert;
  3937.    }
  3938.    if (ctx->ExecuteFlag) {
  3939.       (*ctx->Exec->SampleCoverageARB)( value, invert );
  3940.    }
  3941. }
  3942.  
  3943.  
  3944. /* GL_SGIS_pixel_texture */
  3945.  
  3946. static void
  3947. save_PixelTexGenParameteriSGIS(GLenum target, GLint value)
  3948. {
  3949.    GET_CURRENT_CONTEXT(ctx);
  3950.    Node *n;
  3951.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3952.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 2 );
  3953.    if (n) {
  3954.       n[1].e = target;
  3955.       n[2].i = value;
  3956.    }
  3957.    if (ctx->ExecuteFlag) {
  3958.       (*ctx->Exec->PixelTexGenParameteriSGIS)( target, value );
  3959.    }
  3960. }
  3961.  
  3962.  
  3963. static void
  3964. save_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
  3965. {
  3966.    save_PixelTexGenParameteriSGIS(target, (GLint) value);
  3967. }
  3968.  
  3969.  
  3970. static void
  3971. save_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
  3972. {
  3973.    save_PixelTexGenParameteriSGIS(target, *value);
  3974. }
  3975.  
  3976.  
  3977. static void
  3978. save_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
  3979. {
  3980.    save_PixelTexGenParameteriSGIS(target, (GLint) *value);
  3981. }
  3982.  
  3983.  
  3984. /*
  3985.  * GL_NV_vertex_program
  3986.  */
  3987. #if FEATURE_NV_vertex_program
  3988. static void
  3989. save_BindProgramNV(GLenum target, GLuint id)
  3990. {
  3991.    GET_CURRENT_CONTEXT(ctx);
  3992.    Node *n;
  3993.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  3994.    n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_PROGRAM_NV, 2 );
  3995.    if (n) {
  3996.       n[1].e = target;
  3997.       n[2].ui = id;
  3998.    }
  3999.    if (ctx->ExecuteFlag) {
  4000.       (*ctx->Exec->BindProgramNV)( target, id );
  4001.    }
  4002. }
  4003.  
  4004. static void
  4005. save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
  4006. {
  4007.    GET_CURRENT_CONTEXT(ctx);
  4008.    Node *n;
  4009.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  4010.    n = ALLOC_INSTRUCTION( ctx, OPCODE_EXECUTE_PROGRAM_NV, 6 );
  4011.    if (n) {
  4012.       n[1].e = target;
  4013.       n[2].ui = id;
  4014.       n[3].f = params[0];
  4015.       n[4].f = params[1];
  4016.       n[5].f = params[2];
  4017.       n[6].f = params[3];
  4018.    }
  4019.    if (ctx->ExecuteFlag) {
  4020.       (*ctx->Exec->ExecuteProgramNV)(target, id, params);
  4021.    }
  4022. }
  4023.  
  4024.  
  4025. static void
  4026. save_ProgramParameter4fNV(GLenum target, GLuint index,
  4027.                           GLfloat x, GLfloat y,
  4028.                           GLfloat z, GLfloat w)
  4029. {
  4030.    GET_CURRENT_CONTEXT(ctx);
  4031.    Node *n;
  4032.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  4033.    n = ALLOC_INSTRUCTION( ctx, OPCODE_PROGRAM_PARAMETER4F_NV, 6 );
  4034.    if (n) {
  4035.       n[1].e = target;
  4036.       n[2].ui = index;
  4037.       n[3].f = x;
  4038.       n[4].f = y;
  4039.       n[5].f = z;
  4040.       n[6].f = w;
  4041.    }
  4042.    if (ctx->ExecuteFlag) {
  4043.       (*ctx->Exec->ProgramParameter4fNV)(target, index, x, y, z, w);
  4044.    }
  4045. }
  4046.  
  4047.  
  4048. static void
  4049. save_ProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *params)
  4050. {
  4051.    save_ProgramParameter4fNV(target, index, params[0], params[1],
  4052.                              params[2], params[3]);
  4053. }
  4054.  
  4055.  
  4056. static void
  4057. save_ProgramParameter4dNV(GLenum target, GLuint index,
  4058.                           GLdouble x, GLdouble y,
  4059.                           GLdouble z, GLdouble w)
  4060. {
  4061.    save_ProgramParameter4fNV(target, index, (GLfloat) x, (GLfloat) y,
  4062.                              (GLfloat) z, (GLfloat) w);
  4063. }
  4064.  
  4065.  
  4066. static void
  4067. save_ProgramParameter4dvNV(GLenum target, GLuint index,
  4068.                            const GLdouble *params)
  4069. {
  4070.    save_ProgramParameter4fNV(target, index, (GLfloat) params[0],
  4071.                              (GLfloat) params[1], (GLfloat) params[2],
  4072.                              (GLfloat) params[3]);
  4073. }
  4074.  
  4075.  
  4076. static void
  4077. save_ProgramParameters4dvNV(GLenum target, GLuint index,
  4078.                             GLuint num, const GLdouble *params)
  4079. {
  4080.    GLuint i;
  4081.    for (i = 0; i < num; i++) {
  4082.       save_ProgramParameter4dvNV(target, index + i, params + 4 * i);
  4083.    }
  4084. }
  4085.  
  4086.  
  4087. static void
  4088. save_ProgramParameters4fvNV(GLenum target, GLuint index,
  4089.                             GLuint num, const GLfloat *params)
  4090. {
  4091.    GLuint i;
  4092.    for (i = 0; i < num; i++) {
  4093.       save_ProgramParameter4fvNV(target, index + i, params + 4 * i);
  4094.    }
  4095. }
  4096.  
  4097.  
  4098.  
  4099. static void
  4100. save_TrackMatrixNV(GLenum target, GLuint address,
  4101.                    GLenum matrix, GLenum transform)
  4102. {
  4103.    GET_CURRENT_CONTEXT(ctx);
  4104.    Node *n;
  4105.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  4106.    n = ALLOC_INSTRUCTION( ctx, OPCODE_TRACK_MATRIX_NV, 4 );
  4107.    if (n) {
  4108.       n[1].e = target;
  4109.       n[2].ui = address;
  4110.       n[3].e = matrix;
  4111.       n[4].e = transform;
  4112.    }
  4113.    if (ctx->ExecuteFlag) {
  4114.       (*ctx->Exec->TrackMatrixNV)(target, address, matrix, transform);
  4115.    }
  4116. }
  4117. #endif /* FEATURE_NV_vertex_program */
  4118.  
  4119.  
  4120. /* GL_EXT_stencil_two_side */
  4121. static void save_ActiveStencilFaceEXT( GLenum face )
  4122. {
  4123.    GET_CURRENT_CONTEXT(ctx);
  4124.    Node *n;
  4125.    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
  4126.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1 );
  4127.    if (n) {
  4128.       n[1].e = face;
  4129.    }
  4130.    if (ctx->ExecuteFlag) {
  4131.       (*ctx->Exec->ActiveStencilFaceEXT)( face );
  4132.    }
  4133. }
  4134.  
  4135.  
  4136.  
  4137. /* KW: Compile commands
  4138.  *
  4139.  * Will appear in the list before the vertex buffer containing the
  4140.  * command that provoked the error.  I don't see this as a problem.
  4141.  */
  4142. void
  4143. _mesa_save_error( GLcontext *ctx, GLenum error, const char *s )
  4144. {
  4145.    Node *n;
  4146.    n = ALLOC_INSTRUCTION( ctx, OPCODE_ERROR, 2 );
  4147.    if (n) {
  4148.       n[1].e = error;
  4149.       n[2].data = (void *) s;
  4150.    }
  4151.    /* execute already done */
  4152. }
  4153.  
  4154.  
  4155. /*
  4156.  * Compile an error into current display list.
  4157.  */
  4158. void
  4159. _mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
  4160. {
  4161.    if (ctx->CompileFlag)
  4162.       _mesa_save_error( ctx, error, s );
  4163.  
  4164.    if (ctx->ExecuteFlag)
  4165.       _mesa_error( ctx, error, s );
  4166. }
  4167.  
  4168.  
  4169.  
  4170. static GLboolean
  4171. islist(GLcontext *ctx, GLuint list)
  4172. {
  4173.    if (list > 0 && _mesa_HashLookup(ctx->Shared->DisplayList, list)) {
  4174.       return GL_TRUE;
  4175.    }
  4176.    else {
  4177.       return GL_FALSE;
  4178.    }
  4179. }
  4180.  
  4181.  
  4182.  
  4183. /**********************************************************************/
  4184. /*                     Display list execution                         */
  4185. /**********************************************************************/
  4186.  
  4187.  
  4188. /*
  4189.  * Execute a display list.  Note that the ListBase offset must have already
  4190.  * been added before calling this function.  I.e. the list argument is
  4191.  * the absolute list number, not relative to ListBase.
  4192.  * Input:  list - display list number
  4193.  */
  4194. static void
  4195. execute_list( GLcontext *ctx, GLuint list )
  4196. {
  4197.    Node *n;
  4198.    GLboolean done;
  4199.  
  4200.    if (!islist(ctx,list))
  4201.       return;
  4202.  
  4203.    if (ctx->Driver.BeginCallList)
  4204.       ctx->Driver.BeginCallList( ctx, list );
  4205.  
  4206.    ctx->CallDepth++;
  4207.  
  4208.    n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
  4209.  
  4210.    done = GL_FALSE;
  4211.    while (!done) {
  4212.       OpCode opcode = n[0].opcode;
  4213.       int i = (int)n[0].opcode - (int)OPCODE_DRV_0;
  4214.  
  4215.       if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
  4216.      ctx->listext.opcode[i].execute(ctx, &n[1]);
  4217.      n += ctx->listext.opcode[i].size;
  4218.       }
  4219.       else {
  4220.      switch (opcode) {
  4221.      case OPCODE_ERROR:
  4222.         _mesa_error( ctx, n[1].e, (const char *) n[2].data );
  4223.         break;
  4224.          case OPCODE_ACCUM:
  4225.         (*ctx->Exec->Accum)( n[1].e, n[2].f );
  4226.         break;
  4227.          case OPCODE_ALPHA_FUNC:
  4228.         (*ctx->Exec->AlphaFunc)( n[1].e, n[2].f );
  4229.         break;
  4230.          case OPCODE_BIND_TEXTURE:
  4231.             (*ctx->Exec->BindTexture)( n[1].e, n[2].ui );
  4232.             break;
  4233.      case OPCODE_BITMAP:
  4234.             {
  4235.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4236.                ctx->Unpack = _mesa_native_packing;
  4237.                (*ctx->Exec->Bitmap)( (GLsizei) n[1].i, (GLsizei) n[2].i,
  4238.                  n[3].f, n[4].f, n[5].f, n[6].f, (const GLubyte *) n[7].data );
  4239.                ctx->Unpack = save;  /* restore */
  4240.             }
  4241.         break;
  4242.      case OPCODE_BLEND_COLOR:
  4243.         (*ctx->Exec->BlendColor)( n[1].f, n[2].f, n[3].f, n[4].f );
  4244.         break;
  4245.      case OPCODE_BLEND_EQUATION:
  4246.         (*ctx->Exec->BlendEquation)( n[1].e );
  4247.         break;
  4248.      case OPCODE_BLEND_FUNC:
  4249.         (*ctx->Exec->BlendFunc)( n[1].e, n[2].e );
  4250.         break;
  4251.      case OPCODE_BLEND_FUNC_SEPARATE:
  4252.         (*ctx->Exec->BlendFuncSeparateEXT)(n[1].e, n[2].e, n[3].e, n[4].e);
  4253.         break;
  4254.          case OPCODE_CALL_LIST:
  4255.         /* Generated by glCallList(), don't add ListBase */
  4256.             if (ctx->CallDepth<MAX_LIST_NESTING) {
  4257.                execute_list( ctx, n[1].ui );
  4258.             }
  4259.             break;
  4260.          case OPCODE_CALL_LIST_OFFSET:
  4261.         /* Generated by glCallLists() so we must add ListBase */
  4262.             if (n[2].b) {
  4263.                /* user specified a bad datatype at compile time */
  4264.                _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
  4265.             }
  4266.             else if (ctx->CallDepth < MAX_LIST_NESTING) {
  4267.                execute_list( ctx, ctx->List.ListBase + n[1].ui );
  4268.             }
  4269.             break;
  4270.      case OPCODE_CLEAR:
  4271.         (*ctx->Exec->Clear)( n[1].bf );
  4272.         break;
  4273.      case OPCODE_CLEAR_COLOR:
  4274.         (*ctx->Exec->ClearColor)( n[1].f, n[2].f, n[3].f, n[4].f );
  4275.         break;
  4276.      case OPCODE_CLEAR_ACCUM:
  4277.         (*ctx->Exec->ClearAccum)( n[1].f, n[2].f, n[3].f, n[4].f );
  4278.         break;
  4279.      case OPCODE_CLEAR_DEPTH:
  4280.         (*ctx->Exec->ClearDepth)( (GLclampd) n[1].f );
  4281.         break;
  4282.      case OPCODE_CLEAR_INDEX:
  4283.         (*ctx->Exec->ClearIndex)( (GLfloat) n[1].ui );
  4284.         break;
  4285.      case OPCODE_CLEAR_STENCIL:
  4286.         (*ctx->Exec->ClearStencil)( n[1].i );
  4287.         break;
  4288.          case OPCODE_CLIP_PLANE:
  4289.             {
  4290.                GLdouble eq[4];
  4291.                eq[0] = n[2].f;
  4292.                eq[1] = n[3].f;
  4293.                eq[2] = n[4].f;
  4294.                eq[3] = n[5].f;
  4295.                (*ctx->Exec->ClipPlane)( n[1].e, eq );
  4296.             }
  4297.             break;
  4298.      case OPCODE_COLOR_MASK:
  4299.         (*ctx->Exec->ColorMask)( n[1].b, n[2].b, n[3].b, n[4].b );
  4300.         break;
  4301.      case OPCODE_COLOR_MATERIAL:
  4302.         (*ctx->Exec->ColorMaterial)( n[1].e, n[2].e );
  4303.         break;
  4304.          case OPCODE_COLOR_TABLE:
  4305.             {
  4306.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4307.                ctx->Unpack = _mesa_native_packing;
  4308.                (*ctx->Exec->ColorTable)( n[1].e, n[2].e, n[3].i, n[4].e,
  4309.                                          n[5].e, n[6].data );
  4310.                ctx->Unpack = save;  /* restore */
  4311.             }
  4312.             break;
  4313.          case OPCODE_COLOR_TABLE_PARAMETER_FV:
  4314.             {
  4315.                GLfloat params[4];
  4316.                params[0] = n[3].f;
  4317.                params[1] = n[4].f;
  4318.                params[2] = n[5].f;
  4319.                params[3] = n[6].f;
  4320.                (*ctx->Exec->ColorTableParameterfv)( n[1].e, n[2].e, params );
  4321.             }
  4322.             break;
  4323.          case OPCODE_COLOR_TABLE_PARAMETER_IV:
  4324.             {
  4325.                GLint params[4];
  4326.                params[0] = n[3].i;
  4327.                params[1] = n[4].i;
  4328.                params[2] = n[5].i;
  4329.                params[3] = n[6].i;
  4330.                (*ctx->Exec->ColorTableParameteriv)( n[1].e, n[2].e, params );
  4331.             }
  4332.             break;
  4333.          case OPCODE_COLOR_SUB_TABLE:
  4334.             {
  4335.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4336.                ctx->Unpack = _mesa_native_packing;
  4337.                (*ctx->Exec->ColorSubTable)( n[1].e, n[2].i, n[3].i,
  4338.                                             n[4].e, n[5].e, n[6].data );
  4339.                ctx->Unpack = save;  /* restore */
  4340.             }
  4341.             break;
  4342.          case OPCODE_CONVOLUTION_FILTER_1D:
  4343.             {
  4344.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4345.                ctx->Unpack = _mesa_native_packing;
  4346.                (*ctx->Exec->ConvolutionFilter1D)( n[1].e, n[2].i, n[3].i,
  4347.                                                   n[4].e, n[5].e, n[6].data );
  4348.                ctx->Unpack = save;  /* restore */
  4349.             }
  4350.             break;
  4351.          case OPCODE_CONVOLUTION_FILTER_2D:
  4352.             {
  4353.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4354.                ctx->Unpack = _mesa_native_packing;
  4355.                (*ctx->Exec->ConvolutionFilter2D)( n[1].e, n[2].i, n[3].i,
  4356.                                        n[4].i, n[5].e, n[6].e, n[7].data );
  4357.                ctx->Unpack = save;  /* restore */
  4358.             }
  4359.             break;
  4360.          case OPCODE_CONVOLUTION_PARAMETER_I:
  4361.             (*ctx->Exec->ConvolutionParameteri)( n[1].e, n[2].e, n[3].i );
  4362.             break;
  4363.          case OPCODE_CONVOLUTION_PARAMETER_IV:
  4364.             {
  4365.                GLint params[4];
  4366.                params[0] = n[3].i;
  4367.                params[1] = n[4].i;
  4368.                params[2] = n[5].i;
  4369.                params[3] = n[6].i;
  4370.                (*ctx->Exec->ConvolutionParameteriv)( n[1].e, n[2].e, params );
  4371.             }
  4372.             break;
  4373.          case OPCODE_CONVOLUTION_PARAMETER_F:
  4374.             (*ctx->Exec->ConvolutionParameterf)( n[1].e, n[2].e, n[3].f );
  4375.             break;
  4376.          case OPCODE_CONVOLUTION_PARAMETER_FV:
  4377.             {
  4378.                GLfloat params[4];
  4379.                params[0] = n[3].f;
  4380.                params[1] = n[4].f;
  4381.                params[2] = n[5].f;
  4382.                params[3] = n[6].f;
  4383.                (*ctx->Exec->ConvolutionParameterfv)( n[1].e, n[2].e, params );
  4384.             }
  4385.             break;
  4386.          case OPCODE_COPY_COLOR_SUB_TABLE:
  4387.             (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
  4388.                                              n[3].i, n[4].i, n[5].i );
  4389.             break;
  4390.          case OPCODE_COPY_COLOR_TABLE:
  4391.             (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
  4392.                                              n[3].i, n[4].i, n[5].i );
  4393.             break;
  4394.      case OPCODE_COPY_PIXELS:
  4395.         (*ctx->Exec->CopyPixels)( n[1].i, n[2].i,
  4396.                (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
  4397.         break;
  4398.          case OPCODE_COPY_TEX_IMAGE1D:
  4399.         (*ctx->Exec->CopyTexImage1D)( n[1].e, n[2].i, n[3].e, n[4].i,
  4400.                                          n[5].i, n[6].i, n[7].i );
  4401.             break;
  4402.          case OPCODE_COPY_TEX_IMAGE2D:
  4403.         (*ctx->Exec->CopyTexImage2D)( n[1].e, n[2].i, n[3].e, n[4].i,
  4404.                                          n[5].i, n[6].i, n[7].i, n[8].i );
  4405.             break;
  4406.          case OPCODE_COPY_TEX_SUB_IMAGE1D:
  4407.         (*ctx->Exec->CopyTexSubImage1D)( n[1].e, n[2].i, n[3].i,
  4408.                                             n[4].i, n[5].i, n[6].i );
  4409.             break;
  4410.          case OPCODE_COPY_TEX_SUB_IMAGE2D:
  4411.         (*ctx->Exec->CopyTexSubImage2D)( n[1].e, n[2].i, n[3].i,
  4412.                                      n[4].i, n[5].i, n[6].i, n[7].i, n[8].i );
  4413.             break;
  4414.          case OPCODE_COPY_TEX_SUB_IMAGE3D:
  4415.             (*ctx->Exec->CopyTexSubImage3D)( n[1].e, n[2].i, n[3].i,
  4416.                             n[4].i, n[5].i, n[6].i, n[7].i, n[8].i , n[9].i);
  4417.             break;
  4418.      case OPCODE_CULL_FACE:
  4419.         (*ctx->Exec->CullFace)( n[1].e );
  4420.         break;
  4421.      case OPCODE_DEPTH_FUNC:
  4422.         (*ctx->Exec->DepthFunc)( n[1].e );
  4423.         break;
  4424.      case OPCODE_DEPTH_MASK:
  4425.         (*ctx->Exec->DepthMask)( n[1].b );
  4426.         break;
  4427.      case OPCODE_DEPTH_RANGE:
  4428.         (*ctx->Exec->DepthRange)( (GLclampd) n[1].f, (GLclampd) n[2].f );
  4429.         break;
  4430.      case OPCODE_DISABLE:
  4431.         (*ctx->Exec->Disable)( n[1].e );
  4432.         break;
  4433.      case OPCODE_DRAW_BUFFER:
  4434.         (*ctx->Exec->DrawBuffer)( n[1].e );
  4435.         break;
  4436.      case OPCODE_DRAW_PIXELS:
  4437.             {
  4438.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4439.                ctx->Unpack = _mesa_native_packing;
  4440.                (*ctx->Exec->DrawPixels)( n[1].i, n[2].i, n[3].e, n[4].e,
  4441.                                         n[5].data );
  4442.                ctx->Unpack = save;  /* restore */
  4443.             }
  4444.         break;
  4445.      case OPCODE_ENABLE:
  4446.         (*ctx->Exec->Enable)( n[1].e );
  4447.         break;
  4448.      case OPCODE_EVALMESH1:
  4449.         (*ctx->Exec->EvalMesh1)( n[1].e, n[2].i, n[3].i );
  4450.         break;
  4451.      case OPCODE_EVALMESH2:
  4452.         (*ctx->Exec->EvalMesh2)( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
  4453.         break;
  4454.      case OPCODE_FOG:
  4455.         {
  4456.            GLfloat p[4];
  4457.            p[0] = n[2].f;
  4458.            p[1] = n[3].f;
  4459.            p[2] = n[4].f;
  4460.            p[3] = n[5].f;
  4461.            (*ctx->Exec->Fogfv)( n[1].e, p );
  4462.         }
  4463.         break;
  4464.      case OPCODE_FRONT_FACE:
  4465.         (*ctx->Exec->FrontFace)( n[1].e );
  4466.         break;
  4467.          case OPCODE_FRUSTUM:
  4468.             (*ctx->Exec->Frustum)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  4469.             break;
  4470.      case OPCODE_HINT:
  4471.         (*ctx->Exec->Hint)( n[1].e, n[2].e );
  4472.         break;
  4473.      case OPCODE_HISTOGRAM:
  4474.         (*ctx->Exec->Histogram)( n[1].e, n[2].i, n[3].e, n[4].b );
  4475.         break;
  4476.      case OPCODE_INDEX_MASK:
  4477.         (*ctx->Exec->IndexMask)( n[1].ui );
  4478.         break;
  4479.      case OPCODE_INIT_NAMES:
  4480.         (*ctx->Exec->InitNames)();
  4481.         break;
  4482.          case OPCODE_LIGHT:
  4483.         {
  4484.            GLfloat p[4];
  4485.            p[0] = n[3].f;
  4486.            p[1] = n[4].f;
  4487.            p[2] = n[5].f;
  4488.            p[3] = n[6].f;
  4489.            (*ctx->Exec->Lightfv)( n[1].e, n[2].e, p );
  4490.         }
  4491.         break;
  4492.          case OPCODE_LIGHT_MODEL:
  4493.         {
  4494.            GLfloat p[4];
  4495.            p[0] = n[2].f;
  4496.            p[1] = n[3].f;
  4497.            p[2] = n[4].f;
  4498.            p[3] = n[5].f;
  4499.            (*ctx->Exec->LightModelfv)( n[1].e, p );
  4500.         }
  4501.         break;
  4502.      case OPCODE_LINE_STIPPLE:
  4503.         (*ctx->Exec->LineStipple)( n[1].i, n[2].us );
  4504.         break;
  4505.      case OPCODE_LINE_WIDTH:
  4506.         (*ctx->Exec->LineWidth)( n[1].f );
  4507.         break;
  4508.      case OPCODE_LIST_BASE:
  4509.         (*ctx->Exec->ListBase)( n[1].ui );
  4510.         break;
  4511.      case OPCODE_LOAD_IDENTITY:
  4512.             (*ctx->Exec->LoadIdentity)();
  4513.             break;
  4514.      case OPCODE_LOAD_MATRIX:
  4515.         if (sizeof(Node)==sizeof(GLfloat)) {
  4516.            (*ctx->Exec->LoadMatrixf)( &n[1].f );
  4517.         }
  4518.         else {
  4519.            GLfloat m[16];
  4520.            GLuint i;
  4521.            for (i=0;i<16;i++) {
  4522.           m[i] = n[1+i].f;
  4523.            }
  4524.            (*ctx->Exec->LoadMatrixf)( m );
  4525.         }
  4526.         break;
  4527.      case OPCODE_LOAD_NAME:
  4528.         (*ctx->Exec->LoadName)( n[1].ui );
  4529.         break;
  4530.      case OPCODE_LOGIC_OP:
  4531.         (*ctx->Exec->LogicOp)( n[1].e );
  4532.         break;
  4533.      case OPCODE_MAP1:
  4534.             {
  4535.                GLenum target = n[1].e;
  4536.                GLint ustride = _mesa_evaluator_components(target);
  4537.                GLint uorder = n[5].i;
  4538.                GLfloat u1 = n[2].f;
  4539.                GLfloat u2 = n[3].f;
  4540.                (*ctx->Exec->Map1f)( target, u1, u2, ustride, uorder,
  4541.                                    (GLfloat *) n[6].data );
  4542.             }
  4543.         break;
  4544.      case OPCODE_MAP2:
  4545.             {
  4546.                GLenum target = n[1].e;
  4547.                GLfloat u1 = n[2].f;
  4548.                GLfloat u2 = n[3].f;
  4549.                GLfloat v1 = n[4].f;
  4550.                GLfloat v2 = n[5].f;
  4551.                GLint ustride = n[6].i;
  4552.                GLint vstride = n[7].i;
  4553.                GLint uorder = n[8].i;
  4554.                GLint vorder = n[9].i;
  4555.                (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
  4556.                                    v1, v2, vstride, vorder,
  4557.                                    (GLfloat *) n[10].data );
  4558.             }
  4559.         break;
  4560.      case OPCODE_MAPGRID1:
  4561.         (*ctx->Exec->MapGrid1f)( n[1].i, n[2].f, n[3].f );
  4562.         break;
  4563.      case OPCODE_MAPGRID2:
  4564.         (*ctx->Exec->MapGrid2f)( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
  4565.         break;
  4566.          case OPCODE_MATRIX_MODE:
  4567.             (*ctx->Exec->MatrixMode)( n[1].e );
  4568.             break;
  4569.          case OPCODE_MIN_MAX:
  4570.             (*ctx->Exec->Minmax)(n[1].e, n[2].e, n[3].b);
  4571.             break;
  4572.      case OPCODE_MULT_MATRIX:
  4573.         if (sizeof(Node)==sizeof(GLfloat)) {
  4574.            (*ctx->Exec->MultMatrixf)( &n[1].f );
  4575.         }
  4576.         else {
  4577.            GLfloat m[16];
  4578.            GLuint i;
  4579.            for (i=0;i<16;i++) {
  4580.           m[i] = n[1+i].f;
  4581.            }
  4582.            (*ctx->Exec->MultMatrixf)( m );
  4583.         }
  4584.         break;
  4585.          case OPCODE_ORTHO:
  4586.             (*ctx->Exec->Ortho)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  4587.             break;
  4588.      case OPCODE_PASSTHROUGH:
  4589.         (*ctx->Exec->PassThrough)( n[1].f );
  4590.         break;
  4591.      case OPCODE_PIXEL_MAP:
  4592.         (*ctx->Exec->PixelMapfv)( n[1].e, n[2].i, (GLfloat *) n[3].data );
  4593.         break;
  4594.      case OPCODE_PIXEL_TRANSFER:
  4595.         (*ctx->Exec->PixelTransferf)( n[1].e, n[2].f );
  4596.         break;
  4597.      case OPCODE_PIXEL_ZOOM:
  4598.         (*ctx->Exec->PixelZoom)( n[1].f, n[2].f );
  4599.         break;
  4600.      case OPCODE_POINT_SIZE:
  4601.         (*ctx->Exec->PointSize)( n[1].f );
  4602.         break;
  4603.      case OPCODE_POINT_PARAMETERS:
  4604.         {
  4605.         GLfloat params[3];
  4606.         params[0] = n[2].f;
  4607.         params[1] = n[3].f;
  4608.         params[2] = n[4].f;
  4609.         (*ctx->Exec->PointParameterfvEXT)( n[1].e, params );
  4610.         }
  4611.         break;
  4612.      case OPCODE_POLYGON_MODE:
  4613.         (*ctx->Exec->PolygonMode)( n[1].e, n[2].e );
  4614.         break;
  4615.      case OPCODE_POLYGON_STIPPLE:
  4616.         (*ctx->Exec->PolygonStipple)( (GLubyte *) n[1].data );
  4617.         break;
  4618.      case OPCODE_POLYGON_OFFSET:
  4619.         (*ctx->Exec->PolygonOffset)( n[1].f, n[2].f );
  4620.         break;
  4621.      case OPCODE_POP_ATTRIB:
  4622.         (*ctx->Exec->PopAttrib)();
  4623.         break;
  4624.      case OPCODE_POP_MATRIX:
  4625.         (*ctx->Exec->PopMatrix)();
  4626.         break;
  4627.      case OPCODE_POP_NAME:
  4628.         (*ctx->Exec->PopName)();
  4629.         break;
  4630.      case OPCODE_PRIORITIZE_TEXTURE:
  4631.             (*ctx->Exec->PrioritizeTextures)( 1, &n[1].ui, &n[2].f );
  4632.         break;
  4633.      case OPCODE_PUSH_ATTRIB:
  4634.         (*ctx->Exec->PushAttrib)( n[1].bf );
  4635.         break;
  4636.      case OPCODE_PUSH_MATRIX:
  4637.         (*ctx->Exec->PushMatrix)();
  4638.         break;
  4639.      case OPCODE_PUSH_NAME:
  4640.         (*ctx->Exec->PushName)( n[1].ui );
  4641.         break;
  4642.      case OPCODE_RASTER_POS:
  4643.             (*ctx->Exec->RasterPos4f)( n[1].f, n[2].f, n[3].f, n[4].f );
  4644.         break;
  4645.      case OPCODE_READ_BUFFER:
  4646.         (*ctx->Exec->ReadBuffer)( n[1].e );
  4647.         break;
  4648.          case OPCODE_RESET_HISTOGRAM:
  4649.             (*ctx->Exec->ResetHistogram)( n[1].e );
  4650.             break;
  4651.          case OPCODE_RESET_MIN_MAX:
  4652.             (*ctx->Exec->ResetMinmax)( n[1].e );
  4653.             break;
  4654.          case OPCODE_ROTATE:
  4655.             (*ctx->Exec->Rotatef)( n[1].f, n[2].f, n[3].f, n[4].f );
  4656.             break;
  4657.          case OPCODE_SCALE:
  4658.             (*ctx->Exec->Scalef)( n[1].f, n[2].f, n[3].f );
  4659.             break;
  4660.      case OPCODE_SCISSOR:
  4661.         (*ctx->Exec->Scissor)( n[1].i, n[2].i, n[3].i, n[4].i );
  4662.         break;
  4663.      case OPCODE_SHADE_MODEL:
  4664.         (*ctx->Exec->ShadeModel)( n[1].e );
  4665.         break;
  4666.      case OPCODE_STENCIL_FUNC:
  4667.         (*ctx->Exec->StencilFunc)( n[1].e, n[2].i, n[3].ui );
  4668.         break;
  4669.      case OPCODE_STENCIL_MASK:
  4670.         (*ctx->Exec->StencilMask)( n[1].ui );
  4671.         break;
  4672.      case OPCODE_STENCIL_OP:
  4673.         (*ctx->Exec->StencilOp)( n[1].e, n[2].e, n[3].e );
  4674.         break;
  4675.          case OPCODE_TEXENV:
  4676.             {
  4677.                GLfloat params[4];
  4678.                params[0] = n[3].f;
  4679.                params[1] = n[4].f;
  4680.                params[2] = n[5].f;
  4681.                params[3] = n[6].f;
  4682.                (*ctx->Exec->TexEnvfv)( n[1].e, n[2].e, params );
  4683.             }
  4684.             break;
  4685.          case OPCODE_TEXGEN:
  4686.             {
  4687.                GLfloat params[4];
  4688.                params[0] = n[3].f;
  4689.                params[1] = n[4].f;
  4690.                params[2] = n[5].f;
  4691.                params[3] = n[6].f;
  4692.                (*ctx->Exec->TexGenfv)( n[1].e, n[2].e, params );
  4693.             }
  4694.             break;
  4695.          case OPCODE_TEXPARAMETER:
  4696.             {
  4697.                GLfloat params[4];
  4698.                params[0] = n[3].f;
  4699.                params[1] = n[4].f;
  4700.                params[2] = n[5].f;
  4701.                params[3] = n[6].f;
  4702.                (*ctx->Exec->TexParameterfv)( n[1].e, n[2].e, params );
  4703.             }
  4704.             break;
  4705.      case OPCODE_TEX_IMAGE1D:
  4706.             {
  4707.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4708.                ctx->Unpack = _mesa_native_packing;
  4709.                (*ctx->Exec->TexImage1D)(
  4710.                                         n[1].e, /* target */
  4711.                                         n[2].i, /* level */
  4712.                                         n[3].i, /* components */
  4713.                                         n[4].i, /* width */
  4714.                                         n[5].e, /* border */
  4715.                                         n[6].e, /* format */
  4716.                                         n[7].e, /* type */
  4717.                                         n[8].data );
  4718.                ctx->Unpack = save;  /* restore */
  4719.             }
  4720.         break;
  4721.      case OPCODE_TEX_IMAGE2D:
  4722.             {
  4723.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4724.                ctx->Unpack = _mesa_native_packing;
  4725.                (*ctx->Exec->TexImage2D)(
  4726.                                         n[1].e, /* target */
  4727.                                         n[2].i, /* level */
  4728.                                         n[3].i, /* components */
  4729.                                         n[4].i, /* width */
  4730.                                         n[5].i, /* height */
  4731.                                         n[6].e, /* border */
  4732.                                         n[7].e, /* format */
  4733.                                         n[8].e, /* type */
  4734.                                         n[9].data );
  4735.                ctx->Unpack = save;  /* restore */
  4736.             }
  4737.         break;
  4738.          case OPCODE_TEX_IMAGE3D:
  4739.             {
  4740.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4741.                ctx->Unpack = _mesa_native_packing;
  4742.                (*ctx->Exec->TexImage3D)(
  4743.                                         n[1].e, /* target */
  4744.                                         n[2].i, /* level */
  4745.                                         n[3].i, /* components */
  4746.                                         n[4].i, /* width */
  4747.                                         n[5].i, /* height */
  4748.                                         n[6].i, /* depth  */
  4749.                                         n[7].e, /* border */
  4750.                                         n[8].e, /* format */
  4751.                                         n[9].e, /* type */
  4752.                                         n[10].data );
  4753.                ctx->Unpack = save;  /* restore */
  4754.             }
  4755.             break;
  4756.          case OPCODE_TEX_SUB_IMAGE1D:
  4757.             {
  4758.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4759.                ctx->Unpack = _mesa_native_packing;
  4760.                (*ctx->Exec->TexSubImage1D)( n[1].e, n[2].i, n[3].i,
  4761.                                            n[4].i, n[5].e,
  4762.                                            n[6].e, n[7].data );
  4763.                ctx->Unpack = save;  /* restore */
  4764.             }
  4765.             break;
  4766.          case OPCODE_TEX_SUB_IMAGE2D:
  4767.             {
  4768.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4769.                ctx->Unpack = _mesa_native_packing;
  4770.                (*ctx->Exec->TexSubImage2D)( n[1].e, n[2].i, n[3].i,
  4771.                                            n[4].i, n[5].e,
  4772.                                            n[6].i, n[7].e, n[8].e, n[9].data );
  4773.                ctx->Unpack = save;  /* restore */
  4774.             }
  4775.             break;
  4776.          case OPCODE_TEX_SUB_IMAGE3D:
  4777.             {
  4778.                struct gl_pixelstore_attrib save = ctx->Unpack;
  4779.                ctx->Unpack = _mesa_native_packing;
  4780.                (*ctx->Exec->TexSubImage3D)( n[1].e, n[2].i, n[3].i,
  4781.                                            n[4].i, n[5].i, n[6].i, n[7].i,
  4782.                                            n[8].i, n[9].e, n[10].e,
  4783.                                            n[11].data );
  4784.                ctx->Unpack = save;  /* restore */
  4785.             }
  4786.             break;
  4787.          case OPCODE_TRANSLATE:
  4788.             (*ctx->Exec->Translatef)( n[1].f, n[2].f, n[3].f );
  4789.             break;
  4790.      case OPCODE_VIEWPORT:
  4791.         (*ctx->Exec->Viewport)(n[1].i, n[2].i,
  4792.                                   (GLsizei) n[3].i, (GLsizei) n[4].i);
  4793.         break;
  4794.      case OPCODE_WINDOW_POS:
  4795.             (*ctx->Exec->WindowPos4fMESA)( n[1].f, n[2].f, n[3].f, n[4].f );
  4796.         break;
  4797.          case OPCODE_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
  4798.             (*ctx->Exec->ActiveTextureARB)( n[1].e );
  4799.             break;
  4800.          case OPCODE_PIXEL_TEXGEN_SGIX:  /* GL_SGIX_pixel_texture */
  4801.             (*ctx->Exec->PixelTexGenSGIX)( n[1].e );
  4802.             break;
  4803.          case OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS:  /* GL_SGIS_pixel_texture */
  4804.             (*ctx->Exec->PixelTexGenParameteriSGIS)( n[1].e, n[2].i );
  4805.             break;
  4806.          case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */
  4807.             (*ctx->Exec->CompressedTexImage1DARB)(n[1].e, n[2].i, n[3].e,
  4808.                                             n[4].i, n[5].i, n[6].i, n[7].data);
  4809.             break;
  4810.          case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */
  4811.             (*ctx->Exec->CompressedTexImage2DARB)(n[1].e, n[2].i, n[3].e,
  4812.                                     n[4].i, n[5].i, n[6].i, n[7].i, n[8].data);
  4813.             break;
  4814.          case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */
  4815.             (*ctx->Exec->CompressedTexImage3DARB)(n[1].e, n[2].i, n[3].e,
  4816.                             n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, n[9].data);
  4817.             break;
  4818.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */
  4819.             (*ctx->Exec->CompressedTexSubImage1DARB)(n[1].e, n[2].i, n[3].i,
  4820.                                             n[4].i, n[5].e, n[6].i, n[7].data);
  4821.             break;
  4822.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */
  4823.             (*ctx->Exec->CompressedTexSubImage2DARB)(n[1].e, n[2].i, n[3].i,
  4824.                             n[4].i, n[5].i, n[6].i, n[7].e, n[8].i, n[9].data);
  4825.             break;
  4826.          case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */
  4827.             (*ctx->Exec->CompressedTexSubImage3DARB)(n[1].e, n[2].i, n[3].i,
  4828.                                         n[4].i, n[5].i, n[6].i, n[7].i, n[8].i,
  4829.                                         n[9].e, n[10].i, n[11].data);
  4830.             break;
  4831.          case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
  4832.             (*ctx->Exec->SampleCoverageARB)(n[1].f, n[2].b);
  4833.             break;
  4834.      case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */
  4835.             (*ctx->Exec->WindowPos3fMESA)( n[1].f, n[2].f, n[3].f );
  4836.         break;
  4837.          case OPCODE_BIND_PROGRAM_NV: /* GL_NV_vertex_program */
  4838.             (*ctx->Exec->BindProgramNV)( n[1].e, n[2].ui );
  4839.             break;
  4840.          case OPCODE_EXECUTE_PROGRAM_NV:
  4841.             {
  4842.                GLfloat v[4];
  4843.                v[0] = n[3].f;
  4844.                v[1] = n[4].f;
  4845.                v[2] = n[5].f;
  4846.                v[3] = n[6].f;
  4847.                (*ctx->Exec->ExecuteProgramNV)(n[1].e, n[2].ui, v);
  4848.             }
  4849.             break;
  4850.          case OPCODE_REQUEST_PROGRAMS_RESIDENT_NV:
  4851.             /*
  4852.             (*ctx->Exec->RequestResidentProgramsNV)();
  4853.             */
  4854.             break;
  4855.          case OPCODE_LOAD_PROGRAM_NV:
  4856.             /*
  4857.             (*ctx->Exec->LoadProgramNV)();
  4858.             */
  4859.             break;
  4860.          case OPCODE_PROGRAM_PARAMETER4F_NV:
  4861.             (*ctx->Exec->ProgramParameter4fNV)(n[1].e, n[2].ui, n[3].f,
  4862.                                                n[4].f, n[5].f, n[6].f);
  4863.             break;
  4864.          case OPCODE_TRACK_MATRIX_NV:
  4865.             (*ctx->Exec->TrackMatrixNV)(n[1].e, n[2].ui, n[3].e, n[4].e);
  4866.             break;
  4867.  
  4868.      case OPCODE_CONTINUE:
  4869.         n = (Node *) n[1].next;
  4870.         break;
  4871.      case OPCODE_END_OF_LIST:
  4872.         done = GL_TRUE;
  4873.         break;
  4874.      default:
  4875.             {
  4876.                char msg[1000];
  4877.                _mesa_sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
  4878.                _mesa_problem(ctx, msg);
  4879.             }
  4880.             done = GL_TRUE;
  4881.      }
  4882.  
  4883.      /* increment n to point to next compiled command */
  4884.      if (opcode!=OPCODE_CONTINUE) {
  4885.         n += InstSize[opcode];
  4886.      }
  4887.       }
  4888.    }
  4889.    ctx->CallDepth--;
  4890.  
  4891.    if (ctx->Driver.EndCallList)
  4892.       ctx->Driver.EndCallList( ctx );
  4893. }
  4894.  
  4895.  
  4896.  
  4897.  
  4898.  
  4899. /**********************************************************************/
  4900. /*                           GL functions                             */
  4901. /**********************************************************************/
  4902.  
  4903.  
  4904.  
  4905.  
  4906. /*
  4907.  * Test if a display list number is valid.
  4908.  */
  4909. GLboolean
  4910. _mesa_IsList( GLuint list )
  4911. {
  4912.    GET_CURRENT_CONTEXT(ctx);
  4913.    FLUSH_VERTICES(ctx, 0);    /* must be called before assert */
  4914.    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
  4915.    return islist(ctx, list);
  4916. }
  4917.  
  4918.  
  4919. /*
  4920.  * Delete a sequence of consecutive display lists.
  4921.  */
  4922. void
  4923. _mesa_DeleteLists( GLuint list, GLsizei range )
  4924. {
  4925.    GET_CURRENT_CONTEXT(ctx);
  4926.    GLuint i;
  4927.    FLUSH_VERTICES(ctx, 0);    /* must be called before assert */
  4928.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  4929.  
  4930.    if (range<0) {
  4931.       _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
  4932.       return;
  4933.    }
  4934.    for (i=list;i<list+range;i++) {
  4935.       _mesa_destroy_list( ctx, i );
  4936.    }
  4937. }
  4938.  
  4939.  
  4940.  
  4941. /*
  4942.  * Return a display list number, n, such that lists n through n+range-1
  4943.  * are free.
  4944.  */
  4945. GLuint
  4946. _mesa_GenLists(GLsizei range )
  4947. {
  4948.    GET_CURRENT_CONTEXT(ctx);
  4949.    GLuint base;
  4950.    FLUSH_VERTICES(ctx, 0);    /* must be called before assert */
  4951.    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
  4952.  
  4953.    if (range<0) {
  4954.       _mesa_error( ctx, GL_INVALID_VALUE, "glGenLists" );
  4955.       return 0;
  4956.    }
  4957.    if (range==0) {
  4958.       return 0;
  4959.    }
  4960.  
  4961.    /*
  4962.     * Make this an atomic operation
  4963.     */
  4964.    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
  4965.  
  4966.    base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
  4967.    if (base) {
  4968.       /* reserve the list IDs by with empty/dummy lists */
  4969.       GLint i;
  4970.       for (i=0; i<range; i++) {
  4971.          _mesa_HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list());
  4972.       }
  4973.    }
  4974.  
  4975.    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
  4976.  
  4977.    return base;
  4978. }
  4979.  
  4980.  
  4981.  
  4982. /*
  4983.  * Begin a new display list.
  4984.  */
  4985. void
  4986. _mesa_NewList( GLuint list, GLenum mode )
  4987. {
  4988.    GET_CURRENT_CONTEXT(ctx);
  4989.    FLUSH_CURRENT(ctx, 0);    /* must be called before assert */
  4990.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  4991.  
  4992.    if (MESA_VERBOSE&VERBOSE_API)
  4993.       _mesa_debug(ctx, "glNewList %u %s\n", list,
  4994.                   _mesa_lookup_enum_by_nr(mode));
  4995.  
  4996.    if (list==0) {
  4997.       _mesa_error( ctx, GL_INVALID_VALUE, "glNewList" );
  4998.       return;
  4999.    }
  5000.  
  5001.    if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
  5002.       _mesa_error( ctx, GL_INVALID_ENUM, "glNewList" );
  5003.       return;
  5004.    }
  5005.  
  5006.    if (ctx->CurrentListPtr) {
  5007.       /* already compiling a display list */
  5008.       _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
  5009.       return;
  5010.    }
  5011.  
  5012.    /* Allocate new display list */
  5013.    ctx->CurrentListNum = list;
  5014.    ctx->CurrentBlock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
  5015.    ctx->CurrentListPtr = ctx->CurrentBlock;
  5016.    ctx->CurrentPos = 0;
  5017.    ctx->CompileFlag = GL_TRUE;
  5018.    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
  5019.  
  5020.    ctx->Driver.NewList( ctx, list, mode );
  5021.  
  5022.    ctx->CurrentDispatch = ctx->Save;
  5023.    _glapi_set_dispatch( ctx->CurrentDispatch );
  5024. }
  5025.  
  5026.  
  5027.  
  5028. /*
  5029.  * End definition of current display list.  Is the current
  5030.  * ASSERT_OUTSIDE_BEGIN_END strong enough to really guarentee that
  5031.  * we are outside begin/end calls?
  5032.  */
  5033. void
  5034. _mesa_EndList( void )
  5035. {
  5036.    GET_CURRENT_CONTEXT(ctx);
  5037.    FLUSH_CURRENT(ctx, 0);    /* must be called before assert */
  5038.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  5039.  
  5040.    if (MESA_VERBOSE&VERBOSE_API)
  5041.       _mesa_debug(ctx, "glEndList\n");
  5042.  
  5043.    /* Check that a list is under construction */
  5044.    if (!ctx->CurrentListPtr) {
  5045.       _mesa_error( ctx, GL_INVALID_OPERATION, "glEndList" );
  5046.       return;
  5047.    }
  5048.  
  5049.    (void) ALLOC_INSTRUCTION( ctx, OPCODE_END_OF_LIST, 0 );
  5050.  
  5051.    /* Destroy old list, if any */
  5052.    _mesa_destroy_list(ctx, ctx->CurrentListNum);
  5053.    /* Install the list */
  5054.    _mesa_HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);
  5055.  
  5056.  
  5057.    if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
  5058.       mesa_print_display_list(ctx->CurrentListNum);
  5059.  
  5060.    ctx->CurrentListNum = 0;
  5061.    ctx->CurrentListPtr = NULL;
  5062.    ctx->ExecuteFlag = GL_TRUE;
  5063.    ctx->CompileFlag = GL_FALSE;
  5064.  
  5065.    ctx->Driver.EndList( ctx );
  5066.  
  5067.    ctx->CurrentDispatch = ctx->Exec;
  5068.    _glapi_set_dispatch( ctx->CurrentDispatch );
  5069. }
  5070.  
  5071.  
  5072.  
  5073. void
  5074. _mesa_CallList( GLuint list )
  5075. {
  5076.    GLboolean save_compile_flag;
  5077.    GET_CURRENT_CONTEXT(ctx);
  5078.    FLUSH_CURRENT(ctx, 0);
  5079.    /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
  5080.    /* execute the display list, and restore the CompileFlag. */
  5081.  
  5082.  
  5083.    if (MESA_VERBOSE & VERBOSE_API)
  5084.       _mesa_debug(ctx, "_mesa_CallList %d\n", list); 
  5085.  
  5086. /*     mesa_print_display_list( list ); */
  5087.  
  5088.    save_compile_flag = ctx->CompileFlag;
  5089.    if (save_compile_flag) {
  5090.       ctx->CompileFlag = GL_FALSE;
  5091.    }
  5092.  
  5093.    execute_list( ctx, list );
  5094.    ctx->CompileFlag = save_compile_flag;
  5095.  
  5096.    /* also restore API function pointers to point to "save" versions */
  5097.    if (save_compile_flag) {
  5098.       ctx->CurrentDispatch = ctx->Save;
  5099.       _glapi_set_dispatch( ctx->CurrentDispatch );
  5100.    }
  5101. }
  5102.  
  5103.  
  5104.  
  5105. /*
  5106.  * Execute glCallLists:  call multiple display lists.
  5107.  */
  5108. void
  5109. _mesa_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
  5110. {
  5111.    GET_CURRENT_CONTEXT(ctx);
  5112.    GLuint list;
  5113.    GLint i;
  5114.    GLboolean save_compile_flag;
  5115.  
  5116.    if (MESA_VERBOSE & VERBOSE_API)
  5117.       _mesa_debug(ctx, "_mesa_CallLists %d\n", n); 
  5118.  
  5119.    switch (type) {
  5120.       case GL_BYTE:
  5121.       case GL_UNSIGNED_BYTE:
  5122.       case GL_SHORT:
  5123.       case GL_UNSIGNED_SHORT:
  5124.       case GL_INT:
  5125.       case GL_UNSIGNED_INT:
  5126.       case GL_FLOAT:
  5127.       case GL_2_BYTES:
  5128.       case GL_3_BYTES:
  5129.       case GL_4_BYTES:
  5130.          /* OK */
  5131.          break;
  5132.       default:
  5133.          _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
  5134.          return;
  5135.    }
  5136.  
  5137.    /* Save the CompileFlag status, turn it off, execute display list,
  5138.     * and restore the CompileFlag.
  5139.     */
  5140.    save_compile_flag = ctx->CompileFlag;
  5141.    ctx->CompileFlag = GL_FALSE;
  5142.  
  5143.    for (i=0;i<n;i++) {
  5144.       list = translate_id( i, type, lists );
  5145.       execute_list( ctx, ctx->List.ListBase + list );
  5146.    }
  5147.  
  5148.    ctx->CompileFlag = save_compile_flag;
  5149.  
  5150.    /* also restore API function pointers to point to "save" versions */
  5151.    if (save_compile_flag) {
  5152.       ctx->CurrentDispatch = ctx->Save;
  5153.       _glapi_set_dispatch( ctx->CurrentDispatch );
  5154.    }
  5155. }
  5156.  
  5157.  
  5158.  
  5159. /*
  5160.  * Set the offset added to list numbers in glCallLists.
  5161.  */
  5162. void
  5163. _mesa_ListBase( GLuint base )
  5164. {
  5165.    GET_CURRENT_CONTEXT(ctx);
  5166.    FLUSH_VERTICES(ctx, 0);    /* must be called before assert */
  5167.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  5168.    ctx->List.ListBase = base;
  5169. }
  5170.  
  5171.  
  5172. /* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
  5173.  */
  5174. static void exec_Finish( void )
  5175. {
  5176.    GET_CURRENT_CONTEXT(ctx);
  5177.    FLUSH_VERTICES(ctx, 0);
  5178.    ctx->Exec->Finish();
  5179. }
  5180.  
  5181. static void exec_Flush( void )
  5182. {
  5183.    GET_CURRENT_CONTEXT(ctx);
  5184.    FLUSH_VERTICES(ctx, 0);
  5185.    ctx->Exec->Flush( );
  5186. }
  5187.  
  5188. static void exec_GetBooleanv( GLenum pname, GLboolean *params )
  5189. {
  5190.    GET_CURRENT_CONTEXT(ctx);
  5191.    FLUSH_VERTICES(ctx, 0);
  5192.    ctx->Exec->GetBooleanv( pname, params );
  5193. }
  5194.  
  5195. static void exec_GetClipPlane( GLenum plane, GLdouble *equation )
  5196. {
  5197.    GET_CURRENT_CONTEXT(ctx);
  5198.    FLUSH_VERTICES(ctx, 0);
  5199.    ctx->Exec->GetClipPlane( plane, equation );
  5200. }
  5201.  
  5202. static void exec_GetDoublev( GLenum pname, GLdouble *params )
  5203. {
  5204.    GET_CURRENT_CONTEXT(ctx);
  5205.    FLUSH_VERTICES(ctx, 0);
  5206.    ctx->Exec->GetDoublev(  pname, params );
  5207. }
  5208.  
  5209. static GLenum exec_GetError( void )
  5210. {
  5211.    GET_CURRENT_CONTEXT(ctx);
  5212.    FLUSH_VERTICES(ctx, 0);
  5213.    return ctx->Exec->GetError( );
  5214. }
  5215.  
  5216. static void exec_GetFloatv( GLenum pname, GLfloat *params )
  5217. {
  5218.    GET_CURRENT_CONTEXT(ctx);
  5219.    FLUSH_VERTICES(ctx, 0);
  5220.    ctx->Exec->GetFloatv( pname, params );
  5221. }
  5222.  
  5223. static void exec_GetIntegerv( GLenum pname, GLint *params )
  5224. {
  5225.    GET_CURRENT_CONTEXT(ctx);
  5226.    FLUSH_VERTICES(ctx, 0);
  5227.    ctx->Exec->GetIntegerv( pname, params );
  5228. }
  5229.  
  5230. static void exec_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
  5231. {
  5232.    GET_CURRENT_CONTEXT(ctx);
  5233.    FLUSH_VERTICES(ctx, 0);
  5234.    ctx->Exec->GetLightfv( light, pname, params );
  5235. }
  5236.  
  5237. static void exec_GetLightiv( GLenum light, GLenum pname, GLint *params )
  5238. {
  5239.    GET_CURRENT_CONTEXT(ctx);
  5240.    FLUSH_VERTICES(ctx, 0);
  5241.    ctx->Exec->GetLightiv( light, pname, params );
  5242. }
  5243.  
  5244. static void exec_GetMapdv( GLenum target, GLenum query, GLdouble *v )
  5245. {
  5246.    GET_CURRENT_CONTEXT(ctx);
  5247.    FLUSH_VERTICES(ctx, 0);
  5248.    ctx->Exec->GetMapdv( target, query, v );
  5249. }
  5250.  
  5251. static void exec_GetMapfv( GLenum target, GLenum query, GLfloat *v )
  5252. {
  5253.    GET_CURRENT_CONTEXT(ctx);
  5254.    FLUSH_VERTICES(ctx, 0);
  5255.    ctx->Exec->GetMapfv( target, query, v );
  5256. }
  5257.  
  5258. static void exec_GetMapiv( GLenum target, GLenum query, GLint *v )
  5259. {
  5260.    GET_CURRENT_CONTEXT(ctx);
  5261.    FLUSH_VERTICES(ctx, 0);
  5262.    ctx->Exec->GetMapiv( target, query, v );
  5263. }
  5264.  
  5265. static void exec_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
  5266. {
  5267.    GET_CURRENT_CONTEXT(ctx);
  5268.    FLUSH_VERTICES(ctx, 0);
  5269.    ctx->Exec->GetMaterialfv( face, pname, params );
  5270. }
  5271.  
  5272. static void exec_GetMaterialiv( GLenum face, GLenum pname, GLint *params )
  5273. {
  5274.    GET_CURRENT_CONTEXT(ctx);
  5275.    FLUSH_VERTICES(ctx, 0);
  5276.    ctx->Exec->GetMaterialiv( face, pname, params );
  5277. }
  5278.  
  5279. static void exec_GetPixelMapfv( GLenum map, GLfloat *values )
  5280. {
  5281.    GET_CURRENT_CONTEXT(ctx);
  5282.    FLUSH_VERTICES(ctx, 0);
  5283.    ctx->Exec->GetPixelMapfv( map,  values );
  5284. }
  5285.  
  5286. static void exec_GetPixelMapuiv( GLenum map, GLuint *values )
  5287. {
  5288.    GET_CURRENT_CONTEXT(ctx);
  5289.    FLUSH_VERTICES(ctx, 0);
  5290.    ctx->Exec->GetPixelMapuiv( map, values );
  5291. }
  5292.  
  5293. static void exec_GetPixelMapusv( GLenum map, GLushort *values )
  5294. {
  5295.    GET_CURRENT_CONTEXT(ctx);
  5296.    FLUSH_VERTICES(ctx, 0);
  5297.    ctx->Exec->GetPixelMapusv( map, values );
  5298. }
  5299.  
  5300. static void exec_GetPolygonStipple( GLubyte *dest )
  5301. {
  5302.    GET_CURRENT_CONTEXT(ctx);
  5303.    FLUSH_VERTICES(ctx, 0);
  5304.    ctx->Exec->GetPolygonStipple( dest );
  5305. }
  5306.  
  5307. static const GLubyte *exec_GetString( GLenum name )
  5308. {
  5309.    GET_CURRENT_CONTEXT(ctx);
  5310.    FLUSH_VERTICES(ctx, 0);
  5311.    return ctx->Exec->GetString( name );
  5312. }
  5313.  
  5314. static void exec_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
  5315. {
  5316.    GET_CURRENT_CONTEXT(ctx);
  5317.    FLUSH_VERTICES(ctx, 0);
  5318.    ctx->Exec->GetTexEnvfv( target, pname, params );
  5319. }
  5320.  
  5321. static void exec_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
  5322. {
  5323.    GET_CURRENT_CONTEXT(ctx);
  5324.    FLUSH_VERTICES(ctx, 0);
  5325.    ctx->Exec->GetTexEnviv( target, pname, params );
  5326. }
  5327.  
  5328. static void exec_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
  5329. {
  5330.    GET_CURRENT_CONTEXT(ctx);
  5331.    FLUSH_VERTICES(ctx, 0);
  5332.    ctx->Exec->GetTexGendv( coord, pname, params );
  5333. }
  5334.  
  5335. static void exec_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
  5336. {
  5337.    GET_CURRENT_CONTEXT(ctx);
  5338.    FLUSH_VERTICES(ctx, 0);
  5339.    ctx->Exec->GetTexGenfv( coord, pname, params );
  5340. }
  5341.  
  5342. static void exec_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
  5343. {
  5344.    GET_CURRENT_CONTEXT(ctx);
  5345.    FLUSH_VERTICES(ctx, 0);
  5346.    ctx->Exec->GetTexGeniv( coord, pname, params );
  5347. }
  5348.  
  5349. static void exec_GetTexImage( GLenum target, GLint level, GLenum format,
  5350.                    GLenum type, GLvoid *pixels )
  5351. {
  5352.    GET_CURRENT_CONTEXT(ctx);
  5353.    FLUSH_VERTICES(ctx, 0);
  5354.    ctx->Exec->GetTexImage( target, level, format, type, pixels );
  5355. }
  5356.  
  5357. static void exec_GetTexLevelParameterfv( GLenum target, GLint level,
  5358.                               GLenum pname, GLfloat *params )
  5359. {
  5360.    GET_CURRENT_CONTEXT(ctx);
  5361.    FLUSH_VERTICES(ctx, 0);
  5362.    ctx->Exec->GetTexLevelParameterfv( target, level, pname, params );
  5363. }
  5364.  
  5365. static void exec_GetTexLevelParameteriv( GLenum target, GLint level,
  5366.                               GLenum pname, GLint *params )
  5367. {
  5368.    GET_CURRENT_CONTEXT(ctx);
  5369.    FLUSH_VERTICES(ctx, 0);
  5370.    ctx->Exec->GetTexLevelParameteriv( target, level, pname, params );
  5371. }
  5372.  
  5373. static void exec_GetTexParameterfv( GLenum target, GLenum pname,
  5374.                     GLfloat *params )
  5375. {
  5376.    GET_CURRENT_CONTEXT(ctx);
  5377.    FLUSH_VERTICES(ctx, 0);
  5378.    ctx->Exec->GetTexParameterfv( target, pname, params );
  5379. }
  5380.  
  5381. static void exec_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  5382. {
  5383.    GET_CURRENT_CONTEXT(ctx);
  5384.    FLUSH_VERTICES(ctx, 0);
  5385.    ctx->Exec->GetTexParameteriv( target, pname, params );
  5386. }
  5387.  
  5388. static GLboolean exec_IsEnabled( GLenum cap )
  5389. {
  5390.    GET_CURRENT_CONTEXT(ctx);
  5391.    FLUSH_VERTICES(ctx, 0);
  5392.    return ctx->Exec->IsEnabled( cap );
  5393. }
  5394.  
  5395. static void exec_PixelStoref( GLenum pname, GLfloat param )
  5396. {
  5397.    GET_CURRENT_CONTEXT(ctx);
  5398.    FLUSH_VERTICES(ctx, 0);
  5399.    ctx->Exec->PixelStoref( pname, param );
  5400. }
  5401.  
  5402. static void exec_PixelStorei( GLenum pname, GLint param )
  5403. {
  5404.    GET_CURRENT_CONTEXT(ctx);
  5405.    FLUSH_VERTICES(ctx, 0);
  5406.    ctx->Exec->PixelStorei( pname, param );
  5407. }
  5408.  
  5409. static void exec_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  5410.           GLenum format, GLenum type, GLvoid *pixels )
  5411. {
  5412.    GET_CURRENT_CONTEXT(ctx);
  5413.    FLUSH_VERTICES(ctx, 0);
  5414.    ctx->Exec->ReadPixels( x, y, width, height, format, type, pixels );
  5415. }
  5416.  
  5417. static GLint exec_RenderMode( GLenum mode )
  5418. {
  5419.    GET_CURRENT_CONTEXT(ctx);
  5420.    FLUSH_VERTICES(ctx, 0);
  5421.    return ctx->Exec->RenderMode( mode );
  5422. }
  5423.  
  5424. static void exec_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
  5425. {
  5426.    GET_CURRENT_CONTEXT(ctx);
  5427.    FLUSH_VERTICES(ctx, 0);
  5428.    ctx->Exec->FeedbackBuffer( size, type, buffer );
  5429. }
  5430.  
  5431. static void exec_SelectBuffer( GLsizei size, GLuint *buffer )
  5432. {
  5433.    GET_CURRENT_CONTEXT(ctx);
  5434.    FLUSH_VERTICES(ctx, 0);
  5435.    ctx->Exec->SelectBuffer( size, buffer );
  5436. }
  5437.  
  5438. static GLboolean exec_AreTexturesResident(GLsizei n, const GLuint *texName,
  5439.                       GLboolean *residences)
  5440. {
  5441.    GET_CURRENT_CONTEXT(ctx);
  5442.    FLUSH_VERTICES(ctx, 0);
  5443.    return ctx->Exec->AreTexturesResident( n, texName, residences);
  5444. }
  5445.  
  5446. static void exec_ColorPointer(GLint size, GLenum type, GLsizei stride,
  5447.                   const GLvoid *ptr)
  5448. {
  5449.    GET_CURRENT_CONTEXT(ctx);
  5450.    FLUSH_VERTICES(ctx, 0);
  5451.    ctx->Exec->ColorPointer( size, type, stride, ptr);
  5452. }
  5453.  
  5454. static void exec_DeleteTextures( GLsizei n, const GLuint *texName)
  5455. {
  5456.    GET_CURRENT_CONTEXT(ctx);
  5457.    FLUSH_VERTICES(ctx, 0);
  5458.    ctx->Exec->DeleteTextures( n, texName);
  5459. }
  5460.  
  5461. static void exec_DisableClientState( GLenum cap )
  5462. {
  5463.    GET_CURRENT_CONTEXT(ctx);
  5464.    FLUSH_VERTICES(ctx, 0);
  5465.    ctx->Exec->DisableClientState( cap );
  5466. }
  5467.  
  5468. static void exec_EdgeFlagPointer(GLsizei stride, const void *vptr)
  5469. {
  5470.    GET_CURRENT_CONTEXT(ctx);
  5471.    FLUSH_VERTICES(ctx, 0);
  5472.    ctx->Exec->EdgeFlagPointer( stride, vptr);
  5473. }
  5474.  
  5475. static void exec_EnableClientState( GLenum cap )
  5476. {
  5477.    GET_CURRENT_CONTEXT(ctx);
  5478.    FLUSH_VERTICES(ctx, 0);
  5479.    ctx->Exec->EnableClientState( cap );
  5480. }
  5481.  
  5482. static void exec_GenTextures( GLsizei n, GLuint *texName )
  5483. {
  5484.    GET_CURRENT_CONTEXT(ctx);
  5485.    FLUSH_VERTICES(ctx, 0);
  5486.    ctx->Exec->GenTextures( n, texName );
  5487. }
  5488.  
  5489. static void exec_GetPointerv( GLenum pname, GLvoid **params )
  5490. {
  5491.    GET_CURRENT_CONTEXT(ctx);
  5492.    FLUSH_VERTICES(ctx, 0);
  5493.    ctx->Exec->GetPointerv( pname, params );
  5494. }
  5495.  
  5496. static void exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
  5497. {
  5498.    GET_CURRENT_CONTEXT(ctx);
  5499.    FLUSH_VERTICES(ctx, 0);
  5500.    ctx->Exec->IndexPointer( type, stride, ptr);
  5501. }
  5502.  
  5503. static void exec_InterleavedArrays(GLenum format, GLsizei stride,
  5504.                    const GLvoid *pointer)
  5505. {
  5506.    GET_CURRENT_CONTEXT(ctx);
  5507.    FLUSH_VERTICES(ctx, 0);
  5508.    ctx->Exec->InterleavedArrays( format, stride, pointer);
  5509. }
  5510.  
  5511. static GLboolean exec_IsTexture( GLuint texture )
  5512. {
  5513.    GET_CURRENT_CONTEXT(ctx);
  5514.    FLUSH_VERTICES(ctx, 0);
  5515.    return ctx->Exec->IsTexture( texture );
  5516. }
  5517.  
  5518. static void exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
  5519. {
  5520.    GET_CURRENT_CONTEXT(ctx);
  5521.    FLUSH_VERTICES(ctx, 0);
  5522.    ctx->Exec->NormalPointer( type, stride, ptr );
  5523. }
  5524.  
  5525. static void exec_PopClientAttrib(void)
  5526. {
  5527.    GET_CURRENT_CONTEXT(ctx);
  5528.    FLUSH_VERTICES(ctx, 0);
  5529.    ctx->Exec->PopClientAttrib();
  5530. }
  5531.  
  5532. static void exec_PushClientAttrib(GLbitfield mask)
  5533. {
  5534.    GET_CURRENT_CONTEXT(ctx);
  5535.    FLUSH_VERTICES(ctx, 0);
  5536.    ctx->Exec->PushClientAttrib( mask);
  5537. }
  5538.  
  5539. static void exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
  5540.                  const GLvoid *ptr)
  5541. {
  5542.    GET_CURRENT_CONTEXT(ctx);
  5543.    FLUSH_VERTICES(ctx, 0);
  5544.    ctx->Exec->TexCoordPointer( size,  type,  stride, ptr);
  5545. }
  5546.  
  5547. static void exec_GetCompressedTexImageARB(GLenum target, GLint level,
  5548.                       GLvoid *img)
  5549. {
  5550.    GET_CURRENT_CONTEXT(ctx);
  5551.    FLUSH_VERTICES(ctx, 0);
  5552.    ctx->Exec->GetCompressedTexImageARB( target, level, img);
  5553. }
  5554.  
  5555. static void exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
  5556.                    const GLvoid *ptr)
  5557. {
  5558.    GET_CURRENT_CONTEXT(ctx);
  5559.    FLUSH_VERTICES(ctx, 0);
  5560.    ctx->Exec->VertexPointer( size, type, stride, ptr);
  5561. }
  5562.  
  5563. static void exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
  5564.                      GLint x, GLint y, GLsizei width)
  5565. {
  5566.    GET_CURRENT_CONTEXT(ctx);
  5567.    FLUSH_VERTICES(ctx, 0);
  5568.    ctx->Exec->CopyConvolutionFilter1D( target, internalFormat, x, y, width);
  5569. }
  5570.  
  5571. static void exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
  5572.                      GLint x, GLint y, GLsizei width,
  5573.                      GLsizei height)
  5574. {
  5575.    GET_CURRENT_CONTEXT(ctx);
  5576.    FLUSH_VERTICES(ctx, 0);
  5577.    ctx->Exec->CopyConvolutionFilter2D( target, internalFormat, x, y, width,
  5578.                        height);
  5579. }
  5580.  
  5581. static void exec_GetColorTable( GLenum target, GLenum format,
  5582.                 GLenum type, GLvoid *data )
  5583. {
  5584.    GET_CURRENT_CONTEXT(ctx);
  5585.    FLUSH_VERTICES(ctx, 0);
  5586.    ctx->Exec->GetColorTable( target, format, type, data );
  5587. }
  5588.  
  5589. static void exec_GetColorTableParameterfv( GLenum target, GLenum pname,
  5590.                        GLfloat *params )
  5591. {
  5592.    GET_CURRENT_CONTEXT(ctx);
  5593.    FLUSH_VERTICES(ctx, 0);
  5594.    ctx->Exec->GetColorTableParameterfv( target, pname, params );
  5595. }
  5596.  
  5597. static void exec_GetColorTableParameteriv( GLenum target, GLenum pname,
  5598.                        GLint *params )
  5599. {
  5600.    GET_CURRENT_CONTEXT(ctx);
  5601.    FLUSH_VERTICES(ctx, 0);
  5602.    ctx->Exec->GetColorTableParameteriv( target, pname, params );
  5603. }
  5604.  
  5605. static void exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
  5606.                       GLvoid *image)
  5607. {
  5608.    GET_CURRENT_CONTEXT(ctx);
  5609.    FLUSH_VERTICES(ctx, 0);
  5610.    ctx->Exec->GetConvolutionFilter( target, format, type, image);
  5611. }
  5612.  
  5613. static void exec_GetConvolutionParameterfv(GLenum target, GLenum pname,
  5614.                        GLfloat *params)
  5615. {
  5616.    GET_CURRENT_CONTEXT(ctx);
  5617.    FLUSH_VERTICES(ctx, 0);
  5618.    ctx->Exec->GetConvolutionParameterfv( target, pname, params);
  5619. }
  5620.  
  5621. static void exec_GetConvolutionParameteriv(GLenum target, GLenum pname,
  5622.                        GLint *params)
  5623. {
  5624.    GET_CURRENT_CONTEXT(ctx);
  5625.    FLUSH_VERTICES(ctx, 0);
  5626.    ctx->Exec->GetConvolutionParameteriv( target, pname, params);
  5627. }
  5628.  
  5629. static void exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
  5630.                   GLenum type, GLvoid *values)
  5631. {
  5632.    GET_CURRENT_CONTEXT(ctx);
  5633.    FLUSH_VERTICES(ctx, 0);
  5634.    ctx->Exec->GetHistogram( target, reset, format, type, values);
  5635. }
  5636.  
  5637. static void exec_GetHistogramParameterfv(GLenum target, GLenum pname,
  5638.                      GLfloat *params)
  5639. {
  5640.    GET_CURRENT_CONTEXT(ctx);
  5641.    FLUSH_VERTICES(ctx, 0);
  5642.    ctx->Exec->GetHistogramParameterfv( target, pname, params);
  5643. }
  5644.  
  5645. static void exec_GetHistogramParameteriv(GLenum target, GLenum pname,
  5646.                      GLint *params)
  5647. {
  5648.    GET_CURRENT_CONTEXT(ctx);
  5649.    FLUSH_VERTICES(ctx, 0);
  5650.    ctx->Exec->GetHistogramParameteriv( target, pname, params);
  5651. }
  5652.  
  5653. static void exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
  5654.                GLenum type, GLvoid *values)
  5655. {
  5656.    GET_CURRENT_CONTEXT(ctx);
  5657.    FLUSH_VERTICES(ctx, 0);
  5658.    ctx->Exec->GetMinmax( target, reset, format, type, values);
  5659. }
  5660.  
  5661. static void exec_GetMinmaxParameterfv(GLenum target, GLenum pname,
  5662.                       GLfloat *params)
  5663. {
  5664.    GET_CURRENT_CONTEXT(ctx);
  5665.    FLUSH_VERTICES(ctx, 0);
  5666.    ctx->Exec->GetMinmaxParameterfv( target, pname, params);
  5667. }
  5668.  
  5669. static void exec_GetMinmaxParameteriv(GLenum target, GLenum pname,
  5670.                       GLint *params)
  5671. {
  5672.    GET_CURRENT_CONTEXT(ctx);
  5673.    FLUSH_VERTICES(ctx, 0);
  5674.    ctx->Exec->GetMinmaxParameteriv( target, pname, params);
  5675. }
  5676.  
  5677. static void exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
  5678.                     GLvoid *row, GLvoid *column, GLvoid *span)
  5679. {
  5680.    GET_CURRENT_CONTEXT(ctx);
  5681.    FLUSH_VERTICES(ctx, 0);
  5682.    ctx->Exec->GetSeparableFilter( target, format, type, row, column, span);
  5683. }
  5684.  
  5685. static void exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
  5686.                    GLsizei width, GLsizei height, GLenum format,
  5687.                    GLenum type, const GLvoid *row,
  5688.                    const GLvoid *column)
  5689. {
  5690.    GET_CURRENT_CONTEXT(ctx);
  5691.    FLUSH_VERTICES(ctx, 0);
  5692.    ctx->Exec->SeparableFilter2D( target, internalFormat, width, height, format,
  5693.                  type, row, column);
  5694. }
  5695.  
  5696. static void exec_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
  5697. {
  5698.    GET_CURRENT_CONTEXT(ctx);
  5699.    FLUSH_VERTICES(ctx, 0);
  5700.    ctx->Exec->GetPixelTexGenParameterivSGIS( target, value);
  5701. }
  5702.  
  5703. static void exec_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
  5704. {
  5705.    GET_CURRENT_CONTEXT(ctx);
  5706.    FLUSH_VERTICES(ctx, 0);
  5707.    ctx->Exec->GetPixelTexGenParameterfvSGIS( target, value);
  5708. }
  5709.  
  5710. static void exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
  5711.                  GLsizei count, const GLvoid *ptr)
  5712. {
  5713.    GET_CURRENT_CONTEXT(ctx);
  5714.    FLUSH_VERTICES(ctx, 0);
  5715.    ctx->Exec->ColorPointerEXT( size, type, stride, count, ptr);
  5716. }
  5717.  
  5718. static void exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count,
  5719.                     const GLboolean *ptr)
  5720. {
  5721.    GET_CURRENT_CONTEXT(ctx);
  5722.    FLUSH_VERTICES(ctx, 0);
  5723.    ctx->Exec->EdgeFlagPointerEXT( stride, count, ptr);
  5724. }
  5725.  
  5726. static void exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
  5727.                       const GLvoid *ptr)
  5728. {
  5729.    GET_CURRENT_CONTEXT(ctx);
  5730.    FLUSH_VERTICES(ctx, 0);
  5731.    ctx->Exec->IndexPointerEXT( type, stride, count, ptr);
  5732. }
  5733.  
  5734. static void exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
  5735.                        const GLvoid *ptr)
  5736. {
  5737.    GET_CURRENT_CONTEXT(ctx);
  5738.    FLUSH_VERTICES(ctx, 0);
  5739.    ctx->Exec->NormalPointerEXT( type, stride, count, ptr);
  5740. }
  5741.  
  5742. static void exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
  5743.                     GLsizei count, const GLvoid *ptr)
  5744. {
  5745.    GET_CURRENT_CONTEXT(ctx);
  5746.    FLUSH_VERTICES(ctx, 0);
  5747.    ctx->Exec->TexCoordPointerEXT( size, type, stride, count, ptr);
  5748. }
  5749.  
  5750. static void exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
  5751.                        GLsizei count, const GLvoid *ptr)
  5752. {
  5753.    GET_CURRENT_CONTEXT(ctx);
  5754.    FLUSH_VERTICES(ctx, 0);
  5755.    ctx->Exec->VertexPointerEXT( size, type, stride, count, ptr);
  5756. }
  5757.  
  5758. static void exec_LockArraysEXT(GLint first, GLsizei count)
  5759. {
  5760.    GET_CURRENT_CONTEXT(ctx);
  5761.    FLUSH_VERTICES(ctx, 0);
  5762.    ctx->Exec->LockArraysEXT( first, count);
  5763. }
  5764.  
  5765. static void exec_UnlockArraysEXT( void )
  5766. {
  5767.    GET_CURRENT_CONTEXT(ctx);
  5768.    FLUSH_VERTICES(ctx, 0);
  5769.    ctx->Exec->UnlockArraysEXT( );
  5770. }
  5771.  
  5772. static void exec_ResizeBuffersMESA( void )
  5773. {
  5774.    GET_CURRENT_CONTEXT(ctx);
  5775.    FLUSH_VERTICES(ctx, 0);
  5776.    ctx->Exec->ResizeBuffersMESA( );
  5777. }
  5778.  
  5779.  
  5780. static void exec_ClientActiveTextureARB( GLenum target )
  5781. {
  5782.    GET_CURRENT_CONTEXT(ctx);
  5783.    FLUSH_VERTICES(ctx, 0);
  5784.    ctx->Exec->ClientActiveTextureARB(target);
  5785. }
  5786.  
  5787. static void exec_SecondaryColorPointerEXT(GLint size, GLenum type,
  5788.                    GLsizei stride, const GLvoid *ptr)
  5789. {
  5790.    GET_CURRENT_CONTEXT(ctx);
  5791.    FLUSH_VERTICES(ctx, 0);
  5792.    ctx->Exec->SecondaryColorPointerEXT( size, type, stride, ptr);
  5793. }
  5794.  
  5795. static void exec_FogCoordPointerEXT(GLenum type, GLsizei stride,
  5796.                     const GLvoid *ptr)
  5797. {
  5798.    GET_CURRENT_CONTEXT(ctx);
  5799.    FLUSH_VERTICES(ctx, 0);
  5800.    ctx->Exec->FogCoordPointerEXT( type, stride, ptr);
  5801. }
  5802.  
  5803. /* GL_EXT_multi_draw_arrays */
  5804. static void exec_MultiDrawArraysEXT(GLenum mode, GLint *first,
  5805.                                     GLsizei *count, GLsizei primcount)
  5806. {
  5807.    GET_CURRENT_CONTEXT(ctx);
  5808.    FLUSH_VERTICES(ctx, 0);
  5809.    ctx->Exec->MultiDrawArraysEXT( mode, first, count, primcount );
  5810. }
  5811.  
  5812. /* GL_EXT_multi_draw_arrays */
  5813. static void exec_MultiDrawElementsEXT(GLenum mode, const GLsizei *count,
  5814.                                       GLenum type, const GLvoid **indices,
  5815.                                       GLsizei primcount)
  5816. {
  5817.    GET_CURRENT_CONTEXT(ctx);
  5818.    FLUSH_VERTICES(ctx, 0);
  5819.    ctx->Exec->MultiDrawElementsEXT(mode, count, type, indices, primcount);
  5820. }
  5821.  
  5822.  
  5823.  
  5824. /*
  5825.  * Assign all the pointers in <table> to point to Mesa's display list
  5826.  * building functions.
  5827.  *
  5828.  * This does not include any of the tnl functions - they are
  5829.  * initialized from _mesa_init_api_defaults and from the active vtxfmt
  5830.  * struct.
  5831.  */
  5832. void
  5833. _mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize )
  5834. {
  5835.    _mesa_init_no_op_table(table, tableSize);
  5836.  
  5837.    _mesa_loopback_init_api_table( table, GL_TRUE );
  5838.  
  5839.    /* GL 1.0 */
  5840.    table->Accum = save_Accum;
  5841.    table->AlphaFunc = save_AlphaFunc;
  5842.    table->Bitmap = save_Bitmap;
  5843.    table->BlendFunc = save_BlendFunc;
  5844.    table->CallList = _mesa_save_CallList;
  5845.    table->CallLists = _mesa_save_CallLists;
  5846.    table->Clear = save_Clear;
  5847.    table->ClearAccum = save_ClearAccum;
  5848.    table->ClearColor = save_ClearColor;
  5849.    table->ClearDepth = save_ClearDepth;
  5850.    table->ClearIndex = save_ClearIndex;
  5851.    table->ClearStencil = save_ClearStencil;
  5852.    table->ClipPlane = save_ClipPlane;
  5853.    table->ColorMask = save_ColorMask;
  5854.    table->ColorMaterial = save_ColorMaterial;
  5855.    table->CopyPixels = save_CopyPixels;
  5856.    table->CullFace = save_CullFace;
  5857.    table->DeleteLists = _mesa_DeleteLists;
  5858.    table->DepthFunc = save_DepthFunc;
  5859.    table->DepthMask = save_DepthMask;
  5860.    table->DepthRange = save_DepthRange;
  5861.    table->Disable = save_Disable;
  5862.    table->DrawBuffer = save_DrawBuffer;
  5863.    table->DrawPixels = save_DrawPixels;
  5864.    table->Enable = save_Enable;
  5865.    table->EndList = _mesa_EndList;
  5866.    table->EvalMesh1 = _mesa_save_EvalMesh1;
  5867.    table->EvalMesh2 = _mesa_save_EvalMesh2;
  5868.    table->Finish = exec_Finish;
  5869.    table->Flush = exec_Flush;
  5870.    table->Fogf = save_Fogf;
  5871.    table->Fogfv = save_Fogfv;
  5872.    table->Fogi = save_Fogi;
  5873.    table->Fogiv = save_Fogiv;
  5874.    table->FrontFace = save_FrontFace;
  5875.    table->Frustum = save_Frustum;
  5876.    table->GenLists = _mesa_GenLists;
  5877.    table->GetBooleanv = exec_GetBooleanv;
  5878.    table->GetClipPlane = exec_GetClipPlane;
  5879.    table->GetDoublev = exec_GetDoublev;
  5880.    table->GetError = exec_GetError;
  5881.    table->GetFloatv = exec_GetFloatv;
  5882.    table->GetIntegerv = exec_GetIntegerv;
  5883.    table->GetLightfv = exec_GetLightfv;
  5884.    table->GetLightiv = exec_GetLightiv;
  5885.    table->GetMapdv = exec_GetMapdv;
  5886.    table->GetMapfv = exec_GetMapfv;
  5887.    table->GetMapiv = exec_GetMapiv;
  5888.    table->GetMaterialfv = exec_GetMaterialfv;
  5889.    table->GetMaterialiv = exec_GetMaterialiv;
  5890.    table->GetPixelMapfv = exec_GetPixelMapfv;
  5891.    table->GetPixelMapuiv = exec_GetPixelMapuiv;
  5892.    table->GetPixelMapusv = exec_GetPixelMapusv;
  5893.    table->GetPolygonStipple = exec_GetPolygonStipple;
  5894.    table->GetString = exec_GetString;
  5895.    table->GetTexEnvfv = exec_GetTexEnvfv;
  5896.    table->GetTexEnviv = exec_GetTexEnviv;
  5897.    table->GetTexGendv = exec_GetTexGendv;
  5898.    table->GetTexGenfv = exec_GetTexGenfv;
  5899.    table->GetTexGeniv = exec_GetTexGeniv;
  5900.    table->GetTexImage = exec_GetTexImage;
  5901.    table->GetTexLevelParameterfv = exec_GetTexLevelParameterfv;
  5902.    table->GetTexLevelParameteriv = exec_GetTexLevelParameteriv;
  5903.    table->GetTexParameterfv = exec_GetTexParameterfv;
  5904.    table->GetTexParameteriv = exec_GetTexParameteriv;
  5905.    table->Hint = save_Hint;
  5906.    table->IndexMask = save_IndexMask;
  5907.    table->InitNames = save_InitNames;
  5908.    table->IsEnabled = exec_IsEnabled;
  5909.    table->IsList = _mesa_IsList;
  5910.    table->LightModelf = save_LightModelf;
  5911.    table->LightModelfv = save_LightModelfv;
  5912.    table->LightModeli = save_LightModeli;
  5913.    table->LightModeliv = save_LightModeliv;
  5914.    table->Lightf = save_Lightf;
  5915.    table->Lightfv = save_Lightfv;
  5916.    table->Lighti = save_Lighti;
  5917.    table->Lightiv = save_Lightiv;
  5918.    table->LineStipple = save_LineStipple;
  5919.    table->LineWidth = save_LineWidth;
  5920.    table->ListBase = save_ListBase;
  5921.    table->LoadIdentity = save_LoadIdentity;
  5922.    table->LoadMatrixd = save_LoadMatrixd;
  5923.    table->LoadMatrixf = save_LoadMatrixf;
  5924.    table->LoadName = save_LoadName;
  5925.    table->LogicOp = save_LogicOp;
  5926.    table->Map1d = save_Map1d;
  5927.    table->Map1f = save_Map1f;
  5928.    table->Map2d = save_Map2d;
  5929.    table->Map2f = save_Map2f;
  5930.    table->MapGrid1d = save_MapGrid1d;
  5931.    table->MapGrid1f = save_MapGrid1f;
  5932.    table->MapGrid2d = save_MapGrid2d;
  5933.    table->MapGrid2f = save_MapGrid2f;
  5934.    table->MatrixMode = save_MatrixMode;
  5935.    table->MultMatrixd = save_MultMatrixd;
  5936.    table->MultMatrixf = save_MultMatrixf;
  5937.    table->NewList = save_NewList;
  5938.    table->Ortho = save_Ortho;
  5939.    table->PassThrough = save_PassThrough;
  5940.    table->PixelMapfv = save_PixelMapfv;
  5941.    table->PixelMapuiv = save_PixelMapuiv;
  5942.    table->PixelMapusv = save_PixelMapusv;
  5943.    table->PixelStoref = exec_PixelStoref;
  5944.    table->PixelStorei = exec_PixelStorei;
  5945.    table->PixelTransferf = save_PixelTransferf;
  5946.    table->PixelTransferi = save_PixelTransferi;
  5947.    table->PixelZoom = save_PixelZoom;
  5948.    table->PointSize = save_PointSize;
  5949.    table->PolygonMode = save_PolygonMode;
  5950.    table->PolygonOffset = save_PolygonOffset;
  5951.    table->PolygonStipple = save_PolygonStipple;
  5952.    table->PopAttrib = save_PopAttrib;
  5953.    table->PopMatrix = save_PopMatrix;
  5954.    table->PopName = save_PopName;
  5955.    table->PushAttrib = save_PushAttrib;
  5956.    table->PushMatrix = save_PushMatrix;
  5957.    table->PushName = save_PushName;
  5958.    table->RasterPos2d = save_RasterPos2d;
  5959.    table->RasterPos2dv = save_RasterPos2dv;
  5960.    table->RasterPos2f = save_RasterPos2f;
  5961.    table->RasterPos2fv = save_RasterPos2fv;
  5962.    table->RasterPos2i = save_RasterPos2i;
  5963.    table->RasterPos2iv = save_RasterPos2iv;
  5964.    table->RasterPos2s = save_RasterPos2s;
  5965.    table->RasterPos2sv = save_RasterPos2sv;
  5966.    table->RasterPos3d = save_RasterPos3d;
  5967.    table->RasterPos3dv = save_RasterPos3dv;
  5968.    table->RasterPos3f = save_RasterPos3f;
  5969.    table->RasterPos3fv = save_RasterPos3fv;
  5970.    table->RasterPos3i = save_RasterPos3i;
  5971.    table->RasterPos3iv = save_RasterPos3iv;
  5972.    table->RasterPos3s = save_RasterPos3s;
  5973.    table->RasterPos3sv = save_RasterPos3sv;
  5974.    table->RasterPos4d = save_RasterPos4d;
  5975.    table->RasterPos4dv = save_RasterPos4dv;
  5976.    table->RasterPos4f = save_RasterPos4f;
  5977.    table->RasterPos4fv = save_RasterPos4fv;
  5978.    table->RasterPos4i = save_RasterPos4i;
  5979.    table->RasterPos4iv = save_RasterPos4iv;
  5980.    table->RasterPos4s = save_RasterPos4s;
  5981.    table->RasterPos4sv = save_RasterPos4sv;
  5982.    table->ReadBuffer = save_ReadBuffer;
  5983.    table->ReadPixels = exec_ReadPixels;
  5984.    table->RenderMode = exec_RenderMode;
  5985.    table->Rotated = save_Rotated;
  5986.    table->Rotatef = save_Rotatef;
  5987.    table->Scaled = save_Scaled;
  5988.    table->Scalef = save_Scalef;
  5989.    table->Scissor = save_Scissor;
  5990.    table->FeedbackBuffer = exec_FeedbackBuffer;
  5991.    table->SelectBuffer = exec_SelectBuffer;
  5992.    table->ShadeModel = save_ShadeModel;
  5993.    table->StencilFunc = save_StencilFunc;
  5994.    table->StencilMask = save_StencilMask;
  5995.    table->StencilOp = save_StencilOp;
  5996.    table->TexEnvf = save_TexEnvf;
  5997.    table->TexEnvfv = save_TexEnvfv;
  5998.    table->TexEnvi = save_TexEnvi;
  5999.    table->TexEnviv = save_TexEnviv;
  6000.    table->TexGend = save_TexGend;
  6001.    table->TexGendv = save_TexGendv;
  6002.    table->TexGenf = save_TexGenf;
  6003.    table->TexGenfv = save_TexGenfv;
  6004.    table->TexGeni = save_TexGeni;
  6005.    table->TexGeniv = save_TexGeniv;
  6006.    table->TexImage1D = save_TexImage1D;
  6007.    table->TexImage2D = save_TexImage2D;
  6008.    table->TexParameterf = save_TexParameterf;
  6009.    table->TexParameterfv = save_TexParameterfv;
  6010.    table->TexParameteri = save_TexParameteri;
  6011.    table->TexParameteriv = save_TexParameteriv;
  6012.    table->Translated = save_Translated;
  6013.    table->Translatef = save_Translatef;
  6014.    table->Viewport = save_Viewport;
  6015.  
  6016.    /* GL 1.1 */
  6017.    table->AreTexturesResident = exec_AreTexturesResident;
  6018.    table->AreTexturesResidentEXT = exec_AreTexturesResident;
  6019.    table->BindTexture = save_BindTexture;
  6020.    table->ColorPointer = exec_ColorPointer;
  6021.    table->CopyTexImage1D = save_CopyTexImage1D;
  6022.    table->CopyTexImage2D = save_CopyTexImage2D;
  6023.    table->CopyTexSubImage1D = save_CopyTexSubImage1D;
  6024.    table->CopyTexSubImage2D = save_CopyTexSubImage2D;
  6025.    table->DeleteTextures = exec_DeleteTextures;
  6026.    table->DisableClientState = exec_DisableClientState;
  6027.    table->EdgeFlagPointer = exec_EdgeFlagPointer;
  6028.    table->EnableClientState = exec_EnableClientState;
  6029.    table->GenTextures = exec_GenTextures;
  6030.    table->GenTexturesEXT = exec_GenTextures;
  6031.    table->GetPointerv = exec_GetPointerv;
  6032.    table->IndexPointer = exec_IndexPointer;
  6033.    table->InterleavedArrays = exec_InterleavedArrays;
  6034.    table->IsTexture = exec_IsTexture;
  6035.    table->IsTextureEXT = exec_IsTexture;
  6036.    table->NormalPointer = exec_NormalPointer;
  6037.    table->PopClientAttrib = exec_PopClientAttrib;
  6038.    table->PrioritizeTextures = save_PrioritizeTextures;
  6039.    table->PushClientAttrib = exec_PushClientAttrib;
  6040.    table->TexCoordPointer = exec_TexCoordPointer;
  6041.    table->TexSubImage1D = save_TexSubImage1D;
  6042.    table->TexSubImage2D = save_TexSubImage2D;
  6043.    table->VertexPointer = exec_VertexPointer;
  6044.  
  6045.    /* GL 1.2 */
  6046.    table->CopyTexSubImage3D = save_CopyTexSubImage3D;
  6047.    table->TexImage3D = save_TexImage3D;
  6048.    table->TexSubImage3D = save_TexSubImage3D;
  6049.  
  6050.    /* GL_ARB_imaging */
  6051.    /* Not all are supported */
  6052.    table->BlendColor = save_BlendColor;
  6053.    table->BlendEquation = save_BlendEquation;
  6054.    table->ColorSubTable = save_ColorSubTable;
  6055.    table->ColorTable = save_ColorTable;
  6056.    table->ColorTableParameterfv = save_ColorTableParameterfv;
  6057.    table->ColorTableParameteriv = save_ColorTableParameteriv;
  6058.    table->ConvolutionFilter1D = save_ConvolutionFilter1D;
  6059.    table->ConvolutionFilter2D = save_ConvolutionFilter2D;
  6060.    table->ConvolutionParameterf = save_ConvolutionParameterf;
  6061.    table->ConvolutionParameterfv = save_ConvolutionParameterfv;
  6062.    table->ConvolutionParameteri = save_ConvolutionParameteri;
  6063.    table->ConvolutionParameteriv = save_ConvolutionParameteriv;
  6064.    table->CopyColorSubTable = save_CopyColorSubTable;
  6065.    table->CopyColorTable = save_CopyColorTable;
  6066.    table->CopyConvolutionFilter1D = exec_CopyConvolutionFilter1D;
  6067.    table->CopyConvolutionFilter2D = exec_CopyConvolutionFilter2D;
  6068.    table->GetColorTable = exec_GetColorTable;
  6069.    table->GetColorTableEXT = exec_GetColorTable;
  6070.    table->GetColorTableParameterfv = exec_GetColorTableParameterfv;
  6071.    table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
  6072.    table->GetColorTableParameteriv = exec_GetColorTableParameteriv;
  6073.    table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
  6074.    table->GetConvolutionFilter = exec_GetConvolutionFilter;
  6075.    table->GetConvolutionFilterEXT = exec_GetConvolutionFilter;
  6076.    table->GetConvolutionParameterfv = exec_GetConvolutionParameterfv;
  6077.    table->GetConvolutionParameterfvEXT = exec_GetConvolutionParameterfv;
  6078.    table->GetConvolutionParameteriv = exec_GetConvolutionParameteriv;
  6079.    table->GetConvolutionParameterivEXT = exec_GetConvolutionParameteriv;
  6080.    table->GetHistogram = exec_GetHistogram;
  6081.    table->GetHistogramEXT = exec_GetHistogram;
  6082.    table->GetHistogramParameterfv = exec_GetHistogramParameterfv;
  6083.    table->GetHistogramParameterfvEXT = exec_GetHistogramParameterfv;
  6084.    table->GetHistogramParameteriv = exec_GetHistogramParameteriv;
  6085.    table->GetHistogramParameterivEXT = exec_GetHistogramParameteriv;
  6086.    table->GetMinmax = exec_GetMinmax;
  6087.    table->GetMinmaxEXT = exec_GetMinmax;
  6088.    table->GetMinmaxParameterfv = exec_GetMinmaxParameterfv;
  6089.    table->GetMinmaxParameterfvEXT = exec_GetMinmaxParameterfv;
  6090.    table->GetMinmaxParameteriv = exec_GetMinmaxParameteriv;
  6091.    table->GetMinmaxParameterivEXT = exec_GetMinmaxParameteriv;
  6092.    table->GetSeparableFilter = exec_GetSeparableFilter;
  6093.    table->GetSeparableFilterEXT = exec_GetSeparableFilter;
  6094.    table->Histogram = save_Histogram;
  6095.    table->Minmax = save_Minmax;
  6096.    table->ResetHistogram = save_ResetHistogram;
  6097.    table->ResetMinmax = save_ResetMinmax;
  6098.    table->SeparableFilter2D = exec_SeparableFilter2D;
  6099.  
  6100.    /* 2. GL_EXT_blend_color */
  6101. #if 0
  6102.    table->BlendColorEXT = save_BlendColorEXT;
  6103. #endif
  6104.  
  6105.    /* 3. GL_EXT_polygon_offset */
  6106.    table->PolygonOffsetEXT = save_PolygonOffsetEXT;
  6107.  
  6108.    /* 6. GL_EXT_texture3d */
  6109. #if 0
  6110.    table->CopyTexSubImage3DEXT = save_CopyTexSubImage3D;
  6111.    table->TexImage3DEXT = save_TexImage3DEXT;
  6112.    table->TexSubImage3DEXT = save_TexSubImage3D;
  6113. #endif
  6114.  
  6115.    /* 15. GL_SGIX_pixel_texture */
  6116.    table->PixelTexGenSGIX = save_PixelTexGenSGIX;
  6117.  
  6118.    /* 15. GL_SGIS_pixel_texture */
  6119.    table->PixelTexGenParameteriSGIS = save_PixelTexGenParameteriSGIS;
  6120.    table->PixelTexGenParameterfSGIS = save_PixelTexGenParameterfSGIS;
  6121.    table->PixelTexGenParameterivSGIS = save_PixelTexGenParameterivSGIS;
  6122.    table->PixelTexGenParameterfvSGIS = save_PixelTexGenParameterfvSGIS;
  6123.    table->GetPixelTexGenParameterivSGIS = exec_GetPixelTexGenParameterivSGIS;
  6124.    table->GetPixelTexGenParameterfvSGIS = exec_GetPixelTexGenParameterfvSGIS;
  6125.  
  6126.    /* 30. GL_EXT_vertex_array */
  6127.    table->ColorPointerEXT = exec_ColorPointerEXT;
  6128.    table->EdgeFlagPointerEXT = exec_EdgeFlagPointerEXT;
  6129.    table->IndexPointerEXT = exec_IndexPointerEXT;
  6130.    table->NormalPointerEXT = exec_NormalPointerEXT;
  6131.    table->TexCoordPointerEXT = exec_TexCoordPointerEXT;
  6132.    table->VertexPointerEXT = exec_VertexPointerEXT;
  6133.  
  6134.    /* 37. GL_EXT_blend_minmax */
  6135. #if 0
  6136.    table->BlendEquationEXT = save_BlendEquationEXT;
  6137. #endif
  6138.  
  6139.    /* 54. GL_EXT_point_parameters */
  6140.    table->PointParameterfEXT = save_PointParameterfEXT;
  6141.    table->PointParameterfvEXT = save_PointParameterfvEXT;
  6142.  
  6143.    /* 78. GL_EXT_paletted_texture */
  6144. #if 0
  6145.    table->ColorTableEXT = save_ColorTable;
  6146.    table->ColorSubTableEXT = save_ColorSubTable;
  6147. #endif
  6148.    table->GetColorTableEXT = exec_GetColorTable;
  6149.    table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
  6150.    table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
  6151.  
  6152.    /* 97. GL_EXT_compiled_vertex_array */
  6153.    table->LockArraysEXT = exec_LockArraysEXT;
  6154.    table->UnlockArraysEXT = exec_UnlockArraysEXT;
  6155.  
  6156.    /* 145. GL_EXT_secondary_color */
  6157.    table->SecondaryColorPointerEXT = exec_SecondaryColorPointerEXT;
  6158.  
  6159.    /* 148. GL_EXT_multi_draw_arrays */
  6160.    table->MultiDrawArraysEXT = exec_MultiDrawArraysEXT;
  6161.    table->MultiDrawElementsEXT = exec_MultiDrawElementsEXT;
  6162.  
  6163.    /* 149. GL_EXT_fog_coord */
  6164.    table->FogCoordPointerEXT = exec_FogCoordPointerEXT;
  6165.  
  6166.    /* 173. GL_EXT_blend_func_separate */
  6167.    table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT;
  6168.  
  6169.    /* 196. GL_MESA_resize_buffers */
  6170.    table->ResizeBuffersMESA = exec_ResizeBuffersMESA;
  6171.  
  6172.    /* 197. GL_MESA_window_pos */
  6173.    table->WindowPos2dMESA = save_WindowPos2dMESA;
  6174.    table->WindowPos2dvMESA = save_WindowPos2dvMESA;
  6175.    table->WindowPos2fMESA = save_WindowPos2fMESA;
  6176.    table->WindowPos2fvMESA = save_WindowPos2fvMESA;
  6177.    table->WindowPos2iMESA = save_WindowPos2iMESA;
  6178.    table->WindowPos2ivMESA = save_WindowPos2ivMESA;
  6179.    table->WindowPos2sMESA = save_WindowPos2sMESA;
  6180.    table->WindowPos2svMESA = save_WindowPos2svMESA;
  6181.    table->WindowPos3dMESA = save_WindowPos3dMESA;
  6182.    table->WindowPos3dvMESA = save_WindowPos3dvMESA;
  6183.    table->WindowPos3fMESA = save_WindowPos3fMESA;
  6184.    table->WindowPos3fvMESA = save_WindowPos3fvMESA;
  6185.    table->WindowPos3iMESA = save_WindowPos3iMESA;
  6186.    table->WindowPos3ivMESA = save_WindowPos3ivMESA;
  6187.    table->WindowPos3sMESA = save_WindowPos3sMESA;
  6188.    table->WindowPos3svMESA = save_WindowPos3svMESA;
  6189.    table->WindowPos4dMESA = save_WindowPos4dMESA;
  6190.    table->WindowPos4dvMESA = save_WindowPos4dvMESA;
  6191.    table->WindowPos4fMESA = save_WindowPos4fMESA;
  6192.    table->WindowPos4fvMESA = save_WindowPos4fvMESA;
  6193.    table->WindowPos4iMESA = save_WindowPos4iMESA;
  6194.    table->WindowPos4ivMESA = save_WindowPos4ivMESA;
  6195.    table->WindowPos4sMESA = save_WindowPos4sMESA;
  6196.    table->WindowPos4svMESA = save_WindowPos4svMESA;
  6197.  
  6198. #if FEATURE_NV_vertex_program
  6199.    /* 233. GL_NV_vertex_program */
  6200.    /* The following commands DO NOT go into display lists:
  6201.     * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
  6202.     * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
  6203.     */
  6204.    table->BindProgramNV = save_BindProgramNV;
  6205.    table->DeleteProgramsNV = _mesa_DeleteProgramsNV;
  6206.    table->ExecuteProgramNV = save_ExecuteProgramNV;
  6207.    table->GenProgramsNV = _mesa_GenProgramsNV;
  6208.    table->AreProgramsResidentNV = _mesa_AreProgramsResidentNV;
  6209.    table->RequestResidentProgramsNV = _mesa_RequestResidentProgramsNV;
  6210.    table->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV;
  6211.    table->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV;
  6212.    table->GetProgramivNV = _mesa_GetProgramivNV;
  6213.    table->GetProgramStringNV = _mesa_GetProgramStringNV;
  6214.    table->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV;
  6215.    table->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
  6216.    table->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
  6217.    table->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
  6218.    table->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
  6219.    table->IsProgramNV = _mesa_IsProgramNV;
  6220.    table->LoadProgramNV = _mesa_LoadProgramNV;
  6221.    table->ProgramParameter4dNV = save_ProgramParameter4dNV;
  6222.    table->ProgramParameter4dvNV = save_ProgramParameter4dvNV;
  6223.    table->ProgramParameter4fNV = save_ProgramParameter4fNV;
  6224.    table->ProgramParameter4fvNV = save_ProgramParameter4fvNV;
  6225.    table->ProgramParameters4dvNV = save_ProgramParameters4dvNV;
  6226.    table->ProgramParameters4fvNV = save_ProgramParameters4fvNV;
  6227.    table->TrackMatrixNV = save_TrackMatrixNV;
  6228.    table->VertexAttribPointerNV = _mesa_VertexAttribPointerNV;
  6229. #endif
  6230.  
  6231.    /* 262. GL_NV_point_sprite */
  6232.    table->PointParameteriNV = save_PointParameteriNV;
  6233.    table->PointParameterivNV = save_PointParameterivNV;
  6234.  
  6235.    /* 268. GL_EXT_stencil_two_side */
  6236.    table->ActiveStencilFaceEXT = save_ActiveStencilFaceEXT;
  6237.  
  6238.    /* ARB 1. GL_ARB_multitexture */
  6239.    table->ActiveTextureARB = save_ActiveTextureARB;
  6240.    table->ClientActiveTextureARB = exec_ClientActiveTextureARB;
  6241.  
  6242.    /* ARB 3. GL_ARB_transpose_matrix */
  6243.    table->LoadTransposeMatrixdARB = save_LoadTransposeMatrixdARB;
  6244.    table->LoadTransposeMatrixfARB = save_LoadTransposeMatrixfARB;
  6245.    table->MultTransposeMatrixdARB = save_MultTransposeMatrixdARB;
  6246.    table->MultTransposeMatrixfARB = save_MultTransposeMatrixfARB;
  6247.  
  6248.    /* ARB 5. GL_ARB_multisample */
  6249.    table->SampleCoverageARB = save_SampleCoverageARB;
  6250.  
  6251.    /* ARB 12. GL_ARB_texture_compression */
  6252.    table->CompressedTexImage3DARB = save_CompressedTexImage3DARB;
  6253.    table->CompressedTexImage2DARB = save_CompressedTexImage2DARB;
  6254.    table->CompressedTexImage1DARB = save_CompressedTexImage1DARB;
  6255.    table->CompressedTexSubImage3DARB = save_CompressedTexSubImage3DARB;
  6256.    table->CompressedTexSubImage2DARB = save_CompressedTexSubImage2DARB;
  6257.    table->CompressedTexSubImage1DARB = save_CompressedTexSubImage1DARB;
  6258.    table->GetCompressedTexImageARB = exec_GetCompressedTexImageARB;
  6259.  
  6260.    /* ARB 14. GL_ARB_point_parameters */
  6261.    /* re-use EXT_point_parameters functions */
  6262.  
  6263.    /* ARB 25. GL_ARB_window_pos */
  6264.    /* re-use MESA_window_pos functions */
  6265. }
  6266.  
  6267.  
  6268.  
  6269. /***
  6270.  *** Debugging code
  6271.  ***/
  6272. static const char *enum_string( GLenum k )
  6273. {
  6274.    return _mesa_lookup_enum_by_nr( k );
  6275. }
  6276.  
  6277.  
  6278. /*
  6279.  * Print the commands in a display list.  For debugging only.
  6280.  * TODO: many commands aren't handled yet.
  6281.  */
  6282. static void print_list( GLcontext *ctx, GLuint list )
  6283. {
  6284.    Node *n;
  6285.    GLboolean done;
  6286.  
  6287.    if (!glIsList(list)) {
  6288.       _mesa_printf("%u is not a display list ID\n", list);
  6289.       return;
  6290.    }
  6291.  
  6292.    n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
  6293.  
  6294.    _mesa_printf("START-LIST %u, address %p\n", list, (void*)n );
  6295.  
  6296.    done = n ? GL_FALSE : GL_TRUE;
  6297.    while (!done) {
  6298.       OpCode opcode = n[0].opcode;
  6299.       GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
  6300.  
  6301.       if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
  6302.      ctx->listext.opcode[i].print(ctx, &n[1]);
  6303.      n += ctx->listext.opcode[i].size;
  6304.       }
  6305.       else {
  6306.      switch (opcode) {
  6307.          case OPCODE_ACCUM:
  6308.             _mesa_printf("accum %s %g\n", enum_string(n[1].e), n[2].f );
  6309.         break;
  6310.      case OPCODE_BITMAP:
  6311.             _mesa_printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
  6312.                n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data );
  6313.         break;
  6314.          case OPCODE_CALL_LIST:
  6315.             _mesa_printf("CallList %d\n", (int) n[1].ui );
  6316.             break;
  6317.          case OPCODE_CALL_LIST_OFFSET:
  6318.             _mesa_printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
  6319.                     ctx->List.ListBase, ctx->List.ListBase + n[1].ui );
  6320.             break;
  6321.          case OPCODE_COLOR_TABLE_PARAMETER_FV:
  6322.             _mesa_printf("ColorTableParameterfv %s %s %f %f %f %f\n",
  6323.                     enum_string(n[1].e), enum_string(n[2].e),
  6324.                     n[3].f, n[4].f, n[5].f, n[6].f);
  6325.             break;
  6326.          case OPCODE_COLOR_TABLE_PARAMETER_IV:
  6327.             _mesa_printf("ColorTableParameteriv %s %s %d %d %d %d\n",
  6328.                     enum_string(n[1].e), enum_string(n[2].e),
  6329.                     n[3].i, n[4].i, n[5].i, n[6].i);
  6330.             break;
  6331.      case OPCODE_DISABLE:
  6332.             _mesa_printf("Disable %s\n", enum_string(n[1].e));
  6333.         break;
  6334.      case OPCODE_ENABLE:
  6335.             _mesa_printf("Enable %s\n", enum_string(n[1].e));
  6336.         break;
  6337.          case OPCODE_FRUSTUM:
  6338.             _mesa_printf("Frustum %g %g %g %g %g %g\n",
  6339.                     n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  6340.             break;
  6341.      case OPCODE_LINE_STIPPLE:
  6342.         _mesa_printf("LineStipple %d %x\n", n[1].i, (int) n[2].us );
  6343.         break;
  6344.      case OPCODE_LOAD_IDENTITY:
  6345.             _mesa_printf("LoadIdentity\n");
  6346.         break;
  6347.      case OPCODE_LOAD_MATRIX:
  6348.             _mesa_printf("LoadMatrix\n");
  6349.             _mesa_printf("  %8f %8f %8f %8f\n",
  6350.                          n[1].f, n[5].f,  n[9].f, n[13].f);
  6351.             _mesa_printf("  %8f %8f %8f %8f\n",
  6352.                          n[2].f, n[6].f, n[10].f, n[14].f);
  6353.             _mesa_printf("  %8f %8f %8f %8f\n",
  6354.                          n[3].f, n[7].f, n[11].f, n[15].f);
  6355.             _mesa_printf("  %8f %8f %8f %8f\n",
  6356.                          n[4].f, n[8].f, n[12].f, n[16].f);
  6357.         break;
  6358.      case OPCODE_MULT_MATRIX:
  6359.             _mesa_printf("MultMatrix (or Rotate)\n");
  6360.             _mesa_printf("  %8f %8f %8f %8f\n",
  6361.                          n[1].f, n[5].f,  n[9].f, n[13].f);
  6362.             _mesa_printf("  %8f %8f %8f %8f\n",
  6363.                          n[2].f, n[6].f, n[10].f, n[14].f);
  6364.             _mesa_printf("  %8f %8f %8f %8f\n",
  6365.                          n[3].f, n[7].f, n[11].f, n[15].f);
  6366.             _mesa_printf("  %8f %8f %8f %8f\n",
  6367.                          n[4].f, n[8].f, n[12].f, n[16].f);
  6368.         break;
  6369.          case OPCODE_ORTHO:
  6370.             _mesa_printf("Ortho %g %g %g %g %g %g\n",
  6371.                     n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  6372.             break;
  6373.      case OPCODE_POP_ATTRIB:
  6374.             _mesa_printf("PopAttrib\n");
  6375.         break;
  6376.      case OPCODE_POP_MATRIX:
  6377.             _mesa_printf("PopMatrix\n");
  6378.         break;
  6379.      case OPCODE_POP_NAME:
  6380.             _mesa_printf("PopName\n");
  6381.         break;
  6382.      case OPCODE_PUSH_ATTRIB:
  6383.             _mesa_printf("PushAttrib %x\n", n[1].bf );
  6384.         break;
  6385.      case OPCODE_PUSH_MATRIX:
  6386.             _mesa_printf("PushMatrix\n");
  6387.         break;
  6388.      case OPCODE_PUSH_NAME:
  6389.             _mesa_printf("PushName %d\n", (int) n[1].ui );
  6390.         break;
  6391.      case OPCODE_RASTER_POS:
  6392.             _mesa_printf("RasterPos %g %g %g %g\n",
  6393.                          n[1].f, n[2].f,n[3].f,n[4].f);
  6394.         break;
  6395.          case OPCODE_ROTATE:
  6396.             _mesa_printf("Rotate %g %g %g %g\n",
  6397.                          n[1].f, n[2].f, n[3].f, n[4].f );
  6398.             break;
  6399.          case OPCODE_SCALE:
  6400.             _mesa_printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f );
  6401.             break;
  6402.          case OPCODE_TRANSLATE:
  6403.             _mesa_printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f );
  6404.             break;
  6405.          case OPCODE_BIND_TEXTURE:
  6406.         _mesa_printf("BindTexture %s %d\n",
  6407.                          _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
  6408.         break;
  6409.          case OPCODE_SHADE_MODEL:
  6410.         _mesa_printf("ShadeModel %s\n",
  6411.                          _mesa_lookup_enum_by_nr(n[1].ui));
  6412.         break;
  6413.      case OPCODE_MAP1:
  6414.         _mesa_printf("Map1 %s %.3f %.3f %d %d\n", 
  6415.             _mesa_lookup_enum_by_nr(n[1].ui),
  6416.             n[2].f, n[3].f, n[4].i, n[5].i);
  6417.         break;
  6418.      case OPCODE_MAP2:
  6419.         _mesa_printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n", 
  6420.                          _mesa_lookup_enum_by_nr(n[1].ui),
  6421.                          n[2].f, n[3].f, n[4].f, n[5].f,
  6422.                          n[6].i, n[7].i, n[8].i, n[9].i);
  6423.         break;
  6424.      case OPCODE_MAPGRID1:
  6425.         _mesa_printf("MapGrid1 %d %.3f %.3f\n",
  6426.                          n[1].i, n[2].f, n[3].f);
  6427.         break;
  6428.      case OPCODE_MAPGRID2:
  6429.         _mesa_printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n", 
  6430.                          n[1].i, n[2].f, n[3].f,
  6431.                          n[4].i, n[5].f, n[6].f);
  6432.         break;
  6433.      case OPCODE_EVALMESH1:
  6434.         _mesa_printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
  6435.         break;
  6436.      case OPCODE_EVALMESH2:
  6437.         _mesa_printf("EvalMesh2 %d %d %d %d\n",
  6438.                          n[1].i, n[2].i, n[3].i, n[4].i);
  6439.         break;
  6440.  
  6441.      /*
  6442.       * meta opcodes/commands
  6443.       */
  6444.          case OPCODE_ERROR:
  6445.             _mesa_printf("Error: %s %s\n",
  6446.                          enum_string(n[1].e), (const char *)n[2].data );
  6447.             break;
  6448.      case OPCODE_CONTINUE:
  6449.             _mesa_printf("DISPLAY-LIST-CONTINUE\n");
  6450.         n = (Node *) n[1].next;
  6451.         break;
  6452.      case OPCODE_END_OF_LIST:
  6453.             _mesa_printf("END-LIST %u\n", list);
  6454.         done = GL_TRUE;
  6455.         break;
  6456.          default:
  6457.             if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
  6458.                _mesa_printf("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
  6459.                             opcode, (void*) n);
  6460.                return;
  6461.             }
  6462.             else {
  6463.                _mesa_printf("command %d, %u operands\n", opcode, InstSize[opcode]);
  6464.             }
  6465.      }
  6466.      /* increment n to point to next compiled command */
  6467.      if (opcode!=OPCODE_CONTINUE) {
  6468.         n += InstSize[opcode];
  6469.      }
  6470.       }
  6471.    }
  6472. }
  6473.  
  6474.  
  6475.  
  6476. /*
  6477.  * Clients may call this function to help debug display list problems.
  6478.  * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,
  6479.  * changed, or break in the future without notice.
  6480.  */
  6481. void mesa_print_display_list( GLuint list )
  6482. {
  6483.    GET_CURRENT_CONTEXT(ctx);
  6484.    print_list( ctx, list );
  6485. }
  6486.