#include "glsl_types.h"
#include "ir.h"
+void
+_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
+{
+ struct simple_node *ptr;
+
+ _mesa_glsl_initialize_variables(instructions, state);
+
+ foreach (ptr, & state->translation_unit) {
+ ((ast_node *)ptr)->hir(instructions, state);
+ }
+}
+
+
static const struct glsl_type *
arithmetic_result_type(const struct glsl_type *type_a,
const struct glsl_type *type_b,
* * The two operands are scalars. In this case the operation is
* applied, resulting in a scalar."
*/
- if (is_glsl_type_scalar(type_a) && is_glsl_type_scalar(type_b))
+ if (type_a->is_scalar() && type_b->is_scalar())
return type_a;
/* "* One operand is a scalar, and the other is a vector or matrix.
* component of the vector or matrix, resulting in the same size
* vector or matrix."
*/
- if (is_glsl_type_scalar(type_a)) {
- if (!is_glsl_type_scalar(type_b))
+ if (type_a->is_scalar()) {
+ if (!type_b->is_scalar())
return type_b;
- } else if (is_glsl_type_scalar(type_b)) {
+ } else if (type_b->is_scalar()) {
return type_a;
}
* operation is done component-wise resulting in the same size
* vector."
*/
- if (is_glsl_type_vector(type_a) && is_glsl_type_vector(type_b)) {
+ if (type_a->is_vector() && type_b->is_vector()) {
if (type_a->vector_elements == type_b->vector_elements)
return type_a;
else
* more detail how vectors and matrices are operated on."
*/
if (! multiply) {
- if (is_glsl_type_matrix(type_a) && is_glsl_type_matrix(type_b)
+ if (type_a->is_matrix() && type_b->is_matrix()
&& (type_a->vector_elements == type_b->vector_elements)
&& (type_a->matrix_rows == type_b->matrix_rows))
return type_a;
else
return glsl_error_type;
} else {
- if (is_glsl_type_matrix(type_a) && is_glsl_type_matrix(type_b)) {
+ if (type_a->is_matrix() && type_b->is_matrix()) {
if (type_a->vector_elements == type_b->matrix_rows) {
char type_name[7];
const struct glsl_type *t;
_mesa_symbol_table_find_symbol(state->symbols, 0, type_name);
return (t != NULL) ? t : glsl_error_type;
}
- } else if (is_glsl_type_matrix(type_a)) {
+ } else if (type_a->is_matrix()) {
/* A is a matrix and B is a column vector. Columns of A must match
* rows of B.
*/
if (type_a->vector_elements == type_b->vector_elements)
return type_b;
} else {
- assert(is_glsl_type_matrix(type_b));
+ assert(type_b->is_matrix());
/* A is a row vector and B is a matrix. Columns of A must match
* rows of B.
* wise to the vector, resulting in the same type as the vector. If both
* are vectors of the same size, the result is computed component-wise."
*/
- if (is_glsl_type_vector(type_a)) {
- if (!is_glsl_type_vector(type_b)
+ if (type_a->is_vector()) {
+ if (!type_b->is_vector()
|| (type_a->vector_elements == type_b->vector_elements))
return type_a;
} else
*/
if (! is_numeric_base_type(type_a->base_type)
|| ! is_numeric_base_type(type_b->base_type)
- || ! is_glsl_type_scalar(type_a)
- || ! is_glsl_type_scalar(type_b))
+ || !type_a->is_scalar()
+ || !type_b->is_scalar())
return glsl_error_type;
/* "Either the operands' types must match, or the conversions from
make_empty_list(& op_list);
switch (this->oper) {
- case ast_assign:
+ case ast_assign: {
op[0] = this->subexpressions[0]->hir(instructions, state);
op[1] = this->subexpressions[1]->hir(instructions, state);
/* FINISHME: Check that the LHS and RHS have matching types. */
/* FINISHME: For GLSL 1.10, check that the types are not arrays. */
- result = new ir_assignment(op[0], op[1], NULL);
+ ir_instruction *tmp = new ir_assignment(op[0], op[1], NULL);
+ instructions->push_tail(tmp);
+
+ result = op[0];
break;
+ }
case ast_plus:
op[0] = this->subexpressions[0]->hir(instructions, state);
*/
assert((type == glsl_error_type)
|| ((type->base_type == GLSL_TYPE_BOOL)
- && is_glsl_type_scalar(type)));
+ && type->is_scalar()));
result = new ir_expression(operations[this->oper], type,
op[0], op[1]);
break;
case ast_function_call:
- /* There are three sorts of function calls.
- *
- * 1. contstructors - The first subexpression is an ast_type_specifier.
- * 2. methods - Only the .length() method of array types.
- * 3. functions - Calls to regular old functions.
- *
- * Method calls are actually detected when the ast_field_selection
- * expression is handled.
+ /* Should *NEVER* get here. ast_function_call should always be handled
+ * by ast_function_expression::hir.
*/
-#if 0
- result = _mesa_ast_function_call_to_hir(this->subexpressions[0],
- this->subexpressions[1],
- state);
- type = result->type;
-#endif
+ assert(0);
break;
case ast_identifier: {
const char **name,
struct _mesa_glsl_parse_state *state)
{
- static const char *const type_names[] = {
- "void",
- "float",
- "int",
- "uint",
- "bool",
- "vec2",
- "vec3",
- "vec4",
- "bvec2",
- "bvec3",
- "bvec4",
- "ivec2",
- "ivec3",
- "ivec4",
- "uvec2",
- "uvec3",
- "uvec4",
- "mat2",
- "mat2x3",
- "mat2x4",
- "mat3x2",
- "mat3",
- "mat3x4",
- "mat4x2",
- "mat4x3",
- "mat4",
- "sampler1D",
- "sampler2D",
- "sampler3D",
- "samplerCube",
- "sampler1DShadow",
- "sampler2DShadow",
- "samplerCubeShadow",
- "sampler1DArray",
- "sampler2DArray",
- "sampler1DArrayShadow",
- "sampler2DArrayShadow",
- "isampler1D",
- "isampler2D",
- "isampler3D",
- "isamplerCube",
- "isampler1DArray",
- "isampler2DArray",
- "usampler1D",
- "usampler2D",
- "usampler3D",
- "usamplerCube",
- "usampler1DArray",
- "usampler2DArray",
-
- NULL, /* ast_struct */
- NULL /* ast_type_name */
- };
struct glsl_type *type;
- const char *type_name = NULL;
if (spec->type_specifier == ast_struct) {
/* FINISHME: Handle annonymous structures. */
type = NULL;
} else {
- type_name = (spec->type_specifier == ast_type_name)
- ? spec->type_name : type_names[spec->type_specifier];
-
type = (glsl_type *)
- _mesa_symbol_table_find_symbol(state->symbols, 0, type_name);
- *name = type_name;
+ _mesa_symbol_table_find_symbol(state->symbols, 0, spec->type_name);
+ *name = spec->type_name;
/* FINISHME: Handle array declarations. Note that this requires complete
* FINSIHME: handling of constant expressions.
else if (qual->attribute || qual->in
|| (qual->varying && (state->target == fragment_shader)))
var->mode = ir_var_in;
- else if (qual->out)
+ else if (qual->out || (qual->varying && (state->target == vertex_shader)))
var->mode = ir_var_out;
else if (qual->uniform)
var->mode = ir_var_uniform;
* FINISHME: complete handling of constant expressions.
*/
+ /* Apply any specified qualifiers to the parameter declaration. Note that
+ * for function parameters the default mode is 'in'.
+ */
apply_type_qualifier_to_variable(& this->type->qualifier, var, state);
+ if (var->mode == ir_var_auto)
+ var->mode = ir_var_in;
instructions->push_tail(var);
foreach_iter(exec_list_iterator, iter, parameters) {
ir_variable *const var = (ir_variable *) iter.get();
- assert(var->mode == ir_op_var_decl);
+ assert(((ir_instruction *)var)->mode == ir_op_var_decl);
iter.remove();
instructions->push_tail(var);
projects / mesa.git / blobdiff