src/mesa/main/get_gen.py

   1 #!/usr/bin/env python
   2
   3 # Mesa 3-D graphics library
   4 #
   5 # Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining a
   8 # copy of this software and associated documentation files (the "Software"),
   9 # to deal in the Software without restriction, including without limitation
  10 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11 # and/or sell copies of the Software, and to permit persons to whom the
  12 # Software is furnished to do so, subject to the following conditions:
  13 #
  14 # The above copyright notice and this permission notice shall be included
  15 # in all copies or substantial portions of the Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20 # BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24
  25 # This script is used to generate the get.c file:
  26 # python get_gen.py > get.c
  27
  28
  29 import string
  30 import sys
  31
  32
  33 GLint = 1
  34 GLenum = 2
  35 GLfloat = 3
  36 GLdouble = 4
  37 GLboolean = 5
  38 GLfloatN = 6    # A normalized value, such as a color or depth range
  39 GLint64 = 7
  40
  41
  42 TypeStrings = {
  43         GLint : "GLint",
  44         GLenum : "GLenum",
  45         GLfloat : "GLfloat",
  46         GLdouble : "GLdouble",
  47         GLboolean : "GLboolean",
  48         GLint64 : "GLint64"
  49 }
  50
  51
  52 # Each entry is a tuple of:
  53 #  - the GL state name, such as GL_CURRENT_COLOR
  54 #  - the state datatype, one of GLint, GLfloat, GLboolean or GLenum
  55 #  - list of code fragments to get the state, such as ["ctx->Foo.Bar"]
  56 #  - optional extra code or empty string.  If present, "CONVERSION" will be
  57 #    replaced by ENUM_TO_FLOAT, INT_TO_FLOAT, etc.
  58 #  - optional extensions to check, or None
  59 #
  60 StateVars = [
  61         ( "GL_ACCUM_RED_BITS", GLint, ["ctx->DrawBuffer->Visual.accumRedBits"],
  62           "", None ),
  63         ( "GL_ACCUM_GREEN_BITS", GLint, ["ctx->DrawBuffer->Visual.accumGreenBits"],
  64           "", None ),
  65         ( "GL_ACCUM_BLUE_BITS", GLint, ["ctx->DrawBuffer->Visual.accumBlueBits"],
  66           "", None ),
  67         ( "GL_ACCUM_ALPHA_BITS", GLint, ["ctx->DrawBuffer->Visual.accumAlphaBits"],
  68           "", None ),
  69         ( "GL_ACCUM_CLEAR_VALUE", GLfloatN,
  70           [ "ctx->Accum.ClearColor[0]",
  71                 "ctx->Accum.ClearColor[1]",
  72                 "ctx->Accum.ClearColor[2]",
  73                 "ctx->Accum.ClearColor[3]" ],
  74           "", None ),
  75         ( "GL_ALPHA_BIAS", GLfloat, ["ctx->Pixel.AlphaBias"], "", None ),
  76         ( "GL_ALPHA_BITS", GLint, ["ctx->DrawBuffer->Visual.alphaBits"],
  77           "", None ),
  78         ( "GL_ALPHA_SCALE", GLfloat, ["ctx->Pixel.AlphaScale"], "", None ),
  79         ( "GL_ALPHA_TEST", GLboolean, ["ctx->Color.AlphaEnabled"], "", None ),
  80         ( "GL_ALPHA_TEST_FUNC", GLenum, ["ctx->Color.AlphaFunc"], "", None ),
  81         ( "GL_ALPHA_TEST_REF", GLfloatN, ["ctx->Color.AlphaRef"], "", None ),
  82         ( "GL_ATTRIB_STACK_DEPTH", GLint, ["ctx->AttribStackDepth"], "", None ),
  83         ( "GL_AUTO_NORMAL", GLboolean, ["ctx->Eval.AutoNormal"], "", None ),
  84         ( "GL_AUX_BUFFERS", GLint, ["ctx->DrawBuffer->Visual.numAuxBuffers"],
  85           "", None ),
  86         ( "GL_BLEND", GLboolean, ["(ctx->Color.BlendEnabled & 1)"], "", None ),
  87         ( "GL_BLEND_DST", GLenum, ["ctx->Color.BlendDstRGB"], "", None ),
  88         ( "GL_BLEND_SRC", GLenum, ["ctx->Color.BlendSrcRGB"], "", None ),
  89         ( "GL_BLEND_SRC_RGB_EXT", GLenum, ["ctx->Color.BlendSrcRGB"], "", None ),
  90         ( "GL_BLEND_DST_RGB_EXT", GLenum, ["ctx->Color.BlendDstRGB"], "", None ),
  91         ( "GL_BLEND_SRC_ALPHA_EXT", GLenum, ["ctx->Color.BlendSrcA"], "", None ),
  92         ( "GL_BLEND_DST_ALPHA_EXT", GLenum, ["ctx->Color.BlendDstA"], "", None ),
  93         ( "GL_BLEND_EQUATION", GLenum, ["ctx->Color.BlendEquationRGB "], "", None),
  94         ( "GL_BLEND_EQUATION_ALPHA_EXT", GLenum, ["ctx->Color.BlendEquationA "],
  95           "", None ),
  96         ( "GL_BLEND_COLOR_EXT", GLfloatN,
  97           [ "ctx->Color.BlendColor[0]",
  98                 "ctx->Color.BlendColor[1]",
  99                 "ctx->Color.BlendColor[2]",
 100                 "ctx->Color.BlendColor[3]"], "", None ),
 101         ( "GL_BLUE_BIAS", GLfloat, ["ctx->Pixel.BlueBias"], "", None ),
 102         ( "GL_BLUE_BITS", GLint, ["ctx->DrawBuffer->Visual.blueBits"], "", None ),
 103         ( "GL_BLUE_SCALE", GLfloat, ["ctx->Pixel.BlueScale"], "", None ),
 104         ( "GL_CLIENT_ATTRIB_STACK_DEPTH", GLint,
 105           ["ctx->ClientAttribStackDepth"], "", None ),
 106         ( "GL_CLIP_PLANE0", GLboolean,
 107           [ "(ctx->Transform.ClipPlanesEnabled >> 0) & 1" ], "", None ),
 108         ( "GL_CLIP_PLANE1", GLboolean,
 109           [ "(ctx->Transform.ClipPlanesEnabled >> 1) & 1" ], "", None ),
 110         ( "GL_CLIP_PLANE2", GLboolean,
 111           [ "(ctx->Transform.ClipPlanesEnabled >> 2) & 1" ], "", None ),
 112         ( "GL_CLIP_PLANE3", GLboolean,
 113           [ "(ctx->Transform.ClipPlanesEnabled >> 3) & 1" ], "", None ),
 114         ( "GL_CLIP_PLANE4", GLboolean,
 115           [ "(ctx->Transform.ClipPlanesEnabled >> 4) & 1" ], "", None ),
 116         ( "GL_CLIP_PLANE5", GLboolean,
 117           [ "(ctx->Transform.ClipPlanesEnabled >> 5) & 1" ], "", None ),
 118         ( "GL_COLOR_CLEAR_VALUE", GLfloatN,
 119           [ "ctx->Color.ClearColor[0]",
 120                 "ctx->Color.ClearColor[1]",
 121                 "ctx->Color.ClearColor[2]",
 122                 "ctx->Color.ClearColor[3]" ], "", None ),
 123         ( "GL_COLOR_MATERIAL", GLboolean,
 124           ["ctx->Light.ColorMaterialEnabled"], "", None ),
 125         ( "GL_COLOR_MATERIAL_FACE", GLenum,
 126           ["ctx->Light.ColorMaterialFace"], "", None ),
 127         ( "GL_COLOR_MATERIAL_PARAMETER", GLenum,
 128           ["ctx->Light.ColorMaterialMode"], "", None ),
 129         ( "GL_COLOR_WRITEMASK", GLint,
 130           [ "ctx->Color.ColorMask[0][RCOMP] ? 1 : 0",
 131                 "ctx->Color.ColorMask[0][GCOMP] ? 1 : 0",
 132                 "ctx->Color.ColorMask[0][BCOMP] ? 1 : 0",
 133                 "ctx->Color.ColorMask[0][ACOMP] ? 1 : 0" ], "", None ),
 134         ( "GL_CULL_FACE", GLboolean, ["ctx->Polygon.CullFlag"], "", None ),
 135         ( "GL_CULL_FACE_MODE", GLenum, ["ctx->Polygon.CullFaceMode"], "", None ),
 136         ( "GL_CURRENT_COLOR", GLfloatN,
 137           [ "ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]",
 138                 "ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]",
 139                 "ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]",
 140                 "ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]" ],
 141           "FLUSH_CURRENT(ctx, 0);", None ),
 142         ( "GL_CURRENT_INDEX", GLfloat,
 143           [ "ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]" ],
 144           "FLUSH_CURRENT(ctx, 0);", None ),
 145         ( "GL_CURRENT_NORMAL", GLfloatN,
 146           [ "ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]",
 147                 "ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]",
 148                 "ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]"],
 149           "FLUSH_CURRENT(ctx, 0);", None ),
 150         ( "GL_CURRENT_RASTER_COLOR", GLfloatN,
 151           ["ctx->Current.RasterColor[0]",
 152            "ctx->Current.RasterColor[1]",
 153            "ctx->Current.RasterColor[2]",
 154            "ctx->Current.RasterColor[3]"], "", None ),
 155         ( "GL_CURRENT_RASTER_DISTANCE", GLfloat,
 156           ["ctx->Current.RasterDistance"], "", None ),
 157         ( "GL_CURRENT_RASTER_INDEX", GLfloat,
 158           ["1.0"], "", None ),
 159         ( "GL_CURRENT_RASTER_POSITION", GLfloat,
 160           ["ctx->Current.RasterPos[0]",
 161            "ctx->Current.RasterPos[1]",
 162            "ctx->Current.RasterPos[2]",
 163            "ctx->Current.RasterPos[3]"], "", None ),
 164         ( "GL_CURRENT_RASTER_SECONDARY_COLOR", GLfloatN,
 165           ["ctx->Current.RasterSecondaryColor[0]",
 166            "ctx->Current.RasterSecondaryColor[1]",
 167            "ctx->Current.RasterSecondaryColor[2]",
 168            "ctx->Current.RasterSecondaryColor[3]"], "", None ),
 169         ( "GL_CURRENT_RASTER_TEXTURE_COORDS", GLfloat,
 170           ["ctx->Current.RasterTexCoords[unit][0]",
 171            "ctx->Current.RasterTexCoords[unit][1]",
 172            "ctx->Current.RasterTexCoords[unit][2]",
 173            "ctx->Current.RasterTexCoords[unit][3]"],
 174           """const GLuint unit = ctx->Texture.CurrentUnit;
 175          if (unit >= ctx->Const.MaxTextureCoordUnits) {
 176             _mesa_error(ctx, GL_INVALID_OPERATION,
 177                         "glGet(raster tex coords, unit %u)", unit);
 178             return;
 179          }""",
 180           None ),
 181         ( "GL_CURRENT_RASTER_POSITION_VALID", GLboolean,
 182           ["ctx->Current.RasterPosValid"], "", None ),
 183         ( "GL_CURRENT_TEXTURE_COORDS", GLfloat,
 184           ["ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0]",
 185            "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1]",
 186            "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2]",
 187            "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3]"],
 188           """const GLuint unit = ctx->Texture.CurrentUnit;
 189          if (unit >= ctx->Const.MaxTextureCoordUnits) {
 190             _mesa_error(ctx, GL_INVALID_OPERATION,
 191                         "glGet(current tex coords, unit %u)", unit);
 192             return;
 193          }
 194          FLUSH_CURRENT(ctx, 0);""",
 195           None ),
 196         ( "GL_DEPTH_BIAS", GLfloat, ["ctx->Pixel.DepthBias"], "", None ),
 197         ( "GL_DEPTH_BITS", GLint, ["ctx->DrawBuffer->Visual.depthBits"],
 198           "", None ),
 199         ( "GL_DEPTH_CLEAR_VALUE", GLfloatN, ["((GLfloat) ctx->Depth.Clear)"], "", None ),
 200         ( "GL_DEPTH_FUNC", GLenum, ["ctx->Depth.Func"], "", None ),
 201         ( "GL_DEPTH_RANGE", GLfloatN,
 202           [ "ctx->Viewport.Near", "ctx->Viewport.Far" ], "", None ),
 203         ( "GL_DEPTH_SCALE", GLfloat, ["ctx->Pixel.DepthScale"], "", None ),
 204         ( "GL_DEPTH_TEST", GLboolean, ["ctx->Depth.Test"], "", None ),
 205         ( "GL_DEPTH_WRITEMASK", GLboolean, ["ctx->Depth.Mask"], "", None ),
 206         ( "GL_DITHER", GLboolean, ["ctx->Color.DitherFlag"], "", None ),
 207         ( "GL_DOUBLEBUFFER", GLboolean,
 208           ["ctx->DrawBuffer->Visual.doubleBufferMode"], "", None ),
 209         ( "GL_DRAW_BUFFER", GLenum, ["ctx->DrawBuffer->ColorDrawBuffer[0]"], "", None ),
 210         ( "GL_EDGE_FLAG", GLboolean, ["(ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0)"],
 211           "FLUSH_CURRENT(ctx, 0);", None ),
 212         ( "GL_FEEDBACK_BUFFER_SIZE", GLint, ["ctx->Feedback.BufferSize"], "", None ),
 213         ( "GL_FEEDBACK_BUFFER_TYPE", GLenum, ["ctx->Feedback.Type"], "", None ),
 214         ( "GL_FOG", GLboolean, ["ctx->Fog.Enabled"], "", None ),
 215         ( "GL_FOG_COLOR", GLfloatN,
 216           [ "ctx->Fog.Color[0]",
 217                 "ctx->Fog.Color[1]",
 218                 "ctx->Fog.Color[2]",
 219                 "ctx->Fog.Color[3]" ], "", None ),
 220         ( "GL_FOG_DENSITY", GLfloat, ["ctx->Fog.Density"], "", None ),
 221         ( "GL_FOG_END", GLfloat, ["ctx->Fog.End"], "", None ),
 222         ( "GL_FOG_HINT", GLenum, ["ctx->Hint.Fog"], "", None ),
 223         ( "GL_FOG_INDEX", GLfloat, ["ctx->Fog.Index"], "", None ),
 224         ( "GL_FOG_MODE", GLenum, ["ctx->Fog.Mode"], "", None ),
 225         ( "GL_FOG_START", GLfloat, ["ctx->Fog.Start"], "", None ),
 226         ( "GL_FRONT_FACE", GLenum, ["ctx->Polygon.FrontFace"], "", None ),
 227         ( "GL_GREEN_BIAS", GLfloat, ["ctx->Pixel.GreenBias"], "", None ),
 228         ( "GL_GREEN_BITS", GLint, ["ctx->DrawBuffer->Visual.greenBits"],
 229           "", None ),
 230         ( "GL_GREEN_SCALE", GLfloat, ["ctx->Pixel.GreenScale"], "", None ),
 231         ( "GL_INDEX_BITS", GLint, ["ctx->DrawBuffer->Visual.indexBits"],
 232           "", None ),
 233         ( "GL_INDEX_CLEAR_VALUE", GLint, ["ctx->Color.ClearIndex"], "", None ),
 234         ( "GL_INDEX_MODE", GLboolean, ["GL_FALSE"],
 235           "", None ),
 236         ( "GL_INDEX_OFFSET", GLint, ["ctx->Pixel.IndexOffset"], "", None ),
 237         ( "GL_INDEX_SHIFT", GLint, ["ctx->Pixel.IndexShift"], "", None ),
 238         ( "GL_INDEX_WRITEMASK", GLint, ["ctx->Color.IndexMask"], "", None ),
 239         ( "GL_LIGHT0", GLboolean, ["ctx->Light.Light[0].Enabled"], "", None ),
 240         ( "GL_LIGHT1", GLboolean, ["ctx->Light.Light[1].Enabled"], "", None ),
 241         ( "GL_LIGHT2", GLboolean, ["ctx->Light.Light[2].Enabled"], "", None ),
 242         ( "GL_LIGHT3", GLboolean, ["ctx->Light.Light[3].Enabled"], "", None ),
 243         ( "GL_LIGHT4", GLboolean, ["ctx->Light.Light[4].Enabled"], "", None ),
 244         ( "GL_LIGHT5", GLboolean, ["ctx->Light.Light[5].Enabled"], "", None ),
 245         ( "GL_LIGHT6", GLboolean, ["ctx->Light.Light[6].Enabled"], "", None ),
 246         ( "GL_LIGHT7", GLboolean, ["ctx->Light.Light[7].Enabled"], "", None ),
 247         ( "GL_LIGHTING", GLboolean, ["ctx->Light.Enabled"], "", None ),
 248         ( "GL_LIGHT_MODEL_AMBIENT", GLfloatN,
 249           ["ctx->Light.Model.Ambient[0]",
 250            "ctx->Light.Model.Ambient[1]",
 251            "ctx->Light.Model.Ambient[2]",
 252            "ctx->Light.Model.Ambient[3]"], "", None ),
 253         ( "GL_LIGHT_MODEL_COLOR_CONTROL", GLenum,
 254           ["ctx->Light.Model.ColorControl"], "", None ),
 255         ( "GL_LIGHT_MODEL_LOCAL_VIEWER", GLboolean,
 256           ["ctx->Light.Model.LocalViewer"], "", None ),
 257         ( "GL_LIGHT_MODEL_TWO_SIDE", GLboolean, ["ctx->Light.Model.TwoSide"], "", None ),
 258         ( "GL_LINE_SMOOTH", GLboolean, ["ctx->Line.SmoothFlag"], "", None ),
 259         ( "GL_LINE_SMOOTH_HINT", GLenum, ["ctx->Hint.LineSmooth"], "", None ),
 260         ( "GL_LINE_STIPPLE", GLboolean, ["ctx->Line.StippleFlag"], "", None ),
 261         ( "GL_LINE_STIPPLE_PATTERN", GLint, ["ctx->Line.StipplePattern"], "", None ),
 262         ( "GL_LINE_STIPPLE_REPEAT", GLint, ["ctx->Line.StippleFactor"], "", None ),
 263         ( "GL_LINE_WIDTH", GLfloat, ["ctx->Line.Width"], "", None ),
 264         ( "GL_LINE_WIDTH_GRANULARITY", GLfloat,
 265           ["ctx->Const.LineWidthGranularity"], "", None ),
 266         ( "GL_LINE_WIDTH_RANGE", GLfloat,
 267           ["ctx->Const.MinLineWidthAA",
 268            "ctx->Const.MaxLineWidthAA"], "", None ),
 269         ( "GL_ALIASED_LINE_WIDTH_RANGE", GLfloat,
 270           ["ctx->Const.MinLineWidth",
 271            "ctx->Const.MaxLineWidth"], "", None ),
 272         ( "GL_LIST_BASE", GLint, ["ctx->List.ListBase"], "", None ),
 273         ( "GL_LIST_INDEX", GLint, ["(ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0)"], "", None ),
 274         ( "GL_LIST_MODE", GLenum, ["mode"],
 275           """GLenum mode;
 276          if (!ctx->CompileFlag)
 277             mode = 0;
 278          else if (ctx->ExecuteFlag)
 279             mode = GL_COMPILE_AND_EXECUTE;
 280          else
 281             mode = GL_COMPILE;""", None ),
 282         ( "GL_INDEX_LOGIC_OP", GLboolean, ["ctx->Color.IndexLogicOpEnabled"], "", None ),
 283         ( "GL_COLOR_LOGIC_OP", GLboolean, ["ctx->Color.ColorLogicOpEnabled"], "", None ),
 284         ( "GL_LOGIC_OP_MODE", GLenum, ["ctx->Color.LogicOp"], "", None ),
 285         ( "GL_MAP1_COLOR_4", GLboolean, ["ctx->Eval.Map1Color4"], "", None ),
 286         ( "GL_MAP1_GRID_DOMAIN", GLfloat,
 287           ["ctx->Eval.MapGrid1u1",
 288            "ctx->Eval.MapGrid1u2"], "", None ),
 289         ( "GL_MAP1_GRID_SEGMENTS", GLint, ["ctx->Eval.MapGrid1un"], "", None ),
 290         ( "GL_MAP1_INDEX", GLboolean, ["ctx->Eval.Map1Index"], "", None ),
 291         ( "GL_MAP1_NORMAL", GLboolean, ["ctx->Eval.Map1Normal"], "", None ),
 292         ( "GL_MAP1_TEXTURE_COORD_1", GLboolean, ["ctx->Eval.Map1TextureCoord1"], "", None ),
 293         ( "GL_MAP1_TEXTURE_COORD_2", GLboolean, ["ctx->Eval.Map1TextureCoord2"], "", None ),
 294         ( "GL_MAP1_TEXTURE_COORD_3", GLboolean, ["ctx->Eval.Map1TextureCoord3"], "", None ),
 295         ( "GL_MAP1_TEXTURE_COORD_4", GLboolean, ["ctx->Eval.Map1TextureCoord4"], "", None ),
 296         ( "GL_MAP1_VERTEX_3", GLboolean, ["ctx->Eval.Map1Vertex3"], "", None ),
 297         ( "GL_MAP1_VERTEX_4", GLboolean, ["ctx->Eval.Map1Vertex4"], "", None ),
 298         ( "GL_MAP2_COLOR_4", GLboolean, ["ctx->Eval.Map2Color4"], "", None ),
 299         ( "GL_MAP2_GRID_DOMAIN", GLfloat,
 300           ["ctx->Eval.MapGrid2u1",
 301            "ctx->Eval.MapGrid2u2",
 302            "ctx->Eval.MapGrid2v1",
 303            "ctx->Eval.MapGrid2v2"], "", None ),
 304         ( "GL_MAP2_GRID_SEGMENTS", GLint,
 305           ["ctx->Eval.MapGrid2un",
 306            "ctx->Eval.MapGrid2vn"], "", None ),
 307         ( "GL_MAP2_INDEX", GLboolean, ["ctx->Eval.Map2Index"], "", None ),
 308         ( "GL_MAP2_NORMAL", GLboolean, ["ctx->Eval.Map2Normal"], "", None ),
 309         ( "GL_MAP2_TEXTURE_COORD_1", GLboolean, ["ctx->Eval.Map2TextureCoord1"], "", None ),
 310         ( "GL_MAP2_TEXTURE_COORD_2", GLboolean, ["ctx->Eval.Map2TextureCoord2"], "", None ),
 311         ( "GL_MAP2_TEXTURE_COORD_3", GLboolean, ["ctx->Eval.Map2TextureCoord3"], "", None ),
 312         ( "GL_MAP2_TEXTURE_COORD_4", GLboolean, ["ctx->Eval.Map2TextureCoord4"], "", None ),
 313         ( "GL_MAP2_VERTEX_3", GLboolean, ["ctx->Eval.Map2Vertex3"], "", None ),
 314         ( "GL_MAP2_VERTEX_4", GLboolean, ["ctx->Eval.Map2Vertex4"], "", None ),
 315         ( "GL_MAP_COLOR", GLboolean, ["ctx->Pixel.MapColorFlag"], "", None ),
 316         ( "GL_MAP_STENCIL", GLboolean, ["ctx->Pixel.MapStencilFlag"], "", None ),
 317         ( "GL_MATRIX_MODE", GLenum, ["ctx->Transform.MatrixMode"], "", None ),
 318
 319         ( "GL_MAX_ATTRIB_STACK_DEPTH", GLint, ["MAX_ATTRIB_STACK_DEPTH"], "", None ),
 320         ( "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", GLint, ["MAX_CLIENT_ATTRIB_STACK_DEPTH"], "", None ),
 321         ( "GL_MAX_CLIP_PLANES", GLint, ["ctx->Const.MaxClipPlanes"], "", None ),
 322         ( "GL_MAX_ELEMENTS_VERTICES", GLint, ["ctx->Const.MaxArrayLockSize"], "", None ),
 323         ( "GL_MAX_ELEMENTS_INDICES", GLint, ["ctx->Const.MaxArrayLockSize"], "", None ),
 324         ( "GL_MAX_EVAL_ORDER", GLint, ["MAX_EVAL_ORDER"], "", None ),
 325         ( "GL_MAX_LIGHTS", GLint, ["ctx->Const.MaxLights"], "", None ),
 326         ( "GL_MAX_LIST_NESTING", GLint, ["MAX_LIST_NESTING"], "", None ),
 327         ( "GL_MAX_MODELVIEW_STACK_DEPTH", GLint, ["MAX_MODELVIEW_STACK_DEPTH"], "", None ),
 328         ( "GL_MAX_NAME_STACK_DEPTH", GLint, ["MAX_NAME_STACK_DEPTH"], "", None ),
 329         ( "GL_MAX_PIXEL_MAP_TABLE", GLint, ["MAX_PIXEL_MAP_TABLE"], "", None ),
 330         ( "GL_MAX_PROJECTION_STACK_DEPTH", GLint, ["MAX_PROJECTION_STACK_DEPTH"], "", None ),
 331         ( "GL_MAX_TEXTURE_SIZE", GLint, ["1 << (ctx->Const.MaxTextureLevels - 1)"], "", None ),
 332         ( "GL_MAX_3D_TEXTURE_SIZE", GLint, ["1 << (ctx->Const.Max3DTextureLevels - 1)"], "", None ),
 333         ( "GL_MAX_TEXTURE_STACK_DEPTH", GLint, ["MAX_TEXTURE_STACK_DEPTH"], "", None ),
 334         ( "GL_MAX_VIEWPORT_DIMS", GLint,
 335           ["ctx->Const.MaxViewportWidth", "ctx->Const.MaxViewportHeight"],
 336           "", None ),
 337         ( "GL_MODELVIEW_MATRIX", GLfloat,
 338           [ "matrix[0]", "matrix[1]", "matrix[2]", "matrix[3]",
 339                 "matrix[4]", "matrix[5]", "matrix[6]", "matrix[7]",
 340                 "matrix[8]", "matrix[9]", "matrix[10]", "matrix[11]",
 341                 "matrix[12]", "matrix[13]", "matrix[14]", "matrix[15]" ],
 342           "const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;", None ),
 343         ( "GL_MODELVIEW_STACK_DEPTH", GLint, ["ctx->ModelviewMatrixStack.Depth + 1"], "", None ),
 344         ( "GL_NAME_STACK_DEPTH", GLint, ["ctx->Select.NameStackDepth"], "", None ),
 345         ( "GL_NORMALIZE", GLboolean, ["ctx->Transform.Normalize"], "", None ),
 346         ( "GL_PACK_ALIGNMENT", GLint, ["ctx->Pack.Alignment"], "", None ),
 347         ( "GL_PACK_LSB_FIRST", GLboolean, ["ctx->Pack.LsbFirst"], "", None ),
 348         ( "GL_PACK_ROW_LENGTH", GLint, ["ctx->Pack.RowLength"], "", None ),
 349         ( "GL_PACK_SKIP_PIXELS", GLint, ["ctx->Pack.SkipPixels"], "", None ),
 350         ( "GL_PACK_SKIP_ROWS", GLint, ["ctx->Pack.SkipRows"], "", None ),
 351         ( "GL_PACK_SWAP_BYTES", GLboolean, ["ctx->Pack.SwapBytes"], "", None ),
 352         ( "GL_PACK_SKIP_IMAGES_EXT", GLint, ["ctx->Pack.SkipImages"], "", None ),
 353         ( "GL_PACK_IMAGE_HEIGHT_EXT", GLint, ["ctx->Pack.ImageHeight"], "", None ),
 354         ( "GL_PACK_INVERT_MESA", GLboolean, ["ctx->Pack.Invert"], "", None ),
 355         ( "GL_PERSPECTIVE_CORRECTION_HINT", GLenum,
 356           ["ctx->Hint.PerspectiveCorrection"], "", None ),
 357         ( "GL_PIXEL_MAP_A_TO_A_SIZE", GLint, ["ctx->PixelMaps.AtoA.Size"], "", None ),
 358         ( "GL_PIXEL_MAP_B_TO_B_SIZE", GLint, ["ctx->PixelMaps.BtoB.Size"], "", None ),
 359         ( "GL_PIXEL_MAP_G_TO_G_SIZE", GLint, ["ctx->PixelMaps.GtoG.Size"], "", None ),
 360         ( "GL_PIXEL_MAP_I_TO_A_SIZE", GLint, ["ctx->PixelMaps.ItoA.Size"], "", None ),
 361         ( "GL_PIXEL_MAP_I_TO_B_SIZE", GLint, ["ctx->PixelMaps.ItoB.Size"], "", None ),
 362         ( "GL_PIXEL_MAP_I_TO_G_SIZE", GLint, ["ctx->PixelMaps.ItoG.Size"], "", None ),
 363         ( "GL_PIXEL_MAP_I_TO_I_SIZE", GLint, ["ctx->PixelMaps.ItoI.Size"], "", None ),
 364         ( "GL_PIXEL_MAP_I_TO_R_SIZE", GLint, ["ctx->PixelMaps.ItoR.Size"], "", None ),
 365         ( "GL_PIXEL_MAP_R_TO_R_SIZE", GLint, ["ctx->PixelMaps.RtoR.Size"], "", None ),
 366         ( "GL_PIXEL_MAP_S_TO_S_SIZE", GLint, ["ctx->PixelMaps.StoS.Size"], "", None ),
 367         ( "GL_POINT_SIZE", GLfloat, ["ctx->Point.Size"], "", None ),
 368         ( "GL_POINT_SIZE_GRANULARITY", GLfloat,
 369           ["ctx->Const.PointSizeGranularity"], "", None ),
 370         ( "GL_POINT_SIZE_RANGE", GLfloat,
 371           ["ctx->Const.MinPointSizeAA",
 372            "ctx->Const.MaxPointSizeAA"], "", None ),
 373         ( "GL_ALIASED_POINT_SIZE_RANGE", GLfloat,
 374           ["ctx->Const.MinPointSize",
 375            "ctx->Const.MaxPointSize"], "", None ),
 376         ( "GL_POINT_SMOOTH", GLboolean, ["ctx->Point.SmoothFlag"], "", None ),
 377         ( "GL_POINT_SMOOTH_HINT", GLenum, ["ctx->Hint.PointSmooth"], "", None ),
 378         ( "GL_POINT_SIZE_MIN_EXT", GLfloat, ["ctx->Point.MinSize"], "", None ),
 379         ( "GL_POINT_SIZE_MAX_EXT", GLfloat, ["ctx->Point.MaxSize"], "", None ),
 380         ( "GL_POINT_FADE_THRESHOLD_SIZE_EXT", GLfloat,
 381           ["ctx->Point.Threshold"], "", None ),
 382         ( "GL_DISTANCE_ATTENUATION_EXT", GLfloat,
 383           ["ctx->Point.Params[0]",
 384            "ctx->Point.Params[1]",
 385            "ctx->Point.Params[2]"], "", None ),
 386         ( "GL_POLYGON_MODE", GLenum,
 387           ["ctx->Polygon.FrontMode",
 388            "ctx->Polygon.BackMode"], "", None ),
 389         ( "GL_POLYGON_OFFSET_BIAS_EXT", GLfloat, ["ctx->Polygon.OffsetUnits"], "", None ),
 390         ( "GL_POLYGON_OFFSET_FACTOR", GLfloat, ["ctx->Polygon.OffsetFactor "], "", None ),
 391         ( "GL_POLYGON_OFFSET_UNITS", GLfloat, ["ctx->Polygon.OffsetUnits "], "", None ),
 392         ( "GL_POLYGON_OFFSET_POINT", GLboolean, ["ctx->Polygon.OffsetPoint"], "", None ),
 393         ( "GL_POLYGON_OFFSET_LINE", GLboolean, ["ctx->Polygon.OffsetLine"], "", None ),
 394         ( "GL_POLYGON_OFFSET_FILL", GLboolean, ["ctx->Polygon.OffsetFill"], "", None ),
 395         ( "GL_POLYGON_SMOOTH", GLboolean, ["ctx->Polygon.SmoothFlag"], "", None ),
 396         ( "GL_POLYGON_SMOOTH_HINT", GLenum, ["ctx->Hint.PolygonSmooth"], "", None ),
 397         ( "GL_POLYGON_STIPPLE", GLboolean, ["ctx->Polygon.StippleFlag"], "", None ),
 398         ( "GL_PROJECTION_MATRIX", GLfloat,
 399           [ "matrix[0]", "matrix[1]", "matrix[2]", "matrix[3]",
 400                 "matrix[4]", "matrix[5]", "matrix[6]", "matrix[7]",
 401                 "matrix[8]", "matrix[9]", "matrix[10]", "matrix[11]",
 402                 "matrix[12]", "matrix[13]", "matrix[14]", "matrix[15]" ],
 403           "const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;", None ),
 404         ( "GL_PROJECTION_STACK_DEPTH", GLint,
 405           ["ctx->ProjectionMatrixStack.Depth + 1"], "", None ),
 406         ( "GL_READ_BUFFER", GLenum, ["ctx->ReadBuffer->ColorReadBuffer"], "", None ),
 407         ( "GL_RED_BIAS", GLfloat, ["ctx->Pixel.RedBias"], "", None ),
 408         ( "GL_RED_BITS", GLint, ["ctx->DrawBuffer->Visual.redBits"], "", None ),
 409         ( "GL_RED_SCALE", GLfloat, ["ctx->Pixel.RedScale"], "", None ),
 410         ( "GL_RENDER_MODE", GLenum, ["ctx->RenderMode"], "", None ),
 411         ( "GL_RESCALE_NORMAL", GLboolean,
 412           ["ctx->Transform.RescaleNormals"], "", None ),
 413         ( "GL_RGBA_MODE", GLboolean, ["GL_TRUE"],
 414           "", None ),
 415         ( "GL_SCISSOR_BOX", GLint,
 416           ["ctx->Scissor.X",
 417            "ctx->Scissor.Y",
 418            "ctx->Scissor.Width",
 419            "ctx->Scissor.Height"], "", None ),
 420         ( "GL_SCISSOR_TEST", GLboolean, ["ctx->Scissor.Enabled"], "", None ),
 421         ( "GL_SELECTION_BUFFER_SIZE", GLint, ["ctx->Select.BufferSize"], "", None ),
 422         ( "GL_SHADE_MODEL", GLenum, ["ctx->Light.ShadeModel"], "", None ),
 423         ( "GL_SHARED_TEXTURE_PALETTE_EXT", GLboolean,
 424           ["ctx->Texture.SharedPalette"], "", None ),
 425         ( "GL_STENCIL_BITS", GLint, ["ctx->DrawBuffer->Visual.stencilBits"], "", None ),
 426         ( "GL_STENCIL_CLEAR_VALUE", GLint, ["ctx->Stencil.Clear"], "", None ),
 427         ( "GL_STENCIL_FAIL", GLenum,
 428           ["ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]"], "", None ),
 429         ( "GL_STENCIL_FUNC", GLenum,
 430           ["ctx->Stencil.Function[ctx->Stencil.ActiveFace]"], "", None ),
 431         ( "GL_STENCIL_PASS_DEPTH_FAIL", GLenum,
 432           ["ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]"], "", None ),
 433         ( "GL_STENCIL_PASS_DEPTH_PASS", GLenum,
 434           ["ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]"], "", None ),
 435         ( "GL_STENCIL_REF", GLint,
 436           ["ctx->Stencil.Ref[ctx->Stencil.ActiveFace]"], "", None ),
 437         ( "GL_STENCIL_TEST", GLboolean, ["ctx->Stencil.Enabled"], "", None ),
 438         ( "GL_STENCIL_VALUE_MASK", GLint,
 439           ["ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]"], "", None ),
 440         ( "GL_STENCIL_WRITEMASK", GLint,
 441           ["ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]"], "", None ),
 442         ( "GL_STEREO", GLboolean, ["ctx->DrawBuffer->Visual.stereoMode"],
 443           "", None ),
 444         ( "GL_SUBPIXEL_BITS", GLint, ["ctx->Const.SubPixelBits"], "", None ),
 445         ( "GL_TEXTURE_1D", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_1D)"], "", None ),
 446         ( "GL_TEXTURE_2D", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_2D)"], "", None ),
 447         ( "GL_TEXTURE_3D", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_3D)"], "", None ),
 448         ( "GL_TEXTURE_1D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_1D_ARRAY_EXT)"], "", ["MESA_texture_array"] ),
 449         ( "GL_TEXTURE_2D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)"], "", ["MESA_texture_array"] ),
 450         ( "GL_TEXTURE_BINDING_1D", GLint,
 451           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name"], "", None ),
 452         ( "GL_TEXTURE_BINDING_2D", GLint,
 453           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name"], "", None ),
 454         ( "GL_TEXTURE_BINDING_3D", GLint,
 455           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name"], "", None ),
 456         ( "GL_TEXTURE_BINDING_1D_ARRAY_EXT", GLint,
 457           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ),
 458         ( "GL_TEXTURE_BINDING_2D_ARRAY_EXT", GLint,
 459           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ),
 460         ( "GL_TEXTURE_GEN_S", GLboolean,
 461           ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)"], "", None ),
 462         ( "GL_TEXTURE_GEN_T", GLboolean,
 463           ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0)"], "", None ),
 464         ( "GL_TEXTURE_GEN_R", GLboolean,
 465           ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0)"], "", None ),
 466         ( "GL_TEXTURE_GEN_Q", GLboolean,
 467           ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0)"], "", None ),
 468         ( "GL_TEXTURE_MATRIX", GLfloat,
 469           ["matrix[0]", "matrix[1]", "matrix[2]", "matrix[3]",
 470            "matrix[4]", "matrix[5]", "matrix[6]", "matrix[7]",
 471            "matrix[8]", "matrix[9]", "matrix[10]", "matrix[11]",
 472            "matrix[12]", "matrix[13]", "matrix[14]", "matrix[15]" ],
 473           """const GLfloat *matrix;
 474          const GLuint unit = ctx->Texture.CurrentUnit;
 475          if (unit >= ctx->Const.MaxTextureCoordUnits) {
 476             _mesa_error(ctx, GL_INVALID_OPERATION, "glGet(texture matrix %u)",
 477                         unit);
 478             return;
 479          }
 480          matrix = ctx->TextureMatrixStack[unit].Top->m;""",
 481           None ),
 482         ( "GL_TEXTURE_STACK_DEPTH", GLint,
 483           ["ctx->TextureMatrixStack[unit].Depth + 1"],
 484           """const GLuint unit = ctx->Texture.CurrentUnit;
 485          if (unit >= ctx->Const.MaxTextureCoordUnits) {
 486             _mesa_error(ctx, GL_INVALID_OPERATION,
 487                         "glGet(texture stack depth, unit %u)", unit);
 488             return;
 489          }""",
 490           None ),
 491         ( "GL_UNPACK_ALIGNMENT", GLint, ["ctx->Unpack.Alignment"], "", None ),
 492         ( "GL_UNPACK_LSB_FIRST", GLboolean, ["ctx->Unpack.LsbFirst"], "", None ),
 493         ( "GL_UNPACK_ROW_LENGTH", GLint, ["ctx->Unpack.RowLength"], "", None ),
 494         ( "GL_UNPACK_SKIP_PIXELS", GLint, ["ctx->Unpack.SkipPixels"], "", None ),
 495         ( "GL_UNPACK_SKIP_ROWS", GLint, ["ctx->Unpack.SkipRows"], "", None ),
 496         ( "GL_UNPACK_SWAP_BYTES", GLboolean, ["ctx->Unpack.SwapBytes"], "", None ),
 497         ( "GL_UNPACK_SKIP_IMAGES_EXT", GLint, ["ctx->Unpack.SkipImages"], "", None ),
 498         ( "GL_UNPACK_IMAGE_HEIGHT_EXT", GLint, ["ctx->Unpack.ImageHeight"], "", None ),
 499         ( "GL_UNPACK_CLIENT_STORAGE_APPLE", GLboolean, ["ctx->Unpack.ClientStorage"], "", None ),
 500         ( "GL_VIEWPORT", GLint, [ "ctx->Viewport.X", "ctx->Viewport.Y",
 501           "ctx->Viewport.Width", "ctx->Viewport.Height" ], "", None ),
 502         ( "GL_ZOOM_X", GLfloat, ["ctx->Pixel.ZoomX"], "", None ),
 503         ( "GL_ZOOM_Y", GLfloat, ["ctx->Pixel.ZoomY"], "", None ),
 504
 505         # Vertex arrays
 506         ( "GL_VERTEX_ARRAY", GLboolean, ["ctx->Array.ArrayObj->Vertex.Enabled"], "", None ),
 507         ( "GL_VERTEX_ARRAY_SIZE", GLint, ["ctx->Array.ArrayObj->Vertex.Size"], "", None ),
 508         ( "GL_VERTEX_ARRAY_TYPE", GLenum, ["ctx->Array.ArrayObj->Vertex.Type"], "", None ),
 509         ( "GL_VERTEX_ARRAY_STRIDE", GLint, ["ctx->Array.ArrayObj->Vertex.Stride"], "", None ),
 510         ( "GL_VERTEX_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 511         ( "GL_NORMAL_ARRAY", GLenum, ["ctx->Array.ArrayObj->Normal.Enabled"], "", None ),
 512         ( "GL_NORMAL_ARRAY_TYPE", GLenum, ["ctx->Array.ArrayObj->Normal.Type"], "", None ),
 513         ( "GL_NORMAL_ARRAY_STRIDE", GLint, ["ctx->Array.ArrayObj->Normal.Stride"], "", None ),
 514         ( "GL_NORMAL_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 515         ( "GL_COLOR_ARRAY", GLboolean, ["ctx->Array.ArrayObj->Color.Enabled"], "", None ),
 516         ( "GL_COLOR_ARRAY_SIZE", GLint, ["ctx->Array.ArrayObj->Color.Size"], "", None ),
 517         ( "GL_COLOR_ARRAY_TYPE", GLenum, ["ctx->Array.ArrayObj->Color.Type"], "", None ),
 518         ( "GL_COLOR_ARRAY_STRIDE", GLint, ["ctx->Array.ArrayObj->Color.Stride"], "", None ),
 519         ( "GL_COLOR_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 520         ( "GL_INDEX_ARRAY", GLboolean, ["ctx->Array.ArrayObj->Index.Enabled"], "", None ),
 521         ( "GL_INDEX_ARRAY_TYPE", GLenum, ["ctx->Array.ArrayObj->Index.Type"], "", None ),
 522         ( "GL_INDEX_ARRAY_STRIDE", GLint, ["ctx->Array.ArrayObj->Index.Stride"], "", None ),
 523         ( "GL_INDEX_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 524         ( "GL_TEXTURE_COORD_ARRAY", GLboolean,
 525           ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled"], "", None ),
 526         ( "GL_TEXTURE_COORD_ARRAY_SIZE", GLint,
 527           ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size"], "", None ),
 528         ( "GL_TEXTURE_COORD_ARRAY_TYPE", GLenum,
 529           ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type"], "", None ),
 530         ( "GL_TEXTURE_COORD_ARRAY_STRIDE", GLint,
 531           ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride"], "", None ),
 532         ( "GL_TEXTURE_COORD_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 533         ( "GL_EDGE_FLAG_ARRAY", GLboolean, ["ctx->Array.ArrayObj->EdgeFlag.Enabled"], "", None ),
 534         ( "GL_EDGE_FLAG_ARRAY_STRIDE", GLint, ["ctx->Array.ArrayObj->EdgeFlag.Stride"], "", None ),
 535         ( "GL_EDGE_FLAG_ARRAY_COUNT_EXT", GLint, ["0"], "", None ),
 536
 537         # GL_ARB_multitexture
 538         ( "GL_MAX_TEXTURE_UNITS_ARB", GLint,
 539           ["ctx->Const.MaxTextureUnits"], "", ["ARB_multitexture"] ),
 540         ( "GL_ACTIVE_TEXTURE_ARB", GLint,
 541           [ "GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit"], "", ["ARB_multitexture"] ),
 542         ( "GL_CLIENT_ACTIVE_TEXTURE_ARB", GLint,
 543           ["GL_TEXTURE0_ARB + ctx->Array.ActiveTexture"], "", ["ARB_multitexture"] ),
 544
 545         # GL_ARB_texture_cube_map
 546         ( "GL_TEXTURE_CUBE_MAP_ARB", GLboolean,
 547           ["_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB)"], "", ["ARB_texture_cube_map"] ),
 548         ( "GL_TEXTURE_BINDING_CUBE_MAP_ARB", GLint,
 549           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name"],
 550           "", ["ARB_texture_cube_map"] ),
 551         ( "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", GLint,
 552           ["(1 << (ctx->Const.MaxCubeTextureLevels - 1))"],
 553           "", ["ARB_texture_cube_map"]),
 554
 555         # GL_ARB_texture_compression */
 556         ( "GL_TEXTURE_COMPRESSION_HINT_ARB", GLint,
 557           ["ctx->Hint.TextureCompression"], "", None ),
 558         ( "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB", GLint,
 559           ["_mesa_get_compressed_formats(ctx, NULL, GL_FALSE)"],
 560           "", None ),
 561         ( "GL_COMPRESSED_TEXTURE_FORMATS_ARB", GLenum,
 562           [],
 563           """GLint formats[100];
 564          GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
 565          ASSERT(n <= 100);
 566          for (i = 0; i < n; i++)
 567             params[i] = CONVERSION(formats[i]);""",
 568           None ),
 569
 570         # GL_EXT_compiled_vertex_array
 571         ( "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT", GLint, ["ctx->Array.LockFirst"],
 572           "", ["EXT_compiled_vertex_array"] ),
 573         ( "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT", GLint, ["ctx->Array.LockCount"],
 574           "", ["EXT_compiled_vertex_array"] ),
 575
 576         # GL_ARB_transpose_matrix
 577         ( "GL_TRANSPOSE_COLOR_MATRIX_ARB", GLfloat,
 578           ["matrix[0]", "matrix[4]", "matrix[8]", "matrix[12]",
 579            "matrix[1]", "matrix[5]", "matrix[9]", "matrix[13]",
 580            "matrix[2]", "matrix[6]", "matrix[10]", "matrix[14]",
 581            "matrix[3]", "matrix[7]", "matrix[11]", "matrix[15]"],
 582           "const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;", None ),
 583         ( "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB", GLfloat,
 584           ["matrix[0]", "matrix[4]", "matrix[8]", "matrix[12]",
 585            "matrix[1]", "matrix[5]", "matrix[9]", "matrix[13]",
 586            "matrix[2]", "matrix[6]", "matrix[10]", "matrix[14]",
 587            "matrix[3]", "matrix[7]", "matrix[11]", "matrix[15]"],
 588           "const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;", None ),
 589         ( "GL_TRANSPOSE_PROJECTION_MATRIX_ARB", GLfloat,
 590           ["matrix[0]", "matrix[4]", "matrix[8]", "matrix[12]",
 591            "matrix[1]", "matrix[5]", "matrix[9]", "matrix[13]",
 592            "matrix[2]", "matrix[6]", "matrix[10]", "matrix[14]",
 593            "matrix[3]", "matrix[7]", "matrix[11]", "matrix[15]"],
 594           "const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;", None ),
 595         ( "GL_TRANSPOSE_TEXTURE_MATRIX_ARB", GLfloat,
 596           ["matrix[0]", "matrix[4]", "matrix[8]", "matrix[12]",
 597            "matrix[1]", "matrix[5]", "matrix[9]", "matrix[13]",
 598            "matrix[2]", "matrix[6]", "matrix[10]", "matrix[14]",
 599            "matrix[3]", "matrix[7]", "matrix[11]", "matrix[15]"],
 600           "const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;", None ),
 601
 602         # GL_SGI_color_matrix (also in 1.2 imaging)
 603         ( "GL_COLOR_MATRIX_SGI", GLfloat,
 604           ["matrix[0]", "matrix[1]", "matrix[2]", "matrix[3]",
 605            "matrix[4]", "matrix[5]", "matrix[6]", "matrix[7]",
 606            "matrix[8]", "matrix[9]", "matrix[10]", "matrix[11]",
 607            "matrix[12]", "matrix[13]", "matrix[14]", "matrix[15]" ],
 608           "const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;", None ),
 609         ( "GL_COLOR_MATRIX_STACK_DEPTH_SGI", GLint,
 610           ["ctx->ColorMatrixStack.Depth + 1"], "", None ),
 611         ( "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI", GLint,
 612           ["MAX_COLOR_STACK_DEPTH"], "", None ),
 613         ( "GL_POST_COLOR_MATRIX_RED_SCALE_SGI", GLfloat,
 614           ["ctx->Pixel.PostColorMatrixScale[0]"], "", None ),
 615         ( "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI", GLfloat,
 616           ["ctx->Pixel.PostColorMatrixScale[1]"], "", None ),
 617         ( "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI", GLfloat,
 618           ["ctx->Pixel.PostColorMatrixScale[2]"], "", None ),
 619         ( "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI", GLfloat,
 620           ["ctx->Pixel.PostColorMatrixScale[3]"], "", None ),
 621         ( "GL_POST_COLOR_MATRIX_RED_BIAS_SGI", GLfloat,
 622           ["ctx->Pixel.PostColorMatrixBias[0]"], "", None ),
 623         ( "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI", GLfloat,
 624           ["ctx->Pixel.PostColorMatrixBias[1]"], "", None ),
 625         ( "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI", GLfloat,
 626           ["ctx->Pixel.PostColorMatrixBias[2]"], "", None ),
 627         ( "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI", GLfloat,
 628           ["ctx->Pixel.PostColorMatrixBias[3]"], "", None ),
 629
 630         # GL_EXT_convolution (also in 1.2 imaging)
 631         ( "GL_CONVOLUTION_1D_EXT", GLboolean,
 632           ["ctx->Pixel.Convolution1DEnabled"], "", ["EXT_convolution"] ),
 633         ( "GL_CONVOLUTION_2D_EXT", GLboolean,
 634           ["ctx->Pixel.Convolution2DEnabled"], "", ["EXT_convolution"] ),
 635         ( "GL_SEPARABLE_2D_EXT", GLboolean,
 636           ["ctx->Pixel.Separable2DEnabled"], "", ["EXT_convolution"] ),
 637         ( "GL_POST_CONVOLUTION_RED_SCALE_EXT", GLfloat,
 638           ["ctx->Pixel.PostConvolutionScale[0]"], "", ["EXT_convolution"] ),
 639         ( "GL_POST_CONVOLUTION_GREEN_SCALE_EXT", GLfloat,
 640           ["ctx->Pixel.PostConvolutionScale[1]"], "", ["EXT_convolution"] ),
 641         ( "GL_POST_CONVOLUTION_BLUE_SCALE_EXT", GLfloat,
 642           ["ctx->Pixel.PostConvolutionScale[2]"], "", ["EXT_convolution"] ),
 643         ( "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT", GLfloat,
 644           ["ctx->Pixel.PostConvolutionScale[3]"], "", ["EXT_convolution"] ),
 645         ( "GL_POST_CONVOLUTION_RED_BIAS_EXT", GLfloat,
 646           ["ctx->Pixel.PostConvolutionBias[0]"], "", ["EXT_convolution"] ),
 647         ( "GL_POST_CONVOLUTION_GREEN_BIAS_EXT", GLfloat,
 648           ["ctx->Pixel.PostConvolutionBias[1]"], "", ["EXT_convolution"] ),
 649         ( "GL_POST_CONVOLUTION_BLUE_BIAS_EXT", GLfloat,
 650           ["ctx->Pixel.PostConvolutionBias[2]"], "", ["EXT_convolution"] ),
 651         ( "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT", GLfloat,
 652           ["ctx->Pixel.PostConvolutionBias[3]"], "", ["EXT_convolution"] ),
 653
 654         # GL_EXT_histogram / GL_ARB_imaging
 655         ( "GL_HISTOGRAM", GLboolean,
 656           [ "ctx->Pixel.HistogramEnabled" ], "", ["EXT_histogram"] ),
 657         ( "GL_MINMAX", GLboolean,
 658           [ "ctx->Pixel.MinMaxEnabled" ], "", ["EXT_histogram"] ),
 659
 660         # GL_SGI_color_table / GL_ARB_imaging
 661         ( "GL_COLOR_TABLE_SGI", GLboolean,
 662           ["ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION]"], "", ["SGI_color_table"] ),
 663         ( "GL_POST_CONVOLUTION_COLOR_TABLE_SGI", GLboolean,
 664           ["ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION]"], "", ["SGI_color_table"] ),
 665         ( "GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI", GLboolean,
 666           ["ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX]"], "", ["SGI_color_table"] ),
 667
 668         # GL_SGI_texture_color_table
 669         ( "GL_TEXTURE_COLOR_TABLE_SGI", GLboolean,
 670           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled"],
 671           "", ["SGI_texture_color_table"] ),
 672
 673         # GL_EXT_secondary_color
 674         ( "GL_COLOR_SUM_EXT", GLboolean,
 675           ["ctx->Fog.ColorSumEnabled"], "",
 676           ["EXT_secondary_color", "ARB_vertex_program"] ),
 677         ( "GL_CURRENT_SECONDARY_COLOR_EXT", GLfloatN,
 678           ["ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]",
 679            "ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]",
 680            "ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]",
 681            "ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]"],
 682           "FLUSH_CURRENT(ctx, 0);", ["EXT_secondary_color"] ),
 683         ( "GL_SECONDARY_COLOR_ARRAY_EXT", GLboolean,
 684           ["ctx->Array.ArrayObj->SecondaryColor.Enabled"], "", ["EXT_secondary_color"] ),
 685         ( "GL_SECONDARY_COLOR_ARRAY_TYPE_EXT", GLenum,
 686           ["ctx->Array.ArrayObj->SecondaryColor.Type"], "",  ["EXT_secondary_color"] ),
 687         ( "GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT", GLint,
 688           ["ctx->Array.ArrayObj->SecondaryColor.Stride"], "", ["EXT_secondary_color"] ),
 689         ( "GL_SECONDARY_COLOR_ARRAY_SIZE_EXT", GLint,
 690           ["ctx->Array.ArrayObj->SecondaryColor.Size"], "", ["EXT_secondary_color"] ),
 691
 692         # GL_EXT_fog_coord
 693         ( "GL_CURRENT_FOG_COORDINATE_EXT", GLfloat,
 694           ["ctx->Current.Attrib[VERT_ATTRIB_FOG][0]"],
 695           "FLUSH_CURRENT(ctx, 0);", ["EXT_fog_coord"] ),
 696         ( "GL_FOG_COORDINATE_ARRAY_EXT", GLboolean, ["ctx->Array.ArrayObj->FogCoord.Enabled"],
 697           "",  ["EXT_fog_coord"] ),
 698         ( "GL_FOG_COORDINATE_ARRAY_TYPE_EXT", GLenum, ["ctx->Array.ArrayObj->FogCoord.Type"],
 699           "", ["EXT_fog_coord"] ),
 700         ( "GL_FOG_COORDINATE_ARRAY_STRIDE_EXT", GLint, ["ctx->Array.ArrayObj->FogCoord.Stride"],
 701           "", ["EXT_fog_coord"] ),
 702         ( "GL_FOG_COORDINATE_SOURCE_EXT", GLenum, ["ctx->Fog.FogCoordinateSource"],
 703           "", ["EXT_fog_coord"] ),
 704
 705         # GL_EXT_texture_lod_bias
 706         ( "GL_MAX_TEXTURE_LOD_BIAS_EXT", GLfloat,
 707           ["ctx->Const.MaxTextureLodBias"], "", ["EXT_texture_lod_bias"]),
 708
 709         # GL_EXT_texture_filter_anisotropic
 710         ( "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", GLfloat,
 711           ["ctx->Const.MaxTextureMaxAnisotropy"], "", ["EXT_texture_filter_anisotropic"]),
 712
 713         # GL_ARB_multisample
 714         ( "GL_MULTISAMPLE_ARB", GLboolean,
 715           ["ctx->Multisample.Enabled"], "", None ),
 716         ( "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB", GLboolean,
 717           ["ctx->Multisample.SampleAlphaToCoverage"], "", None ),
 718         ( "GL_SAMPLE_ALPHA_TO_ONE_ARB", GLboolean,
 719           ["ctx->Multisample.SampleAlphaToOne"], "", None ),
 720         ( "GL_SAMPLE_COVERAGE_ARB", GLboolean,
 721           ["ctx->Multisample.SampleCoverage"], "", None ),
 722         ( "GL_SAMPLE_COVERAGE_VALUE_ARB", GLfloat,
 723           ["ctx->Multisample.SampleCoverageValue"], "", None ),
 724         ( "GL_SAMPLE_COVERAGE_INVERT_ARB", GLboolean,
 725           ["ctx->Multisample.SampleCoverageInvert"], "", None ),
 726         ( "GL_SAMPLE_BUFFERS_ARB", GLint,
 727           ["ctx->DrawBuffer->Visual.sampleBuffers"], "", None ),
 728         ( "GL_SAMPLES_ARB", GLint,
 729           ["ctx->DrawBuffer->Visual.samples"], "", None ),
 730
 731         # GL_IBM_rasterpos_clip
 732         ( "GL_RASTER_POSITION_UNCLIPPED_IBM", GLboolean,
 733           ["ctx->Transform.RasterPositionUnclipped"], "", ["IBM_rasterpos_clip"] ),
 734
 735         # GL_NV_point_sprite
 736         ( "GL_POINT_SPRITE_NV", GLboolean, ["ctx->Point.PointSprite"], # == GL_POINT_SPRITE_ARB
 737           "", ["NV_point_sprite", "ARB_point_sprite"] ),
 738         ( "GL_POINT_SPRITE_R_MODE_NV", GLenum, ["ctx->Point.SpriteRMode"],
 739           "", ["NV_point_sprite"] ),
 740         ( "GL_POINT_SPRITE_COORD_ORIGIN", GLenum, ["ctx->Point.SpriteOrigin"],
 741           "", ["NV_point_sprite", "ARB_point_sprite"] ),
 742
 743         # GL_SGIS_generate_mipmap
 744         ( "GL_GENERATE_MIPMAP_HINT_SGIS", GLenum, ["ctx->Hint.GenerateMipmap"],
 745           "", ["SGIS_generate_mipmap"] ),
 746
 747         # GL_NV_vertex_program
 748         ( "GL_VERTEX_PROGRAM_BINDING_NV", GLint,
 749           ["(ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0)"],
 750           "", ["NV_vertex_program"] ),
 751         ( "GL_VERTEX_ATTRIB_ARRAY0_NV", GLboolean,
 752           ["ctx->Array.ArrayObj->VertexAttrib[0].Enabled"], "", ["NV_vertex_program"] ),
 753         ( "GL_VERTEX_ATTRIB_ARRAY1_NV", GLboolean,
 754           ["ctx->Array.ArrayObj->VertexAttrib[1].Enabled"], "", ["NV_vertex_program"] ),
 755         ( "GL_VERTEX_ATTRIB_ARRAY2_NV", GLboolean,
 756           ["ctx->Array.ArrayObj->VertexAttrib[2].Enabled"], "", ["NV_vertex_program"] ),
 757         ( "GL_VERTEX_ATTRIB_ARRAY3_NV", GLboolean,
 758           ["ctx->Array.ArrayObj->VertexAttrib[3].Enabled"], "", ["NV_vertex_program"] ),
 759         ( "GL_VERTEX_ATTRIB_ARRAY4_NV", GLboolean,
 760           ["ctx->Array.ArrayObj->VertexAttrib[4].Enabled"], "", ["NV_vertex_program"] ),
 761         ( "GL_VERTEX_ATTRIB_ARRAY5_NV", GLboolean,
 762           ["ctx->Array.ArrayObj->VertexAttrib[5].Enabled"], "", ["NV_vertex_program"] ),
 763         ( "GL_VERTEX_ATTRIB_ARRAY6_NV", GLboolean,
 764           ["ctx->Array.ArrayObj->VertexAttrib[6].Enabled"], "", ["NV_vertex_program"] ),
 765         ( "GL_VERTEX_ATTRIB_ARRAY7_NV", GLboolean,
 766           ["ctx->Array.ArrayObj->VertexAttrib[7].Enabled"], "", ["NV_vertex_program"] ),
 767         ( "GL_VERTEX_ATTRIB_ARRAY8_NV", GLboolean,
 768           ["ctx->Array.ArrayObj->VertexAttrib[8].Enabled"], "", ["NV_vertex_program"] ),
 769         ( "GL_VERTEX_ATTRIB_ARRAY9_NV", GLboolean,
 770           ["ctx->Array.ArrayObj->VertexAttrib[9].Enabled"], "", ["NV_vertex_program"] ),
 771         ( "GL_VERTEX_ATTRIB_ARRAY10_NV", GLboolean,
 772           ["ctx->Array.ArrayObj->VertexAttrib[10].Enabled"], "", ["NV_vertex_program"] ),
 773         ( "GL_VERTEX_ATTRIB_ARRAY11_NV", GLboolean,
 774           ["ctx->Array.ArrayObj->VertexAttrib[11].Enabled"], "", ["NV_vertex_program"] ),
 775         ( "GL_VERTEX_ATTRIB_ARRAY12_NV", GLboolean,
 776           ["ctx->Array.ArrayObj->VertexAttrib[12].Enabled"], "", ["NV_vertex_program"] ),
 777         ( "GL_VERTEX_ATTRIB_ARRAY13_NV", GLboolean,
 778           ["ctx->Array.ArrayObj->VertexAttrib[13].Enabled"], "", ["NV_vertex_program"] ),
 779         ( "GL_VERTEX_ATTRIB_ARRAY14_NV", GLboolean,
 780           ["ctx->Array.ArrayObj->VertexAttrib[14].Enabled"], "", ["NV_vertex_program"] ),
 781         ( "GL_VERTEX_ATTRIB_ARRAY15_NV", GLboolean,
 782           ["ctx->Array.ArrayObj->VertexAttrib[15].Enabled"], "", ["NV_vertex_program"] ),
 783         ( "GL_MAP1_VERTEX_ATTRIB0_4_NV", GLboolean,
 784           ["ctx->Eval.Map1Attrib[0]"], "", ["NV_vertex_program"] ),
 785         ( "GL_MAP1_VERTEX_ATTRIB1_4_NV", GLboolean,
 786           ["ctx->Eval.Map1Attrib[1]"], "", ["NV_vertex_program"] ),
 787         ( "GL_MAP1_VERTEX_ATTRIB2_4_NV", GLboolean,
 788           ["ctx->Eval.Map1Attrib[2]"], "", ["NV_vertex_program"] ),
 789         ( "GL_MAP1_VERTEX_ATTRIB3_4_NV", GLboolean,
 790           ["ctx->Eval.Map1Attrib[3]"], "", ["NV_vertex_program"] ),
 791         ( "GL_MAP1_VERTEX_ATTRIB4_4_NV", GLboolean,
 792           ["ctx->Eval.Map1Attrib[4]"], "", ["NV_vertex_program"] ),
 793         ( "GL_MAP1_VERTEX_ATTRIB5_4_NV", GLboolean,
 794           ["ctx->Eval.Map1Attrib[5]"], "", ["NV_vertex_program"] ),
 795         ( "GL_MAP1_VERTEX_ATTRIB6_4_NV", GLboolean,
 796           ["ctx->Eval.Map1Attrib[6]"], "", ["NV_vertex_program"] ),
 797         ( "GL_MAP1_VERTEX_ATTRIB7_4_NV", GLboolean,
 798           ["ctx->Eval.Map1Attrib[7]"], "", ["NV_vertex_program"] ),
 799         ( "GL_MAP1_VERTEX_ATTRIB8_4_NV", GLboolean,
 800           ["ctx->Eval.Map1Attrib[8]"], "", ["NV_vertex_program"] ),
 801         ( "GL_MAP1_VERTEX_ATTRIB9_4_NV", GLboolean,
 802           ["ctx->Eval.Map1Attrib[9]"], "", ["NV_vertex_program"] ),
 803         ( "GL_MAP1_VERTEX_ATTRIB10_4_NV", GLboolean,
 804           ["ctx->Eval.Map1Attrib[10]"], "", ["NV_vertex_program"] ),
 805         ( "GL_MAP1_VERTEX_ATTRIB11_4_NV", GLboolean,
 806           ["ctx->Eval.Map1Attrib[11]"], "", ["NV_vertex_program"] ),
 807         ( "GL_MAP1_VERTEX_ATTRIB12_4_NV", GLboolean,
 808           ["ctx->Eval.Map1Attrib[12]"], "", ["NV_vertex_program"] ),
 809         ( "GL_MAP1_VERTEX_ATTRIB13_4_NV", GLboolean,
 810           ["ctx->Eval.Map1Attrib[13]"], "", ["NV_vertex_program"] ),
 811         ( "GL_MAP1_VERTEX_ATTRIB14_4_NV", GLboolean,
 812           ["ctx->Eval.Map1Attrib[14]"], "", ["NV_vertex_program"] ),
 813         ( "GL_MAP1_VERTEX_ATTRIB15_4_NV", GLboolean,
 814           ["ctx->Eval.Map1Attrib[15]"], "", ["NV_vertex_program"] ),
 815
 816         # GL_NV_fragment_program
 817         ( "GL_FRAGMENT_PROGRAM_NV", GLboolean,
 818           ["ctx->FragmentProgram.Enabled"], "", ["NV_fragment_program"] ),
 819         ( "GL_FRAGMENT_PROGRAM_BINDING_NV", GLint,
 820           ["ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0"],
 821           "", ["NV_fragment_program"] ),
 822         ( "GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV", GLint,
 823           ["MAX_NV_FRAGMENT_PROGRAM_PARAMS"], "", ["NV_fragment_program"] ),
 824
 825         # GL_NV_texture_rectangle
 826         ( "GL_TEXTURE_RECTANGLE_NV", GLboolean,
 827           ["_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV)"], "", ["NV_texture_rectangle"] ),
 828         ( "GL_TEXTURE_BINDING_RECTANGLE_NV", GLint,
 829           ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name"],
 830           "", ["NV_texture_rectangle"] ),
 831         ( "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", GLint,
 832           ["ctx->Const.MaxTextureRectSize"], "", ["NV_texture_rectangle"] ),
 833
 834         # GL_EXT_stencil_two_side
 835         ( "GL_STENCIL_TEST_TWO_SIDE_EXT", GLboolean,
 836           ["ctx->Stencil.TestTwoSide"], "", ["EXT_stencil_two_side"] ),
 837         ( "GL_ACTIVE_STENCIL_FACE_EXT", GLenum,
 838           ["ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT"],
 839           "", ["EXT_stencil_two_side"] ),
 840
 841         # GL_NV_light_max_exponent
 842         ( "GL_MAX_SHININESS_NV", GLfloat,
 843           ["ctx->Const.MaxShininess"], "", ["NV_light_max_exponent"] ),
 844         ( "GL_MAX_SPOT_EXPONENT_NV", GLfloat,
 845           ["ctx->Const.MaxSpotExponent"], "", ["NV_light_max_exponent"] ),
 846
 847         # GL_ARB_vertex_buffer_object
 848         ( "GL_ARRAY_BUFFER_BINDING_ARB", GLint,
 849           ["ctx->Array.ArrayBufferObj->Name"], "", None ),
 850         ( "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB", GLint,
 851           ["ctx->Array.ArrayObj->Vertex.BufferObj->Name"], "", None ),
 852         ( "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB", GLint,
 853           ["ctx->Array.ArrayObj->Normal.BufferObj->Name"], "", None ),
 854         ( "GL_COLOR_ARRAY_BUFFER_BINDING_ARB", GLint,
 855           ["ctx->Array.ArrayObj->Color.BufferObj->Name"], "", None ),
 856         ( "GL_INDEX_ARRAY_BUFFER_BINDING_ARB", GLint,
 857           ["ctx->Array.ArrayObj->Index.BufferObj->Name"], "", None ),
 858         ( "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB", GLint,
 859           ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name"],
 860           "", None ),
 861         ( "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB", GLint,
 862           ["ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name"], "", None ),
 863         ( "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB", GLint,
 864           ["ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name"],
 865           "", None ),
 866         ( "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB", GLint,
 867           ["ctx->Array.ArrayObj->FogCoord.BufferObj->Name"],
 868           "", None ),
 869         # GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported
 870         ( "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB", GLint,
 871           ["ctx->Array.ElementArrayBufferObj->Name"],
 872           "", None ),
 873
 874         # GL_EXT_pixel_buffer_object
 875         ( "GL_PIXEL_PACK_BUFFER_BINDING_EXT", GLint,
 876           ["ctx->Pack.BufferObj->Name"], "", ["EXT_pixel_buffer_object"] ),
 877         ( "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT", GLint,
 878           ["ctx->Unpack.BufferObj->Name"], "", ["EXT_pixel_buffer_object"] ),
 879
 880         # GL_ARB_vertex_program
 881         ( "GL_VERTEX_PROGRAM_ARB", GLboolean, # == GL_VERTEX_PROGRAM_NV
 882           ["ctx->VertexProgram.Enabled"], "",
 883           ["ARB_vertex_program", "NV_vertex_program"] ),
 884         ( "GL_VERTEX_PROGRAM_POINT_SIZE_ARB", GLboolean, # == GL_VERTEX_PROGRAM_POINT_SIZE_NV
 885           ["ctx->VertexProgram.PointSizeEnabled"], "",
 886           ["ARB_vertex_program", "NV_vertex_program"] ),
 887         ( "GL_VERTEX_PROGRAM_TWO_SIDE_ARB", GLboolean, # == GL_VERTEX_PROGRAM_TWO_SIDE_NV
 888           ["ctx->VertexProgram.TwoSideEnabled"], "",
 889           ["ARB_vertex_program", "NV_vertex_program"] ),
 890         ( "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB", GLint, # == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV
 891           ["ctx->Const.MaxProgramMatrixStackDepth"], "",
 892           ["ARB_vertex_program", "ARB_fragment_program", "NV_vertex_program"] ),
 893         ( "GL_MAX_PROGRAM_MATRICES_ARB", GLint, # == GL_MAX_TRACK_MATRICES_NV
 894           ["ctx->Const.MaxProgramMatrices"], "",
 895           ["ARB_vertex_program", "ARB_fragment_program", "NV_vertex_program"] ),
 896         ( "GL_CURRENT_MATRIX_STACK_DEPTH_ARB", GLboolean, # == GL_CURRENT_MATRIX_STACK_DEPTH_NV
 897           ["ctx->CurrentStack->Depth + 1"], "",
 898           ["ARB_vertex_program", "ARB_fragment_program", "NV_vertex_program"] ),
 899         ( "GL_CURRENT_MATRIX_ARB", GLfloat, # == GL_CURRENT_MATRIX_NV
 900           ["matrix[0]", "matrix[1]", "matrix[2]", "matrix[3]",
 901            "matrix[4]", "matrix[5]", "matrix[6]", "matrix[7]",
 902            "matrix[8]", "matrix[9]", "matrix[10]", "matrix[11]",
 903            "matrix[12]", "matrix[13]", "matrix[14]", "matrix[15]" ],
 904           "const GLfloat *matrix = ctx->CurrentStack->Top->m;",
 905           ["ARB_vertex_program", "ARB_fragment_program", "NV_fragment_program"] ),
 906         ( "GL_TRANSPOSE_CURRENT_MATRIX_ARB", GLfloat,
 907           ["matrix[0]", "matrix[4]", "matrix[8]", "matrix[12]",
 908            "matrix[1]", "matrix[5]", "matrix[9]", "matrix[13]",
 909            "matrix[2]", "matrix[6]", "matrix[10]", "matrix[14]",
 910            "matrix[3]", "matrix[7]", "matrix[11]", "matrix[15]"],
 911           "const GLfloat *matrix = ctx->CurrentStack->Top->m;",
 912           ["ARB_vertex_program", "ARB_fragment_program"] ),
 913         ( "GL_MAX_VERTEX_ATTRIBS_ARB", GLint,
 914           ["ctx->Const.VertexProgram.MaxAttribs"], "", ["ARB_vertex_program"] ),
 915         ( "GL_PROGRAM_ERROR_POSITION_ARB", GLint, # == GL_PROGRAM_ERROR_POSITION_NV
 916           ["ctx->Program.ErrorPos"], "", ["NV_vertex_program",
 917            "ARB_vertex_program", "NV_fragment_program", "ARB_fragment_program"] ),
 918
 919         # GL_ARB_fragment_program
 920         ( "GL_FRAGMENT_PROGRAM_ARB", GLboolean,
 921           ["ctx->FragmentProgram.Enabled"], "", ["ARB_fragment_program"] ),
 922         ( "GL_MAX_TEXTURE_COORDS_ARB", GLint, # == GL_MAX_TEXTURE_COORDS_NV
 923           ["ctx->Const.MaxTextureCoordUnits"], "",
 924           ["ARB_fragment_program", "NV_fragment_program"] ),
 925         ( "GL_MAX_TEXTURE_IMAGE_UNITS_ARB", GLint, # == GL_MAX_TEXTURE_IMAGE_UNITS_NV
 926           ["ctx->Const.MaxTextureImageUnits"], "",
 927           ["ARB_fragment_program", "NV_fragment_program"] ),
 928
 929         # GL_EXT_depth_bounds_test
 930         ( "GL_DEPTH_BOUNDS_TEST_EXT", GLboolean,
 931           ["ctx->Depth.BoundsTest"], "", ["EXT_depth_bounds_test"] ),
 932         ( "GL_DEPTH_BOUNDS_EXT", GLfloat,
 933           ["ctx->Depth.BoundsMin", "ctx->Depth.BoundsMax"],
 934           "", ["EXT_depth_bounds_test"] ),
 935
 936         # GL_ARB_depth_clamp
 937         ( "GL_DEPTH_CLAMP", GLboolean, ["ctx->Transform.DepthClamp"], "",
 938           ["ARB_depth_clamp"] ),
 939
 940         # GL_ARB_draw_buffers
 941         ( "GL_MAX_DRAW_BUFFERS_ARB", GLint,
 942           ["ctx->Const.MaxDrawBuffers"], "", None ),
 943         ( "GL_DRAW_BUFFER0_ARB", GLenum,
 944           ["ctx->DrawBuffer->ColorDrawBuffer[0]"], "", None ),
 945         ( "GL_DRAW_BUFFER1_ARB", GLenum,
 946           ["buffer"],
 947           """GLenum buffer;
 948          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
 949             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
 950             return;
 951          }
 952          buffer = ctx->DrawBuffer->ColorDrawBuffer[1];""", None ),
 953         ( "GL_DRAW_BUFFER2_ARB", GLenum,
 954           ["buffer"],
 955           """GLenum buffer;
 956          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
 957             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
 958             return;
 959          }
 960          buffer = ctx->DrawBuffer->ColorDrawBuffer[2];""", None ),
 961         ( "GL_DRAW_BUFFER3_ARB", GLenum,
 962           ["buffer"],
 963           """GLenum buffer;
 964          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
 965             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
 966             return;
 967          }
 968          buffer = ctx->DrawBuffer->ColorDrawBuffer[3];""", None ),
 969         # XXX Add more GL_DRAW_BUFFERn_ARB entries as needed in the future
 970
 971         # GL_OES_read_format
 972         ( "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES", GLint,
 973           ["_mesa_get_color_read_type(ctx)"], "", ["OES_read_format"] ),
 974         ( "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES", GLint,
 975           ["_mesa_get_color_read_format(ctx)"], "", ["OES_read_format"] ),
 976
 977         # GL_ATI_fragment_shader
 978         ( "GL_NUM_FRAGMENT_REGISTERS_ATI", GLint, ["6"], "", ["ATI_fragment_shader"] ),
 979         ( "GL_NUM_FRAGMENT_CONSTANTS_ATI", GLint, ["8"], "", ["ATI_fragment_shader"] ),
 980         ( "GL_NUM_PASSES_ATI", GLint, ["2"], "", ["ATI_fragment_shader"] ),
 981         ( "GL_NUM_INSTRUCTIONS_PER_PASS_ATI", GLint, ["8"], "", ["ATI_fragment_shader"] ),
 982         ( "GL_NUM_INSTRUCTIONS_TOTAL_ATI", GLint, ["16"], "", ["ATI_fragment_shader"] ),
 983         ( "GL_COLOR_ALPHA_PAIRING_ATI", GLboolean, ["GL_TRUE"], "", ["ATI_fragment_shader"] ),
 984         ( "GL_NUM_LOOPBACK_COMPONENTS_ATI", GLint, ["3"], "", ["ATI_fragment_shader"] ),
 985         ( "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI", GLint, ["3"], "", ["ATI_fragment_shader"] ),
 986
 987         # OpenGL 2.0
 988         ( "GL_STENCIL_BACK_FUNC", GLenum, ["ctx->Stencil.Function[1]"], "", None ),
 989         ( "GL_STENCIL_BACK_VALUE_MASK", GLint, ["ctx->Stencil.ValueMask[1]"], "", None ),
 990         ( "GL_STENCIL_BACK_WRITEMASK", GLint, ["ctx->Stencil.WriteMask[1]"], "", None ),
 991         ( "GL_STENCIL_BACK_REF", GLint, ["ctx->Stencil.Ref[1]"], "", None ),
 992         ( "GL_STENCIL_BACK_FAIL", GLenum, ["ctx->Stencil.FailFunc[1]"], "", None ),
 993         ( "GL_STENCIL_BACK_PASS_DEPTH_FAIL", GLenum, ["ctx->Stencil.ZFailFunc[1]"], "", None ),
 994         ( "GL_STENCIL_BACK_PASS_DEPTH_PASS", GLenum, ["ctx->Stencil.ZPassFunc[1]"], "", None ),
 995
 996         # GL_EXT_framebuffer_object
 997         ( "GL_FRAMEBUFFER_BINDING_EXT", GLint, ["ctx->DrawBuffer->Name"], "",
 998           ["EXT_framebuffer_object"] ),
 999         ( "GL_RENDERBUFFER_BINDING_EXT", GLint,
1000           ["ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0"], "",
1001           ["EXT_framebuffer_object"] ),
1002         ( "GL_MAX_COLOR_ATTACHMENTS_EXT", GLint,
1003           ["ctx->Const.MaxColorAttachments"], "",
1004           ["EXT_framebuffer_object"] ),
1005         ( "GL_MAX_RENDERBUFFER_SIZE_EXT", GLint,
1006           ["ctx->Const.MaxRenderbufferSize"], "",
1007           ["EXT_framebuffer_object"] ),
1008
1009         # GL_EXT_framebuffer_blit
1010         # NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT
1011         ( "GL_READ_FRAMEBUFFER_BINDING_EXT", GLint, ["ctx->ReadBuffer->Name"], "",
1012           ["EXT_framebuffer_blit"] ),
1013
1014         # GL_EXT_provoking_vertex
1015         ( "GL_PROVOKING_VERTEX_EXT", GLboolean,
1016           ["ctx->Light.ProvokingVertex"], "", ["EXT_provoking_vertex"] ),
1017         ( "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT", GLboolean,
1018           ["ctx->Const.QuadsFollowProvokingVertexConvention"], "",
1019           ["EXT_provoking_vertex"] ),
1020
1021         # GL_ARB_fragment_shader
1022         ( "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB", GLint,
1023           ["ctx->Const.FragmentProgram.MaxUniformComponents"], "",
1024           ["ARB_fragment_shader"] ),
1025         ( "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB", GLenum,
1026           ["ctx->Hint.FragmentShaderDerivative"], "", ["ARB_fragment_shader"] ),
1027
1028         # GL_ARB_vertex_shader
1029         ( "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB", GLint,
1030           ["ctx->Const.VertexProgram.MaxUniformComponents"], "",
1031           ["ARB_vertex_shader"] ),
1032         ( "GL_MAX_VARYING_FLOATS_ARB", GLint,
1033           ["ctx->Const.MaxVarying * 4"], "", ["ARB_vertex_shader"] ),
1034         ( "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB", GLint,
1035           ["ctx->Const.MaxVertexTextureImageUnits"], "", ["ARB_vertex_shader"] ),
1036         ( "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB", GLint,
1037           ["ctx->Const.MaxCombinedTextureImageUnits"], "", ["ARB_vertex_shader"] ),
1038
1039         # GL_ARB_shader_objects
1040         # Actually, this token isn't part of GL_ARB_shader_objects, but is
1041         # close enough for now.
1042         ( "GL_CURRENT_PROGRAM", GLint,
1043           ["ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0"],
1044           "", ["ARB_shader_objects"] ),
1045
1046         # GL_ARB_framebuffer_object
1047         ( "GL_MAX_SAMPLES", GLint, ["ctx->Const.MaxSamples"], "",
1048           ["ARB_framebuffer_object"] ),
1049
1050         # GL_APPLE_vertex_array_object
1051         ( "GL_VERTEX_ARRAY_BINDING_APPLE", GLint, ["ctx->Array.ArrayObj->Name"], "",
1052           ["APPLE_vertex_array_object"] ),
1053
1054         # GL_ARB_seamless_cube_map
1055         ( "GL_TEXTURE_CUBE_MAP_SEAMLESS", GLboolean, ["ctx->Texture.CubeMapSeamless"], "",
1056           ["ARB_seamless_cube_map"] ),
1057
1058         # GL_ARB_sync
1059         ( "GL_MAX_SERVER_WAIT_TIMEOUT", GLint64, ["ctx->Const.MaxServerWaitTimeout"], "",
1060           ["ARB_sync"] ),
1061
1062         # GL3
1063         ( "GL_NUM_EXTENSIONS", GLint, ["_mesa_get_extension_count(ctx)"], "", None ),
1064         ( "GL_MAJOR_VERSION", GLint, ["ctx->VersionMajor"], "", None ),
1065         ( "GL_MINOR_VERSION", GLint, ["ctx->VersionMinor"], "", None )
1066 ]
1067
1068
1069 # These are queried via glGetIntegetIndexdvEXT() or glGetIntegeri_v()
1070 IndexedStateVars = [
1071         ( "GL_BLEND", GLint, ["((ctx->Color.BlendEnabled >> index) & 1)"],
1072           "ctx->Const.MaxDrawBuffers", ["EXT_draw_buffers2"] ),
1073         ( "GL_COLOR_WRITEMASK", GLint,
1074           [ "ctx->Color.ColorMask[index][RCOMP] ? 1 : 0",
1075                 "ctx->Color.ColorMask[index][GCOMP] ? 1 : 0",
1076                 "ctx->Color.ColorMask[index][BCOMP] ? 1 : 0",
1077                 "ctx->Color.ColorMask[index][ACOMP] ? 1 : 0" ],
1078           "ctx->Const.MaxDrawBuffers", ["EXT_draw_buffers2"] ),
1079         # XXX more to come...
1080 ]
1081
1082
1083
1084 def ConversionFunc(fromType, toType):
1085         """Return the name of the macro to convert between two data types."""
1086         if fromType == toType:
1087                 return ""
1088         elif fromType == GLfloat and toType == GLint:
1089                 return "IROUND"
1090         elif fromType == GLfloat and toType == GLint64:
1091                 return "IROUND64"
1092         elif fromType == GLfloatN and toType == GLfloat:
1093                 return ""
1094         elif fromType == GLint and toType == GLfloat: # but not GLfloatN!
1095                 return "(GLfloat)"
1096         elif fromType == GLint and toType == GLint64:
1097                 return "(GLint64)"
1098         elif fromType == GLint64 and toType == GLfloat: # but not GLfloatN!
1099                 return "(GLfloat)"
1100         else:
1101                 if fromType == GLfloatN:
1102                         fromType = GLfloat
1103                 fromStr = TypeStrings[fromType]
1104                 fromStr = string.upper(fromStr[2:])
1105                 toStr = TypeStrings[toType]
1106                 toStr = string.upper(toStr[2:])
1107                 return fromStr + "_TO_" + toStr
1108
1109
1110 def EmitGetFunction(stateVars, returnType, indexed):
1111         """Emit the code to implement glGetBooleanv, glGetIntegerv or glGetFloatv."""
1112         assert (returnType == GLboolean or
1113                         returnType == GLint or
1114                         returnType == GLint64 or
1115                         returnType == GLfloat)
1116
1117         strType = TypeStrings[returnType]
1118         # Capitalize first letter of return type
1119         if indexed:
1120                 if returnType == GLint:
1121                         function = "GetIntegerIndexedv"
1122                 elif returnType == GLboolean:
1123                         function = "GetBooleanIndexedv"
1124                 elif returnType == GLint64:
1125                         function = "GetInteger64Indexedv"
1126                 else:
1127                         function = "Foo"
1128         else:
1129                 if returnType == GLint:
1130                         function = "GetIntegerv"
1131                 elif returnType == GLboolean:
1132                         function = "GetBooleanv"
1133                 elif returnType == GLfloat:
1134                         function = "GetFloatv"
1135                 elif returnType == GLint64:
1136                         function = "GetInteger64v"
1137                 else:
1138                         sys.exit(1)
1139
1140         if returnType == GLint64:
1141                 print "#if FEATURE_ARB_sync"
1142
1143         print "void GLAPIENTRY"
1144         if indexed:
1145                 print "_mesa_%s( GLenum pname, GLuint index, %s *params )" % (function, strType)
1146         else:
1147                 print "_mesa_%s( GLenum pname, %s *params )" % (function, strType)
1148         print "{"
1149         print "   GET_CURRENT_CONTEXT(ctx);"
1150         print "   ASSERT_OUTSIDE_BEGIN_END(ctx);"
1151         print ""
1152         print "   if (!params)"
1153         print "      return;"
1154         print ""
1155         print "   if (ctx->NewState)"
1156         print "      _mesa_update_state(ctx);"
1157         print ""
1158         if indexed == 0:
1159                 print "   if (ctx->Driver.%s &&" % function
1160                 print "       ctx->Driver.%s(ctx, pname, params))" % function
1161                 print "      return;"
1162                 print ""
1163         print "   switch (pname) {"
1164
1165         for state in stateVars:
1166                 if indexed:
1167                         (name, varType, state, indexMax, extensions) = state
1168                         optionalCode = 0
1169                 else:
1170                         (name, varType, state, optionalCode, extensions) = state
1171                         indexMax = 0
1172                 print "      case " + name + ":"
1173                 if extensions:
1174                         if len(extensions) == 1:
1175                                 print ('         CHECK_EXT1(%s, "%s");' %
1176                                            (extensions[0], function))
1177                         elif len(extensions) == 2:
1178                                 print ('         CHECK_EXT2(%s, %s, "%s");' %
1179                                            (extensions[0], extensions[1], function))
1180                         elif len(extensions) == 3:
1181                                 print ('         CHECK_EXT3(%s, %s, %s, "%s");' %
1182                                            (extensions[0], extensions[1], extensions[2], function))
1183                         else:
1184                                 assert len(extensions) == 4
1185                                 print ('         CHECK_EXT4(%s, %s, %s, %s, "%s");' %
1186                                            (extensions[0], extensions[1], extensions[2], extensions[3], function))
1187                 if indexMax:
1188                         print ('         if (index >= %s) {' % indexMax)
1189                         print ('            _mesa_error(ctx, GL_INVALID_VALUE, "gl%s(index=%%u), index", pname);' % function)
1190                         print ('         }')
1191
1192                 conversion = ConversionFunc(varType, returnType)
1193                 if optionalCode:
1194                         optionalCode = string.replace(optionalCode, "CONVERSION", conversion);
1195                         print "         {"
1196                         print "         " + optionalCode
1197                 n = len(state)
1198                 for i in range(n):
1199                         if conversion:
1200                                 print "         params[%d] = %s(%s);" % (i, conversion, state[i])
1201                         else:
1202                                 print "         params[%d] = %s;" % (i, state[i])
1203                 if optionalCode:
1204                         print "         }"
1205                 print "         break;"
1206
1207         print "      default:"
1208         print '         _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(pname=0x%%x)", pname);' % function
1209         print "   }"
1210         print "}"
1211         if returnType == GLint64:
1212                 print "#endif /* FEATURE_ARB_sync */"
1213         print ""
1214         return
1215
1216
1217
1218 def EmitHeader():
1219         """Print the get.c file header."""
1220         print """
1221 /***
1222  ***  NOTE!!!  DO NOT EDIT THIS FILE!!!  IT IS GENERATED BY get_gen.py
1223  ***/
1224
1225 #include "glheader.h"
1226 #include "context.h"
1227 #include "enable.h"
1228 #include "extensions.h"
1229 #include "get.h"
1230 #include "macros.h"
1231 #include "mtypes.h"
1232 #include "state.h"
1233 #include "texcompress.h"
1234 #include "framebuffer.h"
1235
1236
1237 #define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
1238
1239 #define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
1240
1241 #define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
1242 #define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
1243
1244 #define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
1245 #define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
1246 #define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
1247
1248 #define ENUM_TO_INT64(E)      ( (GLint64) (E) )
1249
1250
1251 /*
1252  * Check if named extension is enabled, if not generate error and return.
1253  */
1254 #define CHECK_EXT1(EXT1, FUNC)                                         \\
1255    if (!ctx->Extensions.EXT1) {                                        \\
1256       _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \\
1257       return;                                                          \\
1258    }
1259
1260 /*
1261  * Check if either of two extensions is enabled.
1262  */
1263 #define CHECK_EXT2(EXT1, EXT2, FUNC)                                   \\
1264    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {               \\
1265       _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \\
1266       return;                                                          \\
1267    }
1268
1269 /*
1270  * Check if either of three extensions is enabled.
1271  */
1272 #define CHECK_EXT3(EXT1, EXT2, EXT3, FUNC)                             \\
1273    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 &&               \\
1274        !ctx->Extensions.EXT3) {                                        \\
1275       _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \\
1276       return;                                                          \\
1277    }
1278
1279 /*
1280  * Check if either of four extensions is enabled.
1281  */
1282 #define CHECK_EXT4(EXT1, EXT2, EXT3, EXT4, FUNC)                       \\
1283    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 &&               \\
1284        !ctx->Extensions.EXT3 && !ctx->Extensions.EXT4) {               \\
1285       _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \\
1286       return;                                                          \\
1287    }
1288
1289 """
1290         return
1291
1292
1293
1294 def EmitGetDoublev():
1295         print """
1296 void GLAPIENTRY
1297 _mesa_GetDoublev( GLenum pname, GLdouble *params )
1298 {
1299    const GLfloat magic = -1234.5F;
1300    GLfloat values[16];
1301    GLuint i;
1302
1303    if (!params)
1304       return;
1305
1306    /* Init temp array to magic numbers so we can figure out how many values
1307     * are returned by the GetFloatv() call.
1308     */
1309    for (i = 0; i < 16; i++)
1310       values[i] = magic;
1311
1312    _mesa_GetFloatv(pname, values);
1313
1314    for (i = 0; i < 16 && values[i] != magic; i++)
1315       params[i] = (GLdouble) values[i];
1316 }
1317 """
1318
1319
1320
1321
1322 EmitHeader()
1323 # XXX Maybe sort the StateVars list
1324 EmitGetFunction(StateVars, GLboolean, 0)
1325 EmitGetFunction(StateVars, GLfloat, 0)
1326 EmitGetFunction(StateVars, GLint, 0)
1327 EmitGetFunction(StateVars, GLint64, 0)
1328 EmitGetDoublev()
1329
1330 EmitGetFunction(IndexedStateVars, GLboolean, 1)
1331 EmitGetFunction(IndexedStateVars, GLint, 1)
1332 EmitGetFunction(IndexedStateVars, GLint64, 1)
1333