[pushed/Ada 1/3] Fix indentation level in ada-lang.c::ada_evaluate_subexp.

[Joel Brobecker <brobecker at adacore dot com>]

I just happen to notice that a lexical block was missing one
indentation level.

gdb/ChangeLog:

        * ada-lang.c (ada_evaluate_subexp) <OP_VAR_VALUE>: Fix identation
        of lexical block.
---
 gdb/ChangeLog  |  5 ++++
 gdb/ada-lang.c | 88 +++++++++++++++++++++++++++++-----------------------------
 2 files changed, 49 insertions(+), 44 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0c5e3a1..8cb2f18 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2014-08-18  Joel Brobecker  <brobecker@adacore.com>
+
+	* ada-lang.c (ada_evaluate_subexp) <OP_VAR_VALUE>: Fix identation
+	of lexical block.
+
 2014-08-15  Siva Chandra Reddy  <sivachandra@google.com>
 
 	PR c++/17132
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 32f1b39..334df1f 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -10138,50 +10138,50 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
           if (ada_is_tagged_type (type, 0)
               || (TYPE_CODE (type) == TYPE_CODE_REF
                   && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
-          {
-            /* Tagged types are a little special in the fact that the real
-               type is dynamic and can only be determined by inspecting the
-               object's tag.  This means that we need to get the object's
-               value first (EVAL_NORMAL) and then extract the actual object
-               type from its tag.
-
-               Note that we cannot skip the final step where we extract
-               the object type from its tag, because the EVAL_NORMAL phase
-               results in dynamic components being resolved into fixed ones.
-               This can cause problems when trying to print the type
-               description of tagged types whose parent has a dynamic size:
-               We use the type name of the "_parent" component in order
-               to print the name of the ancestor type in the type description.
-               If that component had a dynamic size, the resolution into
-               a fixed type would result in the loss of that type name,
-               thus preventing us from printing the name of the ancestor
-               type in the type description.  */
-            arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
-
-	    if (TYPE_CODE (type) != TYPE_CODE_REF)
-	      {
-		struct type *actual_type;
-
-		actual_type = type_from_tag (ada_value_tag (arg1));
-		if (actual_type == NULL)
-		  /* If, for some reason, we were unable to determine
-		     the actual type from the tag, then use the static
-		     approximation that we just computed as a fallback.
-		     This can happen if the debugging information is
-		     incomplete, for instance.  */
-		  actual_type = type;
-		return value_zero (actual_type, not_lval);
-	      }
-	    else
-	      {
-		/* In the case of a ref, ada_coerce_ref takes care
-		   of determining the actual type.  But the evaluation
-		   should return a ref as it should be valid to ask
-		   for its address; so rebuild a ref after coerce.  */
-		arg1 = ada_coerce_ref (arg1);
-		return value_ref (arg1);
-	      }
-          }
+	    {
+	      /* Tagged types are a little special in the fact that the real
+		 type is dynamic and can only be determined by inspecting the
+		 object's tag.  This means that we need to get the object's
+		 value first (EVAL_NORMAL) and then extract the actual object
+		 type from its tag.
+
+		 Note that we cannot skip the final step where we extract
+		 the object type from its tag, because the EVAL_NORMAL phase
+		 results in dynamic components being resolved into fixed ones.
+		 This can cause problems when trying to print the type
+		 description of tagged types whose parent has a dynamic size:
+		 We use the type name of the "_parent" component in order
+		 to print the name of the ancestor type in the type description.
+		 If that component had a dynamic size, the resolution into
+		 a fixed type would result in the loss of that type name,
+		 thus preventing us from printing the name of the ancestor
+		 type in the type description.  */
+	      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
+
+	      if (TYPE_CODE (type) != TYPE_CODE_REF)
+		{
+		  struct type *actual_type;
+
+		  actual_type = type_from_tag (ada_value_tag (arg1));
+		  if (actual_type == NULL)
+		    /* If, for some reason, we were unable to determine
+		       the actual type from the tag, then use the static
+		       approximation that we just computed as a fallback.
+		       This can happen if the debugging information is
+		       incomplete, for instance.  */
+		    actual_type = type;
+		  return value_zero (actual_type, not_lval);
+		}
+	      else
+		{
+		  /* In the case of a ref, ada_coerce_ref takes care
+		     of determining the actual type.  But the evaluation
+		     should return a ref as it should be valid to ask
+		     for its address; so rebuild a ref after coerce.  */
+		  arg1 = ada_coerce_ref (arg1);
+		  return value_ref (arg1);
+		}
+	    }
 
           *pos += 4;
           return value_zero (to_static_fixed_type (type), not_lval);
-- 
1.9.1