glsl: fix indentation, comments and line lengths in ast_function.cpp

Acked-by: Timothy Arceri <[email protected]>
Signed-off-by: Andres Gomez <[email protected]>

1 files changed, 443 insertions, 406 deletions

diff --git a/src/compiler/glsl/ast_function.cpp b/src/compiler/glsl/ast_function.cpp
index 6493c4f86b9..ea3ac87d810 100644
--- a/src/compiler/glsl/ast_function.cpp
+++ b/src/compiler/glsl/ast_function.cpp
@@ -33,8 +33,8 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type);
 
 static unsigned
 process_parameters(exec_list *instructions, exec_list *actual_parameters,
-		   exec_list *parameters,
-		   struct _mesa_glsl_parse_state *state)
+                   exec_list *parameters,
+                   struct _mesa_glsl_parse_state *state)
 {
    unsigned count = 0;
 
@@ -49,7 +49,7 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters,
 
       ir_constant *const constant = result->constant_expression_value();
       if (constant != NULL)
-	 result = constant;
+         result = constant;
 
       actual_parameters->push_tail(result);
       count++;
@@ -74,7 +74,7 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters,
  */
 char *
 prototype_string(const glsl_type *return_type, const char *name,
-		 exec_list *parameters)
+                 exec_list *parameters)
 {
    char *str = NULL;
 
@@ -146,7 +146,7 @@ verify_image_parameter(YYLTYPE *loc, _mesa_glsl_parse_state *state,
 
 static bool
 verify_first_atomic_parameter(YYLTYPE *loc, _mesa_glsl_parse_state *state,
-                                   ir_variable *var)
+                              ir_variable *var)
 {
    if (!var ||
        (!var->is_in_shader_storage_block() &&
@@ -178,9 +178,9 @@ is_atomic_function(const char *func_name)
  */
 static bool
 verify_parameter_modes(_mesa_glsl_parse_state *state,
-		       ir_function_signature *sig,
-		       exec_list &actual_ir_parameters,
-		       exec_list &actual_ast_parameters)
+                       ir_function_signature *sig,
+                       exec_list &actual_ir_parameters,
+                       exec_list &actual_ast_parameters)
 {
    exec_node *actual_ir_node  = actual_ir_parameters.get_head_raw();
    exec_node *actual_ast_node = actual_ast_parameters.get_head_raw();
@@ -192,7 +192,7 @@ verify_parameter_modes(_mesa_glsl_parse_state *state,
 
       const ir_rvalue *const actual = (ir_rvalue *) actual_ir_node;
       const ast_expression *const actual_ast =
-	 exec_node_data(ast_expression, actual_ast_node, link);
+         exec_node_data(ast_expression, actual_ast_node, link);
 
       /* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always
        * FIXME: 0:0(0).
@@ -201,18 +201,18 @@ verify_parameter_modes(_mesa_glsl_parse_state *state,
 
       /* Verify that 'const_in' parameters are ir_constants. */
       if (formal->data.mode == ir_var_const_in &&
-	  actual->ir_type != ir_type_constant) {
-	 _mesa_glsl_error(&loc, state,
-			  "parameter `in %s' must be a constant expression",
-			  formal->name);
-	 return false;
+          actual->ir_type != ir_type_constant) {
+         _mesa_glsl_error(&loc, state,
+                          "parameter `in %s' must be a constant expression",
+                          formal->name);
+         return false;
       }
 
       /* Verify that shader_in parameters are shader inputs */
       if (formal->data.must_be_shader_input) {
          const ir_rvalue *val = actual;
 
-         // GLSL 4.40 allows swizzles, while earlier GLSL versions do not.
+         /* GLSL 4.40 allows swizzles, while earlier GLSL versions do not. */
          if (val->ir_type == ir_type_swizzle) {
             if (!state->is_version(440, 0)) {
                _mesa_glsl_error(&loc, state,
@@ -239,29 +239,30 @@ verify_parameter_modes(_mesa_glsl_parse_state *state,
       /* Verify that 'out' and 'inout' actual parameters are lvalues. */
       if (formal->data.mode == ir_var_function_out
           || formal->data.mode == ir_var_function_inout) {
-	 const char *mode = NULL;
-	 switch (formal->data.mode) {
-	 case ir_var_function_out:   mode = "out";   break;
-	 case ir_var_function_inout: mode = "inout"; break;
-	 default:                    assert(false);  break;
-	 }
-
-	 /* This AST-based check catches errors like f(i++).  The IR-based
-	  * is_lvalue() is insufficient because the actual parameter at the
-	  * IR-level is just a temporary value, which is an l-value.
-	  */
-	 if (actual_ast->non_lvalue_description != NULL) {
-	    _mesa_glsl_error(&loc, state,
-			     "function parameter '%s %s' references a %s",
-			     mode, formal->name,
-			     actual_ast->non_lvalue_description);
-	    return false;
-	 }
-
-	 ir_variable *var = actual->variable_referenced();
+         const char *mode = NULL;
+         switch (formal->data.mode) {
+         case ir_var_function_out:   mode = "out";   break;
+         case ir_var_function_inout: mode = "inout"; break;
+         default:                    assert(false);  break;
+         }
+
+         /* This AST-based check catches errors like f(i++).  The IR-based
+          * is_lvalue() is insufficient because the actual parameter at the
+          * IR-level is just a temporary value, which is an l-value.
+          */
+         if (actual_ast->non_lvalue_description != NULL) {
+            _mesa_glsl_error(&loc, state,
+                             "function parameter '%s %s' references a %s",
+                             mode, formal->name,
+                             actual_ast->non_lvalue_description);
+            return false;
+         }
+
+         ir_variable *var = actual->variable_referenced();
 
          if (var && formal->data.mode == ir_var_function_inout) {
-            if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_shader_out) &&
+            if ((var->data.mode == ir_var_auto ||
+                 var->data.mode == ir_var_shader_out) &&
                 !var->data.assigned &&
                 !is_gl_identifier(var->name)) {
                _mesa_glsl_warning(&loc, state, "`%s' used uninitialized",
@@ -269,28 +270,29 @@ verify_parameter_modes(_mesa_glsl_parse_state *state,
             }
          }
 
-	 if (var)
-	    var->data.assigned = true;
-
-	 if (var && var->data.read_only) {
-	    _mesa_glsl_error(&loc, state,
-			     "function parameter '%s %s' references the "
-			     "read-only variable '%s'",
-			     mode, formal->name,
-			     actual->variable_referenced()->name);
-	    return false;
-	 } else if (!actual->is_lvalue()) {
+         if (var)
+            var->data.assigned = true;
+
+         if (var && var->data.read_only) {
+            _mesa_glsl_error(&loc, state,
+                             "function parameter '%s %s' references the "
+                             "read-only variable '%s'",
+                             mode, formal->name,
+                             actual->variable_referenced()->name);
+            return false;
+         } else if (!actual->is_lvalue()) {
             _mesa_glsl_error(&loc, state,
                              "function parameter '%s %s' is not an lvalue",
                              mode, formal->name);
             return false;
-	 }
+         }
       } else {
          assert(formal->data.mode == ir_var_function_in ||
                 formal->data.mode == ir_var_const_in);
          ir_variable *var = actual->variable_referenced();
          if (var) {
-            if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_shader_out) &&
+            if ((var->data.mode == ir_var_auto ||
+                 var->data.mode == ir_var_shader_out) &&
                 !var->data.assigned &&
                 !is_gl_identifier(var->name)) {
                _mesa_glsl_warning(&loc, state, "`%s' used uninitialized",
@@ -406,8 +408,10 @@ fix_parameter(void *mem_ctx, ir_rvalue *actual, const glsl_type *formal_type,
 
    ir_rvalue *lhs = actual;
    if (expr != NULL && expr->operation == ir_binop_vector_extract) {
-      lhs = new(mem_ctx) ir_dereference_array(expr->operands[0]->clone(mem_ctx, NULL),
-                                              expr->operands[1]->clone(mem_ctx, NULL));
+      lhs = new(mem_ctx) ir_dereference_array(expr->operands[0]->clone(mem_ctx,
+                                                                       NULL),
+                                              expr->operands[1]->clone(mem_ctx,
+                                                                       NULL));
    }
 
    ir_assignment *const assignment_2 = new(mem_ctx) ir_assignment(lhs, rhs);
@@ -417,16 +421,16 @@ fix_parameter(void *mem_ctx, ir_rvalue *actual, const glsl_type *formal_type,
 /**
  * Generate a function call.
  *
- * For non-void functions, this returns a dereference of the temporary variable
- * which stores the return value for the call.  For void functions, this returns
- * NULL.
+ * For non-void functions, this returns a dereference of the temporary
+ * variable which stores the return value for the call.  For void functions,
+ * this returns NULL.
  */
 static ir_rvalue *
 generate_call(exec_list *instructions, ir_function_signature *sig,
-	      exec_list *actual_parameters,
+              exec_list *actual_parameters,
               ir_variable *sub_var,
-	      ir_rvalue *array_idx,
-	      struct _mesa_glsl_parse_state *state)
+              ir_rvalue *array_idx,
+              struct _mesa_glsl_parse_state *state)
 {
    void *ctx = state;
    exec_list post_call_conversions;
@@ -442,24 +446,24 @@ generate_call(exec_list *instructions, ir_function_signature *sig,
       ir_variable *formal = (ir_variable *) formal_node;
 
       if (formal->type->is_numeric() || formal->type->is_boolean()) {
-	 switch (formal->data.mode) {
-	 case ir_var_const_in:
-	 case ir_var_function_in: {
-	    ir_rvalue *converted
-	       = convert_component(actual, formal->type);
-	    actual->replace_with(converted);
-	    break;
-	 }
-	 case ir_var_function_out:
-	 case ir_var_function_inout:
+         switch (formal->data.mode) {
+         case ir_var_const_in:
+         case ir_var_function_in: {
+            ir_rvalue *converted
+               = convert_component(actual, formal->type);
+            actual->replace_with(converted);
+            break;
+         }
+         case ir_var_function_out:
+         case ir_var_function_inout:
             fix_parameter(ctx, actual, formal->type,
                           instructions, &post_call_conversions,
                           formal->data.mode == ir_var_function_inout);
-	    break;
-	 default:
-	    assert (!"Illegal formal parameter mode");
-	    break;
-	 }
+            break;
+         default:
+            assert (!"Illegal formal parameter mode");
+            break;
+         }
       }
    }
 
@@ -511,9 +515,10 @@ generate_call(exec_list *instructions, ir_function_signature *sig,
     * instructions; just generate an ir_constant.
     */
    if (state->is_version(120, 100)) {
-      ir_constant *value = sig->constant_expression_value(actual_parameters, NULL);
+      ir_constant *value = sig->constant_expression_value(actual_parameters,
+                                                          NULL);
       if (value != NULL) {
-	 return value;
+         return value;
       }
    }
 
@@ -534,7 +539,8 @@ generate_call(exec_list *instructions, ir_function_signature *sig,
       deref = new(ctx) ir_dereference_variable(var);
    }
 
-   ir_call *call = new(ctx) ir_call(sig, deref, actual_parameters, sub_var, array_idx);
+   ir_call *call = new(ctx) ir_call(sig, deref,
+                                    actual_parameters, sub_var, array_idx);
    instructions->push_tail(call);
 
    /* Also emit any necessary out-parameter conversions. */
@@ -548,8 +554,8 @@ generate_call(exec_list *instructions, ir_function_signature *sig,
  */
 static ir_function_signature *
 match_function_by_name(const char *name,
-		       exec_list *actual_parameters,
-		       struct _mesa_glsl_parse_state *state)
+                       exec_list *actual_parameters,
+                       struct _mesa_glsl_parse_state *state)
 {
    void *ctx = state;
    ir_function *f = state->symbols->get_function(name);
@@ -577,27 +583,29 @@ match_function_by_name(const char *name,
       sig = local_sig = f->matching_signature(state, actual_parameters,
                                               allow_builtins, &is_exact);
       if (is_exact)
-	 goto done;
+         goto done;
 
       if (!allow_builtins)
-	 goto done;
+         goto done;
    }
 
    /* Local shader has no exact candidates; check the built-ins. */
    _mesa_glsl_initialize_builtin_functions();
    sig = _mesa_glsl_find_builtin_function(state, name, actual_parameters);
 
-done:
+ done:
    if (sig != NULL) {
-      /* If the match is from a linked built-in shader, import the prototype. */
+      /* If the match is from a linked built-in shader, import the
+       * prototype.
+       */
       if (sig != local_sig) {
-	 if (f == NULL) {
-	    f = new(ctx) ir_function(name);
-	    state->symbols->add_global_function(f);
-	    emit_function(state, f);
-	 }
-	 sig = sig->clone_prototype(f, NULL);
-	 f->add_signature(sig);
+         if (f == NULL) {
+            f = new(ctx) ir_function(name);
+            state->symbols->add_global_function(f);
+            emit_function(state, f);
+         }
+         sig = sig->clone_prototype(f, NULL);
+         f->add_signature(sig);
       }
    }
    return sig;
@@ -616,7 +624,10 @@ match_subroutine_by_name(const char *name,
    ir_variable *var;
    bool is_exact = false;
 
-   new_name = ralloc_asprintf(ctx, "%s_%s", _mesa_shader_stage_to_subroutine_prefix(state->stage), name);
+   new_name =
+      ralloc_asprintf(ctx, "%s_%s",
+                      _mesa_shader_stage_to_subroutine_prefix(state->stage),
+                      name);
    var = state->symbols->get_variable(new_name);
    if (!var)
       return NULL;
@@ -633,7 +644,7 @@ match_subroutine_by_name(const char *name,
       return NULL;
    *var_r = var;
    sig = found->matching_signature(state, actual_parameters,
-                                  false, &is_exact);
+                                   false, &is_exact);
    return sig;
 }
 
@@ -649,7 +660,8 @@ generate_array_index(void *mem_ctx, exec_list *instructions,
                                                     state, loc,
                                                     array->subexpressions[0],
                                                     array->subexpressions[1],
-                                                    function_name, actual_parameters);
+                                                    function_name,
+                                                    actual_parameters);
       ir_rvalue *outer_array_idx = idx->hir(instructions, state);
 
       YYLTYPE index_loc = idx->get_location();
@@ -679,7 +691,8 @@ print_function_prototypes(_mesa_glsl_parse_state *state, YYLTYPE *loc,
       if (sig->is_builtin() && !sig->is_builtin_available(state))
          continue;
 
-      char *str = prototype_string(sig->return_type, f->name, &sig->parameters);
+      char *str = prototype_string(sig->return_type, f->name,
+                                   &sig->parameters);
       _mesa_glsl_error(loc, state, "   %s", str);
       ralloc_free(str);
    }
@@ -691,27 +704,30 @@ print_function_prototypes(_mesa_glsl_parse_state *state, YYLTYPE *loc,
  */
 static void
 no_matching_function_error(const char *name,
-			   YYLTYPE *loc,
-			   exec_list *actual_parameters,
-			   _mesa_glsl_parse_state *state)
+                           YYLTYPE *loc,
+                           exec_list *actual_parameters,
+                           _mesa_glsl_parse_state *state)
 {
    gl_shader *sh = _mesa_glsl_get_builtin_function_shader();
 
    if (state->symbols->get_function(name) == NULL
-      && (!state->uses_builtin_functions
-          || sh->symbols->get_function(name) == NULL)) {
+       && (!state->uses_builtin_functions
+           || sh->symbols->get_function(name) == NULL)) {
       _mesa_glsl_error(loc, state, "no function with name '%s'", name);
    } else {
       char *str = prototype_string(NULL, name, actual_parameters);
       _mesa_glsl_error(loc, state,
-                       "no matching function for call to `%s'; candidates are:",
+                       "no matching function for call to `%s';"
+                       " candidates are:",
                        str);
       ralloc_free(str);
 
-      print_function_prototypes(state, loc, state->symbols->get_function(name));
+      print_function_prototypes(state, loc,
+                                state->symbols->get_function(name));
 
       if (state->uses_builtin_functions) {
-         print_function_prototypes(state, loc, sh->symbols->get_function(name));
+         print_function_prototypes(state, loc,
+                                   sh->symbols->get_function(name));
       }
    }
 }
@@ -743,64 +759,66 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type)
    case GLSL_TYPE_UINT:
       switch (b) {
       case GLSL_TYPE_INT:
-	 result = new(ctx) ir_expression(ir_unop_i2u, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_i2u, src);
+         break;
       case GLSL_TYPE_FLOAT:
-	 result = new(ctx) ir_expression(ir_unop_f2u, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_f2u, src);
+         break;
       case GLSL_TYPE_BOOL:
-	 result = new(ctx) ir_expression(ir_unop_i2u,
-		  new(ctx) ir_expression(ir_unop_b2i, src));
-	 break;
+         result = new(ctx) ir_expression(ir_unop_i2u,
+                                         new(ctx) ir_expression(ir_unop_b2i,
+                                                                src));
+         break;
       case GLSL_TYPE_DOUBLE:
-	 result = new(ctx) ir_expression(ir_unop_d2u, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_d2u, src);
+         break;
       }
       break;
    case GLSL_TYPE_INT:
       switch (b) {
       case GLSL_TYPE_UINT:
-	 result = new(ctx) ir_expression(ir_unop_u2i, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_u2i, src);
+         break;
       case GLSL_TYPE_FLOAT:
-	 result = new(ctx) ir_expression(ir_unop_f2i, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_f2i, src);
+         break;
       case GLSL_TYPE_BOOL:
-	 result = new(ctx) ir_expression(ir_unop_b2i, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_b2i, src);
+         break;
       case GLSL_TYPE_DOUBLE:
-	 result = new(ctx) ir_expression(ir_unop_d2i, src);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_d2i, src);
+         break;
       }
       break;
    case GLSL_TYPE_FLOAT:
       switch (b) {
       case GLSL_TYPE_UINT:
-	 result = new(ctx) ir_expression(ir_unop_u2f, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_u2f, desired_type, src, NULL);
+         break;
       case GLSL_TYPE_INT:
-	 result = new(ctx) ir_expression(ir_unop_i2f, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_i2f, desired_type, src, NULL);
+         break;
       case GLSL_TYPE_BOOL:
-	 result = new(ctx) ir_expression(ir_unop_b2f, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_b2f, desired_type, src, NULL);
+         break;
       case GLSL_TYPE_DOUBLE:
-	 result = new(ctx) ir_expression(ir_unop_d2f, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_d2f, desired_type, src, NULL);
+         break;
       }
       break;
    case GLSL_TYPE_BOOL:
       switch (b) {
       case GLSL_TYPE_UINT:
-	 result = new(ctx) ir_expression(ir_unop_i2b,
-		  new(ctx) ir_expression(ir_unop_u2i, src));
-	 break;
+         result = new(ctx) ir_expression(ir_unop_i2b,
+                                         new(ctx) ir_expression(ir_unop_u2i,
+                                                                src));
+         break;
       case GLSL_TYPE_INT:
-	 result = new(ctx) ir_expression(ir_unop_i2b, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_i2b, desired_type, src, NULL);
+         break;
       case GLSL_TYPE_FLOAT:
-	 result = new(ctx) ir_expression(ir_unop_f2b, desired_type, src, NULL);
-	 break;
+         result = new(ctx) ir_expression(ir_unop_f2b, desired_type, src, NULL);
+         break;
       case GLSL_TYPE_DOUBLE:
          result = new(ctx) ir_expression(ir_unop_d2b, desired_type, src, NULL);
          break;
@@ -816,7 +834,8 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type)
          break;
       case GLSL_TYPE_BOOL:
          result = new(ctx) ir_expression(ir_unop_f2d,
-                  new(ctx) ir_expression(ir_unop_b2f, src));
+                                         new(ctx) ir_expression(ir_unop_b2f,
+                                                                src));
          break;
       case GLSL_TYPE_FLOAT:
          result = new(ctx) ir_expression(ir_unop_f2d, desired_type, src, NULL);
@@ -917,7 +936,8 @@ dereference_component(ir_rvalue *src, unsigned component)
       const int c = component / src->type->column_type()->vector_elements;
       const int r = component % src->type->column_type()->vector_elements;
       ir_constant *const col_index = new(ctx) ir_constant(c);
-      ir_dereference *const col = new(ctx) ir_dereference_array(src, col_index);
+      ir_dereference *const col = new(ctx) ir_dereference_array(src,
+                                                                col_index);
 
       col->type = src->type->column_type();
 
@@ -1009,15 +1029,16 @@ process_vec_mat_constructor(exec_list *instructions,
       ir_instruction *assignment = NULL;
 
       if (var->type->is_matrix()) {
-         ir_rvalue *lhs = new(ctx) ir_dereference_array(var,
-                                             new(ctx) ir_constant(i));
+         ir_rvalue *lhs =
+            new(ctx) ir_dereference_array(var, new(ctx) ir_constant(i));
          assignment = new(ctx) ir_assignment(lhs, rhs, NULL);
       } else {
          /* use writemask rather than index for vector */
          assert(var->type->is_vector());
          assert(i < 4);
          ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
-         assignment = new(ctx) ir_assignment(lhs, rhs, NULL, (unsigned)(1 << i));
+         assignment = new(ctx) ir_assignment(lhs, rhs, NULL,
+                                             (unsigned)(1 << i));
       }
 
       instructions->push_tail(assignment);
@@ -1031,9 +1052,9 @@ process_vec_mat_constructor(exec_list *instructions,
 
 static ir_rvalue *
 process_array_constructor(exec_list *instructions,
-			  const glsl_type *constructor_type,
-			  YYLTYPE *loc, exec_list *parameters,
-			  struct _mesa_glsl_parse_state *state)
+                          const glsl_type *constructor_type,
+                          YYLTYPE *loc, exec_list *parameters,
+                          struct _mesa_glsl_parse_state *state)
 {
    void *ctx = state;
    /* Array constructors come in two forms: sized and unsized.  Sized array
@@ -1067,16 +1088,16 @@ process_array_constructor(exec_list *instructions,
          ? 1 : constructor_type->length;
 
       _mesa_glsl_error(loc, state, "array constructor must have %s %u "
-		       "parameter%s",
-		       is_unsized_array ? "at least" : "exactly",
-		       min_param, (min_param <= 1) ? "" : "s");
+                       "parameter%s",
+                       is_unsized_array ? "at least" : "exactly",
+                       min_param, (min_param <= 1) ? "" : "s");
       return ir_rvalue::error_value(ctx);
    }
 
    if (is_unsized_array) {
       constructor_type =
-	 glsl_type::get_array_instance(constructor_type->fields.array,
-				       parameter_count);
+         glsl_type::get_array_instance(constructor_type->fields.array,
+                                       parameter_count);
       assert(constructor_type != NULL);
       assert(constructor_type->length == parameter_count);
    }
@@ -1128,8 +1149,8 @@ process_array_constructor(exec_list *instructions,
 
    if (constructor_type->fields.array->is_unsized_array()) {
       constructor_type =
-	 glsl_type::get_array_instance(element_type,
-				       parameter_count);
+         glsl_type::get_array_instance(element_type,
+                                       parameter_count);
       assert(constructor_type != NULL);
       assert(constructor_type->length == parameter_count);
    }
@@ -1138,13 +1159,13 @@ process_array_constructor(exec_list *instructions,
       return new(ctx) ir_constant(constructor_type, &actual_parameters);
 
    ir_variable *var = new(ctx) ir_variable(constructor_type, "array_ctor",
-					   ir_var_temporary);
+                                           ir_var_temporary);
    instructions->push_tail(var);
 
    int i = 0;
    foreach_in_list(ir_rvalue, rhs, &actual_parameters) {
       ir_rvalue *lhs = new(ctx) ir_dereference_array(var,
-						     new(ctx) ir_constant(i));
+                                                     new(ctx) ir_constant(i));
 
       ir_instruction *assignment = new(ctx) ir_assignment(lhs, rhs, NULL);
       instructions->push_tail(assignment);
@@ -1182,9 +1203,9 @@ single_scalar_parameter(exec_list *parameters)
  */
 ir_rvalue *
 emit_inline_vector_constructor(const glsl_type *type,
-			       exec_list *instructions,
-			       exec_list *parameters,
-			       void *ctx)
+                               exec_list *instructions,
+                               exec_list *parameters,
+                               void *ctx)
 {
    assert(!parameters->is_empty());
 
@@ -1208,7 +1229,7 @@ emit_inline_vector_constructor(const glsl_type *type,
    if (single_scalar_parameter(parameters)) {
       ir_rvalue *first_param = (ir_rvalue *)parameters->get_head_raw();
       ir_rvalue *rhs = new(ctx) ir_swizzle(first_param, 0, 0, 0, 0,
-					   lhs_components);
+                                           lhs_components);
       ir_dereference_variable *lhs = new(ctx) ir_dereference_variable(var);
       const unsigned mask = (1U << lhs_components) - 1;
 
@@ -1225,105 +1246,102 @@ emit_inline_vector_constructor(const glsl_type *type,
       memset(&data, 0, sizeof(data));
 
       foreach_in_list(ir_rvalue, param, parameters) {
-	 unsigned rhs_components = param->type->components();
-
-	 /* Do not try to assign more components to the vector than it has!
-	  */
-	 if ((rhs_components + base_lhs_component) > lhs_components) {
-	    rhs_components = lhs_components - base_lhs_component;
-	 }
-
-	 const ir_constant *const c = param->as_constant();
-	 if (c != NULL) {
-	    for (unsigned i = 0; i < rhs_components; i++) {
-	       switch (c->type->base_type) {
-	       case GLSL_TYPE_UINT:
-		  data.u[i + base_component] = c->get_uint_component(i);
-		  break;
-	       case GLSL_TYPE_INT:
-		  data.i[i + base_component] = c->get_int_component(i);
-		  break;
-	       case GLSL_TYPE_FLOAT:
-		  data.f[i + base_component] = c->get_float_component(i);
-		  break;
-	       case GLSL_TYPE_DOUBLE:
-		  data.d[i + base_component] = c->get_double_component(i);
-		  break;
-	       case GLSL_TYPE_BOOL:
-		  data.b[i + base_component] = c->get_bool_component(i);
-		  break;
-	       default:
-		  assert(!"Should not get here.");
-		  break;
-	       }
-	    }
-
-	    /* Mask of fields to be written in the assignment.
-	     */
-	    constant_mask |= ((1U << rhs_components) - 1) << base_lhs_component;
-	    constant_components += rhs_components;
-
-	    base_component += rhs_components;
-	 }
-	 /* Advance the component index by the number of components
-	  * that were just assigned.
-	  */
-	 base_lhs_component += rhs_components;
+         unsigned rhs_components = param->type->components();
+
+         /* Do not try to assign more components to the vector than it has! */
+         if ((rhs_components + base_lhs_component) > lhs_components) {
+            rhs_components = lhs_components - base_lhs_component;
+         }
+
+         const ir_constant *const c = param->as_constant();
+         if (c != NULL) {
+            for (unsigned i = 0; i < rhs_components; i++) {
+               switch (c->type->base_type) {
+               case GLSL_TYPE_UINT:
+                  data.u[i + base_component] = c->get_uint_component(i);
+                  break;
+               case GLSL_TYPE_INT:
+                  data.i[i + base_component] = c->get_int_component(i);
+                  break;
+               case GLSL_TYPE_FLOAT:
+                  data.f[i + base_component] = c->get_float_component(i);
+                  break;
+               case GLSL_TYPE_DOUBLE:
+                  data.d[i + base_component] = c->get_double_component(i);
+                  break;
+               case GLSL_TYPE_BOOL:
+                  data.b[i + base_component] = c->get_bool_component(i);
+                  break;
+               default:
+                  assert(!"Should not get here.");
+                  break;
+               }
+            }
+
+            /* Mask of fields to be written in the assignment. */
+            constant_mask |=
+               ((1U << rhs_components) - 1) << base_lhs_component;
+            constant_components += rhs_components;
+
+            base_component += rhs_components;
+         }
+         /* Advance the component index by the number of components
+          * that were just assigned.
+          */
+         base_lhs_component += rhs_components;
       }
 
       if (constant_mask != 0) {
-	 ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
-	 const glsl_type *rhs_type = glsl_type::get_instance(var->type->base_type,
-							     constant_components,
-							     1);
-	 ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data);
-
-	 ir_instruction *inst =
-	    new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask);
-	 instructions->push_tail(inst);
+         ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
+         const glsl_type *rhs_type =
+            glsl_type::get_instance(var->type->base_type,
+                                    constant_components,
+                                    1);
+         ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data);
+
+         ir_instruction *inst =
+            new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask);
+         instructions->push_tail(inst);
       }
 
       base_component = 0;
       foreach_in_list(ir_rvalue, param, parameters) {
-	 unsigned rhs_components = param->type->components();
-
-	 /* Do not try to assign more components to the vector than it has!
-	  */
-	 if ((rhs_components + base_component) > lhs_components) {
-	    rhs_components = lhs_components - base_component;
-	 }
-
-	 /* If we do not have any components left to copy, break out of the
-	  * loop. This can happen when initializing a vec4 with a mat3 as the
-	  * mat3 would have been broken into a series of column vectors.
-	  */
-	 if (rhs_components == 0) {
-	    break;
-	 }
-
-	 const ir_constant *const c = param->as_constant();
-	 if (c == NULL) {
-	    /* Mask of fields to be written in the assignment.
-	     */
-	    const unsigned write_mask = ((1U << rhs_components) - 1)
-	       << base_component;
-
-	    ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
-
-	    /* Generate a swizzle so that LHS and RHS sizes match.
-	     */
-	    ir_rvalue *rhs =
-	       new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components);
-
-	    ir_instruction *inst =
-	       new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
-	    instructions->push_tail(inst);
-	 }
-
-	 /* Advance the component index by the number of components that were
-	  * just assigned.
-	  */
-	 base_component += rhs_components;
+         unsigned rhs_components = param->type->components();
+
+         /* Do not try to assign more components to the vector than it has! */
+         if ((rhs_components + base_component) > lhs_components) {
+            rhs_components = lhs_components - base_component;
+         }
+
+         /* If we do not have any components left to copy, break out of the
+          * loop. This can happen when initializing a vec4 with a mat3 as the
+          * mat3 would have been broken into a series of column vectors.
+          */
+         if (rhs_components == 0) {
+            break;
+         }
+
+         const ir_constant *const c = param->as_constant();
+         if (c == NULL) {
+            /* Mask of fields to be written in the assignment. */
+            const unsigned write_mask = ((1U << rhs_components) - 1)
+               << base_component;
+
+            ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
+
+            /* Generate a swizzle so that LHS and RHS sizes match. */
+            ir_rvalue *rhs =
+               new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components);
+
+            ir_instruction *inst =
+               new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
+            instructions->push_tail(inst);
+         }
+
+         /* Advance the component index by the number of components that were
+          * just assigned.
+          */
+         base_component += rhs_components;
       }
    }
    return new(ctx) ir_dereference_variable(var);
@@ -1339,16 +1357,17 @@ emit_inline_vector_constructor(const glsl_type *type,
  * \param count     Number of components to be assigned
  *
  * \note
- * \c src_base + \c count must be less than or equal to the number of components
- * in the source vector.
+ * \c src_base + \c count must be less than or equal to the number of
+ * components in the source vector.
  */
 ir_instruction *
 assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base,
-			ir_rvalue *src, unsigned src_base, unsigned count,
-			void *mem_ctx)
+                        ir_rvalue *src, unsigned src_base, unsigned count,
+                        void *mem_ctx)
 {
    ir_constant *col_idx = new(mem_ctx) ir_constant(column);
-   ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var, col_idx);
+   ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var,
+                                                                  col_idx);
 
    assert(column_ref->type->components() >= (row_base + count));
    assert(src->type->components() >= (src_base + count));
@@ -1358,13 +1377,12 @@ assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base,
     */
    if (count < src->type->vector_elements) {
       src = new(mem_ctx) ir_swizzle(src,
-				    src_base + 0, src_base + 1,
-				    src_base + 2, src_base + 3,
-				    count);
+                                    src_base + 0, src_base + 1,
+                                    src_base + 2, src_base + 3,
+                                    count);
    }
 
-   /* Mask of fields to be written in the assignment.
-    */
+   /* Mask of fields to be written in the assignment. */
    const unsigned write_mask = ((1U << count) - 1) << row_base;
 
    return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask);
@@ -1384,9 +1402,9 @@ assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base,
  */
 ir_rvalue *
 emit_inline_matrix_constructor(const glsl_type *type,
-			       exec_list *instructions,
-			       exec_list *parameters,
-			       void *ctx)
+                               exec_list *instructions,
+                               exec_list *parameters,
+                               void *ctx)
 {
    assert(!parameters->is_empty());
 
@@ -1434,7 +1452,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
                                 NULL);
       instructions->push_tail(inst);
 
-      ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
+      ir_dereference *const rhs_ref =
+         new(ctx) ir_dereference_variable(rhs_var);
 
       inst = new(ctx) ir_assignment(rhs_ref, first_param, NULL, 0x01);
       instructions->push_tail(inst);
@@ -1456,7 +1475,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
                                          type->vector_elements);
       for (unsigned i = 0; i < cols_to_init; i++) {
          ir_constant *const col_idx = new(ctx) ir_constant(i);
-         ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx);
+         ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var,
+                                                                  col_idx);
 
          ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
          ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, rhs_swiz[i],
@@ -1468,7 +1488,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
 
       for (unsigned i = cols_to_init; i < type->matrix_columns; i++) {
          ir_constant *const col_idx = new(ctx) ir_constant(i);
-         ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx);
+         ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var,
+                                                                  col_idx);
 
          ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
          ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, 1, 1, 1, 1,
@@ -1496,9 +1517,10 @@ emit_inline_matrix_constructor(const glsl_type *type,
       if ((src_matrix->type->matrix_columns < var->type->matrix_columns) ||
           (src_matrix->type->vector_elements < var->type->vector_elements)) {
 
-         /* If the source matrix has fewer rows, every column of the destination
-          * must be initialized.  Otherwise only the columns in the destination
-          * that do not exist in the source must be initialized.
+         /* If the source matrix has fewer rows, every column of the
+          * destination must be initialized.  Otherwise only the columns in
+          * the destination that do not exist in the source must be
+          * initialized.
           */
          unsigned col =
             (src_matrix->type->vector_elements < var->type->vector_elements)
@@ -1571,7 +1593,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
           * therefore have the same type).
           *
           * It would be perfectly valid to unconditionally generate the
-          * swizzles, this this will typically result in a more compact IR tree.
+          * swizzles, this this will typically result in a more compact IR
+          * tree.
           */
          ir_rvalue *rhs;
          if (lhs->type->vector_elements != rhs_col->type->vector_elements) {
@@ -1622,10 +1645,10 @@ emit_inline_matrix_constructor(const glsl_type *type,
 
             rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var);
             ir_instruction *inst = assign_to_matrix_column(var, col_idx,
-                                                         row_idx,
-                                                         rhs_var_ref,
-                                                         rhs_base,
-                                                         count, ctx);
+                                                           row_idx,
+                                                           rhs_var_ref,
+                                                           rhs_base,
+                                                           count, ctx);
             instructions->push_tail(inst);
             rhs_base += count;
             row_idx += count;
@@ -1649,13 +1672,14 @@ emit_inline_matrix_constructor(const glsl_type *type,
 
 ir_rvalue *
 emit_inline_record_constructor(const glsl_type *type,
-			       exec_list *instructions,
-			       exec_list *parameters,
-			       void *mem_ctx)
+                               exec_list *instructions,
+                               exec_list *parameters,
+                               void *mem_ctx)
 {
    ir_variable *const var =
       new(mem_ctx) ir_variable(type, "record_ctor", ir_var_temporary);
-   ir_dereference_variable *const d = new(mem_ctx) ir_dereference_variable(var);
+   ir_dereference_variable *const d =
+      new(mem_ctx) ir_dereference_variable(var);
 
    instructions->push_tail(var);
 
@@ -1664,13 +1688,14 @@ emit_inline_record_constructor(const glsl_type *type,
       assert(!node->is_tail_sentinel());
 
       ir_dereference *const lhs =
-	 new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL),
-					    type->fields.structure[i].name);
+         new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL),
+                                            type->fields.structure[i].name);
 
       ir_rvalue *const rhs = ((ir_instruction *) node)->as_rvalue();
       assert(rhs != NULL);
 
-      ir_instruction *const assign = new(mem_ctx) ir_assignment(lhs, rhs, NULL);
+      ir_instruction *const assign =
+         new(mem_ctx) ir_assignment(lhs, rhs, NULL);
 
       instructions->push_tail(assign);
       node = node->next;
@@ -1789,12 +1814,14 @@ ast_function_expression::handle_method(exec_list *instructions,
       if (op->type->is_array()) {
          if (op->type->is_unsized_array()) {
             if (!state->has_shader_storage_buffer_objects()) {
-               _mesa_glsl_error(&loc, state, "length called on unsized array"
-                                             " only available with "
-                                             "ARB_shader_storage_buffer_object");
+               _mesa_glsl_error(&loc, state,
+                                "length called on unsized array"
+                                " only available with"
+                                " ARB_shader_storage_buffer_object");
             }
             /* Calculate length of an unsized array in run-time */
-            result = new(ctx) ir_expression(ir_unop_ssbo_unsized_array_length, op);
+            result = new(ctx) ir_expression(ir_unop_ssbo_unsized_array_length,
+                                            op);
          } else {
             result = new(ctx) ir_constant(op->type->array_size());
          }
@@ -1803,8 +1830,8 @@ ast_function_expression::handle_method(exec_list *instructions,
             /* .length() returns int. */
             result = new(ctx) ir_constant((int) op->type->vector_elements);
          } else {
-            _mesa_glsl_error(&loc, state, "length method on matrix only available"
-                             "with ARB_shading_language_420pack");
+            _mesa_glsl_error(&loc, state, "length method on matrix only"
+                             " available with ARB_shading_language_420pack");
             goto fail;
          }
       } else if (op->type->is_matrix()) {
@@ -1812,8 +1839,8 @@ ast_function_expression::handle_method(exec_list *instructions,
             /* .length() returns int. */
             result = new(ctx) ir_constant((int) op->type->matrix_columns);
          } else {
-            _mesa_glsl_error(&loc, state, "length method on matrix only available"
-                             "with ARB_shading_language_420pack");
+            _mesa_glsl_error(&loc, state, "length method on matrix only"
+                             " available with ARB_shading_language_420pack");
             goto fail;
          }
       } else {
@@ -1821,17 +1848,17 @@ ast_function_expression::handle_method(exec_list *instructions,
          goto fail;
       }
    } else {
-         _mesa_glsl_error(&loc, state, "unknown method: `%s'", method);
-         goto fail;
+      _mesa_glsl_error(&loc, state, "unknown method: `%s'", method);
+      goto fail;
    }
    return result;
-fail:
+ fail:
    return ir_rvalue::error_value(ctx);
 }
 
 ir_rvalue *
 ast_function_expression::hir(exec_list *instructions,
-			     struct _mesa_glsl_parse_state *state)
+                             struct _mesa_glsl_parse_state *state)
 {
    void *ctx = state;
    /* There are three sorts of function calls.
@@ -1842,7 +1869,8 @@ ast_function_expression::hir(exec_list *instructions,
     *
     */
    if (is_constructor()) {
-      const ast_type_specifier *type = (ast_type_specifier *) subexpressions[0];
+      const ast_type_specifier *type =
+         (ast_type_specifier *) subexpressions[0];
       YYLTYPE loc = type->get_location();
       const char *name;
 
@@ -1852,35 +1880,36 @@ ast_function_expression::hir(exec_list *instructions,
        * structure has come into scope.
        */
       if (constructor_type == NULL) {
-	 _mesa_glsl_error(& loc, state, "unknown type `%s' (structure name "
-			  "may be shadowed by a variable with the same name)",
-			  type->type_name);
-	 return ir_rvalue::error_value(ctx);
+         _mesa_glsl_error(& loc, state, "unknown type `%s' (structure name "
+                          "may be shadowed by a variable with the same name)",
+                          type->type_name);
+         return ir_rvalue::error_value(ctx);
       }
 
 
       /* Constructors for opaque types are illegal.
        */
       if (constructor_type->contains_opaque()) {
-	 _mesa_glsl_error(& loc, state, "cannot construct opaque type `%s'",
-			  constructor_type->name);
-	 return ir_rvalue::error_value(ctx);
+         _mesa_glsl_error(& loc, state, "cannot construct opaque type `%s'",
+                          constructor_type->name);
+         return ir_rvalue::error_value(ctx);
       }
 
       if (constructor_type->is_subroutine()) {
-         _mesa_glsl_error(& loc, state, "subroutine name cannot be a constructor `%s'",
+         _mesa_glsl_error(& loc, state,
+                          "subroutine name cannot be a constructor `%s'",
                           constructor_type->name);
-	 return ir_rvalue::error_value(ctx);
+         return ir_rvalue::error_value(ctx);
       }
 
       if (constructor_type->is_array()) {
          if (!state->check_version(120, 300, &loc,
                                    "array constructors forbidden")) {
-	    return ir_rvalue::error_value(ctx);
-	 }
+            return ir_rvalue::error_value(ctx);
+         }
 
-	 return process_array_constructor(instructions, constructor_type,
-					  & loc, &this->expressions, state);
+         return process_array_constructor(instructions, constructor_type,
+                                          & loc, &this->expressions, state);
       }
 
 
@@ -1905,7 +1934,7 @@ ast_function_expression::hir(exec_list *instructions,
       }
 
       if (!constructor_type->is_numeric() && !constructor_type->is_boolean())
-	 return ir_rvalue::error_value(ctx);
+         return ir_rvalue::error_value(ctx);
 
       /* Total number of components of the type being constructed. */
       const unsigned type_components = constructor_type->components();
@@ -1920,37 +1949,37 @@ ast_function_expression::hir(exec_list *instructions,
       exec_list actual_parameters;
 
       foreach_list_typed(ast_node, ast, link, &this->expressions) {
-	 ir_rvalue *result = ast->hir(instructions, state);
-
-	 /* 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_rvalue::error_value(ctx);
-	 }
-
-	 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_rvalue::error_value(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++;
-
-	 actual_parameters.push_tail(result);
-	 components_used += result->type->components();
+         ir_rvalue *result = ast->hir(instructions, state);
+
+         /* 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_rvalue::error_value(ctx);
+         }
+
+         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_rvalue::error_value(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++;
+
+         actual_parameters.push_tail(result);
+         components_used += result->type->components();
       }
 
       /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
@@ -1963,7 +1992,7 @@ ast_function_expression::hir(exec_list *instructions,
           && !state->check_version(120, 100, &loc,
                                    "cannot construct `%s' from a matrix",
                                    constructor_type->name)) {
-	 return ir_rvalue::error_value(ctx);
+         return ir_rvalue::error_value(ctx);
       }
 
       /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
@@ -1972,12 +2001,12 @@ ast_function_expression::hir(exec_list *instructions,
        *    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_rvalue::error_value(ctx);
+          && ((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_rvalue::error_value(ctx);
       }
 
       /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
@@ -1987,11 +2016,11 @@ ast_function_expression::hir(exec_list *instructions,
        *    constructed value."
        */
       if (components_used < type_components && components_used != 1
-	  && matrix_parameters == 0) {
-	 _mesa_glsl_error(& loc, state, "too few components to construct "
-			  "`%s'",
-			  constructor_type->name);
-	 return ir_rvalue::error_value(ctx);
+          && matrix_parameters == 0) {
+         _mesa_glsl_error(& loc, state, "too few components to construct "
+                          "`%s'",
+                          constructor_type->name);
+         return ir_rvalue::error_value(ctx);
       }
 
       /* Matrices can never be consumed as is by any constructor but matrix
@@ -1999,72 +2028,75 @@ ast_function_expression::hir(exec_list *instructions,
        * matrix up into a series of column vectors.
        */
       if (!constructor_type->is_matrix()) {
-	 foreach_in_list_safe(ir_rvalue, matrix, &actual_parameters) {
-	    if (!matrix->type->is_matrix())
-	       continue;
-
-	    /* Create a temporary containing the matrix. */
-	    ir_variable *var = new(ctx) ir_variable(matrix->type, "matrix_tmp",
-						    ir_var_temporary);
-	    instructions->push_tail(var);
-	    instructions->push_tail(new(ctx) ir_assignment(new(ctx)
-	       ir_dereference_variable(var), matrix, NULL));
-	    var->constant_value = matrix->constant_expression_value();
-
-	    /* Replace the matrix with dereferences of its columns. */
-	    for (int i = 0; i < matrix->type->matrix_columns; i++) {
-	       matrix->insert_before(new (ctx) ir_dereference_array(var,
-		  new(ctx) ir_constant(i)));
-	    }
-	    matrix->remove();
-	 }
+         foreach_in_list_safe(ir_rvalue, matrix, &actual_parameters) {
+            if (!matrix->type->is_matrix())
+               continue;
+
+            /* Create a temporary containing the matrix. */
+            ir_variable *var = new(ctx) ir_variable(matrix->type, "matrix_tmp",
+                                                    ir_var_temporary);
+            instructions->push_tail(var);
+            instructions->push_tail(
+               new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
+                                      matrix, NULL));
+            var->constant_value = matrix->constant_expression_value();
+
+            /* Replace the matrix with dereferences of its columns. */
+            for (int i = 0; i < matrix->type->matrix_columns; i++) {
+               matrix->insert_before(
+                  new (ctx) ir_dereference_array(var,
+                                                 new(ctx) ir_constant(i)));
+            }
+            matrix->remove();
+         }
       }
 
       bool all_parameters_are_constant = true;
 
       /* Type cast each parameter and, if possible, fold constants.*/
       foreach_in_list_safe(ir_rvalue, ir, &actual_parameters) {
-	 const glsl_type *desired_type =
-	    glsl_type::get_instance(constructor_type->base_type,
-				    ir->type->vector_elements,
-				    ir->type->matrix_columns);
-	 ir_rvalue *result = convert_component(ir, 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;
-
-	 if (result != ir) {
-	    ir->replace_with(result);
-	 }
+         const glsl_type *desired_type =
+            glsl_type::get_instance(constructor_type->base_type,
+                                    ir->type->vector_elements,
+                                    ir->type->matrix_columns);
+         ir_rvalue *result = convert_component(ir, 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;
+
+         if (result != ir) {
+            ir->replace_with(result);
+         }
       }
 
       /* If all of the parameters are trivially constant, create a
        * constant representing the complete collection of parameters.
        */
       if (all_parameters_are_constant) {
-	 return new(ctx) ir_constant(constructor_type, &actual_parameters);
+         return new(ctx) ir_constant(constructor_type, &actual_parameters);
       } else if (constructor_type->is_scalar()) {
-         return dereference_component((ir_rvalue *) actual_parameters.get_head_raw(),
-				      0);
+         return dereference_component((ir_rvalue *)
+                                      actual_parameters.get_head_raw(),
+                                      0);
       } else if (constructor_type->is_vector()) {
-	 return emit_inline_vector_constructor(constructor_type,
-					       instructions,
-					       &actual_parameters,
-					       ctx);
+         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);
+         assert(constructor_type->is_matrix());
+         return emit_inline_matrix_constructor(constructor_type,
+                                               instructions,
+                                               &actual_parameters,
+                                               ctx);
       }
    } else if (subexpressions[0]->oper == ast_field_selection) {
       return handle_method(instructions, state);
@@ -2077,7 +2109,7 @@ ast_function_expression::hir(exec_list *instructions,
       ir_rvalue *array_idx = NULL;
 
       process_parameters(instructions, &actual_parameters, &this->expressions,
-			 state);
+                         state);
 
       if (id->oper == ast_array_index) {
          array_idx = generate_array_index(ctx, instructions, state, loc,
@@ -2093,21 +2125,26 @@ ast_function_expression::hir(exec_list *instructions,
          return ir_rvalue::error_value(ctx);
 
       ir_function_signature *sig =
-	 match_function_by_name(func_name, &actual_parameters, state);
+         match_function_by_name(func_name, &actual_parameters, state);
 
       ir_rvalue *value = NULL;
       if (sig == NULL) {
-         sig = match_subroutine_by_name(func_name, &actual_parameters, state, &sub_var);
+         sig = match_subroutine_by_name(func_name, &actual_parameters,
+                                        state, &sub_var);
       }
 
       if (sig == NULL) {
-	 no_matching_function_error(func_name, &loc, &actual_parameters, state);
-	 value = ir_rvalue::error_value(ctx);
-      } else if (!verify_parameter_modes(state, sig, actual_parameters, this->expressions)) {
-	 /* an error has already been emitted */
-	 value = ir_rvalue::error_value(ctx);
+         no_matching_function_error(func_name, &loc,
+                                    &actual_parameters, state);
+         value = ir_rvalue::error_value(ctx);
+      } else if (!verify_parameter_modes(state, sig,
+                                         actual_parameters,
+                                         this->expressions)) {
+         /* an error has already been emitted */
+         value = ir_rvalue::error_value(ctx);
       } else {
-         value = generate_call(instructions, sig, &actual_parameters, sub_var, array_idx, state);
+         value = generate_call(instructions, sig,
+                               &actual_parameters, sub_var, array_idx, state);
          if (!value) {
             ir_variable *const tmp = new(ctx) ir_variable(glsl_type::void_type,
                                                           "void_var",