src/mesa/main/get.c

   1
   2 /***
   3  ***  NOTE!!!  DO NOT EDIT THIS FILE!!!  IT IS GENERATED BY get_gen.py
   4  ***/
   5
   6 #include "glheader.h"
   7 #include "context.h"
   8 #include "enable.h"
   9 #include "extensions.h"
  10 #include "get.h"
  11 #include "macros.h"
  12 #include "mtypes.h"
  13 #include "texcompress.h"
  14
  15
  16 #define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
  17
  18 #define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
  19
  20 #define ENUM_TO_BOOLEAN(E)    ( (E) ? GL_TRUE : GL_FALSE )
  21 #define ENUM_TO_INT(E)        ( (GLint) (E) )
  22 #define ENUM_TO_FLOAT(E)      ( (GLfloat) (E) )
  23
  24 #define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
  25 #define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
  26
  27
  28 /* Check if named extension is enabled, if not generate error and return */
  29
  30 #define CHECK1(E1, str, PNAME)                         \
  31    if (!ctx->Extensions.E1) {                          \
  32       _mesa_error(ctx, GL_INVALID_VALUE,               \
  33                   "glGet" str "v(0x%x)", (int) PNAME); \
  34       return;                                          \
  35    }
  36
  37 #define CHECK2(E1, E2, str, PNAME)                     \
  38    if (!ctx->Extensions.E1 && !ctx->Extensions.E2) {   \
  39       _mesa_error(ctx, GL_INVALID_VALUE,               \
  40                   "glGet" str "v(0x%x)", (int) PNAME); \
  41       return;                                          \
  42    }
  43
  44 #define CHECK_EXTENSION_B(EXTNAME, PNAME)      \
  45    CHECK1(EXTNAME, "Boolean", PNAME )
  46
  47 #define CHECK_EXTENSION_I(EXTNAME, PNAME)      \
  48    CHECK1(EXTNAME, "Integer", PNAME )
  49
  50 #define CHECK_EXTENSION_F(EXTNAME, PNAME)      \
  51    CHECK1(EXTNAME, "Float", PNAME )
  52
  53
  54 /**
  55  * Helper routine.
  56  */
  57 static GLenum
  58 pixel_texgen_mode(const GLcontext *ctx)
  59 {
  60    if (ctx->Pixel.FragmentRgbSource == GL_CURRENT_RASTER_POSITION) {
  61       if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_POSITION) {
  62          return GL_RGBA;
  63       }
  64       else {
  65          return GL_RGB;
  66       }
  67    }
  68    else {
  69       if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_POSITION) {
  70          return GL_ALPHA;
  71       }
  72       else {
  73          return GL_NONE;
  74       }
  75    }
  76 }
  77
  78 void GLAPIENTRY
  79 _mesa_GetBooleanv( GLenum pname, GLboolean *params )
  80 {
  81    GET_CURRENT_CONTEXT(ctx);
  82    ASSERT_OUTSIDE_BEGIN_END(ctx);
  83
  84    if (!params)
  85       return;
  86
  87    if (ctx->Driver.GetBooleanv &&
  88        ctx->Driver.GetBooleanv(ctx, pname, params))
  89       return;
  90
  91    switch (pname) {
  92       case GL_ACCUM_RED_BITS:
  93          params[0] = INT_TO_BOOLEAN(ctx->Visual.accumRedBits);
  94          break;
  95       case GL_ACCUM_GREEN_BITS:
  96          params[0] = INT_TO_BOOLEAN(ctx->Visual.accumGreenBits);
  97          break;
  98       case GL_ACCUM_BLUE_BITS:
  99          params[0] = INT_TO_BOOLEAN(ctx->Visual.accumBlueBits);
 100          break;
 101       case GL_ACCUM_ALPHA_BITS:
 102          params[0] = INT_TO_BOOLEAN(ctx->Visual.accumAlphaBits);
 103          break;
 104       case GL_ACCUM_CLEAR_VALUE:
 105          params[0] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[0]);
 106          params[1] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[1]);
 107          params[2] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[2]);
 108          params[3] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[3]);
 109          break;
 110       case GL_ALPHA_BIAS:
 111          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaBias);
 112          break;
 113       case GL_ALPHA_BITS:
 114          params[0] = INT_TO_BOOLEAN(ctx->Visual.alphaBits);
 115          break;
 116       case GL_ALPHA_SCALE:
 117          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaScale);
 118          break;
 119       case GL_ALPHA_TEST:
 120          params[0] = ctx->Color.AlphaEnabled;
 121          break;
 122       case GL_ALPHA_TEST_FUNC:
 123          params[0] = ENUM_TO_BOOLEAN(ctx->Color.AlphaFunc);
 124          break;
 125       case GL_ALPHA_TEST_REF:
 126          params[0] = FLOAT_TO_BOOLEAN(ctx->Color.AlphaRef);
 127          break;
 128       case GL_ATTRIB_STACK_DEPTH:
 129          params[0] = INT_TO_BOOLEAN(ctx->AttribStackDepth);
 130          break;
 131       case GL_AUTO_NORMAL:
 132          params[0] = ctx->Eval.AutoNormal;
 133          break;
 134       case GL_AUX_BUFFERS:
 135          params[0] = INT_TO_BOOLEAN(ctx->Visual.numAuxBuffers);
 136          break;
 137       case GL_BLEND:
 138          params[0] = ctx->Color.BlendEnabled;
 139          break;
 140       case GL_BLEND_DST:
 141          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
 142          break;
 143       case GL_BLEND_SRC:
 144          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
 145          break;
 146       case GL_BLEND_SRC_RGB_EXT:
 147          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
 148          break;
 149       case GL_BLEND_DST_RGB_EXT:
 150          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
 151          break;
 152       case GL_BLEND_SRC_ALPHA_EXT:
 153          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcA);
 154          break;
 155       case GL_BLEND_DST_ALPHA_EXT:
 156          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstA);
 157          break;
 158       case GL_BLEND_EQUATION:
 159          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationRGB );
 160          break;
 161       case GL_BLEND_EQUATION_ALPHA_EXT:
 162          params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationA );
 163          break;
 164       case GL_BLEND_COLOR_EXT:
 165          params[0] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[0]);
 166          params[1] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[1]);
 167          params[2] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[2]);
 168          params[3] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[3]);
 169          break;
 170       case GL_BLUE_BIAS:
 171          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueBias);
 172          break;
 173       case GL_BLUE_BITS:
 174          params[0] = INT_TO_BOOLEAN(ctx->Visual.blueBits);
 175          break;
 176       case GL_BLUE_SCALE:
 177          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueScale);
 178          break;
 179       case GL_CLIENT_ATTRIB_STACK_DEPTH:
 180          params[0] = INT_TO_BOOLEAN(ctx->ClientAttribStackDepth);
 181          break;
 182       case GL_CLIP_PLANE0:
 183          params[0] = (ctx->Transform.ClipPlanesEnabled >> 0) & 1;
 184          break;
 185       case GL_CLIP_PLANE1:
 186          params[0] = (ctx->Transform.ClipPlanesEnabled >> 1) & 1;
 187          break;
 188       case GL_CLIP_PLANE2:
 189          params[0] = (ctx->Transform.ClipPlanesEnabled >> 2) & 1;
 190          break;
 191       case GL_CLIP_PLANE3:
 192          params[0] = (ctx->Transform.ClipPlanesEnabled >> 3) & 1;
 193          break;
 194       case GL_CLIP_PLANE4:
 195          params[0] = (ctx->Transform.ClipPlanesEnabled >> 4) & 1;
 196          break;
 197       case GL_CLIP_PLANE5:
 198          params[0] = (ctx->Transform.ClipPlanesEnabled >> 5) & 1;
 199          break;
 200       case GL_COLOR_CLEAR_VALUE:
 201          params[0] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[0]);
 202          params[1] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[1]);
 203          params[2] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[2]);
 204          params[3] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[3]);
 205          break;
 206       case GL_COLOR_MATERIAL:
 207          params[0] = ctx->Light.ColorMaterialEnabled;
 208          break;
 209       case GL_COLOR_MATERIAL_FACE:
 210          params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialFace);
 211          break;
 212       case GL_COLOR_MATERIAL_PARAMETER:
 213          params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialMode);
 214          break;
 215       case GL_COLOR_WRITEMASK:
 216          params[0] = INT_TO_BOOLEAN(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
 217          params[1] = INT_TO_BOOLEAN(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
 218          params[2] = INT_TO_BOOLEAN(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
 219          params[3] = INT_TO_BOOLEAN(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
 220          break;
 221       case GL_CULL_FACE:
 222          params[0] = ctx->Polygon.CullFlag;
 223          break;
 224       case GL_CULL_FACE_MODE:
 225          params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.CullFaceMode);
 226          break;
 227       case GL_CURRENT_COLOR:
 228          {
 229          FLUSH_CURRENT(ctx, 0);
 230          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
 231          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
 232          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
 233          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
 234          }
 235          break;
 236       case GL_CURRENT_INDEX:
 237          {
 238          FLUSH_CURRENT(ctx, 0);
 239          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Index);
 240          }
 241          break;
 242       case GL_CURRENT_NORMAL:
 243          {
 244          FLUSH_CURRENT(ctx, 0);
 245          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
 246          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
 247          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
 248          }
 249          break;
 250       case GL_CURRENT_RASTER_COLOR:
 251          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[0]);
 252          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[1]);
 253          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[2]);
 254          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[3]);
 255          break;
 256       case GL_CURRENT_RASTER_DISTANCE:
 257          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterDistance);
 258          break;
 259       case GL_CURRENT_RASTER_INDEX:
 260          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterIndex);
 261          break;
 262       case GL_CURRENT_RASTER_POSITION:
 263          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[0]);
 264          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[1]);
 265          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[2]);
 266          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[3]);
 267          break;
 268       case GL_CURRENT_RASTER_TEXTURE_COORDS:
 269          {
 270          const GLuint texUnit = ctx->Texture.CurrentUnit;
 271          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][0]);
 272          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][1]);
 273          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][2]);
 274          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][3]);
 275          }
 276          break;
 277       case GL_CURRENT_RASTER_POSITION_VALID:
 278          params[0] = ctx->Current.RasterPosValid;
 279          break;
 280       case GL_CURRENT_TEXTURE_COORDS:
 281          {
 282          const GLuint texUnit = ctx->Texture.CurrentUnit;
 283          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
 284          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
 285          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
 286          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
 287          }
 288          break;
 289       case GL_DEPTH_BIAS:
 290          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthBias);
 291          break;
 292       case GL_DEPTH_BITS:
 293          params[0] = INT_TO_BOOLEAN(ctx->Visual.depthBits);
 294          break;
 295       case GL_DEPTH_CLEAR_VALUE:
 296          params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.Clear);
 297          break;
 298       case GL_DEPTH_FUNC:
 299          params[0] = ENUM_TO_BOOLEAN(ctx->Depth.Func);
 300          break;
 301       case GL_DEPTH_RANGE:
 302          params[0] = FLOAT_TO_BOOLEAN(ctx->Viewport.Near);
 303          params[1] = FLOAT_TO_BOOLEAN(ctx->Viewport.Far);
 304          break;
 305       case GL_DEPTH_SCALE:
 306          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthScale);
 307          break;
 308       case GL_DEPTH_TEST:
 309          params[0] = ctx->Depth.Test;
 310          break;
 311       case GL_DEPTH_WRITEMASK:
 312          params[0] = ctx->Depth.Mask;
 313          break;
 314       case GL_DITHER:
 315          params[0] = ctx->Color.DitherFlag;
 316          break;
 317       case GL_DOUBLEBUFFER:
 318          params[0] = ctx->Visual.doubleBufferMode;
 319          break;
 320       case GL_DRAW_BUFFER:
 321          params[0] = ENUM_TO_BOOLEAN(ctx->Color.DrawBuffer[0]);
 322          break;
 323       case GL_EDGE_FLAG:
 324          {
 325          FLUSH_CURRENT(ctx, 0);
 326          params[0] = ctx->Current.EdgeFlag;
 327          }
 328          break;
 329       case GL_FEEDBACK_BUFFER_SIZE:
 330          params[0] = INT_TO_BOOLEAN(ctx->Feedback.BufferSize);
 331          break;
 332       case GL_FEEDBACK_BUFFER_TYPE:
 333          params[0] = ENUM_TO_BOOLEAN(ctx->Feedback.Type);
 334          break;
 335       case GL_FOG:
 336          params[0] = ctx->Fog.Enabled;
 337          break;
 338       case GL_FOG_COLOR:
 339          params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[0]);
 340          params[1] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[1]);
 341          params[2] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[2]);
 342          params[3] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[3]);
 343          break;
 344       case GL_FOG_DENSITY:
 345          params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Density);
 346          break;
 347       case GL_FOG_END:
 348          params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.End);
 349          break;
 350       case GL_FOG_HINT:
 351          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.Fog);
 352          break;
 353       case GL_FOG_INDEX:
 354          params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Index);
 355          break;
 356       case GL_FOG_MODE:
 357          params[0] = ENUM_TO_BOOLEAN(ctx->Fog.Mode);
 358          break;
 359       case GL_FOG_START:
 360          params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Start);
 361          break;
 362       case GL_FRONT_FACE:
 363          params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontFace);
 364          break;
 365       case GL_GREEN_BIAS:
 366          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenBias);
 367          break;
 368       case GL_GREEN_BITS:
 369          params[0] = INT_TO_BOOLEAN(ctx->Visual.greenBits);
 370          break;
 371       case GL_GREEN_SCALE:
 372          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenScale);
 373          break;
 374       case GL_INDEX_BITS:
 375          params[0] = INT_TO_BOOLEAN(ctx->Visual.indexBits);
 376          break;
 377       case GL_INDEX_CLEAR_VALUE:
 378          params[0] = INT_TO_BOOLEAN(ctx->Color.ClearIndex);
 379          break;
 380       case GL_INDEX_MODE:
 381          params[0] = !ctx->Visual.rgbMode;
 382          break;
 383       case GL_INDEX_OFFSET:
 384          params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexOffset);
 385          break;
 386       case GL_INDEX_SHIFT:
 387          params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexShift);
 388          break;
 389       case GL_INDEX_WRITEMASK:
 390          params[0] = INT_TO_BOOLEAN(ctx->Color.IndexMask);
 391          break;
 392       case GL_LIGHT0:
 393          params[0] = ctx->Light.Light[0].Enabled;
 394          break;
 395       case GL_LIGHT1:
 396          params[0] = ctx->Light.Light[1].Enabled;
 397          break;
 398       case GL_LIGHT2:
 399          params[0] = ctx->Light.Light[2].Enabled;
 400          break;
 401       case GL_LIGHT3:
 402          params[0] = ctx->Light.Light[3].Enabled;
 403          break;
 404       case GL_LIGHT4:
 405          params[0] = ctx->Light.Light[4].Enabled;
 406          break;
 407       case GL_LIGHT5:
 408          params[0] = ctx->Light.Light[5].Enabled;
 409          break;
 410       case GL_LIGHT6:
 411          params[0] = ctx->Light.Light[6].Enabled;
 412          break;
 413       case GL_LIGHT7:
 414          params[0] = ctx->Light.Light[7].Enabled;
 415          break;
 416       case GL_LIGHTING:
 417          params[0] = ctx->Light.Enabled;
 418          break;
 419       case GL_LIGHT_MODEL_AMBIENT:
 420          params[0] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[0]);
 421          params[1] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[1]);
 422          params[2] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[2]);
 423          params[3] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[3]);
 424          break;
 425       case GL_LIGHT_MODEL_COLOR_CONTROL:
 426          params[0] = ENUM_TO_BOOLEAN(ctx->Light.Model.ColorControl);
 427          break;
 428       case GL_LIGHT_MODEL_LOCAL_VIEWER:
 429          params[0] = ctx->Light.Model.LocalViewer;
 430          break;
 431       case GL_LIGHT_MODEL_TWO_SIDE:
 432          params[0] = ctx->Light.Model.TwoSide;
 433          break;
 434       case GL_LINE_SMOOTH:
 435          params[0] = ctx->Line.SmoothFlag;
 436          break;
 437       case GL_LINE_SMOOTH_HINT:
 438          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.LineSmooth);
 439          break;
 440       case GL_LINE_STIPPLE:
 441          params[0] = ctx->Line.StippleFlag;
 442          break;
 443       case GL_LINE_STIPPLE_PATTERN:
 444          params[0] = INT_TO_BOOLEAN(ctx->Line.StipplePattern);
 445          break;
 446       case GL_LINE_STIPPLE_REPEAT:
 447          params[0] = INT_TO_BOOLEAN(ctx->Line.StippleFactor);
 448          break;
 449       case GL_LINE_WIDTH:
 450          params[0] = FLOAT_TO_BOOLEAN(ctx->Line.Width);
 451          break;
 452       case GL_LINE_WIDTH_GRANULARITY:
 453          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.LineWidthGranularity);
 454          break;
 455       case GL_LINE_WIDTH_RANGE:
 456          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidthAA);
 457          params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidthAA);
 458          break;
 459       case GL_ALIASED_LINE_WIDTH_RANGE:
 460          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidth);
 461          params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidth);
 462          break;
 463       case GL_LIST_BASE:
 464          params[0] = INT_TO_BOOLEAN(ctx->List.ListBase);
 465          break;
 466       case GL_LIST_INDEX:
 467          params[0] = INT_TO_BOOLEAN(ctx->ListState.CurrentListNum);
 468          break;
 469       case GL_LIST_MODE:
 470          {
 471          GLenum mode;
 472          if (!ctx->CompileFlag)
 473             mode = 0;
 474          else if (ctx->ExecuteFlag)
 475             mode = GL_COMPILE_AND_EXECUTE;
 476          else
 477             mode = GL_COMPILE;
 478          params[0] = ENUM_TO_BOOLEAN(mode);
 479          }
 480          break;
 481       case GL_INDEX_LOGIC_OP:
 482          params[0] = ctx->Color.IndexLogicOpEnabled;
 483          break;
 484       case GL_COLOR_LOGIC_OP:
 485          params[0] = ctx->Color.ColorLogicOpEnabled;
 486          break;
 487       case GL_LOGIC_OP_MODE:
 488          params[0] = ENUM_TO_BOOLEAN(ctx->Color.LogicOp);
 489          break;
 490       case GL_MAP1_COLOR_4:
 491          params[0] = ctx->Eval.Map1Color4;
 492          break;
 493       case GL_MAP1_GRID_DOMAIN:
 494          params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u1);
 495          params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u2);
 496          break;
 497       case GL_MAP1_GRID_SEGMENTS:
 498          params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid1un);
 499          break;
 500       case GL_MAP1_INDEX:
 501          params[0] = ctx->Eval.Map1Index;
 502          break;
 503       case GL_MAP1_NORMAL:
 504          params[0] = ctx->Eval.Map1Normal;
 505          break;
 506       case GL_MAP1_TEXTURE_COORD_1:
 507          params[0] = ctx->Eval.Map1TextureCoord1;
 508          break;
 509       case GL_MAP1_TEXTURE_COORD_2:
 510          params[0] = ctx->Eval.Map1TextureCoord2;
 511          break;
 512       case GL_MAP1_TEXTURE_COORD_3:
 513          params[0] = ctx->Eval.Map1TextureCoord3;
 514          break;
 515       case GL_MAP1_TEXTURE_COORD_4:
 516          params[0] = ctx->Eval.Map1TextureCoord4;
 517          break;
 518       case GL_MAP1_VERTEX_3:
 519          params[0] = ctx->Eval.Map1Vertex3;
 520          break;
 521       case GL_MAP1_VERTEX_4:
 522          params[0] = ctx->Eval.Map1Vertex4;
 523          break;
 524       case GL_MAP2_COLOR_4:
 525          params[0] = ctx->Eval.Map2Color4;
 526          break;
 527       case GL_MAP2_GRID_DOMAIN:
 528          params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u1);
 529          params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u2);
 530          params[2] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v1);
 531          params[3] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v2);
 532          break;
 533       case GL_MAP2_GRID_SEGMENTS:
 534          params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2un);
 535          params[1] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2vn);
 536          break;
 537       case GL_MAP2_INDEX:
 538          params[0] = ctx->Eval.Map2Index;
 539          break;
 540       case GL_MAP2_NORMAL:
 541          params[0] = ctx->Eval.Map2Normal;
 542          break;
 543       case GL_MAP2_TEXTURE_COORD_1:
 544          params[0] = ctx->Eval.Map2TextureCoord1;
 545          break;
 546       case GL_MAP2_TEXTURE_COORD_2:
 547          params[0] = ctx->Eval.Map2TextureCoord2;
 548          break;
 549       case GL_MAP2_TEXTURE_COORD_3:
 550          params[0] = ctx->Eval.Map2TextureCoord3;
 551          break;
 552       case GL_MAP2_TEXTURE_COORD_4:
 553          params[0] = ctx->Eval.Map2TextureCoord4;
 554          break;
 555       case GL_MAP2_VERTEX_3:
 556          params[0] = ctx->Eval.Map2Vertex3;
 557          break;
 558       case GL_MAP2_VERTEX_4:
 559          params[0] = ctx->Eval.Map2Vertex4;
 560          break;
 561       case GL_MAP_COLOR:
 562          params[0] = ctx->Pixel.MapColorFlag;
 563          break;
 564       case GL_MAP_STENCIL:
 565          params[0] = ctx->Pixel.MapStencilFlag;
 566          break;
 567       case GL_MATRIX_MODE:
 568          params[0] = ENUM_TO_BOOLEAN(ctx->Transform.MatrixMode);
 569          break;
 570       case GL_MAX_ATTRIB_STACK_DEPTH:
 571          params[0] = INT_TO_BOOLEAN(MAX_ATTRIB_STACK_DEPTH);
 572          break;
 573       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 574          params[0] = INT_TO_BOOLEAN(MAX_CLIENT_ATTRIB_STACK_DEPTH);
 575          break;
 576       case GL_MAX_CLIP_PLANES:
 577          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxClipPlanes);
 578          break;
 579       case GL_MAX_ELEMENTS_VERTICES:
 580          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
 581          break;
 582       case GL_MAX_ELEMENTS_INDICES:
 583          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
 584          break;
 585       case GL_MAX_EVAL_ORDER:
 586          params[0] = INT_TO_BOOLEAN(MAX_EVAL_ORDER);
 587          break;
 588       case GL_MAX_LIGHTS:
 589          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxLights);
 590          break;
 591       case GL_MAX_LIST_NESTING:
 592          params[0] = INT_TO_BOOLEAN(MAX_LIST_NESTING);
 593          break;
 594       case GL_MAX_MODELVIEW_STACK_DEPTH:
 595          params[0] = INT_TO_BOOLEAN(MAX_MODELVIEW_STACK_DEPTH);
 596          break;
 597       case GL_MAX_NAME_STACK_DEPTH:
 598          params[0] = INT_TO_BOOLEAN(MAX_NAME_STACK_DEPTH);
 599          break;
 600       case GL_MAX_PIXEL_MAP_TABLE:
 601          params[0] = INT_TO_BOOLEAN(MAX_PIXEL_MAP_TABLE);
 602          break;
 603       case GL_MAX_PROJECTION_STACK_DEPTH:
 604          params[0] = INT_TO_BOOLEAN(MAX_PROJECTION_STACK_DEPTH);
 605          break;
 606       case GL_MAX_TEXTURE_SIZE:
 607          params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.MaxTextureLevels - 1));
 608          break;
 609       case GL_MAX_3D_TEXTURE_SIZE:
 610          params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.Max3DTextureLevels - 1));
 611          break;
 612       case GL_MAX_TEXTURE_STACK_DEPTH:
 613          params[0] = INT_TO_BOOLEAN(MAX_TEXTURE_STACK_DEPTH);
 614          break;
 615       case GL_MAX_VIEWPORT_DIMS:
 616          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxViewportWidth);
 617          params[1] = INT_TO_BOOLEAN(ctx->Const.MaxViewportHeight);
 618          break;
 619       case GL_MODELVIEW_MATRIX:
 620          {
 621          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
 622          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
 623          params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
 624          params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
 625          params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
 626          params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
 627          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
 628          params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
 629          params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
 630          params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
 631          params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
 632          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
 633          params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
 634          params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
 635          params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
 636          params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
 637          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
 638          }
 639          break;
 640       case GL_MODELVIEW_STACK_DEPTH:
 641          params[0] = INT_TO_BOOLEAN(ctx->ModelviewMatrixStack.Depth + 1);
 642          break;
 643       case GL_NAME_STACK_DEPTH:
 644          params[0] = INT_TO_BOOLEAN(ctx->Select.NameStackDepth);
 645          break;
 646       case GL_NORMALIZE:
 647          params[0] = ctx->Transform.Normalize;
 648          break;
 649       case GL_PACK_ALIGNMENT:
 650          params[0] = INT_TO_BOOLEAN(ctx->Pack.Alignment);
 651          break;
 652       case GL_PACK_LSB_FIRST:
 653          params[0] = ctx->Pack.LsbFirst;
 654          break;
 655       case GL_PACK_ROW_LENGTH:
 656          params[0] = INT_TO_BOOLEAN(ctx->Pack.RowLength);
 657          break;
 658       case GL_PACK_SKIP_PIXELS:
 659          params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipPixels);
 660          break;
 661       case GL_PACK_SKIP_ROWS:
 662          params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipRows);
 663          break;
 664       case GL_PACK_SWAP_BYTES:
 665          params[0] = ctx->Pack.SwapBytes;
 666          break;
 667       case GL_PACK_SKIP_IMAGES_EXT:
 668          params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipImages);
 669          break;
 670       case GL_PACK_IMAGE_HEIGHT_EXT:
 671          params[0] = INT_TO_BOOLEAN(ctx->Pack.ImageHeight);
 672          break;
 673       case GL_PACK_INVERT_MESA:
 674          params[0] = ctx->Pack.Invert;
 675          break;
 676       case GL_PERSPECTIVE_CORRECTION_HINT:
 677          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PerspectiveCorrection);
 678          break;
 679       case GL_PIXEL_MAP_A_TO_A_SIZE:
 680          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapAtoAsize);
 681          break;
 682       case GL_PIXEL_MAP_B_TO_B_SIZE:
 683          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapBtoBsize);
 684          break;
 685       case GL_PIXEL_MAP_G_TO_G_SIZE:
 686          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapGtoGsize);
 687          break;
 688       case GL_PIXEL_MAP_I_TO_A_SIZE:
 689          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoAsize);
 690          break;
 691       case GL_PIXEL_MAP_I_TO_B_SIZE:
 692          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoBsize);
 693          break;
 694       case GL_PIXEL_MAP_I_TO_G_SIZE:
 695          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoGsize);
 696          break;
 697       case GL_PIXEL_MAP_I_TO_I_SIZE:
 698          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoIsize);
 699          break;
 700       case GL_PIXEL_MAP_I_TO_R_SIZE:
 701          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoRsize);
 702          break;
 703       case GL_PIXEL_MAP_R_TO_R_SIZE:
 704          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapRtoRsize);
 705          break;
 706       case GL_PIXEL_MAP_S_TO_S_SIZE:
 707          params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapStoSsize);
 708          break;
 709       case GL_POINT_SIZE:
 710          params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Size);
 711          break;
 712       case GL_POINT_SIZE_GRANULARITY:
 713          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.PointSizeGranularity);
 714          break;
 715       case GL_POINT_SIZE_RANGE:
 716          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSizeAA);
 717          params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSizeAA);
 718          break;
 719       case GL_ALIASED_POINT_SIZE_RANGE:
 720          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSize);
 721          params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSize);
 722          break;
 723       case GL_POINT_SMOOTH:
 724          params[0] = ctx->Point.SmoothFlag;
 725          break;
 726       case GL_POINT_SMOOTH_HINT:
 727          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PointSmooth);
 728          break;
 729       case GL_POINT_SIZE_MIN_EXT:
 730          params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MinSize);
 731          break;
 732       case GL_POINT_SIZE_MAX_EXT:
 733          params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MaxSize);
 734          break;
 735       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
 736          params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Threshold);
 737          break;
 738       case GL_DISTANCE_ATTENUATION_EXT:
 739          params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Params[0]);
 740          params[1] = FLOAT_TO_BOOLEAN(ctx->Point.Params[1]);
 741          params[2] = FLOAT_TO_BOOLEAN(ctx->Point.Params[2]);
 742          break;
 743       case GL_POLYGON_MODE:
 744          params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontMode);
 745          params[1] = ENUM_TO_BOOLEAN(ctx->Polygon.BackMode);
 746          break;
 747       case GL_POLYGON_OFFSET_BIAS_EXT:
 748          params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits);
 749          break;
 750       case GL_POLYGON_OFFSET_FACTOR:
 751          params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetFactor );
 752          break;
 753       case GL_POLYGON_OFFSET_UNITS:
 754          params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits );
 755          break;
 756       case GL_POLYGON_SMOOTH:
 757          params[0] = ctx->Polygon.SmoothFlag;
 758          break;
 759       case GL_POLYGON_SMOOTH_HINT:
 760          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PolygonSmooth);
 761          break;
 762       case GL_POLYGON_STIPPLE:
 763          params[0] = ctx->Polygon.StippleFlag;
 764          break;
 765       case GL_PROJECTION_MATRIX:
 766          {
 767          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
 768          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
 769          params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
 770          params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
 771          params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
 772          params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
 773          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
 774          params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
 775          params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
 776          params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
 777          params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
 778          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
 779          params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
 780          params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
 781          params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
 782          params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
 783          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
 784          }
 785          break;
 786       case GL_PROJECTION_STACK_DEPTH:
 787          params[0] = INT_TO_BOOLEAN(ctx->ProjectionMatrixStack.Depth + 1);
 788          break;
 789       case GL_READ_BUFFER:
 790          params[0] = ENUM_TO_BOOLEAN(ctx->Pixel.ReadBuffer);
 791          break;
 792       case GL_RED_BIAS:
 793          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedBias);
 794          break;
 795       case GL_RED_BITS:
 796          params[0] = INT_TO_BOOLEAN( ctx->Visual.redBits );
 797          break;
 798       case GL_RED_SCALE:
 799          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedScale);
 800          break;
 801       case GL_RENDER_MODE:
 802          params[0] = ENUM_TO_BOOLEAN(ctx->RenderMode);
 803          break;
 804       case GL_RESCALE_NORMAL:
 805          params[0] = ctx->Transform.RescaleNormals;
 806          break;
 807       case GL_RGBA_MODE:
 808          params[0] = ctx->Visual.rgbMode;
 809          break;
 810       case GL_SCISSOR_BOX:
 811          params[0] = INT_TO_BOOLEAN(ctx->Scissor.X);
 812          params[1] = INT_TO_BOOLEAN(ctx->Scissor.Y);
 813          params[2] = INT_TO_BOOLEAN(ctx->Scissor.Width);
 814          params[3] = INT_TO_BOOLEAN(ctx->Scissor.Height);
 815          break;
 816       case GL_SCISSOR_TEST:
 817          params[0] = ctx->Scissor.Enabled;
 818          break;
 819       case GL_SELECTION_BUFFER_SIZE:
 820          params[0] = INT_TO_BOOLEAN(ctx->Select.BufferSize);
 821          break;
 822       case GL_SHADE_MODEL:
 823          params[0] = ENUM_TO_BOOLEAN(ctx->Light.ShadeModel);
 824          break;
 825       case GL_SHARED_TEXTURE_PALETTE_EXT:
 826          params[0] = ctx->Texture.SharedPalette;
 827          break;
 828       case GL_STENCIL_BITS:
 829          params[0] = INT_TO_BOOLEAN(ctx->Visual.stencilBits);
 830          break;
 831       case GL_STENCIL_CLEAR_VALUE:
 832          params[0] = INT_TO_BOOLEAN(ctx->Stencil.Clear);
 833          break;
 834       case GL_STENCIL_FAIL:
 835          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
 836          break;
 837       case GL_STENCIL_FUNC:
 838          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
 839          break;
 840       case GL_STENCIL_PASS_DEPTH_FAIL:
 841          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
 842          break;
 843       case GL_STENCIL_PASS_DEPTH_PASS:
 844          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
 845          break;
 846       case GL_STENCIL_REF:
 847          params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
 848          break;
 849       case GL_STENCIL_TEST:
 850          params[0] = ctx->Stencil.Enabled;
 851          break;
 852       case GL_STENCIL_VALUE_MASK:
 853          params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
 854          break;
 855       case GL_STENCIL_WRITEMASK:
 856          params[0] = INT_TO_BOOLEAN(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
 857          break;
 858       case GL_STEREO:
 859          params[0] = ctx->Visual.stereoMode;
 860          break;
 861       case GL_SUBPIXEL_BITS:
 862          params[0] = INT_TO_BOOLEAN(ctx->Const.SubPixelBits);
 863          break;
 864       case GL_TEXTURE_1D:
 865          params[0] = _mesa_IsEnabled(GL_TEXTURE_1D);
 866          break;
 867       case GL_TEXTURE_2D:
 868          params[0] = _mesa_IsEnabled(GL_TEXTURE_2D);
 869          break;
 870       case GL_TEXTURE_3D:
 871          params[0] = _mesa_IsEnabled(GL_TEXTURE_3D);
 872          break;
 873       case GL_TEXTURE_BINDING_1D:
 874          params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
 875          break;
 876       case GL_TEXTURE_BINDING_2D:
 877          params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
 878          break;
 879       case GL_TEXTURE_BINDING_3D:
 880          params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
 881          break;
 882       case GL_TEXTURE_ENV_COLOR:
 883          {
 884          const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
 885          params[0] = FLOAT_TO_BOOLEAN(color[0]);
 886          params[1] = FLOAT_TO_BOOLEAN(color[1]);
 887          params[2] = FLOAT_TO_BOOLEAN(color[2]);
 888          params[3] = FLOAT_TO_BOOLEAN(color[3]);
 889          }
 890          break;
 891       case GL_TEXTURE_ENV_MODE:
 892          params[0] = ENUM_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
 893          break;
 894       case GL_TEXTURE_GEN_S:
 895          params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0);
 896          break;
 897       case GL_TEXTURE_GEN_T:
 898          params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0);
 899          break;
 900       case GL_TEXTURE_GEN_R:
 901          params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0);
 902          break;
 903       case GL_TEXTURE_GEN_Q:
 904          params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0);
 905          break;
 906       case GL_TEXTURE_MATRIX:
 907          {
 908          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
 909          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
 910          params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
 911          params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
 912          params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
 913          params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
 914          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
 915          params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
 916          params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
 917          params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
 918          params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
 919          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
 920          params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
 921          params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
 922          params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
 923          params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
 924          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
 925          }
 926          break;
 927       case GL_TEXTURE_STACK_DEPTH:
 928          params[0] = INT_TO_BOOLEAN(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
 929          break;
 930       case GL_UNPACK_ALIGNMENT:
 931          params[0] = INT_TO_BOOLEAN(ctx->Unpack.Alignment);
 932          break;
 933       case GL_UNPACK_LSB_FIRST:
 934          params[0] = ctx->Unpack.LsbFirst;
 935          break;
 936       case GL_UNPACK_ROW_LENGTH:
 937          params[0] = INT_TO_BOOLEAN(ctx->Unpack.RowLength);
 938          break;
 939       case GL_UNPACK_SKIP_PIXELS:
 940          params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipPixels);
 941          break;
 942       case GL_UNPACK_SKIP_ROWS:
 943          params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipRows);
 944          break;
 945       case GL_UNPACK_SWAP_BYTES:
 946          params[0] = ctx->Unpack.SwapBytes;
 947          break;
 948       case GL_UNPACK_SKIP_IMAGES_EXT:
 949          params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipImages);
 950          break;
 951       case GL_UNPACK_IMAGE_HEIGHT_EXT:
 952          params[0] = INT_TO_BOOLEAN(ctx->Unpack.ImageHeight);
 953          break;
 954       case GL_UNPACK_CLIENT_STORAGE_APPLE:
 955          params[0] = ctx->Unpack.ClientStorage;
 956          break;
 957       case GL_VIEWPORT:
 958          params[0] = INT_TO_BOOLEAN(ctx->Viewport.X);
 959          params[1] = INT_TO_BOOLEAN(ctx->Viewport.Y);
 960          params[2] = INT_TO_BOOLEAN(ctx->Viewport.Width);
 961          params[3] = INT_TO_BOOLEAN(ctx->Viewport.Height);
 962          break;
 963       case GL_ZOOM_X:
 964          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomX);
 965          break;
 966       case GL_ZOOM_Y:
 967          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomY);
 968          break;
 969       case GL_VERTEX_ARRAY:
 970          params[0] = ctx->Array.Vertex.Enabled;
 971          break;
 972       case GL_VERTEX_ARRAY_SIZE:
 973          params[0] = INT_TO_BOOLEAN(ctx->Array.Vertex.Size);
 974          break;
 975       case GL_VERTEX_ARRAY_TYPE:
 976          params[0] = ENUM_TO_BOOLEAN(ctx->Array.Vertex.Type);
 977          break;
 978       case GL_VERTEX_ARRAY_STRIDE:
 979          params[0] = INT_TO_BOOLEAN(ctx->Array.Vertex.Stride);
 980          break;
 981       case GL_VERTEX_ARRAY_COUNT_EXT:
 982          params[0] = INT_TO_BOOLEAN(0);
 983          break;
 984       case GL_NORMAL_ARRAY:
 985          params[0] = ENUM_TO_BOOLEAN(ctx->Array.Normal.Enabled);
 986          break;
 987       case GL_NORMAL_ARRAY_TYPE:
 988          params[0] = ENUM_TO_BOOLEAN(ctx->Array.Normal.Type);
 989          break;
 990       case GL_NORMAL_ARRAY_STRIDE:
 991          params[0] = INT_TO_BOOLEAN(ctx->Array.Normal.Stride);
 992          break;
 993       case GL_NORMAL_ARRAY_COUNT_EXT:
 994          params[0] = INT_TO_BOOLEAN(0);
 995          break;
 996       case GL_COLOR_ARRAY:
 997          params[0] = ctx->Array.Color.Enabled;
 998          break;
 999       case GL_COLOR_ARRAY_SIZE:
