-/*\r
- * Mesa 3-D graphics library\r
- * Version: 6.3\r
- *\r
- * Copyright (C) 2005 Brian Paul All Rights Reserved.\r
- *\r
- * Permission is hereby granted, free of charge, to any person obtaining a\r
- * copy of this software and associated documentation files (the "Software"),\r
- * to deal in the Software without restriction, including without limitation\r
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
- * and/or sell copies of the Software, and to permit persons to whom the\r
- * Software is furnished to do so, subject to the following conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be included\r
- * in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN\r
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
- */\r
-\r
-/**\r
- * \file slang_storage.c\r
- * slang variable storage\r
- * \author Michal Krol\r
- */\r
-\r
-#include "imports.h"\r
-#include "slang_utility.h"\r
-#include "slang_storage.h"\r
-#include "slang_assemble.h"\r
-\r
-/* slang_storage_array */\r
-\r
-void slang_storage_array_construct (slang_storage_array *arr)\r
-{\r
- arr->type = slang_stor_aggregate;\r
- arr->aggregate = NULL;\r
- arr->length = 0;\r
-}\r
-\r
-void slang_storage_array_destruct (slang_storage_array *arr)\r
-{\r
- if (arr->aggregate != NULL)\r
- {\r
- slang_storage_aggregate_destruct (arr->aggregate);\r
- slang_alloc_free (arr->aggregate);\r
- }\r
-}\r
-\r
-/* slang_storage_aggregate */\r
-\r
-void slang_storage_aggregate_construct (slang_storage_aggregate *agg)\r
-{\r
- agg->arrays = NULL;\r
- agg->count = 0;\r
-}\r
-\r
-void slang_storage_aggregate_destruct (slang_storage_aggregate *agg)\r
-{\r
- unsigned int i;\r
- for (i = 0; i < agg->count; i++)\r
- slang_storage_array_destruct (agg->arrays + i);\r
- slang_alloc_free (agg->arrays);\r
-}\r
-\r
-static slang_storage_array *slang_storage_aggregate_push_new (slang_storage_aggregate *agg)\r
-{\r
- slang_storage_array *arr = NULL;\r
- agg->arrays = (slang_storage_array *) slang_alloc_realloc (agg->arrays, agg->count * sizeof (\r
- slang_storage_array), (agg->count + 1) * sizeof (slang_storage_array));\r
- if (agg->arrays != NULL)\r
- {\r
- arr = agg->arrays + agg->count;\r
- slang_storage_array_construct (arr);\r
- agg->count++;\r
- }\r
- return arr;\r
-}\r
-\r
-/* _slang_aggregate_variable() */\r
-\r
-static int aggregate_vector (slang_storage_aggregate *agg, slang_storage_type basic_type,\r
- unsigned int row_count)\r
-{\r
- slang_storage_array *arr = slang_storage_aggregate_push_new (agg);\r
- if (arr == NULL)\r
- return 0;\r
- arr->type = basic_type;\r
- arr->length = row_count;\r
- return 1;\r
-}\r
-\r
-static int aggregate_matrix (slang_storage_aggregate *agg, slang_storage_type basic_type,\r
- unsigned int dimension)\r
-{\r
- slang_storage_array *arr = slang_storage_aggregate_push_new (agg);\r
- if (arr == NULL)\r
- return 0;\r
- arr->type = slang_stor_aggregate;\r
- arr->length = dimension;\r
- arr->aggregate = (slang_storage_aggregate *) slang_alloc_malloc (sizeof (\r
- slang_storage_aggregate));\r
- if (arr->aggregate == NULL)\r
- return 0;\r
- slang_storage_aggregate_construct (arr->aggregate);\r
- if (!aggregate_vector (arr->aggregate, basic_type, dimension))\r
- return 0;\r
- return 1;\r
-}\r
-\r
-static int aggregate_variables (slang_storage_aggregate *agg, const slang_variable_scope *vars,\r
- slang_function_scope *funcs, slang_struct_scope *structs)\r
-{\r
- unsigned int i;\r
- for (i = 0; i < vars->num_variables; i++)\r
- if (!_slang_aggregate_variable (agg, &vars->variables[i].type.specifier,\r
- vars->variables[i].array_size, funcs, structs))\r
- return 0;\r
- return 1;\r
-}\r
-\r
-int _slang_aggregate_variable (slang_storage_aggregate *agg, slang_type_specifier *spec,\r
- slang_operation *array_size, slang_function_scope *funcs, slang_struct_scope *structs)\r
-{\r
- switch (spec->type)\r
- {\r
- case slang_spec_bool:\r
- return aggregate_vector (agg, slang_stor_bool, 1);\r
- case slang_spec_bvec2:\r
- return aggregate_vector (agg, slang_stor_bool, 2);\r
- case slang_spec_bvec3:\r
- return aggregate_vector (agg, slang_stor_bool, 3);\r
- case slang_spec_bvec4:\r
- return aggregate_vector (agg, slang_stor_bool, 4);\r
- case slang_spec_int:\r
- return aggregate_vector (agg, slang_stor_int, 1);\r
- case slang_spec_ivec2:\r
- return aggregate_vector (agg, slang_stor_int, 2);\r
- case slang_spec_ivec3:\r
- return aggregate_vector (agg, slang_stor_int, 3);\r
- case slang_spec_ivec4:\r
- return aggregate_vector (agg, slang_stor_int, 4);\r
- case slang_spec_float:\r
- return aggregate_vector (agg, slang_stor_float, 1);\r
- case slang_spec_vec2:\r
- return aggregate_vector (agg, slang_stor_float, 2);\r
- case slang_spec_vec3:\r
- return aggregate_vector (agg, slang_stor_float, 3);\r
- case slang_spec_vec4:\r
- return aggregate_vector (agg, slang_stor_float, 4);\r
- case slang_spec_mat2:\r
- return aggregate_matrix (agg, slang_stor_float, 2);\r
- case slang_spec_mat3:\r
- return aggregate_matrix (agg, slang_stor_float, 3);\r
- case slang_spec_mat4:\r
- return aggregate_matrix (agg, slang_stor_float, 4);\r
- case slang_spec_sampler1D:\r
- case slang_spec_sampler2D:\r
- case slang_spec_sampler3D:\r
- case slang_spec_samplerCube:\r
- case slang_spec_sampler1DShadow:\r
- case slang_spec_sampler2DShadow:\r
- return aggregate_vector (agg, slang_stor_int, 1);\r
- case slang_spec_struct:\r
- return aggregate_variables (agg, spec->_struct->fields, funcs, structs);\r
- case slang_spec_array:\r
- {\r
- slang_storage_array *arr;\r
- slang_assembly_file file;\r
- slang_assembly_flow_control flow;\r
- slang_assembly_name_space space;\r
- slang_assembly_local_info info;\r
- slang_assembly_stack_info stk;\r
-\r
- arr = slang_storage_aggregate_push_new (agg);\r
- if (arr == NULL)\r
- return 0;\r
- arr->type = slang_stor_aggregate;\r
- arr->aggregate = (slang_storage_aggregate *) slang_alloc_malloc (sizeof (\r
- slang_storage_aggregate));\r
- if (arr->aggregate == NULL)\r
- return 0;\r
- slang_storage_aggregate_construct (arr->aggregate);\r
- if (!_slang_aggregate_variable (arr->aggregate, spec->_array, NULL, funcs, structs))\r
- return 0;\r
- slang_assembly_file_construct (&file);\r
- space.funcs = funcs;\r
- space.structs = structs;\r
- /* XXX: vars! */\r
- space.vars = NULL;\r
- if (!_slang_assemble_operation (&file, array_size, 0, &flow, &space, &info, &stk))\r
- {\r
- slang_assembly_file_destruct (&file);\r
- return 0;\r
- }\r
- /* TODO: evaluate array size */\r
- slang_assembly_file_destruct (&file);\r
- arr->length = 256;\r
- }\r
- return 1;\r
- default:\r
- return 0;\r
- }\r
-}\r
-\r
-/* _slang_sizeof_aggregate() */\r
-\r
-unsigned int _slang_sizeof_aggregate (const slang_storage_aggregate *agg)\r
-{\r
- unsigned int i, size = 0;\r
- for (i = 0; i < agg->count; i++)\r
- {\r
- unsigned int element_size;\r
- if (agg->arrays[i].type == slang_stor_aggregate)\r
- element_size = _slang_sizeof_aggregate (agg->arrays[i].aggregate);\r
- else\r
- element_size = sizeof (GLfloat);\r
- size += element_size * agg->arrays[i].length;\r
- }\r
- return size;\r
-}\r
-\r
-/* _slang_flatten_aggregate () */\r
-\r
-int _slang_flatten_aggregate (slang_storage_aggregate *flat, const slang_storage_aggregate *agg)\r
-{\r
- unsigned int i;\r
- for (i = 0; i < agg->count; i++)\r
- {\r
- unsigned int j;\r
- for (j = 0; j < agg->arrays[i].length; j++)\r
- {\r
- if (agg->arrays[i].type == slang_stor_aggregate)\r
- {\r
- if (!_slang_flatten_aggregate (flat, agg->arrays[i].aggregate))\r
- return 0;\r
- }\r
- else\r
- {\r
- slang_storage_array *arr;\r
- arr = slang_storage_aggregate_push_new (flat);\r
- if (arr == NULL)\r
- return 0;\r
- arr->type = agg->arrays[i].type;\r
- arr->length = 1;\r
- }\r
- }\r
- }\r
- return 1;\r
-}\r
-\r
+/*
+ * Mesa 3-D graphics library
+ * Version: 6.5
+ *
+ * Copyright (C) 2005-2006 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file slang_storage.c
+ * slang variable storage
+ * \author Michal Krol
+ */
+
+#include "main/imports.h"
+#include "slang_storage.h"
+#include "slang_mem.h"
+
+/* slang_storage_array */
+
+GLboolean
+slang_storage_array_construct(slang_storage_array * arr)
+{
+ arr->type = SLANG_STORE_AGGREGATE;
+ arr->aggregate = NULL;
+ arr->length = 0;
+ return GL_TRUE;
+}
+
+GLvoid
+slang_storage_array_destruct(slang_storage_array * arr)
+{
+ if (arr->aggregate != NULL) {
+ slang_storage_aggregate_destruct(arr->aggregate);
+ _slang_free(arr->aggregate);
+ }
+}
+
+/* slang_storage_aggregate */
+
+GLboolean
+slang_storage_aggregate_construct(slang_storage_aggregate * agg)
+{
+ agg->arrays = NULL;
+ agg->count = 0;
+ return GL_TRUE;
+}
+
+GLvoid
+slang_storage_aggregate_destruct(slang_storage_aggregate * agg)
+{
+ GLuint i;
+
+ for (i = 0; i < agg->count; i++)
+ slang_storage_array_destruct(agg->arrays + i);
+ _slang_free(agg->arrays);
+}
+
+static slang_storage_array *
+slang_storage_aggregate_push_new(slang_storage_aggregate * agg)
+{
+ slang_storage_array *arr = NULL;
+
+ agg->arrays = (slang_storage_array *)
+ _slang_realloc(agg->arrays,
+ agg->count * sizeof(slang_storage_array),
+ (agg->count + 1) * sizeof(slang_storage_array));
+ if (agg->arrays != NULL) {
+ arr = agg->arrays + agg->count;
+ if (!slang_storage_array_construct(arr))
+ return NULL;
+ agg->count++;
+ }
+ return arr;
+}
+
+/* _slang_aggregate_variable() */
+
+static GLboolean
+aggregate_vector(slang_storage_aggregate * agg, slang_storage_type basic_type,
+ GLuint row_count)
+{
+ slang_storage_array *arr = slang_storage_aggregate_push_new(agg);
+ if (arr == NULL)
+ return GL_FALSE;
+ arr->type = basic_type;
+ arr->length = row_count;
+ return GL_TRUE;
+}
+
+static GLboolean
+aggregate_matrix(slang_storage_aggregate * agg, slang_storage_type basic_type,
+ GLuint columns, GLuint rows)
+{
+ slang_storage_array *arr = slang_storage_aggregate_push_new(agg);
+ if (arr == NULL)
+ return GL_FALSE;
+ arr->type = SLANG_STORE_AGGREGATE;
+ arr->length = columns;
+ arr->aggregate = (slang_storage_aggregate *)
+ _slang_alloc(sizeof(slang_storage_aggregate));
+ if (arr->aggregate == NULL)
+ return GL_FALSE;
+ if (!slang_storage_aggregate_construct(arr->aggregate)) {
+ _slang_free(arr->aggregate);
+ arr->aggregate = NULL;
+ return GL_FALSE;
+ }
+ if (!aggregate_vector(arr->aggregate, basic_type, rows))
+ return GL_FALSE;
+ return GL_TRUE;
+}
+
+
+static GLboolean
+aggregate_variables(slang_storage_aggregate * agg,
+ slang_variable_scope * vars, slang_function_scope * funcs,
+ slang_struct_scope * structs,
+ slang_variable_scope * globals,
+ slang_atom_pool * atoms)
+{
+ GLuint i;
+
+ for (i = 0; i < vars->num_variables; i++)
+ if (!_slang_aggregate_variable(agg, &vars->variables[i]->type.specifier,
+ vars->variables[i]->array_len, funcs,
+ structs, globals, atoms))
+ return GL_FALSE;
+ return GL_TRUE;
+}
+
+
+GLboolean
+_slang_aggregate_variable(slang_storage_aggregate * agg,
+ slang_type_specifier * spec, GLuint array_len,
+ slang_function_scope * funcs,
+ slang_struct_scope * structs,
+ slang_variable_scope * vars,
+ slang_atom_pool * atoms)
+{
+ switch (spec->type) {
+ case SLANG_SPEC_BOOL:
+ return aggregate_vector(agg, SLANG_STORE_BOOL, 1);
+ case SLANG_SPEC_BVEC2:
+ return aggregate_vector(agg, SLANG_STORE_BOOL, 2);
+ case SLANG_SPEC_BVEC3:
+ return aggregate_vector(agg, SLANG_STORE_BOOL, 3);
+ case SLANG_SPEC_BVEC4:
+ return aggregate_vector(agg, SLANG_STORE_BOOL, 4);
+ case SLANG_SPEC_INT:
+ return aggregate_vector(agg, SLANG_STORE_INT, 1);
+ case SLANG_SPEC_IVEC2:
+ return aggregate_vector(agg, SLANG_STORE_INT, 2);
+ case SLANG_SPEC_IVEC3:
+ return aggregate_vector(agg, SLANG_STORE_INT, 3);
+ case SLANG_SPEC_IVEC4:
+ return aggregate_vector(agg, SLANG_STORE_INT, 4);
+ case SLANG_SPEC_FLOAT:
+ return aggregate_vector(agg, SLANG_STORE_FLOAT, 1);
+ case SLANG_SPEC_VEC2:
+ return aggregate_vector(agg, SLANG_STORE_FLOAT, 2);
+ case SLANG_SPEC_VEC3:
+ return aggregate_vector(agg, SLANG_STORE_FLOAT, 3);
+ case SLANG_SPEC_VEC4:
+ return aggregate_vector(agg, SLANG_STORE_FLOAT, 4);
+ case SLANG_SPEC_MAT2:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 2, 2);
+ case SLANG_SPEC_MAT3:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 3, 3);
+ case SLANG_SPEC_MAT4:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 4, 4);
+
+ case SLANG_SPEC_MAT23:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 2, 3);
+ case SLANG_SPEC_MAT32:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 3, 2);
+ case SLANG_SPEC_MAT24:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 2, 4);
+ case SLANG_SPEC_MAT42:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 4, 2);
+ case SLANG_SPEC_MAT34:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 3, 4);
+ case SLANG_SPEC_MAT43:
+ return aggregate_matrix(agg, SLANG_STORE_FLOAT, 4, 3);
+
+ case SLANG_SPEC_SAMPLER1D:
+ case SLANG_SPEC_SAMPLER2D:
+ case SLANG_SPEC_SAMPLER3D:
+ case SLANG_SPEC_SAMPLERCUBE:
+ case SLANG_SPEC_SAMPLER1DSHADOW:
+ case SLANG_SPEC_SAMPLER2DSHADOW:
+ case SLANG_SPEC_SAMPLER2DRECT:
+ case SLANG_SPEC_SAMPLER2DRECTSHADOW:
+ return aggregate_vector(agg, SLANG_STORE_INT, 1);
+ case SLANG_SPEC_STRUCT:
+ return aggregate_variables(agg, spec->_struct->fields, funcs, structs,
+ vars, atoms);
+ case SLANG_SPEC_ARRAY:
+ {
+ slang_storage_array *arr;
+
+ arr = slang_storage_aggregate_push_new(agg);
+ if (arr == NULL)
+ return GL_FALSE;
+ arr->type = SLANG_STORE_AGGREGATE;
+ arr->aggregate = (slang_storage_aggregate *)
+ _slang_alloc(sizeof(slang_storage_aggregate));
+ if (arr->aggregate == NULL)
+ return GL_FALSE;
+ if (!slang_storage_aggregate_construct(arr->aggregate)) {
+ _slang_free(arr->aggregate);
+ arr->aggregate = NULL;
+ return GL_FALSE;
+ }
+ if (!_slang_aggregate_variable(arr->aggregate, spec->_array, 0,
+ funcs, structs, vars, atoms))
+ return GL_FALSE;
+ arr->length = array_len;
+ /* TODO: check if 0 < arr->length <= 65535 */
+ }
+ return GL_TRUE;
+ default:
+ return GL_FALSE;
+ }
+}
+
+
+GLuint
+_slang_sizeof_type(slang_storage_type type)
+{
+ if (type == SLANG_STORE_AGGREGATE)
+ return 0;
+ if (type == SLANG_STORE_VEC4)
+ return 4 * sizeof(GLfloat);
+ return sizeof(GLfloat);
+}
+
+
+GLuint
+_slang_sizeof_aggregate(const slang_storage_aggregate * agg)
+{
+ GLuint i, size = 0;
+
+ for (i = 0; i < agg->count; i++) {
+ slang_storage_array *arr = &agg->arrays[i];
+ GLuint element_size;
+
+ if (arr->type == SLANG_STORE_AGGREGATE)
+ element_size = _slang_sizeof_aggregate(arr->aggregate);
+ else
+ element_size = _slang_sizeof_type(arr->type);
+ size += element_size * arr->length;
+ }
+ return size;
+}
+
+
+#if 0
+GLboolean
+_slang_flatten_aggregate(slang_storage_aggregate * flat,
+ const slang_storage_aggregate * agg)
+{
+ GLuint i;
+
+ for (i = 0; i < agg->count; i++) {
+ GLuint j;
+
+ for (j = 0; j < agg->arrays[i].length; j++) {
+ if (agg->arrays[i].type == SLANG_STORE_AGGREGATE) {
+ if (!_slang_flatten_aggregate(flat, agg->arrays[i].aggregate))
+ return GL_FALSE;
+ }
+ else {
+ GLuint k, count;
+ slang_storage_type type;
+
+ if (agg->arrays[i].type == SLANG_STORE_VEC4) {
+ count = 4;
+ type = SLANG_STORE_FLOAT;
+ }
+ else {
+ count = 1;
+ type = agg->arrays[i].type;
+ }
+
+ for (k = 0; k < count; k++) {
+ slang_storage_array *arr;
+
+ arr = slang_storage_aggregate_push_new(flat);
+ if (arr == NULL)
+ return GL_FALSE;
+ arr->type = type;
+ arr->length = 1;
+ }
+ }
+ }
+ }
+ return GL_TRUE;
+}
+#endif
projects / mesa.git / blobdiff