summaryrefslogtreecommitdiff
path: root/src/mesa/shader/slang/slang_compile.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa/shader/slang/slang_compile.c')
-rw-r--r--src/mesa/shader/slang/slang_compile.c1230
1 files changed, 401 insertions, 829 deletions
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]);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-20 11:42:44 +0000