[Mesa-dev,2/2] glsl: Fix incorrect indentation.

Submitted by Iago Toral Quiroga on April 11, 2014, 10:52 a.m.

Details

Message ID 1397213524-5412-3-git-send-email-itoral@igalia.com
State Superseded
Headers show

Not browsing as part of any series.

Commit Message

Iago Toral Quiroga April 11, 2014, 10:52 a.m.
---
 src/glsl/ast_to_hir.cpp | 1344 +++++++++++++++++++++++------------------------
 1 file changed, 668 insertions(+), 676 deletions(-)

Patch hide | download patch | download mbox

diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
index b70b628..9760534 100644
--- a/src/glsl/ast_to_hir.cpp
+++ b/src/glsl/ast_to_hir.cpp
@@ -269,7 +269,7 @@  arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
     */
    if (type_a->base_type != type_b->base_type) {
       _mesa_glsl_error(loc, state,
-		       "base type mismatch for arithmetic operator");
+                       "base type mismatch for arithmetic operator");
       return glsl_type::error_type;
    }
 
@@ -291,7 +291,7 @@  arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
     */
    if (type_a->is_scalar()) {
       if (!type_b->is_scalar())
-	 return type_b;
+         return type_b;
    } else if (type_b->is_scalar()) {
       return type_a;
    }
@@ -309,11 +309,11 @@  arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
     */
    if (type_a->is_vector() && type_b->is_vector()) {
       if (type_a == type_b) {
-	 return type_a;
+         return type_a;
       } else {
-	 _mesa_glsl_error(loc, state,
-			  "vector size mismatch for arithmetic operator");
-	 return glsl_type::error_type;
+         _mesa_glsl_error(loc, state,
+                          "vector size mismatch for arithmetic operator");
+         return glsl_type::error_type;
       }
    }
 
@@ -344,64 +344,64 @@  arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
     */
    if (! multiply) {
       if (type_a == type_b)
-	 return type_a;
+         return type_a;
    } else {
       if (type_a->is_matrix() && type_b->is_matrix()) {
-	 /* Matrix multiply.  The columns of A must match the rows of B.  Given
-	  * the other previously tested constraints, this means the vector type
-	  * of a row from A must be the same as the vector type of a column from
-	  * B.
-	  */
-	 if (type_a->row_type() == type_b->column_type()) {
-	    /* The resulting matrix has the number of columns of matrix B and
-	     * the number of rows of matrix A.  We get the row count of A by
-	     * looking at the size of a vector that makes up a column.  The
-	     * transpose (size of a row) is done for B.
-	     */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_a->column_type()->vector_elements,
-				       type_b->row_type()->vector_elements);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
+         /* Matrix multiply.  The columns of A must match the rows of B.  Given
+          * the other previously tested constraints, this means the vector type
+          * of a row from A must be the same as the vector type of a column from
+          * B.
+          */
+         if (type_a->row_type() == type_b->column_type()) {
+            /* The resulting matrix has the number of columns of matrix B and
+             * the number of rows of matrix A.  We get the row count of A by
+             * looking at the size of a vector that makes up a column.  The
+             * transpose (size of a row) is done for B.
+             */
+            const glsl_type *const type =
+               glsl_type::get_instance(type_a->base_type,
+                  type_a->column_type()->vector_elements,
+                  type_b->row_type()->vector_elements);
+            assert(type != glsl_type::error_type);
+
+            return type;
+         }
       } else if (type_a->is_matrix()) {
-	 /* A is a matrix and B is a column vector.  Columns of A must match
-	  * rows of B.  Given the other previously tested constraints, this
-	  * means the vector type of a row from A must be the same as the
-	  * vector the type of B.
-	  */
-	 if (type_a->row_type() == type_b) {
-	    /* The resulting vector has a number of elements equal to
-	     * the number of rows of matrix A. */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_a->column_type()->vector_elements,
-				       1);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
+         /* A is a matrix and B is a column vector.  Columns of A must match
+          * rows of B.  Given the other previously tested constraints, this
+          * means the vector type of a row from A must be the same as the
+          * vector the type of B.
+          */
+         if (type_a->row_type() == type_b) {
+            /* The resulting vector has a number of elements equal to
+             * the number of rows of matrix A. */
+            const glsl_type *const type =
+               glsl_type::get_instance(type_a->base_type,
+                  type_a->column_type()->vector_elements,
+                  1);
+            assert(type != glsl_type::error_type);
+
+            return type;
+         }
       } else {
-	 assert(type_b->is_matrix());
-
-	 /* A is a row vector and B is a matrix.  Columns of A must match rows
-	  * of B.  Given the other previously tested constraints, this means
-	  * the type of A must be the same as the vector type of a column from
-	  * B.
-	  */
-	 if (type_a == type_b->column_type()) {
-	    /* The resulting vector has a number of elements equal to
-	     * the number of columns of matrix B. */
-	    const glsl_type *const type =
-	       glsl_type::get_instance(type_a->base_type,
-				       type_b->row_type()->vector_elements,
-				       1);
-	    assert(type != glsl_type::error_type);
-
-	    return type;
-	 }
+         assert(type_b->is_matrix());
+
+         /* A is a row vector and B is a matrix.  Columns of A must match rows
+          * of B.  Given the other previously tested constraints, this means
+          * the type of A must be the same as the vector type of a column from
+          * B.
+          */
+         if (type_a == type_b->column_type()) {
+            /* The resulting vector has a number of elements equal to
+             * the number of columns of matrix B. */
+            const glsl_type *const type =
+               glsl_type::get_instance(type_a->base_type,
+                  type_b->row_type()->vector_elements,
+                  1);
+            assert(type != glsl_type::error_type);
+
+            return type;
+         }
       }
 
       _mesa_glsl_error(loc, state, "size mismatch for matrix multiplication");
@@ -537,8 +537,8 @@  modulus_result_type(const struct glsl_type *type_a,
     */
    if (type_a->is_vector()) {
       if (!type_b->is_vector()
-	  || (type_a->vector_elements == type_b->vector_elements))
-	 return type_a;
+          || (type_a->vector_elements == type_b->vector_elements))
+      return type_a;
    } else
       return type_b;
 
@@ -792,30 +792,29 @@  do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
       if (non_lvalue_description != NULL) {
          _mesa_glsl_error(&lhs_loc, state,
                           "assignment to %s",
-			  non_lvalue_description);
-	 error_emitted = true;
+                          non_lvalue_description);
+         error_emitted = true;
       } else if (lhs->variable_referenced() != NULL
-		 && lhs->variable_referenced()->data.read_only) {
+                 && lhs->variable_referenced()->data.read_only) {
          _mesa_glsl_error(&lhs_loc, state,
                           "assignment to read-only variable '%s'",
                           lhs->variable_referenced()->name);
          error_emitted = true;
-
       } else if (lhs->type->is_array() &&
                  !state->check_version(120, 300, &lhs_loc,
                                        "whole array assignment forbidden")) {
-	 /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
-	  *
-	  *    "Other binary or unary expressions, non-dereferenced
-	  *     arrays, function names, swizzles with repeated fields,
-	  *     and constants cannot be l-values."
-          *
-          * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
-	  */
-	 error_emitted = true;
+       /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
+        *
+        *    "Other binary or unary expressions, non-dereferenced
+        *     arrays, function names, swizzles with repeated fields,
+        *     and constants cannot be l-values."
+        *
+        * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
+        */
+         error_emitted = true;
       } else if (!lhs->is_lvalue()) {
-	 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
-	 error_emitted = true;
+         _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
+         error_emitted = true;
       }
    }
 
@@ -830,24 +829,24 @@  do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
        * is either not an l-value or not a whole array.
        */
       if (lhs->type->is_unsized_array()) {
-	 ir_dereference *const d = lhs->as_dereference();
+         ir_dereference *const d = lhs->as_dereference();
 
-	 assert(d != NULL);
+         assert(d != NULL);
 
-	 ir_variable *const var = d->variable_referenced();
+         ir_variable *const var = d->variable_referenced();
 
-	 assert(var != NULL);
+         assert(var != NULL);
 
-	 if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
-	    /* FINISHME: This should actually log the location of the RHS. */
-	    _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
-			     "previous access",
-			     var->data.max_array_access);
-	 }
+         if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
+            /* FINISHME: This should actually log the location of the RHS. */
+            _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
+               "previous access",
+               var->data.max_array_access);
+         }
 
-	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),
-						   rhs->type->array_size());
-	 d->type = var->type;
+         var->type = glsl_type::get_array_instance(lhs->type->element_type(),
+                        rhs->type->array_size());
+         d->type = var->type;
       }
       if (lhs->type->is_array()) {
          mark_whole_array_access(rhs);
@@ -951,19 +950,19 @@  do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
 
    case GLSL_TYPE_ARRAY: {
       for (unsigned int i = 0; i < op0->type->length; i++) {
-	 ir_rvalue *e0, *e1, *result;
-
-	 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
-						new(mem_ctx) ir_constant(i));
-	 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
-						new(mem_ctx) ir_constant(i));
-	 result = do_comparison(mem_ctx, operation, e0, e1);
-
-	 if (cmp) {
-	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
-	 } else {
-	    cmp = result;
-	 }
+         ir_rvalue *e0, *e1, *result;
+
+         e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
+                              new(mem_ctx) ir_constant(i));
+         e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
+                              new(mem_ctx) ir_constant(i));
+         result = do_comparison(mem_ctx, operation, e0, e1);
+
+         if (cmp) {
+            cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
+         } else {
+            cmp = result;
+         }
       }
 
       mark_whole_array_access(op0);