1000          params[0] = INT_TO_BOOLEAN(ctx->Array.Color.Size);
1001          break;
1002       case GL_COLOR_ARRAY_TYPE:
1003          params[0] = ENUM_TO_BOOLEAN(ctx->Array.Color.Type);
1004          break;
1005       case GL_COLOR_ARRAY_STRIDE:
1006          params[0] = INT_TO_BOOLEAN(ctx->Array.Color.Stride);
1007          break;
1008       case GL_COLOR_ARRAY_COUNT_EXT:
1009          params[0] = INT_TO_BOOLEAN(0);
1010          break;
1011       case GL_INDEX_ARRAY:
1012          params[0] = ctx->Array.Index.Enabled;
1013          break;
1014       case GL_INDEX_ARRAY_TYPE:
1015          params[0] = ENUM_TO_BOOLEAN(ctx->Array.Index.Type);
1016          break;
1017       case GL_INDEX_ARRAY_STRIDE:
1018          params[0] = INT_TO_BOOLEAN(ctx->Array.Index.Stride);
1019          break;
1020       case GL_INDEX_ARRAY_COUNT_EXT:
1021          params[0] = INT_TO_BOOLEAN(0);
1022          break;
1023       case GL_TEXTURE_COORD_ARRAY:
1024          params[0] = ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
1025          break;
1026       case GL_TEXTURE_COORD_ARRAY_SIZE:
1027          params[0] = INT_TO_BOOLEAN(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Size);
1028          break;
1029       case GL_TEXTURE_COORD_ARRAY_TYPE:
1030          params[0] = ENUM_TO_BOOLEAN(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Type);
1031          break;
1032       case GL_TEXTURE_COORD_ARRAY_STRIDE:
1033          params[0] = INT_TO_BOOLEAN(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Stride);
1034          break;
1035       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
1036          params[0] = INT_TO_BOOLEAN(0);
1037          break;
1038       case GL_EDGE_FLAG_ARRAY:
1039          params[0] = ctx->Array.EdgeFlag.Enabled;
1040          break;
1041       case GL_EDGE_FLAG_ARRAY_STRIDE:
1042          params[0] = INT_TO_BOOLEAN(ctx->Array.EdgeFlag.Stride);
1043          break;
1044       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
1045          params[0] = INT_TO_BOOLEAN(0);
1046          break;
1047       case GL_MAX_TEXTURE_UNITS_ARB:
1048          CHECK_EXTENSION_B(ARB_multitexture, pname);
1049          params[0] = INT_TO_BOOLEAN(MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
1050          break;
1051       case GL_ACTIVE_TEXTURE_ARB:
1052          CHECK_EXTENSION_B(ARB_multitexture, pname);
1053          params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
1054          break;
1055       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
1056          CHECK_EXTENSION_B(ARB_multitexture, pname);
1057          params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
1058          break;
1059       case GL_TEXTURE_CUBE_MAP_ARB:
1060          CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
1061          params[0] = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
1062          break;
1063       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
1064          CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
1065          params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
1066          break;
1067       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
1068          CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
1069          params[0] = INT_TO_BOOLEAN((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
1070          break;
1071       case GL_TEXTURE_COMPRESSION_HINT_ARB:
1072          CHECK_EXTENSION_B(ARB_texture_compression, pname);
1073          params[0] = INT_TO_BOOLEAN(ctx->Hint.TextureCompression);
1074          break;
1075       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
1076          CHECK_EXTENSION_B(ARB_texture_compression, pname);
1077          params[0] = INT_TO_BOOLEAN(_mesa_get_compressed_formats(ctx, NULL));
1078          break;
1079       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
1080          CHECK_EXTENSION_B(ARB_texture_compression, pname);
1081          {
1082          GLint formats[100];
1083          GLuint i, n = _mesa_get_compressed_formats(ctx, formats);
1084          for (i = 0; i < n; i++)
1085             params[i] = ENUM_TO_BOOLEAN(formats[i]);
1086          }
1087          break;
1088       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
1089          CHECK_EXTENSION_B(EXT_compiled_vertex_array, pname);
1090          params[0] = INT_TO_BOOLEAN(ctx->Array.LockFirst);
1091          break;
1092       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
1093          CHECK_EXTENSION_B(EXT_compiled_vertex_array, pname);
1094          params[0] = INT_TO_BOOLEAN(ctx->Array.LockCount);
1095          break;
1096       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
1097          {
1098          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
1099          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1100          params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
1101          params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
1102          params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
1103          params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
1104          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1105          params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
1106          params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
1107          params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
1108          params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
1109          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1110          params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
1111          params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
1112          params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
1113          params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
1114          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1115          }
1116          break;
1117       case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
1118          {
1119          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
1120          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1121          params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
1122          params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
1123          params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
1124          params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
1125          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1126          params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
1127          params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
1128          params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
1129          params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
1130          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1131          params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
1132          params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
1133          params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
1134          params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
1135          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1136          }
1137          break;
1138       case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
1139          {
1140          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
1141          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1142          params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
1143          params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
1144          params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
1145          params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
1146          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1147          params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
1148          params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
1149          params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
1150          params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
1151          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1152          params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
1153          params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
1154          params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
1155          params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
1156          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1157          }
1158          break;
1159       case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
1160          {
1161          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
1162          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1163          params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
1164          params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
1165          params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
1166          params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
1167          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1168          params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
1169          params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
1170          params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
1171          params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
1172          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1173          params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
1174          params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
1175          params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
1176          params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
1177          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1178          }
1179          break;
1180       case GL_OCCLUSION_TEST_HP:
1181          CHECK_EXTENSION_B(HP_occlusion_test, pname);
1182          params[0] = ctx->Depth.OcclusionTest;
1183          break;
1184       case GL_OCCLUSION_TEST_RESULT_HP:
1185          CHECK_EXTENSION_B(HP_occlusion_test, pname);
1186          {
1187          if (ctx->Depth.OcclusionTest)
1188             params[0] = ctx->OcclusionResult;
1189          else
1190             params[0] = ctx->OcclusionResultSaved;
1191          /* reset flag now */
1192          ctx->OcclusionResult = GL_FALSE;
1193          ctx->OcclusionResultSaved = GL_FALSE;
1194          return;
1195          }
1196          break;
1197       case GL_PIXEL_TEXTURE_SGIS:
1198          CHECK_EXTENSION_B(SGIS_pixel_texture, pname);
1199          params[0] = ctx->Pixel.PixelTextureEnabled;
1200          break;
1201       case GL_PIXEL_TEX_GEN_SGIX:
1202          CHECK_EXTENSION_B(SGIX_pixel_texture, pname);
1203          params[0] = ctx->Pixel.PixelTextureEnabled;
1204          break;
1205       case GL_PIXEL_TEX_GEN_MODE_SGIX:
1206          CHECK_EXTENSION_B(SGIX_pixel_texture, pname);
1207          params[0] = ENUM_TO_BOOLEAN(pixel_texgen_mode(ctx));
1208          break;
1209       case GL_COLOR_MATRIX_SGI:
1210          {
1211          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
1212          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1213          params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
1214          params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
1215          params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
1216          params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
1217          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1218          params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
1219          params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
1220          params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
1221          params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
1222          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1223          params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
1224          params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
1225          params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
1226          params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
1227          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1228          }
1229          break;
1230       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
1231          params[0] = INT_TO_BOOLEAN(ctx->ColorMatrixStack.Depth + 1);
1232          break;
1233       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
1234          params[0] = INT_TO_BOOLEAN(MAX_COLOR_STACK_DEPTH);
1235          break;
1236       case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
1237          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[0]);
1238          break;
1239       case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
1240          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[1]);
1241          break;
1242       case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
1243          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[2]);
1244          break;
1245       case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
1246          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[3]);
1247          break;
1248       case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
1249          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[0]);
1250          break;
1251       case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
1252          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[1]);
1253          break;
1254       case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
1255          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[2]);
1256          break;
1257       case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
1258          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[3]);
1259          break;
1260       case GL_CONVOLUTION_1D_EXT:
1261          CHECK_EXTENSION_B(EXT_convolution, pname);
1262          params[0] = ctx->Pixel.Convolution1DEnabled;
1263          break;
1264       case GL_CONVOLUTION_2D_EXT:
1265          CHECK_EXTENSION_B(EXT_convolution, pname);
1266          params[0] = ctx->Pixel.Convolution2DEnabled;
1267          break;
1268       case GL_SEPARABLE_2D_EXT:
1269          CHECK_EXTENSION_B(EXT_convolution, pname);
1270          params[0] = ctx->Pixel.Separable2DEnabled;
1271          break;
1272       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
1273          CHECK_EXTENSION_B(EXT_convolution, pname);
1274          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[0]);
1275          break;
1276       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
1277          CHECK_EXTENSION_B(EXT_convolution, pname);
1278          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[1]);
1279          break;
1280       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
1281          CHECK_EXTENSION_B(EXT_convolution, pname);
1282          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[2]);
1283          break;
1284       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
1285          CHECK_EXTENSION_B(EXT_convolution, pname);
1286          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[3]);
1287          break;
1288       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
1289          CHECK_EXTENSION_B(EXT_convolution, pname);
1290          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[0]);
1291          break;
1292       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
1293          CHECK_EXTENSION_B(EXT_convolution, pname);
1294          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[1]);
1295          break;
1296       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
1297          CHECK_EXTENSION_B(EXT_convolution, pname);
1298          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[2]);
1299          break;
1300       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
1301          CHECK_EXTENSION_B(EXT_convolution, pname);
1302          params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[3]);
1303          break;
1304       case GL_HISTOGRAM:
1305          CHECK_EXTENSION_B(EXT_histogram, pname);
1306          params[0] = ctx->Pixel.HistogramEnabled;
1307          break;
1308       case GL_MINMAX:
1309          CHECK_EXTENSION_B(EXT_histogram, pname);
1310          params[0] = ctx->Pixel.MinMaxEnabled;
1311          break;
1312       case GL_COLOR_TABLE_SGI:
1313          CHECK_EXTENSION_B(SGI_color_table, pname);
1314          params[0] = ctx->Pixel.ColorTableEnabled;
1315          break;
1316       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1317          CHECK_EXTENSION_B(SGI_color_table, pname);
1318          params[0] = ctx->Pixel.PostConvolutionColorTableEnabled;
1319          break;
1320       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1321          CHECK_EXTENSION_B(SGI_color_table, pname);
1322          params[0] = ctx->Pixel.PostColorMatrixColorTableEnabled;
1323          break;
1324       case GL_TEXTURE_COLOR_TABLE_SGI:
1325          CHECK_EXTENSION_B(SGI_texture_color_table, pname);
1326          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
1327          break;
1328       case GL_COLOR_SUM_EXT:
1329          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1330          params[0] = ctx->Fog.ColorSumEnabled;
1331          break;
1332       case GL_CURRENT_SECONDARY_COLOR_EXT:
1333          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1334          {
1335          FLUSH_CURRENT(ctx, 0);
1336          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
1337          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
1338          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
1339          params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
1340          }
1341          break;
1342       case GL_SECONDARY_COLOR_ARRAY_EXT:
1343          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1344          params[0] = ctx->Array.SecondaryColor.Enabled;
1345          break;
1346       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
1347          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1348          params[0] = ENUM_TO_BOOLEAN(ctx->Array.SecondaryColor.Type);
1349          break;
1350       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
1351          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1352          params[0] = INT_TO_BOOLEAN(ctx->Array.SecondaryColor.Stride);
1353          break;
1354       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
1355          CHECK_EXTENSION_B(EXT_secondary_color, pname);
1356          params[0] = INT_TO_BOOLEAN(ctx->Array.SecondaryColor.Size);
1357          break;
1358       case GL_CURRENT_FOG_COORDINATE_EXT:
1359          CHECK_EXTENSION_B(EXT_fog_coord, pname);
1360          {
1361          FLUSH_CURRENT(ctx, 0);
1362          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
1363          }
1364          break;
1365       case GL_FOG_COORDINATE_ARRAY_EXT:
1366          CHECK_EXTENSION_B(EXT_fog_coord, pname);
1367          params[0] = ctx->Array.FogCoord.Enabled;
1368          break;
1369       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
1370          CHECK_EXTENSION_B(EXT_fog_coord, pname);
1371          params[0] = ENUM_TO_BOOLEAN(ctx->Array.FogCoord.Type);
1372          break;
1373       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
1374          CHECK_EXTENSION_B(EXT_fog_coord, pname);
1375          params[0] = INT_TO_BOOLEAN(ctx->Array.FogCoord.Stride);
1376          break;
1377       case GL_FOG_COORDINATE_SOURCE_EXT:
1378          CHECK_EXTENSION_B(EXT_fog_coord, pname);
1379          params[0] = ENUM_TO_BOOLEAN(ctx->Fog.FogCoordinateSource);
1380          break;
1381       case GL_MAX_TEXTURE_LOD_BIAS_EXT:
1382          CHECK_EXTENSION_B(EXT_texture_lod_bias, pname);
1383          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureLodBias);
1384          break;
1385       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
1386          CHECK_EXTENSION_B(EXT_texture_filter_anisotropic, pname);
1387          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureMaxAnisotropy);
1388          break;
1389       case GL_MULTISAMPLE_ARB:
1390          CHECK_EXTENSION_B(ARB_multisample, pname);
1391          params[0] = ctx->Multisample.Enabled;
1392          break;
1393       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1394          CHECK_EXTENSION_B(ARB_multisample, pname);
1395          params[0] = ctx->Multisample.SampleAlphaToCoverage;
1396          break;
1397       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1398          CHECK_EXTENSION_B(ARB_multisample, pname);
1399          params[0] = ctx->Multisample.SampleAlphaToOne;
1400          break;
1401       case GL_SAMPLE_COVERAGE_ARB:
1402          CHECK_EXTENSION_B(ARB_multisample, pname);
1403          params[0] = ctx->Multisample.SampleCoverage;
1404          break;
1405       case GL_SAMPLE_COVERAGE_VALUE_ARB:
1406          CHECK_EXTENSION_B(ARB_multisample, pname);
1407          params[0] = FLOAT_TO_BOOLEAN(ctx->Multisample.SampleCoverageValue);
1408          break;
1409       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1410          CHECK_EXTENSION_B(ARB_multisample, pname);
1411          params[0] = ctx->Multisample.SampleCoverageInvert;
1412          break;
1413       case GL_SAMPLE_BUFFERS_ARB:
1414          CHECK_EXTENSION_B(ARB_multisample, pname);
1415          params[0] = INT_TO_BOOLEAN(0);
1416          break;
1417       case GL_SAMPLES_ARB:
1418          CHECK_EXTENSION_B(ARB_multisample, pname);
1419          params[0] = INT_TO_BOOLEAN(0);
1420          break;
1421       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1422          CHECK_EXTENSION_B(IBM_rasterpos_clip, pname);
1423          params[0] = ctx->Transform.RasterPositionUnclipped;
1424          break;
1425       case GL_POINT_SPRITE_NV:
1426          CHECK_EXTENSION_B(NV_point_sprite, pname);
1427          params[0] = ctx->Point.PointSprite;
1428          break;
1429       case GL_POINT_SPRITE_R_MODE_NV:
1430          CHECK_EXTENSION_B(NV_point_sprite, pname);
1431          params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteRMode);
1432          break;
1433       case GL_POINT_SPRITE_COORD_ORIGIN:
1434          CHECK_EXTENSION_B(NV_point_sprite, pname);
1435          params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteOrigin);
1436          break;
1437       case GL_GENERATE_MIPMAP_HINT_SGIS:
1438          CHECK_EXTENSION_B(SGIS_generate_mipmap, pname);
1439          params[0] = ENUM_TO_BOOLEAN(ctx->Hint.GenerateMipmap);
1440          break;
1441       case GL_VERTEX_PROGRAM_NV:
1442          CHECK_EXTENSION_B(NV_vertex_program, pname);
1443          params[0] = ctx->VertexProgram.Enabled;
1444          break;
1445       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
1446          CHECK_EXTENSION_B(NV_vertex_program, pname);
1447          params[0] = ctx->VertexProgram.PointSizeEnabled;
1448          break;
1449       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
1450          CHECK_EXTENSION_B(NV_vertex_program, pname);
1451          params[0] = ctx->VertexProgram.TwoSideEnabled;
1452          break;
1453       case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
1454          CHECK_EXTENSION_B(NV_vertex_program, pname);
1455          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrixStackDepth);
1456          break;
1457       case GL_MAX_TRACK_MATRICES_NV:
1458          CHECK_EXTENSION_B(NV_vertex_program, pname);
1459          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrices);
1460          break;
1461       case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
1462          CHECK_EXTENSION_B(NV_vertex_program, pname);
1463          params[0] = ctx->CurrentStack->Depth + 1;
1464          break;
1465       case GL_CURRENT_MATRIX_NV:
1466          CHECK_EXTENSION_B(NV_vertex_program, pname);
1467          {
1468          const GLfloat *matrix = ctx->CurrentStack->Top->m;
1469          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1470          params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
1471          params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
1472          params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
1473          params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
1474          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1475          params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
1476          params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
1477          params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
1478          params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
1479          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1480          params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
1481          params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
1482          params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
1483          params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
1484          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1485          }
1486          break;
1487       case GL_VERTEX_PROGRAM_BINDING_NV:
1488          CHECK_EXTENSION_B(NV_vertex_program, pname);
1489          params[0] = INT_TO_BOOLEAN((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
1490          break;
1491       case GL_PROGRAM_ERROR_POSITION_NV:
1492          CHECK_EXTENSION_B(NV_vertex_program, pname);
1493          params[0] = INT_TO_BOOLEAN(ctx->Program.ErrorPos);
1494          break;
1495       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1496          CHECK_EXTENSION_B(NV_vertex_program, pname);
1497          params[0] = ctx->Array.VertexAttrib[0].Enabled;
1498          break;
1499       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1500          CHECK_EXTENSION_B(NV_vertex_program, pname);
1501          params[0] = ctx->Array.VertexAttrib[1].Enabled;
1502          break;
1503       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1504          CHECK_EXTENSION_B(NV_vertex_program, pname);
1505          params[0] = ctx->Array.VertexAttrib[2].Enabled;
1506          break;
1507       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1508          CHECK_EXTENSION_B(NV_vertex_program, pname);
1509          params[0] = ctx->Array.VertexAttrib[3].Enabled;
1510          break;
1511       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1512          CHECK_EXTENSION_B(NV_vertex_program, pname);
1513          params[0] = ctx->Array.VertexAttrib[4].Enabled;
1514          break;
1515       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1516          CHECK_EXTENSION_B(NV_vertex_program, pname);
1517          params[0] = ctx->Array.VertexAttrib[5].Enabled;
1518          break;
1519       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1520          CHECK_EXTENSION_B(NV_vertex_program, pname);
1521          params[0] = ctx->Array.VertexAttrib[6].Enabled;
1522          break;
1523       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1524          CHECK_EXTENSION_B(NV_vertex_program, pname);
1525          params[0] = ctx->Array.VertexAttrib[7].Enabled;
1526          break;
1527       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1528          CHECK_EXTENSION_B(NV_vertex_program, pname);
1529          params[0] = ctx->Array.VertexAttrib[8].Enabled;
1530          break;
1531       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1532          CHECK_EXTENSION_B(NV_vertex_program, pname);
1533          params[0] = ctx->Array.VertexAttrib[9].Enabled;
1534          break;
1535       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1536          CHECK_EXTENSION_B(NV_vertex_program, pname);
1537          params[0] = ctx->Array.VertexAttrib[10].Enabled;
1538          break;
1539       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1540          CHECK_EXTENSION_B(NV_vertex_program, pname);
1541          params[0] = ctx->Array.VertexAttrib[11].Enabled;
1542          break;
1543       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1544          CHECK_EXTENSION_B(NV_vertex_program, pname);
1545          params[0] = ctx->Array.VertexAttrib[12].Enabled;
1546          break;
1547       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1548          CHECK_EXTENSION_B(NV_vertex_program, pname);
1549          params[0] = ctx->Array.VertexAttrib[13].Enabled;
1550          break;
1551       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1552          CHECK_EXTENSION_B(NV_vertex_program, pname);
1553          params[0] = ctx->Array.VertexAttrib[14].Enabled;
1554          break;
1555       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1556          CHECK_EXTENSION_B(NV_vertex_program, pname);
1557          params[0] = ctx->Array.VertexAttrib[15].Enabled;
1558          break;
1559       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1560          CHECK_EXTENSION_B(NV_vertex_program, pname);
1561          params[0] = ctx->Eval.Map1Attrib[0];
1562          break;
1563       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1564          CHECK_EXTENSION_B(NV_vertex_program, pname);
1565          params[0] = ctx->Eval.Map1Attrib[1];
1566          break;
1567       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1568          CHECK_EXTENSION_B(NV_vertex_program, pname);
1569          params[0] = ctx->Eval.Map1Attrib[2];
1570          break;
1571       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1572          CHECK_EXTENSION_B(NV_vertex_program, pname);
1573          params[0] = ctx->Eval.Map1Attrib[3];
1574          break;
1575       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1576          CHECK_EXTENSION_B(NV_vertex_program, pname);
1577          params[0] = ctx->Eval.Map1Attrib[4];
1578          break;
1579       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1580          CHECK_EXTENSION_B(NV_vertex_program, pname);
1581          params[0] = ctx->Eval.Map1Attrib[5];
1582          break;
1583       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1584          CHECK_EXTENSION_B(NV_vertex_program, pname);
1585          params[0] = ctx->Eval.Map1Attrib[6];
1586          break;
1587       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1588          CHECK_EXTENSION_B(NV_vertex_program, pname);
1589          params[0] = ctx->Eval.Map1Attrib[7];
1590          break;
1591       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1592          CHECK_EXTENSION_B(NV_vertex_program, pname);
1593          params[0] = ctx->Eval.Map1Attrib[8];
1594          break;
1595       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1596          CHECK_EXTENSION_B(NV_vertex_program, pname);
1597          params[0] = ctx->Eval.Map1Attrib[9];
1598          break;
1599       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1600          CHECK_EXTENSION_B(NV_vertex_program, pname);
1601          params[0] = ctx->Eval.Map1Attrib[10];
1602          break;
1603       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1604          CHECK_EXTENSION_B(NV_vertex_program, pname);
1605          params[0] = ctx->Eval.Map1Attrib[11];
1606          break;
1607       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1608          CHECK_EXTENSION_B(NV_vertex_program, pname);
1609          params[0] = ctx->Eval.Map1Attrib[12];
1610          break;
1611       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1612          CHECK_EXTENSION_B(NV_vertex_program, pname);
1613          params[0] = ctx->Eval.Map1Attrib[13];
1614          break;
1615       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1616          CHECK_EXTENSION_B(NV_vertex_program, pname);
1617          params[0] = ctx->Eval.Map1Attrib[14];
1618          break;
1619       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1620          CHECK_EXTENSION_B(NV_vertex_program, pname);
1621          params[0] = ctx->Eval.Map1Attrib[15];
1622          break;
1623       case GL_FRAGMENT_PROGRAM_NV:
1624          CHECK_EXTENSION_B(NV_fragment_program, pname);
1625          params[0] = ctx->FragmentProgram.Enabled;
1626          break;
1627       case GL_MAX_TEXTURE_COORDS_NV:
1628          CHECK_EXTENSION_B(NV_fragment_program, pname);
1629          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureCoordUnits);
1630          break;
1631       case GL_MAX_TEXTURE_IMAGE_UNITS_NV:
1632          CHECK_EXTENSION_B(NV_fragment_program, pname);
1633          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureImageUnits);
1634          break;
1635       case GL_FRAGMENT_PROGRAM_BINDING_NV:
1636          CHECK_EXTENSION_B(NV_fragment_program, pname);
1637          params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
1638          break;
1639       case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
1640          CHECK_EXTENSION_B(NV_fragment_program, pname);
1641          params[0] = INT_TO_BOOLEAN(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
1642          break;
1643       case GL_TEXTURE_RECTANGLE_NV:
1644          CHECK_EXTENSION_B(NV_texture_rectangle, pname);
1645          params[0] = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
1646          break;
1647       case GL_TEXTURE_BINDING_RECTANGLE_NV:
1648          CHECK_EXTENSION_B(NV_texture_rectangle, pname);
1649          params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
1650          break;
1651       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
1652          CHECK_EXTENSION_B(NV_texture_rectangle, pname);
1653          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureRectSize);
1654          break;
1655       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1656          CHECK_EXTENSION_B(EXT_stencil_two_side, pname);
1657          params[0] = ctx->Stencil.TestTwoSide;
1658          break;
1659       case GL_ACTIVE_STENCIL_FACE_EXT:
1660          CHECK_EXTENSION_B(EXT_stencil_two_side, pname);
1661          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
1662          break;
1663       case GL_MAX_SHININESS_NV:
1664          CHECK_EXTENSION_B(NV_light_max_exponent, pname);
1665          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxShininess);
1666          break;
1667       case GL_MAX_SPOT_EXPONENT_NV:
1668          CHECK_EXTENSION_B(NV_light_max_exponent, pname);
1669          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxSpotExponent);
1670          break;
1671       case GL_ARRAY_BUFFER_BINDING_ARB:
1672          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1673          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayBufferObj->Name);
1674          break;
1675       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
1676          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1677          params[0] = INT_TO_BOOLEAN(ctx->Array.Vertex.BufferObj->Name);
1678          break;
1679       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
1680          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1681          params[0] = INT_TO_BOOLEAN(ctx->Array.Normal.BufferObj->Name);
1682          break;
1683       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
1684          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1685          params[0] = INT_TO_BOOLEAN(ctx->Array.Color.BufferObj->Name);
1686          break;
1687       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
1688          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1689          params[0] = INT_TO_BOOLEAN(ctx->Array.Index.BufferObj->Name);
1690          break;
1691       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
1692          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1693          params[0] = INT_TO_BOOLEAN(ctx->Array.TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
1694          break;
1695       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
1696          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1697          params[0] = INT_TO_BOOLEAN(ctx->Array.EdgeFlag.BufferObj->Name);
1698          break;
1699       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
1700          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1701          params[0] = INT_TO_BOOLEAN(ctx->Array.SecondaryColor.BufferObj->Name);
1702          break;
1703       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
1704          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1705          params[0] = INT_TO_BOOLEAN(ctx->Array.FogCoord.BufferObj->Name);
1706          break;
1707       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
1708          CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname);
1709          params[0] = INT_TO_BOOLEAN(ctx->Array.ElementArrayBufferObj->Name);
1710          break;
1711       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
1712          CHECK_EXTENSION_B(EXT_pixel_buffer_object, pname);
1713          params[0] = INT_TO_BOOLEAN(ctx->Pack.BufferObj->Name);
1714          break;
1715       case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
1716          CHECK_EXTENSION_B(EXT_pixel_buffer_object, pname);
1717          params[0] = INT_TO_BOOLEAN(ctx->Unpack.BufferObj->Name);
1718          break;
1719       case GL_MAX_VERTEX_ATTRIBS_ARB:
1720          CHECK_EXTENSION_B(ARB_vertex_program, pname);
1721          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxVertexProgramAttribs);
1722          break;
1723       case GL_FRAGMENT_PROGRAM_ARB:
1724          CHECK_EXTENSION_B(ARB_fragment_program, pname);
1725          params[0] = ctx->FragmentProgram.Enabled;
1726          break;
1727       case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
1728          CHECK_EXTENSION_B(ARB_fragment_program, pname);
1729          {
1730          const GLfloat *matrix = ctx->CurrentStack->Top->m;
1731          params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
1732          params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
1733          params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
1734          params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
1735          params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
1736          params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
1737          params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
1738          params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
1739          params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
1740          params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
1741          params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
1742          params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
1743          params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
1744          params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
1745          params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
1746          params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
1747          }
1748          break;
1749       case GL_DEPTH_BOUNDS_TEST_EXT:
1750          CHECK_EXTENSION_B(EXT_depth_bounds_test, pname);
1751          params[0] = ctx->Depth.BoundsTest;
1752          break;
1753       case GL_DEPTH_BOUNDS_EXT:
1754          CHECK_EXTENSION_B(EXT_depth_bounds_test, pname);
1755          params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
1756          params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
1757          break;
1758       case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
1759          CHECK_EXTENSION_B(MESA_program_debug, pname);
1760          params[0] = ctx->FragmentProgram.CallbackEnabled;
1761          break;
1762       case GL_VERTEX_PROGRAM_CALLBACK_MESA:
1763          CHECK_EXTENSION_B(MESA_program_debug, pname);
1764          params[0] = ctx->VertexProgram.CallbackEnabled;
1765          break;
1766       case GL_FRAGMENT_PROGRAM_POSITION_MESA:
1767          CHECK_EXTENSION_B(MESA_program_debug, pname);
1768          params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.CurrentPosition);
1769          break;
1770       case GL_VERTEX_PROGRAM_POSITION_MESA:
1771          CHECK_EXTENSION_B(MESA_program_debug, pname);
1772          params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.CurrentPosition);
1773          break;
1774       case GL_MAX_DRAW_BUFFERS_ARB:
1775          CHECK_EXTENSION_B(ARB_draw_buffers, pname);
1776          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
1777          break;
1778       case GL_DRAW_BUFFER0_ARB:
1779          CHECK_EXTENSION_B(ARB_draw_buffers, pname);
1780          params[0] = ENUM_TO_BOOLEAN(ctx->Color.DrawBuffer[0]);
1781          break;
1782       case GL_DRAW_BUFFER1_ARB:
1783          CHECK_EXTENSION_B(ARB_draw_buffers, pname);
1784          {
1785          GLenum buffer;
1786          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1787             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
1788             return;
1789          }
1790          buffer = ctx->Color.DrawBuffer[1];
1791          params[0] = ENUM_TO_BOOLEAN(buffer);
1792          }
1793          break;
1794       case GL_DRAW_BUFFER2_ARB:
1795          CHECK_EXTENSION_B(ARB_draw_buffers, pname);
1796          {
1797          GLenum buffer;
1798          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1799             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
1800             return;
1801          }
1802          buffer = ctx->Color.DrawBuffer[2];
1803          params[0] = ENUM_TO_BOOLEAN(buffer);
1804          }
1805          break;
1806       case GL_DRAW_BUFFER3_ARB:
1807          CHECK_EXTENSION_B(ARB_draw_buffers, pname);
1808          {
1809          GLenum buffer;
1810          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1811             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
1812             return;
1813          }
1814          buffer = ctx->Color.DrawBuffer[3];
1815          params[0] = ENUM_TO_BOOLEAN(buffer);
1816          }
1817          break;
1818       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
1819          CHECK_EXTENSION_B(OES_read_format, pname);
1820          params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadType);
1821          break;
1822       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
1823          CHECK_EXTENSION_B(OES_read_format, pname);
1824          params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadFormat);
1825          break;
1826       case GL_NUM_FRAGMENT_REGISTERS_ATI:
1827          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1828          params[0] = INT_TO_BOOLEAN(6);
1829          break;
1830       case GL_NUM_FRAGMENT_CONSTANTS_ATI:
1831          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1832          params[0] = INT_TO_BOOLEAN(8);
1833          break;
1834       case GL_NUM_PASSES_ATI:
1835          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1836          params[0] = INT_TO_BOOLEAN(2);
1837          break;
1838       case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
1839          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1840          params[0] = INT_TO_BOOLEAN(8);
1841          break;
1842       case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
1843          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1844          params[0] = INT_TO_BOOLEAN(16);
1845          break;
1846       case GL_COLOR_ALPHA_PAIRING_ATI:
1847          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1848          params[0] = GL_TRUE;
1849          break;
1850       case GL_NUM_LOOPBACK_COMPONENTS_ATI:
1851          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1852          params[0] = INT_TO_BOOLEAN(3);
1853          break;
1854       case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
1855          CHECK_EXTENSION_B(ATI_fragment_shader, pname);
1856          params[0] = INT_TO_BOOLEAN(3);
1857          break;
1858       case GL_STENCIL_BACK_FUNC:
1859          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[1]);
1860          break;
1861       case GL_STENCIL_BACK_VALUE_MASK:
1862          params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[1]);
1863          break;
1864       case GL_STENCIL_BACK_REF:
1865          params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[1]);
1866          break;
1867       case GL_STENCIL_BACK_FAIL:
1868          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[1]);
1869          break;
1870       case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1871          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[1]);
1872          break;
1873       case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1874          params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[1]);
1875          break;
1876       default:
1877          _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname);
1878    }
1879 }
1880
1881 void GLAPIENTRY
1882 _mesa_GetFloatv( GLenum pname, GLfloat *params )
1883 {
1884    GET_CURRENT_CONTEXT(ctx);
1885    ASSERT_OUTSIDE_BEGIN_END(ctx);
1886
1887    if (!params)
1888       return;
1889
1890    if (ctx->Driver.GetFloatv &&
1891        ctx->Driver.GetFloatv(ctx, pname, params))
1892       return;
1893
1894    switch (pname) {
1895       case GL_ACCUM_RED_BITS:
1896          params[0] = (GLfloat)(ctx->Visual.accumRedBits);
1897          break;
1898       case GL_ACCUM_GREEN_BITS:
1899          params[0] = (GLfloat)(ctx->Visual.accumGreenBits);
1900          break;
1901       case GL_ACCUM_BLUE_BITS:
1902          params[0] = (GLfloat)(ctx->Visual.accumBlueBits);
1903          break;
1904       case GL_ACCUM_ALPHA_BITS:
1905          params[0] = (GLfloat)(ctx->Visual.accumAlphaBits);
1906          break;
1907       case GL_ACCUM_CLEAR_VALUE:
1908          params[0] = ctx->Accum.ClearColor[0];
1909          params[1] = ctx->Accum.ClearColor[1];
1910          params[2] = ctx->Accum.ClearColor[2];
1911          params[3] = ctx->Accum.ClearColor[3];
1912          break;
1913       case GL_ALPHA_BIAS:
1914          params[0] = ctx->Pixel.AlphaBias;
1915          break;
1916       case GL_ALPHA_BITS:
1917          params[0] = (GLfloat)(ctx->Visual.alphaBits);
1918          break;
1919       case GL_ALPHA_SCALE:
1920          params[0] = ctx->Pixel.AlphaScale;
1921          break;
1922       case GL_ALPHA_TEST:
1923          params[0] = BOOLEAN_TO_FLOAT(ctx->Color.AlphaEnabled);
1924          break;
1925       case GL_ALPHA_TEST_FUNC:
1926          params[0] = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
1927          break;
1928       case GL_ALPHA_TEST_REF:
1929          params[0] = ctx->Color.AlphaRef;
1930          break;
1931       case GL_ATTRIB_STACK_DEPTH:
1932          params[0] = (GLfloat)(ctx->AttribStackDepth);
1933          break;
1934       case GL_AUTO_NORMAL:
1935          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.AutoNormal);
1936          break;
1937       case GL_AUX_BUFFERS:
1938          params[0] = (GLfloat)(ctx->Visual.numAuxBuffers);
1939          break;
1940       case GL_BLEND:
1941          params[0] = BOOLEAN_TO_FLOAT(ctx->Color.BlendEnabled);
1942          break;
1943       case GL_BLEND_DST:
1944          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
1945          break;
1946       case GL_BLEND_SRC:
1947          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
1948          break;
1949       case GL_BLEND_SRC_RGB_EXT:
1950          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
1951          break;
1952       case GL_BLEND_DST_RGB_EXT:
1953          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
1954          break;
1955       case GL_BLEND_SRC_ALPHA_EXT:
1956          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
1957          break;
1958       case GL_BLEND_DST_ALPHA_EXT:
1959          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
1960          break;
1961       case GL_BLEND_EQUATION:
1962          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationRGB );
1963          break;
1964       case GL_BLEND_EQUATION_ALPHA_EXT:
1965          params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationA );
1966          break;
1967       case GL_BLEND_COLOR_EXT:
1968          params[0] = ctx->Color.BlendColor[0];
1969          params[1] = ctx->Color.BlendColor[1];
1970          params[2] = ctx->Color.BlendColor[2];
1971          params[3] = ctx->Color.BlendColor[3];
1972          break;
1973       case GL_BLUE_BIAS:
1974          params[0] = ctx->Pixel.BlueBias;
1975          break;
1976       case GL_BLUE_BITS:
1977          params[0] = (GLfloat)(ctx->Visual.blueBits);
1978          break;
1979       case GL_BLUE_SCALE:
1980          params[0] = ctx->Pixel.BlueScale;
1981          break;
1982       case GL_CLIENT_ATTRIB_STACK_DEPTH:
1983          params[0] = (GLfloat)(ctx->ClientAttribStackDepth);
1984          break;
1985       case GL_CLIP_PLANE0:
1986          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
1987          break;
1988       case GL_CLIP_PLANE1:
1989          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
1990          break;
1991       case GL_CLIP_PLANE2:
1992          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
1993          break;
1994       case GL_CLIP_PLANE3:
1995          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
1996          break;
1997       case GL_CLIP_PLANE4:
1998          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
1999          break;
2000       case GL_CLIP_PLANE5:
2001          params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
2002          break;
2003       case GL_COLOR_CLEAR_VALUE:
2004          params[0] = ctx->Color.ClearColor[0];
2005          params[1] = ctx->Color.ClearColor[1];
2006          params[2] = ctx->Color.ClearColor[2];
2007          params[3] = ctx->Color.ClearColor[3];
2008          break;
2009       case GL_COLOR_MATERIAL:
2010          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.ColorMaterialEnabled);
2011          break;
2012       case GL_COLOR_MATERIAL_FACE:
2013          params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
2014          break;
2015       case GL_COLOR_MATERIAL_PARAMETER:
2016          params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
2017          break;
2018       case GL_COLOR_WRITEMASK:
2019          params[0] = (GLfloat)(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
2020          params[1] = (GLfloat)(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
2021          params[2] = (GLfloat)(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
2022          params[3] = (GLfloat)(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
2023          break;
2024       case GL_CULL_FACE:
2025          params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.CullFlag);
2026          break;
2027       case GL_CULL_FACE_MODE:
2028          params[0] = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
2029          break;
2030       case GL_CURRENT_COLOR:
2031          {
2032          FLUSH_CURRENT(ctx, 0);
2033          params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
2034          params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
2035          params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
2036          params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
2037          }
2038          break;
2039       case GL_CURRENT_INDEX:
2040          {
2041          FLUSH_CURRENT(ctx, 0);
2042          params[0] = ctx->Current.Index;
2043          }
2044          break;
2045       case GL_CURRENT_NORMAL:
2046          {
2047          FLUSH_CURRENT(ctx, 0);
2048          params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
2049          params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
2050          params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
2051          }
2052          break;
2053       case GL_CURRENT_RASTER_COLOR:
2054          params[0] = ctx->Current.RasterColor[0];
2055          params[1] = ctx->Current.RasterColor[1];
2056          params[2] = ctx->Current.RasterColor[2];
2057          params[3] = ctx->Current.RasterColor[3];
2058          break;
2059       case GL_CURRENT_RASTER_DISTANCE:
2060          params[0] = ctx->Current.RasterDistance;
2061          break;
2062       case GL_CURRENT_RASTER_INDEX:
2063          params[0] = ctx->Current.RasterIndex;
2064          break;
2065       case GL_CURRENT_RASTER_POSITION:
2066          params[0] = ctx->Current.RasterPos[0];
2067          params[1] = ctx->Current.RasterPos[1];
2068          params[2] = ctx->Current.RasterPos[2];
2069          params[3] = ctx->Current.RasterPos[3];
2070          break;
2071       case GL_CURRENT_RASTER_TEXTURE_COORDS:
2072          {
2073          const GLuint texUnit = ctx->Texture.CurrentUnit;
2074          params[0] = ctx->Current.RasterTexCoords[texUnit][0];
2075          params[1] = ctx->Current.RasterTexCoords[texUnit][1];
2076          params[2] = ctx->Current.RasterTexCoords[texUnit][2];
2077          params[3] = ctx->Current.RasterTexCoords[texUnit][3];
2078          }
2079          break;
2080       case GL_CURRENT_RASTER_POSITION_VALID:
2081          params[0] = BOOLEAN_TO_FLOAT(ctx->Current.RasterPosValid);
2082          break;
2083       case GL_CURRENT_TEXTURE_COORDS:
2084          {
2085          const GLuint texUnit = ctx->Texture.CurrentUnit;
2086          params[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
2087          params[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
2088          params[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
2089          params[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
2090          }
2091          break;
2092       case GL_DEPTH_BIAS:
2093          params[0] = ctx->Pixel.DepthBias;
2094          break;
2095       case GL_DEPTH_BITS:
2096          params[0] = (GLfloat)(ctx->Visual.depthBits);
2097          break;
2098       case GL_DEPTH_CLEAR_VALUE:
2099          params[0] = ctx->Depth.Clear;
2100          break;
2101       case GL_DEPTH_FUNC:
2102          params[0] = ENUM_TO_FLOAT(ctx->Depth.Func);
2103          break;
2104       case GL_DEPTH_RANGE:
2105          params[0] = ctx->Viewport.Near;
2106          params[1] = ctx->Viewport.Far;
2107          break;
2108       case GL_DEPTH_SCALE:
2109          params[0] = ctx->Pixel.DepthScale;
2110          break;
2111       case GL_DEPTH_TEST:
2112          params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Test);
2113          break;
2114       case GL_DEPTH_WRITEMASK:
2115          params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Mask);
2116          break;
2117       case GL_DITHER:
2118          params[0] = BOOLEAN_TO_FLOAT(ctx->Color.DitherFlag);
2119          break;
2120       case GL_DOUBLEBUFFER:
2121          params[0] = BOOLEAN_TO_FLOAT(ctx->Visual.doubleBufferMode);
2122          break;
2123       case GL_DRAW_BUFFER:
2124          params[0] = ENUM_TO_FLOAT(ctx->Color.DrawBuffer[0]);
2125          break;
2126       case GL_EDGE_FLAG:
2127          {
2128          FLUSH_CURRENT(ctx, 0);
2129          params[0] = BOOLEAN_TO_FLOAT(ctx->Current.EdgeFlag);
2130          }
2131          break;
2132       case GL_FEEDBACK_BUFFER_SIZE:
2133          params[0] = (GLfloat)(ctx->Feedback.BufferSize);
2134          break;
2135       case GL_FEEDBACK_BUFFER_TYPE:
2136          params[0] = ENUM_TO_FLOAT(ctx->Feedback.Type);
2137          break;
2138       case GL_FOG:
2139          params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.Enabled);
2140          break;
2141       case GL_FOG_COLOR:
2142          params[0] = ctx->Fog.Color[0];
2143          params[1] = ctx->Fog.Color[1];
2144          params[2] = ctx->Fog.Color[2];
2145          params[3] = ctx->Fog.Color[3];
2146          break;
2147       case GL_FOG_DENSITY:
2148          params[0] = ctx->Fog.Density;
2149          break;
2150       case GL_FOG_END:
2151          params[0] = ctx->Fog.End;
2152          break;
2153       case GL_FOG_HINT:
2154          params[0] = ENUM_TO_FLOAT(ctx->Hint.Fog);
2155          break;
2156       case GL_FOG_INDEX:
2157          params[0] = ctx->Fog.Index;
2158          break;
2159       case GL_FOG_MODE:
2160          params[0] = ENUM_TO_FLOAT(ctx->Fog.Mode);
2161          break;
2162       case GL_FOG_START:
2163          params[0] = ctx->Fog.Start;
2164          break;
2165       case GL_FRONT_FACE:
2166          params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
2167          break;
2168       case GL_GREEN_BIAS:
2169          params[0] = ctx->Pixel.GreenBias;
2170          break;
2171       case GL_GREEN_BITS:
2172          params[0] = (GLfloat)(ctx->Visual.greenBits);
2173          break;
2174       case GL_GREEN_SCALE:
2175          params[0] = ctx->Pixel.GreenScale;
2176          break;
2177       case GL_INDEX_BITS:
2178          params[0] = (GLfloat)(ctx->Visual.indexBits);
2179          break;
2180       case GL_INDEX_CLEAR_VALUE:
2181          params[0] = (GLfloat)(ctx->Color.ClearIndex);
2182          break;
2183       case GL_INDEX_MODE:
2184          params[0] = BOOLEAN_TO_FLOAT(!ctx->Visual.rgbMode);
2185          break;
2186       case GL_INDEX_OFFSET:
2187          params[0] = (GLfloat)(ctx->Pixel.IndexOffset);
2188          break;
2189       case GL_INDEX_SHIFT:
2190          params[0] = (GLfloat)(ctx->Pixel.IndexShift);
2191          break;
2192       case GL_INDEX_WRITEMASK:
2193          params[0] = (GLfloat)(ctx->Color.IndexMask);
2194          break;
2195       case GL_LIGHT0:
2196          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[0].Enabled);
2197          break;
2198       case GL_LIGHT1:
2199          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[1].Enabled);
2200          break;
2201       case GL_LIGHT2:
2202          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[2].Enabled);
2203          break;
2204       case GL_LIGHT3:
2205          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[3].Enabled);
2206          break;
2207       case GL_LIGHT4:
2208          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[4].Enabled);
2209          break;
2210       case GL_LIGHT5:
2211          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[5].Enabled);
2212          break;
2213       case GL_LIGHT6:
2214          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[6].Enabled);
2215          break;
2216       case GL_LIGHT7:
2217          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[7].Enabled);
2218          break;
2219       case GL_LIGHTING:
2220          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Enabled);
2221          break;
2222       case GL_LIGHT_MODEL_AMBIENT:
2223          params[0] = ctx->Light.Model.Ambient[0];
2224          params[1] = ctx->Light.Model.Ambient[1];
2225          params[2] = ctx->Light.Model.Ambient[2];
2226          params[3] = ctx->Light.Model.Ambient[3];
2227          break;
2228       case GL_LIGHT_MODEL_COLOR_CONTROL:
2229          params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
2230          break;
2231       case GL_LIGHT_MODEL_LOCAL_VIEWER:
2232          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.LocalViewer);
2233          break;
2234       case GL_LIGHT_MODEL_TWO_SIDE:
2235          params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.TwoSide);
2236          break;
2237       case GL_LINE_SMOOTH:
2238          params[0] = BOOLEAN_TO_FLOAT(ctx->Line.SmoothFlag);
2239          break;
2240       case GL_LINE_SMOOTH_HINT:
2241          params[0] = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
2242          break;
2243       case GL_LINE_STIPPLE:
2244          params[0] = BOOLEAN_TO_FLOAT(ctx->Line.StippleFlag);
2245          break;
2246       case GL_LINE_STIPPLE_PATTERN:
2247          params[0] = (GLfloat)(ctx->Line.StipplePattern);
2248          break;
2249       case GL_LINE_STIPPLE_REPEAT:
2250          params[0] = (GLfloat)(ctx->Line.StippleFactor);
2251          break;
2252       case GL_LINE_WIDTH:
2253          params[0] = ctx->Line.Width;
2254          break;
2255       case GL_LINE_WIDTH_GRANULARITY:
2256          params[0] = ctx->Const.LineWidthGranularity;
2257          break;
2258       case GL_LINE_WIDTH_RANGE:
2259          params[0] = ctx->Const.MinLineWidthAA;
2260          params[1] = ctx->Const.MaxLineWidthAA;
2261          break;
2262       case GL_ALIASED_LINE_WIDTH_RANGE:
2263          params[0] = ctx->Const.MinLineWidth;
2264          params[1] = ctx->Const.MaxLineWidth;
2265          break;
2266       case GL_LIST_BASE:
2267          params[0] = (GLfloat)(ctx->List.ListBase);
2268          break;
2269       case GL_LIST_INDEX:
2270          params[0] = (GLfloat)(ctx->ListState.CurrentListNum);
2271          break;
2272       case GL_LIST_MODE:
2273          {
2274          GLenum mode;
2275          if (!ctx->CompileFlag)
2276             mode = 0;
2277          else if (ctx->ExecuteFlag)
2278             mode = GL_COMPILE_AND_EXECUTE;
2279          else
2280             mode = GL_COMPILE;
2281          params[0] = ENUM_TO_FLOAT(mode);
2282          }
2283          break;
2284       case GL_INDEX_LOGIC_OP:
2285          params[0] = BOOLEAN_TO_FLOAT(ctx->Color.IndexLogicOpEnabled);
2286          break;
2287       case GL_COLOR_LOGIC_OP:
2288          params[0] = BOOLEAN_TO_FLOAT(ctx->Color.ColorLogicOpEnabled);
2289          break;
2290       case GL_LOGIC_OP_MODE:
2291          params[0] = ENUM_TO_FLOAT(ctx->Color.LogicOp);
2292          break;
2293       case GL_MAP1_COLOR_4:
2294          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Color4);
2295          break;
2296       case GL_MAP1_GRID_DOMAIN:
2297          params[0] = ctx->Eval.MapGrid1u1;
2298          params[1] = ctx->Eval.MapGrid1u2;
2299          break;
2300       case GL_MAP1_GRID_SEGMENTS:
2301          params[0] = (GLfloat)(ctx->Eval.MapGrid1un);
2302          break;
2303       case GL_MAP1_INDEX:
2304          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Index);
2305          break;
2306       case GL_MAP1_NORMAL:
2307          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Normal);
2308          break;
2309       case GL_MAP1_TEXTURE_COORD_1:
2310          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord1);
2311          break;
2312       case GL_MAP1_TEXTURE_COORD_2:
2313          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord2);
2314          break;
2315       case GL_MAP1_TEXTURE_COORD_3:
2316          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord3);
2317          break;
2318       case GL_MAP1_TEXTURE_COORD_4:
2319          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord4);
2320          break;
2321       case GL_MAP1_VERTEX_3:
2322          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex3);
2323          break;
2324       case GL_MAP1_VERTEX_4:
2325          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex4);
2326          break;
2327       case GL_MAP2_COLOR_4:
2328          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Color4);
2329          break;
2330       case GL_MAP2_GRID_DOMAIN:
2331          params[0] = ctx->Eval.MapGrid2u1;
2332          params[1] = ctx->Eval.MapGrid2u2;
2333          params[2] = ctx->Eval.MapGrid2v1;
2334          params[3] = ctx->Eval.MapGrid2v2;
2335          break;
2336       case GL_MAP2_GRID_SEGMENTS:
2337          params[0] = (GLfloat)(ctx->Eval.MapGrid2un);
2338          params[1] = (GLfloat)(ctx->Eval.MapGrid2vn);
2339          break;
2340       case GL_MAP2_INDEX:
2341          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Index);
2342          break;
2343       case GL_MAP2_NORMAL:
2344          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Normal);
2345          break;
2346       case GL_MAP2_TEXTURE_COORD_1:
2347          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord1);
2348          break;
2349       case GL_MAP2_TEXTURE_COORD_2:
2350          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord2);
2351          break;
2352       case GL_MAP2_TEXTURE_COORD_3:
2353          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord3);
2354          break;
2355       case GL_MAP2_TEXTURE_COORD_4:
2356          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord4);
2357          break;
2358       case GL_MAP2_VERTEX_3:
2359          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex3);
2360          break;
2361       case GL_MAP2_VERTEX_4:
2362          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex4);
2363          break;
2364       case GL_MAP_COLOR:
2365          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapColorFlag);
2366          break;
2367       case GL_MAP_STENCIL:
2368          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapStencilFlag);
2369          break;
2370       case GL_MATRIX_MODE:
2371          params[0] = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
2372          break;
2373       case GL_MAX_ATTRIB_STACK_DEPTH:
2374          params[0] = (GLfloat)(MAX_ATTRIB_STACK_DEPTH);
2375          break;
2376       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
2377          params[0] = (GLfloat)(MAX_CLIENT_ATTRIB_STACK_DEPTH);
2378          break;
2379       case GL_MAX_CLIP_PLANES:
2380          params[0] = (GLfloat)(ctx->Const.MaxClipPlanes);
2381          break;
2382       case GL_MAX_ELEMENTS_VERTICES:
2383          params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
2384          break;
2385       case GL_MAX_ELEMENTS_INDICES:
2386          params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
2387          break;
2388       case GL_MAX_EVAL_ORDER:
2389          params[0] = (GLfloat)(MAX_EVAL_ORDER);
2390          break;
2391       case GL_MAX_LIGHTS:
2392          params[0] = (GLfloat)(ctx->Const.MaxLights);
2393          break;
2394       case GL_MAX_LIST_NESTING:
2395          params[0] = (GLfloat)(MAX_LIST_NESTING);
2396          break;
2397       case GL_MAX_MODELVIEW_STACK_DEPTH:
2398          params[0] = (GLfloat)(MAX_MODELVIEW_STACK_DEPTH);
2399          break;
2400       case GL_MAX_NAME_STACK_DEPTH:
2401          params[0] = (GLfloat)(MAX_NAME_STACK_DEPTH);
2402          break;
2403       case GL_MAX_PIXEL_MAP_TABLE:
2404          params[0] = (GLfloat)(MAX_PIXEL_MAP_TABLE);
2405          break;
2406       case GL_MAX_PROJECTION_STACK_DEPTH:
2407          params[0] = (GLfloat)(MAX_PROJECTION_STACK_DEPTH);
2408          break;
2409       case GL_MAX_TEXTURE_SIZE:
2410          params[0] = (GLfloat)(1 << (ctx->Const.MaxTextureLevels - 1));
2411          break;
2412       case GL_MAX_3D_TEXTURE_SIZE:
2413          params[0] = (GLfloat)(1 << (ctx->Const.Max3DTextureLevels - 1));
2414          break;
2415       case GL_MAX_TEXTURE_STACK_DEPTH:
2416          params[0] = (GLfloat)(MAX_TEXTURE_STACK_DEPTH);
2417          break;
2418       case GL_MAX_VIEWPORT_DIMS:
2419          params[0] = (GLfloat)(ctx->Const.MaxViewportWidth);
2420          params[1] = (GLfloat)(ctx->Const.MaxViewportHeight);
2421          break;
2422       case GL_MODELVIEW_MATRIX:
2423          {
2424          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
2425          params[0] = matrix[0];
2426          params[1] = matrix[1];
2427          params[2] = matrix[2];
2428          params[3] = matrix[3];
2429          params[4] = matrix[4];
2430          params[5] = matrix[5];
2431          params[6] = matrix[6];
2432          params[7] = matrix[7];
2433          params[8] = matrix[8];
2434          params[9] = matrix[9];
2435          params[10] = matrix[10];
2436          params[11] = matrix[11];
2437          params[12] = matrix[12];
2438          params[13] = matrix[13];
2439          params[14] = matrix[14];
2440          params[15] = matrix[15];
2441          }
2442          break;
2443       case GL_MODELVIEW_STACK_DEPTH:
2444          params[0] = (GLfloat)(ctx->ModelviewMatrixStack.Depth + 1);
2445          break;
2446       case GL_NAME_STACK_DEPTH:
2447          params[0] = (GLfloat)(ctx->Select.NameStackDepth);
2448          break;
2449       case GL_NORMALIZE:
2450          params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.Normalize);
2451          break;
2452       case GL_PACK_ALIGNMENT:
2453          params[0] = (GLfloat)(ctx->Pack.Alignment);
2454          break;
2455       case GL_PACK_LSB_FIRST:
2456          params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.LsbFirst);
2457          break;
2458       case GL_PACK_ROW_LENGTH:
2459          params[0] = (GLfloat)(ctx->Pack.RowLength);
2460          break;
2461       case GL_PACK_SKIP_PIXELS:
2462          params[0] = (GLfloat)(ctx->Pack.SkipPixels);
2463          break;
2464       case GL_PACK_SKIP_ROWS:
2465          params[0] = (GLfloat)(ctx->Pack.SkipRows);
2466          break;
2467       case GL_PACK_SWAP_BYTES:
2468          params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.SwapBytes);
2469          break;
2470       case GL_PACK_SKIP_IMAGES_EXT:
2471          params[0] = (GLfloat)(ctx->Pack.SkipImages);
2472          break;
2473       case GL_PACK_IMAGE_HEIGHT_EXT:
2474          params[0] = (GLfloat)(ctx->Pack.ImageHeight);
2475          break;
2476       case GL_PACK_INVERT_MESA:
2477          params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.Invert);
2478          break;
2479       case GL_PERSPECTIVE_CORRECTION_HINT:
2480          params[0] = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
2481          break;
2482       case GL_PIXEL_MAP_A_TO_A_SIZE:
2483          params[0] = (GLfloat)(ctx->Pixel.MapAtoAsize);
2484          break;
2485       case GL_PIXEL_MAP_B_TO_B_SIZE:
2486          params[0] = (GLfloat)(ctx->Pixel.MapBtoBsize);
2487          break;
2488       case GL_PIXEL_MAP_G_TO_G_SIZE:
2489          params[0] = (GLfloat)(ctx->Pixel.MapGtoGsize);
2490          break;
2491       case GL_PIXEL_MAP_I_TO_A_SIZE:
2492          params[0] = (GLfloat)(ctx->Pixel.MapItoAsize);
2493          break;
2494       case GL_PIXEL_MAP_I_TO_B_SIZE:
2495          params[0] = (GLfloat)(ctx->Pixel.MapItoBsize);
2496          break;
2497       case GL_PIXEL_MAP_I_TO_G_SIZE:
2498          params[0] = (GLfloat)(ctx->Pixel.MapItoGsize);
2499          break;
2500       case GL_PIXEL_MAP_I_TO_I_SIZE:
2501          params[0] = (GLfloat)(ctx->Pixel.MapItoIsize);
2502          break;
2503       case GL_PIXEL_MAP_I_TO_R_SIZE:
2504          params[0] = (GLfloat)(ctx->Pixel.MapItoRsize);
2505          break;
2506       case GL_PIXEL_MAP_R_TO_R_SIZE:
2507          params[0] = (GLfloat)(ctx->Pixel.MapRtoRsize);
2508          break;
2509       case GL_PIXEL_MAP_S_TO_S_SIZE:
2510          params[0] = (GLfloat)(ctx->Pixel.MapStoSsize);
2511          break;
2512       case GL_POINT_SIZE:
2513          params[0] = ctx->Point.Size;
2514          break;
2515       case GL_POINT_SIZE_GRANULARITY:
2516          params[0] = ctx->Const.PointSizeGranularity;
2517          break;
2518       case GL_POINT_SIZE_RANGE:
2519          params[0] = ctx->Const.MinPointSizeAA;
2520          params[1] = ctx->Const.MaxPointSizeAA;
2521          break;
2522       case GL_ALIASED_POINT_SIZE_RANGE:
2523          params[0] = ctx->Const.MinPointSize;
2524          params[1] = ctx->Const.MaxPointSize;
2525          break;
2526       case GL_POINT_SMOOTH:
2527          params[0] = BOOLEAN_TO_FLOAT(ctx->Point.SmoothFlag);
2528          break;
2529       case GL_POINT_SMOOTH_HINT:
2530          params[0] = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
2531          break;
2532       case GL_POINT_SIZE_MIN_EXT:
2533          params[0] = ctx->Point.MinSize;
2534          break;
2535       case GL_POINT_SIZE_MAX_EXT:
2536          params[0] = ctx->Point.MaxSize;
2537          break;
2538       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
2539          params[0] = ctx->Point.Threshold;
2540          break;
2541       case GL_DISTANCE_ATTENUATION_EXT:
2542          params[0] = ctx->Point.Params[0];
2543          params[1] = ctx->Point.Params[1];
2544          params[2] = ctx->Point.Params[2];
2545          break;
2546       case GL_POLYGON_MODE:
2547          params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
2548          params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
2549          break;
2550       case GL_POLYGON_OFFSET_BIAS_EXT:
2551          params[0] = ctx->Polygon.OffsetUnits;
2552          break;
2553       case GL_POLYGON_OFFSET_FACTOR:
2554          params[0] = ctx->Polygon.OffsetFactor ;
2555          break;
2556       case GL_POLYGON_OFFSET_UNITS:
2557          params[0] = ctx->Polygon.OffsetUnits ;
2558          break;
2559       case GL_POLYGON_SMOOTH:
2560          params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.SmoothFlag);
2561          break;
2562       case GL_POLYGON_SMOOTH_HINT:
2563          params[0] = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
2564          break;
2565       case GL_POLYGON_STIPPLE:
2566          params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.StippleFlag);
2567          break;
2568       case GL_PROJECTION_MATRIX:
2569          {
2570          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
2571          params[0] = matrix[0];
2572          params[1] = matrix[1];
2573          params[2] = matrix[2];
2574          params[3] = matrix[3];
2575          params[4] = matrix[4];
2576          params[5] = matrix[5];
2577          params[6] = matrix[6];
2578          params[7] = matrix[7];
2579          params[8] = matrix[8];
2580          params[9] = matrix[9];
2581          params[10] = matrix[10];
2582          params[11] = matrix[11];
2583          params[12] = matrix[12];
2584          params[13] = matrix[13];
2585          params[14] = matrix[14];
2586          params[15] = matrix[15];
2587          }
2588          break;
2589       case GL_PROJECTION_STACK_DEPTH:
2590          params[0] = (GLfloat)(ctx->ProjectionMatrixStack.Depth + 1);
2591          break;
2592       case GL_READ_BUFFER:
2593          params[0] = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
2594          break;
2595       case GL_RED_BIAS:
2596          params[0] = ctx->Pixel.RedBias;
2597          break;
2598       case GL_RED_BITS:
2599          params[0] = (GLfloat)( ctx->Visual.redBits );
2600          break;
2601       case GL_RED_SCALE:
2602          params[0] = ctx->Pixel.RedScale;
2603          break;
2604       case GL_RENDER_MODE:
2605          params[0] = ENUM_TO_FLOAT(ctx->RenderMode);
2606          break;
2607       case GL_RESCALE_NORMAL:
2608          params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RescaleNormals);
2609          break;
2610       case GL_RGBA_MODE:
2611          params[0] = BOOLEAN_TO_FLOAT(ctx->Visual.rgbMode);
2612          break;
2613       case GL_SCISSOR_BOX:
2614          params[0] = (GLfloat)(ctx->Scissor.X);
2615          params[1] = (GLfloat)(ctx->Scissor.Y);
2616          params[2] = (GLfloat)(ctx->Scissor.Width);
2617          params[3] = (GLfloat)(ctx->Scissor.Height);
2618          break;
2619       case GL_SCISSOR_TEST:
2620          params[0] = BOOLEAN_TO_FLOAT(ctx->Scissor.Enabled);
2621          break;
2622       case GL_SELECTION_BUFFER_SIZE:
2623          params[0] = (GLfloat)(ctx->Select.BufferSize);
2624          break;
2625       case GL_SHADE_MODEL:
2626          params[0] = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
2627          break;
2628       case GL_SHARED_TEXTURE_PALETTE_EXT:
2629          params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.SharedPalette);
2630          break;
2631       case GL_STENCIL_BITS:
2632          params[0] = (GLfloat)(ctx->Visual.stencilBits);
2633          break;
2634       case GL_STENCIL_CLEAR_VALUE:
2635          params[0] = (GLfloat)(ctx->Stencil.Clear);
2636          break;
2637       case GL_STENCIL_FAIL:
2638          params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
2639          break;
2640       case GL_STENCIL_FUNC:
2641          params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
2642          break;
2643       case GL_STENCIL_PASS_DEPTH_FAIL:
2644          params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
2645          break;
2646       case GL_STENCIL_PASS_DEPTH_PASS:
2647          params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
2648          break;
2649       case GL_STENCIL_REF:
2650          params[0] = (GLfloat)(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
2651          break;
2652       case GL_STENCIL_TEST:
2653          params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.Enabled);
2654          break;
2655       case GL_STENCIL_VALUE_MASK:
2656          params[0] = (GLfloat)(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
2657          break;
2658       case GL_STENCIL_WRITEMASK:
2659          params[0] = (GLfloat)(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
2660          break;
2661       case GL_STEREO:
2662          params[0] = BOOLEAN_TO_FLOAT(ctx->Visual.stereoMode);
2663          break;
2664       case GL_SUBPIXEL_BITS:
2665          params[0] = (GLfloat)(ctx->Const.SubPixelBits);
2666          break;
2667       case GL_TEXTURE_1D:
2668          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_1D));
2669          break;
2670       case GL_TEXTURE_2D:
2671          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_2D));
2672          break;
2673       case GL_TEXTURE_3D:
2674          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_3D));
2675          break;
2676       case GL_TEXTURE_BINDING_1D:
2677          params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
2678          break;
2679       case GL_TEXTURE_BINDING_2D:
2680          params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
2681          break;
2682       case GL_TEXTURE_BINDING_3D:
2683          params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
2684          break;
2685       case GL_TEXTURE_ENV_COLOR:
2686          {
2687          const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
2688          params[0] = color[0];
2689          params[1] = color[1];
2690          params[2] = color[2];
2691          params[3] = color[3];
2692          }
2693          break;
2694       case GL_TEXTURE_ENV_MODE:
2695          params[0] = ENUM_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
2696          break;
2697       case GL_TEXTURE_GEN_S:
2698          params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
2699          break;
2700       case GL_TEXTURE_GEN_T:
2701          params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
2702          break;
2703       case GL_TEXTURE_GEN_R:
2704          params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
2705          break;
2706       case GL_TEXTURE_GEN_Q:
2707          params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
2708          break;
2709       case GL_TEXTURE_MATRIX:
2710          {
2711          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
2712          params[0] = matrix[0];
2713          params[1] = matrix[1];
2714          params[2] = matrix[2];
2715          params[3] = matrix[3];
2716          params[4] = matrix[4];
2717          params[5] = matrix[5];
2718          params[6] = matrix[6];
2719          params[7] = matrix[7];
2720          params[8] = matrix[8];
2721          params[9] = matrix[9];
2722          params[10] = matrix[10];
2723          params[11] = matrix[11];
2724          params[12] = matrix[12];
2725          params[13] = matrix[13];
2726          params[14] = matrix[14];
2727          params[15] = matrix[15];
2728          }
2729          break;
2730       case GL_TEXTURE_STACK_DEPTH:
2731          params[0] = (GLfloat)(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
2732          break;
2733       case GL_UNPACK_ALIGNMENT:
2734          params[0] = (GLfloat)(ctx->Unpack.Alignment);
2735          break;
2736       case GL_UNPACK_LSB_FIRST:
2737          params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.LsbFirst);
2738          break;
2739       case GL_UNPACK_ROW_LENGTH:
2740          params[0] = (GLfloat)(ctx->Unpack.RowLength);
2741          break;
2742       case GL_UNPACK_SKIP_PIXELS:
2743          params[0] = (GLfloat)(ctx->Unpack.SkipPixels);
2744          break;
2745       case GL_UNPACK_SKIP_ROWS:
2746          params[0] = (GLfloat)(ctx->Unpack.SkipRows);
2747          break;
2748       case GL_UNPACK_SWAP_BYTES:
2749          params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.SwapBytes);
2750          break;
2751       case GL_UNPACK_SKIP_IMAGES_EXT:
2752          params[0] = (GLfloat)(ctx->Unpack.SkipImages);
2753          break;
2754       case GL_UNPACK_IMAGE_HEIGHT_EXT:
2755          params[0] = (GLfloat)(ctx->Unpack.ImageHeight);
2756          break;
2757       case GL_UNPACK_CLIENT_STORAGE_APPLE:
2758          params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.ClientStorage);
2759          break;
2760       case GL_VIEWPORT:
2761          params[0] = (GLfloat)(ctx->Viewport.X);
2762          params[1] = (GLfloat)(ctx->Viewport.Y);
2763          params[2] = (GLfloat)(ctx->Viewport.Width);
2764          params[3] = (GLfloat)(ctx->Viewport.Height);
2765          break;
2766       case GL_ZOOM_X:
2767          params[0] = ctx->Pixel.ZoomX;
2768          break;
2769       case GL_ZOOM_Y:
2770          params[0] = ctx->Pixel.ZoomY;
2771          break;
2772       case GL_VERTEX_ARRAY:
2773          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.Vertex.Enabled);
2774          break;
2775       case GL_VERTEX_ARRAY_SIZE:
2776          params[0] = (GLfloat)(ctx->Array.Vertex.Size);
2777          break;
2778       case GL_VERTEX_ARRAY_TYPE:
2779          params[0] = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
2780          break;
2781       case GL_VERTEX_ARRAY_STRIDE:
2782          params[0] = (GLfloat)(ctx->Array.Vertex.Stride);
2783          break;
2784       case GL_VERTEX_ARRAY_COUNT_EXT:
2785          params[0] = (GLfloat)(0);
2786          break;
2787       case GL_NORMAL_ARRAY:
2788          params[0] = ENUM_TO_FLOAT(ctx->Array.Normal.Enabled);
2789          break;
2790       case GL_NORMAL_ARRAY_TYPE:
2791          params[0] = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
2792          break;
2793       case GL_NORMAL_ARRAY_STRIDE:
2794          params[0] = (GLfloat)(ctx->Array.Normal.Stride);
2795          break;
2796       case GL_NORMAL_ARRAY_COUNT_EXT:
2797          params[0] = (GLfloat)(0);
2798          break;
2799       case GL_COLOR_ARRAY:
2800          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.Color.Enabled);
2801          break;
2802       case GL_COLOR_ARRAY_SIZE:
2803          params[0] = (GLfloat)(ctx->Array.Color.Size);
2804          break;
2805       case GL_COLOR_ARRAY_TYPE:
2806          params[0] = ENUM_TO_FLOAT(ctx->Array.Color.Type);
2807          break;
2808       case GL_COLOR_ARRAY_STRIDE:
2809          params[0] = (GLfloat)(ctx->Array.Color.Stride);
2810          break;
2811       case GL_COLOR_ARRAY_COUNT_EXT:
2812          params[0] = (GLfloat)(0);
2813          break;
2814       case GL_INDEX_ARRAY:
2815          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.Index.Enabled);
2816          break;
2817       case GL_INDEX_ARRAY_TYPE:
2818          params[0] = ENUM_TO_FLOAT(ctx->Array.Index.Type);
2819          break;
2820       case GL_INDEX_ARRAY_STRIDE:
2821          params[0] = (GLfloat)(ctx->Array.Index.Stride);
2822          break;
2823       case GL_INDEX_ARRAY_COUNT_EXT:
2824          params[0] = (GLfloat)(0);
2825          break;
2826       case GL_TEXTURE_COORD_ARRAY:
2827          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled);
2828          break;
2829       case GL_TEXTURE_COORD_ARRAY_SIZE:
2830          params[0] = (GLfloat)(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Size);
2831          break;
2832       case GL_TEXTURE_COORD_ARRAY_TYPE:
2833          params[0] = ENUM_TO_FLOAT(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Type);
2834          break;
2835       case GL_TEXTURE_COORD_ARRAY_STRIDE:
2836          params[0] = (GLfloat)(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Stride);
2837          break;
2838       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
2839          params[0] = (GLfloat)(0);
2840          break;
2841       case GL_EDGE_FLAG_ARRAY:
2842          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.EdgeFlag.Enabled);
2843          break;
2844       case GL_EDGE_FLAG_ARRAY_STRIDE:
2845          params[0] = (GLfloat)(ctx->Array.EdgeFlag.Stride);
2846          break;
2847       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
2848          params[0] = (GLfloat)(0);
2849          break;
2850       case GL_MAX_TEXTURE_UNITS_ARB:
2851          CHECK_EXTENSION_F(ARB_multitexture, pname);
2852          params[0] = (GLfloat)(MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits));
2853          break;
2854       case GL_ACTIVE_TEXTURE_ARB:
2855          CHECK_EXTENSION_F(ARB_multitexture, pname);
2856          params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
2857          break;
2858       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
2859          CHECK_EXTENSION_F(ARB_multitexture, pname);
2860          params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
2861          break;
2862       case GL_TEXTURE_CUBE_MAP_ARB:
2863          CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
2864          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
2865          break;
2866       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
2867          CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
2868          params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
2869          break;
2870       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
2871          CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
2872          params[0] = (GLfloat)((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
2873          break;
2874       case GL_TEXTURE_COMPRESSION_HINT_ARB:
2875          CHECK_EXTENSION_F(ARB_texture_compression, pname);
2876          params[0] = (GLfloat)(ctx->Hint.TextureCompression);
2877          break;
2878       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
2879          CHECK_EXTENSION_F(ARB_texture_compression, pname);
2880          params[0] = (GLfloat)(_mesa_get_compressed_formats(ctx, NULL));
2881          break;
2882       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
2883          CHECK_EXTENSION_F(ARB_texture_compression, pname);
2884          {
2885          GLint formats[100];
2886          GLuint i, n = _mesa_get_compressed_formats(ctx, formats);
2887          for (i = 0; i < n; i++)
2888             params[i] = ENUM_TO_BOOLEAN(formats[i]);
2889          }
2890          break;
2891       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
2892          CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname);
2893          params[0] = (GLfloat)(ctx->Array.LockFirst);
2894          break;
2895       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
2896          CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname);
2897          params[0] = (GLfloat)(ctx->Array.LockCount);
2898          break;
2899       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
2900          {
2901          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
2902          params[0] = matrix[0];
2903          params[1] = matrix[4];
2904          params[2] = matrix[8];
2905          params[3] = matrix[12];
2906          params[4] = matrix[1];
2907          params[5] = matrix[5];
2908          params[6] = matrix[9];
2909          params[7] = matrix[13];
2910          params[8] = matrix[2];
2911          params[9] = matrix[6];
2912          params[10] = matrix[10];
2913          params[11] = matrix[14];
2914          params[12] = matrix[3];
2915          params[13] = matrix[7];
2916          params[14] = matrix[11];
2917          params[15] = matrix[15];
2918          }
2919          break;
2920       case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
2921          {
2922          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
2923          params[0] = matrix[0];
2924          params[1] = matrix[4];
2925          params[2] = matrix[8];
2926          params[3] = matrix[12];
2927          params[4] = matrix[1];
2928          params[5] = matrix[5];
2929          params[6] = matrix[9];
2930          params[7] = matrix[13];
2931          params[8] = matrix[2];
2932          params[9] = matrix[6];
2933          params[10] = matrix[10];
2934          params[11] = matrix[14];
2935          params[12] = matrix[3];
2936          params[13] = matrix[7];
2937          params[14] = matrix[11];
2938          params[15] = matrix[15];
2939          }
2940          break;
2941       case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
2942          {
2943          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
2944          params[0] = matrix[0];
2945          params[1] = matrix[4];
2946          params[2] = matrix[8];
2947          params[3] = matrix[12];
2948          params[4] = matrix[1];
2949          params[5] = matrix[5];
2950          params[6] = matrix[9];
2951          params[7] = matrix[13];
2952          params[8] = matrix[2];
2953          params[9] = matrix[6];
2954          params[10] = matrix[10];
2955          params[11] = matrix[14];
2956          params[12] = matrix[3];
2957          params[13] = matrix[7];
2958          params[14] = matrix[11];
2959          params[15] = matrix[15];
2960          }
2961          break;
2962       case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
2963          {
2964          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
2965          params[0] = matrix[0];
2966          params[1] = matrix[4];
2967          params[2] = matrix[8];
2968          params[3] = matrix[12];
2969          params[4] = matrix[1];
2970          params[5] = matrix[5];
2971          params[6] = matrix[9];
2972          params[7] = matrix[13];
2973          params[8] = matrix[2];
2974          params[9] = matrix[6];
2975          params[10] = matrix[10];
2976          params[11] = matrix[14];
2977          params[12] = matrix[3];
2978          params[13] = matrix[7];
2979          params[14] = matrix[11];
2980          params[15] = matrix[15];
2981          }
2982          break;
2983       case GL_OCCLUSION_TEST_HP:
2984          CHECK_EXTENSION_F(HP_occlusion_test, pname);
2985          params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.OcclusionTest);
2986          break;
2987       case GL_OCCLUSION_TEST_RESULT_HP:
2988          CHECK_EXTENSION_F(HP_occlusion_test, pname);
2989          {
2990          if (ctx->Depth.OcclusionTest)
2991             params[0] = ctx->OcclusionResult;
2992          else
2993             params[0] = ctx->OcclusionResultSaved;
2994          /* reset flag now */
2995          ctx->OcclusionResult = GL_FALSE;
2996          ctx->OcclusionResultSaved = GL_FALSE;
2997          return;
2998          }
2999          break;
3000       case GL_PIXEL_TEXTURE_SGIS:
3001          CHECK_EXTENSION_F(SGIS_pixel_texture, pname);
3002          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PixelTextureEnabled);
3003          break;
3004       case GL_PIXEL_TEX_GEN_SGIX:
3005          CHECK_EXTENSION_F(SGIX_pixel_texture, pname);
3006          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PixelTextureEnabled);
3007          break;
3008       case GL_PIXEL_TEX_GEN_MODE_SGIX:
3009          CHECK_EXTENSION_F(SGIX_pixel_texture, pname);
3010          params[0] = ENUM_TO_FLOAT(pixel_texgen_mode(ctx));
3011          break;
3012       case GL_COLOR_MATRIX_SGI:
3013          {
3014          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
3015          params[0] = matrix[0];
3016          params[1] = matrix[1];
3017          params[2] = matrix[2];
3018          params[3] = matrix[3];
3019          params[4] = matrix[4];
3020          params[5] = matrix[5];
3021          params[6] = matrix[6];
3022          params[7] = matrix[7];
3023          params[8] = matrix[8];
3024          params[9] = matrix[9];
3025          params[10] = matrix[10];
3026          params[11] = matrix[11];
3027          params[12] = matrix[12];
3028          params[13] = matrix[13];
3029          params[14] = matrix[14];
3030          params[15] = matrix[15];
3031          }
3032          break;
3033       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
3034          params[0] = (GLfloat)(ctx->ColorMatrixStack.Depth + 1);
3035          break;
3036       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
3037          params[0] = (GLfloat)(MAX_COLOR_STACK_DEPTH);
3038          break;
3039       case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
3040          params[0] = ctx->Pixel.PostColorMatrixScale[0];
3041          break;
3042       case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
3043          params[0] = ctx->Pixel.PostColorMatrixScale[1];
3044          break;
3045       case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
3046          params[0] = ctx->Pixel.PostColorMatrixScale[2];
3047          break;
3048       case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
3049          params[0] = ctx->Pixel.PostColorMatrixScale[3];
3050          break;
3051       case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
3052          params[0] = ctx->Pixel.PostColorMatrixBias[0];
3053          break;
3054       case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
3055          params[0] = ctx->Pixel.PostColorMatrixBias[1];
3056          break;
3057       case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
3058          params[0] = ctx->Pixel.PostColorMatrixBias[2];
3059          break;
3060       case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
3061          params[0] = ctx->Pixel.PostColorMatrixBias[3];
3062          break;
3063       case GL_CONVOLUTION_1D_EXT:
3064          CHECK_EXTENSION_F(EXT_convolution, pname);
3065          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution1DEnabled);
3066          break;
3067       case GL_CONVOLUTION_2D_EXT:
3068          CHECK_EXTENSION_F(EXT_convolution, pname);
3069          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution2DEnabled);
3070          break;
3071       case GL_SEPARABLE_2D_EXT:
3072          CHECK_EXTENSION_F(EXT_convolution, pname);
3073          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Separable2DEnabled);
3074          break;
3075       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
3076          CHECK_EXTENSION_F(EXT_convolution, pname);
3077          params[0] = ctx->Pixel.PostConvolutionScale[0];
3078          break;
3079       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
3080          CHECK_EXTENSION_F(EXT_convolution, pname);
3081          params[0] = ctx->Pixel.PostConvolutionScale[1];
3082          break;
3083       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
3084          CHECK_EXTENSION_F(EXT_convolution, pname);
3085          params[0] = ctx->Pixel.PostConvolutionScale[2];
3086          break;
3087       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
3088          CHECK_EXTENSION_F(EXT_convolution, pname);
3089          params[0] = ctx->Pixel.PostConvolutionScale[3];
3090          break;
3091       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
3092          CHECK_EXTENSION_F(EXT_convolution, pname);
3093          params[0] = ctx->Pixel.PostConvolutionBias[0];
3094          break;
3095       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
3096          CHECK_EXTENSION_F(EXT_convolution, pname);
3097          params[0] = ctx->Pixel.PostConvolutionBias[1];
3098          break;
3099       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
3100          CHECK_EXTENSION_F(EXT_convolution, pname);
3101          params[0] = ctx->Pixel.PostConvolutionBias[2];
3102          break;
3103       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
3104          CHECK_EXTENSION_F(EXT_convolution, pname);
3105          params[0] = ctx->Pixel.PostConvolutionBias[3];
3106          break;
3107       case GL_HISTOGRAM:
3108          CHECK_EXTENSION_F(EXT_histogram, pname);
3109          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.HistogramEnabled);
3110          break;
3111       case GL_MINMAX:
3112          CHECK_EXTENSION_F(EXT_histogram, pname);
3113          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MinMaxEnabled);
3114          break;
3115       case GL_COLOR_TABLE_SGI:
3116          CHECK_EXTENSION_F(SGI_color_table, pname);
3117          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.ColorTableEnabled);
3118          break;
3119       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
3120          CHECK_EXTENSION_F(SGI_color_table, pname);
3121          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostConvolutionColorTableEnabled);
3122          break;
3123       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
3124          CHECK_EXTENSION_F(SGI_color_table, pname);
3125          params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostColorMatrixColorTableEnabled);
3126          break;
3127       case GL_TEXTURE_COLOR_TABLE_SGI:
3128          CHECK_EXTENSION_F(SGI_texture_color_table, pname);
3129          params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
3130          break;
3131       case GL_COLOR_SUM_EXT:
3132          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3133          params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.ColorSumEnabled);
3134          break;
3135       case GL_CURRENT_SECONDARY_COLOR_EXT:
3136          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3137          {
3138          FLUSH_CURRENT(ctx, 0);
3139          params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
3140          params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
3141          params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
3142          params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3];
3143          }
3144          break;
3145       case GL_SECONDARY_COLOR_ARRAY_EXT:
3146          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3147          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.SecondaryColor.Enabled);
3148          break;
3149       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
3150          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3151          params[0] = ENUM_TO_FLOAT(ctx->Array.SecondaryColor.Type);
3152          break;
3153       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
3154          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3155          params[0] = (GLfloat)(ctx->Array.SecondaryColor.Stride);
3156          break;
3157       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
3158          CHECK_EXTENSION_F(EXT_secondary_color, pname);
3159          params[0] = (GLfloat)(ctx->Array.SecondaryColor.Size);
3160          break;
3161       case GL_CURRENT_FOG_COORDINATE_EXT:
3162          CHECK_EXTENSION_F(EXT_fog_coord, pname);
3163          {
3164          FLUSH_CURRENT(ctx, 0);
3165          params[0] = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
3166          }
3167          break;
3168       case GL_FOG_COORDINATE_ARRAY_EXT:
3169          CHECK_EXTENSION_F(EXT_fog_coord, pname);
3170          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.FogCoord.Enabled);
3171          break;
3172       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
3173          CHECK_EXTENSION_F(EXT_fog_coord, pname);
3174          params[0] = ENUM_TO_FLOAT(ctx->Array.FogCoord.Type);
3175          break;
3176       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
3177          CHECK_EXTENSION_F(EXT_fog_coord, pname);
3178          params[0] = (GLfloat)(ctx->Array.FogCoord.Stride);
3179          break;
3180       case GL_FOG_COORDINATE_SOURCE_EXT:
3181          CHECK_EXTENSION_F(EXT_fog_coord, pname);
3182          params[0] = ENUM_TO_FLOAT(ctx->Fog.FogCoordinateSource);
3183          break;
3184       case GL_MAX_TEXTURE_LOD_BIAS_EXT:
3185          CHECK_EXTENSION_F(EXT_texture_lod_bias, pname);
3186          params[0] = ctx->Const.MaxTextureLodBias;
3187          break;
3188       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
3189          CHECK_EXTENSION_F(EXT_texture_filter_anisotropic, pname);
3190          params[0] = ctx->Const.MaxTextureMaxAnisotropy;
3191          break;
3192       case GL_MULTISAMPLE_ARB:
3193          CHECK_EXTENSION_F(ARB_multisample, pname);
3194          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.Enabled);
3195          break;
3196       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
3197          CHECK_EXTENSION_F(ARB_multisample, pname);
3198          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToCoverage);
3199          break;
3200       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
3201          CHECK_EXTENSION_F(ARB_multisample, pname);
3202          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToOne);
3203          break;
3204       case GL_SAMPLE_COVERAGE_ARB:
3205          CHECK_EXTENSION_F(ARB_multisample, pname);
3206          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverage);
3207          break;
3208       case GL_SAMPLE_COVERAGE_VALUE_ARB:
3209          CHECK_EXTENSION_F(ARB_multisample, pname);
3210          params[0] = ctx->Multisample.SampleCoverageValue;
3211          break;
3212       case GL_SAMPLE_COVERAGE_INVERT_ARB:
3213          CHECK_EXTENSION_F(ARB_multisample, pname);
3214          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverageInvert);
3215          break;
3216       case GL_SAMPLE_BUFFERS_ARB:
3217          CHECK_EXTENSION_F(ARB_multisample, pname);
3218          params[0] = (GLfloat)(0);
3219          break;
3220       case GL_SAMPLES_ARB:
3221          CHECK_EXTENSION_F(ARB_multisample, pname);
3222          params[0] = (GLfloat)(0);
3223          break;
3224       case GL_RASTER_POSITION_UNCLIPPED_IBM:
3225          CHECK_EXTENSION_F(IBM_rasterpos_clip, pname);
3226          params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RasterPositionUnclipped);
3227          break;
3228       case GL_POINT_SPRITE_NV:
3229          CHECK_EXTENSION_F(NV_point_sprite, pname);
3230          params[0] = BOOLEAN_TO_FLOAT(ctx->Point.PointSprite);
3231          break;
3232       case GL_POINT_SPRITE_R_MODE_NV:
3233          CHECK_EXTENSION_F(NV_point_sprite, pname);
3234          params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteRMode);
3235          break;
3236       case GL_POINT_SPRITE_COORD_ORIGIN:
3237          CHECK_EXTENSION_F(NV_point_sprite, pname);
3238          params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteOrigin);
3239          break;
3240       case GL_GENERATE_MIPMAP_HINT_SGIS:
3241          CHECK_EXTENSION_F(SGIS_generate_mipmap, pname);
3242          params[0] = ENUM_TO_FLOAT(ctx->Hint.GenerateMipmap);
3243          break;
3244       case GL_VERTEX_PROGRAM_NV:
3245          CHECK_EXTENSION_F(NV_vertex_program, pname);
3246          params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.Enabled);
3247          break;
3248       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
3249          CHECK_EXTENSION_F(NV_vertex_program, pname);
3250          params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.PointSizeEnabled);
3251          break;
3252       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
3253          CHECK_EXTENSION_F(NV_vertex_program, pname);
3254          params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.TwoSideEnabled);
3255          break;
3256       case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
3257          CHECK_EXTENSION_F(NV_vertex_program, pname);
3258          params[0] = (GLfloat)(ctx->Const.MaxProgramMatrixStackDepth);
3259          break;
3260       case GL_MAX_TRACK_MATRICES_NV:
3261          CHECK_EXTENSION_F(NV_vertex_program, pname);
3262          params[0] = (GLfloat)(ctx->Const.MaxProgramMatrices);
3263          break;
3264       case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
3265          CHECK_EXTENSION_F(NV_vertex_program, pname);
3266          params[0] = BOOLEAN_TO_FLOAT(ctx->CurrentStack->Depth + 1);
3267          break;
3268       case GL_CURRENT_MATRIX_NV:
3269          CHECK_EXTENSION_F(NV_vertex_program, pname);
3270          {
3271          const GLfloat *matrix = ctx->CurrentStack->Top->m;
3272          params[0] = matrix[0];
3273          params[1] = matrix[1];
3274          params[2] = matrix[2];
3275          params[3] = matrix[3];
3276          params[4] = matrix[4];
3277          params[5] = matrix[5];
3278          params[6] = matrix[6];
3279          params[7] = matrix[7];
3280          params[8] = matrix[8];
3281          params[9] = matrix[9];
3282          params[10] = matrix[10];
3283          params[11] = matrix[11];
3284          params[12] = matrix[12];
3285          params[13] = matrix[13];
3286          params[14] = matrix[14];
3287          params[15] = matrix[15];
3288          }
3289          break;
3290       case GL_VERTEX_PROGRAM_BINDING_NV:
3291          CHECK_EXTENSION_F(NV_vertex_program, pname);
3292          params[0] = (GLfloat)((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
3293          break;
3294       case GL_PROGRAM_ERROR_POSITION_NV:
3295          CHECK_EXTENSION_F(NV_vertex_program, pname);
3296          params[0] = (GLfloat)(ctx->Program.ErrorPos);
3297          break;
3298       case GL_VERTEX_ATTRIB_ARRAY0_NV:
3299          CHECK_EXTENSION_F(NV_vertex_program, pname);
3300          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[0].Enabled);
3301          break;
3302       case GL_VERTEX_ATTRIB_ARRAY1_NV:
3303          CHECK_EXTENSION_F(NV_vertex_program, pname);
3304          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[1].Enabled);
3305          break;
3306       case GL_VERTEX_ATTRIB_ARRAY2_NV:
3307          CHECK_EXTENSION_F(NV_vertex_program, pname);
3308          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[2].Enabled);
3309          break;
3310       case GL_VERTEX_ATTRIB_ARRAY3_NV:
3311          CHECK_EXTENSION_F(NV_vertex_program, pname);
3312          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[3].Enabled);
3313          break;
3314       case GL_VERTEX_ATTRIB_ARRAY4_NV:
3315          CHECK_EXTENSION_F(NV_vertex_program, pname);
3316          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[4].Enabled);
3317          break;
3318       case GL_VERTEX_ATTRIB_ARRAY5_NV:
3319          CHECK_EXTENSION_F(NV_vertex_program, pname);
3320          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[5].Enabled);
3321          break;
3322       case GL_VERTEX_ATTRIB_ARRAY6_NV:
3323          CHECK_EXTENSION_F(NV_vertex_program, pname);
3324          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[6].Enabled);
3325          break;
3326       case GL_VERTEX_ATTRIB_ARRAY7_NV:
3327          CHECK_EXTENSION_F(NV_vertex_program, pname);
3328          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[7].Enabled);
3329          break;
3330       case GL_VERTEX_ATTRIB_ARRAY8_NV:
3331          CHECK_EXTENSION_F(NV_vertex_program, pname);
3332          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[8].Enabled);
3333          break;
3334       case GL_VERTEX_ATTRIB_ARRAY9_NV:
3335          CHECK_EXTENSION_F(NV_vertex_program, pname);
3336          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[9].Enabled);
3337          break;
3338       case GL_VERTEX_ATTRIB_ARRAY10_NV:
3339          CHECK_EXTENSION_F(NV_vertex_program, pname);
3340          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[10].Enabled);
3341          break;
3342       case GL_VERTEX_ATTRIB_ARRAY11_NV:
3343          CHECK_EXTENSION_F(NV_vertex_program, pname);
3344          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[11].Enabled);
3345          break;
3346       case GL_VERTEX_ATTRIB_ARRAY12_NV:
3347          CHECK_EXTENSION_F(NV_vertex_program, pname);
3348          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[12].Enabled);
3349          break;
3350       case GL_VERTEX_ATTRIB_ARRAY13_NV:
3351          CHECK_EXTENSION_F(NV_vertex_program, pname);
3352          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[13].Enabled);
3353          break;
3354       case GL_VERTEX_ATTRIB_ARRAY14_NV:
3355          CHECK_EXTENSION_F(NV_vertex_program, pname);
3356          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[14].Enabled);
3357          break;
3358       case GL_VERTEX_ATTRIB_ARRAY15_NV:
3359          CHECK_EXTENSION_F(NV_vertex_program, pname);
3360          params[0] = BOOLEAN_TO_FLOAT(ctx->Array.VertexAttrib[15].Enabled);
3361          break;
3362       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
3363          CHECK_EXTENSION_F(NV_vertex_program, pname);
3364          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[0]);
3365          break;
3366       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
3367          CHECK_EXTENSION_F(NV_vertex_program, pname);
3368          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[1]);
3369          break;
3370       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
3371          CHECK_EXTENSION_F(NV_vertex_program, pname);
3372          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[2]);
3373          break;
3374       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
3375          CHECK_EXTENSION_F(NV_vertex_program, pname);
3376          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[3]);
3377          break;
3378       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
3379          CHECK_EXTENSION_F(NV_vertex_program, pname);
3380          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[4]);
3381          break;
3382       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
3383          CHECK_EXTENSION_F(NV_vertex_program, pname);
3384          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[5]);
3385          break;
3386       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
3387          CHECK_EXTENSION_F(NV_vertex_program, pname);
3388          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[6]);
3389          break;
3390       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
3391          CHECK_EXTENSION_F(NV_vertex_program, pname);
3392          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[7]);
3393          break;
3394       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
3395          CHECK_EXTENSION_F(NV_vertex_program, pname);
3396          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[8]);
3397          break;
3398       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
3399          CHECK_EXTENSION_F(NV_vertex_program, pname);
3400          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[9]);
3401          break;
3402       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
3403          CHECK_EXTENSION_F(NV_vertex_program, pname);
3404          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[10]);
3405          break;
3406       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
3407          CHECK_EXTENSION_F(NV_vertex_program, pname);
3408          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[11]);
3409          break;
3410       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
3411          CHECK_EXTENSION_F(NV_vertex_program, pname);
3412          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[12]);
3413          break;
3414       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
3415          CHECK_EXTENSION_F(NV_vertex_program, pname);
3416          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[13]);
3417          break;
3418       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
3419          CHECK_EXTENSION_F(NV_vertex_program, pname);
3420          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[14]);
3421          break;
3422       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
3423          CHECK_EXTENSION_F(NV_vertex_program, pname);
3424          params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[15]);
3425          break;
3426       case GL_FRAGMENT_PROGRAM_NV:
3427          CHECK_EXTENSION_F(NV_fragment_program, pname);
3428          params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
3429          break;
3430       case GL_MAX_TEXTURE_COORDS_NV:
3431          CHECK_EXTENSION_F(NV_fragment_program, pname);
3432          params[0] = (GLfloat)(ctx->Const.MaxTextureCoordUnits);
3433          break;
3434       case GL_MAX_TEXTURE_IMAGE_UNITS_NV:
3435          CHECK_EXTENSION_F(NV_fragment_program, pname);
3436          params[0] = (GLfloat)(ctx->Const.MaxTextureImageUnits);
3437          break;
3438       case GL_FRAGMENT_PROGRAM_BINDING_NV:
3439          CHECK_EXTENSION_F(NV_fragment_program, pname);
3440          params[0] = (GLfloat)(ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
3441          break;
3442       case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
3443          CHECK_EXTENSION_F(NV_fragment_program, pname);
3444          params[0] = (GLfloat)(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
3445          break;
3446       case GL_TEXTURE_RECTANGLE_NV:
3447          CHECK_EXTENSION_F(NV_texture_rectangle, pname);
3448          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
3449          break;
3450       case GL_TEXTURE_BINDING_RECTANGLE_NV:
3451          CHECK_EXTENSION_F(NV_texture_rectangle, pname);
3452          params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
3453          break;
3454       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
3455          CHECK_EXTENSION_F(NV_texture_rectangle, pname);
3456          params[0] = (GLfloat)(ctx->Const.MaxTextureRectSize);
3457          break;
3458       case GL_STENCIL_TEST_TWO_SIDE_EXT:
3459          CHECK_EXTENSION_F(EXT_stencil_two_side, pname);
3460          params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.TestTwoSide);
3461          break;
3462       case GL_ACTIVE_STENCIL_FACE_EXT:
3463          CHECK_EXTENSION_F(EXT_stencil_two_side, pname);
3464          params[0] = ENUM_TO_FLOAT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
3465          break;
3466       case GL_MAX_SHININESS_NV:
3467          CHECK_EXTENSION_F(NV_light_max_exponent, pname);
3468          params[0] = ctx->Const.MaxShininess;
3469          break;
3470       case GL_MAX_SPOT_EXPONENT_NV:
3471          CHECK_EXTENSION_F(NV_light_max_exponent, pname);
3472          params[0] = ctx->Const.MaxSpotExponent;
3473          break;
3474       case GL_ARRAY_BUFFER_BINDING_ARB:
3475          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3476          params[0] = (GLfloat)(ctx->Array.ArrayBufferObj->Name);
3477          break;
3478       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
3479          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3480          params[0] = (GLfloat)(ctx->Array.Vertex.BufferObj->Name);
3481          break;
3482       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
3483          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3484          params[0] = (GLfloat)(ctx->Array.Normal.BufferObj->Name);
3485          break;
3486       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
3487          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3488          params[0] = (GLfloat)(ctx->Array.Color.BufferObj->Name);
3489          break;
3490       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
3491          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3492          params[0] = (GLfloat)(ctx->Array.Index.BufferObj->Name);
3493          break;
3494       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
3495          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3496          params[0] = (GLfloat)(ctx->Array.TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
3497          break;
3498       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
3499          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3500          params[0] = (GLfloat)(ctx->Array.EdgeFlag.BufferObj->Name);
3501          break;
3502       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
3503          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3504          params[0] = (GLfloat)(ctx->Array.SecondaryColor.BufferObj->Name);
3505          break;
3506       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
3507          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3508          params[0] = (GLfloat)(ctx->Array.FogCoord.BufferObj->Name);
3509          break;
3510       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
3511          CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname);
3512          params[0] = (GLfloat)(ctx->Array.ElementArrayBufferObj->Name);
3513          break;
3514       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
3515          CHECK_EXTENSION_F(EXT_pixel_buffer_object, pname);
3516          params[0] = (GLfloat)(ctx->Pack.BufferObj->Name);
3517          break;
3518       case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
3519          CHECK_EXTENSION_F(EXT_pixel_buffer_object, pname);
3520          params[0] = (GLfloat)(ctx->Unpack.BufferObj->Name);
3521          break;
3522       case GL_MAX_VERTEX_ATTRIBS_ARB:
3523          CHECK_EXTENSION_F(ARB_vertex_program, pname);
3524          params[0] = (GLfloat)(ctx->Const.MaxVertexProgramAttribs);
3525          break;
3526       case GL_FRAGMENT_PROGRAM_ARB:
3527          CHECK_EXTENSION_F(ARB_fragment_program, pname);
3528          params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
3529          break;
3530       case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
3531          CHECK_EXTENSION_F(ARB_fragment_program, pname);
3532          {
3533          const GLfloat *matrix = ctx->CurrentStack->Top->m;
3534          params[0] = matrix[0];
3535          params[1] = matrix[4];
3536          params[2] = matrix[8];
3537          params[3] = matrix[12];
3538          params[4] = matrix[1];
3539          params[5] = matrix[5];
3540          params[6] = matrix[9];
3541          params[7] = matrix[13];
3542          params[8] = matrix[2];
3543          params[9] = matrix[6];
3544          params[10] = matrix[10];
3545          params[11] = matrix[14];
3546          params[12] = matrix[3];
3547          params[13] = matrix[7];
3548          params[14] = matrix[11];
3549          params[15] = matrix[15];
3550          }
3551          break;
3552       case GL_DEPTH_BOUNDS_TEST_EXT:
3553          CHECK_EXTENSION_F(EXT_depth_bounds_test, pname);
3554          params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.BoundsTest);
3555          break;
3556       case GL_DEPTH_BOUNDS_EXT:
3557          CHECK_EXTENSION_F(EXT_depth_bounds_test, pname);
3558          params[0] = ctx->Depth.BoundsMin;
3559          params[1] = ctx->Depth.BoundsMax;
3560          break;
3561       case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
3562          CHECK_EXTENSION_F(MESA_program_debug, pname);
3563          params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.CallbackEnabled);
3564          break;
3565       case GL_VERTEX_PROGRAM_CALLBACK_MESA:
3566          CHECK_EXTENSION_F(MESA_program_debug, pname);
3567          params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.CallbackEnabled);
3568          break;
3569       case GL_FRAGMENT_PROGRAM_POSITION_MESA:
3570          CHECK_EXTENSION_F(MESA_program_debug, pname);
3571          params[0] = (GLfloat)(ctx->FragmentProgram.CurrentPosition);
3572          break;
3573       case GL_VERTEX_PROGRAM_POSITION_MESA:
3574          CHECK_EXTENSION_F(MESA_program_debug, pname);
3575          params[0] = (GLfloat)(ctx->VertexProgram.CurrentPosition);
3576          break;
3577       case GL_MAX_DRAW_BUFFERS_ARB:
3578          CHECK_EXTENSION_F(ARB_draw_buffers, pname);
3579          params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
3580          break;
3581       case GL_DRAW_BUFFER0_ARB:
3582          CHECK_EXTENSION_F(ARB_draw_buffers, pname);
3583          params[0] = ENUM_TO_FLOAT(ctx->Color.DrawBuffer[0]);
3584          break;
3585       case GL_DRAW_BUFFER1_ARB:
3586          CHECK_EXTENSION_F(ARB_draw_buffers, pname);
3587          {
3588          GLenum buffer;
3589          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
3590             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
3591             return;
3592          }
3593          buffer = ctx->Color.DrawBuffer[1];
3594          params[0] = ENUM_TO_FLOAT(buffer);
3595          }
3596          break;
3597       case GL_DRAW_BUFFER2_ARB:
3598          CHECK_EXTENSION_F(ARB_draw_buffers, pname);
3599          {
3600          GLenum buffer;
3601          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
3602             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
3603             return;
3604          }
3605          buffer = ctx->Color.DrawBuffer[2];
3606          params[0] = ENUM_TO_FLOAT(buffer);
3607          }
3608          break;
3609       case GL_DRAW_BUFFER3_ARB:
3610          CHECK_EXTENSION_F(ARB_draw_buffers, pname);
3611          {
3612          GLenum buffer;
3613          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
3614             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
3615             return;
3616          }
3617          buffer = ctx->Color.DrawBuffer[3];
3618          params[0] = ENUM_TO_FLOAT(buffer);
3619          }
3620          break;
3621       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
3622          CHECK_EXTENSION_F(OES_read_format, pname);
3623          params[0] = (GLfloat)(ctx->Const.ColorReadType);
3624          break;
3625       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
3626          CHECK_EXTENSION_F(OES_read_format, pname);
3627          params[0] = (GLfloat)(ctx->Const.ColorReadFormat);
3628          break;
3629       case GL_NUM_FRAGMENT_REGISTERS_ATI:
3630          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3631          params[0] = (GLfloat)(6);
3632          break;
3633       case GL_NUM_FRAGMENT_CONSTANTS_ATI:
3634          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3635          params[0] = (GLfloat)(8);
3636          break;
3637       case GL_NUM_PASSES_ATI:
3638          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3639          params[0] = (GLfloat)(2);
3640          break;
3641       case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
3642          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3643          params[0] = (GLfloat)(8);
3644          break;
3645       case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
3646          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3647          params[0] = (GLfloat)(16);
3648          break;
3649       case GL_COLOR_ALPHA_PAIRING_ATI:
3650          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3651          params[0] = BOOLEAN_TO_FLOAT(GL_TRUE);
3652          break;
3653       case GL_NUM_LOOPBACK_COMPONENTS_ATI:
3654          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3655          params[0] = (GLfloat)(3);
3656          break;
3657       case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
3658          CHECK_EXTENSION_F(ATI_fragment_shader, pname);
3659          params[0] = (GLfloat)(3);
3660          break;
3661       case GL_STENCIL_BACK_FUNC:
3662          params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[1]);
3663          break;
3664       case GL_STENCIL_BACK_VALUE_MASK:
3665          params[0] = (GLfloat)(ctx->Stencil.ValueMask[1]);
3666          break;
3667       case GL_STENCIL_BACK_REF:
3668          params[0] = (GLfloat)(ctx->Stencil.Ref[1]);
3669          break;
3670       case GL_STENCIL_BACK_FAIL:
3671          params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[1]);
3672          break;
3673       case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
3674          params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[1]);
3675          break;
3676       case GL_STENCIL_BACK_PASS_DEPTH_PASS:
3677          params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[1]);
3678          break;
3679       default:
3680          _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(pname=0x%x)", pname);
3681    }
3682 }
3683
3684 void GLAPIENTRY
3685 _mesa_GetIntegerv( GLenum pname, GLint *params )
3686 {
3687    GET_CURRENT_CONTEXT(ctx);
3688    ASSERT_OUTSIDE_BEGIN_END(ctx);
3689
3690    if (!params)
3691       return;
3692
3693    if (ctx->Driver.GetIntegerv &&
3694        ctx->Driver.GetIntegerv(ctx, pname, params))
3695       return;
3696
3697    switch (pname) {
3698       case GL_ACCUM_RED_BITS:
3699          params[0] = ctx->Visual.accumRedBits;
3700          break;
3701       case GL_ACCUM_GREEN_BITS:
3702          params[0] = ctx->Visual.accumGreenBits;
3703          break;
3704       case GL_ACCUM_BLUE_BITS:
3705          params[0] = ctx->Visual.accumBlueBits;
3706          break;
3707       case GL_ACCUM_ALPHA_BITS:
3708          params[0] = ctx->Visual.accumAlphaBits;
3709          break;
3710       case GL_ACCUM_CLEAR_VALUE:
3711          params[0] = FLOAT_TO_INT(ctx->Accum.ClearColor[0]);
3712          params[1] = FLOAT_TO_INT(ctx->Accum.ClearColor[1]);
3713          params[2] = FLOAT_TO_INT(ctx->Accum.ClearColor[2]);
3714          params[3] = FLOAT_TO_INT(ctx->Accum.ClearColor[3]);
3715          break;
3716       case GL_ALPHA_BIAS:
3717          params[0] = IROUND(ctx->Pixel.AlphaBias);
3718          break;
3719       case GL_ALPHA_BITS:
3720          params[0] = ctx->Visual.alphaBits;
3721          break;
3722       case GL_ALPHA_SCALE:
3723          params[0] = IROUND(ctx->Pixel.AlphaScale);
3724          break;
3725       case GL_ALPHA_TEST:
3726          params[0] = BOOLEAN_TO_INT(ctx->Color.AlphaEnabled);
3727          break;
3728       case GL_ALPHA_TEST_FUNC:
3729          params[0] = ENUM_TO_INT(ctx->Color.AlphaFunc);
3730          break;
3731       case GL_ALPHA_TEST_REF:
3732          params[0] = FLOAT_TO_INT(ctx->Color.AlphaRef);
3733          break;
3734       case GL_ATTRIB_STACK_DEPTH:
3735          params[0] = ctx->AttribStackDepth;
3736          break;
3737       case GL_AUTO_NORMAL:
3738          params[0] = BOOLEAN_TO_INT(ctx->Eval.AutoNormal);
3739          break;
3740       case GL_AUX_BUFFERS:
3741          params[0] = ctx->Visual.numAuxBuffers;
3742          break;
3743       case GL_BLEND:
3744          params[0] = BOOLEAN_TO_INT(ctx->Color.BlendEnabled);
3745          break;
3746       case GL_BLEND_DST:
3747          params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
3748          break;
3749       case GL_BLEND_SRC:
3750          params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
3751          break;
3752       case GL_BLEND_SRC_RGB_EXT:
3753          params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
3754          break;
3755       case GL_BLEND_DST_RGB_EXT:
3756          params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
3757          break;
3758       case GL_BLEND_SRC_ALPHA_EXT:
3759          params[0] = ENUM_TO_INT(ctx->Color.BlendSrcA);
3760          break;
3761       case GL_BLEND_DST_ALPHA_EXT:
3762          params[0] = ENUM_TO_INT(ctx->Color.BlendDstA);
3763          break;
3764       case GL_BLEND_EQUATION:
3765          params[0] = ENUM_TO_INT(ctx->Color.BlendEquationRGB );
3766          break;
3767       case GL_BLEND_EQUATION_ALPHA_EXT:
3768          params[0] = ENUM_TO_INT(ctx->Color.BlendEquationA );
3769          break;
3770       case GL_BLEND_COLOR_EXT:
3771          params[0] = FLOAT_TO_INT(ctx->Color.BlendColor[0]);
3772          params[1] = FLOAT_TO_INT(ctx->Color.BlendColor[1]);
3773          params[2] = FLOAT_TO_INT(ctx->Color.BlendColor[2]);
3774          params[3] = FLOAT_TO_INT(ctx->Color.BlendColor[3]);
3775          break;
3776       case GL_BLUE_BIAS:
3777          params[0] = IROUND(ctx->Pixel.BlueBias);
3778          break;
3779       case GL_BLUE_BITS:
3780          params[0] = ctx->Visual.blueBits;
3781          break;
3782       case GL_BLUE_SCALE:
3783          params[0] = IROUND(ctx->Pixel.BlueScale);
3784          break;
3785       case GL_CLIENT_ATTRIB_STACK_DEPTH:
3786          params[0] = ctx->ClientAttribStackDepth;
3787          break;
3788       case GL_CLIP_PLANE0:
3789          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
3790          break;
3791       case GL_CLIP_PLANE1:
3792          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
3793          break;
3794       case GL_CLIP_PLANE2:
3795          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
3796          break;
3797       case GL_CLIP_PLANE3:
3798          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
3799          break;
3800       case GL_CLIP_PLANE4:
3801          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
3802          break;
3803       case GL_CLIP_PLANE5:
3804          params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
3805          break;
3806       case GL_COLOR_CLEAR_VALUE:
3807          params[0] = FLOAT_TO_INT(ctx->Color.ClearColor[0]);
3808          params[1] = FLOAT_TO_INT(ctx->Color.ClearColor[1]);
3809          params[2] = FLOAT_TO_INT(ctx->Color.ClearColor[2]);
3810          params[3] = FLOAT_TO_INT(ctx->Color.ClearColor[3]);
3811          break;
3812       case GL_COLOR_MATERIAL:
3813          params[0] = BOOLEAN_TO_INT(ctx->Light.ColorMaterialEnabled);
3814          break;
3815       case GL_COLOR_MATERIAL_FACE:
3816          params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialFace);
3817          break;
3818       case GL_COLOR_MATERIAL_PARAMETER:
3819          params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialMode);
3820          break;
3821       case GL_COLOR_WRITEMASK:
3822          params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
3823          params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
3824          params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
3825          params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
3826          break;
3827       case GL_CULL_FACE:
3828          params[0] = BOOLEAN_TO_INT(ctx->Polygon.CullFlag);
3829          break;
3830       case GL_CULL_FACE_MODE:
3831          params[0] = ENUM_TO_INT(ctx->Polygon.CullFaceMode);
3832          break;
3833       case GL_CURRENT_COLOR:
3834          {
3835          FLUSH_CURRENT(ctx, 0);
3836          params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
3837          params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
3838          params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
3839          params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
3840          }
3841          break;
3842       case GL_CURRENT_INDEX:
3843          {
3844          FLUSH_CURRENT(ctx, 0);
3845          params[0] = IROUND(ctx->Current.Index);
3846          }
3847          break;
3848       case GL_CURRENT_NORMAL:
3849          {
3850          FLUSH_CURRENT(ctx, 0);
3851          params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
3852          params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
3853          params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
3854          }
3855          break;
3856       case GL_CURRENT_RASTER_COLOR:
3857          params[0] = FLOAT_TO_INT(ctx->Current.RasterColor[0]);
3858          params[1] = FLOAT_TO_INT(ctx->Current.RasterColor[1]);
3859          params[2] = FLOAT_TO_INT(ctx->Current.RasterColor[2]);
3860          params[3] = FLOAT_TO_INT(ctx->Current.RasterColor[3]);
3861          break;
3862       case GL_CURRENT_RASTER_DISTANCE:
3863          params[0] = IROUND(ctx->Current.RasterDistance);
3864          break;
3865       case GL_CURRENT_RASTER_INDEX:
3866          params[0] = IROUND(ctx->Current.RasterIndex);
3867          break;
3868       case GL_CURRENT_RASTER_POSITION:
3869          params[0] = IROUND(ctx->Current.RasterPos[0]);
3870          params[1] = IROUND(ctx->Current.RasterPos[1]);
3871          params[2] = IROUND(ctx->Current.RasterPos[2]);
3872          params[3] = IROUND(ctx->Current.RasterPos[3]);
3873          break;
3874       case GL_CURRENT_RASTER_TEXTURE_COORDS:
3875          {
3876          const GLuint texUnit = ctx->Texture.CurrentUnit;
3877          params[0] = IROUND(ctx->Current.RasterTexCoords[texUnit][0]);
3878          params[1] = IROUND(ctx->Current.RasterTexCoords[texUnit][1]);
3879          params[2] = IROUND(ctx->Current.RasterTexCoords[texUnit][2]);
3880          params[3] = IROUND(ctx->Current.RasterTexCoords[texUnit][3]);
3881          }
3882          break;
3883       case GL_CURRENT_RASTER_POSITION_VALID:
3884          params[0] = BOOLEAN_TO_INT(ctx->Current.RasterPosValid);
3885          break;
3886       case GL_CURRENT_TEXTURE_COORDS:
3887          {
3888          const GLuint texUnit = ctx->Texture.CurrentUnit;
3889          params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
3890          params[1] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
3891          params[2] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
3892          params[3] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
3893          }
3894          break;
3895       case GL_DEPTH_BIAS:
3896          params[0] = IROUND(ctx->Pixel.DepthBias);
3897          break;
3898       case GL_DEPTH_BITS:
3899          params[0] = ctx->Visual.depthBits;
3900          break;
3901       case GL_DEPTH_CLEAR_VALUE:
3902          params[0] = IROUND(ctx->Depth.Clear);
3903          break;
3904       case GL_DEPTH_FUNC:
3905          params[0] = ENUM_TO_INT(ctx->Depth.Func);
3906          break;
3907       case GL_DEPTH_RANGE:
3908          params[0] = FLOAT_TO_INT(ctx->Viewport.Near);
3909          params[1] = FLOAT_TO_INT(ctx->Viewport.Far);
3910          break;
3911       case GL_DEPTH_SCALE:
3912          params[0] = IROUND(ctx->Pixel.DepthScale);
3913          break;
3914       case GL_DEPTH_TEST:
3915          params[0] = BOOLEAN_TO_INT(ctx->Depth.Test);
3916          break;
3917       case GL_DEPTH_WRITEMASK:
3918          params[0] = BOOLEAN_TO_INT(ctx->Depth.Mask);
3919          break;
3920       case GL_DITHER:
3921          params[0] = BOOLEAN_TO_INT(ctx->Color.DitherFlag);
3922          break;
3923       case GL_DOUBLEBUFFER:
3924          params[0] = BOOLEAN_TO_INT(ctx->Visual.doubleBufferMode);
3925          break;
3926       case GL_DRAW_BUFFER:
3927          params[0] = ENUM_TO_INT(ctx->Color.DrawBuffer[0]);
3928          break;
3929       case GL_EDGE_FLAG:
3930          {
3931          FLUSH_CURRENT(ctx, 0);
3932          params[0] = BOOLEAN_TO_INT(ctx->Current.EdgeFlag);
3933          }
3934          break;
3935       case GL_FEEDBACK_BUFFER_SIZE:
3936          params[0] = ctx->Feedback.BufferSize;
3937          break;
3938       case GL_FEEDBACK_BUFFER_TYPE:
3939          params[0] = ENUM_TO_INT(ctx->Feedback.Type);
3940          break;
3941       case GL_FOG:
3942          params[0] = BOOLEAN_TO_INT(ctx->Fog.Enabled);
3943          break;
3944       case GL_FOG_COLOR:
3945          params[0] = FLOAT_TO_INT(ctx->Fog.Color[0]);
3946          params[1] = FLOAT_TO_INT(ctx->Fog.Color[1]);
3947          params[2] = FLOAT_TO_INT(ctx->Fog.Color[2]);
3948          params[3] = FLOAT_TO_INT(ctx->Fog.Color[3]);
3949          break;
3950       case GL_FOG_DENSITY:
3951          params[0] = IROUND(ctx->Fog.Density);
3952          break;
3953       case GL_FOG_END:
3954          params[0] = IROUND(ctx->Fog.End);
3955          break;
3956       case GL_FOG_HINT:
3957          params[0] = ENUM_TO_INT(ctx->Hint.Fog);
3958          break;
3959       case GL_FOG_INDEX:
3960          params[0] = IROUND(ctx->Fog.Index);
3961          break;
3962       case GL_FOG_MODE:
3963          params[0] = ENUM_TO_INT(ctx->Fog.Mode);
3964          break;
3965       case GL_FOG_START:
3966          params[0] = IROUND(ctx->Fog.Start);
3967          break;
3968       case GL_FRONT_FACE:
3969          params[0] = ENUM_TO_INT(ctx->Polygon.FrontFace);
3970          break;
3971       case GL_GREEN_BIAS:
3972          params[0] = IROUND(ctx->Pixel.GreenBias);
3973          break;
3974       case GL_GREEN_BITS:
3975          params[0] = ctx->Visual.greenBits;
3976          break;
3977       case GL_GREEN_SCALE:
3978          params[0] = IROUND(ctx->Pixel.GreenScale);
3979          break;
3980       case GL_INDEX_BITS:
3981          params[0] = ctx->Visual.indexBits;
3982          break;
3983       case GL_INDEX_CLEAR_VALUE:
3984          params[0] = ctx->Color.ClearIndex;
3985          break;
3986       case GL_INDEX_MODE:
3987          params[0] = BOOLEAN_TO_INT(!ctx->Visual.rgbMode);
3988          break;
3989       case GL_INDEX_OFFSET:
3990          params[0] = ctx->Pixel.IndexOffset;
3991          break;
3992       case GL_INDEX_SHIFT:
3993          params[0] = ctx->Pixel.IndexShift;
3994          break;
3995       case GL_INDEX_WRITEMASK:
3996          params[0] = ctx->Color.IndexMask;
3997          break;
3998       case GL_LIGHT0:
3999          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[0].Enabled);
4000          break;
4001       case GL_LIGHT1:
4002          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[1].Enabled);
4003          break;
4004       case GL_LIGHT2:
4005          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[2].Enabled);
4006          break;
4007       case GL_LIGHT3:
4008          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[3].Enabled);
4009          break;
4010       case GL_LIGHT4:
4011          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[4].Enabled);
4012          break;
4013       case GL_LIGHT5:
4014          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[5].Enabled);
4015          break;
4016       case GL_LIGHT6:
4017          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[6].Enabled);
4018          break;
4019       case GL_LIGHT7:
4020          params[0] = BOOLEAN_TO_INT(ctx->Light.Light[7].Enabled);
4021          break;
4022       case GL_LIGHTING:
4023          params[0] = BOOLEAN_TO_INT(ctx->Light.Enabled);
4024          break;
4025       case GL_LIGHT_MODEL_AMBIENT:
4026          params[0] = FLOAT_TO_INT(ctx->Light.Model.Ambient[0]);
4027          params[1] = FLOAT_TO_INT(ctx->Light.Model.Ambient[1]);
4028          params[2] = FLOAT_TO_INT(ctx->Light.Model.Ambient[2]);
4029          params[3] = FLOAT_TO_INT(ctx->Light.Model.Ambient[3]);
4030          break;
4031       case GL_LIGHT_MODEL_COLOR_CONTROL:
4032          params[0] = ENUM_TO_INT(ctx->Light.Model.ColorControl);
4033          break;
4034       case GL_LIGHT_MODEL_LOCAL_VIEWER:
4035          params[0] = BOOLEAN_TO_INT(ctx->Light.Model.LocalViewer);
4036          break;
4037       case GL_LIGHT_MODEL_TWO_SIDE:
4038          params[0] = BOOLEAN_TO_INT(ctx->Light.Model.TwoSide);
4039          break;
4040       case GL_LINE_SMOOTH:
4041          params[0] = BOOLEAN_TO_INT(ctx->Line.SmoothFlag);
4042          break;
4043       case GL_LINE_SMOOTH_HINT:
4044          params[0] = ENUM_TO_INT(ctx->Hint.LineSmooth);
4045          break;
4046       case GL_LINE_STIPPLE:
4047          params[0] = BOOLEAN_TO_INT(ctx->Line.StippleFlag);
4048          break;
4049       case GL_LINE_STIPPLE_PATTERN:
4050          params[0] = ctx->Line.StipplePattern;
4051          break;
4052       case GL_LINE_STIPPLE_REPEAT:
4053          params[0] = ctx->Line.StippleFactor;
4054          break;
4055       case GL_LINE_WIDTH:
4056          params[0] = IROUND(ctx->Line.Width);
4057          break;
4058       case GL_LINE_WIDTH_GRANULARITY:
4059          params[0] = IROUND(ctx->Const.LineWidthGranularity);
4060          break;
4061       case GL_LINE_WIDTH_RANGE:
4062          params[0] = IROUND(ctx->Const.MinLineWidthAA);
4063          params[1] = IROUND(ctx->Const.MaxLineWidthAA);
4064          break;
4065       case GL_ALIASED_LINE_WIDTH_RANGE:
4066          params[0] = IROUND(ctx->Const.MinLineWidth);
4067          params[1] = IROUND(ctx->Const.MaxLineWidth);
4068          break;
4069       case GL_LIST_BASE:
4070          params[0] = ctx->List.ListBase;
4071          break;
4072       case GL_LIST_INDEX:
4073          params[0] = ctx->ListState.CurrentListNum;
4074          break;
4075       case GL_LIST_MODE:
4076          {
4077          GLenum mode;
4078          if (!ctx->CompileFlag)
4079             mode = 0;
4080          else if (ctx->ExecuteFlag)
4081             mode = GL_COMPILE_AND_EXECUTE;
4082          else
4083             mode = GL_COMPILE;
4084          params[0] = ENUM_TO_INT(mode);
4085          }
4086          break;
4087       case GL_INDEX_LOGIC_OP:
4088          params[0] = BOOLEAN_TO_INT(ctx->Color.IndexLogicOpEnabled);
4089          break;
4090       case GL_COLOR_LOGIC_OP:
4091          params[0] = BOOLEAN_TO_INT(ctx->Color.ColorLogicOpEnabled);
4092          break;
4093       case GL_LOGIC_OP_MODE:
4094          params[0] = ENUM_TO_INT(ctx->Color.LogicOp);
4095          break;
4096       case GL_MAP1_COLOR_4:
4097          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Color4);
4098          break;
4099       case GL_MAP1_GRID_DOMAIN:
4100          params[0] = IROUND(ctx->Eval.MapGrid1u1);
4101          params[1] = IROUND(ctx->Eval.MapGrid1u2);
4102          break;
4103       case GL_MAP1_GRID_SEGMENTS:
4104          params[0] = ctx->Eval.MapGrid1un;
4105          break;
4106       case GL_MAP1_INDEX:
4107          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Index);
4108          break;
4109       case GL_MAP1_NORMAL:
4110          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Normal);
4111          break;
4112       case GL_MAP1_TEXTURE_COORD_1:
4113          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord1);
4114          break;
4115       case GL_MAP1_TEXTURE_COORD_2:
4116          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord2);
4117          break;
4118       case GL_MAP1_TEXTURE_COORD_3:
4119          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord3);
4120          break;
4121       case GL_MAP1_TEXTURE_COORD_4:
4122          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord4);
4123          break;
4124       case GL_MAP1_VERTEX_3:
4125          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex3);
4126          break;
4127       case GL_MAP1_VERTEX_4:
4128          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex4);
4129          break;
4130       case GL_MAP2_COLOR_4:
4131          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Color4);
4132          break;
4133       case GL_MAP2_GRID_DOMAIN:
4134          params[0] = IROUND(ctx->Eval.MapGrid2u1);
4135          params[1] = IROUND(ctx->Eval.MapGrid2u2);
4136          params[2] = IROUND(ctx->Eval.MapGrid2v1);
4137          params[3] = IROUND(ctx->Eval.MapGrid2v2);
4138          break;
4139       case GL_MAP2_GRID_SEGMENTS:
4140          params[0] = ctx->Eval.MapGrid2un;
4141          params[1] = ctx->Eval.MapGrid2vn;
4142          break;
4143       case GL_MAP2_INDEX:
4144          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Index);
4145          break;
4146       case GL_MAP2_NORMAL:
4147          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Normal);
4148          break;
4149       case GL_MAP2_TEXTURE_COORD_1:
4150          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord1);
4151          break;
4152       case GL_MAP2_TEXTURE_COORD_2:
4153          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord2);
4154          break;
4155       case GL_MAP2_TEXTURE_COORD_3:
4156          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord3);
4157          break;
4158       case GL_MAP2_TEXTURE_COORD_4:
4159          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord4);
4160          break;
4161       case GL_MAP2_VERTEX_3:
4162          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex3);
4163          break;
4164       case GL_MAP2_VERTEX_4:
4165          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex4);
4166          break;
4167       case GL_MAP_COLOR:
4168          params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapColorFlag);
4169          break;
4170       case GL_MAP_STENCIL:
4171          params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapStencilFlag);
4172          break;
4173       case GL_MATRIX_MODE:
4174          params[0] = ENUM_TO_INT(ctx->Transform.MatrixMode);
4175          break;
4176       case GL_MAX_ATTRIB_STACK_DEPTH:
4177          params[0] = MAX_ATTRIB_STACK_DEPTH;
4178          break;
4179       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
4180          params[0] = MAX_CLIENT_ATTRIB_STACK_DEPTH;
4181          break;
4182       case GL_MAX_CLIP_PLANES:
4183          params[0] = ctx->Const.MaxClipPlanes;
4184          break;
4185       case GL_MAX_ELEMENTS_VERTICES:
4186          params[0] = ctx->Const.MaxArrayLockSize;
4187          break;
4188       case GL_MAX_ELEMENTS_INDICES:
4189          params[0] = ctx->Const.MaxArrayLockSize;
4190          break;
4191       case GL_MAX_EVAL_ORDER:
4192          params[0] = MAX_EVAL_ORDER;
4193          break;
4194       case GL_MAX_LIGHTS:
4195          params[0] = ctx->Const.MaxLights;
4196          break;
4197       case GL_MAX_LIST_NESTING:
4198          params[0] = MAX_LIST_NESTING;
4199          break;
4200       case GL_MAX_MODELVIEW_STACK_DEPTH:
4201          params[0] = MAX_MODELVIEW_STACK_DEPTH;
4202          break;
4203       case GL_MAX_NAME_STACK_DEPTH:
4204          params[0] = MAX_NAME_STACK_DEPTH;
4205          break;
4206       case GL_MAX_PIXEL_MAP_TABLE:
4207          params[0] = MAX_PIXEL_MAP_TABLE;
4208          break;
4209       case GL_MAX_PROJECTION_STACK_DEPTH:
4210          params[0] = MAX_PROJECTION_STACK_DEPTH;
4211          break;
4212       case GL_MAX_TEXTURE_SIZE:
4213          params[0] = 1 << (ctx->Const.MaxTextureLevels - 1);
4214          break;
4215       case GL_MAX_3D_TEXTURE_SIZE:
4216          params[0] = 1 << (ctx->Const.Max3DTextureLevels - 1);
4217          break;
4218       case GL_MAX_TEXTURE_STACK_DEPTH:
4219          params[0] = MAX_TEXTURE_STACK_DEPTH;
4220          break;
4221       case GL_MAX_VIEWPORT_DIMS:
4222          params[0] = ctx->Const.MaxViewportWidth;
4223          params[1] = ctx->Const.MaxViewportHeight;
4224          break;
4225       case GL_MODELVIEW_MATRIX:
4226          {
4227          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
4228          params[0] = IROUND(matrix[0]);
4229          params[1] = IROUND(matrix[1]);
4230          params[2] = IROUND(matrix[2]);
4231          params[3] = IROUND(matrix[3]);
4232          params[4] = IROUND(matrix[4]);
4233          params[5] = IROUND(matrix[5]);
4234          params[6] = IROUND(matrix[6]);
4235          params[7] = IROUND(matrix[7]);
4236          params[8] = IROUND(matrix[8]);
4237          params[9] = IROUND(matrix[9]);
4238          params[10] = IROUND(matrix[10]);
4239          params[11] = IROUND(matrix[11]);
4240          params[12] = IROUND(matrix[12]);
4241          params[13] = IROUND(matrix[13]);
4242          params[14] = IROUND(matrix[14]);
4243          params[15] = IROUND(matrix[15]);
4244          }
4245          break;
4246       case GL_MODELVIEW_STACK_DEPTH:
4247          params[0] = ctx->ModelviewMatrixStack.Depth + 1;
4248          break;
4249       case GL_NAME_STACK_DEPTH:
4250          params[0] = ctx->Select.NameStackDepth;
4251          break;
4252       case GL_NORMALIZE:
4253          params[0] = BOOLEAN_TO_INT(ctx->Transform.Normalize);
4254          break;
4255       case GL_PACK_ALIGNMENT:
4256          params[0] = ctx->Pack.Alignment;
4257          break;
4258       case GL_PACK_LSB_FIRST:
4259          params[0] = BOOLEAN_TO_INT(ctx->Pack.LsbFirst);
4260          break;
4261       case GL_PACK_ROW_LENGTH:
4262          params[0] = ctx->Pack.RowLength;
4263          break;
4264       case GL_PACK_SKIP_PIXELS:
4265          params[0] = ctx->Pack.SkipPixels;
4266          break;
4267       case GL_PACK_SKIP_ROWS:
4268          params[0] = ctx->Pack.SkipRows;
4269          break;
4270       case GL_PACK_SWAP_BYTES:
4271          params[0] = BOOLEAN_TO_INT(ctx->Pack.SwapBytes);
4272          break;
4273       case GL_PACK_SKIP_IMAGES_EXT:
4274          params[0] = ctx->Pack.SkipImages;
4275          break;
4276       case GL_PACK_IMAGE_HEIGHT_EXT:
4277          params[0] = ctx->Pack.ImageHeight;
4278          break;
4279       case GL_PACK_INVERT_MESA:
4280          params[0] = BOOLEAN_TO_INT(ctx->Pack.Invert);
4281          break;
4282       case GL_PERSPECTIVE_CORRECTION_HINT:
4283          params[0] = ENUM_TO_INT(ctx->Hint.PerspectiveCorrection);
4284          break;
4285       case GL_PIXEL_MAP_A_TO_A_SIZE:
4286          params[0] = ctx->Pixel.MapAtoAsize;
4287          break;
4288       case GL_PIXEL_MAP_B_TO_B_SIZE:
4289          params[0] = ctx->Pixel.MapBtoBsize;
4290          break;
4291       case GL_PIXEL_MAP_G_TO_G_SIZE:
4292          params[0] = ctx->Pixel.MapGtoGsize;
4293          break;
4294       case GL_PIXEL_MAP_I_TO_A_SIZE:
4295          params[0] = ctx->Pixel.MapItoAsize;
4296          break;
4297       case GL_PIXEL_MAP_I_TO_B_SIZE:
4298          params[0] = ctx->Pixel.MapItoBsize;
4299          break;
4300       case GL_PIXEL_MAP_I_TO_G_SIZE:
4301          params[0] = ctx->Pixel.MapItoGsize;
4302          break;
4303       case GL_PIXEL_MAP_I_TO_I_SIZE:
4304          params[0] = ctx->Pixel.MapItoIsize;
4305          break;
4306       case GL_PIXEL_MAP_I_TO_R_SIZE:
4307          params[0] = ctx->Pixel.MapItoRsize;
4308          break;
4309       case GL_PIXEL_MAP_R_TO_R_SIZE:
4310          params[0] = ctx->Pixel.MapRtoRsize;
4311          break;
4312       case GL_PIXEL_MAP_S_TO_S_SIZE:
4313          params[0] = ctx->Pixel.MapStoSsize;
4314          break;
4315       case GL_POINT_SIZE:
4316          params[0] = IROUND(ctx->Point.Size);
4317          break;
4318       case GL_POINT_SIZE_GRANULARITY:
4319          params[0] = IROUND(ctx->Const.PointSizeGranularity);
4320          break;
4321       case GL_POINT_SIZE_RANGE:
4322          params[0] = IROUND(ctx->Const.MinPointSizeAA);
4323          params[1] = IROUND(ctx->Const.MaxPointSizeAA);
4324          break;
4325       case GL_ALIASED_POINT_SIZE_RANGE:
4326          params[0] = IROUND(ctx->Const.MinPointSize);
4327          params[1] = IROUND(ctx->Const.MaxPointSize);
4328          break;
4329       case GL_POINT_SMOOTH:
4330          params[0] = BOOLEAN_TO_INT(ctx->Point.SmoothFlag);
4331          break;
4332       case GL_POINT_SMOOTH_HINT:
4333          params[0] = ENUM_TO_INT(ctx->Hint.PointSmooth);
4334          break;
4335       case GL_POINT_SIZE_MIN_EXT:
4336          params[0] = IROUND(ctx->Point.MinSize);
4337          break;
4338       case GL_POINT_SIZE_MAX_EXT:
4339          params[0] = IROUND(ctx->Point.MaxSize);
4340          break;
4341       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
4342          params[0] = IROUND(ctx->Point.Threshold);
4343          break;
4344       case GL_DISTANCE_ATTENUATION_EXT:
4345          params[0] = IROUND(ctx->Point.Params[0]);
4346          params[1] = IROUND(ctx->Point.Params[1]);
4347          params[2] = IROUND(ctx->Point.Params[2]);
4348          break;
4349       case GL_POLYGON_MODE:
4350          params[0] = ENUM_TO_INT(ctx->Polygon.FrontMode);
4351          params[1] = ENUM_TO_INT(ctx->Polygon.BackMode);
4352          break;
4353       case GL_POLYGON_OFFSET_BIAS_EXT:
4354          params[0] = IROUND(ctx->Polygon.OffsetUnits);
4355          break;
4356       case GL_POLYGON_OFFSET_FACTOR:
4357          params[0] = IROUND(ctx->Polygon.OffsetFactor );
4358          break;
4359       case GL_POLYGON_OFFSET_UNITS:
4360          params[0] = IROUND(ctx->Polygon.OffsetUnits );
4361          break;
4362       case GL_POLYGON_SMOOTH:
4363          params[0] = BOOLEAN_TO_INT(ctx->Polygon.SmoothFlag);
4364          break;
4365       case GL_POLYGON_SMOOTH_HINT:
4366          params[0] = ENUM_TO_INT(ctx->Hint.PolygonSmooth);
4367          break;
4368       case GL_POLYGON_STIPPLE:
4369          params[0] = BOOLEAN_TO_INT(ctx->Polygon.StippleFlag);
4370          break;
4371       case GL_PROJECTION_MATRIX:
4372          {
4373          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
4374          params[0] = IROUND(matrix[0]);
4375          params[1] = IROUND(matrix[1]);
4376          params[2] = IROUND(matrix[2]);
4377          params[3] = IROUND(matrix[3]);
4378          params[4] = IROUND(matrix[4]);
4379          params[5] = IROUND(matrix[5]);
4380          params[6] = IROUND(matrix[6]);
4381          params[7] = IROUND(matrix[7]);
4382          params[8] = IROUND(matrix[8]);
4383          params[9] = IROUND(matrix[9]);
4384          params[10] = IROUND(matrix[10]);
4385          params[11] = IROUND(matrix[11]);
4386          params[12] = IROUND(matrix[12]);
4387          params[13] = IROUND(matrix[13]);
4388          params[14] = IROUND(matrix[14]);
4389          params[15] = IROUND(matrix[15]);
4390          }
4391          break;
4392       case GL_PROJECTION_STACK_DEPTH:
4393          params[0] = ctx->ProjectionMatrixStack.Depth + 1;
4394          break;
4395       case GL_READ_BUFFER:
4396          params[0] = ENUM_TO_INT(ctx->Pixel.ReadBuffer);
4397          break;
4398       case GL_RED_BIAS:
4399          params[0] = IROUND(ctx->Pixel.RedBias);
4400          break;
4401       case GL_RED_BITS:
4402          params[0] =  ctx->Visual.redBits ;
4403          break;
4404       case GL_RED_SCALE:
4405          params[0] = IROUND(ctx->Pixel.RedScale);
4406          break;
4407       case GL_RENDER_MODE:
4408          params[0] = ENUM_TO_INT(ctx->RenderMode);
4409          break;
4410       case GL_RESCALE_NORMAL:
4411          params[0] = BOOLEAN_TO_INT(ctx->Transform.RescaleNormals);
4412          break;
4413       case GL_RGBA_MODE:
4414          params[0] = BOOLEAN_TO_INT(ctx->Visual.rgbMode);
4415          break;
4416       case GL_SCISSOR_BOX:
4417          params[0] = ctx->Scissor.X;
4418          params[1] = ctx->Scissor.Y;
4419          params[2] = ctx->Scissor.Width;
4420          params[3] = ctx->Scissor.Height;
4421          break;
4422       case GL_SCISSOR_TEST:
4423          params[0] = BOOLEAN_TO_INT(ctx->Scissor.Enabled);
4424          break;
4425       case GL_SELECTION_BUFFER_SIZE:
4426          params[0] = ctx->Select.BufferSize;
4427          break;
4428       case GL_SHADE_MODEL:
4429          params[0] = ENUM_TO_INT(ctx->Light.ShadeModel);
4430          break;
4431       case GL_SHARED_TEXTURE_PALETTE_EXT:
4432          params[0] = BOOLEAN_TO_INT(ctx->Texture.SharedPalette);
4433          break;
4434       case GL_STENCIL_BITS:
4435          params[0] = ctx->Visual.stencilBits;
4436          break;
4437       case GL_STENCIL_CLEAR_VALUE:
4438          params[0] = ctx->Stencil.Clear;
4439          break;
4440       case GL_STENCIL_FAIL:
4441          params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
4442          break;
4443       case GL_STENCIL_FUNC:
4444          params[0] = ENUM_TO_INT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
4445          break;
4446       case GL_STENCIL_PASS_DEPTH_FAIL:
4447          params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
4448          break;
4449       case GL_STENCIL_PASS_DEPTH_PASS:
4450          params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
4451          break;
4452       case GL_STENCIL_REF:
4453          params[0] = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
4454          break;
4455       case GL_STENCIL_TEST:
4456          params[0] = BOOLEAN_TO_INT(ctx->Stencil.Enabled);
4457          break;
4458       case GL_STENCIL_VALUE_MASK:
4459          params[0] = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
4460          break;
4461       case GL_STENCIL_WRITEMASK:
4462          params[0] = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
4463          break;
4464       case GL_STEREO:
4465          params[0] = BOOLEAN_TO_INT(ctx->Visual.stereoMode);
4466          break;
4467       case GL_SUBPIXEL_BITS:
4468          params[0] = ctx->Const.SubPixelBits;
4469          break;
4470       case GL_TEXTURE_1D:
4471          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_1D));
4472          break;
4473       case GL_TEXTURE_2D:
4474          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_2D));
4475          break;
4476       case GL_TEXTURE_3D:
4477          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_3D));
4478          break;
4479       case GL_TEXTURE_BINDING_1D:
4480          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name;
4481          break;
4482       case GL_TEXTURE_BINDING_2D:
4483          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name;
4484          break;
4485       case GL_TEXTURE_BINDING_3D:
4486          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name;
4487          break;
4488       case GL_TEXTURE_ENV_COLOR:
4489          {
4490          const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
4491          params[0] = FLOAT_TO_INT(color[0]);
4492          params[1] = FLOAT_TO_INT(color[1]);
4493          params[2] = FLOAT_TO_INT(color[2]);
4494          params[3] = FLOAT_TO_INT(color[3]);
4495          }
4496          break;
4497       case GL_TEXTURE_ENV_MODE:
4498          params[0] = ENUM_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
4499          break;
4500       case GL_TEXTURE_GEN_S:
4501          params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
4502          break;
4503       case GL_TEXTURE_GEN_T:
4504          params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
4505          break;
4506       case GL_TEXTURE_GEN_R:
4507          params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
4508          break;
4509       case GL_TEXTURE_GEN_Q:
4510          params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
4511          break;
4512       case GL_TEXTURE_MATRIX:
4513          {
4514          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
4515          params[0] = IROUND(matrix[0]);
4516          params[1] = IROUND(matrix[1]);
4517          params[2] = IROUND(matrix[2]);
4518          params[3] = IROUND(matrix[3]);
4519          params[4] = IROUND(matrix[4]);
4520          params[5] = IROUND(matrix[5]);
4521          params[6] = IROUND(matrix[6]);
4522          params[7] = IROUND(matrix[7]);
4523          params[8] = IROUND(matrix[8]);
4524          params[9] = IROUND(matrix[9]);
4525          params[10] = IROUND(matrix[10]);
4526          params[11] = IROUND(matrix[11]);
4527          params[12] = IROUND(matrix[12]);
4528          params[13] = IROUND(matrix[13]);
4529          params[14] = IROUND(matrix[14]);
4530          params[15] = IROUND(matrix[15]);
4531          }
4532          break;
4533       case GL_TEXTURE_STACK_DEPTH:
4534          params[0] = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1;
4535          break;
4536       case GL_UNPACK_ALIGNMENT:
4537          params[0] = ctx->Unpack.Alignment;
4538          break;
4539       case GL_UNPACK_LSB_FIRST:
4540          params[0] = BOOLEAN_TO_INT(ctx->Unpack.LsbFirst);
4541          break;
4542       case GL_UNPACK_ROW_LENGTH:
4543          params[0] = ctx->Unpack.RowLength;
4544          break;
4545       case GL_UNPACK_SKIP_PIXELS:
4546          params[0] = ctx->Unpack.SkipPixels;
4547          break;
4548       case GL_UNPACK_SKIP_ROWS:
4549          params[0] = ctx->Unpack.SkipRows;
4550          break;
4551       case GL_UNPACK_SWAP_BYTES:
4552          params[0] = BOOLEAN_TO_INT(ctx->Unpack.SwapBytes);
4553          break;
4554       case GL_UNPACK_SKIP_IMAGES_EXT:
4555          params[0] = ctx->Unpack.SkipImages;
4556          break;
4557       case GL_UNPACK_IMAGE_HEIGHT_EXT:
4558          params[0] = ctx->Unpack.ImageHeight;
4559          break;
4560       case GL_UNPACK_CLIENT_STORAGE_APPLE:
4561          params[0] = BOOLEAN_TO_INT(ctx->Unpack.ClientStorage);
4562          break;
4563       case GL_VIEWPORT:
4564          params[0] = ctx->Viewport.X;
4565          params[1] = ctx->Viewport.Y;
4566          params[2] = ctx->Viewport.Width;
4567          params[3] = ctx->Viewport.Height;
4568          break;
4569       case GL_ZOOM_X:
4570          params[0] = IROUND(ctx->Pixel.ZoomX);
4571          break;
4572       case GL_ZOOM_Y:
4573          params[0] = IROUND(ctx->Pixel.ZoomY);
4574          break;
4575       case GL_VERTEX_ARRAY:
4576          params[0] = BOOLEAN_TO_INT(ctx->Array.Vertex.Enabled);
4577          break;
4578       case GL_VERTEX_ARRAY_SIZE:
4579          params[0] = ctx->Array.Vertex.Size;
4580          break;
4581       case GL_VERTEX_ARRAY_TYPE:
4582          params[0] = ENUM_TO_INT(ctx->Array.Vertex.Type);
4583          break;
4584       case GL_VERTEX_ARRAY_STRIDE:
4585          params[0] = ctx->Array.Vertex.Stride;
4586          break;
4587       case GL_VERTEX_ARRAY_COUNT_EXT:
4588          params[0] = 0;
4589          break;
4590       case GL_NORMAL_ARRAY:
4591          params[0] = ENUM_TO_INT(ctx->Array.Normal.Enabled);
4592          break;
4593       case GL_NORMAL_ARRAY_TYPE:
4594          params[0] = ENUM_TO_INT(ctx->Array.Normal.Type);
4595          break;
4596       case GL_NORMAL_ARRAY_STRIDE:
4597          params[0] = ctx->Array.Normal.Stride;
4598          break;
4599       case GL_NORMAL_ARRAY_COUNT_EXT:
4600          params[0] = 0;
4601          break;
4602       case GL_COLOR_ARRAY:
4603          params[0] = BOOLEAN_TO_INT(ctx->Array.Color.Enabled);
4604          break;
4605       case GL_COLOR_ARRAY_SIZE:
4606          params[0] = ctx->Array.Color.Size;
4607          break;
4608       case GL_COLOR_ARRAY_TYPE:
4609          params[0] = ENUM_TO_INT(ctx->Array.Color.Type);
4610          break;
4611       case GL_COLOR_ARRAY_STRIDE:
4612          params[0] = ctx->Array.Color.Stride;
4613          break;
4614       case GL_COLOR_ARRAY_COUNT_EXT:
4615          params[0] = 0;
4616          break;
4617       case GL_INDEX_ARRAY:
4618          params[0] = BOOLEAN_TO_INT(ctx->Array.Index.Enabled);
4619          break;
4620       case GL_INDEX_ARRAY_TYPE:
4621          params[0] = ENUM_TO_INT(ctx->Array.Index.Type);
4622          break;
4623       case GL_INDEX_ARRAY_STRIDE:
4624          params[0] = ctx->Array.Index.Stride;
4625          break;
4626       case GL_INDEX_ARRAY_COUNT_EXT:
4627          params[0] = 0;
4628          break;
4629       case GL_TEXTURE_COORD_ARRAY:
4630          params[0] = BOOLEAN_TO_INT(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled);
4631          break;
4632       case GL_TEXTURE_COORD_ARRAY_SIZE:
4633          params[0] = ctx->Array.TexCoord[ctx->Array.ActiveTexture].Size;
4634          break;
4635       case GL_TEXTURE_COORD_ARRAY_TYPE:
4636          params[0] = ENUM_TO_INT(ctx->Array.TexCoord[ctx->Array.ActiveTexture].Type);
4637          break;
4638       case GL_TEXTURE_COORD_ARRAY_STRIDE:
4639          params[0] = ctx->Array.TexCoord[ctx->Array.ActiveTexture].Stride;
4640          break;
4641       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
4642          params[0] = 0;
4643          break;
4644       case GL_EDGE_FLAG_ARRAY:
4645          params[0] = BOOLEAN_TO_INT(ctx->Array.EdgeFlag.Enabled);
4646          break;
4647       case GL_EDGE_FLAG_ARRAY_STRIDE:
4648          params[0] = ctx->Array.EdgeFlag.Stride;
4649          break;
4650       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
4651          params[0] = 0;
4652          break;
4653       case GL_MAX_TEXTURE_UNITS_ARB:
4654          CHECK_EXTENSION_I(ARB_multitexture, pname);
4655          params[0] = MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits);
4656          break;
4657       case GL_ACTIVE_TEXTURE_ARB:
4658          CHECK_EXTENSION_I(ARB_multitexture, pname);
4659          params[0] = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
4660          break;
4661       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
4662          CHECK_EXTENSION_I(ARB_multitexture, pname);
4663          params[0] = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
4664          break;
4665       case GL_TEXTURE_CUBE_MAP_ARB:
4666          CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
4667          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
4668          break;
4669       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
4670          CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
4671          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name;
4672          break;
4673       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
4674          CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
4675          params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
4676          break;
4677       case GL_TEXTURE_COMPRESSION_HINT_ARB:
4678          CHECK_EXTENSION_I(ARB_texture_compression, pname);
4679          params[0] = ctx->Hint.TextureCompression;
4680          break;
4681       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
4682          CHECK_EXTENSION_I(ARB_texture_compression, pname);
4683          params[0] = _mesa_get_compressed_formats(ctx, NULL);
4684          break;
4685       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
4686          CHECK_EXTENSION_I(ARB_texture_compression, pname);
4687          {
4688          GLint formats[100];
4689          GLuint i, n = _mesa_get_compressed_formats(ctx, formats);
4690          for (i = 0; i < n; i++)
4691             params[i] = ENUM_TO_BOOLEAN(formats[i]);
4692          }
4693          break;
4694       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
4695          CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname);
4696          params[0] = ctx->Array.LockFirst;
4697          break;
4698       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
4699          CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname);
4700          params[0] = ctx->Array.LockCount;
4701          break;
4702       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
4703          {
4704          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
4705          params[0] = IROUND(matrix[0]);
4706          params[1] = IROUND(matrix[4]);
4707          params[2] = IROUND(matrix[8]);
4708          params[3] = IROUND(matrix[12]);
4709          params[4] = IROUND(matrix[1]);
4710          params[5] = IROUND(matrix[5]);
4711          params[6] = IROUND(matrix[9]);
4712          params[7] = IROUND(matrix[13]);
4713          params[8] = IROUND(matrix[2]);
4714          params[9] = IROUND(matrix[6]);
4715          params[10] = IROUND(matrix[10]);
4716          params[11] = IROUND(matrix[14]);
4717          params[12] = IROUND(matrix[3]);
4718          params[13] = IROUND(matrix[7]);
4719          params[14] = IROUND(matrix[11]);
4720          params[15] = IROUND(matrix[15]);
4721          }
4722          break;
4723       case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
4724          {
4725          const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
4726          params[0] = IROUND(matrix[0]);
4727          params[1] = IROUND(matrix[4]);
4728          params[2] = IROUND(matrix[8]);
4729          params[3] = IROUND(matrix[12]);
4730          params[4] = IROUND(matrix[1]);
4731          params[5] = IROUND(matrix[5]);
4732          params[6] = IROUND(matrix[9]);
4733          params[7] = IROUND(matrix[13]);
4734          params[8] = IROUND(matrix[2]);
4735          params[9] = IROUND(matrix[6]);
4736          params[10] = IROUND(matrix[10]);
4737          params[11] = IROUND(matrix[14]);
4738          params[12] = IROUND(matrix[3]);
4739          params[13] = IROUND(matrix[7]);
4740          params[14] = IROUND(matrix[11]);
4741          params[15] = IROUND(matrix[15]);
4742          }
4743          break;
4744       case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
4745          {
4746          const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
4747          params[0] = IROUND(matrix[0]);
4748          params[1] = IROUND(matrix[4]);
4749          params[2] = IROUND(matrix[8]);
4750          params[3] = IROUND(matrix[12]);
4751          params[4] = IROUND(matrix[1]);
4752          params[5] = IROUND(matrix[5]);
4753          params[6] = IROUND(matrix[9]);
4754          params[7] = IROUND(matrix[13]);
4755          params[8] = IROUND(matrix[2]);
4756          params[9] = IROUND(matrix[6]);
4757          params[10] = IROUND(matrix[10]);
4758          params[11] = IROUND(matrix[14]);
4759          params[12] = IROUND(matrix[3]);
4760          params[13] = IROUND(matrix[7]);
4761          params[14] = IROUND(matrix[11]);
4762          params[15] = IROUND(matrix[15]);
4763          }
4764          break;
4765       case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
4766          {
4767          const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
4768          params[0] = IROUND(matrix[0]);
4769          params[1] = IROUND(matrix[4]);
4770          params[2] = IROUND(matrix[8]);
4771          params[3] = IROUND(matrix[12]);
4772          params[4] = IROUND(matrix[1]);
4773          params[5] = IROUND(matrix[5]);
4774          params[6] = IROUND(matrix[9]);
4775          params[7] = IROUND(matrix[13]);
4776          params[8] = IROUND(matrix[2]);
4777          params[9] = IROUND(matrix[6]);
4778          params[10] = IROUND(matrix[10]);
4779          params[11] = IROUND(matrix[14]);
4780          params[12] = IROUND(matrix[3]);
4781          params[13] = IROUND(matrix[7]);
4782          params[14] = IROUND(matrix[11]);
4783          params[15] = IROUND(matrix[15]);
4784          }
4785          break;
4786       case GL_OCCLUSION_TEST_HP:
4787          CHECK_EXTENSION_I(HP_occlusion_test, pname);
4788          params[0] = BOOLEAN_TO_INT(ctx->Depth.OcclusionTest);
4789          break;
4790       case GL_OCCLUSION_TEST_RESULT_HP:
4791          CHECK_EXTENSION_I(HP_occlusion_test, pname);
4792          {
4793          if (ctx->Depth.OcclusionTest)
4794             params[0] = ctx->OcclusionResult;
4795          else
4796             params[0] = ctx->OcclusionResultSaved;
4797          /* reset flag now */
4798          ctx->OcclusionResult = GL_FALSE;
4799          ctx->OcclusionResultSaved = GL_FALSE;
4800          return;
4801          }
4802          break;
4803       case GL_PIXEL_TEXTURE_SGIS:
4804          CHECK_EXTENSION_I(SGIS_pixel_texture, pname);
4805          params[0] = BOOLEAN_TO_INT(ctx->Pixel.PixelTextureEnabled);
4806          break;
4807       case GL_PIXEL_TEX_GEN_SGIX:
4808          CHECK_EXTENSION_I(SGIX_pixel_texture, pname);
4809          params[0] = BOOLEAN_TO_INT(ctx->Pixel.PixelTextureEnabled);
4810          break;
4811       case GL_PIXEL_TEX_GEN_MODE_SGIX:
4812          CHECK_EXTENSION_I(SGIX_pixel_texture, pname);
4813          params[0] = ENUM_TO_INT(pixel_texgen_mode(ctx));
4814          break;
4815       case GL_COLOR_MATRIX_SGI:
4816          {
4817          const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
4818          params[0] = IROUND(matrix[0]);
4819          params[1] = IROUND(matrix[1]);
4820          params[2] = IROUND(matrix[2]);
4821          params[3] = IROUND(matrix[3]);
4822          params[4] = IROUND(matrix[4]);
4823          params[5] = IROUND(matrix[5]);
4824          params[6] = IROUND(matrix[6]);
4825          params[7] = IROUND(matrix[7]);
4826          params[8] = IROUND(matrix[8]);
4827          params[9] = IROUND(matrix[9]);
4828          params[10] = IROUND(matrix[10]);
4829          params[11] = IROUND(matrix[11]);
4830          params[12] = IROUND(matrix[12]);
4831          params[13] = IROUND(matrix[13]);
4832          params[14] = IROUND(matrix[14]);
4833          params[15] = IROUND(matrix[15]);
4834          }
4835          break;
4836       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
4837          params[0] = ctx->ColorMatrixStack.Depth + 1;
4838          break;
4839       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
4840          params[0] = MAX_COLOR_STACK_DEPTH;
4841          break;
4842       case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
4843          params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[0]);
4844          break;
4845       case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
4846          params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[1]);
4847          break;
4848       case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
4849          params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[2]);
4850          break;
4851       case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
4852          params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[3]);
4853          break;
4854       case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
4855          params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[0]);
4856          break;
4857       case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
4858          params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[1]);
4859          break;
4860       case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
4861          params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[2]);
4862          break;
4863       case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
4864          params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[3]);
4865          break;
4866       case GL_CONVOLUTION_1D_EXT:
4867          CHECK_EXTENSION_I(EXT_convolution, pname);
4868          params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution1DEnabled);
4869          break;
4870       case GL_CONVOLUTION_2D_EXT:
4871          CHECK_EXTENSION_I(EXT_convolution, pname);
4872          params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution2DEnabled);
4873          break;
4874       case GL_SEPARABLE_2D_EXT:
4875          CHECK_EXTENSION_I(EXT_convolution, pname);
4876          params[0] = BOOLEAN_TO_INT(ctx->Pixel.Separable2DEnabled);
4877          break;
4878       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
4879          CHECK_EXTENSION_I(EXT_convolution, pname);
4880          params[0] = IROUND(ctx->Pixel.PostConvolutionScale[0]);
4881          break;
4882       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
4883          CHECK_EXTENSION_I(EXT_convolution, pname);
4884          params[0] = IROUND(ctx->Pixel.PostConvolutionScale[1]);
4885          break;
4886       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
4887          CHECK_EXTENSION_I(EXT_convolution, pname);
4888          params[0] = IROUND(ctx->Pixel.PostConvolutionScale[2]);
4889          break;
4890       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
4891          CHECK_EXTENSION_I(EXT_convolution, pname);
4892          params[0] = IROUND(ctx->Pixel.PostConvolutionScale[3]);
4893          break;
4894       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
4895          CHECK_EXTENSION_I(EXT_convolution, pname);
4896          params[0] = IROUND(ctx->Pixel.PostConvolutionBias[0]);
4897          break;
4898       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
4899          CHECK_EXTENSION_I(EXT_convolution, pname);
4900          params[0] = IROUND(ctx->Pixel.PostConvolutionBias[1]);
4901          break;
4902       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
4903          CHECK_EXTENSION_I(EXT_convolution, pname);
4904          params[0] = IROUND(ctx->Pixel.PostConvolutionBias[2]);
4905          break;
4906       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
4907          CHECK_EXTENSION_I(EXT_convolution, pname);
4908          params[0] = IROUND(ctx->Pixel.PostConvolutionBias[3]);
4909          break;
4910       case GL_HISTOGRAM:
4911          CHECK_EXTENSION_I(EXT_histogram, pname);
4912          params[0] = BOOLEAN_TO_INT(ctx->Pixel.HistogramEnabled);
4913          break;
4914       case GL_MINMAX:
4915          CHECK_EXTENSION_I(EXT_histogram, pname);
4916          params[0] = BOOLEAN_TO_INT(ctx->Pixel.MinMaxEnabled);
4917          break;
4918       case GL_COLOR_TABLE_SGI:
4919          CHECK_EXTENSION_I(SGI_color_table, pname);
4920          params[0] = BOOLEAN_TO_INT(ctx->Pixel.ColorTableEnabled);
4921          break;
4922       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
4923          CHECK_EXTENSION_I(SGI_color_table, pname);
4924          params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostConvolutionColorTableEnabled);
4925          break;
4926       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
4927          CHECK_EXTENSION_I(SGI_color_table, pname);
4928          params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostColorMatrixColorTableEnabled);
4929          break;
4930       case GL_TEXTURE_COLOR_TABLE_SGI:
4931          CHECK_EXTENSION_I(SGI_texture_color_table, pname);
4932          params[0] = BOOLEAN_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
4933          break;
4934       case GL_COLOR_SUM_EXT:
4935          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4936          params[0] = BOOLEAN_TO_INT(ctx->Fog.ColorSumEnabled);
4937          break;
4938       case GL_CURRENT_SECONDARY_COLOR_EXT:
4939          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4940          {
4941          FLUSH_CURRENT(ctx, 0);
4942          params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
4943          params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
4944          params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
4945          params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
4946          }
4947          break;
4948       case GL_SECONDARY_COLOR_ARRAY_EXT:
4949          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4950          params[0] = BOOLEAN_TO_INT(ctx->Array.SecondaryColor.Enabled);
4951          break;
4952       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
4953          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4954          params[0] = ENUM_TO_INT(ctx->Array.SecondaryColor.Type);
4955          break;
4956       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
4957          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4958          params[0] = ctx->Array.SecondaryColor.Stride;
4959          break;
4960       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
4961          CHECK_EXTENSION_I(EXT_secondary_color, pname);
4962          params[0] = ctx->Array.SecondaryColor.Size;
4963          break;
4964       case GL_CURRENT_FOG_COORDINATE_EXT:
4965          CHECK_EXTENSION_I(EXT_fog_coord, pname);
4966          {
4967          FLUSH_CURRENT(ctx, 0);
4968          params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
4969          }
4970          break;
4971       case GL_FOG_COORDINATE_ARRAY_EXT:
4972          CHECK_EXTENSION_I(EXT_fog_coord, pname);
4973          params[0] = BOOLEAN_TO_INT(ctx->Array.FogCoord.Enabled);
4974          break;
4975       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
4976          CHECK_EXTENSION_I(EXT_fog_coord, pname);
4977          params[0] = ENUM_TO_INT(ctx->Array.FogCoord.Type);
4978          break;
4979       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
4980          CHECK_EXTENSION_I(EXT_fog_coord, pname);
4981          params[0] = ctx->Array.FogCoord.Stride;
4982          break;
4983       case GL_FOG_COORDINATE_SOURCE_EXT:
4984          CHECK_EXTENSION_I(EXT_fog_coord, pname);
4985          params[0] = ENUM_TO_INT(ctx->Fog.FogCoordinateSource);
4986          break;
4987       case GL_MAX_TEXTURE_LOD_BIAS_EXT:
4988          CHECK_EXTENSION_I(EXT_texture_lod_bias, pname);
4989          params[0] = IROUND(ctx->Const.MaxTextureLodBias);
4990          break;
4991       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
4992          CHECK_EXTENSION_I(EXT_texture_filter_anisotropic, pname);
4993          params[0] = IROUND(ctx->Const.MaxTextureMaxAnisotropy);
4994          break;
4995       case GL_MULTISAMPLE_ARB:
4996          CHECK_EXTENSION_I(ARB_multisample, pname);
4997          params[0] = BOOLEAN_TO_INT(ctx->Multisample.Enabled);
4998          break;
4999       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
5000          CHECK_EXTENSION_I(ARB_multisample, pname);
5001          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToCoverage);
5002          break;
5003       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
5004          CHECK_EXTENSION_I(ARB_multisample, pname);
5005          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToOne);
5006          break;
5007       case GL_SAMPLE_COVERAGE_ARB:
5008          CHECK_EXTENSION_I(ARB_multisample, pname);
5009          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverage);
5010          break;
5011       case GL_SAMPLE_COVERAGE_VALUE_ARB:
5012          CHECK_EXTENSION_I(ARB_multisample, pname);
5013          params[0] = IROUND(ctx->Multisample.SampleCoverageValue);
5014          break;
5015       case GL_SAMPLE_COVERAGE_INVERT_ARB:
5016          CHECK_EXTENSION_I(ARB_multisample, pname);
5017          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverageInvert);
5018          break;
5019       case GL_SAMPLE_BUFFERS_ARB:
5020          CHECK_EXTENSION_I(ARB_multisample, pname);
5021          params[0] = 0;
5022          break;
5023       case GL_SAMPLES_ARB:
5024          CHECK_EXTENSION_I(ARB_multisample, pname);
5025          params[0] = 0;
5026          break;
5027       case GL_RASTER_POSITION_UNCLIPPED_IBM:
5028          CHECK_EXTENSION_I(IBM_rasterpos_clip, pname);
5029          params[0] = BOOLEAN_TO_INT(ctx->Transform.RasterPositionUnclipped);
5030          break;
5031       case GL_POINT_SPRITE_NV:
5032          CHECK_EXTENSION_I(NV_point_sprite, pname);
5033          params[0] = BOOLEAN_TO_INT(ctx->Point.PointSprite);
5034          break;
5035       case GL_POINT_SPRITE_R_MODE_NV:
5036          CHECK_EXTENSION_I(NV_point_sprite, pname);
5037          params[0] = ENUM_TO_INT(ctx->Point.SpriteRMode);
5038          break;
5039       case GL_POINT_SPRITE_COORD_ORIGIN:
5040          CHECK_EXTENSION_I(NV_point_sprite, pname);
5041          params[0] = ENUM_TO_INT(ctx->Point.SpriteOrigin);
5042          break;
5043       case GL_GENERATE_MIPMAP_HINT_SGIS:
5044          CHECK_EXTENSION_I(SGIS_generate_mipmap, pname);
5045          params[0] = ENUM_TO_INT(ctx->Hint.GenerateMipmap);
5046          break;
5047       case GL_VERTEX_PROGRAM_NV:
5048          CHECK_EXTENSION_I(NV_vertex_program, pname);
5049          params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.Enabled);
5050          break;
5051       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
5052          CHECK_EXTENSION_I(NV_vertex_program, pname);
5053          params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.PointSizeEnabled);
5054          break;
5055       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
5056          CHECK_EXTENSION_I(NV_vertex_program, pname);
5057          params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.TwoSideEnabled);
5058          break;
5059       case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
5060          CHECK_EXTENSION_I(NV_vertex_program, pname);
5061          params[0] = ctx->Const.MaxProgramMatrixStackDepth;
5062          break;
5063       case GL_MAX_TRACK_MATRICES_NV:
5064          CHECK_EXTENSION_I(NV_vertex_program, pname);
5065          params[0] = ctx->Const.MaxProgramMatrices;
5066          break;
5067       case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
5068          CHECK_EXTENSION_I(NV_vertex_program, pname);
5069          params[0] = BOOLEAN_TO_INT(ctx->CurrentStack->Depth + 1);
5070          break;
5071       case GL_CURRENT_MATRIX_NV:
5072          CHECK_EXTENSION_I(NV_vertex_program, pname);
5073          {
5074          const GLfloat *matrix = ctx->CurrentStack->Top->m;
5075          params[0] = IROUND(matrix[0]);
5076          params[1] = IROUND(matrix[1]);
5077          params[2] = IROUND(matrix[2]);
5078          params[3] = IROUND(matrix[3]);
5079          params[4] = IROUND(matrix[4]);
5080          params[5] = IROUND(matrix[5]);
5081          params[6] = IROUND(matrix[6]);
5082          params[7] = IROUND(matrix[7]);
5083          params[8] = IROUND(matrix[8]);
5084          params[9] = IROUND(matrix[9]);
5085          params[10] = IROUND(matrix[10]);
5086          params[11] = IROUND(matrix[11]);
5087          params[12] = IROUND(matrix[12]);
5088          params[13] = IROUND(matrix[13]);
5089          params[14] = IROUND(matrix[14]);
5090          params[15] = IROUND(matrix[15]);
5091          }
5092          break;
5093       case GL_VERTEX_PROGRAM_BINDING_NV:
5094          CHECK_EXTENSION_I(NV_vertex_program, pname);
5095          params[0] = (ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
5096          break;
5097       case GL_PROGRAM_ERROR_POSITION_NV:
5098          CHECK_EXTENSION_I(NV_vertex_program, pname);
5099          params[0] = ctx->Program.ErrorPos;
5100          break;
5101       case GL_VERTEX_ATTRIB_ARRAY0_NV:
5102          CHECK_EXTENSION_I(NV_vertex_program, pname);
5103          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[0].Enabled);
5104          break;
5105       case GL_VERTEX_ATTRIB_ARRAY1_NV:
5106          CHECK_EXTENSION_I(NV_vertex_program, pname);
5107          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[1].Enabled);
5108          break;
5109       case GL_VERTEX_ATTRIB_ARRAY2_NV:
5110          CHECK_EXTENSION_I(NV_vertex_program, pname);
5111          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[2].Enabled);
5112          break;
5113       case GL_VERTEX_ATTRIB_ARRAY3_NV:
5114          CHECK_EXTENSION_I(NV_vertex_program, pname);
5115          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[3].Enabled);
5116          break;
5117       case GL_VERTEX_ATTRIB_ARRAY4_NV:
5118          CHECK_EXTENSION_I(NV_vertex_program, pname);
5119          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[4].Enabled);
5120          break;
5121       case GL_VERTEX_ATTRIB_ARRAY5_NV:
5122          CHECK_EXTENSION_I(NV_vertex_program, pname);
5123          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[5].Enabled);
5124          break;
5125       case GL_VERTEX_ATTRIB_ARRAY6_NV:
5126          CHECK_EXTENSION_I(NV_vertex_program, pname);
5127          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[6].Enabled);
5128          break;
5129       case GL_VERTEX_ATTRIB_ARRAY7_NV:
5130          CHECK_EXTENSION_I(NV_vertex_program, pname);
5131          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[7].Enabled);
5132          break;
5133       case GL_VERTEX_ATTRIB_ARRAY8_NV:
5134          CHECK_EXTENSION_I(NV_vertex_program, pname);
5135          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[8].Enabled);
5136          break;
5137       case GL_VERTEX_ATTRIB_ARRAY9_NV:
5138          CHECK_EXTENSION_I(NV_vertex_program, pname);
5139          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[9].Enabled);
5140          break;
5141       case GL_VERTEX_ATTRIB_ARRAY10_NV:
5142          CHECK_EXTENSION_I(NV_vertex_program, pname);
5143          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[10].Enabled);
5144          break;
5145       case GL_VERTEX_ATTRIB_ARRAY11_NV:
5146          CHECK_EXTENSION_I(NV_vertex_program, pname);
5147          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[11].Enabled);
5148          break;
5149       case GL_VERTEX_ATTRIB_ARRAY12_NV:
5150          CHECK_EXTENSION_I(NV_vertex_program, pname);
5151          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[12].Enabled);
5152          break;
5153       case GL_VERTEX_ATTRIB_ARRAY13_NV:
5154          CHECK_EXTENSION_I(NV_vertex_program, pname);
5155          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[13].Enabled);
5156          break;
5157       case GL_VERTEX_ATTRIB_ARRAY14_NV:
5158          CHECK_EXTENSION_I(NV_vertex_program, pname);
5159          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[14].Enabled);
5160          break;
5161       case GL_VERTEX_ATTRIB_ARRAY15_NV:
5162          CHECK_EXTENSION_I(NV_vertex_program, pname);
5163          params[0] = BOOLEAN_TO_INT(ctx->Array.VertexAttrib[15].Enabled);
5164          break;
5165       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
5166          CHECK_EXTENSION_I(NV_vertex_program, pname);
5167          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[0]);
5168          break;
5169       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
5170          CHECK_EXTENSION_I(NV_vertex_program, pname);
5171          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[1]);
5172          break;
5173       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
5174          CHECK_EXTENSION_I(NV_vertex_program, pname);
5175          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[2]);
5176          break;
5177       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
5178          CHECK_EXTENSION_I(NV_vertex_program, pname);
5179          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[3]);
5180          break;
5181       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
5182          CHECK_EXTENSION_I(NV_vertex_program, pname);
5183          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[4]);
5184          break;
5185       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
5186          CHECK_EXTENSION_I(NV_vertex_program, pname);
5187          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[5]);
5188          break;
5189       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
5190          CHECK_EXTENSION_I(NV_vertex_program, pname);
5191          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[6]);
5192          break;
5193       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
5194          CHECK_EXTENSION_I(NV_vertex_program, pname);
5195          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[7]);
5196          break;
5197       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
5198          CHECK_EXTENSION_I(NV_vertex_program, pname);
5199          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[8]);
5200          break;
5201       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
5202          CHECK_EXTENSION_I(NV_vertex_program, pname);
5203          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[9]);
5204          break;
5205       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
5206          CHECK_EXTENSION_I(NV_vertex_program, pname);
5207          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[10]);
5208          break;
5209       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
5210          CHECK_EXTENSION_I(NV_vertex_program, pname);
5211          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[11]);
5212          break;
5213       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
5214          CHECK_EXTENSION_I(NV_vertex_program, pname);
5215          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[12]);
5216          break;
5217       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
5218          CHECK_EXTENSION_I(NV_vertex_program, pname);
5219          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[13]);
5220          break;
5221       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
5222          CHECK_EXTENSION_I(NV_vertex_program, pname);
5223          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[14]);
5224          break;
5225       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
5226          CHECK_EXTENSION_I(NV_vertex_program, pname);
5227          params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[15]);
5228          break;
5229       case GL_FRAGMENT_PROGRAM_NV:
5230          CHECK_EXTENSION_I(NV_fragment_program, pname);
5231          params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
5232          break;
5233       case GL_MAX_TEXTURE_COORDS_NV:
5234          CHECK_EXTENSION_I(NV_fragment_program, pname);
5235          params[0] = ctx->Const.MaxTextureCoordUnits;
5236          break;
5237       case GL_MAX_TEXTURE_IMAGE_UNITS_NV:
5238          CHECK_EXTENSION_I(NV_fragment_program, pname);
5239          params[0] = ctx->Const.MaxTextureImageUnits;
5240          break;
5241       case GL_FRAGMENT_PROGRAM_BINDING_NV:
5242          CHECK_EXTENSION_I(NV_fragment_program, pname);
5243          params[0] = ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;
5244          break;
5245       case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
5246          CHECK_EXTENSION_I(NV_fragment_program, pname);
5247          params[0] = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
5248          break;
5249       case GL_TEXTURE_RECTANGLE_NV:
5250          CHECK_EXTENSION_I(NV_texture_rectangle, pname);
5251          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
5252          break;
5253       case GL_TEXTURE_BINDING_RECTANGLE_NV:
5254          CHECK_EXTENSION_I(NV_texture_rectangle, pname);
5255          params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name;
5256          break;
5257       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
5258          CHECK_EXTENSION_I(NV_texture_rectangle, pname);
5259          params[0] = ctx->Const.MaxTextureRectSize;
5260          break;
5261       case GL_STENCIL_TEST_TWO_SIDE_EXT:
5262          CHECK_EXTENSION_I(EXT_stencil_two_side, pname);
5263          params[0] = BOOLEAN_TO_INT(ctx->Stencil.TestTwoSide);
5264          break;
5265       case GL_ACTIVE_STENCIL_FACE_EXT:
5266          CHECK_EXTENSION_I(EXT_stencil_two_side, pname);
5267          params[0] = ENUM_TO_INT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
5268          break;
5269       case GL_MAX_SHININESS_NV:
5270          CHECK_EXTENSION_I(NV_light_max_exponent, pname);
5271          params[0] = IROUND(ctx->Const.MaxShininess);
5272          break;
5273       case GL_MAX_SPOT_EXPONENT_NV:
5274          CHECK_EXTENSION_I(NV_light_max_exponent, pname);
5275          params[0] = IROUND(ctx->Const.MaxSpotExponent);
5276          break;
5277       case GL_ARRAY_BUFFER_BINDING_ARB:
5278          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5279          params[0] = ctx->Array.ArrayBufferObj->Name;
5280          break;
5281       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
5282          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5283          params[0] = ctx->Array.Vertex.BufferObj->Name;
5284          break;
5285       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
5286          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5287          params[0] = ctx->Array.Normal.BufferObj->Name;
5288          break;
5289       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
5290          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5291          params[0] = ctx->Array.Color.BufferObj->Name;
5292          break;
5293       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
5294          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5295          params[0] = ctx->Array.Index.BufferObj->Name;
5296          break;
5297       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
5298          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5299          params[0] = ctx->Array.TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
5300          break;
5301       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
5302          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5303          params[0] = ctx->Array.EdgeFlag.BufferObj->Name;
5304          break;
5305       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
5306          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5307          params[0] = ctx->Array.SecondaryColor.BufferObj->Name;
5308          break;
5309       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
5310          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5311          params[0] = ctx->Array.FogCoord.BufferObj->Name;
5312          break;
5313       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
5314          CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname);
5315          params[0] = ctx->Array.ElementArrayBufferObj->Name;
5316          break;
5317       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
5318          CHECK_EXTENSION_I(EXT_pixel_buffer_object, pname);
5319          params[0] = ctx->Pack.BufferObj->Name;
5320          break;
5321       case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
5322          CHECK_EXTENSION_I(EXT_pixel_buffer_object, pname);
5323          params[0] = ctx->Unpack.BufferObj->Name;
5324          break;
5325       case GL_MAX_VERTEX_ATTRIBS_ARB:
5326          CHECK_EXTENSION_I(ARB_vertex_program, pname);
5327          params[0] = ctx->Const.MaxVertexProgramAttribs;
5328          break;
5329       case GL_FRAGMENT_PROGRAM_ARB:
5330          CHECK_EXTENSION_I(ARB_fragment_program, pname);
5331          params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
5332          break;
5333       case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
5334          CHECK_EXTENSION_I(ARB_fragment_program, pname);
5335          {
5336          const GLfloat *matrix = ctx->CurrentStack->Top->m;
5337          params[0] = IROUND(matrix[0]);
5338          params[1] = IROUND(matrix[4]);
5339          params[2] = IROUND(matrix[8]);
5340          params[3] = IROUND(matrix[12]);
5341          params[4] = IROUND(matrix[1]);
5342          params[5] = IROUND(matrix[5]);
5343          params[6] = IROUND(matrix[9]);
5344          params[7] = IROUND(matrix[13]);
5345          params[8] = IROUND(matrix[2]);
5346          params[9] = IROUND(matrix[6]);
5347          params[10] = IROUND(matrix[10]);
5348          params[11] = IROUND(matrix[14]);
5349          params[12] = IROUND(matrix[3]);
5350          params[13] = IROUND(matrix[7]);
5351          params[14] = IROUND(matrix[11]);
5352          params[15] = IROUND(matrix[15]);
5353          }
5354          break;
5355       case GL_DEPTH_BOUNDS_TEST_EXT:
5356          CHECK_EXTENSION_I(EXT_depth_bounds_test, pname);
5357          params[0] = BOOLEAN_TO_INT(ctx->Depth.BoundsTest);
5358          break;
5359       case GL_DEPTH_BOUNDS_EXT:
5360          CHECK_EXTENSION_I(EXT_depth_bounds_test, pname);
5361          params[0] = IROUND(ctx->Depth.BoundsMin);
5362          params[1] = IROUND(ctx->Depth.BoundsMax);
5363          break;
5364       case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
5365          CHECK_EXTENSION_I(MESA_program_debug, pname);
5366          params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.CallbackEnabled);
5367          break;
5368       case GL_VERTEX_PROGRAM_CALLBACK_MESA:
5369          CHECK_EXTENSION_I(MESA_program_debug, pname);
5370          params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.CallbackEnabled);
5371          break;
5372       case GL_FRAGMENT_PROGRAM_POSITION_MESA:
5373          CHECK_EXTENSION_I(MESA_program_debug, pname);
5374          params[0] = ctx->FragmentProgram.CurrentPosition;
5375          break;
5376       case GL_VERTEX_PROGRAM_POSITION_MESA:
5377          CHECK_EXTENSION_I(MESA_program_debug, pname);
5378          params[0] = ctx->VertexProgram.CurrentPosition;
5379          break;
5380       case GL_MAX_DRAW_BUFFERS_ARB:
5381          CHECK_EXTENSION_I(ARB_draw_buffers, pname);
5382          params[0] = ctx->Const.MaxDrawBuffers;
5383          break;
5384       case GL_DRAW_BUFFER0_ARB:
5385          CHECK_EXTENSION_I(ARB_draw_buffers, pname);
5386          params[0] = ENUM_TO_INT(ctx->Color.DrawBuffer[0]);
5387          break;
5388       case GL_DRAW_BUFFER1_ARB:
5389          CHECK_EXTENSION_I(ARB_draw_buffers, pname);
5390          {
5391          GLenum buffer;
5392          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
5393             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
5394             return;
5395          }
5396          buffer = ctx->Color.DrawBuffer[1];
5397          params[0] = ENUM_TO_INT(buffer);
5398          }
5399          break;
5400       case GL_DRAW_BUFFER2_ARB:
5401          CHECK_EXTENSION_I(ARB_draw_buffers, pname);
5402          {
5403          GLenum buffer;
5404          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
5405             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
5406             return;
5407          }
5408          buffer = ctx->Color.DrawBuffer[2];
5409          params[0] = ENUM_TO_INT(buffer);
5410          }
5411          break;
5412       case GL_DRAW_BUFFER3_ARB:
5413          CHECK_EXTENSION_I(ARB_draw_buffers, pname);
5414          {
5415          GLenum buffer;
5416          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
5417             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
5418             return;
5419          }
5420          buffer = ctx->Color.DrawBuffer[3];
5421          params[0] = ENUM_TO_INT(buffer);
5422          }
5423          break;
5424       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
5425          CHECK_EXTENSION_I(OES_read_format, pname);
5426          params[0] = ctx->Const.ColorReadType;
5427          break;
5428       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
5429          CHECK_EXTENSION_I(OES_read_format, pname);
5430          params[0] = ctx->Const.ColorReadFormat;
5431          break;
5432       case GL_NUM_FRAGMENT_REGISTERS_ATI:
5433          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5434          params[0] = 6;
5435          break;
5436       case GL_NUM_FRAGMENT_CONSTANTS_ATI:
5437          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5438          params[0] = 8;
5439          break;
5440       case GL_NUM_PASSES_ATI:
5441          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5442          params[0] = 2;
5443          break;
5444       case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
5445          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5446          params[0] = 8;
5447          break;
5448       case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
5449          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5450          params[0] = 16;
5451          break;
5452       case GL_COLOR_ALPHA_PAIRING_ATI:
5453          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5454          params[0] = BOOLEAN_TO_INT(GL_TRUE);
5455          break;
5456       case GL_NUM_LOOPBACK_COMPONENTS_ATI:
5457          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5458          params[0] = 3;
5459          break;
5460       case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
5461          CHECK_EXTENSION_I(ATI_fragment_shader, pname);
5462          params[0] = 3;
5463          break;
5464       case GL_STENCIL_BACK_FUNC:
5465          params[0] = ENUM_TO_INT(ctx->Stencil.Function[1]);
5466          break;
5467       case GL_STENCIL_BACK_VALUE_MASK:
5468          params[0] = ctx->Stencil.ValueMask[1];
5469          break;
5470       case GL_STENCIL_BACK_REF:
5471          params[0] = ctx->Stencil.Ref[1];
5472          break;
5473       case GL_STENCIL_BACK_FAIL:
5474          params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[1]);
5475          break;
5476       case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
5477          params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[1]);
5478          break;
5479       case GL_STENCIL_BACK_PASS_DEPTH_PASS:
5480          params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[1]);
5481          break;
5482       default:
5483          _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname);
5484    }
5485 }
5486
5487
5488 void GLAPIENTRY
5489 _mesa_GetDoublev( GLenum pname, GLdouble *params )
5490 {
5491    const GLfloat magic = -1234.5F;
5492    GLfloat values[16];
5493    GLuint i;
5494
5495    if (!params)
5496       return;
5497
5498    /* Init temp array to magic numbers so we can figure out how many values
5499     * are returned by the GetFloatv() call.
5500     */
5501    for (i = 0; i < 16; i++)
5502       values[i] = magic;
5503
5504    _mesa_GetFloatv(pname, values);
5505
5506    for (i = 0; values[i] != magic && i < 16; i++)
5507       params[i] = (GLdouble) values[i];
5508 }
5509