ast_function: Move error return earlier and don't indent the world.

This has no functional changes.

diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp
index c6cc3eb..566eac4 100644 (file)
--- a/src/glsl/ast_function.cpp
+++ b/src/glsl/ast_function.cpp
@@ -865,7 +865,7 @@ ast_function_expression::hir(exec_list *instructions,
    void *ctx = state;
    /* There are three sorts of function calls.
     *
-    * 1. contstructors - The first subexpression is an ast_type_specifier.
+    * 1. constructors - The first subexpression is an ast_type_specifier.
     * 2. methods - Only the .length() method of array types.
     * 3. functions - Calls to regular old functions.
     *
@@ -907,167 +907,164 @@ ast_function_expression::hir(exec_list *instructions,
        * correct order.  These constructors follow essentially the same type
        * matching rules as functions.
        */
-      if (constructor_type->is_numeric() || constructor_type->is_boolean()) {
-        /* Total number of components of the type being constructed.
-         */
-        const unsigned type_components = constructor_type->components();
+      if (!constructor_type->is_numeric() && !constructor_type->is_boolean())
+        return ir_call::get_error_instruction(ctx);
 
-        /* Number of components from parameters that have actually been
-         * consumed.  This is used to perform several kinds of error checking.
-         */
-        unsigned components_used = 0;
-
-        unsigned matrix_parameters = 0;
-        unsigned nonmatrix_parameters = 0;
-        exec_list actual_parameters;
-
-        bool all_parameters_are_constant = true;
-
-        foreach_list (n, &this->expressions) {
-           ast_node *ast = exec_node_data(ast_node, n, link);
-           ir_rvalue *result =
-              ast->hir(instructions, state)->as_rvalue();
-
-           /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
-            *
-            *    "It is an error to provide extra arguments beyond this
-            *    last used argument."
-            */
-           if (components_used >= type_components) {
-              _mesa_glsl_error(& loc, state, "too many parameters to `%s' "
-                               "constructor",
-                               constructor_type->name);
-              return ir_call::get_error_instruction(ctx);
-           }
+      /* Total number of components of the type being constructed. */
+      const unsigned type_components = constructor_type->components();
 
-           if (!result->type->is_numeric() && !result->type->is_boolean()) {
-              _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
-                               "non-numeric data type",
-                               constructor_type->name);
-              return ir_call::get_error_instruction(ctx);
-           }
+      /* Number of components from parameters that have actually been
+       * consumed.  This is used to perform several kinds of error checking.
+       */
+      unsigned components_used = 0;
 
-           /* Count the number of matrix and nonmatrix parameters.  This
-            * is used below to enforce some of the constructor rules.
-            */
-           if (result->type->is_matrix())
-              matrix_parameters++;
-           else
-              nonmatrix_parameters++;
-
-           /* Type cast the parameter and add it to the parameter list for
-            * the constructor.
-            */
-           const glsl_type *desired_type =
-              glsl_type::get_instance(constructor_type->base_type,
-                                      result->type->vector_elements,
-                                      result->type->matrix_columns);
-           result = convert_component(result, desired_type);
-
-           /* Attempt to convert the parameter to a constant valued expression.
-            * After doing so, track whether or not all the parameters to the
-            * constructor are trivially constant valued expressions.
-            */
-           ir_rvalue *const constant = result->constant_expression_value();
-
-           if (constant != NULL)
-              result = constant;
-           else
-              all_parameters_are_constant = false;
-
-           actual_parameters.push_tail(result);
-           components_used += result->type->components();
-        }
+      unsigned matrix_parameters = 0;
+      unsigned nonmatrix_parameters = 0;
+      exec_list actual_parameters;
 
-        /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
-         *
-         *    "It is an error to construct matrices from other matrices. This
-         *    is reserved for future use."
-         */
-        if ((state->language_version <= 110) && (matrix_parameters > 0)
-            && constructor_type->is_matrix()) {
-           _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
-                            "matrix in GLSL 1.10",
-                            constructor_type->name);
-           return ir_call::get_error_instruction(ctx);
-        }
+      bool all_parameters_are_constant = true;
+
+      foreach_list (n, &this->expressions) {
+        ast_node *ast = exec_node_data(ast_node, n, link);
+        ir_rvalue *result = ast->hir(instructions, state)->as_rvalue();
 
         /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
          *
-         *    "If a matrix argument is given to a matrix constructor, it is
-         *    an error to have any other arguments."
+         *    "It is an error to provide extra arguments beyond this
+         *    last used argument."
          */
-        if ((matrix_parameters > 0)
-            && ((matrix_parameters + nonmatrix_parameters) > 1)
-            && constructor_type->is_matrix()) {
-           _mesa_glsl_error(& loc, state, "for matrix `%s' constructor, "
-                            "matrix must be only parameter",
+        if (components_used >= type_components) {
+           _mesa_glsl_error(& loc, state, "too many parameters to `%s' "
+                            "constructor",
                             constructor_type->name);
            return ir_call::get_error_instruction(ctx);
         }
 
-        /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
-         *
-         *    "In these cases, there must be enough components provided in the
-         *    arguments to provide an initializer for every component in the
-         *    constructed value."
-         */
-        if ((components_used < type_components) && (components_used != 1)) {
-           _mesa_glsl_error(& loc, state, "too few components to construct "
-                            "`%s'",
+        if (!result->type->is_numeric() && !result->type->is_boolean()) {
+           _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
+                            "non-numeric data type",
                             constructor_type->name);
            return ir_call::get_error_instruction(ctx);
         }
 
+        /* Count the number of matrix and nonmatrix parameters.  This
+         * is used below to enforce some of the constructor rules.
+         */
+        if (result->type->is_matrix())
+           matrix_parameters++;
+        else
+           nonmatrix_parameters++;
 
-        /* If all of the parameters are trivially constant, create a
-         * constant representing the complete collection of parameters.
+        /* Type cast the parameter and add it to the parameter list for
+         * the constructor.
          */
-        if (all_parameters_are_constant) {
-           if (components_used >= type_components)
-              return new(ctx) ir_constant(constructor_type,
-                                          & actual_parameters);
-
-           /* The above case must handle all scalar constructors.
-            */
-           assert(constructor_type->is_vector()
-                  || constructor_type->is_matrix());
-
-           /* Constructors with exactly one component are special for
-            * vectors and matrices.  For vectors it causes all elements of
-            * the vector to be filled with the value.  For matrices it
-            * causes the matrix to be filled with 0 and the diagonal to be
-            * filled with the value.
-            */
-           ir_constant_data data;
-           ir_constant *const initializer =
-              (ir_constant *) actual_parameters.head;
-           if (constructor_type->is_matrix())
-              generate_constructor_matrix(constructor_type, initializer,
-                                          &data);
-           else
-              generate_constructor_vector(constructor_type, initializer,
-                                          &data);
-
-           return new(ctx) ir_constant(constructor_type, &data);
-        } else if (constructor_type->is_scalar()) {
-           return dereference_component((ir_rvalue *) actual_parameters.head,
-                                        0);
-        } else if (constructor_type->is_vector()) {
-           return emit_inline_vector_constructor(constructor_type,
-                                                 instructions,
-                                                 &actual_parameters,
-                                                 ctx);
-        } else {
-           assert(constructor_type->is_matrix());
-           return emit_inline_matrix_constructor(constructor_type,
-                                                 instructions,
-                                                 &actual_parameters,
-                                                 ctx);
-        }
+        const glsl_type *desired_type =
+           glsl_type::get_instance(constructor_type->base_type,
+                                   result->type->vector_elements,
+                                   result->type->matrix_columns);
+        result = convert_component(result, desired_type);
+
+        /* Attempt to convert the parameter to a constant valued expression.
+         * After doing so, track whether or not all the parameters to the
+         * constructor are trivially constant valued expressions.
+         */
+        ir_rvalue *const constant = result->constant_expression_value();
+
+        if (constant != NULL)
+           result = constant;
+        else
+           all_parameters_are_constant = false;
+
+        actual_parameters.push_tail(result);
+        components_used += result->type->components();
       }
 
-      return ir_call::get_error_instruction(ctx);
+      /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
+       *
+       *    "It is an error to construct matrices from other matrices. This
+       *    is reserved for future use."
+       */
+      if ((state->language_version <= 110) && (matrix_parameters > 0)
+         && constructor_type->is_matrix()) {
+        _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
+                         "matrix in GLSL 1.10",
+                         constructor_type->name);
+        return ir_call::get_error_instruction(ctx);
+      }
+
+      /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
+       *
+       *    "If a matrix argument is given to a matrix constructor, it is
+       *    an error to have any other arguments."
+       */
+      if ((matrix_parameters > 0)
+         && ((matrix_parameters + nonmatrix_parameters) > 1)
+         && constructor_type->is_matrix()) {
+        _mesa_glsl_error(& loc, state, "for matrix `%s' constructor, "
+                         "matrix must be only parameter",
+                         constructor_type->name);
+        return ir_call::get_error_instruction(ctx);
+      }
+
+      /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
+       *
+       *    "In these cases, there must be enough components provided in the
+       *    arguments to provide an initializer for every component in the
+       *    constructed value."
+       */
+      if ((components_used < type_components) && (components_used != 1)) {
+        _mesa_glsl_error(& loc, state, "too few components to construct "
+                         "`%s'",
+                         constructor_type->name);
+        return ir_call::get_error_instruction(ctx);
+      }
+
+
+      /* If all of the parameters are trivially constant, create a
+       * constant representing the complete collection of parameters.
+       */
+      if (all_parameters_are_constant) {
+        if (components_used >= type_components)
+           return new(ctx) ir_constant(constructor_type,
+                                       & actual_parameters);
+
+        /* The above case must handle all scalar constructors.
+         */
+        assert(constructor_type->is_vector()
+               || constructor_type->is_matrix());
+
+        /* Constructors with exactly one component are special for
+         * vectors and matrices.  For vectors it causes all elements of
+         * the vector to be filled with the value.  For matrices it
+         * causes the matrix to be filled with 0 and the diagonal to be
+         * filled with the value.
+         */
+        ir_constant_data data;
+        ir_constant *const initializer =
+           (ir_constant *) actual_parameters.head;
+        if (constructor_type->is_matrix())
+           generate_constructor_matrix(constructor_type, initializer,
+                                       &data);
+        else
+           generate_constructor_vector(constructor_type, initializer,
+                                       &data);
+
+        return new(ctx) ir_constant(constructor_type, &data);
+      } else if (constructor_type->is_scalar()) {
+        return dereference_component((ir_rvalue *) actual_parameters.head,
+                                     0);
+      } else if (constructor_type->is_vector()) {
+        return emit_inline_vector_constructor(constructor_type,
+                                              instructions,
+                                              &actual_parameters,
+                                              ctx);
+      } else {
+        assert(constructor_type->is_matrix());
+        return emit_inline_matrix_constructor(constructor_type,
+                                              instructions,
+                                              &actual_parameters,
+                                              ctx);
+      }
    } else {
       const ast_expression *id = subexpressions[0];
       YYLTYPE loc = id->get_location();