intermediate code generator (not finished);

generic back-end interpreter (interprets directly intermediate code)

15 files changed, 4059 insertions, 77 deletions

diff --git a/src/mesa/shader/slang/slang_assemble.c b/src/mesa/shader/slang/slang_assemble.c
new file mode 100644
index 00000000000..03672b2fca3
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble.c
@@ -0,0 +1,1385 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_assemble.c

+ * slang intermediate code assembler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_assemble.h"

+#include "slang_compile.h"

+#include "slang_storage.h"

+#include "slang_assemble_constructor.h"

+#include "slang_assemble_typeinfo.h"

+#include "slang_assemble_conditional.h"

+

+/* slang_assembly */

+

+static void slang_assembly_construct (slang_assembly *asm)

+{

+	asm->type = slang_asm_none;

+}

+

+static void slang_assembly_destruct (slang_assembly *asm)

+{

+}

+

+/* slang_assembly_file */

+

+void slang_assembly_file_construct (slang_assembly_file *file)

+{

+	file->code = NULL;

+	file->count = 0;

+}

+

+void slang_assembly_file_destruct (slang_assembly_file *file)

+{

+	unsigned int i;

+

+	for (i = 0; i < file->count; i++)

+		slang_assembly_destruct (file->code + i);

+	slang_alloc_free (file->code);

+}

+

+static int slang_assembly_file_push_new (slang_assembly_file *file)

+{

+	file->code = (slang_assembly *) slang_alloc_realloc (file->code, file->count * sizeof (

+		slang_assembly), (file->count + 1) * sizeof (slang_assembly));

+	if (file->code != NULL)

+	{

+		slang_assembly_construct (file->code + file->count);

+		file->count++;

+		return 1;

+	}

+	return 0;

+}

+

+static int slang_assembly_file_push_general (slang_assembly_file *file, slang_assembly_type type,

+	GLfloat literal, GLuint label, GLuint size)

+{

+	slang_assembly *asm;

+	if (!slang_assembly_file_push_new (file))

+		return 0;

+	asm = file->code + file->count - 1;

+	asm->type = type;

+	asm->literal = literal;

+	asm->param[0] = label;

+	asm->param[1] = size;

+	return 1;

+}

+

+int slang_assembly_file_push (slang_assembly_file *file, slang_assembly_type type)

+{

+	return slang_assembly_file_push_general (file, type, (GLfloat) 0, 0, 0);

+}

+

+int slang_assembly_file_push_label (slang_assembly_file *file, slang_assembly_type type,

+	GLuint label)

+{

+	return slang_assembly_file_push_general (file, type, (GLfloat) 0, label, 0);

+}

+

+int slang_assembly_file_push_label2 (slang_assembly_file *file, slang_assembly_type type,

+	GLuint label1, GLuint label2)

+{

+	return slang_assembly_file_push_general (file, type, (GLfloat) 0, label1, label2);

+}

+

+int slang_assembly_file_push_literal (slang_assembly_file *file, slang_assembly_type type,

+	GLfloat literal)

+{

+	return slang_assembly_file_push_general (file, type, literal, 0, 0);

+}

+

+/* utility functions */

+

+static int sizeof_variable (slang_type_specifier *spec, slang_operation *array_size,

+	slang_assembly_name_space *space, unsigned int *size)

+{

+	slang_storage_aggregate agg;

+

+	slang_storage_aggregate_construct (&agg);

+	if (!_slang_aggregate_variable (&agg, spec, array_size, space->funcs, space->structs))

+	{

+		slang_storage_aggregate_destruct (&agg);

+		return 0;

+	}

+	*size += _slang_sizeof_aggregate (&agg);

+	slang_storage_aggregate_destruct (&agg);

+	return 1;

+}

+

+static int sizeof_variable2 (slang_variable *var, slang_assembly_name_space *space,

+	unsigned int *size)

+{

+	var->address = *size;

+	return sizeof_variable (&var->type.specifier, var->array_size, space, size);

+}

+

+static int sizeof_variables (slang_variable_scope *vars, unsigned int start, unsigned int stop,

+	slang_assembly_name_space *space, unsigned int *size)

+{

+	unsigned int i;

+

+	for (i = start; i < stop; i++)

+		if (!sizeof_variable2 (vars->variables + i, space, size))

+			return 0;

+	return 1;

+}

+

+static int collect_locals (slang_operation *op, slang_assembly_name_space *space,

+	unsigned int *size)

+{

+	unsigned int i;

+

+	if (!sizeof_variables (op->locals, 0, op->locals->num_variables, space, size))

+		return 0;

+	for (i = 0; i < op->num_children; i++)

+		if (!collect_locals (op->children + i, space, size))

+			return 0;

+	return 1;

+}

+

+/* _slang_locate_function() */

+

+slang_function *_slang_locate_function (const char *name, slang_operation *params,

+	unsigned int num_params, slang_assembly_name_space *space)

+{

+	unsigned int i;

+

+	for (i = 0; i < space->funcs->num_functions; i++)

+	{

+		unsigned int j;

+		slang_function *f = space->funcs->functions + i;

+

+		if (slang_string_compare (name, f->header.name) != 0)

+			continue;

+		if (f->param_count != num_params)

+			continue;

+		for (j = 0; j < num_params; j++)

+		{

+			slang_assembly_typeinfo ti;

+			slang_assembly_typeinfo_construct (&ti);

+			if (!_slang_typeof_operation (params + j, space, &ti))

+			{

+				slang_assembly_typeinfo_destruct (&ti);

+				return 0;

+			}

+			if (!slang_type_specifier_equal (&ti.spec, &f->parameters->variables[j].type.specifier))

+			{

+				slang_assembly_typeinfo_destruct (&ti);

+				break;

+			}

+			slang_assembly_typeinfo_destruct (&ti);

+			/* "out" and "inout" formal parameter requires the actual parameter to be l-value */

+			if (!ti.can_be_referenced &&

+				f->parameters->variables[j].type.qualifier != slang_qual_out &&

+				f->parameters->variables[j].type.qualifier != slang_qual_inout)

+				break;

+		}

+		if (j == num_params)

+			return f;

+	}

+	if (space->funcs->outer_scope != NULL)

+	{

+		slang_assembly_name_space my_space = *space;

+		my_space.funcs = space->funcs->outer_scope;

+		return _slang_locate_function (name, params, num_params, &my_space);

+	}

+	return NULL;

+}

+

+/* _slang_assemble_function() */

+

+int _slang_assemble_function (slang_assembly_file *file, slang_function *fun,

+	slang_assembly_name_space *space)

+{

+	unsigned int param_size, local_size;

+	unsigned int skip, cleanup;

+	slang_assembly_flow_control flow;

+	slang_assembly_local_info info;

+	slang_assembly_stack_info stk;

+

+	fun->address = file->count;

+

+	if (fun->body == NULL)

+	{

+		/* TODO: jump to the actual function body */

+		return 1;

+	}

+

+	/* calculate return value and parameters size */

+	param_size = 0;

+	if (fun->header.type.specifier.type != slang_spec_void)

+		if (!sizeof_variable (&fun->header.type.specifier, NULL, space, &param_size))

+			return 0;

+	info.ret_size = param_size;

+	if (!sizeof_variables (fun->parameters, 0, fun->param_count, space, &param_size))

+		return 0;

+

+	/* calculate local variables size, take into account the four-byte return address and

+	temporaries for various tasks */

+	info.addr_tmp = param_size + 4;

+	info.swizzle_tmp = param_size + 4 + 4;

+	local_size = param_size + 4 + 4 + 16;

+	if (!sizeof_variables (fun->parameters, fun->param_count, fun->parameters->num_variables, space,

+		&local_size))

+		return 0;

+	if (!collect_locals (fun->body, space, &local_size))

+		return 0;

+

+	/* allocate local variable storage */

+	if (!slang_assembly_file_push_label (file, slang_asm_local_alloc, local_size - param_size - 4))

+		return 0;

+

+	/* mark a new frame for function variable storage */

+	if (!slang_assembly_file_push_label (file, slang_asm_enter, local_size))

+		return 0;

+

+	/* skip the cleanup jump */

+	skip = file->count;

+	if (!slang_assembly_file_push_new (file))

+		return 0;

+	file->code[skip].type = slang_asm_jump;

+

+	/* all "return" statements will be directed here */

+	flow.function_end = file->count;

+	cleanup = file->count;

+	if (!slang_assembly_file_push_new (file))

+		return 0;

+	file->code[cleanup].type = slang_asm_jump;

+

+	/* execute the function body */

+	file->code[skip].param[0] = file->count;

+	if (!_slang_assemble_operation (file, fun->body, 0, &flow, space, &info, &stk))

+		return 0;

+

+	/* this is the end of the function - restore the old function frame */

+	file->code[cleanup].param[0] = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_leave))

+		return 0;

+

+	/* free local variable storage */

+	if (!slang_assembly_file_push_label (file, slang_asm_local_free, local_size - param_size - 4))

+		return 0;

+

+	/* jump out of the function */

+	if (!slang_assembly_file_push (file, slang_asm_return))

+		return 0;

+	return 1;

+}

+

+int _slang_cleanup_stack (slang_assembly_file *file, slang_operation *op, int ref,

+	slang_assembly_name_space *space)

+{

+	slang_assembly_typeinfo ti;

+	unsigned int size;

+

+	slang_assembly_typeinfo_construct (&ti);

+	if (!_slang_typeof_operation (op, space, &ti))

+	{

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+	if (ti.spec.type == slang_spec_void)

+		size = 0;

+	else if (ref)

+		size = 4;

+	else

+	{

+		size = 0;

+		if (!sizeof_variable (&ti.spec, NULL, space, &size))

+		{

+			slang_assembly_typeinfo_destruct (&ti);

+			return 0;

+		}

+	}

+	slang_assembly_typeinfo_destruct (&ti);

+	if (size != 0)

+	{

+		if (!slang_assembly_file_push_label (file, slang_asm_local_free, size))

+			return 0;

+	}

+	return 1;

+}

+

+/* _slang_assemble_operation() */

+

+/* XXX: general swizzle! */

+static int dereference_aggregate (slang_assembly_file *file, const slang_storage_aggregate *agg,

+	unsigned int index, unsigned int *size, slang_assembly_local_info *info)

+{

+	unsigned int i;

+

+	for (i = agg->count; i > 0; i--)

+	{

+		const slang_storage_array *arr = agg->arrays + i - 1;

+		unsigned int j;

+

+		for (j = arr->length; j > 0; j--)

+		{

+			if (arr->type == slang_stor_aggregate)

+			{

+				if (!dereference_aggregate (file, arr->aggregate, index, size, info))

+					return 0;

+			}

+			else

+			{

+				*size -= 4;

+				if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->addr_tmp,

+					4))

+					return 0;

+				if (!slang_assembly_file_push (file, slang_asm_addr_deref))

+					return 0;

+				if (!slang_assembly_file_push_label (file, slang_asm_addr_push, *size))

+					return 0;

+				if (!slang_assembly_file_push (file, slang_asm_addr_add))

+					return 0;

+				switch (arr->type)

+				{

+				case slang_stor_bool:

+					if (!slang_assembly_file_push (file, slang_asm_bool_deref))

+						return 0;

+					break;

+				case slang_stor_int:

+					if (!slang_assembly_file_push (file, slang_asm_int_deref))

+						return 0;

+					break;

+				case slang_stor_float:

+					if (!slang_assembly_file_push (file, slang_asm_float_deref))

+						return 0;

+					break;

+				}

+				index += 4;

+			}

+		}

+	}

+	return 1;

+}

+/* XXX: general swizzle! */

+static int dereference (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_name_space *space, slang_assembly_local_info *info)

+{

+	slang_assembly_typeinfo ti;

+	int result;

+	slang_storage_aggregate agg;

+	unsigned int size;

+

+	slang_assembly_typeinfo_construct (&ti);

+	if (!_slang_typeof_operation (op, space, &ti))

+	{

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+

+	slang_storage_aggregate_construct (&agg);

+	if (!_slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs))

+	{

+		slang_storage_aggregate_destruct (&agg);

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+

+	size = _slang_sizeof_aggregate (&agg);

+	result = dereference_aggregate (file, &agg, 0, &size, info);

+

+	slang_storage_aggregate_destruct (&agg);

+	slang_assembly_typeinfo_destruct (&ti);

+	return result;

+}

+

+static int call_function (slang_assembly_file *file, slang_function *fun, slang_operation *params,

+	unsigned int param_count, int assignment, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	unsigned int ret_size, i;

+	slang_assembly_stack_info stk;

+

+	/* make room for the return value, if any */

+	ret_size = 0;

+	if (!sizeof_variable (&fun->header.type.specifier, NULL, space, &ret_size))

+		return 0;

+	if (ret_size > 0)

+	{

+		if (!slang_assembly_file_push_label (file, slang_asm_local_alloc, ret_size))

+			return 0;

+	}

+

+	/* push the actual parameters on the stack */

+	for (i = 0; i < param_count; i++)

+	{

+		slang_assembly_flow_control flow;

+

+		if (i == 0 && assignment)

+		{

+			if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+				return 0;

+			/* TODO: optimize the "out" parameter case */

+			/* TODO: inspect stk */

+			if (!_slang_assemble_operation (file, params, 1, &flow, space, info, &stk))

+				return 0;

+			if (!slang_assembly_file_push (file, slang_asm_addr_copy))

+				return 0;

+			if (!slang_assembly_file_push (file, slang_asm_addr_deref))

+				return 0;

+			if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->addr_tmp, 4))

+				return 0;

+			if (!slang_assembly_file_push (file, slang_asm_addr_deref))

+				return 0;

+			if (!dereference (file, params, space, info))

+				return 0;

+		}

+		else

+		{

+			/* TODO: for "out" and "inout" parameters also push the address (first) */

+			/* TODO: optimize the "out" parameter case */

+			/* TODO: inspect stk */

+			if (!_slang_assemble_operation (file, params + i, 0, &flow, space, info, &stk))

+				return 0;

+		}

+	}

+

+	/* call the function */

+	if (!slang_assembly_file_push_label (file, slang_asm_call, fun->address))

+		return 0;

+

+	/* pop the parameters from the stack */

+	for (i = param_count; i > 0; i--)

+	{

+		/* XXX: copy inout/out params back to the actual variables */

+		if (!_slang_cleanup_stack (file, params + i - 1, 0, space))

+			return 0;

+	}

+

+	return 1;

+}

+

+static int call_function_name (slang_assembly_file *file, const char *name, slang_operation *params,

+	unsigned int param_count, int assignment, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	slang_function *fun = _slang_locate_function (name, params, param_count, space);

+	if (fun == NULL)

+		return 0;

+	return call_function (file, fun, params, param_count, assignment, space, info);

+}

+

+static int call_function_name_dummyint (slang_assembly_file *file, const char *name,

+	slang_operation *params, slang_assembly_name_space *space, slang_assembly_local_info *info)

+{

+	slang_operation p2[2];

+	int result;

+

+	p2[0] = *params;

+	if (!slang_operation_construct_a (p2 + 1))

+		return 0;

+	p2[1].type = slang_oper_literal_int;

+	result = call_function_name (file, name, p2, 2, 0, space, info);

+	slang_operation_destruct (p2 + 1);

+	return result;

+}

+

+static int call_asm_instruction (slang_assembly_file *file, const char *name)

