Split slang_compile.c into several smaller files - it was just too big.

Minor fixes and cosmetic changes.

16 files changed, 1639 insertions, 1066 deletions

diff --git a/src/mesa/shader/slang/slang_assemble.c b/src/mesa/shader/slang/slang_assemble.c
index 6f928d7378..a97da6b283 100644
--- a/src/mesa/shader/slang/slang_assemble.c
+++ b/src/mesa/shader/slang/slang_assemble.c
@@ -1,8 +1,8 @@
 /*

  * Mesa 3-D graphics library

- * Version:  6.3

+ * Version:  6.5

  *

- * Copyright (C) 2005  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2005-2006  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"),

@@ -124,7 +124,7 @@ static int sizeof_variable (slang_type_specifier *spec, slang_type_qualifier qua
 	slang_storage_aggregate agg;

 

 	slang_storage_aggregate_construct (&agg);

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

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

 	{

 		slang_storage_aggregate_destruct (&agg);

 		return 0;

@@ -404,7 +404,7 @@ int dereference (slang_assembly_file *file, slang_operation *op,
 	}

 

 	slang_storage_aggregate_construct (&agg);

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

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

 	{

 		slang_storage_aggregate_destruct (&agg);

 		slang_assembly_typeinfo_destruct (&ti);

@@ -518,7 +518,7 @@ static int call_function_name_dummyint (slang_assembly_file *file, const char *n
 	int result;

 

 	p2[0] = *params;

-	if (!slang_operation_construct_a (p2 + 1))

+	if (!slang_operation_construct (p2 + 1))

 		return 0;

 	p2[1].type = slang_oper_literal_int;

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

@@ -618,7 +618,8 @@ static int equality (slang_assembly_file *file, slang_operation *op,
 

 	/* convert it to an aggregate */

 	slang_storage_aggregate_construct (&agg);

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

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

+			space->vars)))

 		goto end;

 

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

diff --git a/src/mesa/shader/slang/slang_assemble_assignment.c b/src/mesa/shader/slang/slang_assemble_assignment.c
index 551f5d9b11..d8821f03bb 100644
--- a/src/mesa/shader/slang/slang_assemble_assignment.c
+++ b/src/mesa/shader/slang/slang_assemble_assignment.c
@@ -1,8 +1,8 @@
 /*

  * Mesa 3-D graphics library

- * Version:  6.3

+ * Version:  6.5

  *

- * Copyright (C) 2005  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2005-2006  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"),

@@ -115,7 +115,7 @@ int _slang_assemble_assignment (slang_assembly_file *file, slang_operation *op,
 	}

 

 	slang_storage_aggregate_construct (&agg);

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

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

 	{

 		slang_storage_aggregate_destruct (&agg);

 		slang_assembly_typeinfo_destruct (&ti);

diff --git a/src/mesa/shader/slang/slang_assemble_constructor.c b/src/mesa/shader/slang/slang_assemble_constructor.c
index 76a30f6b6c..e62f88b591 100644
--- a/src/mesa/shader/slang/slang_assemble_constructor.c
+++ b/src/mesa/shader/slang/slang_assemble_constructor.c
@@ -1,8 +1,8 @@
 /*

  * Mesa 3-D graphics library

- * Version:  6.3

+ * Version:  6.5

  *

- * Copyright (C) 2005  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2005-2006  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"),

@@ -158,7 +158,8 @@ static int constructor_aggregate (slang_assembly_file *file, const slang_storage
 		goto end1;

 

 	slang_storage_aggregate_construct (&agg);

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

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

+			space->vars)))

 		goto end2;

 

 	slang_storage_aggregate_construct (&flat_agg);

@@ -205,7 +206,8 @@ int _slang_assemble_constructor (slang_assembly_file *file, slang_operation *op,
 		goto end1;

 

 	slang_storage_aggregate_construct (&agg);

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

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

+			space->vars)))

 		goto end2;

 

 	size = _slang_sizeof_aggregate (&agg);

diff --git a/src/mesa/shader/slang/slang_assemble_typeinfo.c b/src/mesa/shader/slang/slang_assemble_typeinfo.c
index ce78f66ebe..f550556763 100644
--- a/src/mesa/shader/slang/slang_assemble_typeinfo.c
+++ b/src/mesa/shader/slang/slang_assemble_typeinfo.c
@@ -1,8 +1,8 @@
 /*

  * Mesa 3-D graphics library

- * Version:  6.3

+ * Version:  6.5

  *

- * Copyright (C) 2005  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2005-2006  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"),

@@ -257,7 +257,7 @@ int _slang_typeof_operation (slang_operation *op, slang_assembly_name_space *spa
 					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))

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

 					{

 						slang_alloc_free (ti->spec._struct);

 						ti->spec._struct = NULL;

diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c
index 3418f6fae2..ce5653c6c5 100644
--- a/src/mesa/shader/slang/slang_compile.c
+++ b/src/mesa/shader/slang/slang_compile.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.3
+ * Version:  6.5
  *
- * Copyright (C) 2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2005-2006  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"),
@@ -42,549 +42,56 @@
 	Lots of error-checking functionality is missing but every well-formed shader source should
 	compile successfully and execute as expected. However, some semantically ill-formed shaders
 	may be accepted resulting in undefined behaviour.
-*/
-
-static void slang_variable_construct (slang_variable *);
-static int slang_variable_copy (slang_variable *, const slang_variable *);
-static void slang_struct_destruct (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 */
-
-void slang_type_specifier_construct (slang_type_specifier *spec)
-{
-	spec->type = slang_spec_void;
-	spec->_struct = NULL;
-	spec->_array = NULL;
-}
-
-void slang_type_specifier_destruct (slang_type_specifier *spec)
-{
-	if (spec->_struct != NULL)
-	{
-		slang_struct_destruct (spec->_struct);
-		slang_alloc_free (spec->_struct);
-	}
-	if (spec->_array != NULL)
-	{
-		slang_type_specifier_destruct (spec->_array);
-		slang_alloc_free (spec->_array);
-	}
-}
-
-int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)
-{
-	slang_type_specifier_destruct (x);
-	slang_type_specifier_construct (x);
-	x->type = y->type;
-	if (x->type == slang_spec_struct)
-	{
-		x->_struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_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;
-}
-
-int slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)
-{
-	if (x->type != y->type)
-		return 0;
-	if (x->type == slang_spec_struct)
-		return slang_struct_equal (x->_struct, y->_struct);
-	if (x->type == slang_spec_array)
-		return slang_type_specifier_equal (x->_array, y->_array);
-	return 1;
-}
-
-/* slang_fully_specified_type */
-
-static void slang_fully_specified_type_construct (slang_fully_specified_type *type)
-{
-	type->qualifier = slang_qual_none;
-	slang_type_specifier_construct (&type->specifier);
-}
-
-static void slang_fully_specified_type_destruct (slang_fully_specified_type *type)
-{
-	slang_type_specifier_destruct (&type->specifier);
-}
-
-static int slang_fully_specified_type_copy (slang_fully_specified_type *x,
-	const slang_fully_specified_type *y)
-{
-	slang_fully_specified_type_construct (x);
-	slang_fully_specified_type_destruct (x);
-	x->qualifier = y->qualifier;
-	return slang_type_specifier_copy (&x->specifier, &y->specifier);
-}
-
-/* slang_variable_scope */
-
-static void slang_variable_scope_construct (slang_variable_scope *scope)
-{
-	scope->variables = NULL;
-	scope->num_variables = 0;
-	scope->outer_scope = NULL;
-}
-
-static void slang_variable_scope_destruct (slang_variable_scope *scope)
-{
-	unsigned int i;
-	for (i = 0; i < scope->num_variables; i++)
-		slang_variable_destruct (scope->variables + i);
-	slang_alloc_free (scope->variables);
-}
-
-static int slang_variable_scope_copy (slang_variable_scope *x, const slang_variable_scope *y)
-{
-	unsigned int i;
-	slang_variable_scope_destruct (x);
-	slang_variable_scope_construct (x);
-	x->variables = (slang_variable *) slang_alloc_malloc (y->num_variables * sizeof (
-		slang_variable));
-	if (x->variables == NULL)
-		return 0;
-	x->num_variables = y->num_variables;
-	for (i = 0; i < x->num_variables; i++)
-		slang_variable_construct (x->variables + i);
-	for (i = 0; i < x->num_variables; i++)
-		if (!slang_variable_copy (x->variables + i, y->variables + i))
-			return 0;
-	x->outer_scope = y->outer_scope;
-	return 1;
-}
-
-/* slang_operation */
-
-int slang_operation_construct_a (slang_operation *oper)
-{
-	oper->type = slang_oper_none;
-	oper->children = NULL;
-	oper->num_children = 0;
-	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;
-}
-
-void slang_operation_destruct (slang_operation *oper)
-{
-	unsigned int i;
-	for (i = 0; i < oper->num_children; i++)
-		slang_operation_destruct (oper->children + i);
-	slang_alloc_free (oper->children);
-	slang_alloc_free (oper->identifier);
-	slang_variable_scope_destruct (oper->locals);
-	slang_alloc_free (oper->locals);
-}
-
-static int slang_operation_copy (slang_operation *x, const slang_operation *y)
-{
-	unsigned int i;
-	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++)
-		if (!slang_operation_copy (x->children + i, y->children + i))
-			return 0;
-	x->literal = y->literal;
-	if (y->identifier != NULL)
-	{
-		x->identifier = slang_string_duplicate (y->identifier);
-		if (x->identifier == NULL)
-			return 0;
-	}
-	if (!slang_variable_scope_copy (x->locals, y->locals))
-		return 0;
-	return 1;
-}
-
-/* slang_variable */
-
-static void slang_variable_construct (slang_variable *var)
-{
-	slang_fully_specified_type_construct (&var->type);
-	var->name = NULL;
-	var->array_size = NULL;
-	var->initializer = NULL;
-	var->address = ~0;
-}
-
-static void slang_variable_destruct (slang_variable *var)
-{
-	slang_fully_specified_type_destruct (&var->type);
-	slang_alloc_free (var->name);
-	if (var->array_size != NULL)
-	{
-		slang_operation_destruct (var->array_size);
-		slang_alloc_free (var->array_size);
-	}
-	if (var->initializer != NULL)
-	{
-		slang_operation_destruct (var->initializer);
-		slang_alloc_free (var->initializer);
-	}
-}
-
-static int slang_variable_copy (slang_variable *x, const slang_variable *y)
-{
-	slang_variable_destruct (x);
-	slang_variable_construct (x);
-	if (!slang_fully_specified_type_copy (&x->type, &y->type))
-		return 0;
-	if (y->name != NULL)
-	{
-		x->name = slang_string_duplicate (y->name);
-		if (x->name == NULL)
-			return 0;
-	}
-	if (y->array_size != NULL)
-	{
-		x->array_size = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
-		if (x->array_size == NULL)
-			return 0;
-		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;
-	}
-	if (y->initializer != NULL)
-	{
-		x->initializer = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
-		if (x->initializer == NULL)
-			return 0;
-		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)
-{
-	scope->structs = NULL;
-	scope->num_structs = 0;
-	scope->outer_scope = NULL;
-}
-
-static void slang_struct_scope_destruct (slang_struct_scope *scope)
-{
-	unsigned int i;
-	for (i = 0; i < scope->num_structs; i++)
-		slang_struct_destruct (scope->structs + i);
-	slang_alloc_free (scope->structs);
-}
-
-static int slang_struct_scope_copy (slang_struct_scope *x, const slang_struct_scope *y)
-{
-	unsigned int i;
-	slang_struct_scope_destruct (x);
-	slang_struct_scope_construct (x);
-	x->structs = (slang_struct *) slang_alloc_malloc (y->num_structs * sizeof (slang_struct));
-	if (x->structs == NULL)
-		return 0;
-	x->num_structs = y->num_structs;
-	for (i = 0; i < x->num_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;
-	x->outer_scope = y->outer_scope;
-	return 1;
-}
-
-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++)
-		if (slang_string_compare (name, stru->structs[i].name) == 0)
-			return stru->structs + i;
-	if (all_scopes && stru->outer_scope != NULL)
-		return slang_struct_scope_find (stru->outer_scope, name, 1);
-	return NULL;
-}
-
-/* slang_struct */
-
-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)
-{
-	slang_alloc_free (stru->name);
-	slang_variable_scope_destruct (stru->fields);
-	slang_alloc_free (stru->fields);
-	slang_struct_scope_destruct (stru->structs);
-	slang_alloc_free (stru->structs);
+*/

+

+/* slang_var_pool */

+

+static GLuint slang_var_pool_alloc (slang_var_pool *pool, unsigned int size)

+{

+	GLuint addr;

+

+	addr = pool->next_addr;

+	pool->next_addr += size;

+	return addr;

 }
 
-int slang_struct_copy (slang_struct *x, const slang_struct *y)
-{
-	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);
-		if (x->name == NULL)
-			return 0;
-	}
-	if (!slang_variable_scope_copy (x->fields, y->fields))
-		return 0;
-	if (!slang_struct_scope_copy (x->structs, y->structs))
-		return 0;
-	return 1;
-}
+/* slang_translation_unit */
 
