/*
* 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"),
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);
+*/\r
+\r
+/* slang_var_pool */\r
+\r
+static GLuint slang_var_pool_alloc (slang_var_pool *pool, unsigned int size)\r
+{\r
+ GLuint addr;\r
+\r
+ addr = pool->next_addr;\r
+ pool->next_addr += size;\r
+ return addr;\r
}
-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))\r
+ return 0;\r
+ if (!slang_function_scope_construct (&unit->functions))\r
+ {\r
+ slang_variable_scope_destruct (&unit->globals);\r
+ return 0;\r
}
+ if (!slang_struct_scope_construct (&unit->structs))\r
+ {\r
+ slang_variable_scope_destruct (&unit->globals);\r
+ slang_function_scope_destruct (&unit->functions);\r
+ return 0;\r
+ }\r
+ unit->assembly = (slang_assembly_file *) slang_alloc_malloc (sizeof (slang_assembly_file));\r
+ if (unit->assembly == NULL)\r
+ {\r
+ slang_variable_scope_destruct (&unit->globals);\r
+ slang_function_scope_destruct (&unit->functions);\r
+ slang_struct_scope_destruct (&unit->structs);\r
+ return 0;\r
+ }\r
+ slang_assembly_file_construct (unit->assembly);\r
+ unit->global_pool.next_addr = 0;\r
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);\r
+ slang_assembly_file_destruct (unit->assembly);\r
+ slang_alloc_free (unit->assembly);
}
/* slang_info_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;\r
+
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);
+ {\r
+ unsigned int text_len = slang_string_length (log->text);\r
+
+ 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;
{
const byte *I;
slang_info_log *L;
- int parsing_builtin;
-} slang_parse_ctx;
+ int parsing_builtin;\r
+ int global_scope;
+} slang_parse_ctx;\r
+\r
+/* slang_output_ctx */\r
+\r
+typedef struct slang_output_ctx_\r
+{\r
+ slang_variable_scope *vars;\r
+ slang_function_scope *funs;\r
+ slang_struct_scope *structs;\r
+ slang_assembly_file *assembly;\r
+ slang_var_pool *global_pool;\r
+} slang_output_ctx;
/* _slang_compile() */
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 *);\r
+static int parse_type_specifier (slang_parse_ctx *, slang_output_ctx *, slang_type_specifier *);\r
+\r
+/* structure field */\r
+#define FIELD_NONE 0\r
+#define FIELD_NEXT 1\r
+#define FIELD_ARRAY 2\r
+\r
+static int parse_struct_field_var (slang_parse_ctx *C, slang_output_ctx *O, slang_variable *var)\r
+{\r
+ if (!parse_identifier (C, &var->name))\r
+ return 0;\r
+ switch (*C->I++)\r
+ {\r
+ case FIELD_NONE:\r
+ break;\r
+ case FIELD_ARRAY:\r
+ var->array_size = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));\r
+ if (var->array_size == NULL)\r
+ {\r
+ slang_info_log_memory (C->L);\r
+ return 0;\r
+ }\r
+ if (!slang_operation_construct (var->array_size))\r
+ {\r
+ slang_alloc_free (var->array_size);\r
+ var->array_size = NULL;\r
+ return 0;\r
+ }\r
+ if (!parse_expression (C, O, var->array_size))\r
+ return 0;\r
+ break;\r
+ default:\r
+ return 0;\r
+ }\r
+ return 1;\r
+}\r
+\r
+static int parse_struct_field (slang_parse_ctx *C, slang_output_ctx *O, slang_struct *st,\r
+ slang_type_specifier *sp)\r
+{\r
+ slang_output_ctx o = *O;\r
+\r
+ o.structs = st->structs;\r
+ if (!parse_type_specifier (C, &o, sp))\r
+ return 0;\r
+ do\r
+ {\r
+ slang_variable *var;\r
+\r
+ st->fields->variables = (slang_variable *) slang_alloc_realloc (st->fields->variables,\r
+ st->fields->num_variables * sizeof (slang_variable),\r
+ (st->fields->num_variables + 1) * sizeof (slang_variable));\r
+ if (st->fields->variables == NULL)\r
+ {\r
+ slang_info_log_memory (C->L);\r
+ return 0;\r
+ }\r
+ var = st->fields->variables + st->fields->num_variables;\r
+ if (!slang_variable_construct (var))\r
+ return 0;\r
+ st->fields->num_variables++;\r
+ if (!slang_type_specifier_copy (&var->type.specifier, sp))\r
+ return 0;\r
+ if (!parse_struct_field_var (C, &o, var))\r
+ return 0;\r
+ }\r
+ while (*C->I++ != FIELD_NONE);\r
+ return 1;\r
+}\r
+\r
+static int parse_struct (slang_parse_ctx *C, slang_output_ctx *O, slang_struct **st)\r
+{\r
+ char *name;\r
+\r
+ if (!parse_identifier (C, &name))\r
+ return 0;\r
+ if (name[0] != '\0' && slang_struct_scope_find (O->structs, name, 0) != NULL)\r
+ {\r
+ slang_info_log_error (C->L, "%s: duplicate type name", name);\r
+ slang_alloc_free (name);\r
+ return 0;\r
+ }\r
+ *st = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));\r
+ if (*st == NULL)\r
+ {\r
+ slang_alloc_free (name);\r
+ slang_info_log_memory (C->L);\r
+ return 0;\r
+ }\r
+ if (!slang_struct_construct (*st))\r
+ {\r
+ slang_alloc_free (*st);\r
+ *st = NULL;\r
+ slang_alloc_free (name);\r
+ slang_info_log_memory (C->L);\r
+ return 0;\r
+ }\r
+ (**st).name = name;\r
+ (**st).structs->outer_scope = O->structs;\r
+\r
+ do\r
+ {\r
+ slang_type_specifier sp;\r
+\r
+ if (!slang_type_specifier_construct (&sp))\r
+ return 0;\r
+ if (!parse_struct_field (C, O, *st, &sp))\r
+ {\r
+ slang_type_specifier_destruct (&sp);\r
+ return 0;\r
+ }\r
+ }\r
+ while (*C->I++ != FIELD_NONE);\r
+\r
+ if ((**st).name != '\0')\r
+ {\r
+ slang_struct *s;\r
+\r
+ O->structs->structs = (slang_struct *) slang_alloc_realloc (O->structs->structs,\r
+ O->structs->num_structs * sizeof (slang_struct),\r
+ (O->structs->num_structs + 1) * sizeof (slang_struct));\r
+ if (O->structs->structs == NULL)\r
+ {\r
+ slang_info_log_memory (C->L);\r
+ return 0;\r
+ }\r
+ s = &O->structs->structs[O->structs->num_structs];\r
+ if (!slang_struct_construct (s))\r
+ return 0;\r
+ O->structs->num_structs++;\r
+ if (!slang_struct_copy (s, *st))\r
+ return 0;\r
+ }\r
+\r
+ return 1;\r
+}
/* type qualifier */
#define TYPE_QUALIFIER_NONE 0
#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++)
{
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;\r
+ if (!parse_struct (C, O, &spec->_struct))
+ return 0;
break;
case TYPE_SPECIFIER_TYPENAME:
spec->type = slang_spec_struct;
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);
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;
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,\r
+ 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 */
#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,\r
+ int statement)
{
oper->children = (slang_operation *) slang_alloc_realloc (oper->children,
oper->num_children * sizeof (slang_operation),
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)\r
+ {\r
+ slang_output_ctx o = *O;\r
+ o.vars = oper->locals;
+ if (!parse_child_operation (C, &o, oper, 1))
+ return 0;\r
+ }
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;\r
+
+ 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;\r
+
oper->children = (slang_operation *) slang_alloc_malloc (num_vars * sizeof (
slang_operation));
if (oper->children == NULL)
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++)
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);
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;
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;\r
+ {\r
+ slang_output_ctx o = *O;\r
+ o.vars = oper->locals;
+ if (!parse_child_operation (C, &o, oper, 1))
+ return 0;
+ if (!parse_child_operation (C, &o, oper, 1))
+ return 0;\r
+ }
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;\r
+ {\r
+ slang_output_ctx o = *O;\r
+ 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;\r
+ }
break;
default:
return 0;
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;
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:
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;
#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,\r
+ slang_variable *param)
{
slang_storage_aggregate agg;
if (!parse_type_qualifier (C, ¶m->type.qualifier))
default:
return 0;
}
- if (!parse_type_specifier (C, ¶m->type.specifier, structs, scope, funcs))
+ if (!parse_type_specifier (C, O, ¶m->type.specifier))
return 0;
if (!parse_identifier (C, ¶m->name))
return 0;
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, ¶m->type.specifier, param->array_size, funcs,
- structs))
+ if (!_slang_aggregate_variable (&agg, ¶m->type.specifier, param->array_size, O->funs,
+ O->structs, O->vars))
{
slang_storage_aggregate_destruct (&agg);
return 0;
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++)
{
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);
default:
return 0;
}\r
- func->parameters->outer_scope = scope;
+ func->parameters->outer_scope = O->vars;
while (*C->I++ == PARAMETER_NEXT)
{
func->parameters->variables = (slang_variable *) slang_alloc_realloc (
}
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,\r
+ &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)
+{\r
+ slang_output_ctx o = *O;\r
+
+ if (!parse_function_prototype (C, O, func))
return 0;
func->body = (slang_operation *) slang_alloc_malloc (sizeof (slang_operation));
if (func->body == NULL)
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;
+ }\r
+ C->global_scope = 0;\r
+ o.vars = func->parameters;
+ if (!parse_statement (C, &o, func->body))
+ return 0;\r
+ C->global_scope = 1;
return 1;
}
#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,\r
+ const slang_fully_specified_type *type)
{
slang_variable *var;
-
+\r
+ /* empty init declatator, e.g. "float ;" */\r
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;\r
+\r
+ /* 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);\r
+ O->vars->num_variables++;\r
+\r
+ /* copy the declarator qualifier type, parse the identifier */
var->type.qualifier = type->qualifier;
if (!parse_identifier (C, &var->name))
- return 0;
+ return 0;\r
+
switch (*C->I++)
{
- case VARIABLE_NONE:
+ case VARIABLE_NONE:\r
+ /* 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:\r
+ /* 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));
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:\r
+ /* 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));
if (!slang_type_specifier_copy (var->type.specifier._array, &type->specifier))
return 0;
break;
- case VARIABLE_ARRAY_EXPLICIT:
+ case VARIABLE_ARRAY_EXPLICIT:\r
+ /* an array - mark it as array, copy the specifier to the array element and\r
+ * parse the expression */
var->type.specifier.type = slang_spec_array;
var->type.specifier._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (
slang_type_specifier));
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))
+ }\r
+\r
+ /* 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;
- }
+ }\r
+ 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;
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,\r
+ 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))\r
+ 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;
}
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;
/* 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),\r
+ (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
{
/* assemble the parsed function */
if (definition)
{
- slang_assembly_file file;
slang_assembly_name_space space;
\r
- 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;
}
#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:
#define EXTERNAL_DECLARATION 2
static int parse_translation_unit (slang_parse_ctx *C, slang_translation_unit *unit)
-{
+{\r
+ slang_output_ctx o;\r
+\r
+ o.funs = &unit->functions;\r
+ o.structs = &unit->structs;\r
+ o.vars = &unit->globals;\r
+ o.assembly = unit->assembly;\r
+ o.global_pool = &unit->global_pool;\r
+
while (*C->I != EXTERNAL_NULL)
- {
- slang_function *func;
+ {\r
+ slang_function *func;\r
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:
}
C->I++;
return 1;
-}
+}\r
+\r
+#define BUILTIN_CORE 0\r
+#define BUILTIN_COMMON 1\r
+#define BUILTIN_TARGET 2\r
+#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)
/* set-up parse context */
C.I = prod;
C.L = log;
- C.parsing_builtin = builtins == NULL;
+ C.parsing_builtin = builtins == NULL;\r
+ C.global_scope = 1;
if (!check_revision (&C))
return 0;
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 */
#include "library/slang_vertex_builtin_gc.h"
};\r
\r
-int compile (grammar *id, slang_translation_unit builtin_units[3], int compiled[3],\r
+static int compile (grammar *id, slang_translation_unit *builtin_units, int *compiled,\r
const char *source, slang_translation_unit *unit, slang_unit_type type, slang_info_log *log)\r
{\r
slang_translation_unit *builtins = NULL;\r
/* if parsing user-specified shader, load built-in library */\r
if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader)\r
{\r
- if (!compile_binary (slang_core_gc, &builtin_units[0], slang_unit_fragment_builtin, log,\r
- NULL))\r
+ if (!compile_binary (slang_core_gc, &builtin_units[BUILTIN_CORE],\r
+ slang_unit_fragment_builtin, log, NULL))\r
return 0;\r
- compiled[0] = 1;\r
+ compiled[BUILTIN_CORE] = 1;\r
\r
- if (!compile_binary (slang_common_builtin_gc, &builtin_units[1],\r
+ if (!compile_binary (slang_common_builtin_gc, &builtin_units[BUILTIN_COMMON],\r
slang_unit_fragment_builtin, log, NULL))\r
return 0;\r
- compiled[1] = 1;\r
+ compiled[BUILTIN_COMMON] = 1;\r
\r
if (type == slang_unit_fragment_shader)\r
{\r
- if (!compile_binary (slang_fragment_builtin_gc, &builtin_units[2],\r
+ if (!compile_binary (slang_fragment_builtin_gc, &builtin_units[BUILTIN_TARGET],\r
slang_unit_fragment_builtin, log, NULL))\r
return 0;\r
}\r
else if (type == slang_unit_vertex_shader)\r
{\r
- if (!compile_binary (slang_vertex_builtin_gc, &builtin_units[2],\r
+ if (!compile_binary (slang_vertex_builtin_gc, &builtin_units[BUILTIN_TARGET],\r
slang_unit_vertex_builtin, log, NULL))\r
return 0;\r
}\r
- compiled[2] = 1;\r
+ compiled[BUILTIN_TARGET] = 1;\r
\r
/* disable language extensions */\r
grammar_set_reg8 (*id, (const byte *) "parsing_builtin", 0);\r
\r
return 1;\r
}
-
+\r
int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit_type type,
slang_info_log *log)
{\r
int success;
grammar id = 0;
- slang_translation_unit builtin_units[3];\r
- int compiled[3] = { 0 };
+ slang_translation_unit builtin_units[BUILTIN_TOTAL];\r
+ int compiled[BUILTIN_TOTAL] = { 0 };
success = compile (&id, builtin_units, compiled, source, unit, type, log);
{\r
int i;\r
\r
- for (i = 0; i < 3; i++)\r
+ for (i = 0; i < BUILTIN_TOTAL; i++)\r
if (compiled[i] != 0)
slang_translation_unit_destruct (&builtin_units[i]);
}\r
projects / mesa.git / commitdiff