+{

+	const struct

+	{

+		const char *name;

+		slang_assembly_type code1, code2;

+	} inst[] = {

+		{ "float_to_int",   slang_asm_float_to_int,   slang_asm_int_copy },

+		{ "int_to_float",   slang_asm_int_to_float,   slang_asm_float_copy },

+		{ "float_copy",     slang_asm_float_copy,     slang_asm_none },

+		{ "int_copy",       slang_asm_int_copy,       slang_asm_none },

+		{ "bool_copy",      slang_asm_bool_copy,      slang_asm_none },

+		{ "float_add",      slang_asm_float_add,      slang_asm_float_copy },

+		{ "float_multiply", slang_asm_float_multiply, slang_asm_float_copy },

+		{ "float_divide",   slang_asm_float_divide,   slang_asm_float_copy },

+		{ "float_negate",   slang_asm_float_negate,   slang_asm_float_copy },

+		{ "float_less",     slang_asm_float_less,     slang_asm_bool_copy },

+		{ "float_equal",    slang_asm_float_equal,    slang_asm_bool_copy },

+		{ NULL,             slang_asm_none,           slang_asm_none }

+	};

+	unsigned int i;

+

+	for (i = 0; inst[i].name != NULL; i++)

+		if (slang_string_compare (name, inst[i].name) == 0)

+			break;

+	if (inst[i].name == NULL)

+		return 0;

+

+	if (!slang_assembly_file_push_label2 (file, inst[i].code1, 4, 0))

+		return 0;

+	if (inst[i].code2 != slang_asm_none)

+		if (!slang_assembly_file_push_label2 (file, inst[i].code2, 4, 0))

+			return 0;

+

+	/* clean-up the stack from the remaining dst address */

+	if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+		return 0;

+

+	return 1;

+}

+/* XXX: general swizzle! */

+static int assign_aggregate (slang_assembly_file *file, const slang_storage_aggregate *agg,

+	unsigned int *index, unsigned int size, slang_assembly_local_info *info)

+{

+	unsigned int i;

+

+	for (i = 0; i < agg->count; i++)

+	{

+		const slang_storage_array *arr = agg->arrays + i;

+		unsigned int j;

+

+		for (j = 0; j < arr->length; j++)

+		{

+			if (arr->type == slang_stor_aggregate)

+			{

+				if (!assign_aggregate (file, arr->aggregate, index, size, info))

+					return 0;

+			}

+			else

+			{

+				switch (arr->type)

+				{

+				case slang_stor_bool:

+					if (!slang_assembly_file_push_label2 (file, slang_asm_bool_copy,

+						size - *index, *index))

+						return 0;

+					break;

+				case slang_stor_int:

+					if (!slang_assembly_file_push_label2 (file, slang_asm_int_copy,

+						size - *index, *index))

+						return 0;

+					break;

+				case slang_stor_float:

+					if (!slang_assembly_file_push_label2 (file, slang_asm_float_copy,

+						size - *index, *index))

+						return 0;

+					break;

+				}

+				*index += 4;

+			}

+		}

+	}

+	return 1;

+}

+/* XXX: general swizzle! */

+static int assignment (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_name_space *space, slang_assembly_local_info *info)

+{

+	slang_assembly_typeinfo ti;

+	int result;

+	slang_storage_aggregate agg;

+	unsigned int index, size;

+

+	slang_assembly_typeinfo_construct (&ti);

+	if (!_slang_typeof_operation (op, space, &ti))

+	{

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+

+	slang_storage_aggregate_construct (&agg);

+	if (!_slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs))

+	{

+		slang_storage_aggregate_destruct (&agg);

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+

+	index = 0;

+	size = _slang_sizeof_aggregate (&agg);

+	result = assign_aggregate (file, &agg, &index, size, info);

+

+	slang_storage_aggregate_destruct (&agg);

+	slang_assembly_typeinfo_destruct (&ti);

+	return result;

+}

+/* XXX: general swizzle! */

+static int equality_aggregate (slang_assembly_file *file, const slang_storage_aggregate *agg,

+	unsigned int *index, unsigned int size, slang_assembly_local_info *info, unsigned int z_label)

+{

+	unsigned int i;

+

+	for (i = 0; i < agg->count; i++)

+	{

+		const slang_storage_array *arr = agg->arrays + i;

+		unsigned int j;

+

+		for (j = 0; j < arr->length; j++)

+		{

+			if (arr->type == slang_stor_aggregate)

+			{

+				if (!equality_aggregate (file, arr->aggregate, index, size, info, z_label))

+					return 0;

+			}

+			else

+			{

+				if (!slang_assembly_file_push_label2 (file, slang_asm_float_equal, size + *index,

+					*index))

+					return 0;

+				*index += 4;

+				if (!slang_assembly_file_push_label (file, slang_asm_jump_if_zero, z_label))

+					return 0;

+			}

+		}

+	}

+	return 1;

+}

+/* XXX: general swizzle! */

+static int equality (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_name_space *space, slang_assembly_local_info *info, int equal)

+{

+	slang_assembly_typeinfo ti;

+	int result;

+	slang_storage_aggregate agg;

+	unsigned int index, size;

+	unsigned int skip_jump, true_label, true_jump, false_label, false_jump;

+

+	/* get type of operation */

+	slang_assembly_typeinfo_construct (&ti);

+	if (!_slang_typeof_operation (op, space, &ti))

+	{

+		slang_assembly_typeinfo_destruct (&ti);

+		return 0;

+	}

+

+	/* convert it to an aggregate */

+	slang_storage_aggregate_construct (&agg);

+	if (!(result = _slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs)))

+		goto end;

+

+	/* compute the size of the agregate - there are two such aggregates on the stack */

+	size = _slang_sizeof_aggregate (&agg);

+

+	/* jump to the actual data-comparison code */

+	skip_jump = file->count;

+	if (!(result = slang_assembly_file_push (file, slang_asm_jump)))

+		goto end;

+

+	/* pop off the stack the compared data and push 1 */

+	true_label = file->count;

+	if (!(result = slang_assembly_file_push_label (file, slang_asm_local_free, size * 2)))

+		goto end;

+	if (!(result = slang_assembly_file_push_literal (file, slang_asm_bool_push, 1.0f)))

+		goto end;

+	true_jump = file->count;

+	if (!(result = slang_assembly_file_push (file, slang_asm_jump)))

+		goto end;

+

+	false_label = file->count;

+	if (!(result = slang_assembly_file_push_label (file, slang_asm_local_free, size * 2)))

+		goto end;

+	if (!(result = slang_assembly_file_push_literal (file, slang_asm_bool_push, 0.0f)))

+		goto end;

+	false_jump = file->count;

+	if (!(result = slang_assembly_file_push (file, slang_asm_jump)))

+		goto end;

+

+	file->code[skip_jump].param[0] = file->count;

+

+	/* compare the data on stack, it will eventually jump either to true or false label */

+	index = 0;

+	if (!(result = equality_aggregate (file, &agg, &index, size, info,

+		equal ? false_label : true_label)))

+		goto end;

+	if (!(result = slang_assembly_file_push_label (file, slang_asm_jump,

+		equal ? true_label : false_label)))

+		goto end;

+

+	file->code[true_jump].param[0] = file->count;

+	file->code[false_jump].param[0] = file->count;

+

+	result = 1;

+end:

+	slang_storage_aggregate_destruct (&agg);

+	slang_assembly_typeinfo_destruct (&ti);

+	return result;

+}

+

+int _slang_assemble_operation (slang_assembly_file *file, slang_operation *op, int reference,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info, slang_assembly_stack_info *stk)

+{

+	unsigned int asm;

+

+	stk->swizzle_mask = 0;

+

+	asm = file->count;

+	if (!slang_assembly_file_push_new (file))

+		return 0;

+

+	switch (op->type)

+	{

+	case slang_oper_block_no_new_scope:

+	case slang_oper_block_new_scope:

+		{

+			unsigned int i;

+			for (i = 0; i < op->num_children; i++)

+			{

+				slang_assembly_stack_info stk;

+				if (!_slang_assemble_operation (file, op->children + i, 0, flow, space, info, &stk))

+					return 0;

+				/* TODO: pass-in stk to cleanup */

+				if (!_slang_cleanup_stack (file, op->children + i, 0, space))

+					return 0;

+			}

+		}

+		break;

+	case slang_oper_variable_decl:

+		{

+			unsigned int i;

+

+			for (i = 0; i < op->num_children; i++)

+			{

+				/* TODO: perform initialization of op->children[i] */

+				/* TODO: clean-up stack */

+			}

+		}

+		break;

+	case slang_oper_asm:

+		{

+			unsigned int i;

+			for (i = 0; i < op->num_children; i++)

+			{

+				slang_assembly_stack_info stk;

+				if (!_slang_assemble_operation (file, op->children + i, i == 0, flow, space, info,

+					&stk))

+					return 0;

+				/* TODO: inspect stk */

+			}

+			if (!call_asm_instruction (file, op->identifier))

+				return 0;

+		}

+		break;

+	case slang_oper_break:

+		file->code[asm].type = slang_asm_jump;

+		file->code[asm].param[0] = flow->loop_end;

+		break;

+	case slang_oper_continue:

+		file->code[asm].type = slang_asm_jump;

+		file->code[asm].param[0] = flow->loop_start;

+		break;

+	case slang_oper_discard:

+		file->code[asm].type = slang_asm_discard;

+		if (!slang_assembly_file_push (file, slang_asm_exit))

+			return 0;

+		break;

+	case slang_oper_return:

+		if (info->ret_size != 0)

+		{

+			slang_assembly_stack_info stk;

+			if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, 0, info->ret_size))

+				return 0;

+			if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!assignment (file, op->children, space, info))

+				return 0;

+			if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+				return 0;

+		}

+		if (!slang_assembly_file_push_label (file, slang_asm_jump, flow->function_end))

+			return 0;

+		break;

+	case slang_oper_expression:

+		{

+			slang_assembly_stack_info stk;

+			if (!_slang_assemble_operation (file, op->children, reference, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+		}

+		break;

+	case slang_oper_if:

+		if (!_slang_assemble_if (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_while:

+		if (!_slang_assemble_while (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_do:

+		if (!_slang_assemble_do (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_for:

+		if (!_slang_assemble_for (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_void:

+		break;

+	case slang_oper_literal_bool:

+		file->code[asm].type = slang_asm_bool_push;

+		file->code[asm].literal = op->literal;

+		break;

+	case slang_oper_literal_int:

+		file->code[asm].type = slang_asm_int_push;

+		file->code[asm].literal = op->literal;

+		break;

+	case slang_oper_literal_float:

+		file->code[asm].type = slang_asm_float_push;

+		file->code[asm].literal = op->literal;

+		break;

+	case slang_oper_identifier:

+		{

+			slang_variable *var;

+			unsigned int size;

+			var = _slang_locate_variable (op->locals, op->identifier, 1);

+			if (var == NULL)

+				return 0;

+			size = 0;

+			if (!sizeof_variable (&var->type.specifier, var->array_size, space, &size))

+				return 0;

+			if (var->initializer != NULL)

+			{

+				assert (!"var->initializer, oper_identifier");

+			}

+			else

+			{

+				if (!reference)

+				{

+					if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr,

+						info->addr_tmp, 4))

+						return 0;

+				}

+				/* XXX: globals! */

+				if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, var->address,

+					size))

+					return 0;

+				if (!reference)

+				{

+					if (!slang_assembly_file_push (file, slang_asm_addr_copy))

+						return 0;

+					if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+						return 0;

+					if (!dereference (file, op, space, info))

+						return 0;

+				}

+			}

+		}

+		break;

+	case slang_oper_sequence:

+		{

+			slang_assembly_stack_info stk;

+			if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: pass-in stk to cleanup */

+			if (!_slang_cleanup_stack (file, op->children, 0, space))

+				return 0;

+			if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info,

+				&stk))

+				return 0;

+			/* TODO: inspect stk */

+		}

+		break;

+	case slang_oper_assign:

+		{

+			slang_assembly_stack_info stk;

+			if (!reference)

+				if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->addr_tmp,

+					4))

+					return 0;

+			if (!_slang_assemble_operation (file, op->children, 1, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!assignment (file, op->children, space, info))

+				return 0;

+			if (!reference)

+			{

+				if (!slang_assembly_file_push (file, slang_asm_addr_copy))

+					return 0;

+				if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+					return 0;

+				if (!dereference (file, op->children, space, info))

+					return 0;

+			}

+		}

+		break;

+	case slang_oper_addassign:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "+=", op->children, 2, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			if (!dereference (file, op->children, space, info))

+				return 0;

+			/* TODO: stack is operation type */

+		}

+		break;

+	case slang_oper_subassign:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "-=", op->children, 2, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			if (!dereference (file, op->children, space, info))

+				return 0;

+			/* TODO: stack is operation type */

+		}

+		break;

+	case slang_oper_mulassign:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "*=", op->children, 2, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			if (!dereference (file, op->children, space, info))

+				return 0;

+			/* TODO: stack is operation type */

+		}

+		break;

+	/*case slang_oper_modassign:*/

+	/*case slang_oper_lshassign:*/

+	/*case slang_oper_rshassign:*/

+	/*case slang_oper_orassign:*/

+	/*case slang_oper_xorassign:*/

+	/*case slang_oper_andassign:*/

+	case slang_oper_divassign:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "/=", op->children, 2, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			if (!dereference (file, op->children, space, info))

+				return 0;

+			/* TODO: stack is operation type */

+		}

+		break;

+	case slang_oper_select:

