* \author Michal Krol
*/
-#include "imports.h"
+#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_stor_aggregate;
+ arr->type = SLANG_STORE_AGGREGATE;
arr->aggregate = NULL;
arr->length = 0;
return GL_TRUE;
{
if (arr->aggregate != NULL) {
slang_storage_aggregate_destruct(arr->aggregate);
- slang_alloc_free(arr->aggregate);
+ _slang_free(arr->aggregate);
}
}
for (i = 0; i < agg->count; i++)
slang_storage_array_destruct(agg->arrays + i);
- slang_alloc_free(agg->arrays);
+ _slang_free(agg->arrays);
}
static slang_storage_array *
{
slang_storage_array *arr = NULL;
- agg->arrays =
- (slang_storage_array *) slang_alloc_realloc(agg->arrays,
- agg->count *
- sizeof(slang_storage_array),
- (agg->count +
- 1) *
- sizeof
- (slang_storage_array));
+ 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))
static GLboolean
aggregate_matrix(slang_storage_aggregate * agg, slang_storage_type basic_type,
- GLuint dimension)
+ GLuint columns, GLuint rows)
{
slang_storage_array *arr = slang_storage_aggregate_push_new(agg);
if (arr == NULL)
return GL_FALSE;
- arr->type = slang_stor_aggregate;
- arr->length = dimension;
- arr->aggregate =
- (slang_storage_aggregate *)
- slang_alloc_malloc(sizeof(slang_storage_aggregate));
+ 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_alloc_free(arr->aggregate);
+ _slang_free(arr->aggregate);
arr->aggregate = NULL;
return GL_FALSE;
}
- if (!aggregate_vector(arr->aggregate, basic_type, dimension))
+ 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_assembly_file * file, slang_atom_pool * atoms)
+ 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, file, atoms))
+ 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_assembly_file * file, slang_atom_pool * atoms)
+ slang_atom_pool * atoms)
{
switch (spec->type) {
- case slang_spec_bool:
- return aggregate_vector(agg, slang_stor_bool, 1);
- case slang_spec_bvec2:
- return aggregate_vector(agg, slang_stor_bool, 2);
- case slang_spec_bvec3:
- return aggregate_vector(agg, slang_stor_bool, 3);
- case slang_spec_bvec4:
- return aggregate_vector(agg, slang_stor_bool, 4);
- case slang_spec_int:
- return aggregate_vector(agg, slang_stor_int, 1);
- case slang_spec_ivec2:
- return aggregate_vector(agg, slang_stor_int, 2);
- case slang_spec_ivec3:
- return aggregate_vector(agg, slang_stor_int, 3);
- case slang_spec_ivec4:
- return aggregate_vector(agg, slang_stor_int, 4);
- case slang_spec_float:
- return aggregate_vector(agg, slang_stor_float, 1);
- case slang_spec_vec2:
- return aggregate_vector(agg, slang_stor_float, 2);
- case slang_spec_vec3:
- return aggregate_vector(agg, slang_stor_float, 3);
- case slang_spec_vec4:
-#if 0 /*defined(USE_X86_ASM) || defined(SLANG_X86) */
- return aggregate_vector(agg, slang_stor_vec4, 1);
-#else
- return aggregate_vector(agg, slang_stor_float, 4);
-#endif
- case slang_spec_mat2:
- return aggregate_matrix(agg, slang_stor_float, 2);
- case slang_spec_mat3:
- return aggregate_matrix(agg, slang_stor_float, 3);
- case slang_spec_mat4:
-#if 0 /*defined(USE_X86_ASM) || defined(SLANG_X86) */
- return aggregate_vector(agg, slang_stor_vec4, 4);
-#else
- return aggregate_matrix(agg, slang_stor_float, 4);
-#endif
- case slang_spec_sampler1D:
- case slang_spec_sampler2D:
- case slang_spec_sampler3D:
- case slang_spec_samplerCube:
- case slang_spec_sampler1DShadow:
- case slang_spec_sampler2DShadow:
- return aggregate_vector(agg, slang_stor_int, 1);
- case slang_spec_struct:
+ 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, file, atoms);
- case slang_spec_array:
+ 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_stor_aggregate;
- arr->aggregate =
- (slang_storage_aggregate *)
- slang_alloc_malloc(sizeof(slang_storage_aggregate));
+ 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_alloc_free(arr->aggregate);
+ _slang_free(arr->aggregate);
arr->aggregate = NULL;
return GL_FALSE;
}
if (!_slang_aggregate_variable(arr->aggregate, spec->_array, 0,
- funcs, structs, vars, file, atoms))
+ funcs, structs, vars, atoms))
return GL_FALSE;
arr->length = array_len;
/* TODO: check if 0 < arr->length <= 65535 */
}
}
-/* _slang_sizeof_type() */
GLuint
_slang_sizeof_type(slang_storage_type type)
{
- if (type == slang_stor_aggregate)
+ if (type == SLANG_STORE_AGGREGATE)
return 0;
- if (type == slang_stor_vec4)
+ if (type == SLANG_STORE_VEC4)
return 4 * sizeof(GLfloat);
return sizeof(GLfloat);
}
-/* _slang_sizeof_aggregate() */
GLuint
_slang_sizeof_aggregate(const slang_storage_aggregate * agg)
slang_storage_array *arr = &agg->arrays[i];
GLuint element_size;
- if (arr->type == slang_stor_aggregate)
+ if (arr->type == SLANG_STORE_AGGREGATE)
element_size = _slang_sizeof_aggregate(arr->aggregate);
else
element_size = _slang_sizeof_type(arr->type);
return size;
}
-/* _slang_flatten_aggregate () */
+#if 0
GLboolean
_slang_flatten_aggregate(slang_storage_aggregate * flat,
const slang_storage_aggregate * agg)
GLuint j;
for (j = 0; j < agg->arrays[i].length; j++) {
- if (agg->arrays[i].type == slang_stor_aggregate) {
+ if (agg->arrays[i].type == SLANG_STORE_AGGREGATE) {
if (!_slang_flatten_aggregate(flat, agg->arrays[i].aggregate))
return GL_FALSE;
}
GLuint k, count;
slang_storage_type type;
- if (agg->arrays[i].type == slang_stor_vec4) {
+ if (agg->arrays[i].type == SLANG_STORE_VEC4) {
count = 4;
- type = slang_stor_float;
+ type = SLANG_STORE_FLOAT;
}
else {
count = 1;
}
return GL_TRUE;
}
+#endif