summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorMichal Krol <mjkrol@gmail.org>2006-01-30 14:48:42 +0000
committerMichal Krol <mjkrol@gmail.org>2006-01-30 14:48:42 +0000
commit9dc8bce88e84322171e16be190f2e430dee986ac (patch)
treeb9cdc26a56e1eb7847d457e8c91c498538838d4b /src
parentb2006a40eb22899d38cd31691640555228e36975 (diff)
Split slang_compile.c into several smaller files - it was just too big.
Minor fixes and cosmetic changes.
Diffstat (limited to 'src')
-rw-r--r--src/mesa/shader/slang/slang_assemble.c13
-rw-r--r--src/mesa/shader/slang/slang_assemble_assignment.c6
-rw-r--r--src/mesa/shader/slang/slang_assemble_constructor.c10
-rw-r--r--src/mesa/shader/slang/slang_assemble_typeinfo.c6
-rw-r--r--src/mesa/shader/slang/slang_compile.c1230
-rw-r--r--src/mesa/shader/slang/slang_compile.h227
-rw-r--r--src/mesa/shader/slang/slang_compile_function.c133
-rw-r--r--src/mesa/shader/slang/slang_compile_function.h69
-rw-r--r--src/mesa/shader/slang/slang_compile_operation.c115
-rw-r--r--src/mesa/shader/slang/slang_compile_operation.h117
-rw-r--r--src/mesa/shader/slang/slang_compile_struct.c191
-rw-r--r--src/mesa/shader/slang/slang_compile_struct.h61
-rw-r--r--src/mesa/shader/slang/slang_compile_variable.c371
-rw-r--r--src/mesa/shader/slang/slang_compile_variable.h129
-rw-r--r--src/mesa/shader/slang/slang_storage.c20
-rw-r--r--src/mesa/shader/slang/slang_storage.h7
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