@@ -973,20 +972,20 @@  do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
 
    case GLSL_TYPE_STRUCT: {
       for (unsigned int i = 0; i < op0->type->length; i++) {
-	 ir_rvalue *e0, *e1, *result;
-	 const char *field_name = op0->type->fields.structure[i].name;
-
-	 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
-						 field_name);
-	 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
-						 field_name);
-	 result = do_comparison(mem_ctx, operation, e0, e1);
-
-	 if (cmp) {
-	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
-	 } else {
-	    cmp = result;
-	 }
+         ir_rvalue *e0, *e1, *result;
+         const char *field_name = op0->type->fields.structure[i].name;
+
+         e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
+                              field_name);
+         e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
+                              field_name);
+         result = do_comparison(mem_ctx, operation, e0, e1);
+
+         if (cmp) {
+            cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
+         } else {
+            cmp = result;
+         }
       }
       break;
    }
@@ -1181,8 +1180,8 @@  ast_expression::do_hir(exec_list *instructions,
 
    switch (this->oper) {
    case ast_aggregate:
-         assert(!"ast_aggregate: Should never get here.");
-         break;
+      assert(!"ast_aggregate: Should never get here.");
+      break;
 
    case ast_assign: {
       op[0] = this->subexpressions[0]->hir(instructions, state);
@@ -1297,15 +1296,15 @@  ast_expression::do_hir(exec_list *instructions,
        *    case this conversion is done."
        */
       if ((!apply_implicit_conversion(op[0]->type, op[1], state)
-	   && !apply_implicit_conversion(op[1]->type, op[0], state))
-	  || (op[0]->type != op[1]->type)) {
-	 _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
-			  "type", (this->oper == ast_equal) ? "==" : "!=");
-	 error_emitted = true;
+           && !apply_implicit_conversion(op[1]->type, op[0], state))
+          || (op[0]->type != op[1]->type)) {
+         _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
+                          "type", (this->oper == ast_equal) ? "==" : "!=");
+         error_emitted = true;
       } else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
                  !state->check_version(120, 300, &loc,
                                        "array comparisons forbidden")) {
-	 error_emitted = true;
+         error_emitted = true;
       } else if ((op[0]->type->contains_opaque() ||
                   op[1]->type->contains_opaque())) {
          _mesa_glsl_error(&loc, state, "opaque type comparisons forbidden");
@@ -1313,10 +1312,10 @@  ast_expression::do_hir(exec_list *instructions,
       }
 
       if (error_emitted) {
-	 result = new(ctx) ir_constant(false);
+         result = new(ctx) ir_constant(false);
       } else {
-	 result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
-	 assert(result->type == glsl_type::bool_type);
+         result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
+         assert(result->type == glsl_type::bool_type);
       }
       break;
 
@@ -1328,7 +1327,7 @@  ast_expression::do_hir(exec_list *instructions,
       type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
                                    state, &loc);
       result = new(ctx) ir_expression(operations[this->oper], type,
-				      op[0], op[1]);
+                                      op[0], op[1]);
       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
       break;
 
@@ -1336,12 +1335,12 @@  ast_expression::do_hir(exec_list *instructions,
       op[0] = this->subexpressions[0]->hir(instructions, state);
 
       if (!state->check_bitwise_operations_allowed(&loc)) {
-	 error_emitted = true;
+         error_emitted = true;
       }
 
       if (!op[0]->type->is_integer()) {
-	 _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
-	 error_emitted = true;
+         _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
+         error_emitted = true;
       }
 
       type = error_emitted ? glsl_type::error_type : op[0]->type;
@@ -1356,30 +1355,30 @@  ast_expression::do_hir(exec_list *instructions,
 					 "RHS", &error_emitted);
 
       if (rhs_instructions.is_empty()) {
-	 result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
-	 type = result->type;
+         result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
+         type = result->type;
       } else {
-	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
-						       "and_tmp",
-						       ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 stmt->then_instructions.append_list(&rhs_instructions);
-	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, op[1]);
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
-	 type = tmp->type;
+         ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
+                                                       "and_tmp",
+                                                       ir_var_temporary);
+         instructions->push_tail(tmp);
+
+         ir_if *const stmt = new(ctx) ir_if(op[0]);
+         instructions->push_tail(stmt);
+
+         stmt->then_instructions.append_list(&rhs_instructions);
+         ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const then_assign =
+            new(ctx) ir_assignment(then_deref, op[1]);
+         stmt->then_instructions.push_tail(then_assign);
+
+         ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const else_assign =
+            new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
+         stmt->else_instructions.push_tail(else_assign);
+
+         result = new(ctx) ir_dereference_variable(tmp);
+         type = tmp->type;
       }
       break;
    }
@@ -1392,30 +1391,30 @@  ast_expression::do_hir(exec_list *instructions,
 					 "RHS", &error_emitted);
 
       if (rhs_instructions.is_empty()) {
-	 result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
-	 type = result->type;
+         result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
+         type = result->type;
       } else {
-	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
-						       "or_tmp",
-						       ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 stmt->else_instructions.append_list(&rhs_instructions);
-	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, op[1]);
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
-	 type = tmp->type;
+         ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
+                                                       "or_tmp",
+                                                       ir_var_temporary);
+         instructions->push_tail(tmp);
+
+         ir_if *const stmt = new(ctx) ir_if(op[0]);
+         instructions->push_tail(stmt);
+
+         ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const then_assign =
+            new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
+         stmt->then_instructions.push_tail(then_assign);
+
+         stmt->else_instructions.append_list(&rhs_instructions);
+         ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const else_assign =
+            new(ctx) ir_assignment(else_deref, op[1]);
+         stmt->else_instructions.push_tail(else_assign);
+
+         result = new(ctx) ir_dereference_variable(tmp);
+         type = tmp->type;
       }
       break;
    }
@@ -1428,20 +1427,20 @@  ast_expression::do_hir(exec_list *instructions,
        *     expressions and result in a Boolean expression."
        */
       op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
-					 &error_emitted);
+                                         &error_emitted);
       op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
-					 &error_emitted);
+                                         &error_emitted);
 
       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
-				      op[0], op[1]);
+                                      op[0], op[1]);
       break;
 
    case ast_logic_not:
       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
-					 "operand", &error_emitted);
+                                         "operand", &error_emitted);
 
       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
-				      op[0], NULL);
+                                      op[0], NULL);
       break;
 
    case ast_mul_assign:
@@ -1452,11 +1451,11 @@  ast_expression::do_hir(exec_list *instructions,
       op[1] = this->subexpressions[1]->hir(instructions, state);
 
       type = arithmetic_result_type(op[0], op[1],
-				    (this->oper == ast_mul_assign),
-				    state, & loc);
+                                    (this->oper == ast_mul_assign),
+                                    state, & loc);
 
       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-						   op[0], op[1]);
+                                                   op[0], op[1]);
 
       error_emitted =
          do_assignment(instructions, state,
@@ -1537,7 +1536,7 @@  ast_expression::do_hir(exec_list *instructions,
        *    first expression, which must result in a scalar Boolean."
        */
       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
-					 "condition", &error_emitted);
+                                         "condition", &error_emitted);
 
       /* The :? operator is implemented by generating an anonymous temporary
        * followed by an if-statement.  The last instruction in each branch of
@@ -1560,16 +1559,16 @@  ast_expression::do_hir(exec_list *instructions,
        *     expression."
        */
       if ((!apply_implicit_conversion(op[1]->type, op[2], state)
-	   && !apply_implicit_conversion(op[2]->type, op[1], state))
-	  || (op[1]->type != op[2]->type)) {
-	 YYLTYPE loc = this->subexpressions[1]->get_location();
-
-	 _mesa_glsl_error(& loc, state, "second and third operands of ?: "
-			  "operator must have matching types");
-	 error_emitted = true;
-	 type = glsl_type::error_type;
+          && !apply_implicit_conversion(op[2]->type, op[1], state))
+          || (op[1]->type != op[2]->type)) {
+         YYLTYPE loc = this->subexpressions[1]->get_location();
+
+         _mesa_glsl_error(& loc, state, "second and third operands of ?: "
+                          "operator must have matching types");
+         error_emitted = true;
+         type = glsl_type::error_type;
       } else {
-	 type = op[1]->type;
+         type = op[1]->type;
       }
 
       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
@@ -1581,7 +1580,7 @@  ast_expression::do_hir(exec_list *instructions,
           !state->check_version(120, 300, &loc,
                                 "second and third operands of ?: operator "
                                 "cannot be arrays")) {
-	 error_emitted = true;
+         error_emitted = true;
       }
 
       ir_constant *cond_val = op[0]->constant_expression_value();
@@ -1589,32 +1588,32 @@  ast_expression::do_hir(exec_list *instructions,
       ir_constant *else_val = op[2]->constant_expression_value();
 
       if (then_instructions.is_empty()
-	  && else_instructions.is_empty()
-	  && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
-	 result = (cond_val->value.b[0]) ? then_val : else_val;
+          && else_instructions.is_empty()
+          && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
+         result = (cond_val->value.b[0]) ? then_val : else_val;
       } else {
-	 ir_variable *const tmp =
-	    new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
-	 instructions->push_tail(tmp);
-
-	 ir_if *const stmt = new(ctx) ir_if(op[0]);
-	 instructions->push_tail(stmt);
-
-	 then_instructions.move_nodes_to(& stmt->then_instructions);
-	 ir_dereference *const then_deref =
-	    new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const then_assign =
-	    new(ctx) ir_assignment(then_deref, op[1]);
-	 stmt->then_instructions.push_tail(then_assign);
-
-	 else_instructions.move_nodes_to(& stmt->else_instructions);
-	 ir_dereference *const else_deref =
-	    new(ctx) ir_dereference_variable(tmp);
-	 ir_assignment *const else_assign =
-	    new(ctx) ir_assignment(else_deref, op[2]);
-	 stmt->else_instructions.push_tail(else_assign);
-
-	 result = new(ctx) ir_dereference_variable(tmp);
+         ir_variable *const tmp =
+            new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
+         instructions->push_tail(tmp);
+
+         ir_if *const stmt = new(ctx) ir_if(op[0]);
+         instructions->push_tail(stmt);
+
+         then_instructions.move_nodes_to(& stmt->then_instructions);
+         ir_dereference *const then_deref =
+            new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const then_assign =
+            new(ctx) ir_assignment(then_deref, op[1]);
+         stmt->then_instructions.push_tail(then_assign);
+
+         else_instructions.move_nodes_to(& stmt->else_instructions);
+         ir_dereference *const else_deref =
+            new(ctx) ir_dereference_variable(tmp);
+         ir_assignment *const else_assign =
+            new(ctx) ir_assignment(else_deref, op[2]);
+         stmt->else_instructions.push_tail(else_assign);
+
+         result = new(ctx) ir_dereference_variable(tmp);
       }
       break;
    }
