WebSVN - shark - Blame - Rev 1618 - /shark/branches/xen/ports/mesa/src/dlist.c

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

Subversion Repositories shark

(root)/shark/branches/xen/ports/mesa/src/dlist.c - Rev 1618