-static int slang_struct_equal (const slang_struct *x, const slang_struct *y)
+int slang_translation_unit_construct (slang_translation_unit *unit)
 {
-	unsigned int i;
-	if (x->fields->num_variables != y->fields->num_variables)
-		return 0;
-	for (i = 0; i < x->fields->num_variables; i++)
-	{
-		slang_variable *varx = x->fields->variables + i;
-		slang_variable *vary = y->fields->variables + i;
-		if (slang_string_compare (varx->name, vary->name) != 0)
-			return 0;
-		if (!slang_type_specifier_equal (&varx->type.specifier, &vary->type.specifier))
-			return 0;
-		if (varx->type.specifier.type == slang_spec_array)
-		{
-			/* TODO compare array sizes */
-		}
+	if (!slang_variable_scope_construct (&unit->globals))

+		return 0;

+	if (!slang_function_scope_construct (&unit->functions))

+	{

+		slang_variable_scope_destruct (&unit->globals);

+		return 0;

 	}
+	if (!slang_struct_scope_construct (&unit->structs))

+	{

+		slang_variable_scope_destruct (&unit->globals);

+		slang_function_scope_destruct (&unit->functions);

+		return 0;

+	}

+	unit->assembly = (slang_assembly_file *) slang_alloc_malloc (sizeof (slang_assembly_file));

+	if (unit->assembly == NULL)

+	{

+		slang_variable_scope_destruct (&unit->globals);

+		slang_function_scope_destruct (&unit->functions);

+		slang_struct_scope_destruct (&unit->structs);

+		return 0;

+	}

+	slang_assembly_file_construct (unit->assembly);

+	unit->global_pool.next_addr = 0;

 	return 1;
 }
 
-/* slang_function */
-/* XXX mem! */
-static void slang_function_construct (slang_function *func)
-{
-	func->kind = slang_func_ordinary;
-	slang_variable_construct (&func->header);
-	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)
-{
-	slang_variable_destruct (&func->header);
-	slang_variable_scope_destruct (func->parameters);
-	slang_alloc_free (func->parameters);
-	if (func->body != NULL)
-	{
-		slang_operation_destruct (func->body);
-		slang_alloc_free (func->body);
-	}
-}
-
-/* slang_function_scope */
-
-static void slang_function_scope_construct (slang_function_scope *scope)
-{
-	scope->functions = NULL;
-	scope->num_functions = 0;
-	scope->outer_scope = NULL;
-}
-
-static void slang_function_scope_destruct (slang_function_scope *scope)
-{
-	unsigned int i;
-	for (i = 0; i < scope->num_functions; i++)
-		slang_function_destruct (scope->functions + i);
-	slang_alloc_free (scope->functions);
-}
-
-static int slang_function_scope_find_by_name (slang_function_scope *funcs, const char *name,
-	int all_scopes)
-{
-	unsigned int i;
-	for (i = 0; i < funcs->num_functions; i++)
-		if (slang_string_compare (name, funcs->functions[i].header.name) == 0)
-			return 1;
-	if (all_scopes && funcs->outer_scope != NULL)
-		return slang_function_scope_find_by_name (funcs->outer_scope, name, 1);
-	return 0;
-}
-
-static slang_function *slang_function_scope_find (slang_function_scope *funcs, slang_function *fun,
-	int all_scopes)
-{
-	unsigned int i;
-	for (i = 0; i < funcs->num_functions; i++)
-	{
-		slang_function *f = funcs->functions + i;
-		unsigned int j;
-		if (slang_string_compare (fun->header.name, f->header.name) != 0)
-			continue;
-		if (fun->param_count != f->param_count)
-			continue;
-		for (j = 0; j < fun->param_count; j++)
-		{
-			if (!slang_type_specifier_equal (&fun->parameters->variables[j].type.specifier,
-				&f->parameters->variables[j].type.specifier))
-			{
-				break;
-			}
-		}
-		if (j == fun->param_count)
-			return f;
-	}
-	if (all_scopes && funcs->outer_scope != NULL)
-		return slang_function_scope_find (funcs->outer_scope, fun, 1);
-	return NULL;
-}
-
-/* slang_translation_unit */
-
-void slang_translation_unit_construct (slang_translation_unit *unit)
-{
-	slang_variable_scope_construct (&unit->globals);
-	slang_function_scope_construct (&unit->functions);
-	slang_struct_scope_construct (&unit->structs);
-}
-
 void slang_translation_unit_destruct (slang_translation_unit *unit)
 {
 	slang_variable_scope_destruct (&unit->globals);
 	slang_function_scope_destruct (&unit->functions);
-	slang_struct_scope_destruct (&unit->structs);
+	slang_struct_scope_destruct (&unit->structs);

+	slang_assembly_file_destruct (unit->assembly);

+	slang_alloc_free (unit->assembly);
 }
 
 /* slang_info_log */
@@ -605,20 +112,22 @@ void slang_info_log_destruct (slang_info_log *log)
 
 static int slang_info_log_message (slang_info_log *log, const char *prefix, const char *msg)
 {
-	unsigned int new_size;
+	unsigned int new_size;

+
 	if (log->dont_free_text)
 		return 0;
 	new_size = slang_string_length (prefix) + 3 + slang_string_length (msg);
 	if (log->text != NULL)
-	{
-		log->text = (char *) slang_alloc_realloc (log->text, slang_string_length (log->text) + 1,
-			new_size + slang_string_length (log->text) + 1);
+	{

+		unsigned int text_len = slang_string_length (log->text);

+
+		log->text = (char *) slang_alloc_realloc (log->text, text_len + 1, new_size + text_len + 1);
 	}
 	else
 	{
 		log->text = (char *) slang_alloc_malloc (new_size + 1);
 		if (log->text != NULL)
-			*log->text = '\0';
+			log->text[0] = '\0';
 	}
 	if (log->text == NULL)
 		return 0;
@@ -672,8 +181,20 @@ typedef struct slang_parse_ctx_
 {
 	const byte *I;
 	slang_info_log *L;
-	int parsing_builtin;
-} slang_parse_ctx;
+	int parsing_builtin;

+	int global_scope;
+} slang_parse_ctx;

+

+/* slang_output_ctx */

+

+typedef struct slang_output_ctx_

+{

+	slang_variable_scope *vars;

+	slang_function_scope *funs;

+	slang_struct_scope *structs;

+	slang_assembly_file *assembly;

+	slang_var_pool *global_pool;

+} slang_output_ctx;
 
 /* _slang_compile() */
 
@@ -775,10 +296,144 @@ static int check_revision (slang_parse_ctx *C)
 	return 1;
 }
 
-static int parse_statement (slang_parse_ctx *, slang_operation *, slang_variable_scope *,
-	slang_struct_scope *, slang_function_scope *);
-static int parse_expression (slang_parse_ctx *, slang_operation *, slang_variable_scope *,
-	slang_struct_scope *, slang_function_scope *);
+static int parse_statement (slang_parse_ctx *, slang_output_ctx *, slang_operation *);
+static int parse_expression (slang_parse_ctx *, slang_output_ctx *, slang_operation *);

+static int parse_type_specifier (slang_parse_ctx *, slang_output_ctx *, slang_type_specifier *);

+

+/* structure field */

+#define FIELD_NONE 0

+#define FIELD_NEXT 1

+#define FIELD_ARRAY 2

+

+static int parse_struct_field_var (slang_parse_ctx *C, slang_output_ctx *O, slang_variable *var)

+{

+	if (!parse_identifier (C, &var->name))

+		return 0;

+	switch (*C->I++)

+	{

+	case FIELD_NONE:

+		break;

+	case FIELD_ARRAY:

+		var->array_size = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));

+		if (var->array_size == NULL)

+		{

+			slang_info_log_memory (C->L);

+			return 0;

+		}

+		if (!slang_operation_construct (var->array_size))

+		{

+			slang_alloc_free (var->array_size);

+			var->array_size = NULL;

+			return 0;

+		}

+		if (!parse_expression (C, O, var->array_size))

+			return 0;

+		break;

+	default:

+		return 0;

+	}

+	return 1;

+}

+

+static int parse_struct_field (slang_parse_ctx *C, slang_output_ctx *O, slang_struct *st,

+	slang_type_specifier *sp)

+{

+	slang_output_ctx o = *O;

+

+	o.structs = st->structs;

+	if (!parse_type_specifier (C, &o, sp))

+		return 0;

+	do

+	{

+		slang_variable *var;

+

+		st->fields->variables = (slang_variable *) slang_alloc_realloc (st->fields->variables,

+			st->fields->num_variables * sizeof (slang_variable),

+			(st->fields->num_variables + 1) * sizeof (slang_variable));

+		if (st->fields->variables == NULL)

+		{

+			slang_info_log_memory (C->L);

+			return 0;

+		}

+		var = st->fields->variables + st->fields->num_variables;

+		if (!slang_variable_construct (var))

+			return 0;

+		st->fields->num_variables++;

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

+			return 0;

+		if (!parse_struct_field_var (C, &o, var))

+			return 0;

+	}

+	while (*C->I++ != FIELD_NONE);

+	return 1;

+}

+

+static int parse_struct (slang_parse_ctx *C, slang_output_ctx *O, slang_struct **st)

+{

+	char *name;

+

+	if (!parse_identifier (C, &name))

+		return 0;

+	if (name[0] != '\0' && slang_struct_scope_find (O->structs, name, 0) != NULL)

+	{

+		slang_info_log_error (C->L, "%s: duplicate type name", name);

+		slang_alloc_free (name);

+		return 0;

+	}

+	*st = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));

+	if (*st == NULL)

+	{

+		slang_alloc_free (name);

+		slang_info_log_memory (C->L);

+		return 0;

+	}

+	if (!slang_struct_construct (*st))

+	{

+		slang_alloc_free (*st);

+		*st = NULL;

+		slang_alloc_free (name);

+		slang_info_log_memory (C->L);

+		return 0;

+	}

+	(**st).name = name;

+	(**st).structs->outer_scope = O->structs;

+

+	do

+	{

+		slang_type_specifier sp;

+

+		if (!slang_type_specifier_construct (&sp))

+			return 0;

+		if (!parse_struct_field (C, O, *st, &sp))

+		{

+			slang_type_specifier_destruct (&sp);

+			return 0;

+		}

+	}

+	while (*C->I++ != FIELD_NONE);

+

+	if ((**st).name != '\0')

+	{

+		slang_struct *s;

+

+		O->structs->structs = (slang_struct *) slang_alloc_realloc (O->structs->structs,

+				O->structs->num_structs * sizeof (slang_struct),

+				(O->structs->num_structs + 1) * sizeof (slang_struct));

+		if (O->structs->structs == NULL)

+		{

+			slang_info_log_memory (C->L);

+			return 0;

+		}

+		s = &O->structs->structs[O->structs->num_structs];

+		if (!slang_struct_construct (s))

+			return 0;

+		O->structs->num_structs++;

+		if (!slang_struct_copy (s, *st))

+			return 0;

+	}

