Get it running for ARB_vertex_shader.

Add experimental print functions to builtin library.
Some functionality missing:
- automatic arrays;
- general constructors;
- local variable initialization;
- texture sampling and noise;
- semantic error checking;
- function prototypes.

1 files changed, 39 insertions, 75 deletions

diff --git a/src/mesa/shader/slang/slang_assemble_constructor.c b/src/mesa/shader/slang/slang_assemble_constructor.c
index e62f88b591..aa2e019538 100644
--- a/src/mesa/shader/slang/slang_assemble_constructor.c
+++ b/src/mesa/shader/slang/slang_assemble_constructor.c
@@ -84,25 +84,23 @@ int _slang_is_swizzle (const char *field, unsigned int rows, slang_swizzle *swz)
 		case 'y':

 		case 'g':

 		case 't':

-			if (rows < 2)

-				return 0;

 			swz->swizzle[i] = 1;

 			break;

 		case 'z':

 		case 'b':

 		case 'p':

-			if (rows < 3)

-				return 0;

 			swz->swizzle[i] = 2;

 			break;

 		case 'w':

 		case 'a':

 		case 'q':

-			if (rows < 4)

-				return 0;

 			swz->swizzle[i] = 3;

 			break;

 		}

+

+		/* check if the component is valid for given vector's row count */

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

+			return 0;

 	}

 

 	/* only one swizzle group can be used */

@@ -116,16 +114,18 @@ int _slang_is_swizzle (const char *field, unsigned int rows, slang_swizzle *swz)
 

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

 {

-	unsigned int c, i;

+	unsigned int i, c = 0;

 

+	/* the swizzle may not be longer than the vector dim */

 	if (swz->num_components > rows)

 		return 0;

-	c = swz->swizzle[0];

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

+

+	/* the swizzle components cannot be duplicated */

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

 	{

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

+		if ((c & (1 << swz->swizzle[i])) != 0)

 			return 0;

-		c = swz->swizzle[i];

+		c |= 1 << swz->swizzle[i];

 	}

 	return 1;

 }

@@ -136,13 +136,14 @@ void _slang_multiply_swizzles (slang_swizzle *dst, const slang_swizzle *left,
 	const slang_swizzle *right)

 {

 	unsigned int i;

+

 	dst->num_components = right->num_components;

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

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

 }

 

 /* _slang_assemble_constructor() */

-

+/*

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

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

 	slang_assembly_name_space *space, slang_assembly_local_info *info)

@@ -177,10 +178,10 @@ static int constructor_aggregate (slang_assembly_file *file, const slang_storage
 		if (arr1->type != arr2->type)

 		{

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

-		}

+/*		}

 		(*index)++;

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

-	}

+/*	}

 

 	result = 1;

 end:

@@ -192,38 +193,41 @@ end1:
 	return result;

 }

 /* XXX: general swizzle! */

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

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

 	slang_assembly_flow_control *flow, slang_assembly_name_space *space,

-	slang_assembly_local_info *info)

+	slang_assembly_local_info *info, struct slang_machine_ *pmach)

 {

 	slang_assembly_typeinfo ti;

 	int result;

 	slang_storage_aggregate agg, flat;

 	unsigned int size, index, i;

 

-	slang_assembly_typeinfo_construct (&ti);

+	if (!slang_assembly_typeinfo_construct (&ti))

+		return 0;

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

 		goto end1;

 

-	slang_storage_aggregate_construct (&agg);

+	if (!(result = slang_storage_aggregate_construct (&agg)))

+		goto end1;

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

-			space->vars)))

+			space->vars, pmach, file)))

 		goto end2;

 

 	size = _slang_sizeof_aggregate (&agg);

 

-	slang_storage_aggregate_construct (&flat);

+	if (!(result = slang_storage_aggregate_construct (&flat)))

+		goto end2;

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

 		goto end;

 

 	index = 0;

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

 	{

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

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

 			space, info)))

 			goto end;

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

-	}

+/*	}

 

 	result = 1;

 end:

@@ -236,66 +240,34 @@ end1:
 }

 

 /* _slang_assemble_constructor_from_swizzle() */

-/* XXX: wrong */

+

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

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

 {

 	unsigned int master_rows, i;

-	switch (master_spec->type)

-	{

-	case slang_spec_bool:

-	case slang_spec_int:

-	case slang_spec_float:

-		master_rows = 1;

-		break;

-	case slang_spec_bvec2:

-	case slang_spec_ivec2:

-	case slang_spec_vec2:

-		master_rows = 2;

-		break;

-	case slang_spec_bvec3:

-	case slang_spec_ivec3:

-	case slang_spec_vec3:

-		master_rows = 3;

-		break;

-	case slang_spec_bvec4:

-	case slang_spec_ivec4:

-	case slang_spec_vec4:

-		master_rows = 4;

-		break;

-	default:

-	   break;

-	}

+

+	master_rows = _slang_type_dim (master_spec->type);

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

 	{

-		switch (master_spec->type)

+		switch (_slang_type_base (master_spec->type))

 		{

 		case slang_spec_bool:

-		case slang_spec_bvec2:

-		case slang_spec_bvec3:

-		case slang_spec_bvec4:

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

-				i * 4))

+			if (!slang_assembly_file_push_label2 (file, slang_asm_bool_copy,

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

 				return 0;

 			break;

 		case slang_spec_int:

-		case slang_spec_ivec2:

-		case slang_spec_ivec3:

-		case slang_spec_ivec4:

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

-				i * 4))

+			if (!slang_assembly_file_push_label2 (file, slang_asm_int_copy,

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

 				return 0;

 			break;

 		case slang_spec_float:

-		case slang_spec_vec2:

-		case slang_spec_vec3:

-		case slang_spec_vec4:

 			if (!slang_assembly_file_push_label2 (file, slang_asm_float_copy,

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

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

 				return 0;

 			break;

 		default:

-		      break;

+			break;

 		}

 	}

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

@@ -303,37 +275,29 @@ int _slang_assemble_constructor_from_swizzle (slang_assembly_file *file, const s
 	for (i = swz->num_components; i > 0; i--)

 	{

 		unsigned int n = i - 1;

+

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

 			return 0;

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

 			return 0;

 		if (!slang_assembly_file_push (file, slang_asm_addr_add))

 			return 0;

-		switch (master_spec->type)

+		switch (_slang_type_base (master_spec->type))

 		{

 		case slang_spec_bool:

-		case slang_spec_bvec2:

-		case slang_spec_bvec3:

-		case slang_spec_bvec4:

 			if (!slang_assembly_file_push (file, slang_asm_bool_deref))

 				return 0;

 			break;

 		case slang_spec_int:

-		case slang_spec_ivec2:

-		case slang_spec_ivec3:

-		case slang_spec_ivec4:

 			if (!slang_assembly_file_push (file, slang_asm_int_deref))

 				return 0;

 			break;

 		case slang_spec_float:

-		case slang_spec_vec2:

-		case slang_spec_vec3:

-		case slang_spec_vec4:

 			if (!slang_assembly_file_push (file, slang_asm_float_deref))

 				return 0;

 			break;

 		default:

-		   break;

+			break;

 		}

 	}

 	return 1;