+		if (!_slang_assemble_select (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_logicalor:

+		if (!_slang_assemble_logicalor (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_logicaland:

+		if (!_slang_assemble_logicaland (file, op, flow, space, info))

+			return 0;

+		break;

+	case slang_oper_logicalxor:

+		if (!call_function_name (file, "^^", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	/*case slang_oper_bitor:*/

+	/*case slang_oper_bitxor:*/

+	/*case slang_oper_bitand:*/

+	case slang_oper_less:

+		if (!call_function_name (file, "<", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_greater:

+		if (!call_function_name (file, ">", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_lessequal:

+		if (!call_function_name (file, "<=", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_greaterequal:

+		if (!call_function_name (file, ">=", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	/*case slang_oper_lshift:*/

+	/*case slang_oper_rshift:*/

+	case slang_oper_add:

+		if (!call_function_name (file, "+", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_subtract:

+		if (!call_function_name (file, "-", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_multiply:

+		if (!call_function_name (file, "*", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	/*case slang_oper_modulus:*/

+	case slang_oper_divide:

+		if (!call_function_name (file, "/", op->children, 2, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_equal:

+		{

+			slang_assembly_stack_info stk;

+			if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!equality (file, op->children, space, info, 1))

+				return 0;

+		}

+		break;

+	case slang_oper_notequal:

+		{

+			slang_assembly_stack_info stk;

+			if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+				return 0;

+			/* TODO: inspect stk */

+			if (!equality (file, op->children, space, info, 0))

+				return 0;

+		}

+		break;

+	case slang_oper_preincrement:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "++", op->children, 1, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			/* TODO: dereference */

+			/* TODO: stack is operation type */

+		}

+		break;

+	case slang_oper_predecrement:

+		/* TODO: posprawdzaj czy zadzia�a dereferencja */

+		if (!call_function_name (file, "--", op->children, 1, 1, space, info))

+			return 0;

+		if (reference)

+		{

+			/* TODO: stack is address */

+		}

+		else

+		{

+			/* TODO: dereference */

+			/* TODO: stack is operation type */

+		}

+		break;

+	case slang_oper_plus:

+		if (!call_function_name (file, "+", op->children, 1, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_minus:

+		if (!call_function_name (file, "-", op->children, 1, 0, space, info))

+			return 0;

+		break;

+	/*case slang_oper_complement:*/

+	case slang_oper_not:

+		if (!call_function_name (file, "!", op->children, 1, 0, space, info))

+			return 0;

+		break;

+	case slang_oper_subscript:

+		{

+			slang_assembly_stack_info _stk;

+			slang_assembly_typeinfo ti_arr, ti_elem;

+			unsigned int arr_size = 0, elem_size = 0;

+			if (!_slang_assemble_operation (file, op->children, reference, flow, space, info,

+				&_stk))

+				return 0;

+			if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &_stk))

+				return 0;

+			slang_assembly_typeinfo_construct (&ti_arr);

+			if (!_slang_typeof_operation (op->children, space, &ti_arr))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				return 0;

+			}

+			if (!sizeof_variable (&ti_arr.spec, NULL, space, &arr_size))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				return 0;

+			}

+			slang_assembly_typeinfo_construct (&ti_elem);

+			if (!_slang_typeof_operation (op, space, &ti_elem))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				slang_assembly_typeinfo_destruct (&ti_elem);

+				return 0;

+			}

+			if (!sizeof_variable (&ti_elem.spec, NULL, space, &elem_size))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				slang_assembly_typeinfo_destruct (&ti_elem);

+				return 0;

+			}

+			if (!slang_assembly_file_push (file, slang_asm_int_to_addr))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				slang_assembly_typeinfo_destruct (&ti_elem);

+				return 0;

+			}

+			if (!slang_assembly_file_push_label (file, slang_asm_addr_push, elem_size))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				slang_assembly_typeinfo_destruct (&ti_elem);

+				return 0;

+			}

+			if (!slang_assembly_file_push (file, slang_asm_addr_multiply))

+			{

+				slang_assembly_typeinfo_destruct (&ti_arr);

+				slang_assembly_typeinfo_destruct (&ti_elem);

+				return 0;

+			}

+			if (reference)

+			{

+				if (!slang_assembly_file_push (file, slang_asm_addr_add))

+				{

+					slang_assembly_typeinfo_destruct (&ti_arr);

+					slang_assembly_typeinfo_destruct (&ti_elem);

+					return 0;

+				}

+			}

+			else

+			{

+				unsigned int i;

+				for (i = 0; i < elem_size; i += 4)

+				{

+					if (!slang_assembly_file_push_label2 (file, slang_asm_float_move,

+						arr_size - elem_size + i + 4, i + 4))

+					{

+						slang_assembly_typeinfo_destruct (&ti_arr);

+						slang_assembly_typeinfo_destruct (&ti_elem);

+						return 0;

+					}

+				}

+				if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+				{

+					slang_assembly_typeinfo_destruct (&ti_arr);

+					slang_assembly_typeinfo_destruct (&ti_elem);

+					return 0;

+				}

+				if (!slang_assembly_file_push_label (file, slang_asm_local_free,

+					arr_size - elem_size))

+				{

+					slang_assembly_typeinfo_destruct (&ti_arr);

+					slang_assembly_typeinfo_destruct (&ti_elem);

+					return 0;

+				}

+			}

+			slang_assembly_typeinfo_destruct (&ti_arr);

+			slang_assembly_typeinfo_destruct (&ti_elem);

+		}

+		break;

+	case slang_oper_call:

+		{

+			slang_function *fun = _slang_locate_function (op->identifier, op->children,

+				op->num_children, space);

+			if (fun == NULL)

+			{

+				if (!_slang_assemble_constructor (file, op, flow, space, info))

+					return 0;

+			}

+			else

+			{

+				if (!call_function (file, fun, op->children, op->num_children, 0, space, info))

+					return 0;

+			}

+		}

+		break;

+	case slang_oper_field:

+		{

+			slang_assembly_typeinfo ti_after, ti_before;

+			slang_assembly_stack_info _stk;

+			slang_assembly_typeinfo_construct (&ti_after);

+			if (!_slang_typeof_operation (op, space, &ti_after))

+			{

+				slang_assembly_typeinfo_destruct (&ti_after);

+				return 0;

+			}

+			slang_assembly_typeinfo_construct (&ti_before);

+			if (!_slang_typeof_operation (op->children, space, &ti_before))

+			{

+				slang_assembly_typeinfo_destruct (&ti_after);

+				slang_assembly_typeinfo_destruct (&ti_before);

+				return 0;

+			}

+			if (!reference && ti_after.is_swizzled)

+			{

+				if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr,

+					info->swizzle_tmp, 16))

+				{

+					slang_assembly_typeinfo_destruct (&ti_after);

+					slang_assembly_typeinfo_destruct (&ti_before);

+					return 0;

+				}

+			}

+			if (!_slang_assemble_operation (file, op->children, reference, flow, space, info,

+				&_stk))

+			{

+				slang_assembly_typeinfo_destruct (&ti_after);

+				slang_assembly_typeinfo_destruct (&ti_before);

+				return 0;

+			}

+			/* TODO: inspect stk */

+			if (ti_after.is_swizzled)

+			{

+				if (reference)

+				{

+					if (ti_after.swz.num_components == 1)

+					{

+						if (!slang_assembly_file_push_label (file, slang_asm_addr_push,

+							ti_after.swz.swizzle[0] * 4))

+						{

+							slang_assembly_typeinfo_destruct (&ti_after);

+							slang_assembly_typeinfo_destruct (&ti_before);

+							return 0;

+						}

+						if (!slang_assembly_file_push (file, slang_asm_addr_add))

+						{

+							slang_assembly_typeinfo_destruct (&ti_after);

+							slang_assembly_typeinfo_destruct (&ti_before);

+							return 0;

+						}

+					}

+					else

+					{

+						unsigned int i;

+						for (i = 0; i < ti_after.swz.num_components; i++)

+							stk->swizzle_mask |= 1 << ti_after.swz.swizzle[i];

+					}

+				}

+				else

+				{

+					if (!_slang_assemble_constructor_from_swizzle (file, &ti_after.swz,

+						&ti_after.spec, &ti_before.spec, info))

+					{

+						slang_assembly_typeinfo_destruct (&ti_after);

+						slang_assembly_typeinfo_destruct (&ti_before);

+						return 0;

+					}

+				}

+			}

+			else

+			{

+				if (reference)

+				{

+					/* TODO: struct field address */

+				}

+				else

+				{

+					/* TODO: struct field value */

+				}

+			}

+			slang_assembly_typeinfo_destruct (&ti_after);

+			slang_assembly_typeinfo_destruct (&ti_before);

+		}

+		break;

+	case slang_oper_postincrement:

+		if (!call_function_name_dummyint (file, "++", op->children, space, info))

+			return 0;

+		if (!dereference (file, op, space, info))

+			return 0;

+		break;

+	case slang_oper_postdecrement:

+		if (!call_function_name_dummyint (file, "--", op->children, space, info))

+			return 0;

+		if (!dereference (file, op, space, info))

+			return 0;

+		break;

+	default:

+		return 0;

+	}

+	return 1;

+}

+

+

+

+

+

+

+

+

+

+void xxx_first (slang_assembly_file *file)

+{

+	slang_assembly_file_push (file, slang_asm_jump);

+}

+

+void xxx_prolog (slang_assembly_file *file)

+{

+	file->code[0].param[0] = file->count;

+

+	/* allocate local storage for inout/out params */

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_label (file, slang_asm_enter, 4);

+

+/*	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);*/

+	slang_assembly_file_push_literal (file, slang_asm_int_push, 777.777f);

+/*	slang_assembly_file_push_literal (file, slang_asm_float_push, 16.16f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 15.15f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 14.14f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 13.13f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 12.12f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 11.11f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 10.10f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 9.9f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 8.8f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 7.7f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 6.6f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 5.5f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 4.4f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 3.3f);

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 2.2f);*/

+	slang_assembly_file_push_literal (file, slang_asm_float_push, 1.1f);

+

+	slang_assembly_file_push_label (file, slang_asm_call, file->count + 3);

+	slang_assembly_file_push_label (file, slang_asm_local_free, 4);

+

+	slang_assembly_file_push (file, slang_asm_exit);

+}

+

diff --git a/src/mesa/shader/slang/slang_assemble.h b/src/mesa/shader/slang/slang_assemble.h
new file mode 100644
index 00000000000..21721c42732
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble.h
@@ -0,0 +1,145 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_ASSEMBLE_H

+#define SLANG_ASSEMBLE_H

+

+#include "slang_compile.h"

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef enum slang_assembly_type_

+{

+	/* core */

+	slang_asm_none,

+	slang_asm_float_copy,

+	slang_asm_float_move,

+	slang_asm_float_push,

+	slang_asm_float_deref,

+	slang_asm_float_add,

+	slang_asm_float_multiply,

+	slang_asm_float_divide,

+	slang_asm_float_negate,

+	slang_asm_float_less,

+	slang_asm_float_equal,

+	slang_asm_float_to_int,

+	slang_asm_int_copy,

+	slang_asm_int_move,

+	slang_asm_int_push,

+	slang_asm_int_deref,

+	slang_asm_int_to_float,

+	slang_asm_int_to_addr,

+	slang_asm_bool_copy,

+	slang_asm_bool_move,

+	slang_asm_bool_push,

+	slang_asm_bool_deref,

+	slang_asm_addr_copy,

+	slang_asm_addr_push,

+	slang_asm_addr_deref,

+	slang_asm_addr_add,

+	slang_asm_addr_multiply,

+	slang_asm_jump,

+	slang_asm_jump_if_zero,

+	slang_asm_enter,

+	slang_asm_leave,

+	slang_asm_local_alloc,

+	slang_asm_local_free,

+	slang_asm_local_addr,

+	slang_asm_call,

+	slang_asm_return,

+	slang_asm_discard,

+	slang_asm_exit,

+	slang_asm__last

+} slang_assembly_type;

+

+typedef struct slang_assembly_

+{

+	slang_assembly_type type;

+	GLfloat literal;

+	GLuint param[2];

+} slang_assembly;

+

+typedef struct slang_assembly_file_

+{

+	slang_assembly *code;

+	unsigned int count;

+} slang_assembly_file;

+

+void slang_assembly_file_construct (slang_assembly_file *);

+void slang_assembly_file_destruct (slang_assembly_file *);

+int slang_assembly_file_push (slang_assembly_file *, slang_assembly_type);

+int slang_assembly_file_push_label (slang_assembly_file *, slang_assembly_type, GLuint);

+int slang_assembly_file_push_label2 (slang_assembly_file *, slang_assembly_type, GLuint, GLuint);

+int slang_assembly_file_push_literal (slang_assembly_file *, slang_assembly_type, GLfloat);

+

+typedef struct slang_assembly_flow_control_

+{

+	unsigned int loop_start;			/* for "continue" statement */

+	unsigned int loop_end;				/* for "break" statement */

+	unsigned int function_end;			/* for "return" statement */

+} slang_assembly_flow_control;

+

+typedef struct slang_assembly_name_space_

+{

+	struct slang_function_scope_ *funcs;

+	struct slang_struct_scope_ *structs;

+	struct slang_variable_scope_ *vars;

+} slang_assembly_name_space;

+

+slang_function *_slang_locate_function (const char *name, slang_operation *params,

+	unsigned int num_params, slang_assembly_name_space *space);

+

+int _slang_assemble_function (slang_assembly_file *, struct slang_function_ *,

+	slang_assembly_name_space *);

+

+typedef struct slang_assembly_stack_info_

+{

+	unsigned int swizzle_mask;

+} slang_assembly_stack_info;

+

+int _slang_cleanup_stack (slang_assembly_file *, slang_operation *, int ref,

+	slang_assembly_name_space *);

+

+typedef struct slang_assembly_local_info_

+{

+	unsigned int ret_size;

+	unsigned int addr_tmp;

+	unsigned int swizzle_tmp;

+} slang_assembly_local_info;

+

+int _slang_assemble_operation (slang_assembly_file *, struct slang_operation_ *, int reference,

+	slang_assembly_flow_control *, slang_assembly_name_space *, slang_assembly_local_info *,

+	slang_assembly_stack_info *);

+

+void xxx_first (slang_assembly_file *);

+void xxx_prolog (slang_assembly_file *);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_assemble_conditional.c b/src/mesa/shader/slang/slang_assemble_conditional.c
new file mode 100644
index 00000000000..498938bdd55
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_conditional.c
@@ -0,0 +1,485 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_assemble_conditional.c

+ * slang condtional expressions assembler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_assemble_conditional.h"

+#include "slang_assemble.h"

+

+/* _slang_assemble_logicaland() */

+

+int _slang_assemble_logicaland (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		and:

+			<left-expression>

+			jumpz zero

+			<right-expression>

+			jump end

+		zero:

+			push 0

+		end:

+	*/

+

+	unsigned int zero_jump, end_jump;

+	slang_assembly_stack_info stk;

+

+	/* evaluate left expression */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to pushing 0 if not true */

+	zero_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* evaluate right expression */

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to the end of the expression */

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* push 0 on stack */

+	file->code[zero_jump].param[0] = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_bool_push))

+		return 0;

+

+	/* the end of the expression */

+	file->code[end_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_logicalor() */

+

+int _slang_assemble_logicalor (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		or:

+			<left-expression>

+			jumpz right

+			push 1

+			jump end

+		right:

+			<right-expression>

+		end:

+	*/

+

+	unsigned int right_jump, end_jump;

+	slang_assembly_stack_info stk;

+

+	/* evaluate left expression */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to evaluation of right expression if not true */

+	right_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* push 1 on stack */

+	if (!slang_assembly_file_push_literal (file, slang_asm_bool_push, 1.0f))

+		return 0;

+

+	/* jump to the end of the expression */

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* evaluate right expression */

+	file->code[right_jump].param[0] = file->count;

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* the end of the expression */

+	file->code[end_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_select() */

+

+int _slang_assemble_select (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		select:

+			<condition-expression>

+			jumpz false

+			<true-expression>

+			jump end

+		false:

+			<false-expression>

+		end:

+	*/

+

+	unsigned int cond_jump, end_jump;

+	slang_assembly_stack_info stk;

+

+	/* execute condition expression */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to false expression if not true */

+	cond_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* execute true expression */

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to the end of the expression */

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* resolve false point */

+	file->code[cond_jump].param[0] = file->count;

+

+	/* execute false expression */

+	if (!_slang_assemble_operation (file, op->children + 2, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* resolve the end of the expression */

+	file->code[end_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_for() */

+

+int _slang_assemble_for (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		for:

+			<init-statement>

+			jump start

+		break:

+			jump end

+		continue:

+			<loop-increment>

+		start:

+			<condition-statement>

+			jumpz end

+			<loop-body>

+			jump continue

+		end:

+	*/

+

+	unsigned int start_jump, end_jump, cond_jump;

+	unsigned int break_label, cont_label;

+	slang_assembly_flow_control loop_flow = *flow;

+	slang_assembly_stack_info stk;

+

+	/* execute initialization statement */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children, 0, space))

+		return 0;

+

+	/* skip the "go to the end of the loop" and loop-increment statements */

+	start_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* go to the end of the loop - break statements are directed here */

+	break_label = file->count;

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* resolve the beginning of the loop - continue statements are directed here */

+	cont_label = file->count;

+

+	/* execute loop-increment statement */

+	if (!_slang_assemble_operation (file, op->children + 2, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children + 2, 0, space))

+		return 0;

+

+	/* resolve the condition point */

+	file->code[start_jump].param[0] = file->count;

+

+	/* execute condition statement */

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: inspect stk */

+

+	/* jump to the end of the loop if not true */

+	cond_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* execute loop body */

+	loop_flow.loop_start = cont_label;

+	loop_flow.loop_end = break_label;

+	if (!_slang_assemble_operation (file, op->children + 3, 0, &loop_flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children + 3, 0, space))

+		return 0;

+

+	/* go to the beginning of the loop */

+	if (!slang_assembly_file_push_label (file, slang_asm_jump, cont_label))

+		return 0;

+

+	/* resolve the end of the loop */

+	file->code[end_jump].param[0] = file->count;

+	file->code[cond_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_do() */

+

+int _slang_assemble_do (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		do:

+			jump start

+		break:

+			jump end

+		continue:

+			jump condition

+		start:

+			<loop-body>

+		condition:

+			<condition-statement>

+			jumpz end

+			jump start

+		end:

+	*/

+

+	unsigned int skip_jump, end_jump, cont_jump, cond_jump;

+	unsigned int break_label, cont_label;

+	slang_assembly_flow_control loop_flow = *flow;

+	slang_assembly_stack_info stk;

+

+	/* skip the "go to the end of the loop" and "go to condition" statements */

+	skip_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* go to the end of the loop - break statements are directed here */

+	break_label = file->count;

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* go to condition - continue statements are directed here */

+	cont_label = file->count;

+	cont_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* resolve the beginning of the loop */

+	file->code[skip_jump].param[0] = file->count;

+

+	/* execute loop body */

+	loop_flow.loop_start = cont_label;

+	loop_flow.loop_end = break_label;

+	if (!_slang_assemble_operation (file, op->children, 0, &loop_flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children, 0, space))

+		return 0;

+

+	/* resolve condition point */

+	file->code[cont_jump].param[0] = file->count;

+

+	/* execute condition statement */

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+

+	/* jump to the end of the loop if not true */

+	cond_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* jump to the beginning of the loop */

+	if (!slang_assembly_file_push_label (file, slang_asm_jump, file->code[skip_jump].param[0]))

+		return 0;

+

+	/* resolve the end of the loop */

+	file->code[end_jump].param[0] = file->count;

+	file->code[cond_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_while() */

+

+int _slang_assemble_while (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		while:

+			jump continue

+		break:

+			jump end

+		continue:

+			<condition-statement>

+			jumpz end

+			<loop-body>

+			jump continue

+		end:

+	*/

+

+	unsigned int skip_jump, end_jump, cond_jump;

+	unsigned int break_label;

+	slang_assembly_flow_control loop_flow = *flow;

+	slang_assembly_stack_info stk;

+

+	/* skip the "go to the end of the loop" statement */

+	skip_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* go to the end of the loop - break statements are directed here */

+	break_label = file->count;

+	end_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* resolve the beginning of the loop - continue statements are directed here */

+	file->code[skip_jump].param[0] = file->count;

+

+	/* execute condition statement */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+

+	/* jump to the end of the loop if not true */

+	cond_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* execute loop body */

+	loop_flow.loop_start = file->code[skip_jump].param[0];

+	loop_flow.loop_end = break_label;

+	if (!_slang_assemble_operation (file, op->children + 1, 0, &loop_flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children + 1, 0, space))

+		return 0;

+

+	/* jump to the beginning of the loop */

+	if (!slang_assembly_file_push_label (file, slang_asm_jump, file->code[skip_jump].param[0]))

+		return 0;

+

+	/* resolve the end of the loop */

+	file->code[end_jump].param[0] = file->count;

+	file->code[cond_jump].param[0] = file->count;

+

+	return 1;

+}

+

+/* _slang_assemble_if() */

+

+int _slang_assemble_if (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	/*

+		if:

+			<condition-statement>

+			jumpz else

+			<true-statement>

+			jump end

+		else:

+			<false-statement>

+		end:

+	*/

+

+	unsigned int cond_jump, else_jump;

+	slang_assembly_stack_info stk;

+

+	/* execute condition statement */

+	if (!_slang_assemble_operation (file, op->children, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+

+	/* jump to false-statement if not true */

+	cond_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump_if_zero))

+		return 0;

+

+	/* execute true-statement */

+	if (!_slang_assemble_operation (file, op->children + 1, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children + 1, 0, space))

+		return 0;

+

+	/* skip if-false statement */

+	else_jump = file->count;

+	if (!slang_assembly_file_push (file, slang_asm_jump))

+		return 0;

+

+	/* resolve start of false-statement */

+	file->code[cond_jump].param[0] = file->count;

+

+	/* execute false-statement */

+	if (!_slang_assemble_operation (file, op->children + 2, 0, flow, space, info, &stk))

+		return 0;

+	/* TODO: pass-in stk to cleanup */

+	if (!_slang_cleanup_stack (file, op->children + 2, 0, space))

+		return 0;

+

+	/* resolve end of if-false statement */

+	file->code[else_jump].param[0] = file->count;

+

+	return 1;

+}

+

diff --git a/src/mesa/shader/slang/slang_assemble_conditional.h b/src/mesa/shader/slang/slang_assemble_conditional.h
new file mode 100644
index 00000000000..9ae2c62a21f
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_conditional.h
@@ -0,0 +1,66 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_ASSEMBLE_CONDITIONAL_H

+#define SLANG_ASSEMBLE_CONDITIONAL_H

+

+#include "slang_assemble.h"

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+int _slang_assemble_logicaland (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_logicalor (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_select (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_for (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_do (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_while (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_if (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_assemble_constructor.c b/src/mesa/shader/slang/slang_assemble_constructor.c
new file mode 100644
index 00000000000..976e2a02a5e
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_constructor.c
@@ -0,0 +1,333 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_assemble_constructor.c

+ * slang constructor and vector swizzle assembler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_assemble_constructor.h"

+#include "slang_assemble_typeinfo.h"

+#include "slang_storage.h"

+

+/* _slang_is_swizzle() */

+

+int _slang_is_swizzle (const char *field, unsigned int rows, slang_swizzle *swz)

+{

+	unsigned int i;

+	int xyzw = 0, rgba = 0, stpq = 0;

+

+	/* the swizzle can be at most 4-component long */

+	swz->num_components = slang_string_length (field);

+	if (swz->num_components > 4)

+		return 0;

+

+	for (i = 0; i < swz->num_components; i++)

+	{

+		/* mark which swizzle group is used */

+		switch (field[i])

+		{

+		case 'x':

+		case 'y':

+		case 'z':

+		case 'w':

+			xyzw = 1;

+			break;

+		case 'r':

+		case 'g':

+		case 'b':

+		case 'a':

+			rgba = 1;

+			break;

+		case 's':

+		case 't':

+		case 'p':

+		case 'q':

+			stpq = 1;

+			break;

+		default:

+			return 0;

+		}

+

+		/* collect swizzle component */

+		switch (field[i])

+		{

+		case 'x':

+		case 'r':

+		case 's':

+			swz->swizzle[i] = 0;

+			break;

+		case 'y':

+		case 'g':

+		case 't':

+			if (rows < 2)

+				return 0;

+			swz->swizzle[i] = 1;

+			break;

+		case 'z':

+		case 'b':

+		case 'p':

+			if (rows < 3)

+				return 0;

+			swz->swizzle[i] = 2;

+			break;

+		case 'w':

+		case 'a':

+		case 'q':

+			if (rows < 4)

+				return 0;

+			swz->swizzle[i] = 3;

+			break;

+		}

+	}

+

+	/* only one swizzle group can be used */

+	if ((xyzw && rgba) || (xyzw && stpq) || (rgba && stpq))

+		return 0;

+

+	return 1;

+}

+

+/* _slang_is_swizzle_mask() */

+

+int _slang_is_swizzle_mask (const slang_swizzle *swz, unsigned int rows)

+{

+	unsigned int c, i;

+

+	if (swz->num_components > rows)

+		return 0;

+	c = swz->swizzle[0];

+	for (i = 1; i < swz->num_components; i++)

+	{

+		if (swz->swizzle[i] <= c)

+			return 0;

+		c = swz->swizzle[i];

+	}

+	return 1;

+}

+

+/* _slang_multiply_swizzles() */

+

+void _slang_multiply_swizzles (slang_swizzle *dst, const slang_swizzle *left,

+	const slang_swizzle *right)

+{

+	unsigned int i;

+	dst->num_components = right->num_components;

+	for (i = 0; i < right->num_components; i++)

+		dst->swizzle[i] = left->swizzle[right->swizzle[i]];

+}

+

+/* _slang_assemble_constructor() */

+

+static int constructor_aggregate (slang_assembly_file *file, const slang_storage_aggregate *flat,

+	unsigned int *index, slang_operation *op, unsigned int size, slang_assembly_flow_control *flow,

+	slang_assembly_name_space *space, slang_assembly_local_info *info)

+{

+	slang_assembly_typeinfo ti;

+	int result;

+	slang_storage_aggregate agg, flat_agg;

+	slang_assembly_stack_info stk;

+	unsigned int i;

+

+	slang_assembly_typeinfo_construct (&ti);

+	if (!(result = _slang_typeof_operation (op, space, &ti)))

+		goto end1;

+

+	slang_storage_aggregate_construct (&agg);

+	if (!(result = _slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs)))

+		goto end2;

+

+	slang_storage_aggregate_construct (&flat_agg);

+	if (!(result = _slang_flatten_aggregate (&flat_agg, &agg)))

+		goto end;

+

+	if (!(result = _slang_assemble_operation (file, op, 0, flow, space, info, &stk)))

+		goto end;

+

+	for (i = 0; i < flat_agg.count; i++)

+	{

+		const slang_storage_array *arr1 = flat_agg.arrays + i;

+		const slang_storage_array *arr2 = flat->arrays + *index;

+

+		if (arr1->type != arr2->type)

+		{

+			/* TODO: convert (generic) from arr1 to arr2 */

+		}

+		(*index)++;

+		/* TODO: watch the index, if it reaches the size, pop off the stack subsequent values */

+	}

+

+	result = 1;

+end:

+	slang_storage_aggregate_destruct (&flat_agg);

+end2:

+	slang_storage_aggregate_destruct (&agg);

+end1:

+	slang_assembly_typeinfo_destruct (&ti);

+	return result;

+}

+/* XXX: general swizzle! */

+int _slang_assemble_constructor (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info)

+{

+	slang_assembly_typeinfo ti;

+	int result;

+	slang_storage_aggregate agg, flat;

+	unsigned int size, index, i;

+

+	slang_assembly_typeinfo_construct (&ti);

+	if (!(result = _slang_typeof_operation (op, space, &ti)))

+		goto end1;

+

+	slang_storage_aggregate_construct (&agg);

+	if (!(result = _slang_aggregate_variable (&agg, &ti.spec, NULL, space->funcs, space->structs)))

+		goto end2;

+

+	size = _slang_sizeof_aggregate (&agg);

+

+	slang_storage_aggregate_construct (&flat);

+	if (!(result = _slang_flatten_aggregate (&flat, &agg)))

+		goto end;

+

+	index = 0;

+	for (i = 0; i < op->num_children; i++)

+	{

+		if (!(result = constructor_aggregate (file, &flat, &index, op->children + i, size, flow,

+			space, info)))

+			goto end;

+		/* TODO: watch the index, if it reaches the size, raise an error */

+	}

+

+	result = 1;

+end:

+	slang_storage_aggregate_destruct (&flat);

+end2:

+	slang_storage_aggregate_destruct (&agg);

+end1:

+	slang_assembly_typeinfo_destruct (&ti);

+	return result;

+}

+

+/* _slang_assemble_constructor_from_swizzle() */

+/* XXX: wrong */

+int _slang_assemble_constructor_from_swizzle (slang_assembly_file *file, const slang_swizzle *swz,

+	slang_type_specifier *spec, slang_type_specifier *master_spec, slang_assembly_local_info *info)

+{

+	unsigned int master_rows, i;

+	switch (master_spec->type)

+	{

+	case slang_spec_bool:

+	case slang_spec_int:

+	case slang_spec_float:

+		master_rows = 1;

+		break;

+	case slang_spec_bvec2:

+	case slang_spec_ivec2:

+	case slang_spec_vec2:

+		master_rows = 2;

+		break;

+	case slang_spec_bvec3:

+	case slang_spec_ivec3:

+	case slang_spec_vec3:

+		master_rows = 3;

+		break;

+	case slang_spec_bvec4:

+	case slang_spec_ivec4:

+	case slang_spec_vec4:

+		master_rows = 4;

+		break;

+	}

+	for (i = 0; i < master_rows; i++)

+	{

+		switch (master_spec->type)

+		{

+		case slang_spec_bool:

+		case slang_spec_bvec2:

+		case slang_spec_bvec3:

+		case slang_spec_bvec4:

+			if (!slang_assembly_file_push_label2 (file, slang_asm_bool_copy, (master_rows - i) * 4,

+				i * 4))

+				return 0;

+			break;

+		case slang_spec_int:

+		case slang_spec_ivec2:

+		case slang_spec_ivec3:

+		case slang_spec_ivec4:

+			if (!slang_assembly_file_push_label2 (file, slang_asm_int_copy, (master_rows - i) * 4,

+				i * 4))

+				return 0;

+			break;

+		case slang_spec_float:

+		case slang_spec_vec2:

+		case slang_spec_vec3:

+		case slang_spec_vec4:

+			if (!slang_assembly_file_push_label2 (file, slang_asm_float_copy,

+				(master_rows - i) * 4, i * 4))

+				return 0;

+			break;

+		}

+	}

+	if (!slang_assembly_file_push_label (file, slang_asm_local_free, 4))

+		return 0;

+	for (i = swz->num_components; i > 0; i--)

+	{

+		unsigned int n = i - 1;

+		if (!slang_assembly_file_push_label2 (file, slang_asm_local_addr, info->swizzle_tmp, 16))

+			return 0;

+		if (!slang_assembly_file_push_label (file, slang_asm_addr_push, swz->swizzle[n] * 4))

+			return 0;

+		if (!slang_assembly_file_push (file, slang_asm_addr_add))

+			return 0;

+		switch (master_spec->type)

+		{

+		case slang_spec_bool:

+		case slang_spec_bvec2:

+		case slang_spec_bvec3:

+		case slang_spec_bvec4:

+			if (!slang_assembly_file_push (file, slang_asm_bool_deref))

+				return 0;

+			break;

+		case slang_spec_int:

+		case slang_spec_ivec2:

+		case slang_spec_ivec3:

+		case slang_spec_ivec4:

+			if (!slang_assembly_file_push (file, slang_asm_int_deref))

+				return 0;

+			break;

+		case slang_spec_float:

+		case slang_spec_vec2:

+		case slang_spec_vec3:

+		case slang_spec_vec4:

+			if (!slang_assembly_file_push (file, slang_asm_float_deref))

+				return 0;

+			break;

+		}

+	}

+	return 1;

+}

+

diff --git a/src/mesa/shader/slang/slang_assemble_constructor.h b/src/mesa/shader/slang/slang_assemble_constructor.h
new file mode 100644
index 00000000000..f8a0fead3ca
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_constructor.h
@@ -0,0 +1,80 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_ASSEMBLE_CONSTRUCTOR_H

+#define SLANG_ASSEMBLE_CONSTRUCTOR_H

+

+#include "slang_assemble.h"

+#include "slang_compile.h"

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+/*

+	holds a complete information about vector swizzle - the <swizzle> array contains

+	vector component sources indices, where 0 is "x", 1 is "y", ...

+	example: "xwz" --> { 3, { 0, 3, 2, n/u } }

+*/

+typedef struct slang_swizzle_

+{

+	unsigned int num_components;

+	unsigned int swizzle[4];

+} slang_swizzle;

+

+/*

+	checks if a field selector is a general swizzle (an r-value swizzle with replicated

+	components or an l-value swizzle mask) for a vector

+	returns 1 if this is the case, <swz> is filled with swizzle information

+	returns 0 otherwise

+*/

+int _slang_is_swizzle (const char *field, unsigned int rows, slang_swizzle *swz);

+

+/*

+	checks if a general swizzle is an l-value swizzle - these swizzles do not have

+	duplicated fields and they are specified in order

+	returns 1 if this is a swizzle mask

+	returns 0 otherwise

+*/

+int _slang_is_swizzle_mask (const slang_swizzle *swz, unsigned int rows);

+

+/*

+	combines two swizzles to form single swizzle

+	example: "wzyx.yx" --> "zw"

+*/

+void _slang_multiply_swizzles (slang_swizzle *, const slang_swizzle *, const slang_swizzle *);

+

+int _slang_assemble_constructor (slang_assembly_file *file, slang_operation *op,

+	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

+	slang_assembly_local_info *info);

+

+int _slang_assemble_constructor_from_swizzle (slang_assembly_file *file, const slang_swizzle *swz,

+	slang_type_specifier *spec, slang_type_specifier *master_spec, slang_assembly_local_info *info);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_assemble_typeinfo.c b/src/mesa/shader/slang/slang_assemble_typeinfo.c
new file mode 100644
index 00000000000..92af52a0e65
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_typeinfo.c
@@ -0,0 +1,428 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_assemble_typeinfo.c

+ * slang type info

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_assemble_typeinfo.h"

+

+/* slang_assembly_typeinfo */

+

+void slang_assembly_typeinfo_construct (slang_assembly_typeinfo *ti)

+{

+	slang_type_specifier_construct (&ti->spec);

+}

+

+void slang_assembly_typeinfo_destruct (slang_assembly_typeinfo *ti)

+{

+	slang_type_specifier_destruct (&ti->spec);

+}

+

+/* _slang_typeof_operation() */

+

+int _slang_typeof_operation (slang_operation *op, slang_assembly_name_space *space,

+	slang_assembly_typeinfo *ti)

+{

+	ti->can_be_referenced = 0;

+	ti->is_swizzled = 0;

+

+	switch (op->type)

+	{

+	case slang_oper_block_no_new_scope:

+	case slang_oper_block_new_scope:

+	case slang_oper_variable_decl:

+	case slang_oper_asm:

+	case slang_oper_break:

+	case slang_oper_continue:

+	case slang_oper_discard:

+	case slang_oper_return:

+	case slang_oper_if:

+	case slang_oper_while:

+	case slang_oper_do:

+	case slang_oper_for:

+	case slang_oper_void:

+		ti->spec.type = slang_spec_void;

+		break;

+	case slang_oper_expression:

+	case slang_oper_assign:

+	case slang_oper_addassign:

+	case slang_oper_subassign:

+	case slang_oper_mulassign:

+	case slang_oper_divassign:

+	case slang_oper_preincrement:

+	case slang_oper_predecrement:

+		if (!_slang_typeof_operation (op->children, space, ti))

+			return 0;

+		break;

+	case slang_oper_literal_bool:

+	case slang_oper_logicalor:

+	case slang_oper_logicalxor:

+	case slang_oper_logicaland:

+	case slang_oper_equal:

+	case slang_oper_notequal:

+	case slang_oper_less:

+	case slang_oper_greater:

+	case slang_oper_lessequal:

+	case slang_oper_greaterequal:

+	case slang_oper_not:

+		ti->spec.type = slang_spec_bool;

+		break;

+	case slang_oper_literal_int:

+		ti->spec.type = slang_spec_int;

+		break;

+	case slang_oper_literal_float:

+		ti->spec.type = slang_spec_float;

+		break;

+	case slang_oper_identifier:

+		{

+			slang_variable *var;

+

+			var = _slang_locate_variable (op->locals, op->identifier, 1);

+			if (var == NULL)

+				return 0;

+			if (!slang_type_specifier_copy (&ti->spec, &var->type.specifier))

+				return 0;

+			ti->can_be_referenced = 1;

+		}

+		break;

+	case slang_oper_sequence:

+		/* TODO: check [0] and [1] if they match */

+		if (!_slang_typeof_operation (op->children + 1, space, ti))

+			return 0;

+		ti->can_be_referenced = 0;

+		ti->is_swizzled = 0;

+		break;

+	/*case slang_oper_modassign:*/

+	/*case slang_oper_lshassign:*/

+	/*case slang_oper_rshassign:*/

+	/*case slang_oper_orassign:*/

+	/*case slang_oper_xorassign:*/

+	/*case slang_oper_andassign:*/

+	case slang_oper_select:

+		/* TODO: check [1] and [2] if they match */

+		if (!_slang_typeof_operation (op->children + 1, space, ti))

+			return 0;

+		ti->can_be_referenced = 0;

+		ti->is_swizzled = 0;

+		break;

+	/*case slang_oper_bitor:*/

+	/*case slang_oper_bitxor:*/

+	/*case slang_oper_bitand:*/

+	/*case slang_oper_lshift:*/

+	/*case slang_oper_rshift:*/

+	case slang_oper_add:

+		{

+			int exists;

+			if (!_slang_typeof_function ("+", op->children, 2, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	case slang_oper_subtract:

+		{

+			int exists;

+			if (!_slang_typeof_function ("-", op->children, 2, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	case slang_oper_multiply:

+		{

+			int exists;

+			if (!_slang_typeof_function ("*", op->children, 2, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	case slang_oper_divide:

+		{

+			int exists;

+			if (!_slang_typeof_function ("/", op->children, 2, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	/*case slang_oper_modulus:*/

+	case slang_oper_plus:

+		{

+			int exists;

+			if (!_slang_typeof_function ("+", op->children, 1, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	case slang_oper_minus:

+		{

+			int exists;

+			if (!_slang_typeof_function ("-", op->children, 1, space, &ti->spec, &exists))

+				return 0;

+			if (!exists)

+				return 0;

+		}

+		break;

+	/*case slang_oper_complement:*/

+	case slang_oper_subscript:

+		{

+			slang_assembly_typeinfo _ti;

+			slang_assembly_typeinfo_construct (&_ti);

+			if (!_slang_typeof_operation (op->children, space, &_ti))

+			{

+				slang_assembly_typeinfo_destruct (&_ti);

+				return 0;

+			}

+			ti->can_be_referenced = _ti.can_be_referenced;

+			switch (_ti.spec.type)

+			{

+			case slang_spec_bvec2:

+			case slang_spec_bvec3:

+			case slang_spec_bvec4:

+				ti->spec.type = slang_spec_bool;

+				break;

+			case slang_spec_ivec2:

+			case slang_spec_ivec3:

+			case slang_spec_ivec4:

+				ti->spec.type = slang_spec_int;

+				break;

+			case slang_spec_vec2:

+			case slang_spec_vec3:

+			case slang_spec_vec4:

+				ti->spec.type = slang_spec_float;

+				break;

+			case slang_spec_mat2:

+				ti->spec.type = slang_spec_vec2;

+				break;

+			case slang_spec_mat3:

+				ti->spec.type = slang_spec_vec3;

+				break;

+			case slang_spec_mat4:

+				ti->spec.type = slang_spec_vec4;

+				break;

+			case slang_spec_array:

+				if (!slang_type_specifier_copy (&ti->spec, _ti.spec._array))

+				{

+					slang_assembly_typeinfo_destruct (&_ti);

+					return 0;

+				}

+				break;

+			default:

+				slang_assembly_typeinfo_destruct (&_ti);

+				return 0;

+			}

+			slang_assembly_typeinfo_destruct (&_ti);

+		}

+		break;

+	case slang_oper_call:

+		{

+			int exists;

+			if (!_slang_typeof_function (op->identifier, op->children, op->num_children, space,

+				&ti->spec, &exists))

+				return 0;

+			if (!exists)

+			{

+				slang_struct *s = slang_struct_scope_find (space->structs, op->identifier, 1);

+				if (s != NULL)

+				{

+					ti->spec.type = slang_spec_struct;

+					ti->spec._struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));

+					if (ti->spec._struct == NULL)

+						return 0;

+					if (!slang_struct_construct_a (ti->spec._struct))

+					{

+						slang_alloc_free (ti->spec._struct);

+						ti->spec._struct = NULL;

+						return 0;

+					}

+					if (!slang_struct_copy (ti->spec._struct, s))

+						return 0;

+				}

+				else

+				{

+					slang_type_specifier_type type = slang_type_specifier_type_from_string (

+						op->identifier);

+					if (type == slang_spec_void)

+						return 0;

+					ti->spec.type = type;

+				}

+			}

+		}

+		break;

+	case slang_oper_field:

+		{

+			slang_assembly_typeinfo _ti;

+			slang_assembly_typeinfo_construct (&_ti);

+			if (!_slang_typeof_operation (op->children, space, &_ti))

+			{

+				slang_assembly_typeinfo_destruct (&_ti);

+				return 0;

+			}

+			if (_ti.spec.type == slang_spec_struct)

+			{

+				slang_variable *field = _slang_locate_variable (_ti.spec._struct->fields,

+					op->identifier, 0);

+				if (field == NULL)

+				{

+					slang_assembly_typeinfo_destruct (&_ti);

+					return 0;

+				}

+				if (!slang_type_specifier_copy (&ti->spec, &field->type.specifier))

+				{

+					slang_assembly_typeinfo_destruct (&_ti);

+					return 0;

+				}

+			}

+			else

+			{

+				unsigned int rows;

+				switch (_ti.spec.type)

+				{

+				case slang_spec_vec2:

+				case slang_spec_ivec2:

+				case slang_spec_bvec2:

+					rows = 2;

+					break;

+				case slang_spec_vec3:

+				case slang_spec_ivec3:

+				case slang_spec_bvec3:

+					rows = 3;

+					break;

+				case slang_spec_vec4:

+				case slang_spec_ivec4:

+				case slang_spec_bvec4:

+					rows = 4;

+					break;

+				default:

+					slang_assembly_typeinfo_destruct (&_ti);

+					return 0;

+				}

+				if (!_slang_is_swizzle (op->identifier, rows, &ti->swz))

+					return 0;

+				ti->is_swizzled = 1;

+				ti->can_be_referenced = _ti.can_be_referenced && _slang_is_swizzle_mask (&ti->swz,

+					rows);

+				if (_ti.is_swizzled)

+				{

+					slang_swizzle swz;

+					_slang_multiply_swizzles (&swz, &_ti.swz, &ti->swz);

+					ti->swz = swz;

+				}

+				switch (_ti.spec.type)

+				{

+				case slang_spec_vec2:

+				case slang_spec_vec3:

+				case slang_spec_vec4:

+					switch (ti->swz.num_components)

+					{

+					case 1:

+						ti->spec.type = slang_spec_float;

+						break;

+					case 2:

+						ti->spec.type = slang_spec_vec2;

+						break;

+					case 3:

+						ti->spec.type = slang_spec_vec3;

+						break;

+					case 4:

+						ti->spec.type = slang_spec_vec4;

+						break;

+					}

+					break;

+				case slang_spec_ivec2:

+				case slang_spec_ivec3:

+				case slang_spec_ivec4:

+					switch (ti->swz.num_components)

+					{

+					case 1:

+						ti->spec.type = slang_spec_int;

+						break;

+					case 2:

+						ti->spec.type = slang_spec_ivec2;

+						break;

+					case 3:

+						ti->spec.type = slang_spec_ivec3;

+						break;

+					case 4:

+						ti->spec.type = slang_spec_ivec4;

+						break;

+					}

+					break;

+				case slang_spec_bvec2:

+				case slang_spec_bvec3:

+				case slang_spec_bvec4:

+					switch (ti->swz.num_components)

+					{

+					case 1:

+						ti->spec.type = slang_spec_bool;

+						break;

+					case 2:

+						ti->spec.type = slang_spec_bvec2;

+						break;

+					case 3:

+						ti->spec.type = slang_spec_bvec3;

+						break;

+					case 4:

+						ti->spec.type = slang_spec_bvec4;

+						break;

+					}

+					break;

+				}

+			}

+			slang_assembly_typeinfo_destruct (&_ti);

+			return 1;

+		}

+		break;

+	case slang_oper_postincrement:

+	case slang_oper_postdecrement:

+		if (!_slang_typeof_operation (op->children, space, ti))

+			return 0;

+		ti->can_be_referenced = 0;

+		ti->is_swizzled = 0;

+		break;

+	default:

+		return 0;

+	}

+	return 1;

+}

+

+/* _slang_typeof_function() */

+

+int _slang_typeof_function (const char *name, slang_operation *params, unsigned int num_params,

+	slang_assembly_name_space *space, slang_type_specifier *spec, int *exists)

+{

+	slang_function *fun = _slang_locate_function (name, params, num_params, space);

+	*exists = fun != NULL;

+	if (fun == NULL)

+		return 1;

+	return slang_type_specifier_copy (spec, &fun->header.type.specifier);

+}

+

diff --git a/src/mesa/shader/slang/slang_assemble_typeinfo.h b/src/mesa/shader/slang/slang_assemble_typeinfo.h
new file mode 100644
index 00000000000..1c1839457eb
--- /dev/null
+++ b/src/mesa/shader/slang/slang_assemble_typeinfo.h
@@ -0,0 +1,67 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_ASSEMBLE_TYPEINFO_H

+#define SLANG_ASSEMBLE_TYPEINFO_H

+

+#include "slang_assemble_constructor.h"

+#include "slang_compile.h"

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef struct slang_assembly_typeinfo_

+{

+	int can_be_referenced;

+	int is_swizzled;

+	slang_swizzle swz;

+	slang_type_specifier spec;

+} slang_assembly_typeinfo;

+

+void slang_assembly_typeinfo_construct (slang_assembly_typeinfo *);

+void slang_assembly_typeinfo_destruct (slang_assembly_typeinfo *);

+

+/*

+	retrieves type information about an operation

+	returns 1 on success

+	returns 0 otherwise

+*/

+int _slang_typeof_operation (slang_operation *, slang_assembly_name_space *,

+	slang_assembly_typeinfo *);

+

+/*

+	retrieves type of a function prototype, if one exists

+	returns 1 on success, even if the function was not found

+	returns 0 otherwise

+*/

+int _slang_typeof_function (const char *name, slang_operation *params, unsigned int num_params,

+	slang_assembly_name_space *space, slang_type_specifier *spec, int *exists);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c
index 06dc7df9536..6835adea6d8 100644
--- a/src/mesa/shader/slang/slang_compile.c
+++ b/src/mesa/shader/slang/slang_compile.c
@@ -33,6 +33,9 @@
 #include "slang_utility.h"
 #include "slang_compile.h"
 #include "slang_preprocess.h"
+#include "slang_storage.h"
+#include "slang_assemble.h"
+#include "slang_execute.h"
 
 /*
 	This is a straightforward implementation of the slang front-end compiler.
@@ -43,22 +46,61 @@
 
 static void slang_variable_construct (slang_variable *);
 static int slang_variable_copy (slang_variable *, const slang_variable *);
-static void slang_struct_construct (slang_struct *);
 static void slang_struct_destruct (slang_struct *);
-static int slang_struct_copy (slang_struct *, const slang_struct *);
 static int slang_struct_equal (const slang_struct *, const slang_struct *);
 static void slang_variable_destruct (slang_variable *);
 
+/* slang_type_specifier_type */
+
+/* these must match with slang_type_specifier_type enum */
+static const char *type_specifier_type_names[] = {
+	"void",
+	"bool",
+	"bvec2",
+	"bvec3",
+	"bvec4",
+	"int",
+	"ivec2",
+	"ivec3",
+	"ivec4",
+	"float",
+	"vec2",
+	"vec3",
+	"vec4",
+	"mat2",
+	"mat3",
+	"mat4",
+	"sampler1D",
+	"sampler2D",
+	"sampler3D",
+	"samplerCube",
+	"sampler1DShadow",
+	"sampler2DShadow",
+	NULL
+};
+
+slang_type_specifier_type slang_type_specifier_type_from_string (const char *name)
+{
+	const char **p = type_specifier_type_names;
+	while (*p != NULL)
+	{
+		if (slang_string_compare (*p, name) == 0)
+			return (slang_type_specifier_type) (p - type_specifier_type_names);
+		p++;
+	}
+	return slang_spec_void;
+}
+
 /* slang_type_specifier */
 
-static void slang_type_specifier_construct (slang_type_specifier *spec)
+void slang_type_specifier_construct (slang_type_specifier *spec)
 {
 	spec->type = slang_spec_void;
 	spec->_struct = NULL;
 	spec->_array = NULL;
 }
 
-static void slang_type_specifier_destruct (slang_type_specifier *spec)
+void slang_type_specifier_destruct (slang_type_specifier *spec)
 {
 	if (spec->_struct != NULL)
 	{
@@ -72,7 +114,7 @@ static void slang_type_specifier_destruct (slang_type_specifier *spec)
 	}
 }
 
-static int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)
+int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)
 {
 	slang_type_specifier_destruct (x);
 	slang_type_specifier_construct (x);
@@ -80,19 +122,28 @@ static int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_
 	if (x->type == slang_spec_struct)
 	{
 		x->_struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));
-		slang_struct_construct (x->_struct);
+		if (x->_struct == NULL)
+			return 0;
+		if (!slang_struct_construct_a (x->_struct))
+		{
+			slang_alloc_free (x->_struct);
+			x->_struct = NULL;
+			return 0;
+		}
 		return slang_struct_copy (x->_struct, y->_struct);
 	}
 	if (x->type == slang_spec_array)
 	{
 		x->_array = (slang_type_specifier *) slang_alloc_malloc (sizeof (slang_type_specifier));
+		if (x->_array == NULL)
+			return 0;
 		slang_type_specifier_construct (x->_array);
 		return slang_type_specifier_copy (x->_array, y->_array);
 	}
 	return 1;
 }
 
-static int slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)
+int slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)
 {
 	if (x->type != y->type)
 		return 0;
@@ -162,8 +213,8 @@ static int slang_variable_scope_copy (slang_variable_scope *x, const slang_varia
 }
 
 /* slang_operation */
-/* XXX mem! */
-static void slang_operation_construct (slang_operation *oper)
+
+int slang_operation_construct_a (slang_operation *oper)
 {
 	oper->type = slang_oper_none;
 	oper->children = NULL;
@@ -171,10 +222,13 @@ static void slang_operation_construct (slang_operation *oper)
 	oper->literal = (float) 0;
 	oper->identifier = NULL;
 	oper->locals = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));
+	if (oper->locals == NULL)
+		return 0;
 	slang_variable_scope_construct (oper->locals);
+	return 1;
 }
 
-static void slang_operation_destruct (slang_operation *oper)
+void slang_operation_destruct (slang_operation *oper)
 {
 	unsigned int i;
 	for (i = 0; i < oper->num_children; i++)
@@ -188,17 +242,32 @@ static void slang_operation_destruct (slang_operation *oper)
 static int slang_operation_copy (slang_operation *x, const slang_operation *y)
 {
 	unsigned int i;
-	slang_operation_destruct (x);
-	slang_operation_construct (x);
+	for (i = 0; i < x->num_children; i++)
+		slang_operation_destruct (x->children + i);
+	slang_alloc_free (x->children);
+	x->num_children = 0;
+	slang_alloc_free (x->identifier);
+	x->identifier = NULL;
+	slang_variable_scope_destruct (x->locals);
+	slang_variable_scope_construct (x->locals);
+
 	x->type = y->type;
 	x->children = (slang_operation *) slang_alloc_malloc (y->num_children * sizeof (
 		slang_operation));
 	if (x->children == NULL)
 		return 0;
+	for (i = 0; i < y->num_children; i++)
+		if (!slang_operation_construct_a (x->children + i))
+		{
+			unsigned int j;
+			for (j = 0; j < i; j++)
+				slang_operation_destruct (x->children + j);
+			slang_alloc_free (x->children);
+			x->children = NULL;
+			return 0;
+		}
 	x->num_children = y->num_children;
 	for (i = 0; i < x->num_children; i++)
-		slang_operation_construct (x->children + i);
-	for (i = 0; i < x->num_children; i++)
 		if (!slang_operation_copy (x->children + i, y->children + i))
 			return 0;
 	x->literal = y->literal;
@@ -221,6 +290,7 @@ static void slang_variable_construct (slang_variable *var)
 	var->name = NULL;
 	var->array_size = NULL;
 	var->initializer = NULL;
+	var->address = ~0;
 }
 
 static void slang_variable_destruct (slang_variable *var)
@@ -256,7 +326,12 @@ static int slang_variable_copy (slang_variable *x, const slang_variable *y)
 		x->array_size = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
 		if (x->array_size == NULL)
 			return 0;
-		slang_operation_construct (x->array_size);
+		if (!slang_operation_construct_a (x->array_size))
+		{
+			slang_alloc_free (x->array_size);
+			x->array_size = NULL;
+			return 0;
+		}
 		if (!slang_operation_copy (x->array_size, y->array_size))
 			return 0;
 	}
@@ -265,13 +340,29 @@ static int slang_variable_copy (slang_variable *x, const slang_variable *y)
 		x->initializer = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
 		if (x->initializer == NULL)
 			return 0;
-		slang_operation_construct (x->initializer);
+		if (!slang_operation_construct_a (x->initializer))
+		{
+			slang_alloc_free (x->initializer);
+			x->initializer = NULL;
+			return 0;
+		}
 		if (!slang_operation_copy (x->initializer, y->initializer))
 			return 0;
 	}
 	return 1;
 }
 
+slang_variable *_slang_locate_variable (slang_variable_scope *scope, const char *name, int all)
+{
+	unsigned int i;
+	for (i = 0; i < scope->num_variables; i++)
+		if (slang_string_compare (name, scope->variables[i].name) == 0)
+			return scope->variables + i;
+	if (all && scope->outer_scope != NULL)
+		return _slang_locate_variable (scope->outer_scope, name, 1);
+	return NULL;
+}
+
 /* slang_struct_scope */
 
 static void slang_struct_scope_construct (slang_struct_scope *scope)
@@ -299,7 +390,17 @@ static int slang_struct_scope_copy (slang_struct_scope *x, const slang_struct_sc
 		return 0;
 	x->num_structs = y->num_structs;
 	for (i = 0; i < x->num_structs; i++)
-		slang_struct_construct (x->structs + i);
+	{
+		unsigned int j;
+		if (!slang_struct_construct_a (x->structs + i))
+		{
+			for (j = 0; j < i; j++)
+				slang_struct_destruct (x->structs + j);
+			slang_alloc_free (x->structs);
+			x->structs = NULL;
+			return 0;
+		}
+	}
 	for (i = 0; i < x->num_structs; i++)
 		if (!slang_struct_copy (x->structs + i, y->structs + i))
 			return 0;
@@ -307,8 +408,7 @@ static int slang_struct_scope_copy (slang_struct_scope *x, const slang_struct_sc
 	return 1;
 }
 
-static slang_struct *slang_struct_scope_find (slang_struct_scope *stru, const char *name,
-	int all_scopes)
+slang_struct *slang_struct_scope_find (slang_struct_scope *stru, const char *name, int all_scopes)
 {
 	unsigned int i;
 	for (i = 0; i < stru->num_structs; i++)
@@ -320,14 +420,23 @@ static slang_struct *slang_struct_scope_find (slang_struct_scope *stru, const ch
 }
 
 /* slang_struct */
-/* XXX mem! */
-static void slang_struct_construct (slang_struct *stru)
+
+int slang_struct_construct_a (slang_struct *stru)
 {
 	stru->name = NULL;
 	stru->fields = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));
+	if (stru->fields == NULL)
+		return 0;
 	slang_variable_scope_construct (stru->fields);
 	stru->structs = (slang_struct_scope *) slang_alloc_malloc (sizeof (slang_struct_scope));
+	if (stru->structs == NULL)
+	{
+		slang_variable_scope_destruct (stru->fields);
+		slang_alloc_free (stru->fields);
+		return 0;
+	}
 	slang_struct_scope_construct (stru->structs);
+	return 1;
 }
 
 static void slang_struct_destruct (slang_struct *stru)
@@ -339,10 +448,14 @@ static void slang_struct_destruct (slang_struct *stru)
 	slang_alloc_free (stru->structs);
 }
 
-static int slang_struct_copy (slang_struct *x, const slang_struct *y)
+int slang_struct_copy (slang_struct *x, const slang_struct *y)
 {
-	slang_struct_destruct (x);
-	slang_struct_construct (x);
+	slang_alloc_free (x->name);
+	x->name = NULL;
+	slang_variable_scope_destruct (x->fields);
+	slang_variable_scope_construct (x->fields);
+	slang_struct_scope_destruct (x->structs);
+	slang_struct_scope_construct (x->structs);
 	if (y->name != NULL)
 	{
 		x->name = slang_string_duplicate (y->name);
@@ -386,6 +499,7 @@ static void slang_function_construct (slang_function *func)
 	func->parameters = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));
 	slang_variable_scope_construct (func->parameters);
 	func->body = NULL;
+	func->address = ~0;
 }
 
 static void slang_function_destruct (slang_function *func)
@@ -561,7 +675,7 @@ typedef struct slang_parse_ctx_
 	int parsing_builtin;
 } slang_parse_ctx;
 
-/* --- */
+/* _slang_compile() */
 
 static int parse_identifier (slang_parse_ctx *C, char **id)
 {
@@ -826,7 +940,14 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 				slang_info_log_memory (C->L);
 				return 0;
 			}
-			slang_struct_construct (spec->_struct);
+			if (!slang_struct_construct_a (spec->_struct))
+			{
+				slang_alloc_free (spec->_struct);
+				spec->_struct = NULL;
+				slang_alloc_free (name);
+				slang_info_log_memory (C->L);
+				return 0;
+			}
 			spec->_struct->name = name;
 			spec->_struct->structs->outer_scope = structs;
 		}
@@ -878,7 +999,14 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 						slang_info_log_memory (C->L);
 						return 0;
 					}
-					slang_operation_construct (var->array_size);
+					if (!slang_operation_construct_a (var->array_size))
+					{
+						slang_alloc_free (var->array_size);
+						var->array_size = NULL;
+						slang_type_specifier_destruct (&sp);
+						slang_info_log_memory (C->L);
+						return 0;
+					}
 					if (!parse_expression (C, var->array_size, scope, structs, funcs))
 					{
 						slang_type_specifier_destruct (&sp);
@@ -904,8 +1032,9 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 				return 0;
 			}
 			s = structs->structs + structs->num_structs;
+			if (!slang_struct_construct_a (s))
+				return 0;
 			structs->num_structs++;
-			slang_struct_construct (s);
 			if (!slang_struct_copy (s, spec->_struct))
 				return 0;
 		}
@@ -931,7 +1060,12 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 				slang_info_log_memory (C->L);
 				return 0;
 			}
-			slang_struct_construct (spec->_struct);
+			if (!slang_struct_construct_a (spec->_struct))
+			{
+				slang_alloc_free (spec->_struct);
+				spec->_struct = NULL;
+				return 0;
+			}
 			if (!slang_struct_copy (spec->_struct, stru))
 				return 0;
 		}
@@ -1025,7 +1159,11 @@ static int parse_child_operation (slang_parse_ctx *C, slang_operation *oper, int
 		slang_info_log_memory (C->L);
 		return 0;
 	}
-	slang_operation_construct (oper->children + oper->num_children);
+	if (!slang_operation_construct_a (oper->children + oper->num_children))
+	{
+		slang_info_log_memory (C->L);
+		return 0;
+	}
 	oper->num_children++;
 	if (statement)
 		return parse_statement (C, oper->children + oper->num_children - 1, scope, structs, funcs);
@@ -1073,7 +1211,16 @@ static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_var
 					return 0;
 				}
 				for (i = 0; i < num_vars; i++)
-					slang_operation_construct (oper->children + i);
+					if (!slang_operation_construct_a (oper->children + i))
+					{
+						unsigned int j;
+						for (j = 0; j < i; j++)
+							slang_operation_destruct (oper->children + j);
+						slang_alloc_free (oper->children);
+						oper->children = NULL;
+						slang_info_log_memory (C->L);
+						return 0;
+					}
 				oper->num_children = num_vars;
 				for (i = first_var; i < scope->num_variables; i++)
 				{
@@ -1230,39 +1377,10 @@ static int handle_unary_expression (slang_parse_ctx *C, slang_operation *op,
 	return 1;
 }
 
-/* these must match with slang_type_specifier_type enum */
-static const char *builtin_constructor_names[] = {
-	"void",
-	"bool",
-	"bvec2",
-	"bvec3",
-	"bvec4",
-	"int",
-	"ivec2",
-	"ivec3",
-	"ivec4",
-	"float",
-	"vec2",
-	"vec3",
-	"vec4",
-	"mat2",
-	"mat3",
-	"mat4",
-	"sampler1D",
-	"sampler2D",
-	"sampler3D",
-	"samplerCube",
-	"sampler1DShadow",
-	"sampler2DShadow",
-	NULL
-};
-
 static int is_constructor_name (const char *name, slang_struct_scope *structs)
 {
-	const char **p = &builtin_constructor_names[1];
-	while (*p != NULL)
-		if (slang_string_compare (*p++, name) == 0)
-			return 1;
+	if (slang_type_specifier_type_from_string (name) != slang_spec_void)
+		return 1;
 	return slang_struct_scope_find (structs, name, 1) != NULL;
 }
 
@@ -1285,8 +1403,12 @@ static int parse_expression (slang_parse_ctx *C, slang_operation *oper, slang_va
 			return 0;
 		}
 		op = ops + num_ops;
+		if (!slang_operation_construct_a (op))
+		{
+			slang_info_log_memory (C->L);
+			return 0;
+		}
 		num_ops++;
-		slang_operation_construct (op);
 		op->locals->outer_scope = scope;
 		switch (op_code)
 		{
@@ -1513,6 +1635,7 @@ static int parse_expression (slang_parse_ctx *C, slang_operation *oper, slang_va
 static int parse_parameter_declaration (slang_parse_ctx *C, slang_variable *param,
 	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
 {
+	slang_storage_aggregate agg;
 	if (!parse_type_qualifier (C, &param->type.qualifier))
 		return 0;
 	switch (*C->I++)
@@ -1557,10 +1680,24 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_variable *para
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		slang_operation_construct (param->array_size);
+		if (!slang_operation_construct_a (param->array_size))
+		{
+			slang_alloc_free (param->array_size);
+			param->array_size = NULL;
+			slang_info_log_memory (C->L);
+			return 0;
+		}
 		if (!parse_expression (C, param->array_size, scope, structs, funcs))
 			return 0;
 	}
+	slang_storage_aggregate_construct (&agg);
+	if (!_slang_aggregate_variable (&agg, &param->type.specifier, param->array_size, funcs,
+		structs))
+	{
+		slang_storage_aggregate_destruct (&agg);
+		return 0;
+	}
+	slang_storage_aggregate_destruct (&agg);
 	return 1;
 }
 
@@ -1680,7 +1817,7 @@ static int parse_function_prototype (slang_parse_ctx *C, slang_function *func,
 		if (func->header.type.specifier.type == slang_spec_struct)
 			return 0;
 		func->header.name = slang_string_duplicate (
-			builtin_constructor_names[func->header.type.specifier.type]);
+			type_specifier_type_names[func->header.type.specifier.type]);
 		if (func->header.name == NULL)
 		{
 			slang_info_log_memory (C->L);
@@ -1728,7 +1865,13 @@ static int parse_function_definition (slang_parse_ctx *C, slang_function *func,
 		slang_info_log_memory (C->L);
 		return 0;
 	}
-	slang_operation_construct (func->body);
+	if (!slang_operation_construct_a (func->body))
+	{
+		slang_alloc_free (func->body);
+		func->body = NULL;
+		slang_info_log_memory (C->L);
+		return 0;
+	}
 	if (!parse_statement (C, func->body, func->parameters, structs, funcs))
 		return 0;
 	return 1;
@@ -1781,7 +1924,13 @@ static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specifie
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		slang_operation_construct (var->initializer);
+		if (!slang_operation_construct_a (var->initializer))
+		{
+			slang_alloc_free (var->initializer);
+			var->initializer = NULL;
+			slang_info_log_memory (C->L);
+			return 0;
+		}
 		if (!parse_expression (C, var->initializer, vars, structs, funcs))
 			return 0;
 		break;
@@ -1816,13 +1965,32 @@ static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specifie
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		slang_operation_construct (var->array_size);
+		if (!slang_operation_construct_a (var->array_size))
+		{
+			slang_alloc_free (var->array_size);
+			var->array_size = NULL;
+			slang_info_log_memory (C->L);
+			return 0;
+		}
 		if (!parse_expression (C, var->array_size, vars, structs, funcs))
 			return 0;
 		break;
 	default:
 		return 0;
 	}
+	if (!(var->type.specifier.type == slang_spec_array && var->array_size == NULL))
+	{
+		slang_storage_aggregate agg;
+
+		slang_storage_aggregate_construct (&agg);
+		if (!_slang_aggregate_variable (&agg, &var->type.specifier, var->array_size, funcs,
+			structs))
+		{
+			slang_storage_aggregate_destruct (&agg);
+			return 0;
+		}
+		slang_storage_aggregate_destruct (&agg);
+	}
 	return 1;
 }
 
@@ -1874,7 +2042,8 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 		}
 	}
 
-	/* find a function with a prototype matching the parsed one */
+	/* find a function with a prototype matching the parsed one - only the current scope
+	is being searched to allow built-in function overriding */
 	found_func = slang_function_scope_find (funcs, &parsed_func, 0);
 	if (found_func == NULL)
 	{
@@ -1919,6 +2088,37 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 		/* return the found function */
 		*parsed_func_ret = found_func;
 	}
+
+	/* assemble the parsed function */
+	if (definition)
+	{
+static int x = 0;
+const int y = 61;	/* core 437 */
+static
+		slang_assembly_file file;
+		slang_assembly_name_space space;
+x++;
+if (x == 1)
+		slang_assembly_file_construct (&file);
+		space.funcs = funcs;
+		space.structs = structs;
+		space.vars = scope;
+if (x == 1)
+	xxx_first (&file);
+if (x == y)
+	xxx_prolog (&file);
+		if (!_slang_assemble_function (&file, *parsed_func_ret, &space))
+		{
+			slang_assembly_file_destruct (&file);
+			return 0;
+		}
+if (x == y)
+{
+_slang_execute (&file);
+slang_assembly_file_destruct (&file);
+exit (0);
+}
+	}
 	return 1;
 }
 
diff --git a/src/mesa/shader/slang/slang_compile.h b/src/mesa/shader/slang/slang_compile.h
index 25a0ef8ad81..a9a075c37f2 100644
--- a/src/mesa/shader/slang/slang_compile.h
+++ b/src/mesa/shader/slang/slang_compile.h
@@ -68,14 +68,21 @@ typedef enum slang_type_specifier_type_
 	slang_spec_sampler2DShadow,
 	slang_spec_struct,
 	slang_spec_array
-} slang_type_specifier_type;
+} slang_type_specifier_type;

+

+slang_type_specifier_type slang_type_specifier_type_from_string (const char *);
 
 typedef struct slang_type_specifier_
 {
 	slang_type_specifier_type type;
 	struct slang_struct_ *_struct;		/* spec_struct */
 	struct slang_type_specifier_ *_array;	/* spec_array */
-} slang_type_specifier;
+} slang_type_specifier;

+

+void slang_type_specifier_construct (slang_type_specifier *);

+void slang_type_specifier_destruct (slang_type_specifier *);

+int slang_type_specifier_copy (slang_type_specifier *, const slang_type_specifier *);

+int slang_type_specifier_equal (const slang_type_specifier *, const slang_type_specifier *);
 
 typedef struct slang_fully_specified_type_
 {
@@ -164,29 +171,40 @@ typedef struct slang_operation_
 	float literal;		/* bool, literal_int, literal_float */
 	char *identifier;	/* asm, identifier, call, field */
 	slang_variable_scope *locals;
-} slang_operation;
+} slang_operation;

+

+int slang_operation_construct_a (slang_operation *);

+void slang_operation_destruct (slang_operation *);
 
 typedef struct slang_variable_
 {
 	slang_fully_specified_type type;
 	char *name;
 	slang_operation *array_size;	/* spec_array */
-	slang_operation *initializer;
-} slang_variable;
+	slang_operation *initializer;

+	unsigned int address;
+} slang_variable;

+

+slang_variable *_slang_locate_variable (slang_variable_scope *scope, const char *name, int all);
 
 typedef struct slang_struct_scope_
 {
 	struct slang_struct_ *structs;
 	unsigned int num_structs;
 	struct slang_struct_scope_ *outer_scope;
-} slang_struct_scope;
+} slang_struct_scope;

+

+struct slang_struct_ *slang_struct_scope_find (slang_struct_scope *, const char *, int);
 
 typedef struct slang_struct_
 {
 	char *name;
 	slang_variable_scope *fields;
 	slang_struct_scope *structs;
-} slang_struct;
+} slang_struct;

+

+int slang_struct_construct_a (slang_struct *);

+int slang_struct_copy (slang_struct *, const slang_struct *);
 
 typedef enum slang_function_kind_
 {
@@ -201,7 +219,8 @@ typedef struct slang_function_
 	slang_variable header;
 	slang_variable_scope *parameters;
 	unsigned int param_count;
-	slang_operation *body;
+	slang_operation *body;

+	unsigned int address;
 } slang_function;
 
 typedef struct slang_function_scope_
diff --git a/src/mesa/shader/slang/slang_execute.c b/src/mesa/shader/slang/slang_execute.c
new file mode 100644
index 00000000000..1bcc4188a84
--- /dev/null
+++ b/src/mesa/shader/slang/slang_execute.c
@@ -0,0 +1,347 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_execute.c

+ * intermediate code interpreter

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_assemble.h"

+#include "slang_storage.h"

+#include "slang_execute.h"

+

+static void dump_instruction (FILE *f, slang_assembly *a, unsigned int i)

+{

+	fprintf (f, "%.5u:\t", i);

+	

+	switch (a->type)

+	{

+	case slang_asm_none:

+		fprintf (f, "none");

+		break;

+	case slang_asm_float_copy:

+		fprintf (f, "float_copy\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_float_move:

+		fprintf (f, "float_move\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_float_push:

+		fprintf (f, "float_push\t%f", a->literal);

+		break;

+	case slang_asm_float_deref:

+		fprintf (f, "float_deref");

+		break;

+	case slang_asm_float_add:

+		fprintf (f, "float_add");

+		break;

+	case slang_asm_float_multiply:

+		fprintf (f, "float_multiply");

+		break;

+	case slang_asm_float_divide:

+		fprintf (f, "float_divide");

+		break;

+	case slang_asm_float_negate:

+		fprintf (f, "float_negate");

+		break;

+	case slang_asm_float_less:

+		fprintf (f, "float_less");

+		break;

+	case slang_asm_float_equal:

+		fprintf (f, "float_equal\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_float_to_int:

+		fprintf (f, "float_to_int");

+		break;

+	case slang_asm_int_copy:

+		fprintf (f, "int_copy\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_int_move:

+		fprintf (f, "int_move\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_int_push:

+		fprintf (f, "int_push\t%d", (GLint) a->literal);

+		break;

+	case slang_asm_int_deref:

+		fprintf (f, "int_deref");

+		break;

+	case slang_asm_int_to_float:

+		fprintf (f, "int_to_float");

+		break;

+	case slang_asm_int_to_addr:

+		fprintf (f, "int_to_addr");

+		break;

+	case slang_asm_bool_copy:

+		fprintf (f, "bool_copy\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_bool_move:

+		fprintf (f, "bool_move\t%d, %d", a->param[0], a->param[1]);

+		break;

+	case slang_asm_bool_push:

+		fprintf (f, "bool_push\t%d", a->literal != 0.0f);

+		break;

+	case slang_asm_bool_deref:

+		fprintf (f, "bool_deref");

+		break;

+	case slang_asm_addr_copy:

+		fprintf (f, "addr_copy");

+		break;

+	case slang_asm_addr_push:

+		fprintf (f, "addr_push\t%u", a->param[0]);

+		break;

+	case slang_asm_addr_deref:

+		fprintf (f, "addr_deref");

+		break;

+	case slang_asm_addr_add:

+		fprintf (f, "address_add");

+		break;

+	case slang_asm_addr_multiply:

+		fprintf (f, "address_multiply");

+		break;

+	case slang_asm_jump:

+		fprintf (f, "jump\t%u", a->param[0]);

+		break;

+	case slang_asm_jump_if_zero:

+		fprintf (f, "jump_if_zero\t%u", a->param[0]);

+		break;

+	case slang_asm_enter:

+		fprintf (f, "enter\t%u", a->param[0]);

+		break;

+	case slang_asm_leave:

+		fprintf (f, "leave");

+		break;

+	case slang_asm_local_alloc:

+		fprintf (f, "local_alloc\t%u", a->param[0]);

+		break;

+	case slang_asm_local_free:

+		fprintf (f, "local_free\t%u", a->param[0]);

+		break;

+	case slang_asm_local_addr:

+		fprintf (f, "local_addr\t%u, %u", a->param[0], a->param[1]);

+		break;

+	case slang_asm_call:

+		fprintf (f, "call\t%u", a->param[0]);

+		break;

+	case slang_asm_return:

+		fprintf (f, "return");

+		break;

+	case slang_asm_discard:

+		fprintf (f, "discard");

+		break;

+	case slang_asm_exit:

+		fprintf (f, "exit");

+		break;

+	}

+

+	fprintf (f, "\n");

+}

+

+static void dump (const slang_assembly_file *file)

+{

+	unsigned int i;

+	static unsigned int counter = 0;

+	FILE *f;

+	char filename[256];

+

+	counter++;

+	sprintf (filename, "~mesa-slang-assembly-dump-(%u).txt", counter);

+	f = fopen (filename, "w");

+	if (f == NULL)

+		return;

+

+	for (i = 0; i < file->count; i++)

+		dump_instruction (f, file->code + i, i);

+

+	fclose (f);

+}

+

+int _slang_execute (const slang_assembly_file *file)

+{

+	slang_machine mach;

+FILE *f;

+

+	mach.ip = 0;

+	mach.sp = SLANG_MACHINE_STACK_SIZE;

+	mach.bp = 0;

+	mach.kill = 0;

+	mach.exit = 0;

+

+	/* assume 32-bit machine */

+	static_assert(sizeof (GLfloat) == 4);

+	static_assert(sizeof (GLfloat *) == 4);

+	static_assert(sizeof (GLuint) == 4);

+	static_assert(sizeof (GLuint *) == 4);

+

+dump (file);

+

+f = fopen ("~mesa-slang-assembly-execution.txt", "w");

+

+	while (!mach.exit)

+	{

+		slang_assembly *a = file->code + mach.ip;

+if (f != NULL)

+{

+unsigned int i;

+dump_instruction (f, a, mach.ip);

+fprintf (f, "\t\tsp=%u bp=%u\n", mach.sp, mach.bp);

+for (i = mach.sp; i < SLANG_MACHINE_STACK_SIZE; i++)

+fprintf (f, "\t%.5u\t%6f\t%u\n", i, mach.stack._float[i], mach.stack._addr[i]);

+fflush (f);

+}

+		mach.ip++;

+

+		switch (a->type)

+		{

+		case slang_asm_none:

+			break;

+		case slang_asm_float_copy:

+		case slang_asm_int_copy:

+		case slang_asm_bool_copy:

+			*(mach.stack._floatp[mach.sp + a->param[0] / 4] + a->param[1] / 4) =

+				mach.stack._float[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_float_move:

+		case slang_asm_int_move:

+		case slang_asm_bool_move:

+			mach.stack._float[mach.sp + a->param[0] / 4] =

+				mach.stack._float[mach.sp + (mach.stack._addr[mach.sp] + a->param[1]) / 4];

+			break;

+		case slang_asm_float_push:

+		case slang_asm_int_push:

+		case slang_asm_bool_push:

+			mach.sp--;

+			mach.stack._float[mach.sp] = a->literal;

+			break;

+		case slang_asm_float_deref:

+		case slang_asm_int_deref:

+		case slang_asm_bool_deref:

+			mach.stack._float[mach.sp] = *mach.stack._floatp[mach.sp];

+			break;

+		case slang_asm_float_add:

+			mach.stack._float[mach.sp + 1] += mach.stack._float[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_float_multiply:

+			mach.stack._float[mach.sp + 1] *= mach.stack._float[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_float_divide:

+			mach.stack._float[mach.sp + 1] /= mach.stack._float[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_float_negate:

+			mach.stack._float[mach.sp] = -mach.stack._float[mach.sp];

+			break;

+		case slang_asm_float_less:

+			mach.stack._float[mach.sp + 1] =

+				mach.stack._float[mach.sp + 1] < mach.stack._float[mach.sp] ? 1.0f : 0.0f;

+			mach.sp++;

+			break;

+		case slang_asm_float_equal:

+			mach.sp--;

+			mach.stack._float[mach.sp] = mach.stack._float[mach.sp + 1 + a->param[0] / 4] ==

+				mach.stack._float[mach.sp + 1 + a->param[1] / 4] ? 1.0f : 0.0f;

+			break;

+		case slang_asm_float_to_int:

+			mach.stack._float[mach.sp] = (GLfloat) (GLint) mach.stack._float[mach.sp];

+			break;

+		case slang_asm_int_to_float:

+			break;

+		case slang_asm_int_to_addr:

+			mach.stack._addr[mach.sp] = (GLuint) (GLint) mach.stack._float[mach.sp];

+			break;

+		case slang_asm_addr_copy:

+			*mach.stack._addrp[mach.sp + 1] = mach.stack._addr[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_addr_push:

+			mach.sp--;

+			mach.stack._addr[mach.sp] = a->param[0];

+			break;

+		case slang_asm_addr_deref:

+			mach.stack._addr[mach.sp] = *mach.stack._addrp[mach.sp];

+			break;

+		case slang_asm_addr_add:

+			mach.stack._addr[mach.sp + 1] += mach.stack._addr[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_addr_multiply:

+			mach.stack._addr[mach.sp + 1] *= mach.stack._addr[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_jump:

+			mach.ip = a->param[0];

+			break;

+		case slang_asm_jump_if_zero:

+			if (mach.stack._float[mach.sp] == 0.0f)

+				mach.ip = a->param[0];

+			mach.sp++;

+			break;

+		case slang_asm_enter:

+			mach.sp--;

+			mach.stack._addr[mach.sp] = mach.bp;

+			mach.bp = mach.sp + a->param[0] / 4 + 1;

+			break;

+		case slang_asm_leave:

+			mach.bp = mach.stack._addr[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_local_alloc:

+			mach.sp -= a->param[0] / 4;

+			break;

+		case slang_asm_local_free:

+			mach.sp += a->param[0] / 4;

+			break;

+		case slang_asm_local_addr:

+			mach.sp--;

+			mach.stack._addr[mach.sp] = (GLuint) mach.stack._addr + mach.bp * 4 -

+				(a->param[0] + a->param[1]);

+			break;

+		case slang_asm_call:

+			mach.sp--;

+			mach.stack._addr[mach.sp] = mach.ip;

+			mach.ip = a->param[0];

+			break;

+		case slang_asm_return:

+			mach.ip = mach.stack._addr[mach.sp];

+			mach.sp++;

+			break;

+		case slang_asm_discard:

+			mach.kill = 1;

+			break;

+		case slang_asm_exit:

+			mach.exit = 1;

+			break;

+		}

+	}

+

+if (f != NULL)

+fclose (f);

+

+	return 0;

+}

+

diff --git a/src/mesa/shader/slang/slang_execute.h b/src/mesa/shader/slang/slang_execute.h
new file mode 100644
index 00000000000..119fd5135cb
--- /dev/null
+++ b/src/mesa/shader/slang/slang_execute.h
@@ -0,0 +1,57 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_EXECUTE_H

+#define SLANG_EXECUTE_H

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+#define SLANG_MACHINE_STACK_SIZE 64

+

+typedef struct slang_machine_

+{

+	GLuint ip;					/* instruction pointer, for flow control */

+	GLuint sp;					/* stack pointer, for stack access */

+	GLuint bp;					/* base pointer, for local variable access */

+	GLuint kill;				/* discard the fragment */

+	GLuint exit;				/* terminate the shader */

+	union stack_

+	{

+		GLfloat _float[SLANG_MACHINE_STACK_SIZE];

+		GLfloat *_floatp[SLANG_MACHINE_STACK_SIZE];

+		GLuint _addr[SLANG_MACHINE_STACK_SIZE];

+		GLuint *_addrp[SLANG_MACHINE_STACK_SIZE];

+	} stack;

+} slang_machine;

+

+int _slang_execute (const slang_assembly_file *);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_storage.c b/src/mesa/shader/slang/slang_storage.c
new file mode 100644
index 00000000000..84af8d575c8
--- /dev/null
+++ b/src/mesa/shader/slang/slang_storage.c
@@ -0,0 +1,255 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file slang_storage.c

+ * slang variable storage

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_storage.h"

+#include "slang_assemble.h"

+

+/* slang_storage_array */

+

+void slang_storage_array_construct (slang_storage_array *arr)

+{

+	arr->type = slang_stor_aggregate;

+	arr->aggregate = NULL;

+	arr->length = 0;

+}

+

+void slang_storage_array_destruct (slang_storage_array *arr)

+{

+	if (arr->aggregate != NULL)

+	{

+		slang_storage_aggregate_destruct (arr->aggregate);

+		slang_alloc_free (arr->aggregate);

+	}

+}

+

+/* slang_storage_aggregate */

+

+void slang_storage_aggregate_construct (slang_storage_aggregate *agg)

+{

+	agg->arrays = NULL;

+	agg->count = 0;

+}

+

+void slang_storage_aggregate_destruct (slang_storage_aggregate *agg)

+{

+	unsigned int i;

+	for (i = 0; i < agg->count; i++)

+		slang_storage_array_destruct (agg->arrays + i);

+	slang_alloc_free (agg->arrays);

+}

+

+static slang_storage_array *slang_storage_aggregate_push_new (slang_storage_aggregate *agg)

+{

+	slang_storage_array *arr = NULL;

+	agg->arrays = (slang_storage_array *) slang_alloc_realloc (agg->arrays, agg->count * sizeof (

+		slang_storage_array), (agg->count + 1) * sizeof (slang_storage_array));

+	if (agg->arrays != NULL)

+	{

+		arr = agg->arrays + agg->count;

+		slang_storage_array_construct (arr);

+		agg->count++;

+	}

+	return arr;

+}

+

+/* _slang_aggregate_variable() */

+

+static int aggregate_vector (slang_storage_aggregate *agg, slang_storage_type basic_type,

+	unsigned int row_count)

+{

+	slang_storage_array *arr = slang_storage_aggregate_push_new (agg);

+	if (arr == NULL)

+		return 0;

+	arr->type = basic_type;

+	arr->length = row_count;

+	return 1;

+}

+

+static int aggregate_matrix (slang_storage_aggregate *agg, slang_storage_type basic_type,

+	unsigned int order)

+{

+	slang_storage_array *arr = slang_storage_aggregate_push_new (agg);

+	if (arr == NULL)

+		return 0;

+	arr->type = slang_stor_aggregate;

+	arr->length = order;

+	arr->aggregate = (slang_storage_aggregate *) slang_alloc_malloc (sizeof (

+		slang_storage_aggregate));

+	if (arr->aggregate == NULL)

+		return 0;

+	slang_storage_aggregate_construct (arr->aggregate);

+	if (!aggregate_vector (arr->aggregate, basic_type, order))

+		return 0;

+	return 1;

+}

+

+static int aggregate_variables (slang_storage_aggregate *agg, const slang_variable_scope *vars,

+	slang_function_scope *funcs, slang_struct_scope *structs)

+{

+	unsigned int i;

+	for (i = 0; i < vars->num_variables; i++)

+		if (!_slang_aggregate_variable (agg, &vars->variables[i].type.specifier,

+			vars->variables[i].array_size, funcs, structs))

+			return 0;

+	return 1;

+}

+

+int _slang_aggregate_variable (slang_storage_aggregate *agg, slang_type_specifier *spec,

+	slang_operation *array_size, slang_function_scope *funcs, slang_struct_scope *structs)

+{

+	switch (spec->type)

+	{

+	case slang_spec_bool:

+		return aggregate_vector (agg, slang_stor_bool, 1);

+	case slang_spec_bvec2:

+		return aggregate_vector (agg, slang_stor_bool, 2);

+	case slang_spec_bvec3:

+		return aggregate_vector (agg, slang_stor_bool, 3);

+	case slang_spec_bvec4:

+		return aggregate_vector (agg, slang_stor_bool, 4);

+	case slang_spec_int:

+		return aggregate_vector (agg, slang_stor_int, 1);

+	case slang_spec_ivec2:

+		return aggregate_vector (agg, slang_stor_int, 2);

+	case slang_spec_ivec3:

+		return aggregate_vector (agg, slang_stor_int, 3);

+	case slang_spec_ivec4:

+		return aggregate_vector (agg, slang_stor_int, 4);

+	case slang_spec_float:

+		return aggregate_vector (agg, slang_stor_float, 1);

+	case slang_spec_vec2:

+		return aggregate_vector (agg, slang_stor_float, 2);

+	case slang_spec_vec3:

+		return aggregate_vector (agg, slang_stor_float, 3);

+	case slang_spec_vec4:

+		return aggregate_vector (agg, slang_stor_float, 4);

+	case slang_spec_mat2:

+		return aggregate_matrix (agg, slang_stor_float, 2);

+	case slang_spec_mat3:

+		return aggregate_matrix (agg, slang_stor_float, 3);

+	case slang_spec_mat4:

+		return aggregate_matrix (agg, slang_stor_float, 4);

+	case slang_spec_sampler1D:

+	case slang_spec_sampler2D:

+	case slang_spec_sampler3D:

+	case slang_spec_samplerCube:

+	case slang_spec_sampler1DShadow:

+	case slang_spec_sampler2DShadow:

+		return aggregate_vector (agg, slang_stor_int, 1);

+	case slang_spec_struct:

+		return aggregate_variables (agg, spec->_struct->fields, funcs, structs);

+	case slang_spec_array:

+		{

+			slang_storage_array *arr;

+			slang_assembly_file file;

+			slang_assembly_flow_control flow;

+			slang_assembly_name_space space;

+			slang_assembly_local_info info;

+			slang_assembly_stack_info stk;

+

+			arr = slang_storage_aggregate_push_new (agg);

+			if (arr == NULL)

+				return 0;

+			arr->type = slang_stor_aggregate;

+			arr->aggregate = (slang_storage_aggregate *) slang_alloc_malloc (sizeof (

+				slang_storage_aggregate));

+			if (arr->aggregate == NULL)

+				return 0;

+			slang_storage_aggregate_construct (arr->aggregate);

+			if (!_slang_aggregate_variable (arr->aggregate, spec->_array, NULL, funcs, structs))

+				return 0;

+			slang_assembly_file_construct (&file);

+			space.funcs = funcs;

+			space.structs = structs;

+			/* XXX: vars! */

+			space.vars = NULL;

+			if (!_slang_assemble_operation (&file, array_size, 0, &flow, &space, &info, &stk))

+			{

+				slang_assembly_file_destruct (&file);

+				return 0;

+			}

+			/* TODO: evaluate array size */

+			slang_assembly_file_destruct (&file);

+			arr->length = 256;

+		}

+		return 1;

+	default:

+		return 0;

+	}

+}

+

+/* _slang_sizeof_aggregate() */

+

+unsigned int _slang_sizeof_aggregate (const slang_storage_aggregate *agg)

+{

+	unsigned int i, size = 0;

+	for (i = 0; i < agg->count; i++)

+	{

+		unsigned int element_size;

+		if (agg->arrays[i].type == slang_stor_aggregate)

+			element_size = _slang_sizeof_aggregate (agg->arrays[i].aggregate);

+		else

+			element_size = sizeof (GLfloat);

+		size += element_size * agg->arrays[i].length;

+	}

+	return size;

+}

+

+/* _slang_flatten_aggregate () */

+

+int _slang_flatten_aggregate (slang_storage_aggregate *flat, const slang_storage_aggregate *agg)

+{

+	unsigned int i;

+	for (i = 0; i < agg->count; i++)

+	{

+		unsigned int j;

+		for (j = 0; j < agg->arrays[i].length; j++)

+		{

+			if (agg->arrays[i].type == slang_stor_aggregate)

+			{

+				if (!_slang_flatten_aggregate (flat, agg->arrays[i].aggregate))

+					return 0;

+			}

+			else

+			{

+				slang_storage_array *arr;

+				arr = slang_storage_aggregate_push_new (flat);

+				if (arr == NULL)

+					return 0;

+				arr->type = agg->arrays[i].type;

+				arr->length = 1;

+			}

+		}

+	}

+	return 1;

+}

+

diff --git a/src/mesa/shader/slang/slang_storage.h b/src/mesa/shader/slang/slang_storage.h
new file mode 100644
index 00000000000..c1b123f2a0a
--- /dev/null
+++ b/src/mesa/shader/slang/slang_storage.h
@@ -0,0 +1,109 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.3

+ *

+ * Copyright (C) 2005  Brian Paul   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 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

+ * BRIAN PAUL 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.

+ */

+

+#if !defined SLANG_STORAGE_H

+#define SLANG_STORAGE_H

+

+#include "slang_compile.h"

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+/*

+	Program variable data storage is kept completely transparent to the front-end compiler. It is

+	up to the back-end how the data is actually allocated. The slang_storage_type enum

+	provides the basic information about how the memory is interpreted. This abstract piece

+	of memory is called a data slot. A data slot of a particular type has a fixed size.

+

+	For now, only the three basic types are supported, that is bool, int and float. Other built-in

+	types like vector or matrix can easily be decomposed into a series of basic types.

+*/

+typedef enum slang_storage_type_

+{

+	slang_stor_aggregate,

+	slang_stor_bool,

+	slang_stor_int,

+	slang_stor_float

+} slang_storage_type;

+

+/*

+	The slang_storage_array structure groups data slots of the same type into an array. This

+	array has a fixed length. Arrays are required to have a size equal to the sum of sizes of its

+	elements. They are also required to support indirect addressing. That is, if B references

+	first data slot in the array, S is the size of the data slot and I is the integral index that

+	is not known at compile time, B+I*S references I-th data slot.

+

+	This structure is also used to break down built-in data types that are not supported directly.

+	Vectors, like vec3, are constructed from arrays of their basic types. Matrices are formed of

+	an array of column vectors, which are in turn processed as other vectors.

+*/

+typedef struct slang_storage_array_

+{

+	slang_storage_type type;

+	struct slang_storage_aggregate_ *aggregate;	/* slang_stor_aggregate */

+	unsigned int length;

+} slang_storage_array;

+

+void slang_storage_array_construct (slang_storage_array *);

+void slang_storage_array_destruct (slang_storage_array *);

+

+/*

+	The slang_storage_aggregate structure relaxes the indirect addressing requirement for

+	slang_storage_array structure. Aggregates are always accessed statically - its member

+	addresses are well-known at compile time. For example, user-defined types are implemented as

+	aggregates. Aggregates can collect data of a different type.

+*/

+typedef struct slang_storage_aggregate_

+{

+	slang_storage_array *arrays;

+	unsigned int count;

+} slang_storage_aggregate;

+

+void slang_storage_aggregate_construct (slang_storage_aggregate *);

+void slang_storage_aggregate_destruct (slang_storage_aggregate *);

+

+int _slang_aggregate_variable (slang_storage_aggregate *, struct slang_type_specifier_ *,

+	struct slang_operation_ *, struct slang_function_scope_ *, slang_struct_scope *);

+

+/*

+	returns total size (in machine units) of the given aggregate

+	returns 0 on error

+*/

+unsigned int _slang_sizeof_aggregate (const slang_storage_aggregate *);

+

+/*

+	converts structured aggregate to a flat one, with arrays of generic type being

+	one-element long

+	returns 1 on success

+	returns 0 otherwise

+*/

+int _slang_flatten_aggregate (slang_storage_aggregate *, const slang_storage_aggregate *);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/sources b/src/mesa/sources
index c3165594bc6..ab0ae480889 100644
--- a/src/mesa/sources
+++ b/src/mesa/sources
@@ -187,8 +187,14 @@ SLANG_CPP_SOURCES = \
 	shader/slang/OSDependent/Linux/ossource.cpp
 	
 SLANG_SOURCES =	\
+	shader/slang/slang_assemble.c	\
+	shader/slang/slang_assemble_conditional.c	\
+	shader/slang/slang_assemble_constructor.c	\
+	shader/slang/slang_assemble_typeinfo.c	\
 	shader/slang/slang_compile.c	\
+	shader/slang/slang_execute.c	\
 	shader/slang/slang_preprocess.c	\
+	shader/slang/slang_storage.c	\
 	shader/slang/slang_utility.c
 
 ASM_C_SOURCES =	\