+

+	return 1;

+}
 
 /* type qualifier */
 #define TYPE_QUALIFIER_NONE 0
@@ -846,13 +501,7 @@ static int parse_type_qualifier (slang_parse_ctx *C, slang_type_qualifier *qual)
 #define TYPE_SPECIFIER_STRUCT 22
 #define TYPE_SPECIFIER_TYPENAME 23
 
-/* structure field */
-#define FIELD_NONE 0
-#define FIELD_NEXT 1
-#define FIELD_ARRAY 2
-
-static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
-	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
+static int parse_type_specifier (slang_parse_ctx *C, slang_output_ctx *O, slang_type_specifier *spec)
 {
 	switch (*C->I++)
 	{
@@ -923,122 +572,9 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 		spec->type = slang_spec_sampler2DShadow;
 		break;
 	case TYPE_SPECIFIER_STRUCT:
-		spec->type = slang_spec_struct;
-		{
-			char *name;
-			if (!parse_identifier (C, &name))
-				return 0;
-			if (*name != '\0' && slang_struct_scope_find (structs, name, 0) != NULL)
-			{
-				slang_info_log_error (C->L, "%s: duplicate type name", name);
-				slang_alloc_free (name);
-				return 0;
-			}
-			spec->_struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));
-			if (spec->_struct == NULL)
-			{
-				slang_alloc_free (name);
-				slang_info_log_memory (C->L);
-				return 0;
-			}
-			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;
-		}
-		do
-		{
-			slang_type_specifier sp;
-			slang_type_specifier_construct (&sp);
-			if (!parse_type_specifier (C, &sp, spec->_struct->structs, scope, funcs))
-			{
-				slang_type_specifier_destruct (&sp);
-				return 0;
-			}
-			do
-			{
-				slang_variable *var;
-				spec->_struct->fields->variables = (slang_variable *) slang_alloc_realloc (
-					spec->_struct->fields->variables,
-					spec->_struct->fields->num_variables * sizeof (slang_variable),
-					(spec->_struct->fields->num_variables + 1) * sizeof (slang_variable));
-				if (spec->_struct->fields->variables == NULL)
-				{
-					slang_type_specifier_destruct (&sp);
-					slang_info_log_memory (C->L);
-					return 0;
-				}
-				var = spec->_struct->fields->variables + spec->_struct->fields->num_variables;
-				spec->_struct->fields->num_variables++;
-				slang_variable_construct (var);
-				if (!slang_type_specifier_copy (&var->type.specifier, &sp))
-				{
-					slang_type_specifier_destruct (&sp);
-					return 0;
-				}
-				if (!parse_identifier (C, &var->name))
-				{
-					slang_type_specifier_destruct (&sp);
-					return 0;
-				}
-				switch (*C->I++)
-				{
-				case FIELD_NONE:
-					break;
-				case FIELD_ARRAY:
-					var->array_size = (slang_operation *) slang_alloc_malloc (sizeof (
-						slang_operation));
-					if (var->array_size == NULL)
-					{
-						slang_type_specifier_destruct (&sp);
-						slang_info_log_memory (C->L);
-						return 0;
-					}
-					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);
-						return 0;
-					}
-					break;
-				default:
-					return 0;
-				}
-			}
-			while (*C->I++ != FIELD_NONE);
-		}
-		while (*C->I++ != FIELD_NONE);
-		if (*spec->_struct->name != '\0')
-		{
-			slang_struct *s;
-			structs->structs = (slang_struct *) slang_alloc_realloc (structs->structs,
-				structs->num_structs * sizeof (slang_struct),
-				(structs->num_structs + 1) * sizeof (slang_struct));
-			if (structs->structs == NULL)
-			{
-				slang_info_log_memory (C->L);
-				return 0;
-			}
-			s = structs->structs + structs->num_structs;
-			if (!slang_struct_construct_a (s))
-				return 0;
-			structs->num_structs++;
-			if (!slang_struct_copy (s, spec->_struct))
-				return 0;
-		}
+		spec->type = slang_spec_struct;

+		if (!parse_struct (C, O, &spec->_struct))
+			return 0;
 		break;
 	case TYPE_SPECIFIER_TYPENAME:
 		spec->type = slang_spec_struct;
@@ -1047,7 +583,7 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 			slang_struct *stru;
 			if (!parse_identifier (C, &name))
 				return 0;
-			stru = slang_struct_scope_find (structs, name, 1);
+			stru = slang_struct_scope_find (O->structs, name, 1);
 			if (stru == NULL)
 			{
 				slang_info_log_error (C->L, "%s: undeclared type name", name);
@@ -1061,7 +597,7 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 				slang_info_log_memory (C->L);
 				return 0;
 			}
-			if (!slang_struct_construct_a (spec->_struct))
+			if (!slang_struct_construct (spec->_struct))
 			{
 				slang_alloc_free (spec->_struct);
 				spec->_struct = NULL;
@@ -1077,12 +613,12 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_type_specifier *spec,
 	return 1;
 }
 