@@ -1622,7 +1621,7 @@  ast_expression::do_hir(exec_list *instructions,
    case ast_pre_inc:
    case ast_pre_dec: {
       this->non_lvalue_description = (this->oper == ast_pre_inc)
-	 ? "pre-increment operation" : "pre-decrement operation";
+         ? "pre-increment operation" : "pre-decrement operation";
 
       op[0] = this->subexpressions[0]->hir(instructions, state);
       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
@@ -1631,7 +1630,7 @@  ast_expression::do_hir(exec_list *instructions,
 
       ir_rvalue *temp_rhs;
       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-					op[0], op[1]);
+                                        op[0], op[1]);
 
       error_emitted =
          do_assignment(instructions, state,
@@ -1645,7 +1644,7 @@  ast_expression::do_hir(exec_list *instructions,
    case ast_post_inc:
    case ast_post_dec: {
       this->non_lvalue_description = (this->oper == ast_post_inc)
-	 ? "post-increment operation" : "post-decrement operation";
+         ? "post-increment operation" : "post-decrement operation";
       op[0] = this->subexpressions[0]->hir(instructions, state);
       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
 
@@ -1655,7 +1654,7 @@  ast_expression::do_hir(exec_list *instructions,
 
       ir_rvalue *temp_rhs;
       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
-					op[0], op[1]);
+                                        op[0], op[1]);
 
       /* Get a temporary of a copy of the lvalue before it's modified.
        * This may get thrown away later.
@@ -1687,7 +1686,7 @@  ast_expression::do_hir(exec_list *instructions,
 					    loc, index_loc);
 
       if (result->type->is_error())
-	 error_emitted = true;
+         error_emitted = true;
 
       break;
    }
@@ -1705,17 +1704,17 @@  ast_expression::do_hir(exec_list *instructions,
        * as 'variable_identifier'.
        */
       ir_variable *var = 
-	 state->symbols->get_variable(this->primary_expression.identifier);
+         state->symbols->get_variable(this->primary_expression.identifier);
 
       if (var != NULL) {
-	 var->data.used = true;
-	 result = new(ctx) ir_dereference_variable(var);
+         var->data.used = true;
+         result = new(ctx) ir_dereference_variable(var);
       } else {
-	 _mesa_glsl_error(& loc, state, "`%s' undeclared",
-			  this->primary_expression.identifier);
+         _mesa_glsl_error(& loc, state, "`%s' undeclared",
+                          this->primary_expression.identifier);
 
-	 result = ir_rvalue::error_value(ctx);
-	 error_emitted = true;
+         result = ir_rvalue::error_value(ctx);
+         error_emitted = true;
       }
       break;
    }
@@ -1751,37 +1750,37 @@  ast_expression::do_hir(exec_list *instructions,
       YYLTYPE previous_operand_loc = loc;
 
       foreach_list_typed (ast_node, ast, link, &this->expressions) {
-	 /* If one of the operands of comma operator does not generate any
-	  * code, we want to emit a warning.  At each pass through the loop
-	  * previous_tail_pred will point to the last instruction in the
-	  * stream *before* processing the previous operand.  Naturally,
-	  * instructions->tail_pred will point to the last instruction in the
-	  * stream *after* processing the previous operand.  If the two
-	  * pointers match, then the previous operand had no effect.
-	  *
-	  * The warning behavior here differs slightly from GCC.  GCC will
-	  * only emit a warning if none of the left-hand operands have an
-	  * effect.  However, it will emit a warning for each.  I believe that
-	  * there are some cases in C (especially with GCC extensions) where
-	  * it is useful to have an intermediate step in a sequence have no
-	  * effect, but I don't think these cases exist in GLSL.  Either way,
-	  * it would be a giant hassle to replicate that behavior.
-	  */
-	 if (previous_tail_pred == instructions->tail_pred) {
-	    _mesa_glsl_warning(&previous_operand_loc, state,
-			       "left-hand operand of comma expression has "
-			       "no effect");
-	 }
-
-	 /* tail_pred is directly accessed instead of using the get_tail()
-	  * method for performance reasons.  get_tail() has extra code to
-	  * return NULL when the list is empty.  We don't care about that
-	  * here, so using tail_pred directly is fine.
-	  */
-	 previous_tail_pred = instructions->tail_pred;
-	 previous_operand_loc = ast->get_location();
-
-	 result = ast->hir(instructions, state);
+         /* If one of the operands of comma operator does not generate any
+          * code, we want to emit a warning.  At each pass through the loop
+          * previous_tail_pred will point to the last instruction in the
+          * stream *before* processing the previous operand.  Naturally,
+          * instructions->tail_pred will point to the last instruction in the
+          * stream *after* processing the previous operand.  If the two
+          * pointers match, then the previous operand had no effect.
+          *
+          * The warning behavior here differs slightly from GCC.  GCC will
+          * only emit a warning if none of the left-hand operands have an
+          * effect.  However, it will emit a warning for each.  I believe that
+          * there are some cases in C (especially with GCC extensions) where
+          * it is useful to have an intermediate step in a sequence have no
+          * effect, but I don't think these cases exist in GLSL.  Either way,
+          * it would be a giant hassle to replicate that behavior.
+          */
+	       if (previous_tail_pred == instructions->tail_pred) {
+            _mesa_glsl_warning(&previous_operand_loc, state,
+                               "left-hand operand of comma expression has "
+                               "no effect");
+	       }
+
+        /* tail_pred is directly accessed instead of using the get_tail()
+         * method for performance reasons.  get_tail() has extra code to
+         * return NULL when the list is empty.  We don't care about that
+         * here, so using tail_pred directly is fine.
+         */
+         previous_tail_pred = instructions->tail_pred;
+         previous_operand_loc = ast->get_location();
+
+         result = ast->hir(instructions, state);
       }
 
       /* Any errors should have already been emitted in the loop above.
@@ -2356,12 +2355,12 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
 
    if (qual->flags.q.invariant) {
       if (var->data.used) {
-	 _mesa_glsl_error(loc, state,
-			  "variable `%s' may not be redeclared "
-			  "`invariant' after being used",
-			  var->name);
+         _mesa_glsl_error(loc, state,
+                          "variable `%s' may not be redeclared "
+                          "`invariant' after being used",
+                          var->name);
       } else {
-	 var->data.invariant = 1;
+         var->data.invariant = 1;
       }
    }
 
@@ -2379,9 +2378,9 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) {
       var->type = glsl_type::error_type;
       _mesa_glsl_error(loc, state,
-		       "`attribute' variables may not be declared in the "
-		       "%s shader",
-		       _mesa_shader_stage_to_string(state->stage));
+                       "`attribute' variables may not be declared in the "
+                       "%s shader",
+                       _mesa_shader_stage_to_string(state->stage));
    }
 
    /* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says:
@@ -2474,18 +2473,18 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if (state->all_invariant && (state->current_function == NULL)) {
       switch (state->stage) {
       case MESA_SHADER_VERTEX:
-	 if (var->data.mode == ir_var_shader_out)
-	    var->data.invariant = true;
-	 break;
+         if (var->data.mode == ir_var_shader_out)
+            var->data.invariant = true;
+	      break;
       case MESA_SHADER_GEOMETRY:
-	 if ((var->data.mode == ir_var_shader_in)
+         if ((var->data.mode == ir_var_shader_in)
              || (var->data.mode == ir_var_shader_out))
-	    var->data.invariant = true;
-	 break;
+            var->data.invariant = true;
+         break;
       case MESA_SHADER_FRAGMENT:
-	 if (var->data.mode == ir_var_shader_in)
-	    var->data.invariant = true;
-	 break;
+         if (var->data.mode == ir_var_shader_in)
+            var->data.invariant = true;
+         break;
       case MESA_SHADER_COMPUTE:
          /* Invariance isn't meaningful in compute shaders. */
          break;
@@ -2501,7 +2500,7 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
        && (strcmp(var->name, "gl_FragCoord") != 0)) {
       const char *const qual_string = (qual->flags.q.origin_upper_left)
-	 ? "origin_upper_left" : "pixel_center_integer";
+         ? "origin_upper_left" : "pixel_center_integer";
 
       _mesa_glsl_error(loc, state,
 		       "layout qualifier `%s' can only be applied to "
@@ -2512,8 +2511,7 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    if (qual->flags.q.explicit_location) {
       validate_explicit_location(qual, var, state, loc);
    } else if (qual->flags.q.explicit_index) {
-	 _mesa_glsl_error(loc, state,
-			  "explicit index requires explicit location");
+      _mesa_glsl_error(loc, state, "explicit index requires explicit location");
    }
 
    if (qual->flags.q.explicit_binding &&
@@ -2577,13 +2575,13 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
 
    if (qual->has_layout() && uses_deprecated_qualifier) {
       if (relaxed_layout_qualifier_checking) {
-	 _mesa_glsl_warning(loc, state,
-			    "`layout' qualifier may not be used with "
-			    "`attribute' or `varying'");
+         _mesa_glsl_warning(loc, state,
+                            "`layout' qualifier may not be used with "
+                            "`attribute' or `varying'");
       } else {
-	 _mesa_glsl_error(loc, state,
-			  "`layout' qualifier may not be used with "
-			  "`attribute' or `varying'");
+         _mesa_glsl_error(loc, state,
+                          "`layout' qualifier may not be used with "
+                          "`attribute' or `varying'");
       }
    }
 
@@ -2600,7 +2598,7 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
        _mesa_glsl_error(loc, state,
                         "extension GL_AMD_conservative_depth or "
                         "GL_ARB_conservative_depth must be enabled "
-			"to use depth layout qualifiers");
+                        "to use depth layout qualifiers");
    } else if (depth_layout_count > 0
               && strcmp(var->name, "gl_FragDepth") != 0) {
        _mesa_glsl_error(loc, state,
@@ -2628,8 +2626,8 @@  apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
        qual->flags.q.shared) {
       _mesa_glsl_error(loc, state,
                        "uniform block layout qualifiers std140, packed, and "
-		       "shared can only be applied to uniform blocks, not "
-		       "members");
+                       "shared can only be applied to uniform blocks, not "
+                       "members");
    }
 
    if (qual->flags.q.row_major || qual->flags.q.column_major) {
@@ -2665,7 +2663,7 @@  get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
    ir_variable *earlier = state->symbols->get_variable(var->name);
    if (earlier == NULL ||
        (state->current_function != NULL &&
-	!state->symbols->name_declared_this_scope(var->name))) {
+       !state->symbols->name_declared_this_scope(var->name))) {
       return NULL;
    }
 
@@ -2686,19 +2684,19 @@  get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
       const unsigned size = unsigned(var->type->array_size());
       check_builtin_array_max_size(var->name, size, loc, state);
       if ((size > 0) && (size <= earlier->data.max_array_access)) {
-	 _mesa_glsl_error(& loc, state, "array size must be > %u due to "
-			  "previous access",
-			  earlier->data.max_array_access);
+         _mesa_glsl_error(& loc, state, "array size must be > %u due to "
+                          "previous access",
+                          earlier->data.max_array_access);
       }
 
       earlier->type = var->type;
       delete var;
       var = NULL;
    } else if ((state->ARB_fragment_coord_conventions_enable ||
-               state->is_version(150, 0))
-	      && strcmp(var->name, "gl_FragCoord") == 0
-	      && earlier->type == var->type
-	      && earlier->data.mode == var->data.mode) {
+              state->is_version(150, 0))
+              && strcmp(var->name, "gl_FragCoord") == 0
+              && earlier->type == var->type
+              && earlier->data.mode == var->data.mode) {
       /* Allow redeclaration of gl_FragCoord for ARB_fcc layout
        * qualifiers.
        */
@@ -2716,42 +2714,42 @@  get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
        *    * gl_SecondaryColor
        */
    } else if (state->is_version(130, 0)
-	      && (strcmp(var->name, "gl_FrontColor") == 0
-		  || strcmp(var->name, "gl_BackColor") == 0
-		  || strcmp(var->name, "gl_FrontSecondaryColor") == 0
-		  || strcmp(var->name, "gl_BackSecondaryColor") == 0
-		  || strcmp(var->name, "gl_Color") == 0
-		  || strcmp(var->name, "gl_SecondaryColor") == 0)
-	      && earlier->type == var->type
-	      && earlier->data.mode == var->data.mode) {
+              && (strcmp(var->name, "gl_FrontColor") == 0
+                  || strcmp(var->name, "gl_BackColor") == 0
+                  || strcmp(var->name, "gl_FrontSecondaryColor") == 0
+                  || strcmp(var->name, "gl_BackSecondaryColor") == 0
+                  || strcmp(var->name, "gl_Color") == 0
+                  || strcmp(var->name, "gl_SecondaryColor") == 0)
+              && earlier->type == var->type
+              && earlier->data.mode == var->data.mode) {
       earlier->data.interpolation = var->data.interpolation;
 
       /* Layout qualifiers for gl_FragDepth. */
    } else if ((state->AMD_conservative_depth_enable ||
                state->ARB_conservative_depth_enable)
-	      && strcmp(var->name, "gl_FragDepth") == 0
-	      && earlier->type == var->type
-	      && earlier->data.mode == var->data.mode) {
+              && strcmp(var->name, "gl_FragDepth") == 0
+              && earlier->type == var->type
+              && earlier->data.mode == var->data.mode) {
 
       /** From the AMD_conservative_depth spec:
        *     Within any shader, the first redeclarations of gl_FragDepth
        *     must appear before any use of gl_FragDepth.
        */
       if (earlier->data.used) {
-	 _mesa_glsl_error(&loc, state,
-			  "the first redeclaration of gl_FragDepth "
-			  "must appear before any use of gl_FragDepth");
+         _mesa_glsl_error(&loc, state,
+                          "the first redeclaration of gl_FragDepth "
+                          "must appear before any use of gl_FragDepth");
       }
 
       /* Prevent inconsistent redeclaration of depth layout qualifier. */
       if (earlier->data.depth_layout != ir_depth_layout_none
-	  && earlier->data.depth_layout != var->data.depth_layout) {
-	 _mesa_glsl_error(&loc, state,
-			  "gl_FragDepth: depth layout is declared here "
-			  "as '%s, but it was previously declared as "
-			  "'%s'",
-			  depth_layout_string(var->data.depth_layout),
-			  depth_layout_string(earlier->data.depth_layout));
+          && earlier->data.depth_layout != var->data.depth_layout) {
+            _mesa_glsl_error(&loc, state,
+                             "gl_FragDepth: depth layout is declared here "
+                             "as '%s, but it was previously declared as "
+                             "'%s'",
+                             depth_layout_string(var->data.depth_layout),
+                             depth_layout_string(earlier->data.depth_layout));
       }
 
       earlier->data.depth_layout = var->data.depth_layout;
@@ -2858,35 +2856,35 @@  process_initializer(ir_variable *var, ast_declaration *decl,
                }
             }
          } else {
-	    rhs = constant_value;
-	    var->constant_value = constant_value;
-	 }
+            rhs = constant_value;
+            var->constant_value = constant_value;
+         }
       } else {
-	 if (var->type->is_numeric()) {
-	    /* Reduce cascading errors. */
-	    var->constant_value = ir_constant::zero(state, var->type);
-	 }
+         if (var->type->is_numeric()) {
+            /* Reduce cascading errors. */
+            var->constant_value = ir_constant::zero(state, var->type);
+         }
       }
    }
 
    if (rhs && !rhs->type->is_error()) {
       bool temp = var->data.read_only;
       if (type->qualifier.flags.q.constant)
-	 var->data.read_only = false;
+         var->data.read_only = false;
 
       /* Never emit code to initialize a uniform.
        */
       const glsl_type *initializer_type;
       if (!type->qualifier.flags.q.uniform) {
-	 do_assignment(initializer_instructions, state,
+         do_assignment(initializer_instructions, state,
                        NULL,
                        lhs, rhs,
                        &result, true,
                        true,
                        type->get_location());
-	 initializer_type = result->type;
+         initializer_type = result->type;
       } else
-	 initializer_type = rhs->type;
+         initializer_type = rhs->type;
 
       var->constant_initializer = rhs->constant_expression_value();
       var->data.has_initializer = true;
@@ -3062,33 +3060,33 @@  ast_declarator_list::hir(exec_list *instructions,
       }
 
       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
-	 assert(decl->array_specifier == NULL);
-	 assert(decl->initializer == NULL);
-
-	 ir_variable *const earlier =
-	    state->symbols->get_variable(decl->identifier);
-	 if (earlier == NULL) {
-	    _mesa_glsl_error(& loc, state,
-			     "undeclared variable `%s' cannot be marked "
-			     "invariant", decl->identifier);
-	 } else if ((state->stage == MESA_SHADER_VERTEX)
-	       && (earlier->data.mode != ir_var_shader_out)) {
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, vertex shader "
-			     "outputs only", decl->identifier);
-	 } else if ((state->stage == MESA_SHADER_FRAGMENT)
-	       && (earlier->data.mode != ir_var_shader_in)) {
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, fragment shader "
-			     "inputs only", decl->identifier);
-	 } else if (earlier->data.used) {
-	    _mesa_glsl_error(& loc, state,
-			     "variable `%s' may not be redeclared "
-			     "`invariant' after being used",
-			     earlier->name);
-	 } else {
-	    earlier->data.invariant = true;
-	 }
+         assert(decl->array_specifier == NULL);
+         assert(decl->initializer == NULL);
+
+         ir_variable *const earlier =
+            state->symbols->get_variable(decl->identifier);
+         if (earlier == NULL) {
+            _mesa_glsl_error(& loc, state,
+                             "undeclared variable `%s' cannot be marked "
+                             "invariant", decl->identifier);
+         } else if ((state->stage == MESA_SHADER_VERTEX)
+                    && (earlier->data.mode != ir_var_shader_out)) {
+            _mesa_glsl_error(& loc, state,
+                             "`%s' cannot be marked invariant, vertex shader "
+                             "outputs only", decl->identifier);
+         } else if ((state->stage == MESA_SHADER_FRAGMENT)
+                    && (earlier->data.mode != ir_var_shader_in)) {
+            _mesa_glsl_error(& loc, state,
+                             "`%s' cannot be marked invariant, fragment shader "
+                             "inputs only", decl->identifier);
+         } else if (earlier->data.used) {
+            _mesa_glsl_error(& loc, state,
+                            "variable `%s' may not be redeclared "
+                            "`invariant' after being used",
+                            earlier->name);
+         } else {
+            earlier->data.invariant = true;
+         }
       }
 
       /* Invariant redeclarations do not have r-values.
@@ -3181,16 +3179,16 @@  ast_declarator_list::hir(exec_list *instructions,
       ir_variable *var;
 
       if ((decl_type == NULL) || decl_type->is_void()) {
-	 if (type_name != NULL) {
-	    _mesa_glsl_error(& loc, state,
-			     "invalid type `%s' in declaration of `%s'",
-			     type_name, decl->identifier);
-	 } else {
-	    _mesa_glsl_error(& loc, state,
-			     "invalid type in declaration of `%s'",
-			     decl->identifier);
-	 }
-	 continue;
+         if (type_name != NULL) {
+            _mesa_glsl_error(& loc, state,
+                             "invalid type `%s' in declaration of `%s'",
+                             type_name, decl->identifier);
+         } else {
+            _mesa_glsl_error(& loc, state,
+                             "invalid type in declaration of `%s'",
+                             decl->identifier);
+         }
+         continue;
       }
 
       if (state->symbols->get_variable(decl->identifier)) {
@@ -3236,95 +3234,95 @@  ast_declarator_list::hir(exec_list *instructions,
        * any extension that adds the 'layout' keyword.
        */
       if (!state->is_version(130, 300)
-	  && !state->has_explicit_attrib_location()
-	  && !state->has_separate_shader_objects()
-	  && !state->ARB_fragment_coord_conventions_enable) {
-	 if (this->type->qualifier.flags.q.out) {
-	    _mesa_glsl_error(& loc, state,
-			     "`out' qualifier in declaration of `%s' "
-			     "only valid for function parameters in %s",
-			     decl->identifier, state->get_version_string());
-	 }
-	 if (this->type->qualifier.flags.q.in) {
-	    _mesa_glsl_error(& loc, state,
-			     "`in' qualifier in declaration of `%s' "
-			     "only valid for function parameters in %s",
-			     decl->identifier, state->get_version_string());
-	 }
-	 /* FINISHME: Test for other invalid qualifiers. */
+          && !state->has_explicit_attrib_location()
+          && !state->has_separate_shader_objects()
+          && !state->ARB_fragment_coord_conventions_enable) {
+         if (this->type->qualifier.flags.q.out) {
+            _mesa_glsl_error(& loc, state,
+                             "`out' qualifier in declaration of `%s' "
+                             "only valid for function parameters in %s",
+                             decl->identifier, state->get_version_string());
+         }
+         if (this->type->qualifier.flags.q.in) {
+            _mesa_glsl_error(& loc, state,
+                             "`in' qualifier in declaration of `%s' "
+                             "only valid for function parameters in %s",
+                             decl->identifier, state->get_version_string());
+         }
+         /* FINISHME: Test for other invalid qualifiers. */
       }
 
       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
 				       & loc, false);
 
       if (this->type->qualifier.flags.q.invariant) {
-	 if ((state->stage == MESA_SHADER_VERTEX) &&
+         if ((state->stage == MESA_SHADER_VERTEX) &&
              var->data.mode != ir_var_shader_out) {
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, vertex shader "
-			     "outputs only", var->name);
-	 } else if ((state->stage == MESA_SHADER_FRAGMENT) &&
-		    var->data.mode != ir_var_shader_in) {
-	    /* FINISHME: Note that this doesn't work for invariant on
-	     * a function signature inval
-	     */
-	    _mesa_glsl_error(& loc, state,
-			     "`%s' cannot be marked invariant, fragment shader "
-			     "inputs only", var->name);
-	 }
+            _mesa_glsl_error(& loc, state,
+                             "`%s' cannot be marked invariant, vertex shader "
+                             "outputs only", var->name);
+         } else if ((state->stage == MESA_SHADER_FRAGMENT) &&
+                    var->data.mode != ir_var_shader_in) {
+            /* FINISHME: Note that this doesn't work for invariant on
+             * a function signature inval
+             */
+            _mesa_glsl_error(& loc, state,
+               "`%s' cannot be marked invariant, fragment shader "
+               "inputs only", var->name);
+         }
       }
 
       if (state->current_function != NULL) {
-	 const char *mode = NULL;
-	 const char *extra = "";
-
-	 /* There is no need to check for 'inout' here because the parser will
-	  * only allow that in function parameter lists.
-	  */
-	 if (this->type->qualifier.flags.q.attribute) {
-	    mode = "attribute";
-	 } else if (this->type->qualifier.flags.q.uniform) {
-	    mode = "uniform";
-	 } else if (this->type->qualifier.flags.q.varying) {
-	    mode = "varying";
-	 } else if (this->type->qualifier.flags.q.in) {
-	    mode = "in";
-	    extra = " or in function parameter list";
-	 } else if (this->type->qualifier.flags.q.out) {
-	    mode = "out";
-	    extra = " or in function parameter list";
-	 }
-
-	 if (mode) {
-	    _mesa_glsl_error(& loc, state,
-			     "%s variable `%s' must be declared at "
-			     "global scope%s",
-			     mode, var->name, extra);
-	 }
+         const char *mode = NULL;
+         const char *extra = "";
+
+         /* There is no need to check for 'inout' here because the parser will
+          * only allow that in function parameter lists.
+          */
+         if (this->type->qualifier.flags.q.attribute) {
+            mode = "attribute";
+         } else if (this->type->qualifier.flags.q.uniform) {
+            mode = "uniform";
+         } else if (this->type->qualifier.flags.q.varying) {
+            mode = "varying";
+         } else if (this->type->qualifier.flags.q.in) {
+            mode = "in";
+            extra = " or in function parameter list";
+         } else if (this->type->qualifier.flags.q.out) {
+            mode = "out";
+            extra = " or in function parameter list";
+         }
+
+         if (mode) {
+            _mesa_glsl_error(& loc, state,
+                             "%s variable `%s' must be declared at "
+                             "global scope%s",
+                             mode, var->name, extra);
+         }
       } else if (var->data.mode == ir_var_shader_in) {
          var->data.read_only = true;
 
-	 if (state->stage == MESA_SHADER_VERTEX) {
-	    bool error_emitted = false;
-
-	    /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
-	     *
-	     *    "Vertex shader inputs can only be float, floating-point
-	     *    vectors, matrices, signed and unsigned integers and integer
-	     *    vectors. Vertex shader inputs can also form arrays of these
-	     *    types, but not structures."
-	     *
-	     * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
-	     *
-	     *    "Vertex shader inputs can only be float, floating-point
-	     *    vectors, matrices, signed and unsigned integers and integer
-	     *    vectors. They cannot be arrays or structures."
-	     *
-	     * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
-	     *
-	     *    "The attribute qualifier can be used only with float,
-	     *    floating-point vectors, and matrices. Attribute variables
-	     *    cannot be declared as arrays or structures."
+         if (state->stage == MESA_SHADER_VERTEX) {
+            bool error_emitted = false;
+
+            /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
+             *
+             *    "Vertex shader inputs can only be float, floating-point
+             *    vectors, matrices, signed and unsigned integers and integer
+             *    vectors. Vertex shader inputs can also form arrays of these
+             *    types, but not structures."
+             *
+             * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
+             *
+             *    "Vertex shader inputs can only be float, floating-point
+             *    vectors, matrices, signed and unsigned integers and integer
+             *    vectors. They cannot be arrays or structures."
+             *
+             * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
+             *
+             *    "The attribute qualifier can be used only with float,
+             *    floating-point vectors, and matrices. Attribute variables
+             *    cannot be declared as arrays or structures."
              *
              * From page 33 (page 39 of the PDF) of the GLSL ES 3.00 spec:
              *
@@ -3332,35 +3330,35 @@  ast_declarator_list::hir(exec_list *instructions,
              *    vectors, matrices, signed and unsigned integers and integer
              *    vectors. Vertex shader inputs cannot be arrays or
              *    structures."
-	     */
+             */
             const glsl_type *check_type = var->type;
             while (check_type->is_array())
                check_type = check_type->element_type();
 
-	    switch (check_type->base_type) {
-	    case GLSL_TYPE_FLOAT:
-	       break;
-	    case GLSL_TYPE_UINT:
-	    case GLSL_TYPE_INT:
-	       if (state->is_version(120, 300))
-		  break;
-	       /* FALLTHROUGH */
-	    default:
-	       _mesa_glsl_error(& loc, state,
-				"vertex shader input / attribute cannot have "
-				"type %s`%s'",
-				var->type->is_array() ? "array of " : "",
-				check_type->name);
-	       error_emitted = true;
-	    }
-
-	    if (!error_emitted && var->type->is_array() &&
+            switch (check_type->base_type) {
+            case GLSL_TYPE_FLOAT:
+            break;
+            case GLSL_TYPE_UINT:
+            case GLSL_TYPE_INT:
+               if (state->is_version(120, 300))
+                  break;
+            /* FALLTHROUGH */
+            default:
+               _mesa_glsl_error(& loc, state,
+                                "vertex shader input / attribute cannot have "
+                                "type %s`%s'",
+                                var->type->is_array() ? "array of " : "",
+                                check_type->name);
+               error_emitted = true;
+            }
+
+            if (!error_emitted && var->type->is_array() &&
                 !state->check_version(150, 0, &loc,
                                       "vertex shader input / attribute "
                                       "cannot have array type")) {
-	       error_emitted = true;
-	    }
-	 } else if (state->stage == MESA_SHADER_GEOMETRY) {
+               error_emitted = true;
+            }
+         } else if (state->stage == MESA_SHADER_GEOMETRY) {
             /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
              *
              *     Geometry shader input variables get the per-vertex values
@@ -3609,9 +3607,9 @@  ast_declarator_list::hir(exec_list *instructions,
       }
 
       if (decl->initializer != NULL) {
-	 result = process_initializer((earlier == NULL) ? var : earlier,
-				      decl, this->type,
-				      &initializer_instructions, state);
+         result = process_initializer((earlier == NULL) ? var : earlier,
+                                      decl, this->type,
+                                      &initializer_instructions, state);
       }
 
       /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:
@@ -3621,14 +3619,14 @@  ast_declarator_list::hir(exec_list *instructions,
        *      declared."
        */
       if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {
-	 _mesa_glsl_error(& loc, state,
-			  "const declaration of `%s' must be initialized",
-			  decl->identifier);
+         _mesa_glsl_error(& loc, state,
+                          "const declaration of `%s' must be initialized",
+                          decl->identifier);
       }
 
       if (state->es_shader) {
-	 const glsl_type *const t = (earlier == NULL)
-	    ? var->type : earlier->type;
+         const glsl_type *const t = (earlier == NULL)
+            ? var->type : earlier->type;
 
          if (t->is_unsized_array())
             /* Section 10.17 of the GLSL ES 1.00 specification states that
@@ -3660,32 +3658,32 @@  ast_declarator_list::hir(exec_list *instructions,
       if (earlier == NULL) {
          validate_identifier(decl->identifier, loc, state);
 
-	 /* Add the variable to the symbol table.  Note that the initializer's
-	  * IR was already processed earlier (though it hasn't been emitted
-	  * yet), without the variable in scope.
-	  *
-	  * This differs from most C-like languages, but it follows the GLSL
-	  * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50
-	  * spec:
-	  *
-	  *     "Within a declaration, the scope of a name starts immediately
-	  *     after the initializer if present or immediately after the name
-	  *     being declared if not."
-	  */
-	 if (!state->symbols->add_variable(var)) {
-	    YYLTYPE loc = this->get_location();
-	    _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
-			     "current scope", decl->identifier);
-	    continue;
-	 }
-
-	 /* Push the variable declaration to the top.  It means that all the
-	  * variable declarations will appear in a funny last-to-first order,
-	  * but otherwise we run into trouble if a function is prototyped, a
-	  * global var is decled, then the function is defined with usage of
-	  * the global var.  See glslparsertest's CorrectModule.frag.
-	  */
-	 instructions->push_head(var);
+         /* Add the variable to the symbol table.  Note that the initializer's
+          * IR was already processed earlier (though it hasn't been emitted
+          * yet), without the variable in scope.
+          *
+          * This differs from most C-like languages, but it follows the GLSL
+          * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50
+          * spec:
+          *
+          *     "Within a declaration, the scope of a name starts immediately
+          *     after the initializer if present or immediately after the name
+          *     being declared if not."
+          */
+         if (!state->symbols->add_variable(var)) {
+            YYLTYPE loc = this->get_location();
+            _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
+                             "current scope", decl->identifier);
+            continue;
+         }
+
+         /* Push the variable declaration to the top.  It means that all the
+          * variable declarations will appear in a funny last-to-first order,
+          * but otherwise we run into trouble if a function is prototyped, a
+          * global var is decled, then the function is defined with usage of
+          * the global var.  See glslparsertest's CorrectModule.frag.
+          */
+         instructions->push_head(var);
       }
 
       instructions->append_list(&initializer_instructions);
@@ -3718,13 +3716,13 @@  ast_parameter_declarator::hir(exec_list *instructions,
 
    if (type == NULL) {
       if (name != NULL) {
-	 _mesa_glsl_error(& loc, state,
-			  "invalid type `%s' in declaration of `%s'",
-			  name, this->identifier);
+         _mesa_glsl_error(& loc, state,
+                          "invalid type `%s' in declaration of `%s'",
+                          name, this->identifier);
       } else {
-	 _mesa_glsl_error(& loc, state,
-			  "invalid type in declaration of `%s'",
-			  this->identifier);
+         _mesa_glsl_error(& loc, state,
+                          "invalid type in declaration of `%s'",
+                          this->identifier);
       }
 
       type = glsl_type::error_type;
@@ -3744,8 +3742,8 @@  ast_parameter_declarator::hir(exec_list *instructions,
     */
    if (type->is_void()) {
       if (this->identifier != NULL)
-	 _mesa_glsl_error(& loc, state,
-			  "named parameter cannot have type `void'");
+         _mesa_glsl_error(& loc, state,
+                          "named parameter cannot have type `void'");
 
       is_void = true;
       return NULL;
@@ -3763,7 +3761,7 @@  ast_parameter_declarator::hir(exec_list *instructions,
 
    if (!type->is_error() && type->is_unsized_array()) {
       _mesa_glsl_error(&loc, state, "arrays passed as parameters must have "
-		       "a declared size");
+                       "a declared size");
       type = glsl_type::error_type;
    }
 
@@ -3833,7 +3831,7 @@  ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
       param->hir(ir_parameters, state);
 
       if (param->is_void)
-	 void_param = param;
+         void_param = param;
 
       count++;
    }
@@ -3842,7 +3840,7 @@  ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
       YYLTYPE loc = void_param->get_location();
 
       _mesa_glsl_error(& loc, state,
-		       "`void' parameter must be only parameter");
+                       "`void' parameter must be only parameter");
    }
 }
 
@@ -3961,20 +3959,20 @@  ast_function::hir(exec_list *instructions,
    if (f != NULL && (state->es_shader || f->has_user_signature())) {
       sig = f->exact_matching_signature(state, &hir_parameters);
       if (sig != NULL) {
-	 const char *badvar = sig->qualifiers_match(&hir_parameters);
-	 if (badvar != NULL) {
-	    YYLTYPE loc = this->get_location();
+         const char *badvar = sig->qualifiers_match(&hir_parameters);
+         if (badvar != NULL) {
+            YYLTYPE loc = this->get_location();
 
-	    _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
-			     "qualifiers don't match prototype", name, badvar);
-	 }
+            _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
+                             "qualifiers don't match prototype", name, badvar);
+         }
 
-	 if (sig->return_type != return_type) {
-	    YYLTYPE loc = this->get_location();
+         if (sig->return_type != return_type) {
+            YYLTYPE loc = this->get_location();
 
-	    _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
-			     "match prototype", name);
-	 }
+            _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
+                             "match prototype", name);
+         }
 
          if (sig->is_defined) {
             if (is_definition) {
@@ -3987,17 +3985,17 @@  ast_function::hir(exec_list *instructions,
                 */
                return NULL;
             }
-	 }
+         }
       }
    } else {
       f = new(ctx) ir_function(name);
       if (!state->symbols->add_function(f)) {
-	 /* This function name shadows a non-function use of the same name. */
-	 YYLTYPE loc = this->get_location();
+         /* This function name shadows a non-function use of the same name. */
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
-			  "non-function", name);
-	 return NULL;
+         _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
+                          "non-function", name);
+         return NULL;
       }
 
       emit_function(state, f);
