From 1bc71e32ea281077fed6f77bf4c1d63c65eb14f6 Mon Sep 17 00:00:00 2001 From: Brian Date: Fri, 2 Feb 2007 15:30:50 -0700 Subject: s/slang_assembly_typeinfo/slang_typeinfo/ --- src/mesa/shader/slang/slang_codegen.c | 26 +++++++++--------- src/mesa/shader/slang/slang_compile_operation.h | 2 +- src/mesa/shader/slang/slang_simplify.c | 14 +++++----- src/mesa/shader/slang/slang_typeinfo.c | 36 ++++++++++++------------- src/mesa/shader/slang/slang_typeinfo.h | 12 ++++----- 5 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/mesa/shader/slang/slang_codegen.c b/src/mesa/shader/slang/slang_codegen.c index d972118de6..295292e076 100644 --- a/src/mesa/shader/slang/slang_codegen.c +++ b/src/mesa/shader/slang/slang_codegen.c @@ -1284,20 +1284,20 @@ _slang_locate_function(const slang_function_scope * funcs, slang_atom a_name, /* compare parameter / argument types */ for (j = 0; j < num_args; j++) { - slang_assembly_typeinfo ti; + slang_typeinfo ti; - if (!slang_assembly_typeinfo_construct(&ti)) + if (!slang_typeinfo_construct(&ti)) return NULL; if (!_slang_typeof_operation_(&args[j], space, &ti, atoms)) { - slang_assembly_typeinfo_destruct(&ti); + slang_typeinfo_destruct(&ti); return NULL; } if (!slang_type_specifier_equal(&ti.spec, &f->parameters->variables[j/* + haveRetValue*/]->type.specifier)) { - slang_assembly_typeinfo_destruct(&ti); + slang_typeinfo_destruct(&ti); break; } - slang_assembly_typeinfo_destruct(&ti); + slang_typeinfo_destruct(&ti); /* "out" and "inout" formal parameter requires the actual parameter to be l-value */ if (!ti.can_be_referenced && @@ -1667,14 +1667,14 @@ _slang_gen_select(slang_assemble_ctx *A, slang_operation *oper) slang_ir_node *altLab, *endLab; slang_ir_node *tree, *tmpDecl, *tmpVar, *cond, *cjump, *jump; slang_ir_node *bodx, *body, *assignx, *assigny; - slang_assembly_typeinfo type; + slang_typeinfo type; int size; assert(oper->type == slang_oper_select); assert(oper->num_children == 3); /* size of x or y's type */ - slang_assembly_typeinfo_construct(&type); + slang_typeinfo_construct(&type); _slang_typeof_operation(A, &oper->children[1], &type); size = _slang_sizeof_type_specifier(&type.spec); assert(size > 0); @@ -2110,9 +2110,9 @@ _slang_gen_assignment(slang_assemble_ctx * A, slang_operation *oper) static slang_ir_node * _slang_gen_field(slang_assemble_ctx * A, slang_operation *oper) { - slang_assembly_typeinfo ti; + slang_typeinfo ti; - slang_assembly_typeinfo_construct(&ti); + slang_typeinfo_construct(&ti); _slang_typeof_operation(A, &oper->children[0], &ti); if (_slang_type_is_vector(ti.spec.type)) { @@ -2167,10 +2167,10 @@ _slang_gen_field(slang_assemble_ctx * A, slang_operation *oper) static slang_ir_node * _slang_gen_subscript(slang_assemble_ctx * A, slang_operation *oper) { - slang_assembly_typeinfo array_ti; + slang_typeinfo array_ti; /* get array's type info */ - slang_assembly_typeinfo_construct(&array_ti); + slang_typeinfo_construct(&array_ti); _slang_typeof_operation(A, &oper->children[0], &array_ti); if (_slang_type_is_vector(array_ti.spec.type)) { @@ -2201,12 +2201,12 @@ _slang_gen_subscript(slang_assemble_ctx * A, slang_operation *oper) } else { /* conventional array */ - slang_assembly_typeinfo elem_ti; + slang_typeinfo elem_ti; slang_ir_node *elem, *array, *index; GLint elemSize; /* size of array element */ - slang_assembly_typeinfo_construct(&elem_ti); + slang_typeinfo_construct(&elem_ti); _slang_typeof_operation(A, oper, &elem_ti); elemSize = _slang_sizeof_type_specifier(&elem_ti.spec); assert(elemSize >= 1); diff --git a/src/mesa/shader/slang/slang_compile_operation.h b/src/mesa/shader/slang/slang_compile_operation.h index ad52b6690d..0ce9bbad81 100644 --- a/src/mesa/shader/slang/slang_compile_operation.h +++ b/src/mesa/shader/slang/slang_compile_operation.h @@ -122,7 +122,7 @@ typedef struct slang_operation_ struct slang_function_ *fun; /**< If type == slang_oper_call */ struct slang_variable_ *var; /**< If type == slang_oper_identier */ slang_fully_specified_type *datatype; /**< Type of this operation */ - slang_assembly_typeinfo ti; + slang_typeinfo ti; } slang_operation; diff --git a/src/mesa/shader/slang/slang_simplify.c b/src/mesa/shader/slang/slang_simplify.c index bf6afe4532..ef8b2fedd8 100644 --- a/src/mesa/shader/slang/slang_simplify.c +++ b/src/mesa/shader/slang/slang_simplify.c @@ -294,15 +294,15 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun, * into individual floats/ints and try to match the function params. */ for (i = 0; i < numParams; i++) { - slang_assembly_typeinfo argType; + slang_typeinfo argType; GLint argSz, j; /* Get type of arg[i] */ - if (!slang_assembly_typeinfo_construct(&argType)) + if (!slang_typeinfo_construct(&argType)) return GL_FALSE; if (!_slang_typeof_operation_(&callOper->children[i], space, &argType, atoms)) { - slang_assembly_typeinfo_destruct(&argType); + slang_typeinfo_destruct(&argType); return GL_FALSE; } @@ -369,15 +369,15 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun, * x = foo(int(3.15), bool(9)) */ for (i = 0; i < numParams; i++) { - slang_assembly_typeinfo argType; + slang_typeinfo argType; slang_variable *paramVar = fun->parameters->variables[i]; /* Get type of arg[i] */ - if (!slang_assembly_typeinfo_construct(&argType)) + if (!slang_typeinfo_construct(&argType)) return GL_FALSE; if (!_slang_typeof_operation_(&callOper->children[i], space, &argType, atoms)) { - slang_assembly_typeinfo_destruct(&argType); + slang_typeinfo_destruct(&argType); return GL_FALSE; } @@ -398,7 +398,7 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun, callOper->children[i].children = child; } - slang_assembly_typeinfo_destruct(&argType); + slang_typeinfo_destruct(&argType); } if (dbg) { diff --git a/src/mesa/shader/slang/slang_typeinfo.c b/src/mesa/shader/slang/slang_typeinfo.c index d48113a14a..cfed54276d 100644 --- a/src/mesa/shader/slang/slang_typeinfo.c +++ b/src/mesa/shader/slang/slang_typeinfo.c @@ -230,7 +230,7 @@ slang_type_specifier_equal(const slang_type_specifier * x, GLboolean -slang_assembly_typeinfo_construct(slang_assembly_typeinfo * ti) +slang_typeinfo_construct(slang_typeinfo * ti) { slang_type_specifier_ctr(&ti->spec); ti->array_len = 0; @@ -238,7 +238,7 @@ slang_assembly_typeinfo_construct(slang_assembly_typeinfo * ti) } GLvoid -slang_assembly_typeinfo_destruct(slang_assembly_typeinfo * ti) +slang_typeinfo_destruct(slang_typeinfo * ti) { slang_type_specifier_dtr(&ti->spec); } @@ -274,7 +274,7 @@ typeof_existing_function(const char *name, const slang_operation * params, GLboolean _slang_typeof_operation(const slang_assemble_ctx * A, const slang_operation * op, - slang_assembly_typeinfo * ti) + slang_typeinfo * ti) { return _slang_typeof_operation_(op, &A->space, ti, A->atoms); } @@ -291,7 +291,7 @@ _slang_typeof_operation(const slang_assemble_ctx * A, GLboolean _slang_typeof_operation_(const slang_operation * op, const slang_name_space * space, - slang_assembly_typeinfo * ti, + slang_typeinfo * ti, slang_atom_pool * atoms) { ti->can_be_referenced = GL_FALSE; @@ -415,30 +415,30 @@ _slang_typeof_operation_(const slang_operation * op, /*case slang_oper_complement: */ case slang_oper_subscript: { - slang_assembly_typeinfo _ti; + slang_typeinfo _ti; - if (!slang_assembly_typeinfo_construct(&_ti)) + if (!slang_typeinfo_construct(&_ti)) RETURN_NIL(); if (!_slang_typeof_operation_(op->children, space, &_ti, atoms)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_NIL(); } ti->can_be_referenced = _ti.can_be_referenced; if (_ti.spec.type == slang_spec_array) { if (!slang_type_specifier_copy(&ti->spec, _ti.spec._array)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_NIL(); } } else { if (!_slang_type_is_vector(_ti.spec.type) && !_slang_type_is_matrix(_ti.spec.type)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_ERROR("cannot index a non-array type", 0); } ti->spec.type = _slang_type_base(_ti.spec.type); } - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); } break; case slang_oper_call: @@ -480,12 +480,12 @@ _slang_typeof_operation_(const slang_operation * op, break; case slang_oper_field: { - slang_assembly_typeinfo _ti; + slang_typeinfo _ti; - if (!slang_assembly_typeinfo_construct(&_ti)) + if (!slang_typeinfo_construct(&_ti)) RETURN_NIL(); if (!_slang_typeof_operation_(op->children, space, &_ti, atoms)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_NIL(); } if (_ti.spec.type == slang_spec_struct) { @@ -494,11 +494,11 @@ _slang_typeof_operation_(const slang_operation * op, field = _slang_locate_variable(_ti.spec._struct->fields, op->a_id, GL_FALSE); if (field == NULL) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_NIL(); } if (!slang_type_specifier_copy(&ti->spec, &field->type.specifier)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_NIL(); } ti->can_be_referenced = _ti.can_be_referenced; @@ -511,14 +511,14 @@ _slang_typeof_operation_(const slang_operation * op, /* determine the swizzle of the field expression */ #if 000 if (!_slang_type_is_vector(_ti.spec.type)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_ERROR("Can't swizzle scalar expression", 0); } #endif rows = _slang_type_dim(_ti.spec.type); swizzle = slang_atom_pool_id(atoms, op->a_id); if (!_slang_is_swizzle(swizzle, rows, &ti->swz)) { - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); RETURN_ERROR("Bad swizzle", 0); } ti->is_swizzled = GL_TRUE; @@ -585,7 +585,7 @@ _slang_typeof_operation_(const slang_operation * op, break; } } - slang_assembly_typeinfo_destruct(&_ti); + slang_typeinfo_destruct(&_ti); } break; case slang_oper_postincrement: diff --git a/src/mesa/shader/slang/slang_typeinfo.h b/src/mesa/shader/slang/slang_typeinfo.h index 267f9abe7b..71ed9b7a53 100644 --- a/src/mesa/shader/slang/slang_typeinfo.h +++ b/src/mesa/shader/slang/slang_typeinfo.h @@ -143,20 +143,20 @@ slang_type_specifier_equal(const slang_type_specifier *, const slang_type_specifier *); -typedef struct slang_assembly_typeinfo_ +typedef struct slang_typeinfo_ { GLboolean can_be_referenced; GLboolean is_swizzled; slang_swizzle swz; slang_type_specifier spec; GLuint array_len; -} slang_assembly_typeinfo; +} slang_typeinfo; extern GLboolean -slang_assembly_typeinfo_construct(slang_assembly_typeinfo *); +slang_typeinfo_construct(slang_typeinfo *); extern GLvoid -slang_assembly_typeinfo_destruct(slang_assembly_typeinfo *); +slang_typeinfo_destruct(slang_typeinfo *); /** @@ -167,12 +167,12 @@ slang_assembly_typeinfo_destruct(slang_assembly_typeinfo *); extern GLboolean _slang_typeof_operation(const slang_assemble_ctx *, const struct slang_operation_ *, - slang_assembly_typeinfo *); + slang_typeinfo *); extern GLboolean _slang_typeof_operation_(const struct slang_operation_ *, const slang_name_space *, - slang_assembly_typeinfo *, slang_atom_pool *); + slang_typeinfo *, slang_atom_pool *); /** * Retrieves type of a function prototype, if one exists. -- cgit v1.2.3