-static int parse_fully_specified_type (slang_parse_ctx *C, slang_fully_specified_type *type,
-	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
+static int parse_fully_specified_type (slang_parse_ctx *C, slang_output_ctx *O,

+	slang_fully_specified_type *type)
 {
 	if (!parse_type_qualifier (C, &type->qualifier))
 		return 0;
-	return parse_type_specifier (C, &type->specifier, structs, scope, funcs);
+	return parse_type_specifier (C, O, &type->specifier);
 }
 
 /* operation */
@@ -1149,8 +685,8 @@ static int parse_fully_specified_type (slang_parse_ctx *C, slang_fully_specified
 #define OP_POSTINCREMENT 60
 #define OP_POSTDECREMENT 61
 
-static int parse_child_operation (slang_parse_ctx *C, slang_operation *oper, int statement,
-	slang_variable_scope *scope, slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_child_operation (slang_parse_ctx *C, slang_output_ctx *O, slang_operation *oper,

+	int statement)
 {
 	oper->children = (slang_operation *) slang_alloc_realloc (oper->children,
 		oper->num_children * sizeof (slang_operation),
@@ -1160,50 +696,54 @@ static int parse_child_operation (slang_parse_ctx *C, slang_operation *oper, int
 		slang_info_log_memory (C->L);
 		return 0;
 	}
-	if (!slang_operation_construct_a (oper->children + oper->num_children))
+	if (!slang_operation_construct (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);
-	return parse_expression (C, oper->children + oper->num_children - 1, scope, structs, funcs);
+		return parse_statement (C, O, &oper->children[oper->num_children - 1]);
+	return parse_expression (C, O, &oper->children[oper->num_children - 1]);
 }
 
-static int parse_declaration (slang_parse_ctx *C, slang_variable_scope *, slang_struct_scope *,
-	slang_function_scope *);
+static int parse_declaration (slang_parse_ctx *C, slang_output_ctx *O);
 
-static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_variable_scope *scope,
-	slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_statement (slang_parse_ctx *C, slang_output_ctx *O, slang_operation *oper)
 {
-	oper->locals->outer_scope = scope;
+	oper->locals->outer_scope = O->vars;
 	switch (*C->I++)
 	{
 	case OP_BLOCK_BEGIN_NO_NEW_SCOPE:
 		oper->type = slang_oper_block_no_new_scope;
 		while (*C->I != OP_END)
-			if (!parse_child_operation (C, oper, 1, scope, structs, funcs))
+			if (!parse_child_operation (C, O, oper, 1))
 				return 0;
 		C->I++;
 		break;
 	case OP_BLOCK_BEGIN_NEW_SCOPE:
 		oper->type = slang_oper_block_new_scope;
-		while (*C->I != OP_END)
-			if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-				return 0;
+		while (*C->I != OP_END)

+		{

+			slang_output_ctx o = *O;

+			o.vars = oper->locals;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;

+		}
 		C->I++;
 		break;
 	case OP_DECLARE:
 		oper->type = slang_oper_variable_decl;
 		{
-			const unsigned int first_var = scope->num_variables;
-			if (!parse_declaration (C, scope, structs, funcs))
+			const unsigned int first_var = O->vars->num_variables;

+
+			if (!parse_declaration (C, O))
 				return 0;
-			if (first_var < scope->num_variables)
+			if (first_var < O->vars->num_variables)
 			{
-				const unsigned int num_vars = scope->num_variables - first_var;
-				unsigned int i;
+				const unsigned int num_vars = O->vars->num_variables - first_var;
+				unsigned int i;

+
 				oper->children = (slang_operation *) slang_alloc_malloc (num_vars * sizeof (
 					slang_operation));
 				if (oper->children == NULL)
@@ -1212,7 +752,7 @@ static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_var
 					return 0;
 				}
 				for (i = 0; i < num_vars; i++)
-					if (!slang_operation_construct_a (oper->children + i))
+					if (!slang_operation_construct (oper->children + i))
 					{
 						unsigned int j;
 						for (j = 0; j < i; j++)
@@ -1223,12 +763,12 @@ static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_var
 						return 0;
 					}
 				oper->num_children = num_vars;
-				for (i = first_var; i < scope->num_variables; i++)
+				for (i = first_var; i < O->vars->num_variables; i++)
 				{
 					slang_operation *o = oper->children + i - first_var;
 					o->type = slang_oper_identifier;
-					o->locals->outer_scope = scope;
-					o->identifier = slang_string_duplicate (scope->variables[i].name);
+					o->locals->outer_scope = O->vars;
+					o->identifier = slang_string_duplicate (O->vars->variables[i].name);
 					if (o->identifier == NULL)
 					{
 						slang_info_log_memory (C->L);
@@ -1243,7 +783,7 @@ static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_var
 		if (!parse_identifier (C, &oper->identifier))
 			return 0;
 		while (*C->I != OP_END)
-			if (!parse_child_operation (C, oper, 0, scope, structs, funcs))
+			if (!parse_child_operation (C, O, oper, 0))
 				return 0;
 		C->I++;
 		break;
@@ -1258,47 +798,55 @@ static int parse_statement (slang_parse_ctx *C, slang_operation *oper, slang_var
 		break;
 	case OP_RETURN:
 		oper->type = slang_oper_return;
-		if (!parse_child_operation (C, oper, 0, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 0))
 			return 0;
 		break;
 	case OP_EXPRESSION:
 		oper->type = slang_oper_expression;
-		if (!parse_child_operation (C, oper, 0, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 0))
 			return 0;
 		break;
 	case OP_IF:
 		oper->type = slang_oper_if;
-		if (!parse_child_operation (C, oper, 0, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 0))
 			return 0;
-		if (!parse_child_operation (C, oper, 1, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 1))
 			return 0;
-		if (!parse_child_operation (C, oper, 1, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 1))
 			return 0;
 		break;
 	case OP_WHILE:
-		oper->type = slang_oper_while;
-		if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-			return 0;
-		if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-			return 0;
+		oper->type = slang_oper_while;

+		{

+			slang_output_ctx o = *O;

+			o.vars = oper->locals;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;

+		}
 		break;
 	case OP_DO:
 		oper->type = slang_oper_do;
-		if (!parse_child_operation (C, oper, 1, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 1))
 			return 0;
-		if (!parse_child_operation (C, oper, 0, scope, structs, funcs))
+		if (!parse_child_operation (C, O, oper, 0))
 			return 0;
 		break;
 	case OP_FOR:
-		oper->type = slang_oper_for;
-		if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-			return 0;
-		if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-			return 0;
-		if (!parse_child_operation (C, oper, 0, oper->locals, structs, funcs))
-			return 0;
-		if (!parse_child_operation (C, oper, 1, oper->locals, structs, funcs))
-			return 0;
+		oper->type = slang_oper_for;

+		{

+			slang_output_ctx o = *O;

+			o.vars = oper->locals;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;
+			if (!parse_child_operation (C, &o, oper, 0))
+				return 0;
+			if (!parse_child_operation (C, &o, oper, 1))
+				return 0;

+		}
 		break;
 	default:
 		return 0;
@@ -1385,8 +933,7 @@ static int is_constructor_name (const char *name, slang_struct_scope *structs)
 	return slang_struct_scope_find (structs, name, 1) != NULL;
 }
 
-static int parse_expression (slang_parse_ctx *C, slang_operation *oper, slang_variable_scope *scope,
-	slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_expression (slang_parse_ctx *C, slang_output_ctx *O, slang_operation *oper)
 {
 	slang_operation *ops = NULL;
 	unsigned int num_ops = 0;
@@ -1404,13 +951,13 @@ 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))
+		if (!slang_operation_construct (op))
 		{
 			slang_info_log_memory (C->L);
 			return 0;
 		}
 		num_ops++;
-		op->locals->outer_scope = scope;
+		op->locals->outer_scope = O->vars;
 		switch (op_code)
 		{
 		case OP_PUSH_VOID:
@@ -1586,12 +1133,12 @@ static int parse_expression (slang_parse_ctx *C, slang_operation *oper, slang_va
 			if (!parse_identifier (C, &op->identifier))
 				return 0;
 			while (*C->I != OP_END)
-				if (!parse_child_operation (C, op, 0, scope, structs, funcs))
+				if (!parse_child_operation (C, O, op, 0))
 					return 0;
 			C->I++;
 			if (!C->parsing_builtin &&
-				!slang_function_scope_find_by_name (funcs, op->identifier, 1) &&
-				!is_constructor_name (op->identifier, structs))
+				!slang_function_scope_find_by_name (O->funs, op->identifier, 1) &&
+				!is_constructor_name (op->identifier, O->structs))
 			{
 				slang_info_log_error (C->L, "%s: undeclared function name", op->identifier);
 				return 0;
@@ -1633,8 +1180,8 @@ static int parse_expression (slang_parse_ctx *C, slang_operation *oper, slang_va
 #define PARAMETER_ARRAY_NOT_PRESENT 0
 #define PARAMETER_ARRAY_PRESENT 1
 
-static int parse_parameter_declaration (slang_parse_ctx *C, slang_variable *param,
-	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
+static int parse_parameter_declaration (slang_parse_ctx *C, slang_output_ctx *O,

+	slang_variable *param)
 {
 	slang_storage_aggregate agg;
 	if (!parse_type_qualifier (C, &param->type.qualifier))
@@ -1669,7 +1216,7 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_variable *para
 	default:
 		return 0;
 	}
-	if (!parse_type_specifier (C, &param->type.specifier, structs, scope, funcs))
+	if (!parse_type_specifier (C, O, &param->type.specifier))
 		return 0;
 	if (!parse_identifier (C, &param->name))
 		return 0;
@@ -1681,19 +1228,19 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_variable *para
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		if (!slang_operation_construct_a (param->array_size))
+		if (!slang_operation_construct (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))
+		if (!parse_expression (C, O, param->array_size))
 			return 0;
 	}
 	slang_storage_aggregate_construct (&agg);
-	if (!_slang_aggregate_variable (&agg, &param->type.specifier, param->array_size, funcs,
-		structs))
+	if (!_slang_aggregate_variable (&agg, &param->type.specifier, param->array_size, O->funs,
+			O->structs, O->vars))
 	{
 		slang_storage_aggregate_destruct (&agg);
 		return 0;
@@ -1801,10 +1348,9 @@ static int parse_operator_name (slang_parse_ctx *C, char **pname)
 	return 0;
 }
 
-static int parse_function_prototype (slang_parse_ctx *C, slang_function *func,
-	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
+static int parse_function_prototype (slang_parse_ctx *C, slang_output_ctx *O, slang_function *func)
 {
-	if (!parse_fully_specified_type (C, &func->header.type, structs, scope, funcs))
+	if (!parse_fully_specified_type (C, O, &func->header.type))
 		return 0;
 	switch (*C->I++)
 	{
@@ -1818,7 +1364,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 (
-			type_specifier_type_names[func->header.type.specifier.type]);
+			slang_type_specifier_type_to_string (func->header.type.specifier.type));
 		if (func->header.name == NULL)
 		{
 			slang_info_log_memory (C->L);
@@ -1833,7 +1379,7 @@ static int parse_function_prototype (slang_parse_ctx *C, slang_function *func,
 	default:
 		return 0;
 	}

-	func->parameters->outer_scope = scope;
+	func->parameters->outer_scope = O->vars;
 	while (*C->I++ == PARAMETER_NEXT)
 	{
 		func->parameters->variables = (slang_variable *) slang_alloc_realloc (
@@ -1847,18 +1393,19 @@ static int parse_function_prototype (slang_parse_ctx *C, slang_function *func,
 		}
 		slang_variable_construct (func->parameters->variables + func->parameters->num_variables);
 		func->parameters->num_variables++;
-		if (!parse_parameter_declaration (C, func->parameters->variables +
-			func->parameters->num_variables - 1, structs, scope, funcs))
+		if (!parse_parameter_declaration (C, O,

+				&func->parameters->variables[func->parameters->num_variables - 1]))
 			return 0;
 	}
 	func->param_count = func->parameters->num_variables;
 	return 1;
 }
 
-static int parse_function_definition (slang_parse_ctx *C, slang_function *func,
-	slang_struct_scope *structs, slang_variable_scope *scope, slang_function_scope *funcs)
-{
-	if (!parse_function_prototype (C, func, structs, scope, funcs))
+static int parse_function_definition (slang_parse_ctx *C, slang_output_ctx *O, slang_function *func)
+{

+	slang_output_ctx o = *O;

+
+	if (!parse_function_prototype (C, O, func))
 		return 0;
 	func->body = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
 	if (func->body == NULL)
@@ -1866,15 +1413,18 @@ static int parse_function_definition (slang_parse_ctx *C, slang_function *func,
 		slang_info_log_memory (C->L);
 		return 0;
 	}
-	if (!slang_operation_construct_a (func->body))
+	if (!slang_operation_construct (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;
+	}

+	C->global_scope = 0;

+	o.vars = func->parameters;
+	if (!parse_statement (C, &o, func->body))
+		return 0;

+	C->global_scope = 1;
 	return 1;
 }
 
@@ -1889,34 +1439,42 @@ static int parse_function_definition (slang_parse_ctx *C, slang_function *func,
 #define VARIABLE_ARRAY_EXPLICIT 3
 #define VARIABLE_ARRAY_UNKNOWN 4
 
-static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specified_type *type,
-	slang_variable_scope *vars, slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_init_declarator (slang_parse_ctx *C, slang_output_ctx *O,

+	const slang_fully_specified_type *type)
 {
 	slang_variable *var;
-
+

+	/* empty init declatator, e.g. "float ;" */

 	if (*C->I++ == VARIABLE_NONE)
-		return 1;
-	vars->variables = (slang_variable *) slang_alloc_realloc (vars->variables,
-		vars->num_variables * sizeof (slang_variable),
-		(vars->num_variables + 1) * sizeof (slang_variable));
-	if (vars->variables == NULL)
+		return 1;

+

+	/* make room for the new variable and initialize it */
+	O->vars->variables = (slang_variable *) slang_alloc_realloc (O->vars->variables,
+		O->vars->num_variables * sizeof (slang_variable),
+		(O->vars->num_variables + 1) * sizeof (slang_variable));
+	if (O->vars->variables == NULL)
 	{
 		slang_info_log_memory (C->L);
 		return 0;
 	}
-	var = vars->variables + vars->num_variables;
-	vars->num_variables++;
-	slang_variable_construct (var);
+	var = &O->vars->variables[O->vars->num_variables];
+	slang_variable_construct (var);

+	O->vars->num_variables++;

+

+	/* copy the declarator qualifier type, parse the identifier */
 	var->type.qualifier = type->qualifier;
 	if (!parse_identifier (C, &var->name))
-		return 0;
+		return 0;

+
 	switch (*C->I++)
 	{
-	case VARIABLE_NONE:
+	case VARIABLE_NONE:

+		/* simple variable declarator - just copy the specifier */
 		if (!slang_type_specifier_copy (&var->type.specifier, &type->specifier))
 			return 0;
 		break;
-	case VARIABLE_INITIALIZER:
+	case VARIABLE_INITIALIZER:

+		/* initialized variable - copy the specifier and parse the expression */
 		if (!slang_type_specifier_copy (&var->type.specifier, &type->specifier))
 			return 0;
 		var->initializer = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
@@ -1925,17 +1483,18 @@ static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specifie
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		if (!slang_operation_construct_a (var->initializer))
+		if (!slang_operation_construct (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))
+		if (!parse_expression (C, O, var->initializer))
 			return 0;
 		break;
-	case VARIABLE_ARRAY_UNKNOWN:
+	case VARIABLE_ARRAY_UNKNOWN:

+		/* unsized array - mark it as array and copy the specifier to the array element */
 		var->type.specifier.type = slang_spec_array;
 		var->type.specifier._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (
 			slang_type_specifier));
@@ -1948,7 +1507,9 @@ static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specifie
 		if (!slang_type_specifier_copy (var->type.specifier._array, &type->specifier))
 			return 0;
 		break;
-	case VARIABLE_ARRAY_EXPLICIT:
+	case VARIABLE_ARRAY_EXPLICIT:

+		/* an array - mark it as array, copy the specifier to the array element and

+		 * parse the expression */
 		var->type.specifier.type = slang_spec_array;
 		var->type.specifier._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (
 			slang_type_specifier));
@@ -1966,49 +1527,51 @@ static int parse_init_declarator (slang_parse_ctx *C, const slang_fully_specifie
 			slang_info_log_memory (C->L);
 			return 0;
 		}
-		if (!slang_operation_construct_a (var->array_size))
+		if (!slang_operation_construct (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))
+		if (!parse_expression (C, O, var->array_size))
 			return 0;
 		break;
 	default:
 		return 0;
-	}
-	if (!(var->type.specifier.type == slang_spec_array && var->array_size == NULL))
+	}

+

+	/* allocate global address space for a variable with a known size */
+	if (C->global_scope && !(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))
+		if (!_slang_aggregate_variable (&agg, &var->type.specifier, var->array_size, O->funs,
+				O->structs, O->vars))
 		{
 			slang_storage_aggregate_destruct (&agg);
 			return 0;
-		}
+		}

+		var->address = slang_var_pool_alloc (O->global_pool, _slang_sizeof_aggregate (&agg));
 		slang_storage_aggregate_destruct (&agg);
 	}
 	return 1;
 }
 
-static int parse_init_declarator_list (slang_parse_ctx *C, slang_variable_scope *vars,
-	slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_init_declarator_list (slang_parse_ctx *C, slang_output_ctx *O)
 {
 	slang_fully_specified_type type;
 
 	slang_fully_specified_type_construct (&type);
-	if (!parse_fully_specified_type (C, &type, structs, vars, funcs))
+	if (!parse_fully_specified_type (C, O, &type))
 	{
 		slang_fully_specified_type_destruct (&type);
 		return 0;
 	}
 	do
 	{
-		if (!parse_init_declarator (C, &type, vars, structs, funcs))
+		if (!parse_init_declarator (C, O, &type))
 		{
 			slang_fully_specified_type_destruct (&type);
 			return 0;
@@ -2019,16 +1582,17 @@ static int parse_init_declarator_list (slang_parse_ctx *C, slang_variable_scope
 	return 1;
 }
 
-static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scope *structs,
-	slang_function_scope *funcs, slang_variable_scope *scope, slang_function **parsed_func_ret)
+static int parse_function (slang_parse_ctx *C, slang_output_ctx *O, int definition,

+	slang_function **parsed_func_ret)
 {
 	slang_function parsed_func, *found_func;
 
 	/* parse function definition/declaration */
-	slang_function_construct (&parsed_func);
+	if (!slang_function_construct (&parsed_func))

+		return 0;
 	if (definition)
 	{
-		if (!parse_function_definition (C, &parsed_func, structs, scope, funcs))
+		if (!parse_function_definition (C, O, &parsed_func))
 		{
 			slang_function_destruct (&parsed_func);
 			return 0;
@@ -2036,7 +1600,7 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 	}
 	else
 	{
-		if (!parse_function_prototype (C, &parsed_func, structs, scope, funcs))
+		if (!parse_function_prototype (C, O, &parsed_func))
 		{
 			slang_function_destruct (&parsed_func);
 			return 0;
@@ -2045,24 +1609,24 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 
 	/* 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);
+	found_func = slang_function_scope_find (O->funs, &parsed_func, 0);
 	if (found_func == NULL)
 	{
 		/* add the parsed function to the function list */
-		funcs->functions = (slang_function *) slang_alloc_realloc (funcs->functions,
-			funcs->num_functions * sizeof (slang_function), (funcs->num_functions + 1) * sizeof (
-			slang_function));
-		if (funcs->functions == NULL)
+		O->funs->functions = (slang_function *) slang_alloc_realloc (O->funs->functions,
+			O->funs->num_functions * sizeof (slang_function),

+			(O->funs->num_functions + 1) * sizeof (slang_function));
+		if (O->funs->functions == NULL)
 		{
 			slang_info_log_memory (C->L);
 			slang_function_destruct (&parsed_func);
 			return 0;
 		}
-		funcs->functions[funcs->num_functions] = parsed_func;
-		funcs->num_functions++;
+		O->funs->functions[O->funs->num_functions] = parsed_func;
+		O->funs->num_functions++;
 
 		/* return the newly parsed function */
-		*parsed_func_ret = funcs->functions + funcs->num_functions - 1;
+		*parsed_func_ret = &O->funs->functions[O->funs->num_functions - 1];
 	}
 	else
 	{
@@ -2093,20 +1657,15 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 	/* assemble the parsed function */
 	if (definition)
 	{
-		slang_assembly_file file;
 		slang_assembly_name_space space;
 

-		slang_assembly_file_construct (&file);
-		space.funcs = funcs;
-		space.structs = structs;
-		space.vars = scope;
+		space.funcs = O->funs;
+		space.structs = O->structs;
+		space.vars = O->vars;
 
-		(**parsed_func_ret).address = file.count;
-		if (!_slang_assemble_function (&file, *parsed_func_ret, &space))
-		{
-			slang_assembly_file_destruct (&file);
-			return 0;
-		}
+		(**parsed_func_ret).address = O->assembly->count;
+		/*if (!_slang_assemble_function (O->assembly, *parsed_func_ret, &space))
+			return 0;*/
 	}
 	return 1;
 }
@@ -2115,19 +1674,18 @@ static int parse_function (slang_parse_ctx *C, int definition, slang_struct_scop
 #define DECLARATION_FUNCTION_PROTOTYPE 1
 #define DECLARATION_INIT_DECLARATOR_LIST 2
 
-static int parse_declaration (slang_parse_ctx *C, slang_variable_scope *scope,
-	slang_struct_scope *structs, slang_function_scope *funcs)
+static int parse_declaration (slang_parse_ctx *C, slang_output_ctx *O)
 {
 	slang_function *dummy_func;
 
 	switch (*C->I++)
 	{
 	case DECLARATION_INIT_DECLARATOR_LIST:
-		if (!parse_init_declarator_list (C, scope, structs, funcs))
+		if (!parse_init_declarator_list (C, O))
 			return 0;
 		break;
 	case DECLARATION_FUNCTION_PROTOTYPE:
-		if (!parse_function (C, 0, structs, funcs, scope, &dummy_func))
+		if (!parse_function (C, O, 0, &dummy_func))
 			return 0;
 		break;
 	default:
@@ -2142,19 +1700,27 @@ static int parse_declaration (slang_parse_ctx *C, slang_variable_scope *scope,
 #define EXTERNAL_DECLARATION 2
 
 static int parse_translation_unit (slang_parse_ctx *C, slang_translation_unit *unit)
-{
+{

+	slang_output_ctx o;

+

+	o.funs = &unit->functions;

+	o.structs = &unit->structs;

+	o.vars = &unit->globals;

+	o.assembly = unit->assembly;

+	o.global_pool = &unit->global_pool;

+
 	while (*C->I != EXTERNAL_NULL)
-	{
-		slang_function *func;
+	{

+		slang_function *func;

 
 		switch (*C->I++)
 		{
 		case EXTERNAL_FUNCTION_DEFINITION:
-			if (!parse_function (C, 1, &unit->structs, &unit->functions, &unit->globals, &func))
+			if (!parse_function (C, &o, 1, &func))
 				return 0;
 			break;
 		case EXTERNAL_DECLARATION:
-			if (!parse_declaration (C, &unit->globals, &unit->structs, &unit->functions))
+			if (!parse_declaration (C, &o))
 				return 0;
 			break;
 		default:
@@ -2163,7 +1729,12 @@ static int parse_translation_unit (slang_parse_ctx *C, slang_translation_unit *u
 	}
 	C->I++;
 	return 1;
-}
+}

+

+#define BUILTIN_CORE 0

+#define BUILTIN_COMMON 1

+#define BUILTIN_TARGET 2

+#define BUILTIN_TOTAL 3
 
 static int compile_binary (const byte *prod, slang_translation_unit *unit, slang_unit_type type,
 	slang_info_log *log, slang_translation_unit *builtins)
@@ -2173,7 +1744,8 @@ static int compile_binary (const byte *prod, slang_translation_unit *unit, slang
 	/* set-up parse context */
 	C.I = prod;
 	C.L = log;
-	C.parsing_builtin = builtins == NULL;
+	C.parsing_builtin = builtins == NULL;

+	C.global_scope = 1;
 
 	if (!check_revision (&C))
 		return 0;
@@ -2185,16 +1757,16 @@ static int compile_binary (const byte *prod, slang_translation_unit *unit, slang
 	if (builtins != NULL)
 	{
 		/* link to built-in functions */
-		builtins[1].functions.outer_scope = &builtins[0].functions;
-		builtins[2].functions.outer_scope = &builtins[1].functions;
-		unit->functions.outer_scope = &builtins[2].functions;
+		builtins[BUILTIN_COMMON].functions.outer_scope = &builtins[BUILTIN_CORE].functions;
+		builtins[BUILTIN_TARGET].functions.outer_scope = &builtins[BUILTIN_COMMON].functions;
+		unit->functions.outer_scope = &builtins[BUILTIN_TARGET].functions;
 
 		/* link to built-in variables - core unit does not define any */
-		builtins[2].globals.outer_scope = &builtins[1].globals;
-		unit->globals.outer_scope = &builtins[2].globals;
+		builtins[BUILTIN_TARGET].globals.outer_scope = &builtins[BUILTIN_COMMON].globals;
+		unit->globals.outer_scope = &builtins[BUILTIN_TARGET].globals;
 
 		/* link to built-in structure typedefs - only in common unit */
-		unit->structs.outer_scope = &builtins[1].structs;
+		unit->structs.outer_scope = &builtins[BUILTIN_COMMON].structs;
 	}
 
 	/* parse translation unit */
@@ -2257,7 +1829,7 @@ static const byte slang_vertex_builtin_gc[] = {
 #include "library/slang_vertex_builtin_gc.h"
 };

 

-int compile (grammar *id, slang_translation_unit builtin_units[3], int compiled[3],

+static int compile (grammar *id, slang_translation_unit *builtin_units, int *compiled,

 	const char *source, slang_translation_unit *unit, slang_unit_type type, slang_info_log *log)

 {

 	slang_translation_unit *builtins = NULL;

@@ -2286,29 +1858,29 @@ int compile (grammar *id, slang_translation_unit builtin_units[3], int compiled[
 	/* if parsing user-specified shader, load built-in library */

 	if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader)

 	{

-		if (!compile_binary (slang_core_gc, &builtin_units[0], slang_unit_fragment_builtin, log,

-				NULL))

+		if (!compile_binary (slang_core_gc, &builtin_units[BUILTIN_CORE],

+				slang_unit_fragment_builtin, log, NULL))

 			return 0;

-		compiled[0] = 1;

+		compiled[BUILTIN_CORE] = 1;

 

-		if (!compile_binary (slang_common_builtin_gc, &builtin_units[1],

+		if (!compile_binary (slang_common_builtin_gc, &builtin_units[BUILTIN_COMMON],

 				slang_unit_fragment_builtin, log, NULL))

 			return 0;

-		compiled[1] = 1;

+		compiled[BUILTIN_COMMON] = 1;

 

 		if (type == slang_unit_fragment_shader)

 		{

-			if (!compile_binary (slang_fragment_builtin_gc, &builtin_units[2],

+			if (!compile_binary (slang_fragment_builtin_gc, &builtin_units[BUILTIN_TARGET],

 					slang_unit_fragment_builtin, log, NULL))

 				return 0;

 		}

 		else if (type == slang_unit_vertex_shader)

 		{

-			if (!compile_binary (slang_vertex_builtin_gc, &builtin_units[2],

+			if (!compile_binary (slang_vertex_builtin_gc, &builtin_units[BUILTIN_TARGET],

 					slang_unit_vertex_builtin, log, NULL))

 				return 0;

 		}

-		compiled[2] = 1;

+		compiled[BUILTIN_TARGET] = 1;

 

 		/* disable language extensions */

 		grammar_set_reg8 (*id, (const byte *) "parsing_builtin", 0);

@@ -2321,14 +1893,14 @@ int compile (grammar *id, slang_translation_unit builtin_units[3], int compiled[
 

 	return 1;

 }
-
+

 int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit_type type,
 	slang_info_log *log)
 {

 	int success;
 	grammar id = 0;
-	slang_translation_unit builtin_units[3];

-	int compiled[3] = { 0 };
+	slang_translation_unit builtin_units[BUILTIN_TOTAL];

+	int compiled[BUILTIN_TOTAL] = { 0 };
 
 	success = compile (&id, builtin_units, compiled, source, unit, type, log);
 
@@ -2337,7 +1909,7 @@ int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit
 	{

 		int i;

 

-		for (i = 0; i < 3; i++)

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

 			if (compiled[i] != 0)
 				slang_translation_unit_destruct (&builtin_units[i]);
 	}

diff --git a/src/mesa/shader/slang/slang_compile.h b/src/mesa/shader/slang/slang_compile.h
index a9a075c37f..dd774dd35e 100644
--- a/src/mesa/shader/slang/slang_compile.h
+++ b/src/mesa/shader/slang/slang_compile.h
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.3
+ * Version:  6.5
  *
- * Copyright (C) 2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2005-2006  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"),
@@ -23,230 +23,41 @@
  */
 
 #if !defined SLANG_COMPILE_H
-#define SLANG_COMPILE_H
+#define SLANG_COMPILE_H

+

+#include "slang_compile_variable.h"

+#include "slang_compile_struct.h"

+#include "slang_compile_operation.h"

+#include "slang_compile_function.h"
 
 #if defined __cplusplus
 extern "C" {
 #endif
 
-typedef enum slang_type_qualifier_
-{
-	slang_qual_none,
-	slang_qual_const,
-	slang_qual_attribute,
-	slang_qual_varying,
-	slang_qual_uniform,
-	slang_qual_out,
-	slang_qual_inout,
-	slang_qual_fixedoutput,	/* internal */
-	slang_qual_fixedinput	/* internal */
-} slang_type_qualifier;
-
-typedef enum slang_type_specifier_type_
-{
-	slang_spec_void,
-	slang_spec_bool,
-	slang_spec_bvec2,
-	slang_spec_bvec3,
-	slang_spec_bvec4,
-	slang_spec_int,
-	slang_spec_ivec2,
-	slang_spec_ivec3,
-	slang_spec_ivec4,
-	slang_spec_float,
-	slang_spec_vec2,
-	slang_spec_vec3,
-	slang_spec_vec4,
-	slang_spec_mat2,
-	slang_spec_mat3,
-	slang_spec_mat4,
-	slang_spec_sampler1D,
-	slang_spec_sampler2D,
-	slang_spec_sampler3D,
-	slang_spec_samplerCube,
-	slang_spec_sampler1DShadow,
-	slang_spec_sampler2DShadow,
-	slang_spec_struct,
-	slang_spec_array
-} 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;

-

-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_
-{
-	slang_type_qualifier qualifier;
-	slang_type_specifier specifier;
-} slang_fully_specified_type;
-
-typedef struct slang_variable_scope_
-{
-	struct slang_variable_ *variables;
-	unsigned int num_variables;
-	struct slang_variable_scope_ *outer_scope;
-} slang_variable_scope;
-
-typedef enum slang_operation_type_
-{
-	slang_oper_none,
-	slang_oper_block_no_new_scope,
-	slang_oper_block_new_scope,
-	slang_oper_variable_decl,
-	slang_oper_asm,
-	slang_oper_break,
-	slang_oper_continue,
-	slang_oper_discard,
-	slang_oper_return,
-	slang_oper_expression,
-	slang_oper_if,
-	slang_oper_while,
-	slang_oper_do,
-	slang_oper_for,
-	slang_oper_void,
-	slang_oper_literal_bool,
-	slang_oper_literal_int,
-	slang_oper_literal_float,
-	slang_oper_identifier,
-	slang_oper_sequence,
-	slang_oper_assign,
-	slang_oper_addassign,
-	slang_oper_subassign,
-	slang_oper_mulassign,
-	slang_oper_divassign,
-	/*slang_oper_modassign,*/
-	/*slang_oper_lshassign,*/
-	/*slang_oper_rshassign,*/
-	/*slang_oper_orassign,*/
-	/*slang_oper_xorassign,*/
-	/*slang_oper_andassign,*/
-	slang_oper_select,
-	slang_oper_logicalor,
-	slang_oper_logicalxor,
-	slang_oper_logicaland,
-	/*slang_oper_bitor,*/
-	/*slang_oper_bitxor,*/
-	/*slang_oper_bitand,*/
-	slang_oper_equal,
-	slang_oper_notequal,
-	slang_oper_less,
-	slang_oper_greater,
-	slang_oper_lessequal,
-	slang_oper_greaterequal,
-	/*slang_oper_lshift,*/
-	/*slang_oper_rshift,*/
-	slang_oper_add,
-	slang_oper_subtract,
-	slang_oper_multiply,
-	slang_oper_divide,
-	/*slang_oper_modulus,*/
-	slang_oper_preincrement,
-	slang_oper_predecrement,
-	slang_oper_plus,
-	slang_oper_minus,
-	/*slang_oper_complement,*/
-	slang_oper_not,
-	slang_oper_subscript,
-	slang_oper_call,
-	slang_oper_field,
-	slang_oper_postincrement,
-	slang_oper_postdecrement
-} slang_operation_type;
-
-typedef struct slang_operation_
-{
-	slang_operation_type type;
-	struct slang_operation_ *children;
-	unsigned int num_children;
-	float literal;		/* bool, literal_int, literal_float */
-	char *identifier;	/* asm, identifier, call, field */
-	slang_variable_scope *locals;
-} 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;

-	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;

-

-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;

-

-int slang_struct_construct_a (slang_struct *);

-int slang_struct_copy (slang_struct *, const slang_struct *);
-
-typedef enum slang_function_kind_
-{
-	slang_func_ordinary,
-	slang_func_constructor,
-	slang_func_operator
-} slang_function_kind;
-
-typedef struct slang_function_
-{
-	slang_function_kind kind;
-	slang_variable header;
-	slang_variable_scope *parameters;
-	unsigned int param_count;
-	slang_operation *body;

-	unsigned int address;
-} slang_function;
-
-typedef struct slang_function_scope_
-{
-	slang_function *functions;
-	unsigned int num_functions;
-	struct slang_function_scope_ *outer_scope;
-} slang_function_scope;
-
 typedef enum slang_unit_type_
 {
 	slang_unit_fragment_shader,
 	slang_unit_vertex_shader,
 	slang_unit_fragment_builtin,
 	slang_unit_vertex_builtin
-} slang_unit_type;
-	
+} slang_unit_type;

+

+typedef struct slang_var_pool_

+{

+	GLuint next_addr;

+} slang_var_pool;

+

 typedef struct slang_translation_unit_
 {
 	slang_variable_scope globals;
 	slang_function_scope functions;
 	slang_struct_scope structs;
-	slang_unit_type type;
+	slang_unit_type type;

+	struct slang_assembly_file_ *assembly;

+	slang_var_pool global_pool;
 } slang_translation_unit;
 
-void slang_translation_unit_construct (slang_translation_unit *);
+int slang_translation_unit_construct (slang_translation_unit *);
 void slang_translation_unit_destruct (slang_translation_unit *);
 
 typedef struct slang_info_log_
diff --git a/src/mesa/shader/slang/slang_compile_function.c b/src/mesa/shader/slang/slang_compile_function.c
new file mode 100644
index 0000000000..970c6faef0
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_function.c
@@ -0,0 +1,133 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_compile_function.c

+ * slang front-end compiler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_compile_variable.h"

+#include "slang_compile_struct.h"

+#include "slang_compile_operation.h"

+#include "slang_compile_function.h"

+

+/* slang_function */

+

+int slang_function_construct (slang_function *func)

+{

+	func->kind = slang_func_ordinary;

+	if (!slang_variable_construct (&func->header))

+		return 0;

+	func->parameters = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));

+	if (func->parameters == NULL)

+	{

+		slang_variable_destruct (&func->header);

+		return 0;

+	}

+	if (!slang_variable_scope_construct (func->parameters))

+	{

+		slang_alloc_free (func->parameters);

+		slang_variable_destruct (&func->header);

+		return 0;

+	}

+	func->param_count = 0;

+	func->body = NULL;

+	func->address = ~0;

+	return 1;

+}

+

+void slang_function_destruct (slang_function *func)

+{

+	slang_variable_destruct (&func->header);

+	slang_variable_scope_destruct (func->parameters);

+	slang_alloc_free (func->parameters);

+	if (func->body != NULL)

+	{

+		slang_operation_destruct (func->body);

+		slang_alloc_free (func->body);

+	}

+}

+

+/* slang_function_scope */

+

+int slang_function_scope_construct (slang_function_scope *scope)

+{

+	scope->functions = NULL;

+	scope->num_functions = 0;

+	scope->outer_scope = NULL;

+	return 1;

+}

+

+void slang_function_scope_destruct (slang_function_scope *scope)

+{

+	unsigned int i;

+

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

+		slang_function_destruct (scope->functions + i);

+	slang_alloc_free (scope->functions);

+}

+

+int slang_function_scope_find_by_name (slang_function_scope *funcs, const char *name, int all_scopes)

+{

+	unsigned int i;

+

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

+		if (slang_string_compare (name, funcs->functions[i].header.name) == 0)

+			return 1;

+	if (all_scopes && funcs->outer_scope != NULL)

+		return slang_function_scope_find_by_name (funcs->outer_scope, name, 1);

+	return 0;

+}

+

+slang_function *slang_function_scope_find (slang_function_scope *funcs, slang_function *fun,

+	int all_scopes)

+{

+	unsigned int i;

+

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

+	{

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

+		unsigned int j;

+

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

+			continue;

+		if (fun->param_count != f->param_count)

+			continue;

+		for (j = 0; j < fun->param_count; j++)

+		{

+			if (!slang_type_specifier_equal (&fun->parameters->variables[j].type.specifier,

+					&f->parameters->variables[j].type.specifier))

+				break;

+		}

+		if (j == fun->param_count)

+			return f;

+	}

+	if (all_scopes && funcs->outer_scope != NULL)

+		return slang_function_scope_find (funcs->outer_scope, fun, 1);

+	return NULL;

+}

+

diff --git a/src/mesa/shader/slang/slang_compile_function.h b/src/mesa/shader/slang/slang_compile_function.h
new file mode 100644
index 0000000000..7f13bffa92
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_function.h
@@ -0,0 +1,69 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_COMPILE_FUNCTION_H

+#define SLANG_COMPILE_FUNCTION_H

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef enum slang_function_kind_

+{

+	slang_func_ordinary,

+	slang_func_constructor,

+	slang_func_operator

+} slang_function_kind;

+

+typedef struct slang_function_

+{

+	slang_function_kind kind;

+	slang_variable header;

+	slang_variable_scope *parameters;

+	unsigned int param_count;

+	slang_operation *body;

+	unsigned int address;

+} slang_function;

+

+int slang_function_construct (slang_function *);

+void slang_function_destruct (slang_function *);

+

+typedef struct slang_function_scope_

+{

+	slang_function *functions;

+	unsigned int num_functions;

+	struct slang_function_scope_ *outer_scope;

+} slang_function_scope;

+

+int slang_function_scope_construct (slang_function_scope *);

+void slang_function_scope_destruct (slang_function_scope *);

+int slang_function_scope_find_by_name (slang_function_scope *, const char *, int);

+slang_function *slang_function_scope_find (slang_function_scope *, slang_function *, int);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_compile_operation.c b/src/mesa/shader/slang/slang_compile_operation.c
new file mode 100644
index 0000000000..f6d371a44b
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_operation.c
@@ -0,0 +1,115 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_compile_operation.c

+ * slang front-end compiler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_compile_variable.h"

+#include "slang_compile_struct.h"

+#include "slang_compile_operation.h"

+#include "slang_compile_function.h"

+

+/* slang_operation */

+

+int slang_operation_construct (slang_operation *oper)

+{

+	oper->type = slang_oper_none;

+	oper->children = NULL;

+	oper->num_children = 0;

+	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;

+	if (!slang_variable_scope_construct (oper->locals))

+	{

+		slang_alloc_free (oper->locals);

+		return 0;

+	}

+	return 1;

+}

+

+void slang_operation_destruct (slang_operation *oper)

+{

+	unsigned int i;

+

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

+		slang_operation_destruct (oper->children + i);

+	slang_alloc_free (oper->children);

+	slang_alloc_free (oper->identifier);

+	slang_variable_scope_destruct (oper->locals);

+	slang_alloc_free (oper->locals);

+}

+

+int slang_operation_copy (slang_operation *x, const slang_operation *y)

+{

+	slang_operation z;

+	unsigned int i;

+

+	if (!slang_operation_construct (&z))

+		return 0;

+	z.type = y->type;

+	z.children = (slang_operation *) slang_alloc_malloc (y->num_children * sizeof (slang_operation));

+	if (z.children == NULL)

+	{

+		slang_operation_destruct (&z);

+		return 0;

+	}

+	for (z.num_children = 0; z.num_children < y->num_children; z.num_children++)

+		if (!slang_operation_construct (&z.children[z.num_children]))

+		{

+			slang_operation_destruct (&z);

+			return 0;

+		}

+	for (i = 0; i < z.num_children; i++)

+		if (!slang_operation_copy (&z.children[i], &y->children[i]))

+		{

+			slang_operation_destruct (&z);

+			return 0;

+		}

+	z.literal = y->literal;

+	if (y->identifier != NULL)

+	{

+		z.identifier = slang_string_duplicate (y->identifier);

+		if (z.identifier == NULL)

+		{

+			slang_operation_destruct (&z);

+			return 0;

+		}

+	}

+	if (!slang_variable_scope_copy (z.locals, y->locals))

+	{

+		slang_operation_destruct (&z);

+		return 0;

+	}

+	slang_operation_destruct (x);

+	*x = z;

+	return 1;

+}

+

diff --git a/src/mesa/shader/slang/slang_compile_operation.h b/src/mesa/shader/slang/slang_compile_operation.h
new file mode 100644
index 0000000000..54b2d17df6
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_operation.h
@@ -0,0 +1,117 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_COMPILE_OPERATION_H

+#define SLANG_COMPILE_OPERATION_H

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef enum slang_operation_type_

+{

+	slang_oper_none,

+	slang_oper_block_no_new_scope,

+	slang_oper_block_new_scope,

+	slang_oper_variable_decl,

+	slang_oper_asm,

+	slang_oper_break,

+	slang_oper_continue,

+	slang_oper_discard,

+	slang_oper_return,

+	slang_oper_expression,

+	slang_oper_if,

+	slang_oper_while,

+	slang_oper_do,

+	slang_oper_for,

+	slang_oper_void,

+	slang_oper_literal_bool,

+	slang_oper_literal_int,

+	slang_oper_literal_float,

+	slang_oper_identifier,

+	slang_oper_sequence,

+	slang_oper_assign,

+	slang_oper_addassign,

+	slang_oper_subassign,

+	slang_oper_mulassign,

+	slang_oper_divassign,

+	/*slang_oper_modassign,*/

+	/*slang_oper_lshassign,*/

+	/*slang_oper_rshassign,*/

+	/*slang_oper_orassign,*/

+	/*slang_oper_xorassign,*/

+	/*slang_oper_andassign,*/

+	slang_oper_select,

+	slang_oper_logicalor,

+	slang_oper_logicalxor,

+	slang_oper_logicaland,

+	/*slang_oper_bitor,*/

+	/*slang_oper_bitxor,*/

+	/*slang_oper_bitand,*/

+	slang_oper_equal,

+	slang_oper_notequal,

+	slang_oper_less,

+	slang_oper_greater,

+	slang_oper_lessequal,

+	slang_oper_greaterequal,

+	/*slang_oper_lshift,*/

+	/*slang_oper_rshift,*/

+	slang_oper_add,

+	slang_oper_subtract,

+	slang_oper_multiply,

+	slang_oper_divide,

+	/*slang_oper_modulus,*/

+	slang_oper_preincrement,

+	slang_oper_predecrement,

+	slang_oper_plus,

+	slang_oper_minus,

+	/*slang_oper_complement,*/

+	slang_oper_not,

+	slang_oper_subscript,

+	slang_oper_call,

+	slang_oper_field,

+	slang_oper_postincrement,

+	slang_oper_postdecrement

+} slang_operation_type;

+

+typedef struct slang_operation_

+{

+	slang_operation_type type;

+	struct slang_operation_ *children;

+	unsigned int num_children;

+	float literal;		/* type: bool, literal_int, literal_float */

+	char *identifier;	/* type: asm, identifier, call, field */

+	slang_variable_scope *locals;

+} slang_operation;

+

+int slang_operation_construct (slang_operation *);

+void slang_operation_destruct (slang_operation *);

+int slang_operation_copy (slang_operation *, const slang_operation *);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_compile_struct.c b/src/mesa/shader/slang/slang_compile_struct.c
new file mode 100644
index 0000000000..bad58f4e5b
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_struct.c
@@ -0,0 +1,191 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_compile_struct.c

+ * slang front-end compiler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_compile_variable.h"

+#include "slang_compile_struct.h"

+#include "slang_compile_operation.h"

+#include "slang_compile_function.h"

+

+/* slang_struct_scope */

+

+int slang_struct_scope_construct (slang_struct_scope *scope)

+{

+	scope->structs = NULL;

+	scope->num_structs = 0;

+	scope->outer_scope = NULL;

+	return 1;

+}

+

+void slang_struct_scope_destruct (slang_struct_scope *scope)

+{

+	unsigned int i;

+

+	for (i = 0; i < scope->num_structs; i++)

+		slang_struct_destruct (scope->structs + i);

+	slang_alloc_free (scope->structs);

+	/* do not free scope->outer_scope */

+}

+

+int slang_struct_scope_copy (slang_struct_scope *x, const slang_struct_scope *y)

+{

+	slang_struct_scope z;

+	unsigned int i;

+

+	if (!slang_struct_scope_construct (&z))

+		return 0;

+	z.structs = (slang_struct *) slang_alloc_malloc (y->num_structs * sizeof (slang_struct));

+	if (z.structs == NULL)

+	{

+		slang_struct_scope_destruct (&z);

+		return 0;

+	}

+	for (z.num_structs = 0; z.num_structs < y->num_structs; z.num_structs++)

+		if (!slang_struct_construct (&z.structs[z.num_structs]))

+		{

+			slang_struct_scope_destruct (&z);

+			return 0;

+		}

+	for (i = 0; i < z.num_structs; i++)

+		if (!slang_struct_copy (&z.structs[i], &y->structs[i]))

+		{

+			slang_struct_scope_destruct (&z);

+			return 0;

+		}

+	z.outer_scope = y->outer_scope;

+	slang_struct_scope_destruct (x);

+	*x = z;

+	return 1;

+}

+

+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++)

+		if (slang_string_compare (name, stru->structs[i].name) == 0)

+			return stru->structs + i;

+	if (all_scopes && stru->outer_scope != NULL)

+		return slang_struct_scope_find (stru->outer_scope, name, 1);

+	return NULL;

+}

+

+/* slang_struct */

+

+int slang_struct_construct (slang_struct *stru)

+{

+	stru->name = NULL;

+	stru->fields = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));

+	if (stru->fields == NULL)

+		return 0;

+	if (!slang_variable_scope_construct (stru->fields))

+	{

+		slang_alloc_free (stru->fields);

+		return 0;

+	}

+	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;

+	}

+	if (!slang_struct_scope_construct (stru->structs))

+	{

+		slang_variable_scope_destruct (stru->fields);

+		slang_alloc_free (stru->fields);

+		slang_alloc_free (stru->structs);

+		return 0;

+	}

+	return 1;

+}

+

+void slang_struct_destruct (slang_struct *stru)

+{

+	slang_alloc_free (stru->name);

+	slang_variable_scope_destruct (stru->fields);

+	slang_alloc_free (stru->fields);

+	slang_struct_scope_destruct (stru->structs);

+	slang_alloc_free (stru->structs);

+}

+

+int slang_struct_copy (slang_struct *x, const slang_struct *y)

+{

+	slang_struct z;

+

+	if (!slang_struct_construct (&z))

+		return 0;

+	if (y->name != NULL)

+	{

+		z.name = slang_string_duplicate (y->name);

+		if (z.name == NULL)

+		{

+			slang_struct_destruct (&z);

+			return 0;

+		}

+	}

+	if (!slang_variable_scope_copy (z.fields, y->fields))

+	{

+		slang_struct_destruct (&z);

+		return 0;

+	}

+	if (!slang_struct_scope_copy (z.structs, y->structs))

+	{

+		slang_struct_destruct (&z);

+		return 0;

+	}

+	slang_struct_destruct (x);

+	*x = z;

+	return 1;

+}

+

+int slang_struct_equal (const slang_struct *x, const slang_struct *y)

+{

+	unsigned int i;

+

+	if (x->fields->num_variables != y->fields->num_variables)

+		return 0;

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

+	{

+		slang_variable *varx = x->fields->variables + i;

+		slang_variable *vary = y->fields->variables + i;

+		if (slang_string_compare (varx->name, vary->name) != 0)

+			return 0;

+		if (!slang_type_specifier_equal (&varx->type.specifier, &vary->type.specifier))

+			return 0;

+		if (varx->type.specifier.type == slang_spec_array)

+		{

+			/* TODO compare array sizes */

+		}

+	}

+	return 1;

+}

+

diff --git a/src/mesa/shader/slang/slang_compile_struct.h b/src/mesa/shader/slang/slang_compile_struct.h
new file mode 100644
index 0000000000..10af980216
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_struct.h
@@ -0,0 +1,61 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_COMPILE_STRUCT_H

+#define SLANG_COMPILE_STRUCT_H

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef struct slang_struct_scope_

+{

+	struct slang_struct_ *structs;

+	unsigned int num_structs;

+	struct slang_struct_scope_ *outer_scope;

+} slang_struct_scope;

+

+int slang_struct_scope_construct (slang_struct_scope *);

+void slang_struct_scope_destruct (slang_struct_scope *);

+int slang_struct_scope_copy (slang_struct_scope *, const slang_struct_scope *);

+struct slang_struct_ *slang_struct_scope_find (slang_struct_scope *, const char *, int);

+

+typedef struct slang_struct_

+{

+	char *name;

+	struct slang_variable_scope_ *fields;

+	slang_struct_scope *structs;

+} slang_struct;

+

+int slang_struct_construct (slang_struct *);

+void slang_struct_destruct (slang_struct *);

+int slang_struct_copy (slang_struct *, const slang_struct *);

+int slang_struct_equal (const slang_struct *, const slang_struct *);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_compile_variable.c b/src/mesa/shader/slang/slang_compile_variable.c
new file mode 100644
index 0000000000..39aabd8312
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_variable.c
@@ -0,0 +1,371 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_compile_variable.c

+ * slang front-end compiler

+ * \author Michal Krol

+ */

+

+#include "imports.h"

+#include "slang_utility.h"

+#include "slang_compile_variable.h"

+#include "slang_compile_struct.h"

+#include "slang_compile_operation.h"

+#include "slang_compile_function.h"

+

+/* slang_type_specifier_type */

+

+typedef struct

+{

+	const char *name;

+	slang_type_specifier_type type;

+} type_specifier_type_name;

+

+static type_specifier_type_name type_specifier_type_names[] = {

+	{ "void", slang_spec_void },

+	{ "bool", slang_spec_bool },

+	{ "bvec2", slang_spec_bvec2 },

+	{ "bvec3", slang_spec_bvec3 },

+	{ "bvec4", slang_spec_bvec4 },

+	{ "int", slang_spec_int },

+	{ "ivec2", slang_spec_ivec2 },

+	{ "ivec3", slang_spec_ivec3 },

+	{ "ivec4", slang_spec_ivec4 },

+	{ "float", slang_spec_float },

+	{ "vec2", slang_spec_vec2 },

+	{ "vec3", slang_spec_vec3 },

+	{ "vec4", slang_spec_vec4 },

+	{ "mat2", slang_spec_mat2 },

+	{ "mat3", slang_spec_mat3 },

+	{ "mat4", slang_spec_mat4 },

+	{ "sampler1D", slang_spec_sampler1D },

+	{ "sampler2D", slang_spec_sampler2D },

+	{ "sampler3D", slang_spec_sampler3D },

+	{ "samplerCube", slang_spec_samplerCube },

+	{ "sampler1DShadow", slang_spec_sampler1DShadow },

+	{ "sampler2DShadow", slang_spec_sampler2DShadow },

+	{ NULL, slang_spec_void }

+};

+

+slang_type_specifier_type slang_type_specifier_type_from_string (const char *name)

+{

+	type_specifier_type_name *p = type_specifier_type_names;

+	while (p->name != NULL)

+	{

+		if (slang_string_compare (p->name, name) == 0)

+			break;

+		p++;

+	}

+	return p->type;

+}

+

+const char *slang_type_specifier_type_to_string (slang_type_specifier_type type)

+{

+	type_specifier_type_name *p = type_specifier_type_names;

+	while (p->name != NULL)

+	{

+		if (p->type == type)

+			break;

+		p++;

+	}

+	return p->name;

+}

+

+/* slang_type_specifier */

+

+int slang_type_specifier_construct (slang_type_specifier *spec)

+{

+	spec->type = slang_spec_void;

+	spec->_struct = NULL;

+	spec->_array = NULL;

+	return 1;

+}

+

+void slang_type_specifier_destruct (slang_type_specifier *spec)

+{

+	if (spec->_struct != NULL)

+	{

+		slang_struct_destruct (spec->_struct);

+		slang_alloc_free (spec->_struct);

+	}

+	if (spec->_array != NULL)

+	{

+		slang_type_specifier_destruct (spec->_array);

+		slang_alloc_free (spec->_array);

+	}

+}

+

+int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)

+{

+	slang_type_specifier z;

+

+	if (!slang_type_specifier_construct (&z))

+		return 0;

+	z.type = y->type;

+	if (z.type == slang_spec_struct)

+	{

+		z._struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));

+		if (z._struct == NULL)

+		{

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+		if (!slang_struct_construct (z._struct))

+		{

+			slang_alloc_free (z._struct);

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+		if (!slang_struct_copy (z._struct, y->_struct))

+		{

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+	}

+	else if (z.type == slang_spec_array)

+	{

+		z._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (slang_type_specifier));

+		if (z._array == NULL)

+		{

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+		if (!slang_type_specifier_construct (z._array))

+		{

+			slang_alloc_free (z._array);

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+		if (!slang_type_specifier_copy (z._array, y->_array))

+		{

+			slang_type_specifier_destruct (&z);

+			return 0;

+		}

+	}

+	slang_type_specifier_destruct (x);

+	*x = z;

+	return 1;

+}

+

+int slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)

+{

+	if (x->type != y->type)

+		return 0;

+	if (x->type == slang_spec_struct)

+		return slang_struct_equal (x->_struct, y->_struct);

+	if (x->type == slang_spec_array)

+		return slang_type_specifier_equal (x->_array, y->_array);

+	return 1;

+}

+

+/* slang_fully_specified_type */

+

+int slang_fully_specified_type_construct (slang_fully_specified_type *type)

+{

+	type->qualifier = slang_qual_none;

+	if (!slang_type_specifier_construct (&type->specifier))

+		return 0;

+	return 1;

+}

+

+void slang_fully_specified_type_destruct (slang_fully_specified_type *type)

+{

+	slang_type_specifier_destruct (&type->specifier);

+}

+

+int slang_fully_specified_type_copy (slang_fully_specified_type *x, const slang_fully_specified_type *y)

+{

+	slang_fully_specified_type z;

+

+	if (!slang_fully_specified_type_construct (&z))

+		return 0;

+	z.qualifier = y->qualifier;

+	if (!slang_type_specifier_copy (&z.specifier, &y->specifier))

+	{

+		slang_fully_specified_type_destruct (&z);

+		return 0;

+	}

+	slang_fully_specified_type_destruct (x);

+	*x = z;

+	return 1;

+}

+

+/* slang_variable_scope */

+

+int slang_variable_scope_construct (slang_variable_scope *scope)

+{

+	scope->variables = NULL;

+	scope->num_variables = 0;

+	scope->outer_scope = NULL;

+	return 1;

+}

+

+void slang_variable_scope_destruct (slang_variable_scope *scope)

+{

+	unsigned int i;

+

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

+		slang_variable_destruct (scope->variables + i);

+	slang_alloc_free (scope->variables);

+	/* do not free scope->outer_scope */

+}

+

+int slang_variable_scope_copy (slang_variable_scope *x, const slang_variable_scope *y)

+{

+	slang_variable_scope z;

+	unsigned int i;

+

+	if (!slang_variable_scope_construct (&z))

+		return 0;

+	z.variables = (slang_variable *) slang_alloc_malloc (y->num_variables * sizeof (slang_variable));

+	if (z.variables == NULL)

+	{

+		slang_variable_scope_destruct (&z);

+		return 0;

+	}

+	for (z.num_variables = 0; z.num_variables < y->num_variables; z.num_variables++)

+		if (!slang_variable_construct (&z.variables[z.num_variables]))

+		{

+			slang_variable_scope_destruct (&z);

+			return 0;

+		}

+	for (i = 0; i < z.num_variables; i++)

+		if (!slang_variable_copy (&z.variables[i], &y->variables[i]))

+		{

+			slang_variable_scope_destruct (&z);

+			return 0;

+		}

+	z.outer_scope = y->outer_scope;

+	slang_variable_scope_destruct (x);

+	*x = z;

+	return 1;

+}

+

+/* slang_variable */

+

+int slang_variable_construct (slang_variable *var)

+{

+	if (!slang_fully_specified_type_construct (&var->type))

+		return 0;

+	var->name = NULL;

+	var->array_size = NULL;

+	var->initializer = NULL;

+	var->address = ~0;

+	return 1;

+}

+

+void slang_variable_destruct (slang_variable *var)

+{

+	slang_fully_specified_type_destruct (&var->type);

+	slang_alloc_free (var->name);

+	if (var->array_size != NULL)

+	{

+		slang_operation_destruct (var->array_size);

+		slang_alloc_free (var->array_size);

+	}

+	if (var->initializer != NULL)

+	{

+		slang_operation_destruct (var->initializer);

+		slang_alloc_free (var->initializer);

+	}

+}

+

+int slang_variable_copy (slang_variable *x, const slang_variable *y)

+{

+	slang_variable z;

+

+	if (!slang_variable_construct (&z))

+		return 0;

+	if (!slang_fully_specified_type_copy (&z.type, &y->type))

+	{

+		slang_variable_destruct (&z);

+		return 0;

+	}

+	if (y->name != NULL)

+	{

+		z.name = slang_string_duplicate (y->name);

+		if (z.name == NULL)

+		{

+			slang_variable_destruct (&z);

+			return 0;

+		}

+	}

+	if (y->array_size != NULL)

+	{

+		z.array_size = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));

+		if (z.array_size == NULL)

+		{

+			slang_variable_destruct (&z);

+			return 0;

+		}

+		if (!slang_operation_construct (z.array_size))

+		{

+			slang_alloc_free (z.array_size);

+			slang_variable_destruct (&z);

+			return 0;

+		}

+		if (!slang_operation_copy (z.array_size, y->array_size))

+		{

+			slang_variable_destruct (&z);

+			return 0;

+		}

+	}

+	if (y->initializer != NULL)

+	{

+		z.initializer = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));

+		if (z.initializer == NULL)

+		{

+			slang_variable_destruct (&z);

+			return 0;

+		}

+		if (!slang_operation_construct (z.initializer))

+		{

+			slang_alloc_free (z.initializer);

+			slang_variable_destruct (&z);

+			return 0;

+		}

+		if (!slang_operation_copy (z.initializer, y->initializer))

+		{

+			slang_variable_destruct (&z);

+			return 0;

+		}

+	}

+	slang_variable_destruct (x);

+	*x = z;

+	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;

+}

+

diff --git a/src/mesa/shader/slang/slang_compile_variable.h b/src/mesa/shader/slang/slang_compile_variable.h
new file mode 100644
index 0000000000..d82a661eda
--- /dev/null
+++ b/src/mesa/shader/slang/slang_compile_variable.h
@@ -0,0 +1,129 @@
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 2005-2006  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_COMPILE_VARIABLE_H

+#define SLANG_COMPILE_VARIABLE_H

+

+#if defined __cplusplus

+extern "C" {

+#endif

+

+typedef enum slang_type_qualifier_

+{

+	slang_qual_none,

+	slang_qual_const,

+	slang_qual_attribute,

+	slang_qual_varying,

+	slang_qual_uniform,

+	slang_qual_out,

+	slang_qual_inout,

+	slang_qual_fixedoutput,	/* internal */

+	slang_qual_fixedinput	/* internal */

+} slang_type_qualifier;

+

+typedef enum slang_type_specifier_type_

+{

+	slang_spec_void,

+	slang_spec_bool,

+	slang_spec_bvec2,

+	slang_spec_bvec3,

+	slang_spec_bvec4,

+	slang_spec_int,

+	slang_spec_ivec2,

+	slang_spec_ivec3,

+	slang_spec_ivec4,

+	slang_spec_float,

+	slang_spec_vec2,

+	slang_spec_vec3,

+	slang_spec_vec4,

+	slang_spec_mat2,

+	slang_spec_mat3,

+	slang_spec_mat4,

+	slang_spec_sampler1D,

+	slang_spec_sampler2D,

+	slang_spec_sampler3D,

+	slang_spec_samplerCube,

+	slang_spec_sampler1DShadow,

+	slang_spec_sampler2DShadow,

+	slang_spec_struct,

+	slang_spec_array

+} slang_type_specifier_type;

+

+slang_type_specifier_type slang_type_specifier_type_from_string (const char *);

+const char *slang_type_specifier_type_to_string (slang_type_specifier_type);

+

+typedef struct slang_type_specifier_

+{

+	slang_type_specifier_type type;

+	struct slang_struct_ *_struct;			/* type: spec_struct */

+	struct slang_type_specifier_ *_array;	/* type: spec_array */

+} slang_type_specifier;

+

+int 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_

+{

+	slang_type_qualifier qualifier;

+	slang_type_specifier specifier;

+} slang_fully_specified_type;

+

+int slang_fully_specified_type_construct (slang_fully_specified_type *);

+void slang_fully_specified_type_destruct (slang_fully_specified_type *);

+int slang_fully_specified_type_copy (slang_fully_specified_type *, const slang_fully_specified_type *);

+

+typedef struct slang_variable_scope_

+{

+	struct slang_variable_ *variables;

+	unsigned int num_variables;

+	struct slang_variable_scope_ *outer_scope;

+} slang_variable_scope;

+

+int slang_variable_scope_construct (slang_variable_scope *);

+void slang_variable_scope_destruct (slang_variable_scope *);

+int slang_variable_scope_copy (slang_variable_scope *, const slang_variable_scope *);

+

+typedef struct slang_variable_

+{

+	slang_fully_specified_type type;

+	char *name;

+	struct slang_operation_ *array_size;	/* type: spec_array */

+	struct slang_operation_ *initializer;

+	unsigned int address;

+} slang_variable;

+

+int slang_variable_construct (slang_variable *);

+void slang_variable_destruct (slang_variable *);

+int slang_variable_copy (slang_variable *, const slang_variable *);

+

+slang_variable *_slang_locate_variable (slang_variable_scope *scope, const char *name, int all);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/src/mesa/shader/slang/slang_storage.c b/src/mesa/shader/slang/slang_storage.c
index 3b2fda415b..8a608c4902 100644
--- a/src/mesa/shader/slang/slang_storage.c
+++ b/src/mesa/shader/slang/slang_storage.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.3
+ * Version:  6.5
  *
- * Copyright (C) 2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2005-2006  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"),
@@ -112,19 +112,20 @@ static int aggregate_matrix (slang_storage_aggregate *agg, slang_storage_type ba
 	return 1;
 }
 
-static int aggregate_variables (slang_storage_aggregate *agg, const slang_variable_scope *vars,
-	slang_function_scope *funcs, slang_struct_scope *structs)
+static int aggregate_variables (slang_storage_aggregate *agg, slang_variable_scope *vars,
+	slang_function_scope *funcs, slang_struct_scope *structs, slang_variable_scope *globals)
 {
 	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))
+				vars->variables[i].array_size, funcs, structs, globals))
 			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)
+	slang_operation *array_size, slang_function_scope *funcs, slang_struct_scope *structs,
+	slang_variable_scope *vars)
 {
 	switch (spec->type)
 	{
@@ -166,7 +167,7 @@ int _slang_aggregate_variable (slang_storage_aggregate *agg, slang_type_specifie
 	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);
+		return aggregate_variables (agg, spec->_struct->fields, funcs, structs, vars);
 	case slang_spec_array:
 		{
 			slang_storage_array *arr;
@@ -185,13 +186,12 @@ int _slang_aggregate_variable (slang_storage_aggregate *agg, slang_type_specifie
 			if (arr->aggregate == NULL)
 				return 0;
 			slang_storage_aggregate_construct (arr->aggregate);
-			if (!_slang_aggregate_variable (arr->aggregate, spec->_array, NULL, funcs, structs))
+			if (!_slang_aggregate_variable (arr->aggregate, spec->_array, NULL, funcs, structs, vars))
 				return 0;
 			slang_assembly_file_construct (&file);
 			space.funcs = funcs;
 			space.structs = structs;
-			/* XXX: vars! */
-			space.vars = NULL;
+			space.vars = vars;
 			if (!_slang_assemble_operation (&file, array_size, 0, &flow, &space, &info, &stk))
 			{
 				slang_assembly_file_destruct (&file);
diff --git a/src/mesa/shader/slang/slang_storage.h b/src/mesa/shader/slang/slang_storage.h
index 77962c1986..b875ce6745 100644
--- a/src/mesa/shader/slang/slang_storage.h
+++ b/src/mesa/shader/slang/slang_storage.h
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.3
+ * Version:  6.5
  *
- * Copyright (C) 2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2005-2006  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"),
@@ -85,7 +85,8 @@ 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 *);
+	struct slang_operation_ *, struct slang_function_scope_ *, slang_struct_scope *,
+	slang_variable_scope *);
 
 /*
 	returns total size (in machine units) of the given aggregate