@@ -4006,15 +4004,15 @@  ast_function::hir(exec_list *instructions,
    /* Verify the return type of main() */
    if (strcmp(name, "main") == 0) {
       if (! return_type->is_void()) {
-	 YYLTYPE loc = this->get_location();
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state, "main() must return void");
+         _mesa_glsl_error(& loc, state, "main() must return void");
       }
 
       if (!hir_parameters.is_empty()) {
-	 YYLTYPE loc = this->get_location();
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state, "main() must not take any parameters");
+         _mesa_glsl_error(& loc, state, "main() must not take any parameters");
       }
    }
 
@@ -4062,11 +4060,11 @@  ast_function_definition::hir(exec_list *instructions,
        * the same name.
        */
       if (state->symbols->name_declared_this_scope(var->name)) {
-	 YYLTYPE loc = this->get_location();
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
+         _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
       } else {
-	 state->symbols->add_variable(var);
+         state->symbols->add_variable(var);
       }
    }
 
@@ -4105,23 +4103,23 @@  ast_jump_statement::hir(exec_list *instructions,
       assert(state->current_function);
 
       if (opt_return_value) {
-	 ir_rvalue *ret = opt_return_value->hir(instructions, state);
-
-	 /* The value of the return type can be NULL if the shader says
-	  * 'return foo();' and foo() is a function that returns void.
-	  *
-	  * NOTE: The GLSL spec doesn't say that this is an error.  The type
-	  * of the return value is void.  If the return type of the function is
-	  * also void, then this should compile without error.  Seriously.
-	  */
-	 const glsl_type *const ret_type =
-	    (ret == NULL) ? glsl_type::void_type : ret->type;
+         ir_rvalue *ret = opt_return_value->hir(instructions, state);
+
+         /* The value of the return type can be NULL if the shader says
+          * 'return foo();' and foo() is a function that returns void.
+          *
+          * NOTE: The GLSL spec doesn't say that this is an error.  The type
+          * of the return value is void.  If the return type of the function is
+          * also void, then this should compile without error.  Seriously.
+          */
+         const glsl_type *const ret_type =
+            (ret == NULL) ? glsl_type::void_type : ret->type;
 
          /* Implicit conversions are not allowed for return values prior to
           * ARB_shading_language_420pack.
           */
          if (state->current_function->return_type != ret_type) {
-	    YYLTYPE loc = this->get_location();
+            YYLTYPE loc = this->get_location();
 
             if (state->ARB_shading_language_420pack_enable) {
                if (!apply_implicit_conversion(state->current_function->return_type,
@@ -4158,18 +4156,18 @@  ast_jump_statement::hir(exec_list *instructions,
                              "return argument");
          }
 
-	 inst = new(ctx) ir_return(ret);
+         inst = new(ctx) ir_return(ret);
       } else {
-	 if (state->current_function->return_type->base_type !=
-	     GLSL_TYPE_VOID) {
-	    YYLTYPE loc = this->get_location();
-
-	    _mesa_glsl_error(& loc, state,
-			     "`return' with no value, in function %s returning "
-			     "non-void",
-			     state->current_function->function_name());
-	 }
-	 inst = new(ctx) ir_return;
+         if (state->current_function->return_type->base_type !=
+             GLSL_TYPE_VOID) {
+            YYLTYPE loc = this->get_location();
+
+            _mesa_glsl_error(& loc, state,
+                             "`return' with no value, in function %s returning "
+                             "non-void",
+            state->current_function->function_name());
+         }
+         inst = new(ctx) ir_return;
       }
 
       state->found_return = true;
@@ -4179,10 +4177,10 @@  ast_jump_statement::hir(exec_list *instructions,
 
    case ast_discard:
       if (state->stage != MESA_SHADER_FRAGMENT) {
-	 YYLTYPE loc = this->get_location();
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state,
-			  "`discard' may only appear in a fragment shader");
+         _mesa_glsl_error(& loc, state,
+                          "`discard' may only appear in a fragment shader");
       }
       instructions->push_tail(new(ctx) ir_discard);
       break;
@@ -4190,26 +4188,25 @@  ast_jump_statement::hir(exec_list *instructions,
    case ast_break:
    case ast_continue:
       if (mode == ast_continue &&
-	  state->loop_nesting_ast == NULL) {
-	 YYLTYPE loc = this->get_location();
+          state->loop_nesting_ast == NULL) {
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state,
-			  "continue may only appear in a loop");
+         _mesa_glsl_error(& loc, state, "continue may only appear in a loop");
       } else if (mode == ast_break &&
-		 state->loop_nesting_ast == NULL &&
-		 state->switch_state.switch_nesting_ast == NULL) {
-	 YYLTYPE loc = this->get_location();
+         state->loop_nesting_ast == NULL &&
+         state->switch_state.switch_nesting_ast == NULL) {
+         YYLTYPE loc = this->get_location();
 
-	 _mesa_glsl_error(& loc, state,
-			  "break may only appear in a loop or a switch");
+         _mesa_glsl_error(& loc, state,
+                          "break may only appear in a loop or a switch");
       } else {
-	 /* For a loop, inline the for loop expression again, since we don't
-	  * know where near the end of the loop body the normal copy of it is
-	  * going to be placed.  Same goes for the condition for a do-while
-	  * loop.
-	  */
-	 if (state->loop_nesting_ast != NULL &&
-	     mode == ast_continue) {
+         /* For a loop, inline the for loop expression again, since we don't
+          * know where near the end of the loop body the normal copy of it is
+          * going to be placed.  Same goes for the condition for a do-while
+          * loop.
+          */
+         if (state->loop_nesting_ast != NULL &&
+             mode == ast_continue) {
             if (state->loop_nesting_ast->rest_expression) {
                state->loop_nesting_ast->rest_expression->hir(instructions,
                                                              state);
@@ -4220,26 +4217,26 @@  ast_jump_statement::hir(exec_list *instructions,
             }
          }
 
-	 if (state->switch_state.is_switch_innermost &&
-	     mode == ast_break) {
-	    /* Force break out of switch by setting is_break switch state.
-	     */
-	    ir_variable *const is_break_var = state->switch_state.is_break_var;
-	    ir_dereference_variable *const deref_is_break_var =
-	       new(ctx) ir_dereference_variable(is_break_var);
-	    ir_constant *const true_val = new(ctx) ir_constant(true);
-	    ir_assignment *const set_break_var =
-	       new(ctx) ir_assignment(deref_is_break_var, true_val);
+         if (state->switch_state.is_switch_innermost &&
+             mode == ast_break) {
+            /* Force break out of switch by setting is_break switch state.
+             */
+            ir_variable *const is_break_var = state->switch_state.is_break_var;
+            ir_dereference_variable *const deref_is_break_var =
+               new(ctx) ir_dereference_variable(is_break_var);
+            ir_constant *const true_val = new(ctx) ir_constant(true);
+            ir_assignment *const set_break_var =
+               new(ctx) ir_assignment(deref_is_break_var, true_val);
 	    
-	    instructions->push_tail(set_break_var);
-	 }
-	 else {
-	    ir_loop_jump *const jump = 
-	       new(ctx) ir_loop_jump((mode == ast_break)
-				     ? ir_loop_jump::jump_break
-				     : ir_loop_jump::jump_continue);
-	    instructions->push_tail(jump);
-	 }
+            instructions->push_tail(set_break_var);
+         }
+         else {
+            ir_loop_jump *const jump = 
+               new(ctx) ir_loop_jump((mode == ast_break)
+                  ? ir_loop_jump::jump_break
+                  : ir_loop_jump::jump_continue);
+            instructions->push_tail(jump);
+         }
       }
 
       break;
@@ -4483,62 +4480,57 @@  ast_case_label::hir(exec_list *instructions,
       ir_constant *label_const = label_rval->constant_expression_value();
 
       if (!label_const) {
-	 YYLTYPE loc = this->test_value->get_location();
+         YYLTYPE loc = this->test_value->get_location();
 
-	 _mesa_glsl_error(& loc, state,
-			  "switch statement case label must be a "
-			  "constant expression");
+         _mesa_glsl_error(& loc, state,
+                          "switch statement case label must be a "
+                          "constant expression");
 
-	 /* Stuff a dummy value in to allow processing to continue. */
-	 label_const = new(ctx) ir_constant(0);
+         /* Stuff a dummy value in to allow processing to continue. */
+         label_const = new(ctx) ir_constant(0);
       } else {
-	 ast_expression *previous_label = (ast_expression *)
-	    hash_table_find(state->switch_state.labels_ht,
-			    (void *)(uintptr_t)label_const->value.u[0]);
-
-	 if (previous_label) {
-	    YYLTYPE loc = this->test_value->get_location();
-	    _mesa_glsl_error(& loc, state,
-			     "duplicate case value");
-
-	    loc = previous_label->get_location();
-	    _mesa_glsl_error(& loc, state,
-			     "this is the previous case label");
-	 } else {
-	    hash_table_insert(state->switch_state.labels_ht,
-			      this->test_value,
-			      (void *)(uintptr_t)label_const->value.u[0]);
-	 }
+         ast_expression *previous_label = (ast_expression *)
+         hash_table_find(state->switch_state.labels_ht,
+                         (void *)(uintptr_t)label_const->value.u[0]);
+
+         if (previous_label) {
+            YYLTYPE loc = this->test_value->get_location();
+            _mesa_glsl_error(& loc, state, "duplicate case value");
+
+            loc = previous_label->get_location();
+            _mesa_glsl_error(& loc, state, "this is the previous case label");
+         } else {
+            hash_table_insert(state->switch_state.labels_ht,
+                              this->test_value,
+                              (void *)(uintptr_t)label_const->value.u[0]);
+         }
       }
 
       ir_dereference_variable *deref_test_var =
-	 new(ctx) ir_dereference_variable(state->switch_state.test_var);
+         new(ctx) ir_dereference_variable(state->switch_state.test_var);
 
       ir_rvalue *const test_cond = new(ctx) ir_expression(ir_binop_all_equal,
-							  label_const,
-							  deref_test_var);
+                                                          label_const,
+                                                          deref_test_var);
 
       ir_assignment *set_fallthru_on_test =
-	 new(ctx) ir_assignment(deref_fallthru_var,
-				true_val,
-				test_cond);
+         new(ctx) ir_assignment(deref_fallthru_var, true_val, test_cond);
 
       instructions->push_tail(set_fallthru_on_test);
    } else { /* default case */
       if (state->switch_state.previous_default) {
-	 YYLTYPE loc = this->get_location();
-	 _mesa_glsl_error(& loc, state,
-			  "multiple default labels in one switch");
+         YYLTYPE loc = this->get_location();
+         _mesa_glsl_error(& loc, state,
+                          "multiple default labels in one switch");
 
-	 loc = state->switch_state.previous_default->get_location();
-	 _mesa_glsl_error(& loc, state,
-			  "this is the first default label");
+         loc = state->switch_state.previous_default->get_location();
+         _mesa_glsl_error(& loc, state, "this is the first default label");
       }
       state->switch_state.previous_default = this;
 
       /* Set falltrhu state. */
       ir_assignment *set_fallthru =
-	 new(ctx) ir_assignment(deref_fallthru_var, true_val);
+         new(ctx) ir_assignment(deref_fallthru_var, true_val);
 
       instructions->push_tail(set_fallthru);
    }
@@ -4555,28 +4547,28 @@  ast_iteration_statement::condition_to_hir(exec_list *instructions,
 
    if (condition != NULL) {
       ir_rvalue *const cond =
-	 condition->hir(instructions, state);
+         condition->hir(instructions, state);
 
       if ((cond == NULL)
-	  || !cond->type->is_boolean() || !cond->type->is_scalar()) {
-	 YYLTYPE loc = condition->get_location();
+          || !cond->type->is_boolean() || !cond->type->is_scalar()) {
+         YYLTYPE loc = condition->get_location();
 
-	 _mesa_glsl_error(& loc, state,
-			  "loop condition must be scalar boolean");
+         _mesa_glsl_error(& loc, state,
+                          "loop condition must be scalar boolean");
       } else {
-	 /* As the first code in the loop body, generate a block that looks
-	  * like 'if (!condition) break;' as the loop termination condition.
-	  */
-	 ir_rvalue *const not_cond =
-	    new(ctx) ir_expression(ir_unop_logic_not, cond);
+         /* As the first code in the loop body, generate a block that looks
+          * like 'if (!condition) break;' as the loop termination condition.
+          */
+         ir_rvalue *const not_cond =
+            new(ctx) ir_expression(ir_unop_logic_not, cond);
 
-	 ir_if *const if_stmt = new(ctx) ir_if(not_cond);
+         ir_if *const if_stmt = new(ctx) ir_if(not_cond);
 
-	 ir_jump *const break_stmt =
-	    new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
+         ir_jump *const break_stmt =
+            new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
 
-	 if_stmt->then_instructions.push_tail(break_stmt);
-	 instructions->push_tail(if_stmt);
+         if_stmt->then_instructions.push_tail(break_stmt);
+         instructions->push_tail(if_stmt);
       }
    }
 }
@@ -4798,10 +4790,10 @@  ast_type_specifier::hir(exec_list *instructions,
  */
 unsigned
 ast_process_structure_or_interface_block(exec_list *instructions,
-					 struct _mesa_glsl_parse_state *state,
-					 exec_list *declarations,
-					 YYLTYPE &loc,
-					 glsl_struct_field **fields_ret,
+                                         struct _mesa_glsl_parse_state *state,
+                                         exec_list *declarations,
+                                         YYLTYPE &loc,
+                                         glsl_struct_field **fields_ret,
                                          bool is_interface,
                                          bool block_row_major,
                                          bool allow_reserved_names,
@@ -4816,7 +4808,7 @@  ast_process_structure_or_interface_block(exec_list *instructions,
     */
    foreach_list_typed (ast_declarator_list, decl_list, link, declarations) {
       foreach_list_const (decl_ptr, & decl_list->declarations) {
-	 decl_count++;
+         decl_count++;
       }
    }
 
@@ -4838,15 +4830,15 @@  ast_process_structure_or_interface_block(exec_list *instructions,
        * embedded structure definitions have been removed from the language.
        */
       if (state->es_shader && decl_list->type->specifier->structure != NULL) {
-	 _mesa_glsl_error(&loc, state, "embedded structure definitions are "
-			  "not allowed in GLSL ES 1.00");
+         _mesa_glsl_error(&loc, state, "embedded structure definitions are "
+                          "not allowed in GLSL ES 1.00");
       }
 
       const glsl_type *decl_type =
          decl_list->type->glsl_type(& type_name, state);
 
       foreach_list_typed (ast_declaration, decl, link,
-			  &decl_list->declarations) {
+                          &decl_list->declarations) {
          if (!allow_reserved_names)
             validate_identifier(decl->identifier, loc, state);
 
@@ -4901,10 +4893,10 @@  ast_process_structure_or_interface_block(exec_list *instructions,
                              "members");
          }
 
-	 field_type = process_array_type(&loc, decl_type,
+         field_type = process_array_type(&loc, decl_type,
                                          decl->array_specifier, state);
          fields[i].type = field_type;
-	 fields[i].name = decl->identifier;
+         fields[i].name = decl->identifier;
          fields[i].location = -1;
          fields[i].interpolation =
             interpret_interpolation_qualifier(qual, var_mode, state, &loc);
@@ -4935,7 +4927,7 @@  ast_process_structure_or_interface_block(exec_list *instructions,
                fields[i].row_major = false;
          }
 
-	 i++;
+      i++;
       }
    }
 
@@ -4982,10 +4974,10 @@  ast_struct_specifier::hir(exec_list *instructions,
    glsl_struct_field *fields;
    unsigned decl_count =
       ast_process_structure_or_interface_block(instructions,
-					       state,
-					       &this->declarations,
-					       loc,
-					       &fields,
+                                               state,
+                                               &this->declarations,
+                                               loc,
+                                               &fields,
                                                false,
                                                false,
                                                false /* allow_reserved_names */,
@@ -5003,9 +4995,9 @@  ast_struct_specifier::hir(exec_list *instructions,
 				     const glsl_type *,
 				     state->num_user_structures + 1);
       if (s != NULL) {
-	 s[state->num_user_structures] = t;
-	 state->user_structures = s;
-	 state->num_user_structures++;
+         s[state->num_user_structures] = t;
+         state->user_structures = s;
+         state->num_user_structures++;
       }
    }
 
@@ -5570,18 +5562,18 @@  detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
       ir_variable *var = ((ir_instruction *)node)->as_variable();
 
       if (!var || !var->data.assigned)
-	 continue;
+         continue;
 
       if (strcmp(var->name, "gl_FragColor") == 0)
-	 gl_FragColor_assigned = true;
+         gl_FragColor_assigned = true;
       else if (strcmp(var->name, "gl_FragData") == 0)
-	 gl_FragData_assigned = true;
+         gl_FragData_assigned = true;
       else if (strncmp(var->name, "gl_", 3) != 0) {
-	 if (state->stage == MESA_SHADER_FRAGMENT &&
-	     var->data.mode == ir_var_shader_out) {
-	    user_defined_fs_output_assigned = true;
-	    user_defined_fs_output = var;
-	 }
+         if (state->stage == MESA_SHADER_FRAGMENT &&
+             var->data.mode == ir_var_shader_out) {
+            user_defined_fs_output_assigned = true;
+            user_defined_fs_output = var;
+         }
       }
    }
 

Comments

Oof... that's a giant wall of text. :(  I skimmed this patch, and it
mostly looks right.  I made a couple comments below.  I've pruned out
hunks that did not have comments.

On 04/11/2014 03:52 AM, Iago Toral Quiroga wrote:
> ---
>  src/glsl/ast_to_hir.cpp | 1344 +++++++++++++++++++++++------------------------
>  1 file changed, 668 insertions(+), 676 deletions(-)
> 
> diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
> index b70b628..9760534 100644
> --- a/src/glsl/ast_to_hir.cpp
> +++ b/src/glsl/ast_to_hir.cpp
> @@ -792,30 +792,29 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
>        if (non_lvalue_description != NULL) {
>           _mesa_glsl_error(&lhs_loc, state,
>                            "assignment to %s",
> -			  non_lvalue_description);
> -	 error_emitted = true;
> +                          non_lvalue_description);
> +         error_emitted = true;
>        } else if (lhs->variable_referenced() != NULL
> -		 && lhs->variable_referenced()->data.read_only) {
> +                 && lhs->variable_referenced()->data.read_only) {
>           _mesa_glsl_error(&lhs_loc, state,
>                            "assignment to read-only variable '%s'",
>                            lhs->variable_referenced()->name);
>           error_emitted = true;
> -
>        } else if (lhs->type->is_array() &&
>                   !state->check_version(120, 300, &lhs_loc,
>                                         "whole array assignment forbidden")) {
> -	 /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
> -	  *
> -	  *    "Other binary or unary expressions, non-dereferenced
> -	  *     arrays, function names, swizzles with repeated fields,
> -	  *     and constants cannot be l-values."
> -          *
> -          * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
> -	  */
> -	 error_emitted = true;
> +       /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
> +        *
> +        *    "Other binary or unary expressions, non-dereferenced
> +        *     arrays, function names, swizzles with repeated fields,
> +        *     and constants cannot be l-values."
> +        *
> +        * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
> +        */
> +         error_emitted = true;

This indentation looks fishy.  It seems like the comment block should be
indented more.  Just looking at the patch is hard...

>        } else if (!lhs->is_lvalue()) {
> -	 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
> -	 error_emitted = true;
> +         _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
> +         error_emitted = true;
>        }
>     }
>  
> @@ -830,24 +829,24 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
>         * is either not an l-value or not a whole array.
>         */
>        if (lhs->type->is_unsized_array()) {
> -	 ir_dereference *const d = lhs->as_dereference();
> +         ir_dereference *const d = lhs->as_dereference();
>  
> -	 assert(d != NULL);
> +         assert(d != NULL);
>  
> -	 ir_variable *const var = d->variable_referenced();
> +         ir_variable *const var = d->variable_referenced();
>  
> -	 assert(var != NULL);
> +         assert(var != NULL);
>  
> -	 if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
> -	    /* FINISHME: This should actually log the location of the RHS. */
> -	    _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
> -			     "previous access",
> -			     var->data.max_array_access);
> -	 }
> +         if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
> +            /* FINISHME: This should actually log the location of the RHS. */
> +            _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
> +               "previous access",
> +               var->data.max_array_access);

This also looks wrong.  The later lines should match with the (.

I'm going to copy-and-paste this comment other places...

> +         }
>  
> -	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),
> -						   rhs->type->array_size());
> -	 d->type = var->type;
> +         var->type = glsl_type::get_array_instance(lhs->type->element_type(),
> +                        rhs->type->array_size());
> +         d->type = var->type;
>        }
>        if (lhs->type->is_array()) {
>           mark_whole_array_access(rhs);
> @@ -951,19 +950,19 @@ do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
>  
>     case GLSL_TYPE_ARRAY: {
>        for (unsigned int i = 0; i < op0->type->length; i++) {
> -	 ir_rvalue *e0, *e1, *result;
> -
> -	 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
> -						new(mem_ctx) ir_constant(i));
> -	 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
> -						new(mem_ctx) ir_constant(i));
> -	 result = do_comparison(mem_ctx, operation, e0, e1);
> -
> -	 if (cmp) {
> -	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
> -	 } else {
> -	    cmp = result;
> -	 }
> +         ir_rvalue *e0, *e1, *result;
> +
> +         e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
> +                              new(mem_ctx) ir_constant(i));
> +         e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
> +                              new(mem_ctx) ir_constant(i));

