From 0d72a7c318b83384973583323f8c7d54bf1bbffa Mon Sep 17 00:00:00 2001 From: Joel Brobecker Date: Thu, 14 Aug 2014 13:26:34 -0700 Subject: [PATCH] Fix indentation level in ada-lang.c::ada_evaluate_subexp. I just happen to notice that a lexical block was missing one indentation level. gdb/ChangeLog: * ada-lang.c (ada_evaluate_subexp) : 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 + + * ada-lang.c (ada_evaluate_subexp) : Fix identation + of lexical block. + 2014-08-15 Siva Chandra Reddy 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); -- 2.7.4