Merge branch 'master' of git+ssh://keithw@git.freedesktop.org/git/mesa/mesa into vbo-0.2

Conflicts:

	src/mesa/array_cache/sources
	src/mesa/drivers/dri/i965/brw_context.c
	src/mesa/drivers/dri/i965/brw_draw.c
	src/mesa/drivers/dri/i965/brw_fallback.c
	src/mesa/drivers/dri/i965/brw_vs_emit.c
	src/mesa/drivers/dri/i965/brw_vs_tnl.c
	src/mesa/drivers/dri/mach64/mach64_context.c
	src/mesa/main/extensions.c
	src/mesa/main/getstring.c
	src/mesa/tnl/sources
	src/mesa/tnl/t_save_api.c
	src/mesa/tnl/t_save_playback.c
	src/mesa/tnl/t_vtx_api.c
	src/mesa/tnl/t_vtx_exec.c
	src/mesa/vbo/vbo_attrib.h
	src/mesa/vbo/vbo_exec_api.c
	src/mesa/vbo/vbo_save_api.c
	src/mesa/vbo/vbo_save_draw.c

14 files changed, 1065 insertions, 1844 deletions

diff --git a/src/mesa/drivers/dri/r300/.gitignore b/src/mesa/drivers/dri/r300/.gitignore
new file mode 100644
index 0000000000..3773d8ea73
--- /dev/null
+++ b/src/mesa/drivers/dri/r300/.gitignore
@@ -0,0 +1,3 @@
+radeon_chipset.h
+radeon_screen.*
+server
diff --git a/src/mesa/drivers/dri/r300/r300_context.h b/src/mesa/drivers/dri/r300/r300_context.h
index 02ffbfcbef..02f8e9107d 100644
--- a/src/mesa/drivers/dri/r300/r300_context.h
+++ b/src/mesa/drivers/dri/r300/r300_context.h
@@ -552,6 +552,7 @@ struct r300_stencilbuffer_state {
 /* Can be tested with colormat currently. */
 #define VSF_MAX_FRAGMENT_TEMPS (14)
 
+#define STATE_R300_WINDOW_DIMENSION (STATE_INTERNAL_DRIVER+0)
 
 struct r300_vertex_shader_fragment {
 	int length;
@@ -595,7 +596,8 @@ struct r300_vertex_shader_state {
 	
 extern int hw_tcl_on;
 
-#define CURRENT_VERTEX_SHADER(ctx) (ctx->VertexProgram._Current)
+//#define CURRENT_VERTEX_SHADER(ctx) (ctx->VertexProgram._Current)
+#define CURRENT_VERTEX_SHADER(ctx) (R300_CONTEXT(ctx)->selected_vp)
 
 /* Should but doesnt work */
 //#define CURRENT_VERTEX_SHADER(ctx) (R300_CONTEXT(ctx)->curr_vp)
@@ -610,15 +612,22 @@ extern int hw_tcl_on;
 /* r300_vertex_shader_state and r300_vertex_program should probably be merged together someday.
  * Keeping them them seperate for now should ensure fixed pipeline keeps functioning properly.
  */	
+
+struct r300_vertex_program_key {
+	GLuint InputsRead;
+	GLuint OutputsWritten;
+};
+
 struct r300_vertex_program {
-	struct gl_vertex_program mesa_program; /* Must be first */
+	struct r300_vertex_program *next;
+	struct r300_vertex_program_key key;
 	int translated;
 	
 	struct r300_vertex_shader_fragment program;
-	struct r300_vertex_shader_fragment params;
 	
 	int pos_end;
 	int num_temporaries; /* Number of temp vars used by program */
+	int wpos_idx;
 	int inputs[VERT_ATTRIB_MAX];
 	int outputs[VERT_RESULT_MAX];
 	int native;
@@ -626,6 +635,12 @@ struct r300_vertex_program {
 	int use_ref_count;
 };
 
+struct r300_vertex_program_cont {
+	struct gl_vertex_program mesa_program; /* Must be first */
+	struct r300_vertex_shader_fragment params;
+	struct r300_vertex_program *progs;
+};
+
 #define PFS_MAX_ALU_INST	64
 #define PFS_MAX_TEX_INST	64
 #define PFS_MAX_TEX_INDIRECT 4
@@ -800,6 +815,7 @@ struct r300_context {
 	struct r300_cmdbuf cmdbuf;
 	struct r300_state state;
 	struct gl_vertex_program *curr_vp;
+	struct r300_vertex_program *selected_vp;
 
 	/* Vertex buffers
 	 */
@@ -857,9 +873,9 @@ extern GLboolean r300CreateContext(const __GLcontextModes * glVisual,
 
 extern int r300_get_num_verts(r300ContextPtr rmesa, int num_verts, int prim);
 
-void r300_translate_vertex_shader(struct r300_vertex_program *vp);
+extern void r300_select_vertex_shader(r300ContextPtr r300);
 extern void r300InitShaderFuncs(struct dd_function_table *functions);
-extern int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program *vp, float *dst);
+extern int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program_cont *vp, float *dst);
 extern int r300Fallback(GLcontext *ctx);
 
 extern void radeon_vb_to_rvb(r300ContextPtr rmesa, struct radeon_vertex_buffer *rvb, struct vertex_buffer *vb);
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.c b/src/mesa/drivers/dri/r300/r300_fragprog.c
index 91ec4f855c..6e85f0b5dd 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.c
@@ -28,14 +28,14 @@
 /*
  * Authors:
  *   Ben Skeggs <darktama@iinet.net.au>
+ *   Jerome Glisse <j.glisse@gmail.com>
  */
 
 /*TODO'S
  *
- * - COS/SIN/SCS/LIT instructions
+ * - COS/SIN/SCS instructions
  * - Depth write, WPOS/FOGC inputs
  * - FogOption
- * - Negate on individual components (implement in swizzle code?)
  * - Verify results of opcodes for accuracy, I've only checked them
  *   in specific cases.
  * - and more...
@@ -51,18 +51,110 @@
 #include "r300_fragprog.h"
 #include "r300_reg.h"
 
+/*
+ * Usefull macros and values
+ */
+#define ERROR(fmt, args...) do {			\
+		fprintf(stderr, "%s::%s(): " fmt "\n",	\
+			__FILE__, __func__, ##args);	\
+		rp->error = GL_TRUE;			\
+	} while(0)
+
 #define PFS_INVAL 0xFFFFFFFF
 #define COMPILE_STATE struct r300_pfs_compile_state *cs = rp->cs
 
-static void dump_program(struct r300_fragment_program *rp);
-static void emit_arith(struct r300_fragment_program *rp, int op,
-				pfs_reg_t dest, int mask,
-				pfs_reg_t src0, pfs_reg_t src1, pfs_reg_t src2,
-				int flags);
+#define SWIZZLE_XYZ		0
+#define SWIZZLE_XXX		1
+#define SWIZZLE_YYY		2
+#define SWIZZLE_ZZZ		3
+#define SWIZZLE_WWW		4
+#define SWIZZLE_YZX		5
+#define SWIZZLE_ZXY		6
+#define SWIZZLE_WZY		7
+#define SWIZZLE_111		8
+#define SWIZZLE_000		9
+#define SWIZZLE_HHH		10
+
+#define swizzle(r, x, y, z, w) do_swizzle(rp, r,		\
+					  ((SWIZZLE_##x<<0)|	\
+					   (SWIZZLE_##y<<3)|	\
+					   (SWIZZLE_##z<<6)|	\
+					   (SWIZZLE_##w<<9)),	\
+					  0)
 
-/***************************************
- * begin: useful data structions for fragment program generation
- ***************************************/
+#define REG_TYPE_INPUT		0
+#define REG_TYPE_OUTPUT		1
+#define REG_TYPE_TEMP		2
+#define REG_TYPE_CONST		3
+
+#define REG_TYPE_SHIFT		0
+#define REG_INDEX_SHIFT		2
+#define REG_VSWZ_SHIFT		8
+#define REG_SSWZ_SHIFT		13
+#define REG_NEGV_SHIFT		18
+#define REG_NEGS_SHIFT		19
+#define REG_ABS_SHIFT		20
+#define REG_NO_USE_SHIFT	21
+#define REG_VALID_SHIFT		22
+
+#define REG_TYPE_MASK		(0x03 << REG_TYPE_SHIFT)
+#define REG_INDEX_MASK		(0x3F << REG_INDEX_SHIFT)
+#define REG_VSWZ_MASK		(0x1F << REG_VSWZ_SHIFT)
+#define REG_SSWZ_MASK		(0x1F << REG_SSWZ_SHIFT)
+#define REG_NEGV_MASK		(0x01 << REG_NEGV_SHIFT)
+#define REG_NEGS_MASK		(0x01 << REG_NEGS_SHIFT)
+#define REG_ABS_MASK		(0x01 << REG_ABS_SHIFT)
+#define REG_NO_USE_MASK		(0x01 << REG_NO_USE_SHIFT)
+#define REG_VALID_MASK		(0x01 << REG_VALID_SHIFT)
+
+#define REG(type, index, vswz, sswz, nouse, valid)			\
+	(((type << REG_TYPE_SHIFT) & REG_TYPE_MASK) |			\
+	 ((index << REG_INDEX_SHIFT) & REG_INDEX_MASK) |		\
+	 ((nouse << REG_NO_USE_SHIFT) & REG_NO_USE_MASK) |		\
+	 ((valid << REG_VALID_SHIFT) & REG_VALID_MASK) |		\
+	 ((vswz << REG_VSWZ_SHIFT) & REG_VSWZ_MASK) |			\
+	 ((sswz << REG_SSWZ_SHIFT) & REG_SSWZ_MASK))
+#define REG_GET_TYPE(reg)						\
+	((reg & REG_TYPE_MASK) >> REG_TYPE_SHIFT)
+#define REG_GET_INDEX(reg)						\
+	((reg & REG_INDEX_MASK) >> REG_INDEX_SHIFT)
+#define REG_GET_VSWZ(reg)						\
+	((reg & REG_VSWZ_MASK) >> REG_VSWZ_SHIFT)
+#define REG_GET_SSWZ(reg)						\
+	((reg & REG_SSWZ_MASK) >> REG_SSWZ_SHIFT)
+#define REG_GET_NO_USE(reg)						\
+	((reg & REG_NO_USE_MASK) >> REG_NO_USE_SHIFT)
+#define REG_GET_VALID(reg)						\
+	((reg & REG_VALID_MASK) >> REG_VALID_SHIFT)
+#define REG_SET_TYPE(reg, type)						\
+	reg = ((reg & ~REG_TYPE_MASK) |					\
+	       ((type << REG_TYPE_SHIFT) & REG_TYPE_MASK))
+#define REG_SET_INDEX(reg, index)					\
+	reg = ((reg & ~REG_INDEX_MASK) |				\
+	       ((index << REG_INDEX_SHIFT) & REG_INDEX_MASK))
+#define REG_SET_VSWZ(reg, vswz)						\
+	reg = ((reg & ~REG_VSWZ_MASK) |					\
+	       ((vswz << REG_VSWZ_SHIFT) & REG_VSWZ_MASK))
+#define REG_SET_SSWZ(reg, sswz)						\
+	reg = ((reg & ~REG_SSWZ_MASK) |					\
+	       ((sswz << REG_SSWZ_SHIFT) & REG_SSWZ_MASK))
+#define REG_SET_NO_USE(reg, nouse)					\
+	reg = ((reg & ~REG_NO_USE_MASK) |				\
+	       ((nouse << REG_NO_USE_SHIFT) & REG_NO_USE_MASK))
+#define REG_SET_VALID(reg, valid)					\
+	reg = ((reg & ~REG_VALID_MASK) |				\
+	       ((valid << REG_VALID_SHIFT) & REG_VALID_MASK))
+#define REG_ABS(reg)							\
+	reg = (reg | REG_ABS_MASK)
+#define REG_NEGV(reg)							\
+	reg = (reg | REG_NEGV_MASK)
+#define REG_NEGS(reg)							\
+	reg = (reg | REG_NEGS_MASK)
+
+
+/*
+ * Datas structures for fragment program generation
+ */
 
 /* description of r300 native hw instructions */
 static const struct {
@@ -86,20 +178,19 @@ static const struct {
 	{ "CMPH", 3, R300_FPI0_OUTC_CMPH, PFS_INVAL },
 };
 
-#define MAKE_SWZ3(x, y, z) (MAKE_SWIZZLE4(SWIZZLE_##x, \
-					  SWIZZLE_##y, \
-					  SWIZZLE_##z, \
-					  SWIZZLE_ZERO))
-
-#define SLOT_VECTOR	(1<<0)
-#define SLOT_SCALAR (1<<3)
-#define SLOT_BOTH	(SLOT_VECTOR|SLOT_SCALAR)
 
 /* vector swizzles r300 can support natively, with a couple of
  * cases we handle specially
  *
- * pfs_reg_t.v_swz/pfs_reg_t.s_swz is an index into this table
- **/
+ * REG_VSWZ/REG_SSWZ is an index into this table
+ */
+#define SLOT_VECTOR	(1<<0)
+#define SLOT_SCALAR	(1<<3)
+#define SLOT_BOTH	(SLOT_VECTOR | SLOT_SCALAR)
+#define MAKE_SWZ3(x, y, z) (MAKE_SWIZZLE4(SWIZZLE_##x, \
+					  SWIZZLE_##y, \
+					  SWIZZLE_##z, \
+					  SWIZZLE_ZERO))
 static const struct r300_pfs_swizzle {
 	GLuint hash;	/* swizzle value this matches */
 	GLuint base;	/* base value for hw swizzle */
@@ -120,39 +211,29 @@ static const struct r300_pfs_swizzle {
 	{ PFS_INVAL, R300_FPI0_ARGC_HALF, 0, 0},
 	{ PFS_INVAL, 0, 0, 0},
 };
-#define SWIZZLE_XYZ		0
-#define SWIZZLE_XXX		1
-#define SWIZZLE_YYY		2
-#define SWIZZLE_ZZZ		3
-#define SWIZZLE_WWW		4
-#define SWIZZLE_YZX		5
-#define SWIZZLE_ZXY		6
-#define SWIZZLE_WZY		7
-#define SWIZZLE_111		8
-#define SWIZZLE_000		9
-#define SWIZZLE_HHH		10
 
+/* used during matching of non-native swizzles */
 #define SWZ_X_MASK (7 << 0)
 #define SWZ_Y_MASK (7 << 3)
 #define SWZ_Z_MASK (7 << 6)
 #define SWZ_W_MASK (7 << 9)
-/* used during matching of non-native swizzles */
 static const struct {
-	GLuint hash;	/* used to mask matching swizzle components */
+	GLuint hash;		/* used to mask matching swizzle components */
 	int mask;		/* actual outmask */
 	int count;		/* count of components matched */
 } s_mask[] = {
-    { SWZ_X_MASK|SWZ_Y_MASK|SWZ_Z_MASK, 1|2|4, 3},
-    { SWZ_X_MASK|SWZ_Y_MASK, 1|2, 2},
-    { SWZ_X_MASK|SWZ_Z_MASK, 1|4, 2},
-    { SWZ_Y_MASK|SWZ_Z_MASK, 2|4, 2},
-    { SWZ_X_MASK, 1, 1},
-    { SWZ_Y_MASK, 2, 1},
-    { SWZ_Z_MASK, 4, 1},
-    { PFS_INVAL, PFS_INVAL, PFS_INVAL}
+	{ SWZ_X_MASK|SWZ_Y_MASK|SWZ_Z_MASK, 1|2|4, 3},
+	{ SWZ_X_MASK|SWZ_Y_MASK, 1|2, 2},
+	{ SWZ_X_MASK|SWZ_Z_MASK, 1|4, 2},
+	{ SWZ_Y_MASK|SWZ_Z_MASK, 2|4, 2},
+	{ SWZ_X_MASK, 1, 1},
+	{ SWZ_Y_MASK, 2, 1},
+	{ SWZ_Z_MASK, 4, 1},
+	{ PFS_INVAL, PFS_INVAL, PFS_INVAL}
 };
 
 /* mapping from SWIZZLE_* to r300 native values for scalar insns */
+#define SWIZZLE_HALF 6
 static const struct {
 	int base;	/* hw value of swizzle */
 	int stride;	/* difference between SRC0/1/2 */
@@ -166,58 +247,51 @@ static const struct {
 	{ R300_FPI2_ARGA_ONE    , 0, 0 },
 	{ R300_FPI2_ARGA_HALF   , 0, 0 }
 };
-#define SWIZZLE_HALF 6
 
 /* boiler-plate reg, for convenience */
-static const pfs_reg_t undef = {
-	type: REG_TYPE_TEMP,
-	index: 0,
-	v_swz: SWIZZLE_XYZ,
-	s_swz: SWIZZLE_W,
-	negate_v: 0,
-	negate_s: 0,
-	absolute: 0,
-	no_use: GL_FALSE,
-	valid: GL_FALSE
-};
+static const GLuint undef = REG(REG_TYPE_TEMP,
+				0,
+				SWIZZLE_XYZ,
+				SWIZZLE_W,
+				GL_FALSE,
+				GL_FALSE);
 
 /* constant one source */
-static const pfs_reg_t pfs_one = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_111,
-	s_swz: SWIZZLE_ONE,
-	valid: GL_TRUE
-};
+static const GLuint pfs_one = REG(REG_TYPE_CONST,
+				  0,
+				  SWIZZLE_111,
+				  SWIZZLE_ONE,
+				  GL_FALSE,
+				  GL_TRUE);
 
 /* constant half source */
-static const pfs_reg_t pfs_half = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_HHH,
-	s_swz: SWIZZLE_HALF,
-	valid: GL_TRUE
-};
+static const GLuint pfs_half = REG(REG_TYPE_CONST,
+				   0,
+				   SWIZZLE_HHH,
+				   SWIZZLE_HALF,
+				   GL_FALSE,
+				   GL_TRUE);
 
 /* constant zero source */
-static const pfs_reg_t pfs_zero = {
-	type: REG_TYPE_CONST,
-	index: 0,
-	v_swz: SWIZZLE_000,
-	s_swz: SWIZZLE_ZERO,
-	valid: GL_TRUE
-};
-
-/***************************************
- * end: data structures
- ***************************************/
+static const GLuint pfs_zero = REG(REG_TYPE_CONST,
+				   0,
+				   SWIZZLE_000,
+				   SWIZZLE_ZERO,
+				   GL_FALSE,
+				   GL_TRUE);
 
-#define ERROR(fmt, args...) do { \
-		fprintf(stderr, "%s::%s(): " fmt "\n",\
-			__FILE__, __func__, ##args);  \
-		rp->error = GL_TRUE; \
-} while(0)
+/*
+ * Common functions prototypes
+ */
+static void dump_program(struct r300_fragment_program *rp);
+static void emit_arith(struct r300_fragment_program *rp, int op,
+				GLuint dest, int mask,
+				GLuint src0, GLuint src1, GLuint src2,
+				int flags);
 
+/*
+ * Helper functions prototypes
+ */
 static int get_hw_temp(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
@@ -256,266 +330,339 @@ static void free_hw_temp(struct r300_fragment_program *rp, int idx)
 	cs->hwreg_in_use &= ~(1<<idx);
 }
 
-static pfs_reg_t get_temp_reg(struct r300_fragment_program *rp)
+static GLuint get_temp_reg(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = ffs(~cs->temp_in_use);
-	if (!r.index) {
+	index = ffs(~cs->temp_in_use);
+	if (!index) {
 		ERROR("Out of program temps\n");
 		return r;
 	}
-	cs->temp_in_use |= (1 << --r.index);
-	
-	cs->temps[r.index].refcount = 0xFFFFFFFF;
-	cs->temps[r.index].reg = -1;
-	r.valid = GL_TRUE;
+
+	cs->temp_in_use |= (1 << --index);
+	cs->temps[index].refcount = 0xFFFFFFFF;
+	cs->temps[index].reg = -1;
+
+	REG_SET_TYPE(r, REG_TYPE_TEMP);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static pfs_reg_t get_temp_reg_tex(struct r300_fragment_program *rp)
+static GLuint get_temp_reg_tex(struct r300_fragment_program *rp)
 {
 	COMPILE_STATE;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = ffs(~cs->temp_in_use);
-	if (!r.index) {
+	index = ffs(~cs->temp_in_use);
+	if (!index) {
 		ERROR("Out of program temps\n");
 		return r;
 	}
-	cs->temp_in_use |= (1 << --r.index);
-	
-	cs->temps[r.index].refcount = 0xFFFFFFFF;
-	cs->temps[r.index].reg = get_hw_temp_tex(rp);
-	r.valid = GL_TRUE;
+
+	cs->temp_in_use |= (1 << --index);
+	cs->temps[index].refcount = 0xFFFFFFFF;
+	cs->temps[index].reg = get_hw_temp_tex(rp);
+
+	REG_SET_TYPE(r, REG_TYPE_TEMP);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static void free_temp(struct r300_fragment_program *rp, pfs_reg_t r)
+static void free_temp(struct r300_fragment_program *rp, GLuint r)
 {
 	COMPILE_STATE;
-	if (!(cs->temp_in_use & (1<<r.index))) return;
+	GLuint index = REG_GET_INDEX(r);
+
+	if (!(cs->temp_in_use & (1 << index)))
+		return;
 	
-	if (r.type == REG_TYPE_TEMP) {
-		free_hw_temp(rp, cs->temps[r.index].reg);
-		cs->temps[r.index].reg = -1;
-		cs->temp_in_use &= ~(1<<r.index);
-	} else if (r.type == REG_TYPE_INPUT) {
-		free_hw_temp(rp, cs->inputs[r.index].reg);
-		cs->inputs[r.index].reg = -1;
+	if (REG_GET_TYPE(r) == REG_TYPE_TEMP) {
+		free_hw_temp(rp, cs->temps[index].reg);
+		cs->temps[index].reg = -1;
+		cs->temp_in_use &= ~(1 << index);
+	} else if (REG_GET_TYPE(r) == REG_TYPE_INPUT) {
+		free_hw_temp(rp, cs->inputs[index].reg);
+		cs->inputs[index].reg = -1;
 	}
 }
 
-static pfs_reg_t emit_param4fv(struct r300_fragment_program *rp,
-			       GLfloat *values)
+static GLuint emit_param4fv(struct r300_fragment_program *rp,
+			    GLfloat *values)
 {
-	pfs_reg_t r = undef;
-		r.type = REG_TYPE_CONST;
+	GLuint r = undef;
+	GLuint index;
 	int pidx;
 
 	pidx = rp->param_nr++;
-	r.index = rp->const_nr++;
-	if (pidx >= PFS_NUM_CONST_REGS || r.index >= PFS_NUM_CONST_REGS) {
+	index = rp->const_nr++;
+	if (pidx >= PFS_NUM_CONST_REGS || index >= PFS_NUM_CONST_REGS) {
 		ERROR("Out of const/param slots!\n");
 		return r;
 	}
-	
-	rp->param[pidx].idx = r.index;
+
+	rp->param[pidx].idx = index;
 	rp->param[pidx].values = values;
 	rp->params_uptodate = GL_FALSE;
 
-	r.valid = GL_TRUE;
+	REG_SET_TYPE(r, REG_TYPE_CONST);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static pfs_reg_t emit_const4fv(struct r300_fragment_program *rp, GLfloat *cp)
+static GLuint emit_const4fv(struct r300_fragment_program *rp, GLfloat *cp)
 { 
-	pfs_reg_t r = undef;
-		r.type = REG_TYPE_CONST;
+	GLuint r = undef;
+	GLuint index;
 
-	r.index = rp->const_nr++;
-	if (r.index >= PFS_NUM_CONST_REGS) {
+	index = rp->const_nr++;
+	if (index >= PFS_NUM_CONST_REGS) {
 		ERROR("Out of hw constants!\n");
 		return r;
 	}
 
-	COPY_4V(rp->constant[r.index], cp);
-	r.valid = GL_TRUE;
+	COPY_4V(rp->constant[index], cp);
+
+	REG_SET_TYPE(r, REG_TYPE_CONST);
+	REG_SET_INDEX(r, index);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 
-static __inline pfs_reg_t negate(pfs_reg_t r)
+static inline GLuint negate(GLuint r)
 {
-	r.negate_v = 1;
-	r.negate_s = 1;
+	REG_NEGS(r);
+	REG_NEGV(r);
 	return r;
 }
 
 /* Hack, to prevent clobbering sources used multiple times when
  * emulating non-native instructions
  */
-static __inline pfs_reg_t keep(pfs_reg_t r)
+static inline GLuint keep(GLuint r)
 {
-	r.no_use = GL_TRUE;
+	REG_SET_NO_USE(r, GL_TRUE);
 	return r;
 }
 
-static __inline pfs_reg_t absolute(pfs_reg_t r)
+static inline GLuint absolute(GLuint r)
 {
-	r.absolute = 1;
+	REG_ABS(r);
 	return r;
 }
 
 static int swz_native(struct r300_fragment_program *rp,
-		      pfs_reg_t src, pfs_reg_t *r, GLuint arbneg)
+		      GLuint src,
+		      GLuint *r,
+		      GLuint arbneg)
 {
-	/* Native swizzle, nothing to see here */
-	src.negate_s = (arbneg >> 3) & 1;
+	/* Native swizzle, handle negation */
+	src = (src & ~REG_NEGS_MASK) |
+		(((arbneg >> 3) & 1) << REG_NEGS_SHIFT);
 
 	if ((arbneg & 0x7) == 0x0) {
-		src.negate_v = 0;
+		src = src & ~REG_NEGV_MASK;
 		*r = src;
 	} else if ((arbneg & 0x7) == 0x7) {
-		src.negate_v = 1;
+		src |= REG_NEGV_MASK;
 		*r = src;
 	} else {
-		if (!r->valid)
+		if (!REG_GET_VALID(*r))
 			*r = get_temp_reg(rp);
-		src.negate_v = 1;
-		emit_arith(rp, PFS_OP_MAD, *r, arbneg & 0x7,
-			   keep(src), pfs_one, pfs_zero, 0);
-		src.negate_v = 0;
-		emit_arith(rp, PFS_OP_MAD, *r,
+		src |= REG_NEGV_MASK;
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   *r,
+			   arbneg & 0x7,
+			   keep(src),
+			   pfs_one,
+			   pfs_zero,
+			   0);
+		src = src & ~REG_NEGV_MASK;
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   *r,
 			   (arbneg ^ 0x7) | WRITEMASK_W,
-			   src, pfs_one, pfs_zero, 0);
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 	}
 
 	return 3;
 }
 
-static int swz_emit_partial(struct r300_fragment_program *rp, pfs_reg_t src,
-			    pfs_reg_t *r, int mask, int mc, GLuint arbneg)
+static int swz_emit_partial(struct r300_fragment_program *rp,
+			    GLuint src,
+			    GLuint *r,
+			    int mask,
+			    int mc,
+			    GLuint arbneg)
 {
 	GLuint tmp;
 	GLuint wmask = 0;
 
-	if (!r->valid)
+	if (!REG_GET_VALID(*r))
 		*r = get_temp_reg(rp);
 
-	/* A partial match, src.v_swz/mask define what parts of the
-	 * desired swizzle we match */
+	/* A partial match, VSWZ/mask define what parts of the
+	 * desired swizzle we match
+	 */
 	if (mc + s_mask[mask].count == 3) {
 		wmask = WRITEMASK_W;
-		src.negate_s = (arbneg >> 3) & 1;
+		src |= ((arbneg >> 3) & 1) << REG_NEGS_SHIFT;
 	}
 
 	tmp = arbneg & s_mask[mask].mask;
 	if (tmp) {
 		tmp = tmp ^ s_mask[mask].mask;
 		if (tmp) {
-			src.negate_v = 1;
-			emit_arith(rp, PFS_OP_MAD, *r,
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
 				   arbneg & s_mask[mask].mask,
-				   keep(src), pfs_one, pfs_zero, 0);
-			src.negate_v = 0;
-			if (!wmask) src.no_use = GL_TRUE;
-			else        src.no_use = GL_FALSE;
-			emit_arith(rp, PFS_OP_MAD, *r, tmp | wmask,
-				   src, pfs_one, pfs_zero, 0);
+				   keep(src) | REG_NEGV_MASK,
+				   pfs_one,
+				   pfs_zero,
+				   0);
+			if (!wmask) {
+				REG_SET_NO_USE(src, GL_TRUE);
+			} else {
+				REG_SET_NO_USE(src, GL_FALSE);
+			}
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
+				   tmp | wmask,
+				   src,
+				   pfs_one,
+				   pfs_zero,
+				   0);
 		} else {
-			src.negate_v = 1;
-			if (!wmask) src.no_use = GL_TRUE;
-			else        src.no_use = GL_FALSE;
-			emit_arith(rp, PFS_OP_MAD, *r,
+			if (!wmask) {
+				REG_SET_NO_USE(src, GL_TRUE);
+			} else {
+				REG_SET_NO_USE(src, GL_FALSE);
+			}
+			emit_arith(rp,
+				   PFS_OP_MAD,
+				   *r,
 				   (arbneg & s_mask[mask].mask) | wmask,
-				   src, pfs_one, pfs_zero, 0);
-			src.negate_v = 0;
+				   src | REG_NEGV_MASK,
+				   pfs_one,
+				   pfs_zero,
+				   0);
 		}
 	} else {
-		if (!wmask) src.no_use = GL_TRUE;
-		else        src.no_use = GL_FALSE;
-		emit_arith(rp, PFS_OP_MAD, *r,
+		if (!wmask) {
+			REG_SET_NO_USE(src, GL_TRUE);
+		} else {
+			REG_SET_NO_USE(src, GL_FALSE);
+		}
+		emit_arith(rp, PFS_OP_MAD,
+			   *r,
 			   s_mask[mask].mask | wmask,
-			   src, pfs_one, pfs_zero, 0);
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 	}
 
 	return s_mask[mask].count;
 }
 
-#define swizzle(r, x, y, z, w) do_swizzle(rp, r, \
-					  ((SWIZZLE_##x<<0)|	\
-					   (SWIZZLE_##y<<3)|	\
-					   (SWIZZLE_##z<<6)|	\
-					   (SWIZZLE_##w<<9)),	\
-					  0)
-
-static pfs_reg_t do_swizzle(struct r300_fragment_program *rp,
-			    pfs_reg_t src, GLuint arbswz, GLuint arbneg)
+static GLuint do_swizzle(struct r300_fragment_program *rp,
+			 GLuint src,
+			 GLuint arbswz,
+			 GLuint arbneg)
 {
-	pfs_reg_t r = undef;
-	
+	GLuint r = undef;
+	GLuint vswz;
 	int c_mask = 0;
-	int v_matched = 0;
+	int v_match = 0;
 
 	/* If swizzling from something without an XYZW native swizzle,
 	 * emit result to a temp, and do new swizzle from the temp.
 	 */
-	if (src.v_swz != SWIZZLE_XYZ || src.s_swz != SWIZZLE_W) {
-		pfs_reg_t temp = get_temp_reg(rp);
-		emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_XYZW, src, pfs_one,
-			   pfs_zero, 0);
+	if (REG_GET_VSWZ(src) != SWIZZLE_XYZ ||
+	    REG_GET_SSWZ(src) != SWIZZLE_W) {
+		GLuint temp = get_temp_reg(rp);
+		emit_arith(rp,
+			   PFS_OP_MAD,
+			   temp,
+			   WRITEMASK_XYZW,
+			   src,
+			   pfs_one,
+			   pfs_zero,
+			   0);
 		src = temp;
 	}
-	src.s_swz = GET_SWZ(arbswz, 3);
+
+	/* set scalar swizzling */
+	REG_SET_SSWZ(src, GET_SWZ(arbswz, 3));
 
 	do {
+		vswz = REG_GET_VSWZ(src);
 		do {
-#define CUR_HASH (v_swiz[src.v_swz].hash & s_mask[c_mask].hash)
-			if (CUR_HASH == (arbswz & s_mask[c_mask].hash)) {
-				if (s_mask[c_mask].count == 3)
-					v_matched += swz_native(rp, src, &r,
+			int chash;
+
+			REG_SET_VSWZ(src, vswz);
+			chash = v_swiz[REG_GET_VSWZ(src)].hash &
+				s_mask[c_mask].hash;
+
+			if (chash == (arbswz & s_mask[c_mask].hash)) {
+				if (s_mask[c_mask].count == 3) {
+					v_match += swz_native(rp,
+								src,
+								&r,
 								arbneg);
-				else
-					v_matched += swz_emit_partial(rp, src,
-								      &r,
-								      c_mask,
-								      v_matched,
-								      arbneg);
-
-				if (v_matched == 3)
+				} else {
+					v_match += swz_emit_partial(rp,
+								    src,
+								    &r,
+								    c_mask,
+								    v_match,
+								    arbneg);
+				}
+
+				if (v_match == 3)
 					return r;
 
 				/* Fill with something invalid.. all 0's was
 				 * wrong before, matched SWIZZLE_X.  So all
-				 * 1's will be okay for now */
+				 * 1's will be okay for now
+				 */
 				arbswz |= (PFS_INVAL & s_mask[c_mask].hash);
 			}
-		} while(v_swiz[++src.v_swz].hash != PFS_INVAL);
-		src.v_swz = SWIZZLE_XYZ;
+		} while(v_swiz[++vswz].hash != PFS_INVAL);
+		REG_SET_VSWZ(src, SWIZZLE_XYZ);
 	} while (s_mask[++c_mask].hash != PFS_INVAL);
 
 	ERROR("should NEVER get here\n");
 	return r;
 }
-				
-static pfs_reg_t t_src(struct r300_fragment_program *rp,
-		       struct prog_src_register fpsrc)
+
+static GLuint t_src(struct r300_fragment_program *rp,
+		    struct prog_src_register fpsrc)
 {
-	pfs_reg_t r = undef;
-#if 0
-	pfs_reg_t n = undef;
-#endif
+	GLuint r = undef;
 
 	switch (fpsrc.File) {
 	case PROGRAM_TEMPORARY:
-		r.index = fpsrc.Index;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, fpsrc.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_TEMP);
 		break;
 	case PROGRAM_INPUT:
-		r.index = fpsrc.Index;
-		r.type = REG_TYPE_INPUT;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, fpsrc.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_INPUT);
 		break;
 	case PROGRAM_LOCAL_PARAM:
 		r = emit_param4fv(rp,
@@ -536,72 +683,40 @@ static pfs_reg_t t_src(struct r300_fragment_program *rp,
 	}
 
 	/* no point swizzling ONE/ZERO/HALF constants... */
-	if (r.v_swz < SWIZZLE_111 || r.s_swz < SWIZZLE_ZERO)
+	if (REG_GET_VSWZ(r) < SWIZZLE_111 || REG_GET_SSWZ(r) < SWIZZLE_ZERO)
 		r = do_swizzle(rp, r, fpsrc.Swizzle, fpsrc.NegateBase);
-#if 0
-	/* WRONG! Need to be able to do individual component negation,
-	 * should probably handle this in the swizzling code unless
-	 * all components are negated, then we can do this natively */
-	if ((fpsrc.NegateBase & 0xf) == 0xf)
-		r.negate = GL_TRUE;
-
-	r.negate_s = (fpsrc.NegateBase >> 3) & 1;
-
-	if ((fpsrc.NegateBase & 0x7) == 0x0) {
-		r.negate_v = 0;
-	} else if ((fpsrc.NegateBase & 0x7) == 0x7) {
-		r.negate_v = 1;
-	} else {
-		if (r.type != REG_TYPE_TEMP) {
-			n = get_temp_reg(rp);
-			emit_arith(rp, PFS_OP_MAD, n, 0x7 ^ fpsrc.NegateBase,
-				   keep(r), pfs_one, pfs_zero, 0);
-			r.negate_v = 1;
-			emit_arith(rp, PFS_OP_MAD, n,
-				   fpsrc.NegateBase & 0x7 | WRITEMASK_W,
-				   r, pfs_one, pfs_zero, 0);
-			r.negate_v = 0;
-			r = n;
-		} else {
-			r.negate_v = 1;
-			emit_arith(rp, PFS_OP_MAD, r,
-				   fpsrc.NegateBase & 0x7 | WRITEMASK_W,
-				   r, pfs_one, pfs_zero, 0);
-			r.negate_v = 0;
-		}
-	}
-#endif
-
 	return r;
 }
 
-static pfs_reg_t t_scalar_src(struct r300_fragment_program *rp,
-			      struct prog_src_register fpsrc)
+static GLuint t_scalar_src(struct r300_fragment_program *rp,
+			   struct prog_src_register fpsrc)
 {
 	struct prog_src_register src = fpsrc;
 	int sc = GET_SWZ(fpsrc.Swizzle, 0); /* X */
-	
+
 	src.Swizzle = ((sc<<0)|(sc<<3)|(sc<<6)|(sc<<9));
 
 	return t_src(rp, src);
 }
 
-static pfs_reg_t t_dst(struct r300_fragment_program *rp,
-		       struct prog_dst_register dest) {
-	pfs_reg_t r = undef;
+static GLuint t_dst(struct r300_fragment_program *rp,
+		       struct prog_dst_register dest)
+{
+	GLuint r = undef;
 	
 	switch (dest.File) {
 	case PROGRAM_TEMPORARY:
-		r.index = dest.Index;
-		r.valid = GL_TRUE;
+		REG_SET_INDEX(r, dest.Index);
+		REG_SET_VALID(r, GL_TRUE);
+		REG_SET_TYPE(r, REG_TYPE_TEMP);
 		return r;
 	case PROGRAM_OUTPUT:
-		r.type = REG_TYPE_OUTPUT;
+		REG_SET_TYPE(r, REG_TYPE_OUTPUT);
 		switch (dest.Index) {
 		case FRAG_RESULT_COLR:
 		case FRAG_RESULT_DEPR:
-			r.index = dest.Index;
-			r.valid = GL_TRUE;
+			REG_SET_INDEX(r, dest.Index);
+			REG_SET_VALID(r, GL_TRUE);
 			return r;
 		default:
 			ERROR("Bad DstReg->Index 0x%x\n", dest.Index);
@@ -613,66 +728,77 @@ static pfs_reg_t t_dst(struct r300_fragment_program *rp,
 	}
 }
 
-static int t_hw_src(struct r300_fragment_program *rp, pfs_reg_t src,
+static int t_hw_src(struct r300_fragment_program *rp,
+		    GLuint src,
 		    GLboolean tex)
 {
 	COMPILE_STATE;
 	int idx;
+	int index = REG_GET_INDEX(src);
 
-	switch (src.type) {
+	switch(REG_GET_TYPE(src)) {
 	case REG_TYPE_TEMP:
 		/* NOTE: if reg==-1 here, a source is being read that
-		 * 	 hasn't been written to. Undefined results */
-		if (cs->temps[src.index].reg == -1)
-			cs->temps[src.index].reg = get_hw_temp(rp);
-		idx = cs->temps[src.index].reg;
+		 * 	 hasn't been written to. Undefined results
+		 */
+		if (cs->temps[index].reg == -1)
+			cs->temps[index].reg = get_hw_temp(rp);
+
+		idx = cs->temps[index].reg;
 
-		if (!src.no_use && (--cs->temps[src.index].refcount == 0))
+		if (!REG_GET_NO_USE(src) &&
+		    (--cs->temps[index].refcount == 0))
 			free_temp(rp, src);
 		break;
 	case REG_TYPE_INPUT:
-		idx = cs->inputs[src.index].reg;
+		idx = cs->inputs[index].reg;
 
-		if (!src.no_use && (--cs->inputs[src.index].refcount == 0))
-			free_hw_temp(rp, cs->inputs[src.index].reg);
+		if (!REG_GET_NO_USE(src) &&
+		    (--cs->inputs[index].refcount == 0))
+			free_hw_temp(rp, cs->inputs[index].reg);
 		break;
 	case REG_TYPE_CONST:
-		return (src.index | SRC_CONST);
+		return (index | SRC_CONST);
 	default:
 		ERROR("Invalid type for source reg\n");
 		return (0 | SRC_CONST);
 	}
 
-	if (!tex) cs->used_in_node |= (1 << idx);
+	if (!tex)
+		cs->used_in_node |= (1 << idx);
 
 	return idx;
 }
 
-static int t_hw_dst(struct r300_fragment_program *rp, pfs_reg_t dest,
+static int t_hw_dst(struct r300_fragment_program *rp,
+		    GLuint dest,
 		    GLboolean tex)
 {
 	COMPILE_STATE;
 	int idx;
-	assert(dest.valid);
+	GLuint index = REG_GET_INDEX(dest);
+	assert(REG_GET_VALID(dest));
 
-	switch (dest.type) {
+	switch(REG_GET_TYPE(dest)) {
 	case REG_TYPE_TEMP:
-		if (cs->temps[dest.index].reg == -1) {
-			if (!tex)
-				cs->temps[dest.index].reg = get_hw_temp(rp);
-			else
-				cs->temps[dest.index].reg = get_hw_temp_tex(rp);
+		if (cs->temps[REG_GET_INDEX(dest)].reg == -1) {
+			if (!tex) {
+				cs->temps[index].reg = get_hw_temp(rp);
+			} else {
+				cs->temps[index].reg = get_hw_temp_tex(rp);
+			}
 		}
-		idx = cs->temps[dest.index].reg;
+		idx = cs->temps[index].reg;
 
-		if (!dest.no_use && (--cs->temps[dest.index].refcount == 0))
+		if (!REG_GET_NO_USE(dest) &&
+		    (--cs->temps[index].refcount == 0))
 			free_temp(rp, dest);
 
 		cs->dest_in_node |= (1 << idx);
 		cs->used_in_node |= (1 << idx);
 		break;
 	case REG_TYPE_OUTPUT:
-		switch (dest.index) {
+		switch(index) {
 		case FRAG_RESULT_COLR:
 			rp->node[rp->cur_node].flags |= R300_PFS_NODE_OUTPUT_COLOR;
 			break;
@@ -680,17 +806,18 @@ static int t_hw_dst(struct r300_fragment_program *rp, pfs_reg_t dest,
 			rp->node[rp->cur_node].flags |= R300_PFS_NODE_OUTPUT_DEPTH;
 			break;
 		}
-		return dest.index;
+		return index;
 		break;
 	default:
-		ERROR("invalid dest reg type %d\n", dest.type);
+		ERROR("invalid dest reg type %d\n", REG_GET_TYPE(dest));
 		return 0;
 	}
 	
 	return idx;
 }
 
-static void emit_nop(struct r300_fragment_program *rp, GLuint mask,
+static void emit_nop(struct r300_fragment_program *rp,
+		     GLuint mask,
 		     GLboolean sync)
 {
 	COMPILE_STATE;
@@ -716,8 +843,8 @@ static void emit_tex(struct r300_fragment_program *rp,
 		     int opcode)
 {
 	COMPILE_STATE;
-	pfs_reg_t coord = t_src(rp, fpi->SrcReg[0]);
-	pfs_reg_t dest = undef, rdest = undef;
+	GLuint coord = t_src(rp, fpi->SrcReg[0]);
+	GLuint dest = undef, rdest = undef;
 	GLuint din = cs->dest_in_node, uin = cs->used_in_node;
 	int unit = fpi->TexSrcUnit;
 	int hwsrc, hwdest;
@@ -728,7 +855,7 @@ static void emit_tex(struct r300_fragment_program *rp,
 		dest = t_dst(rp, fpi->DstReg);
 
 		/* r300 doesn't seem to be able to do TEX->output reg */
-		if (dest.type == REG_TYPE_OUTPUT) {
+		if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
 			rdest = dest;
 			dest = get_temp_reg_tex(rp);
 		}
@@ -740,7 +867,7 @@ static void emit_tex(struct r300_fragment_program *rp,
 		if (uin & (1 << hwdest)) {
 			free_hw_temp(rp, hwdest);
 			hwdest = get_hw_temp_tex(rp);
-			cs->temps[dest.index].reg = hwdest;
+			cs->temps[REG_GET_INDEX(dest)].reg = hwdest;
 		}
 	} else {
 		hwdest = 0;
@@ -750,8 +877,8 @@ static void emit_tex(struct r300_fragment_program *rp,
 	/* Indirection if source has been written in this node, or if the
 	 * dest has been read/written in this node
 	 */
-	if ((coord.type != REG_TYPE_CONST && (din & (1<<hwsrc))) ||
-					(uin & (1<<hwdest))) {
+	if ((REG_GET_TYPE(coord) != REG_TYPE_CONST &&
+	     (din & (1<<hwsrc))) || (uin & (1<<hwdest))) {
 			
 		/* Finish off current node */
 		cs->v_pos = cs->s_pos = MAX2(cs->v_pos, cs->s_pos);
@@ -791,13 +918,13 @@ static void emit_tex(struct r300_fragment_program *rp,
 		| (opcode << R300_FPITX_OPCODE_SHIFT);
 
 	cs->dest_in_node |= (1 << hwdest); 
-	if (coord.type != REG_TYPE_CONST)
+	if (REG_GET_TYPE(coord) != REG_TYPE_CONST)
 		cs->used_in_node |= (1 << hwsrc);
 
 	rp->node[rp->cur_node].tex_end++;
 
 	/* Copy from temp to output if needed */
-	if (rdest.valid) {
+	if (REG_GET_VALID(rdest)) {
 		emit_arith(rp, PFS_OP_MAD, rdest, WRITEMASK_XYZW, dest,
 			   pfs_one, pfs_zero, 0);
 		free_temp(rp, dest);
@@ -807,7 +934,9 @@ static void emit_tex(struct r300_fragment_program *rp,
 /* Add sources to FPI1/FPI3 lists.  If source is already on list,
  * reuse the index instead of wasting a source.
  */
-static int add_src(struct r300_fragment_program *rp, int reg, int pos,
+static int add_src(struct r300_fragment_program *rp,
+		   int reg,
+		   int pos,
 		   int srcmask)
 {
 	COMPILE_STATE;
@@ -856,9 +985,12 @@ static int add_src(struct r300_fragment_program *rp, int reg, int pos,
  * It's not necessary to force the first case, but it makes disassembled
  * shaders easier to read.
  */
-static GLboolean force_same_slot(int vop, int sop,
-				 GLboolean emit_vop, GLboolean emit_sop,
-				 int argc, pfs_reg_t *src)
+static GLboolean force_same_slot(int vop,
+				 int sop,
+				 GLboolean emit_vop,
+				 GLboolean emit_sop,
+				 int argc,
+				 GLuint *src)
 {
 	int i;
 
@@ -870,20 +1002,24 @@ static GLboolean force_same_slot(int vop, int sop,
 
 	if (emit_vop) {
 		for (i=0;i<argc;i++)
-			if (src[i].v_swz == SWIZZLE_WZY)
+			if (REG_GET_VSWZ(src[i]) == SWIZZLE_WZY)
 				return GL_TRUE;
 	}
 
 	return GL_FALSE;
 }
 
-static void emit_arith(struct r300_fragment_program *rp, int op,
-		       pfs_reg_t dest, int mask,
-		       pfs_reg_t src0, pfs_reg_t src1, pfs_reg_t src2,
+static void emit_arith(struct r300_fragment_program *rp,
+		       int op,
+		       GLuint dest,
+		       int mask,
+		       GLuint src0,
+		       GLuint src1,
+		       GLuint src2,
 		       int flags)
 {
 	COMPILE_STATE;
-	pfs_reg_t src[3] = { src0, src1, src2 };
+	GLuint src[3] = { src0, src1, src2 };
 	int hwsrc[3], sswz[3], vswz[3];
 	int hwdest;
 	GLboolean emit_vop = GL_FALSE, emit_sop = GL_FALSE;
@@ -900,7 +1036,8 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 	if ((mask & WRITEMASK_W) || vop == R300_FPI0_OUTC_REPL_ALPHA)
 		emit_sop = GL_TRUE;
 
-	if (dest.type == REG_TYPE_OUTPUT && dest.index == FRAG_RESULT_DEPR)
+	if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT &&
+	    REG_GET_INDEX(dest) == FRAG_RESULT_DEPR)
 		emit_vop = GL_FALSE;
 					
 	if (force_same_slot(vop, sop, emit_vop, emit_sop, argc, src)) {
@@ -916,12 +1053,12 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 		 */
 		for (i=0;i<3;i++) {
 			if (emit_vop &&
-			    (v_swiz[src[i].v_swz].flags & SLOT_SCALAR)) {
+			    (v_swiz[REG_GET_VSWZ(src[i])].flags & SLOT_SCALAR)) {
 				vpos = spos = MAX2(vpos, spos);
 				break;
 			}
 			if (emit_sop &&
-			    (s_swiz[src[i].s_swz].flags & SLOT_VECTOR)) {
+			    (s_swiz[REG_GET_VSWZ(src[i])].flags & SLOT_VECTOR)) {
 				vpos = spos = MAX2(vpos, spos);
 				break;
 			}
@@ -945,20 +1082,22 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 
 		if (emit_vop && vop != R300_FPI0_OUTC_REPL_ALPHA) {
 			srcpos = add_src(rp, hwsrc[i], vpos,
-					 v_swiz[src[i].v_swz].flags);	
-			vswz[i] = (v_swiz[src[i].v_swz].base +
-				   (srcpos * v_swiz[src[i].v_swz].stride)) |
-				(src[i].negate_v ? ARG_NEG : 0) |
-				(src[i].absolute ? ARG_ABS : 0);
+					 v_swiz[REG_GET_VSWZ(src[i])].flags);
+			vswz[i] = (v_swiz[REG_GET_VSWZ(src[i])].base +
+				   (srcpos *
+				    v_swiz[REG_GET_VSWZ(src[i])].stride)) |
+				((src[i] & REG_NEGV_MASK) ? ARG_NEG : 0) |
+				((src[i] & REG_ABS_MASK) ? ARG_ABS : 0);
 		} else vswz[i] = R300_FPI0_ARGC_ZERO;
 		
 		if (emit_sop) {
 			srcpos = add_src(rp, hwsrc[i], spos,
-					 s_swiz[src[i].s_swz].flags);
-			sswz[i] = (s_swiz[src[i].s_swz].base +
-				   (srcpos * s_swiz[src[i].s_swz].stride)) |
-				(src[i].negate_s ? ARG_NEG : 0) |
-				(src[i].absolute ? ARG_ABS : 0);	
+					 s_swiz[REG_GET_SSWZ(src[i])].flags);
+			sswz[i] = (s_swiz[REG_GET_SSWZ(src[i])].base +
+				   (srcpos *
+				    s_swiz[REG_GET_SSWZ(src[i])].stride)) |
+				((src[i] & REG_NEGS_MASK) ? ARG_NEG : 0) |
+				((src[i] & REG_ABS_MASK) ? ARG_ABS : 0);
 		} else sswz[i] = R300_FPI2_ARGA_ZERO;
 	}
 	hwdest = t_hw_dst(rp, dest, GL_FALSE);
@@ -980,8 +1119,8 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 				(vswz[2] << R300_FPI0_ARG2C_SHIFT);
 
 		rp->alu.inst[vpos].inst1 |= hwdest << R300_FPI1_DSTC_SHIFT;
-		if (dest.type == REG_TYPE_OUTPUT) {
-			if (dest.index == FRAG_RESULT_COLR) {
+		if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
+			if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
 				rp->alu.inst[vpos].inst1 |=
 					(mask & WRITEMASK_XYZ) << R300_FPI1_DSTC_OUTPUT_MASK_SHIFT;
 			} else assert(0);
@@ -1005,11 +1144,11 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 				sswz[2] << R300_FPI2_ARG2A_SHIFT;
 
 		if (mask & WRITEMASK_W) {
-			if (dest.type == REG_TYPE_OUTPUT) {
-				if (dest.index == FRAG_RESULT_COLR) {
+			if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
+				if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
 					rp->alu.inst[spos].inst3 |= 
 							(hwdest << R300_FPI3_DSTA_SHIFT) | R300_FPI3_DSTA_OUTPUT;
-				} else if (dest.index == FRAG_RESULT_DEPR) {
+				} else if (REG_GET_INDEX(dest) == FRAG_RESULT_DEPR) {
 					rp->alu.inst[spos].inst3 |= R300_FPI3_DSTA_DEPTH;
 				} else assert(0);
 			} else {
@@ -1022,22 +1161,22 @@ static void emit_arith(struct r300_fragment_program *rp, int op,
 		rp->alu.inst[vpos].inst2 = NOP_INST2;
 
 	return;
-};
+}
 
 #if 0
-static pfs_reg_t get_attrib(struct r300_fragment_program *rp, GLuint attr)
+static GLuint get_attrib(struct r300_fragment_program *rp, GLuint attr)
 {
 	struct gl_fragment_program *mp = &rp->mesa_program;
-	pfs_reg_t r = undef;
+	GLuint r = undef;
 
 	if (!(mp->Base.InputsRead & (1<<attr))) {
 		ERROR("Attribute %d was not provided!\n", attr);
 		return undef;
 	}
 
-	r.type  = REG_TYPE_INPUT;
-	r.index = attr;
-	r.valid = GL_TRUE;
+	REG_SET_TYPE(r, REG_TYPE_INPUT);
+	REG_SET_INDEX(r, attr);
+	REG_SET_VALID(r, GL_TRUE);
 	return r;
 }
 #endif
@@ -1047,8 +1186,8 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 	struct gl_fragment_program *mp = &rp->mesa_program;
 	const struct prog_instruction *inst = mp->Base.Instructions;
 	struct prog_instruction *fpi;
-	pfs_reg_t src[3], dest, temp;
-	pfs_reg_t cnst;
+	GLuint src[3], dest, temp;
+	GLuint cnst;
 	int flags, mask = 0;
 	GLfloat cnstv[4] = {0.0, 0.0, 0.0, 0.0};
 
@@ -1094,7 +1233,64 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 				   flags);
 			break;
 		case OPCODE_COS:
-			ERROR("COS not implemented\n");
+			/*
+			 * cos using taylor serie:
+			 * cos(x) = 1 - x^2/2! + x^4/4! - x^6/6!
+			 */
+			temp = get_temp_reg(rp);
+			cnstv[0] = 0.5;
+			cnstv[1] = 0.041666667;
+			cnstv[2] = 0.001388889;
+			cnstv[4] = 0.0;
+			cnst = emit_const4fv(rp, cnstv);
+			src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
+
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_XYZ,
+				   src[0],
+				   src[0],
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_Y | WRITEMASK_Z,
+				   temp, temp,
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_Z,
+				   temp,
+				   swizzle(temp, X, X, X, W),
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_XYZ,
+				   temp, cnst,
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   pfs_one,
+				   pfs_one,
+				   negate(temp),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   temp,
+				   pfs_one,
+				   swizzle(temp, Y, Y, Y, W),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   temp,
+				   pfs_one,
+				   negate(swizzle(temp, Z, Z, Z, W)),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, dest, mask,
+				   swizzle(temp, X, X, X, X),
+				   pfs_one,
+				   pfs_zero,
+				   flags);
+			free_temp(rp, temp);
 			break;
 		case OPCODE_DP3:
 			src[0] = t_src(rp, fpi->SrcReg[0]);
@@ -1147,7 +1343,7 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 			/* result.x = 1.0
 			 * result.w = src1.w */
 			if (mask & WRITEMASK_XW) {
-				src[1].v_swz = SWIZZLE_111; /* Cheat.. */
+				REG_SET_VSWZ(src[1], SWIZZLE_111); /*Cheat*/
 				emit_arith(rp, PFS_OP_MAD, dest,
 					   mask & WRITEMASK_XW,
 					   src[1], pfs_one, pfs_zero,
@@ -1351,7 +1547,70 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
 			free_temp(rp, temp);
 			break;
 		case OPCODE_SIN:
-			ERROR("SIN not implemented\n");
+			/*
+			 * sin using taylor serie:
+			 * sin(x) = x - x^3/3! + x^5/5! - x^7/7!
+			 */
+			temp = get_temp_reg(rp);
+			cnstv[0] = 0.333333333;
+			cnstv[1] = 0.008333333;
+			cnstv[2] = 0.000198413;
+			cnstv[4] = 0.0;
+			cnst = emit_const4fv(rp, cnstv);
+			src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
+
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_XYZ,
+				   src[0],
+				   src[0],
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_Y | WRITEMASK_Z,
+				   temp, temp,
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_Z,
+				   temp,
+				   swizzle(temp, X, X, X, W),
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_XYZ,
+				   src[0],
+				   temp,
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_XYZ,
+				   temp, cnst,
+				   pfs_zero,
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   src[0],
+				   pfs_one,
+				   negate(temp),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   temp,
+				   pfs_one,
+				   swizzle(temp, Y, Y, Y, W),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, temp,
+				   WRITEMASK_X,
+				   temp,
+				   pfs_one,
+				   negate(swizzle(temp, Z, Z, Z, W)),
+				   flags);
+			emit_arith(rp, PFS_OP_MAD, dest, mask,
+				   swizzle(temp, X, X, X, X),
+				   pfs_one,
+				   pfs_zero,
+				   flags);
+			free_temp(rp, temp);
 			break;
 		case OPCODE_SLT:
 			src[0] = t_src(rp, fpi->SrcReg[0]);
@@ -1470,6 +1729,13 @@ static void init_program(struct r300_fragment_program *rp)
 	}
 	InputsRead &= ~FRAG_BITS_TEX_ANY;
 
+	/* fragment position treated as a texcoord */
+	if (InputsRead & FRAG_BIT_WPOS) {
+		cs->inputs[FRAG_ATTRIB_WPOS].refcount = 0;
+		cs->inputs[FRAG_ATTRIB_WPOS].reg = get_hw_temp(rp);
+	}
+	InputsRead &= ~FRAG_BIT_WPOS;
+
 	/* Then primary colour */
 	if (InputsRead & FRAG_BIT_COL0) {
 		cs->inputs[FRAG_ATTRIB_COL0].refcount = 0;
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.h b/src/mesa/drivers/dri/r300/r300_fragprog.h
index 4bbaa07e01..b0cebe60bb 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.h
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.h
@@ -41,6 +41,7 @@
 #include "r300_context.h"
 #include "program_instruction.h"
 
+#if 0
 /* representation of a register for emit_arith/swizzle */
 typedef struct _pfs_reg_t {
 	enum {
@@ -58,7 +59,7 @@ typedef struct _pfs_reg_t {
 	GLboolean no_use:1;
 	GLboolean valid:1;
 } pfs_reg_t;
-
+#endif
 typedef struct r300_fragment_program_swizzle {
 	GLuint length;
 	GLuint src[4];
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog_swz.c b/src/mesa/drivers/dri/r300/r300_fragprog_swz.c
deleted file mode 100644
index b29331d7bd..0000000000
--- a/src/mesa/drivers/dri/r300/r300_fragprog_swz.c
+++ /dev/null
@@ -1,1328 +0,0 @@
-/*
- * Copyright (C) 2005 Jerome Glisse.  All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-#include "r300_fragprog.h"
-#include "r300_reg.h"
-
-
-#define I0_000	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_ZERO) |				\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_111	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_ZERO) |				\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG2C_SHIFT) )
-#define I0_XXX	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_XXX) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_YYY	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_YYY) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_ZZZ	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_ZZZ) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_XYZ	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_XYZ) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_YZX	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_YZX) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_ZXY	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0C_ZXY) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_WZY	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0CA_WZY) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-#define I0_WWW	( (R300_FPI0_OUTC_MAD) |				\
-		  (R300_FPI0_ARGC_SRC0A) |				\
-		  (R300_FPI0_ARGC_ONE  << R300_FPI0_ARG1C_SHIFT) |	\
-		  (R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT) )
-
-#define IEMPTY	0
-
-#define I1_XYZ	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_X |	\
-		  R300_FPI1_DSTC_REG_Y |	\
-		  R300_FPI1_DSTC_REG_Z )
-#define I1_XY_	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_X |	\
-		  R300_FPI1_DSTC_REG_Y )	
-#define I1_X_Z	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_X |	\
-		  R300_FPI1_DSTC_REG_Z )	
-#define I1__YZ	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_Y |	\
-		  R300_FPI1_DSTC_REG_Z )
-#define I1_X__	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_X )
-#define I1__Y_	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_Y )
-#define I1___Z	( R300_FPI1_SRC1C_CONST |	\
-		  R300_FPI1_SRC2C_CONST |	\
-		  R300_FPI1_DSTC_REG_Z )
-
-#define SEMPTY	{0,{0,0,0,0},{0,0,0,0,0,0,0,0}}
-
-struct r300_fragment_program_swizzle r300_swizzle [512] = {
-	/* XXX */
-	{1,{0,0,0,0},{ I0_XXX, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* YXX */
-	{2,{0,0,0,0},{ I0_YZX, I1_X_Z,
-		       I0_XXX, I1__Y_,
-		       0,0,
-		       0,0 } },
-	/* ZXX */
-	{2,{0,0,0,0},{ I0_ZZZ, I1_X__,
-		       I0_XXX, I1__YZ,
-		       0,0,
-		       0,0 } },
-	/* WXX */
-	{2,{0,0,0,0},{ I0_WZY, I1_X__,
-		       I0_XXX, I1__YZ,
-		       0,0,
-		       0,0} },
-	/* 0XX */
-	{2,{0,2,0,0},{ I0_XXX, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,
-		       0,0 } },
-	/* 1XX */
-	{2,{0,2,0,0},{ I0_XXX, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XYX */
-	{2,{0,0,0,0},{ I0_YYY, I1__Y_,
-		       I0_XXX, I1_X_Z,
-		       0,0,0,0}},
-	/* YYX */
-	{2,{0,0,0,0},{ I0_YYY, I1_XY_,
-		       I0_XXX, I1___Z,
-		       0,0,0,0}},
-	/* ZYX */
-	{3,{0,0,0,0},{ I0_ZZZ, I1_X__,
-		       I0_YYY, I1__Y_,
-		       I0_XXX, I1___Z,
-		       0,0}},
-	/* WYX */
-	{3,{0,0,0,0},{ I0_WZY, I1_X__,
-		       I0_YYY, I1__Y_,
-		       I0_XXX, I1___Z,
-		       0,0}},
-	/* 0YX */
-	{3,{0,0,2,0},{ I0_YYY, I1__Y_,
-		       I0_XXX, I1___Z,
-	               I0_000, I1_X__,
-		       0,0}},
-	/* 1YX */
-	{3,{0,0,2,0},{ I0_YYY, I1__Y_,
-		       I0_XXX, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XZX */
-	{2,{0,0,0,0},{ I0_YZX, I1__YZ,
-		       I0_XXX, I1_X__,
-		       0,0,0,0}},
-	/* YZX */
-	{1,{0,0,0,0},{ I0_YZX, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* ZZX */
-	{2,{0,0,0,0},{ I0_YZX, I1__YZ,
-		       I0_ZZZ, I1_X__,0,0,0,0}},
-	/* WZX */
-	{2,{0,0,0,0},{ I0_WZY, I1_XY_,
-		       I0_XXX, I1___Z,0,0,0,0}},
-	/* 0ZX */
-	{2,{0,2,0,0},{ I0_YZX, I1__YZ,
-		       I0_000, I1_X__,
-	               0,0,0,0}},
-	/* 1ZX */
-	{2,{0,2,0,0},{ I0_YZX, I1__YZ,
-		       I0_111, I1_X__,
-	               0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XWX */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_XXX, I1_X_Z,
-		       0,0,0,0}},
-	/* YWX */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_YZX, I1_X_Z,
-		       0,0,0,0}},
-	/* ZWX */
-	{3,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       I0_XXX, I1___Z,
-		       0,0}},
-	/* WWX */
-	{2,{0,0,0,0},{ I0_WWW, I1_XY_,
-		       I0_YZX, I1___Z,
-		       0,0,0,0}},
-	/* 0WX */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XXX, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1WX */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XXX, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X0X */
-	{2,{0,2,0,0},{ I0_XXX, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* Y0X */
-	{2,{0,2,0,0},{ I0_YZX, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* Z0X */
-	{3,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_000, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       0,0}},
-	/* W0X */
-	{3,{0,0,2,0},{ I0_WZY, I1_XYZ,
-		       I0_XXX, I1___Z,		       
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* 00X */
-	{2,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_000, I1_XY_,
-		       0,0,0,0}},
-	/* 10X */
-	{3,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_000, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X1X */
-	{2,{0,2,0,0},{ I0_XXX, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* Y1X */
-	{2,{0,2,0,0},{ I0_YZX, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* Z1X */
-	{3,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_111, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       0,0}},
-	/* W1X */
-	{3,{0,0,2,0},{ I0_WZY, I1_XYZ,
-		       I0_XXX, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* 01X */
-	{3,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_111, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 11X */
-	{2,{0,2,0,0},{ I0_XXX, I1___Z,
-		       I0_111, I1_XY_,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	/* XXY */
-	{2,{0,0,0,0},{ I0_YYY, I1___Z,
-		       I0_XXX, I1_XY_,
-		       0,0,0,0}},
-	/* YXY */
-	{2,{0,0,0,0},{ I0_YYY, I1_X_Z,
-		       I0_XXX, I1__Y_,
-		       0,0,0,0}},
-	/* ZXY */
-	{1,{0,0,0,0},{ I0_ZXY, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* WXY */
-	{2,{0,0,0,0},{ I0_WZY, I1_X__,
-		       I0_ZXY, I1__YZ,
-		       0,0,0,0}},
-	/* 0XY */
-	{2,{0,0,0,0},{ I0_ZXY, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1XY */
-	{2,{0,0,0,0},{ I0_ZXY, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XYY */
-	{2,{0,0,0,0},{ I0_YYY, I1__YZ,
-		       I0_XXX, I1_X__,
-		       0,0,0,0}},
-	/* YYY */
-	{1,{0,0,0,0},{ I0_YYY, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* ZYY */
-	{2,{0,0,0,0},{ I0_YYY, I1__YZ,
-		       I0_ZZZ, I1_X__,
-		       0,0,0,0}},
-	/* WYY */
-	{2,{0,0,0,0},{ I0_WZY, I1_XYZ,
-		       I0_YYY, I1__YZ,
-		       0,0,0,0}},
-	/* 0YY */
-	{2,{0,0,0,0},{ I0_YYY, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1YY */
-	{2,{0,0,0,0},{ I0_YYY, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XZY */
-	{2,{0,0,0,0},{ I0_WZY, I1__YZ,
-		       I0_XXX, I1_X__,
-		       0,0,0,0}},
-	/* YZY */
-	{2,{0,0,0,0},{ I0_WZY, I1__YZ,
-		       I0_YYY, I1_X__,
-		       0,0,0,0}},
-	/* ZZY */
-	{2,{0,0,0,0},{ I0_WZY, I1__YZ,
-		       I0_ZZZ, I1_X__,
-		       0,0,0,0}},
-	/* WZY */
-	{1,{0,0,0,0},{ I0_WZY, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* 0ZY */
-	{2,{0,0,0,0},{ I0_WZY, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1ZY */
-	{2,{0,0,0,0},{ I0_WZY, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XWY */
-	{3,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_XXX, I1_X__,
-		       I0_YYY, I1___Z,
-		       0,0}},
-	/* YWY */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_YYY, I1_X_Z,
-		       0,0,0,0}},
-	/* ZWY */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_ZXY, I1_X_Z,
-		       0,0,0,0}},
-	/* WWY */
-	{2,{0,0,0,0},{ I0_WWW, I1_XY_,
-		       I0_ZXY, I1___Z,
-		       0,0,0,0}},
-	/* 0WY */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_ZXY, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1WY */
-	{3,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_ZXY, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X0Y */
-	{3,{0,2,0,0},{ I0_XXX, I1_X__,
-		       I0_000, I1__Y_,
-		       I0_YYY, I1___Z,
-		       0,0}},
-	/* Y0Y */
-	{2,{0,2,0,0},{ I0_YYY, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* Z0Y */
-	{2,{0,2,0,0},{ I0_ZXY, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* W0Y */
-	{2,{0,2,0,0},{ I0_WZY, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* 00Y */
-	{2,{0,2,0,0},{ I0_YYY, I1___Z,
-		       I0_000, I1_XY_,
-		       0,0,0,0}},
-	/* 10Y */
-	{3,{0,2,0,0},{ I0_YYY, I1___Z,
-		       I0_000, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X1Y */
-	{3,{0,2,0,0},{ I0_XXX, I1_X__,
-		       I0_111, I1__Y_,
-		       I0_YYY, I1___Z,
-		       0,0}},
-	/* Y1Y */
-	{2,{0,2,0,0},{ I0_YYY, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* Z1Y */
-	{2,{0,2,0,0},{ I0_ZXY, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* W1Y */
-	{3,{0,2,0,0},{ I0_WZY, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* 01Y */
-	{3,{0,2,0,0},{ I0_YYY, I1___Z,
-		       I0_111, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 11Y */
-	{2,{0,2,0,0},{ I0_YYY, I1___Z,
-		       I0_111, I1_XY_,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	/* XXZ */
-	{2,{0,0,0,0},{ I0_XXX, I1_XY_,
-		       I0_ZZZ, I1___Z,
-		       0,0,0,0}},
-	/* YXZ */
-	{3,{0,0,0,0},{ I0_XXX, I1__Y_,
-		       I0_YYY, I1_X__,
-		       I0_ZZZ, I1___Z,
-		       0,0}},
-	/* ZXZ */
-	{2,{0,0,0,0},{ I0_XXX, I1__Y_,
-		       I0_ZZZ, I1_X_Z,
-		       0,0,0,0}},
-	/* WXZ */
-	{3,{0,0,0,0},{ I0_WZY, I1_XYZ,
-		       I0_XXX, I1__Y_,
-		       I0_ZZZ, I1___Z,
-		       0,0}},
-	/* 0XZ */
-	{3,{0,0,2,0},{ I0_XXX, I1__Y_,
-		       I0_ZZZ, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1XZ */
-	{3,{0,0,2,0},{ I0_XXX, I1__Y_,
-		       I0_ZZZ, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XYZ */
-	{1,{0,0,0,0},{ I0_XYZ, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* YYZ */
-	{2,{0,0,0,0},{ I0_ZZZ, I1___Z,
-		       I0_YYY, I1_XY_,
-		       0,0,0,0}},
-	/* ZYZ */
-	{2,{0,0,0,0},{ I0_ZZZ, I1_X_Z,
-		       I0_YYY, I1__Y_,
-		       0,0,0,0}},
-	/* WYZ */
-	{2,{0,0,0,0},{ I0_WZY, I1_XYZ,
-		       I0_XYZ, I1__YZ,
-		       0,0,0,0}},
-	/* 0YZ */
-	{2,{0,2,0,0},{ I0_XYZ, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1YZ */
-	{2,{0,2,0,0},{ I0_XYZ, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XZZ */
-	{2,{0,0,0,0},{ I0_ZZZ, I1__YZ,
-		       I0_XXX, I1_X__,
-		       0,0,0,0}},
-	/* YZZ */
-	{2,{0,0,0,0},{ I0_ZZZ, I1__YZ,
-		       I0_YYY, I1_X__,
-		       0,0,0,0}},
-	/* ZZZ */
-	{1,{0,0,0,0},{ I0_ZZZ, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* WZZ */
-	{2,{0,0,0,0},{ I0_WZY, I1_XYZ,
-		       I0_ZZZ, I1__YZ,
-		       0,0,0,0}},
-	/* 0ZZ */
-	{2,{0,2,0,0},{ I0_ZZZ, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1ZZ */
-	{2,{0,2,0,0},{ I0_ZZZ, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XWZ */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_XYZ, I1_X_Z,
-		       0,0,0,0}},
-	/* YWZ */
-	{3,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_YYY, I1_X__,
-		       I0_XYZ, I1___Z,
-		       0,0}},
-	/* ZWZ */
-	{2,{0,0,0,0},{ I0_WWW, I1__Y_,
-		       I0_ZZZ, I1_X_Z,
-		       0,0,0,0}},
-	/* WWZ */
-	{2,{0,0,0,0},{ I0_WWW, I1_XY_,
-		       I0_XYZ, I1___Z,
-		       0,0,0,0}},
-	/* 0WZ */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XYZ, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1WZ */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XYZ, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X0Z */
-	{2,{0,2,0,0},{ I0_XYZ, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* Y0Z */
-	{3,{0,2,0,0},{ I0_ZZZ, I1___Z,
-		       I0_000, I1__Y_,
-		       I0_YYY, I1_X__,
-		       0,0}},
-	/* Z0Z */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* W0Z */
-	{3,{0,0,2,0},{ I0_WZY, I1_X_Z,
-		       I0_ZZZ, I1___Z,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* 00Z */
-	{2,{0,2,0,0},{ I0_ZZZ, I1___Z,
-		       I0_000, I1_XY_,
-		       0,0,0,0}},
-	/* 10Z */
-	{3,{0,2,2,0},{ I0_ZZZ, I1___Z,
-		       I0_000, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X1Z */
-	{2,{0,2,0,0},{ I0_XYZ, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* Y1Z */
-	{3,{0,2,0,0},{ I0_ZZZ, I1___Z,
-		       I0_111, I1__Y_,
-		       I0_YYY, I1_X__,
-		       0,0}},
-	/* Z1Z */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* W1Z */
-	{3,{0,0,2,0},{ I0_WZY, I1_XYZ,
-		       I0_ZZZ, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* 01Z */
-	{3,{0,2,2,0},{ I0_ZZZ, I1___Z,
-		       I0_111, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 11Z */
-	{2,{0,2,0,0},{ I0_ZZZ, I1___Z,
-		       I0_111, I1_XY_,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	/* XXW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_XXX, I1_XY_,
-		       0,0,0,0}},
-	/* YXW */
-	{3,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_XXX, I1__Y_,
-		       I0_YYY, I1_X__,
-		       0,0}},
-	/* ZXW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_ZXY, I1_XY_,
-		       0,0,0,0}},
-	/* WXW */
-	{2,{0,0,0,0},{ I0_WWW, I1_X_Z,
-		       I0_XXX, I1__Y_,
-		       0,0,0,0}},
-	/* 0XW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_XXX, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1XW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_XXX, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XYW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_XYZ, I1_XY_,
-		       0,0,0,0}},
-	/* YYW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_YYY, I1_XY_,
-		       0,0}},
-	/* ZYW */
-	{3,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_XYZ, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       0,0}},
-	/* WYW */
-	{2,{0,0,0,0},{ I0_WWW, I1_X_Z,
-		       I0_YYY, I1__Y_,
-		       0,0,0,0}},
-	/* 0YW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_YYY, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1YW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_YYY, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-
-	SEMPTY,SEMPTY,
-	/* XZW */
-	{3,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_XYZ, I1_X__,
-		       I0_ZZZ, I1__Y_,
-		       0,0}},
-	/* YZW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_YZX, I1_XY_,
-		       0,0,0,0}},
-	/* ZZW */
-	{2,{0,0,0,0},{ I0_WWW, I1___Z,
-		       I0_ZZZ, I1_XY_,
-		       0,0,0,0}},
-	/* WZW */
-	{2,{0,0,0,0},{ I0_WWW, I1_X_Z,
-		       I0_ZZZ, I1__Y_,
-		       0,0,0,0}},
-	/* 0ZW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_ZZZ, I1__Y_,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1ZW */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_ZZZ, I1__Y_,
-		       I0_111, I1_X__,
-		       0,0}},
-
-	SEMPTY,SEMPTY,
-	/* XWW */
-	{2,{0,0,0,0},{ I0_WWW, I1__YZ,
-		       I0_XYZ, I1_X__,
-		       0,0,0,0}},
-	/* YWW */
-	{2,{0,0,0,0},{ I0_WWW, I1__YZ,
-		       I0_YYY, I1_X__,
-		       0,0,0,0}},
-	/* ZWW */
-	{2,{0,0,0,0},{ I0_WWW, I1__YZ,
-		       I0_ZZZ, I1_X__,
-		       0,0,0,0}},
-	/* WWW */
-	{1,{0,0,0,0},{ I0_WWW, I1_XYZ,
-		       0,0,0,0,0,0}},
-	/* 0WW */
-	{2,{0,2,0,0},{ I0_WWW, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 1WW */
-	{2,{0,2,0,0},{ I0_WWW, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X0W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_XYZ, I1_X__,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* Y0W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_YYY, I1_X__,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* Z0W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_ZZZ, I1_X__,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* W0W */
-	{2,{0,2,0,0},{ I0_WWW, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0,0,0,0}},
-	/* 00W */
-	{2,{0,2,0,0},{ I0_WWW, I1___Z,
-		       I0_000, I1_XY_,
-		       0,0,0,0}},
-	/* 10W */
-	{3,{0,2,2,0},{ I0_WWW, I1___Z,
-		       I0_111, I1_X__,
-		       I0_000, I1__Y_,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X1W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_XYZ, I1_X__,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* Y1W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_YYY, I1_X__,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* Z1W */
-	{3,{0,0,2,0},{ I0_WWW, I1___Z,
-		       I0_ZZZ, I1_X__,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* W1W */
-	{2,{0,2,0,0},{ I0_WWW, I1_XYZ,
-		       I0_111, I1__Y_,
-		       0,0,0,0}},
-	/* 01W */
-	{3,{0,2,2,0},{ I0_WWW, I1___Z,
-		       I0_000, I1_X__,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* 11W */
-	{2,{0,2,0,0},{ I0_WWW, I1___Z,
-		       I0_111, I1_XY_,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	/* XX0 */
-	{2,{0,2,0,0},{ I0_XXX, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* YX0 */
-	{3,{0,0,2,0},{ I0_YYY, I1_X__,
-		       I0_XXX, I1__Y_,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* ZX0 */
-	{2,{0,2,0,0},{ I0_ZXY, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* WX0 */
-	{3,{0,0,2,0},{ I0_WZY, I1_X__,
-		       I0_XXX, I1__Y_,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* 0X0 */
-	{2,{0,2,0,0},{ I0_XXX, I1__Y_,
-		       I0_000, I1_X_Z,
-		       0,0,0,0}},
-	/* 1X0 */
-	{3,{0,2,2,0},{ I0_XXX, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XY0 */
-	{2,{0,2,0,0},{ I0_XYZ, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* YY0 */
-	{2,{0,2,0,0},{ I0_YYY, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* ZY0 */
-	{3,{0,0,2,0},{ I0_YYY, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* WY0 */
-	{3,{0,0,2,0},{ I0_WZY, I1_X__,
-		       I0_XYZ, I1__Y_,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* 0Y0 */
-	{2,{0,2,0,0},{ I0_XYZ, I1__Y_,
-		       I0_000, I1_X_Z,
-		       0,0,0,0}},
-	/* 1Y0 */
-	{3,{0,2,2,0},{ I0_XYZ, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XZ0 */
-	{3,{0,0,2,0},{ I0_ZZZ, I1__Y_,
-		       I0_XYZ, I1_X__,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* YZ0 */
-	{2,{0,2,0,0},{ I0_YZX, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* ZZ0 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* WZ0 */
-	{3,{0,0,2,0},{ I0_XYZ, I1_XYZ,
-		       I0_WZY, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* 0Z0 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1__Y_,
-		       I0_000, I1_X_Z,
-		       0,0,0,0}},
-	/* 1Z0 */
-	{3,{0,2,2,0},{ I0_ZZZ, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* XW0 */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XYZ, I1_X__,
-		       I0_000, I1___Z,
-		       0,0}},
-	/* YW0 */
-	{3,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_YYY, I1_X__,
-		       0,0}},
-	/* ZW0 */
-	{3,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_ZZZ, I1_X__,
-		       0,0}},
-	/* WW0 */
-	{2,{0,2,0,0},{ I0_WWW, I1_XY_,
-		       I0_000, I1___Z,
-		       0,0,0,0}},
-	/* 0W0 */
-	{2,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_000, I1_X_Z,
-		       0,0,0,0}},
-	/* 1W0 */
-	{3,{0,2,2,0},{ I0_WWW, I1__Y_,
-		       I0_000, I1___Z,
-		       I0_111, I1_X__,
-		       0,0}},
-	SEMPTY,SEMPTY,
-	/* X00 */
-	{2,{0,2,0,0},{ I0_XYZ, I1_X__,
-		       I0_000, I1__YZ,
-		       0,0,0,0}},
-	/* Y00 */
-	{2,{0,2,0,0},{ I0_YYY, I1_X__,
-		       I0_000, I1__YZ,
-		       0,0,0,0}},
-	/* Z00 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_X__,
-		       I0_000, I1__YZ,
-		       0,0,0,0}},
-	/* W00 */
-	{2,{2,0,0,0},{ I0_WZY, I1_X__,
-		       I0_000, I1__YZ,
-		       0,0,0,0}},
-	/* 000 */
-	{1,{2,0,0,0},{ I0_000, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	/* 100 */
-	{2,{2,2,0,0},{ I0_000, I1__YZ,
-		       I0_111, I1_X__,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* X10 */
-	{3,{0,2,2,0},{ I0_XYZ, I1_XYZ,
-		       I0_000, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* Y10 */
-	{3,{0,2,2,0},{ I0_YYY, I1_XYZ,
-		       I0_000, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* Z10 */
-	{3,{0,2,2,0},{ I0_ZZZ, I1_XYZ,
-		       I0_000, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* W10 */
-	{3,{0,2,2,0},{ I0_WZY, I1_XYZ,
-		       I0_000, I1___Z,
-		       I0_111, I1__Y_,
-		       0,0}},
-	/* 010 */
-	{2,{2,2,0,0},{ I0_000, I1_X_Z,
-		       I0_111, I1__Y_,
-		       0, 0, 0, 0 } },
-	/* 110 */
-	{2,{2,2,0,0},{ I0_000, I1___Z,
-		       I0_111, I1_XY_,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-
-
-
-	/* XX1 */
-	{2,{0,2,0,0},{ I0_XXX, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* YX1 */
-	{3,{0,0,2,0},{ I0_YYY, I1_X__,
-		       I0_XXX, I1__Y_,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* ZX1 */
-	{2,{0,2,0,0},{ I0_ZXY, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* WX1 */
-	{3,{0,0,2,0},{ I0_WZY, I1_XYZ,
-		       I0_XXX, I1__Y_,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* 0X1 */
-	{3,{0,2,2,0},{ I0_XXX, I1__Y_,
-		       I0_111, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1X1 */
-	{2,{0,2,0,0},{ I0_XXX, I1__Y_,
-		       I0_111, I1_X_Z,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XY1 */
-	{2,{0,2,0,0},{ I0_XYZ, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* YY1 */
-	{2,{0,2,0,0},{ I0_YYY, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* ZY1 */
-	{3,{0,0,2,0},{ I0_YYY, I1__Y_,
-		       I0_ZZZ, I1_X__,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* WY1 */
-	{3,{0,0,2,0},{ I0_WZY, I1_XYZ,
-		       I0_XYZ, I1__Y_,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* 0Y1 */
-	{3,{0,2,2,0},{ I0_XYZ, I1__Y_,
-		       I0_111, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1Y1 */
-	{2,{0,2,0,0},{ I0_XYZ, I1__Y_,
-		       I0_111, I1_X_Z,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XZ1 */
-	{3,{0,0,2,0},{ I0_ZZZ, I1__Y_,
-		       I0_XYZ, I1_X__,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* YZ1 */
-	{2,{0,2,0,0},{ I0_YZX, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* ZZ1 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_XYZ,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* WZ1 */
-	{2,{0,2,0,0},{ I0_WZY, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* 0Z1 */
-	{3,{0,2,2,0},{ I0_ZZZ, I1_XYZ,
-		       I0_111, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1Z1 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1__Y_,
-		       I0_111, I1_X_Z,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* XW1 */
-	{3,{0,0,2,0},{ I0_WWW, I1__Y_,
-		       I0_XYZ, I1_X__,
-		       I0_111, I1___Z,
-		       0,0}},
-	/* YW1 */
-	{3,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_111, I1___Z,
-		       I0_YYY, I1_X__,
-		       0,0}},
-	/* ZW1 */
-	{3,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_111, I1___Z,
-		       I0_ZZZ, I1_X__,
-		       0,0}},
-	/* WW1 */
-	{2,{0,2,0,0},{ I0_WWW, I1_XY_,
-		       I0_111, I1___Z,
-		       0,0,0,0}},
-	/* 0W1 */
-	{3,{0,2,2,0},{ I0_WWW, I1__Y_,
-		       I0_111, I1___Z,
-		       I0_000, I1_X__,
-		       0,0}},
-	/* 1W1 */
-	{2,{0,2,0,0},{ I0_WWW, I1__Y_,
-		       I0_111, I1_X_Z,
-		       0,0,0,0}},
-	SEMPTY,SEMPTY,
-	/* X01 */
-	{3,{0,2,2,0},{ I0_XYZ, I1_X__,
-		       I0_111, I1___Z,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* Y01 */
-	{3,{0,2,2,0},{ I0_YYY, I1_X__,
-		       I0_111, I1___Z,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* Z01 */
-	{3,{0,2,2,0},{ I0_ZZZ, I1_X__,
-		       I0_111, I1___Z,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* W01 */
-	{3,{0,2,2,0},{ I0_WZY, I1_XYZ,
-		       I0_111, I1___Z,
-		       I0_000, I1__Y_,
-		       0,0}},
-	/* 001 */
-	{2,{2,2,0,0},{ I0_111, I1___Z,
-		       I0_000, I1_XY_,
-		       0,0,0,0}},
-	/* 101 */
-	{2,{2,2,0,0},{ I0_111, I1_X_Z,
-		       I0_000, I1__Y_,
-		       0, 0, 0, 0 } },
-	SEMPTY,SEMPTY,
-	/* X11 */
-	{2,{0,2,0,0},{ I0_XYZ, I1_X__,
-		       I0_111, I1__YZ,
-		       0,0,0,0}},
-	/* Y11 */
-	{2,{0,2,0,0},{ I0_YYY, I1_X__,
-		       I0_111, I1__YZ,
-		       0,0,0,0}},
-	/* Z11 */
-	{2,{0,2,0,0},{ I0_ZZZ, I1_X__,
-		       I0_111, I1__YZ,
-		       0,0,0,0}},
-	/* W11 */
-	{2,{0,2,0,0},{ I0_WZY, I1_XYZ,
-		       I0_111, I1__YZ,
-		       0,0,0,0}},
-	/* 011 */
-	{2,{2,2,0,0},{ I0_111, I1__YZ,
-		       I0_000, I1_X__,
-		       0,0,0,0}},
-	/* 111 */
-	{1,{2,0,0,0},{ I0_111, I1_XYZ,
-		       0, 0, 0, 0, 0, 0 } },
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,
-	SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY,SEMPTY
-};
-
-/******************************************************************************
-* Color source mask table
-******************************************************************************/
-
-#define S_111	R300_FPI0_ARGC_ONE
-#define S_000	R300_FPI0_ARGC_ZERO
-
-#define S0XXX	R300_FPI0_ARGC_SRC0C_XXX
-#define S0YYY	R300_FPI0_ARGC_SRC0C_YYY
-#define S0ZZZ	R300_FPI0_ARGC_SRC0C_ZZZ
-#define S0WWW	R300_FPI0_ARGC_SRC0A
-#define S0XYZ	R300_FPI0_ARGC_SRC0C_XYZ
-#define S0ZXY	R300_FPI0_ARGC_SRC0C_ZXY
-#define S0YZX	R300_FPI0_ARGC_SRC0C_YZX
-#define S0WZY	R300_FPI0_ARGC_SRC0CA_WZY
-#define S0WZY	R300_FPI0_ARGC_SRC0CA_WZY
-
-#define S1XXX	R300_FPI0_ARGC_SRC1C_XXX
-#define S1YYY	R300_FPI0_ARGC_SRC1C_YYY
-#define S1ZZZ	R300_FPI0_ARGC_SRC1C_ZZZ
-#define S1WWW	R300_FPI0_ARGC_SRC1A
-#define S1XYZ	R300_FPI0_ARGC_SRC1C_XYZ
-#define S1ZXY	R300_FPI0_ARGC_SRC1C_ZXY
-#define S1YZX	R300_FPI0_ARGC_SRC1C_YZX
-#define S1WZY	R300_FPI0_ARGC_SRC1CA_WZY
-
-#define S2XXX	R300_FPI0_ARGC_SRC2C_XXX
-#define S2YYY	R300_FPI0_ARGC_SRC2C_YYY
-#define S2ZZZ	R300_FPI0_ARGC_SRC2C_ZZZ
-#define S2WWW	R300_FPI0_ARGC_SRC2A
-#define S2XYZ	R300_FPI0_ARGC_SRC2C_XYZ
-#define S2ZXY	R300_FPI0_ARGC_SRC2C_ZXY
-#define S2YZX	R300_FPI0_ARGC_SRC2C_YZX
-#define S2WZY	R300_FPI0_ARGC_SRC2CA_WZY
-
-#define ntnat	32
-
-const GLuint r300_swz_srcc_mask[3][512] = {
-	{
-		S0XXX,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S0YZX,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S0ZXY,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S0YYY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S0WZY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S0XYZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S0ZZZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S0WWW,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,S_000,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,S_111,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat
-	},
-	{
-		S1XXX,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S1YZX,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S1ZXY,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S1YYY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S1WZY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S1XYZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S1ZZZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S1WWW,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,S_000,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,S_111,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat
-	},
-	{
-		S2XXX,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S2YZX,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S2ZXY,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S2YYY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,S2WZY,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S2XYZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S2ZZZ,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,S2WWW,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,S_000,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,S_111,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,ntnat,
-		ntnat,ntnat
-	}
-};
-
-/******************************************************************************
-* Alpha source mask table
-******************************************************************************/
-
-GLuint r300_swz_srca_mask[3][6] = {
-	{ R300_FPI2_ARGA_SRC0C_X,
-	  R300_FPI2_ARGA_SRC0C_Y,
-	  R300_FPI2_ARGA_SRC0C_Z,
-	  R300_FPI2_ARGA_SRC0A,
-	  R300_FPI2_ARGA_ZERO,
-	  R300_FPI2_ARGA_ONE },
-	{ R300_FPI2_ARGA_SRC1C_X,
-	  R300_FPI2_ARGA_SRC1C_Y,
-	  R300_FPI2_ARGA_SRC1C_Z,
-	  R300_FPI2_ARGA_SRC1A,
-	  R300_FPI2_ARGA_ZERO,
-	  R300_FPI2_ARGA_ONE },
-	{ R300_FPI2_ARGA_SRC2C_X,
-	  R300_FPI2_ARGA_SRC2C_Y,
-	  R300_FPI2_ARGA_SRC2C_Z,
-	  R300_FPI2_ARGA_SRC2A,
-	  R300_FPI2_ARGA_ZERO,
-	  R300_FPI2_ARGA_ONE },
-};
diff --git a/src/mesa/drivers/dri/r300/r300_ioctl.c b/src/mesa/drivers/dri/r300/r300_ioctl.c
index 87276a11ae..0774a2af6b 100644
--- a/src/mesa/drivers/dri/r300/r300_ioctl.c
+++ b/src/mesa/drivers/dri/r300/r300_ioctl.c
@@ -570,9 +570,10 @@ void r300Flush(GLcontext * ctx)
 #ifdef USER_BUFFERS
 #include "radeon_mm.h"
 
-void r300RefillCurrentDmaRegion(r300ContextPtr rmesa)
+void r300RefillCurrentDmaRegion(r300ContextPtr rmesa, int size)
 {
 	struct r300_dma_buffer *dmabuf;
+	size = MAX2(size, RADEON_BUFFER_SIZE*16);
 	
 	if (RADEON_DEBUG & (DEBUG_IOCTL | DEBUG_DMA))
 		fprintf(stderr, "%s\n", __FUNCTION__);
@@ -591,20 +592,20 @@ void r300RefillCurrentDmaRegion(r300ContextPtr rmesa)
 	dmabuf->buf = (void *)1; /* hack */
 	dmabuf->refcount = 1;
 
-	dmabuf->id = radeon_mm_alloc(rmesa, 4, RADEON_BUFFER_SIZE*16);
+	dmabuf->id = radeon_mm_alloc(rmesa, 4, size);
 	if (dmabuf->id == 0) {
 		LOCK_HARDWARE(&rmesa->radeon);	/* no need to validate */
 		
 		r300FlushCmdBufLocked(rmesa, __FUNCTION__);
 		radeonWaitForIdleLocked(&rmesa->radeon);
 		
-		dmabuf->id = radeon_mm_alloc(rmesa, 4, RADEON_BUFFER_SIZE*16);
+		dmabuf->id = radeon_mm_alloc(rmesa, 4, size);
 
 #ifdef HW_VBOS
 		if (dmabuf->id == 0) {
 			/* Just kick all */
 			r300_evict_vbos(rmesa->radeon.glCtx, /*RADEON_BUFFER_SIZE*16*/1<<30);
-			dmabuf->id = radeon_mm_alloc(rmesa, 4, RADEON_BUFFER_SIZE*16);
+			dmabuf->id = radeon_mm_alloc(rmesa, 4, size);
 		}
 #endif
 		UNLOCK_HARDWARE(&rmesa->radeon);
@@ -617,7 +618,7 @@ void r300RefillCurrentDmaRegion(r300ContextPtr rmesa)
 			
 	rmesa->dma.current.buf = dmabuf;
 	rmesa->dma.current.address = radeon_mm_ptr(rmesa, dmabuf->id);
-	rmesa->dma.current.end = RADEON_BUFFER_SIZE*16;
+	rmesa->dma.current.end = size;
 	rmesa->dma.current.start = 0;
 	rmesa->dma.current.ptr = 0;
 }
@@ -665,7 +666,8 @@ void r300AllocDmaRegion(r300ContextPtr rmesa,
 	    (rmesa->dma.current.ptr + alignment) & ~alignment;
 
 	if (rmesa->dma.current.ptr + bytes > rmesa->dma.current.end)
-		r300RefillCurrentDmaRegion(rmesa);
+		r300RefillCurrentDmaRegion(rmesa,
+					   (bytes + 0x7) & ~0x7);
 
 	region->start = rmesa->dma.current.start;
 	region->ptr = rmesa->dma.current.start;
diff --git a/src/mesa/drivers/dri/r300/r300_ioctl.h b/src/mesa/drivers/dri/r300/r300_ioctl.h
index 5514214cc6..52325646e9 100644
--- a/src/mesa/drivers/dri/r300/r300_ioctl.h
+++ b/src/mesa/drivers/dri/r300/r300_ioctl.h
@@ -50,7 +50,6 @@ extern GLuint r300GartOffsetFromVirtual(r300ContextPtr rmesa,
 
 extern void r300Flush(GLcontext * ctx);
 
-extern void r300RefillCurrentDmaRegion(r300ContextPtr rmesa);
 extern void r300ReleaseDmaRegion(r300ContextPtr rmesa,
 			  struct r300_dma_region *region, const char *caller);
 extern void r300AllocDmaRegion(r300ContextPtr rmesa,
diff --git a/src/mesa/drivers/dri/r300/r300_maos.c b/src/mesa/drivers/dri/r300/r300_maos.c
index 2fdad519fd..fcb87cbbb5 100644
--- a/src/mesa/drivers/dri/r300/r300_maos.c
+++ b/src/mesa/drivers/dri/r300/r300_maos.c
@@ -407,8 +407,8 @@ int r300EmitArrays(GLcontext *ctx)
 	if (hw_tcl_on) {
 		struct r300_vertex_program *prog=(struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
 		inputs = prog->inputs;
-		InputsRead = CURRENT_VERTEX_SHADER(ctx)->Base.InputsRead;
-		OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->Base.OutputsWritten;
+		InputsRead = CURRENT_VERTEX_SHADER(ctx)->key.InputsRead;
+		OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->key.OutputsWritten;
 	} else {
 		DECLARE_RENDERINPUTS(inputs_bitset);
 		inputs = r300->state.sw_tcl_inputs;
diff --git a/src/mesa/drivers/dri/r300/r300_shader.c b/src/mesa/drivers/dri/r300/r300_shader.c
index 576b18953f..26721e8dfd 100644
--- a/src/mesa/drivers/dri/r300/r300_shader.c
+++ b/src/mesa/drivers/dri/r300/r300_shader.c
@@ -12,13 +12,13 @@ r300BindProgram(GLcontext *ctx, GLenum target, struct gl_program *prog)
 {
 	
 	r300ContextPtr rmesa = R300_CONTEXT(ctx);
-	struct r300_vertex_program *vp=(void *)prog;
+	struct r300_vertex_program_cont *vp=(void *)prog;
 	
 	
 	switch(target){
 		case GL_VERTEX_PROGRAM_ARB:
-		rmesa->curr_vp = (struct gl_vertex_program *)vp;
-		vp->ref_count++;
+		//rmesa->curr_vp = (struct gl_vertex_program *)vp;
+		//vp->ref_count++;
 #if 0
 		if((vp->ref_count % 1500) == 0) {
 			fprintf(stderr, "id %p, ref_count %d\n", vp, vp->ref_count);
@@ -37,13 +37,13 @@ r300BindProgram(GLcontext *ctx, GLenum target, struct gl_program *prog)
 static struct gl_program *
 r300NewProgram(GLcontext *ctx, GLenum target, GLuint id)
 {
-	struct r300_vertex_program *vp;
+	struct r300_vertex_program_cont *vp;
 	struct r300_fragment_program *fp;
 	
 	switch(target){
 		case GL_VERTEX_STATE_PROGRAM_NV:
 		case GL_VERTEX_PROGRAM_ARB:
-			vp=CALLOC_STRUCT(r300_vertex_program);
+			vp=CALLOC_STRUCT(r300_vertex_program_cont);
 			return _mesa_init_vertex_program(ctx, &vp->mesa_program, target, id);
 		case GL_FRAGMENT_PROGRAM_ARB:
 			fp=CALLOC_STRUCT(r300_fragment_program);
@@ -77,13 +77,14 @@ r300DeleteProgram(GLcontext *ctx, struct gl_program *prog)
 static void
 r300ProgramStringNotify(GLcontext *ctx, GLenum target, struct gl_program *prog)
 {
-	struct r300_vertex_program *vp=(void *)prog;
+	struct r300_vertex_program_cont *vp=(void *)prog;
 	struct r300_fragment_program *fp = (struct r300_fragment_program *) prog;
 	
 	switch(target) {
 	case GL_VERTEX_PROGRAM_ARB:
-		vp->translated = GL_FALSE;
-		memset(&vp->translated, 0, sizeof(struct r300_vertex_program) - sizeof(struct gl_vertex_program));
+		vp->progs = NULL;
+		/*vp->translated = GL_FALSE;
+		memset(&vp->translated, 0, sizeof(struct r300_vertex_program) - sizeof(struct gl_vertex_program));*/
 		/*r300_translate_vertex_shader(vp);*/
 	break;
 	case GL_FRAGMENT_PROGRAM_ARB:
diff --git a/src/mesa/drivers/dri/r300/r300_state.c b/src/mesa/drivers/dri/r300/r300_state.c
index 6aff04fd27..1930a683f1 100644
--- a/src/mesa/drivers/dri/r300/r300_state.c
+++ b/src/mesa/drivers/dri/r300/r300_state.c
@@ -206,7 +206,7 @@ static void r300_set_blend_state(GLcontext * ctx)
 	    (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
 	int eqnA = R300_COMB_FCN_ADD_CLAMP;
 
-	if (ctx->Color._LogicOpEnabled || !ctx->Color.BlendEnabled) {
+	if (RGBA_LOGICOP_ENABLED(ctx) || !ctx->Color.BlendEnabled) {
 		r300_set_blend_cntl(r300,
 			func, eqn, 0,
 			func, eqn);
@@ -1044,6 +1044,59 @@ r300UpdateDrawBuffer(GLcontext *ctx)
 #endif
 }
 
+static void r300FetchStateParameter(GLcontext *ctx, const enum state_index state[],
+                  GLfloat *value)
+{
+    r300ContextPtr r300 = R300_CONTEXT(ctx);
+
+    switch(state[0])
+    {
+    case STATE_INTERNAL:
+    	switch(state[1])
+	{
+	case STATE_R300_WINDOW_DIMENSION:
+	    value[0] = r300->radeon.dri.drawable->w;	/* width */
+    	    value[1] = r300->radeon.dri.drawable->h;	/* height */
+	    value[2] = 0.5F; 				/* for moving range [-1 1] -> [0 1] */
+    	    value[3] = 1.0F; 				/* not used */
+	    break;
+	default:;
+	}
+    default:;
+    }
+}
+
+/**
+ * Update R300's own internal state parameters.
+ * For now just STATE_R300_WINDOW_DIMENSION
+ */
+static void r300UpdateStateParameters(GLcontext * ctx, GLuint new_state)
+{
+	struct r300_vertex_program_cont *vpc;
+	struct gl_program_parameter_list *paramList;
+	GLuint i;
+
+	if(!(new_state & (_NEW_BUFFERS|_NEW_PROGRAM)))
+	    return;
+
+	vpc = (struct r300_vertex_program_cont *)ctx->VertexProgram._Current;
+	if (!vpc)
+	    return;
+
+	paramList = vpc->mesa_program.Base.Parameters;
+
+	if (!paramList)
+	    return;
+
+	for (i = 0; i < paramList->NumParameters; i++) {
+		if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR){
+			r300FetchStateParameter(ctx,
+				    paramList->Parameters[i].StateIndexes,
+				    paramList->ParameterValues[i]);
+		}
+	}
+}
+
 /* =============================================================
  * Polygon state
  */
@@ -1285,7 +1338,7 @@ void r300_setup_rs_unit(GLcontext *ctx)
 	int i;
 
 	if(hw_tcl_on)
-		OutputsWritten.vp_outputs = CURRENT_VERTEX_SHADER(ctx)->Base.OutputsWritten;
+		OutputsWritten.vp_outputs = CURRENT_VERTEX_SHADER(ctx)->key.OutputsWritten;
 	else
 		RENDERINPUTS_COPY( OutputsWritten.index_bitset, r300->state.render_inputs_bitset );
 
@@ -1304,6 +1357,20 @@ void r300_setup_rs_unit(GLcontext *ctx)
 
 	r300->hw.rr.cmd[R300_RR_ROUTE_1] = 0;
 	
+	if (InputsRead & FRAG_BIT_WPOS){
+		for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
+			if (!(InputsRead & (FRAG_BIT_TEX0 << i)))
+				break;
+
+		if(i == ctx->Const.MaxTextureUnits){
+			fprintf(stderr, "\tno free texcoord found...\n");
+			exit(0);
+		}
+
+		InputsRead |= (FRAG_BIT_TEX0 << i);
+		InputsRead &= ~FRAG_BIT_WPOS;
+	}
+	
 	for (i=0;i<ctx->Const.MaxTextureUnits;i++) {
 		r300->hw.ri.cmd[R300_RI_INTERP_0+i] = 0
 				| R300_RS_INTERP_USED
@@ -1610,7 +1677,7 @@ void r300SetupVertexProgram(r300ContextPtr rmesa)
 
 	((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
 	R300_STATECHANGE(rmesa, vpp);
-	param_count = r300VertexProgUpdateParams(ctx, prog, (float *)&rmesa->hw.vpp.cmd[R300_VPP_PARAM_0]);
+	param_count = r300VertexProgUpdateParams(ctx, (struct r300_vertex_program_cont *)ctx->VertexProgram._Current/*prog*/, (float *)&rmesa->hw.vpp.cmd[R300_VPP_PARAM_0]);
 	bump_vpu_count(rmesa->hw.vpp.cmd, param_count);
 	param_count /= 4;
 	
@@ -1669,9 +1736,10 @@ void r300UpdateShaders(r300ContextPtr rmesa)
 			TNL_CONTEXT(ctx)->vb.AttribPtr[i] = rmesa->temp_attrib[i];
 		}
 		
+		r300_select_vertex_shader(rmesa);
 		vp = (struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
-		if (vp->translated == GL_FALSE)
-			r300_translate_vertex_shader(vp);
+		/*if (vp->translated == GL_FALSE)
+			r300_translate_vertex_shader(vp);*/
 		if (vp->translated == GL_FALSE) {
 			fprintf(stderr, "Failing back to sw-tcl\n");
 			hw_tcl_on = future_hw_tcl_on = 0;
@@ -1679,6 +1747,7 @@ void r300UpdateShaders(r300ContextPtr rmesa)
 
 			return ;
 		}
+		r300UpdateStateParameters(ctx, _NEW_PROGRAM);
 	}
 	
 }
@@ -1812,6 +1881,9 @@ static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
 	if (new_state & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) {
 		r300UpdateDrawBuffer(ctx);
 	}
+
+	r300UpdateStateParameters(ctx, new_state);
+
 #ifndef CB_DPATH
 	/* Go inefficiency! */
 	r300ResetHwState(r300);
diff --git a/src/mesa/drivers/dri/r300/r300_vertexprog.c b/src/mesa/drivers/dri/r300/r300_vertexprog.c
index cc932b86d9..c08c98767e 100644
--- a/src/mesa/drivers/dri/r300/r300_vertexprog.c
+++ b/src/mesa/drivers/dri/r300/r300_vertexprog.c
@@ -95,7 +95,7 @@ static struct{
 };
 #undef OPN
 	
-int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program *vp, float *dst)
+int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program_cont *vp, float *dst)
 {
 	int pi;
 	struct gl_vertex_program *mesa_vp = &vp->mesa_program;
@@ -177,17 +177,9 @@ static unsigned long t_dst_class(enum register_file file)
 
 static unsigned long t_dst_index(struct r300_vertex_program *vp, struct prog_dst_register *dst)
 {
-	if(dst->File == PROGRAM_OUTPUT) {
-		if (vp->outputs[dst->Index] != -1)
-			return vp->outputs[dst->Index];
-		else {
-			WARN_ONCE("Unknown output %d\n", dst->Index);
-			return 10;
-		}
-	}else if(dst->File == PROGRAM_ADDRESS) {
-		assert(dst->Index == 0);
-	}
-	
+	if(dst->File == PROGRAM_OUTPUT)
+		return vp->outputs[dst->Index];
+
 	return dst->Index;
 }
 
@@ -335,6 +327,18 @@ static unsigned long op_operands(enum prog_opcode opcode)
 	return 0;
 }
 
+static GLboolean valid_dst(struct r300_vertex_program *vp, struct prog_dst_register *dst)
+{
+	if(dst->File == PROGRAM_OUTPUT && vp->outputs[dst->Index] == -1){
+		WARN_ONCE("Output %d not used by fragment program\n", dst->Index);
+		return GL_FALSE;
+	}else if(dst->File == PROGRAM_ADDRESS) {
+		assert(dst->Index == 0);
+	}
+	
+	return GL_TRUE;
+}
+
 /* TODO: Get rid of t_src_class call */
 #define CMP_SRCS(a, b) ((a.RelAddr != b.RelAddr) || (a.Index != b.Index && \
 		       ((t_src_class(a.File) == VSF_IN_CLASS_PARAM && \
@@ -384,10 +388,8 @@ static unsigned long op_operands(enum prog_opcode opcode)
 		u_temp_i=VSF_MAX_FRAGMENT_TEMPS-1; \
 	} while (0)
 
-void r300_translate_vertex_shader(struct r300_vertex_program *vp)
+static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct prog_instruction *vpi)
 {
-	struct gl_vertex_program *mesa_vp= &vp->mesa_program;
-	struct prog_instruction *vpi;
 	int i, cur_reg=0;
 	VERTEX_SHADER_INSTRUCTION *o_inst;
 	unsigned long operands;
@@ -399,131 +401,9 @@ void r300_translate_vertex_shader(struct r300_vertex_program *vp)
 	int u_temp_i=VSF_MAX_FRAGMENT_TEMPS-1;
 	struct prog_src_register src[3];
 
-	if (mesa_vp->Base.NumInstructions == 0)
-		return;
-
-	if (getenv("R300_VP_SAFETY")) {
-		WARN_ONCE("R300_VP_SAFETY enabled.\n");
-		
-		vpi = malloc((mesa_vp->Base.NumInstructions + VSF_MAX_FRAGMENT_TEMPS) * sizeof(struct prog_instruction));
-		memset(vpi, 0, VSF_MAX_FRAGMENT_TEMPS * sizeof(struct prog_instruction));
-		
-		for (i=0; i < VSF_MAX_FRAGMENT_TEMPS; i++) {
-			vpi[i].Opcode = OPCODE_MOV;
-			vpi[i].StringPos = 0;
-			vpi[i].Data = 0;
-			
-			vpi[i].DstReg.File = PROGRAM_TEMPORARY;
-			vpi[i].DstReg.Index = i;
-			vpi[i].DstReg.WriteMask = WRITEMASK_XYZW;
-			vpi[i].DstReg.CondMask = COND_TR;
-					
-			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
-			vpi[i].SrcReg[0].Index = 0;
-			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_ONE, SWIZZLE_ONE, SWIZZLE_ONE, SWIZZLE_ONE);
-		}
-		
-		memcpy(&vpi[i], mesa_vp->Base.Instructions, mesa_vp->Base.NumInstructions * sizeof(struct prog_instruction));
-		
-		free(mesa_vp->Base.Instructions);
-		
-		mesa_vp->Base.Instructions = vpi;
-		
-		mesa_vp->Base.NumInstructions += VSF_MAX_FRAGMENT_TEMPS;
-		vpi = &mesa_vp->Base.Instructions[mesa_vp->Base.NumInstructions-1];
-		
-		assert(vpi->Opcode == OPCODE_END);
-	}
-	
-	if (mesa_vp->IsPositionInvariant) {
-		struct gl_program_parameter_list *paramList;
-		GLint tokens[6] = { STATE_MATRIX, STATE_MVP, 0, 0, 0, STATE_MATRIX };
-
-#ifdef PREFER_DP4
-		tokens[5] = STATE_MATRIX;
-#else
-		tokens[5] = STATE_MATRIX_TRANSPOSE;
-#endif
-		paramList = mesa_vp->Base.Parameters;
-		
-		vpi = malloc((mesa_vp->Base.NumInstructions + 4) * sizeof(struct prog_instruction));
-		memset(vpi, 0, 4 * sizeof(struct prog_instruction));
-		
-		for (i=0; i < 4; i++) {
-			GLint idx;
-			tokens[3] = tokens[4] = i;
-			idx = _mesa_add_state_reference(paramList, tokens);
-#ifdef PREFER_DP4
-			vpi[i].Opcode = OPCODE_DP4;
-			vpi[i].StringPos = 0;
-			vpi[i].Data = 0;
-			
-			vpi[i].DstReg.File = PROGRAM_OUTPUT;
-			vpi[i].DstReg.Index = VERT_RESULT_HPOS;
-			vpi[i].DstReg.WriteMask = 1 << i;
-			vpi[i].DstReg.CondMask = COND_TR;
-					
-			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
-			vpi[i].SrcReg[0].Index = idx;
-			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
-			
-			vpi[i].SrcReg[1].File = PROGRAM_INPUT;
-			vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
-			vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
-#else
-			if (i == 0)
-				vpi[i].Opcode = OPCODE_MUL;
-			else
-				vpi[i].Opcode = OPCODE_MAD;
-			
-			vpi[i].StringPos = 0;
-			vpi[i].Data = 0;
-			
-			if (i == 3)
-				vpi[i].DstReg.File = PROGRAM_OUTPUT;
-			else
-				vpi[i].DstReg.File = PROGRAM_TEMPORARY;
-			vpi[i].DstReg.Index = 0;
-			vpi[i].DstReg.WriteMask = 0xf;
-			vpi[i].DstReg.CondMask = COND_TR;
-					
-			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
-			vpi[i].SrcReg[0].Index = idx;
-			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
-			
-			vpi[i].SrcReg[1].File = PROGRAM_INPUT;
-			vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
-			vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(i, i, i, i);
-			
-			if (i > 0) {
-				vpi[i].SrcReg[2].File = PROGRAM_TEMPORARY;
-				vpi[i].SrcReg[2].Index = 0;
-				vpi[i].SrcReg[2].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
-			}
-#endif					
-		}
-		
-		memcpy(&vpi[i], mesa_vp->Base.Instructions, mesa_vp->Base.NumInstructions * sizeof(struct prog_instruction));
-		
-		free(mesa_vp->Base.Instructions);
-		
-		mesa_vp->Base.Instructions = vpi;
-		
-		mesa_vp->Base.NumInstructions += 4;
-		vpi = &mesa_vp->Base.Instructions[mesa_vp->Base.NumInstructions-1];
-		
-		assert(vpi->Opcode == OPCODE_END);
-		
-		mesa_vp->Base.InputsRead |= (1 << VERT_ATTRIB_POS);
-		mesa_vp->Base.OutputsWritten |= (1 << VERT_RESULT_HPOS);
-		
-		//fprintf(stderr, "IsPositionInvariant is set!\n");
-		//_mesa_print_program(&mesa_vp->Base);
-	}
-	
 	vp->pos_end=0; /* Not supported yet */
 	vp->program.length=0;
-	vp->num_temporaries=mesa_vp->Base.NumTemporaries;
+	/*vp->num_temporaries=mesa_vp->Base.NumTemporaries;*/
 	
 	for(i=0; i < VERT_ATTRIB_MAX; i++)
 		vp->inputs[i] = -1;
@@ -531,42 +411,49 @@ void r300_translate_vertex_shader(struct r300_vertex_program *vp)
 	for(i=0; i < VERT_RESULT_MAX; i++)
 		vp->outputs[i] = -1;
 	
-	assert(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_HPOS));
+	assert(vp->key.OutputsWritten & (1 << VERT_RESULT_HPOS));
 	
 	/* Assign outputs */
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_HPOS))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_HPOS))
 		vp->outputs[VERT_RESULT_HPOS] = cur_reg++;
 	
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_PSIZ))
 		vp->outputs[VERT_RESULT_PSIZ] = cur_reg++;
 	
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_COL0))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_COL0))
 		vp->outputs[VERT_RESULT_COL0] = cur_reg++;
 	
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_COL1))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_COL1))
 		vp->outputs[VERT_RESULT_COL1] = cur_reg++;
 	
 #if 0 /* Not supported yet */
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_BFC0))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_BFC0))
 		vp->outputs[VERT_RESULT_BFC0] = cur_reg++;
 	
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_BFC1))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_BFC1))
 		vp->outputs[VERT_RESULT_BFC1] = cur_reg++;
 	
-	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_FOGC))
+	if(vp->key.OutputsWritten & (1 << VERT_RESULT_FOGC))
 		vp->outputs[VERT_RESULT_FOGC] = cur_reg++;
 #endif
 	
 	for(i=VERT_RESULT_TEX0; i <= VERT_RESULT_TEX7; i++)
-		if(mesa_vp->Base.OutputsWritten & (1 << i))
+		if(vp->key.OutputsWritten & (1 << i))
 			vp->outputs[i] = cur_reg++;
 	
 	vp->translated = GL_TRUE;
 	vp->native = GL_TRUE;
 	
 	o_inst=vp->program.body.i;
-	for(vpi=mesa_vp->Base.Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
+	for(; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
 		FREE_TEMPS();
+
+		if(!valid_dst(vp, &vpi->DstReg))
+		{
+			/* redirect result to unused temp */
+			vpi->DstReg.File = PROGRAM_TEMPORARY;
+			vpi->DstReg.Index = u_temp_i;
+		}
 		
 		operands=op_operands(vpi->Opcode);
 		are_srcs_scalar=operands & SCALAR_FLAG;
@@ -987,3 +874,308 @@ void r300_translate_vertex_shader(struct r300_vertex_program *vp)
 #endif
 }
 
+static void position_invariant(struct gl_program *prog)
+{
+	struct prog_instruction *vpi;
+	struct gl_program_parameter_list *paramList;
+	int i;
+
+	GLint tokens[6] = { STATE_MATRIX, STATE_MVP, 0, 0, 0, STATE_MATRIX };
+
+#ifdef PREFER_DP4
+	tokens[5] = STATE_MATRIX;
+#else
+	tokens[5] = STATE_MATRIX_TRANSPOSE;
+#endif
+	paramList = prog->Parameters;
+
+	vpi = malloc((prog->NumInstructions + 4) * sizeof(struct prog_instruction));
+	memset(vpi, 0, 4 * sizeof(struct prog_instruction));
+
+	for (i=0; i < 4; i++) {
+		GLint idx;
+		tokens[3] = tokens[4] = i;
+		idx = _mesa_add_state_reference(paramList, tokens);
+#ifdef PREFER_DP4
+		vpi[i].Opcode = OPCODE_DP4;
+		vpi[i].StringPos = 0;
+		vpi[i].Data = 0;
+
+		vpi[i].DstReg.File = PROGRAM_OUTPUT;
+		vpi[i].DstReg.Index = VERT_RESULT_HPOS;
+		vpi[i].DstReg.WriteMask = 1 << i;
+		vpi[i].DstReg.CondMask = COND_TR;
+
+		vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
+		vpi[i].SrcReg[0].Index = idx;
+		vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+
+		vpi[i].SrcReg[1].File = PROGRAM_INPUT;
+		vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
+		vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+#else
+		if (i == 0)
+			vpi[i].Opcode = OPCODE_MUL;
+		else
+			vpi[i].Opcode = OPCODE_MAD;
+
+		vpi[i].StringPos = 0;
+		vpi[i].Data = 0;
+
+		if (i == 3)
+			vpi[i].DstReg.File = PROGRAM_OUTPUT;
+		else
+			vpi[i].DstReg.File = PROGRAM_TEMPORARY;
+		vpi[i].DstReg.Index = 0;
+		vpi[i].DstReg.WriteMask = 0xf;
+		vpi[i].DstReg.CondMask = COND_TR;
+
+		vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
+		vpi[i].SrcReg[0].Index = idx;
+		vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+
+		vpi[i].SrcReg[1].File = PROGRAM_INPUT;
+		vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
+		vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(i, i, i, i);
+
+		if (i > 0) {
+			vpi[i].SrcReg[2].File = PROGRAM_TEMPORARY;
+			vpi[i].SrcReg[2].Index = 0;
+			vpi[i].SrcReg[2].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+		}
+#endif					
+	}
+
+	memcpy(&vpi[i], prog->Instructions, prog->NumInstructions * sizeof(struct prog_instruction));
+
+	free(prog->Instructions);
+
+	prog->Instructions = vpi;
+
+	prog->NumInstructions += 4;
+	vpi = &prog->Instructions[prog->NumInstructions-1];
+
+	assert(vpi->Opcode == OPCODE_END);
+}
+
+static void insert_wpos(struct r300_vertex_program *vp,
+		       struct gl_program *prog,
+		       GLint pos)
+{
+
+	GLint tokens[6] = { STATE_INTERNAL, STATE_R300_WINDOW_DIMENSION, 0, 0, 0, 0 };
+	struct prog_instruction *vpi;
+	struct prog_instruction *vpi_insert;
+	GLuint temp_index;
+	GLuint window_index;
+	int i = 0;
+	
+	vpi = malloc((prog->NumInstructions + 5) * sizeof(struct prog_instruction));
+	memcpy(vpi, prog->Instructions, (pos+1) * sizeof(struct prog_instruction));
+	
+	vpi_insert = &vpi[pos];
+
+	/* make a copy before outputting VERT_RESULT_HPOS */
+	vpi_insert->DstReg.File = vpi_insert->SrcReg[2].File;
+	vpi_insert->DstReg.Index = temp_index = vpi_insert->SrcReg[2].Index;
+	
+	vpi_insert++;
+	memset(vpi_insert, 0, 5 * sizeof(struct prog_instruction));
+
+	vpi_insert[i].Opcode = OPCODE_MOV;
+
+	vpi_insert[i].DstReg.File = PROGRAM_OUTPUT;
+	vpi_insert[i].DstReg.Index = VERT_RESULT_HPOS;
+	vpi_insert[i].DstReg.WriteMask = WRITEMASK_XYZW;
+	vpi_insert[i].DstReg.CondMask = COND_TR;
+
+	vpi_insert[i].SrcReg[0].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[0].Index = temp_index;
+	vpi_insert[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+	i++;
+
+	/* perspective divide */
+	vpi_insert[i].Opcode = OPCODE_RCP;
+
+	vpi_insert[i].DstReg.File = PROGRAM_TEMPORARY;
+	vpi_insert[i].DstReg.Index = temp_index;
+	vpi_insert[i].DstReg.WriteMask = WRITEMASK_W;
+	vpi_insert[i].DstReg.CondMask = COND_TR;
+
+	vpi_insert[i].SrcReg[0].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[0].Index = temp_index;
+	vpi_insert[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ZERO);
+	i++;
+
+	vpi_insert[i].Opcode = OPCODE_MUL;
+
+	vpi_insert[i].DstReg.File = PROGRAM_TEMPORARY;
+	vpi_insert[i].DstReg.Index = temp_index;
+	vpi_insert[i].DstReg.WriteMask = WRITEMASK_XYZ;
+	vpi_insert[i].DstReg.CondMask = COND_TR;
+
+	vpi_insert[i].SrcReg[0].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[0].Index = temp_index;
+	vpi_insert[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ZERO);
+
+	vpi_insert[i].SrcReg[1].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[1].Index = temp_index;
+	vpi_insert[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_ZERO);
+	i++;
+
+	/* viewport transformation */
+	window_index = _mesa_add_state_reference(prog->Parameters, tokens);
+
+	vpi_insert[i].Opcode = OPCODE_MAD;
+
+	vpi_insert[i].DstReg.File = PROGRAM_TEMPORARY;
+	vpi_insert[i].DstReg.Index = temp_index;
+	vpi_insert[i].DstReg.WriteMask = WRITEMASK_XYZ;
+	vpi_insert[i].DstReg.CondMask = COND_TR;
+
+	vpi_insert[i].SrcReg[0].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[0].Index = temp_index;
+	vpi_insert[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ZERO);
+
+	vpi_insert[i].SrcReg[1].File = PROGRAM_STATE_VAR;
+	vpi_insert[i].SrcReg[1].Index = window_index;
+	vpi_insert[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_ZERO);
+
+	vpi_insert[i].SrcReg[2].File = PROGRAM_STATE_VAR;
+	vpi_insert[i].SrcReg[2].Index = window_index;
+	vpi_insert[i].SrcReg[2].Swizzle = MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_ZERO);
+	i++;
+
+	vpi_insert[i].Opcode = OPCODE_MUL;
+
+	vpi_insert[i].DstReg.File = PROGRAM_OUTPUT;
+	vpi_insert[i].DstReg.Index = VERT_RESULT_TEX0+vp->wpos_idx;
+	vpi_insert[i].DstReg.WriteMask = WRITEMASK_XYZW;
+	vpi_insert[i].DstReg.CondMask = COND_TR;
+
+	vpi_insert[i].SrcReg[0].File = PROGRAM_TEMPORARY;
+	vpi_insert[i].SrcReg[0].Index = temp_index;
+	vpi_insert[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
+
+	vpi_insert[i].SrcReg[1].File = PROGRAM_STATE_VAR;
+	vpi_insert[i].SrcReg[1].Index = window_index;
+	vpi_insert[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_ONE, SWIZZLE_ONE);
+	i++;
+
+	memcpy(&vpi_insert[i], &prog->Instructions[pos+1], (prog->NumInstructions-(pos+1)) * sizeof(struct prog_instruction));
+
+	free(prog->Instructions);
+
+	prog->Instructions = vpi;
+
+	prog->NumInstructions += i;
+	vpi = &prog->Instructions[prog->NumInstructions-1];
+
+	assert(vpi->Opcode == OPCODE_END);
+	/* we need position, don't we ? :) */
+	prog->InputsRead |= (1 << VERT_ATTRIB_POS);
+}
+
+static void pos_as_texcoord(struct r300_vertex_program *vp,
+			    struct gl_program *prog)
+{
+	struct prog_instruction *vpi;
+	int pos = 0;
+	
+	for(vpi = prog->Instructions; vpi->Opcode != OPCODE_END; vpi++, pos++){
+		if( vpi->DstReg.File == PROGRAM_OUTPUT &&
+		    vpi->DstReg.Index == VERT_RESULT_HPOS ){
+			insert_wpos(vp, prog, pos);
+			break;
+		}
+	}
+
+}
+
+static struct r300_vertex_program *build_program(struct r300_vertex_program_key *wanted_key,
+						 struct gl_vertex_program *mesa_vp,
+						 GLint wpos_idx)
+{
+	struct r300_vertex_program *vp;
+
+	vp = _mesa_calloc(sizeof(*vp));
+	_mesa_memcpy(&vp->key, wanted_key, sizeof(vp->key));
+
+	vp->wpos_idx = wpos_idx;
+
+	if(mesa_vp->IsPositionInvariant) {
+		position_invariant(&mesa_vp->Base);
+	}
+
+	if(wpos_idx > -1)
+		pos_as_texcoord(vp, &mesa_vp->Base);
+
+	assert(mesa_vp->Base.NumInstructions);
+
+	vp->num_temporaries=mesa_vp->Base.NumTemporaries;
+
+	r300_translate_vertex_shader(vp, mesa_vp->Base.Instructions);
+
+	return vp;	
+}
+
+void r300_select_vertex_shader(r300ContextPtr r300)
+{
+	GLcontext *ctx = ctx = r300->radeon.glCtx;
+	GLuint InputsRead;
+	struct r300_vertex_program_key wanted_key = { 0 };
+	GLint i;
+	struct r300_vertex_program_cont *vpc;
+	struct r300_vertex_program *vp;
+	GLint wpos_idx;
+
+	vpc = (struct r300_vertex_program_cont *)ctx->VertexProgram._Current;
+	InputsRead = ctx->FragmentProgram._Current->Base.InputsRead;
+
+	wanted_key.OutputsWritten |= 1 << VERT_RESULT_HPOS;
+
+	wpos_idx = -1;
+	if (InputsRead & FRAG_BIT_WPOS){
+		for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
+			if (!(InputsRead & (FRAG_BIT_TEX0 << i)))
+				break;
+		
+		if(i == ctx->Const.MaxTextureUnits){
+			fprintf(stderr, "\tno free texcoord found\n");
+			exit(0);
+		}
+
+		InputsRead |= (FRAG_BIT_TEX0 << i);
+		wpos_idx = i;
+	}
+
+	if (InputsRead & FRAG_BIT_COL0)
+		wanted_key.OutputsWritten |= 1 << VERT_RESULT_COL0;
+
+	if ((InputsRead & FRAG_BIT_COL1) /*||
+	    (InputsRead & FRAG_BIT_FOGC)*/)
+		wanted_key.OutputsWritten |= 1 << VERT_RESULT_COL1;
+	
+	for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
+		if (InputsRead & (FRAG_BIT_TEX0 << i))
+			wanted_key.OutputsWritten |= 1 << (VERT_RESULT_TEX0 + i);
+
+	wanted_key.InputsRead = vpc->mesa_program.Base.InputsRead;
+	if(vpc->mesa_program.IsPositionInvariant) {
+		/* we wan't position don't we ? */
+		wanted_key.InputsRead |= (1 << VERT_ATTRIB_POS);
+	}
+
+	for (vp = vpc->progs; vp; vp = vp->next)
+		if (_mesa_memcmp(&vp->key, &wanted_key, sizeof(wanted_key)) == 0) {
+			r300->selected_vp = vp;
+			return ;
+		}
+
+	//_mesa_print_program(&vpc->mesa_program.Base);
+
+	vp = build_program(&wanted_key, &vpc->mesa_program, wpos_idx);
+	vp->next = vpc->progs;
+	vpc->progs = vp;
+	r300->selected_vp = vp;
+}
diff --git a/src/mesa/drivers/dri/r300/radeon_context.c b/src/mesa/drivers/dri/r300/radeon_context.c
index 62a6e1e5f7..3a6bde8fc3 100644
--- a/src/mesa/drivers/dri/r300/radeon_context.c
+++ b/src/mesa/drivers/dri/r300/radeon_context.c
@@ -102,7 +102,6 @@ static const GLubyte *radeonGetString(GLcontext * ctx, GLenum name)
  */
 static void radeonInitDriverFuncs(struct dd_function_table *functions)
 {
-	functions->GetBufferSize = NULL;
 	functions->GetString = radeonGetString;
 }
 
@@ -267,12 +266,14 @@ GLboolean radeonMakeCurrent(__DRIcontextPrivate * driContextPriv,
 			fprintf(stderr, "%s ctx %p\n", __FUNCTION__,
 				radeon->glCtx);
 
-		if ( (radeon->dri.drawable != driDrawPriv)
-		     || (radeon->dri.readable != driReadPriv) ) {
-
+		if (radeon->dri.drawable != driDrawPriv) {
 			driDrawableInitVBlank(driDrawPriv,
 					      radeon->vblank_flags,
 					      &radeon->vbl_seq);
+		}
+
+		if (radeon->dri.drawable != driDrawPriv ||
+		    radeon->dri.readable != driReadPriv) {
 			radeon->dri.drawable = driDrawPriv;
 			radeon->dri.readable = driReadPriv;
 
diff --git a/src/mesa/drivers/dri/r300/radeon_mm.c b/src/mesa/drivers/dri/r300/radeon_mm.c
index 7595d2144f..f86a1b4e72 100644
--- a/src/mesa/drivers/dri/r300/radeon_mm.c
+++ b/src/mesa/drivers/dri/r300/radeon_mm.c
@@ -213,7 +213,7 @@ int radeon_mm_alloc(r300ContextPtr rmesa, int alignment, int size)
 		}
 		goto again;
 #else
-		WARN_ONCE("Ran out of GART memory!\nPlease consider adjusting GARTSize option.\n");
+		WARN_ONCE("Ran out of GART memory (for %d)!\nPlease consider adjusting GARTSize option.\n", size);
 		return 0;
 #endif
 	}
diff --git a/src/mesa/drivers/dri/r300/radeon_state.c b/src/mesa/drivers/dri/r300/radeon_state.c
index 1b1ec3df3c..ddadf83a00 100644
--- a/src/mesa/drivers/dri/r300/radeon_state.c
+++ b/src/mesa/drivers/dri/r300/radeon_state.c
@@ -169,10 +169,6 @@ void radeonSetCliprects(radeonContextPtr radeon)
 
 	if ((draw_fb->Width != drawable->w) ||
 	    (draw_fb->Height != drawable->h)) {
-		printf("w,h %d %d\n",
-		       radeon->glCtx->DrawBuffer->Width,
-		       radeon->glCtx->DrawBuffer->Height);
-
 		_mesa_resize_framebuffer(radeon->glCtx, draw_fb,
 					 drawable->w, drawable->h);
 		draw_fb->Initialized = GL_TRUE;