This also looks wrong.  The later lines should match with the (.

> +         result = do_comparison(mem_ctx, operation, e0, e1);
> +
> +         if (cmp) {
> +            cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
> +         } else {
> +            cmp = result;
> +         }
>        }
>  
>        mark_whole_array_access(op0);
> @@ -973,20 +972,20 @@ do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
>  
>     case GLSL_TYPE_STRUCT: {
>        for (unsigned int i = 0; i < op0->type->length; i++) {
> -	 ir_rvalue *e0, *e1, *result;
> -	 const char *field_name = op0->type->fields.structure[i].name;
> -
> -	 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
> -						 field_name);
> -	 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
> -						 field_name);
> -	 result = do_comparison(mem_ctx, operation, e0, e1);
> -
> -	 if (cmp) {
> -	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
> -	 } else {
> -	    cmp = result;
> -	 }
> +         ir_rvalue *e0, *e1, *result;
> +         const char *field_name = op0->type->fields.structure[i].name;
> +
> +         e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
> +                              field_name);
> +         e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
> +                              field_name);

This also looks wrong.  The later lines should match with the (.

> +         result = do_comparison(mem_ctx, operation, e0, e1);
> +
> +         if (cmp) {
> +            cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
> +         } else {
> +            cmp = result;
> +         }
>        }
>        break;
>     }
Thanks for reviewing and sorry for the huge patch, unfortunately
indentation was wrong all over the place, so it was this or a large number
of smaller patches :-(

I fixed the issues you found and completed the patch to fix some other things
that I missed in my previous patch, mostly about wrong indentation of function
parameters and wrong alignment of parameters for various function calls.

Iago Toral Quiroga (1):
  glsl: Fix incorrect indentation.

 src/glsl/ast_to_hir.cpp | 1575 +++++++++++++++++++++++------------------------
 1 file changed, 782 insertions(+), 793 deletions(-)