WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/main/dlist.c

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/main/dlist.c – Rev 5564