WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/mesa/main/dlist.c

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

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/main/dlist.c – Rev 4248