int
c_value_print (struct value *val, struct ui_file *stream, int format,
enum val_prettyprint pretty)
{
struct type *type, *real_type;
int full, top, using_enc;
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
C++: if it is a member pointer, we will take care
of that when we print it. */
type = check_typedef (value_type (val));
if (TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway. */
if (TYPE_CODE (type) == TYPE_CODE_PTR
&& TYPE_NAME (type) == NULL
&& TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
&& strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
{
/* Print nothing */
}
else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
if (TYPE_CODE(type) == TYPE_CODE_REF)
{
/* Copy value, change to pointer, so we don't get an
* error about a non-pointer type in value_rtti_target_type
*/
struct value *temparg;
temparg=value_copy(val);
deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
val=temparg;
}
/* Pointer to class, check real type of object */
fprintf_filtered (stream, "(");
real_type = value_rtti_target_type (val, &full, &top, &using_enc);
if (real_type)
{
/* RTTI entry found */
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
/* create a pointer type pointing to the real type */
type = lookup_pointer_type (real_type);
}
else
{
/* create a reference type referencing the real type */
type = lookup_reference_type (real_type);
}
/* JYG: Need to adjust pointer value. */
/* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
value_contents_writeable (val)[0] -= top;
/* Note: When we look up RTTI entries, we don't get any
information on const or volatile attributes */
}
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
else
{
/* normal case */
fprintf_filtered (stream, "(");
type_print (value_type (val), "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
/* APPLE LOCAL begin variable initialized status. */
if (value_var_status (val) == 0)
fprintf_filtered (stream, " [uninitialized] ");
/* APPLE LOCAL end variable initialized status. */
if (objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
{
/* Attempt to determine real type of object */
real_type = value_rtti_type (val, &full, &top, &using_enc);
if (real_type)
{
/* We have RTTI information, so use it */
val = value_full_object (val, real_type, full, top, using_enc);
fprintf_filtered (stream, "(%s%s) ",
TYPE_NAME (real_type),
full ? "" : _(" [incomplete object]"));
/* Print out object: enclosing type is same as real_type if full */
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
/* Note: When we look up RTTI entries, we don't get any information on
const or volatile attributes */
}
else if (type != check_typedef (value_enclosing_type (val)))
{
/* No RTTI information, so let's do our best */
fprintf_filtered (stream, "(%s ?) ",
TYPE_NAME (value_enclosing_type (val)));
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
}
/* Otherwise, we end up at the return outside this "if" */
}
real_type = get_closure_dynamic_type (val);
if (real_type)
type = real_type;
return val_print (type, value_contents_all (val),
value_embedded_offset (val),
VALUE_ADDRESS (val) + value_offset (val),
stream, format, 1, 0, pretty);
}
int
c_value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options)
{
struct type *type, *real_type, *val_type;
int full, top, using_enc;
struct value_print_options opts = *options;
opts.deref_ref = 1;
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
C++: if it is a member pointer, we will take care
of that when we print it. */
/* Preserve the original type before stripping typedefs. We prefer
to pass down the original type when possible, but for local
checks it is better to look past the typedefs. */
val_type = value_type (val);
type = check_typedef (val_type);
if (TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway.
(Don't use c_textual_element_type here; quoted strings
are always exactly (char *), (wchar_t *), or the like. */
if (TYPE_CODE (val_type) == TYPE_CODE_PTR
&& TYPE_NAME (val_type) == NULL
&& TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
&& (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)), "char") == 0
|| textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
{
/* Print nothing */
}
else if (options->objectprint
&& (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
if (TYPE_CODE(type) == TYPE_CODE_REF)
{
/* Copy value, change to pointer, so we don't get an
* error about a non-pointer type in value_rtti_target_type
*/
struct value *temparg;
temparg=value_copy(val);
deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
val=temparg;
}
/* Pointer to class, check real type of object */
fprintf_filtered (stream, "(");
real_type = value_rtti_target_type (val, &full, &top, &using_enc);
if (real_type)
{
/* RTTI entry found */
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
/* create a pointer type pointing to the real type */
type = lookup_pointer_type (real_type);
}
else
{
/* create a reference type referencing the real type */
type = lookup_reference_type (real_type);
}
/* JYG: Need to adjust pointer value. */
/* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
value_contents_writeable (val)[0] -= top;
/* Note: When we look up RTTI entries, we don't get any
information on const or volatile attributes */
}
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
val_type = type;
}
else
{
/* normal case */
fprintf_filtered (stream, "(");
type_print (value_type (val), "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
if (!value_initialized (val))
fprintf_filtered (stream, " [uninitialized] ");
if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
{
/* Attempt to determine real type of object */
real_type = value_rtti_type (val, &full, &top, &using_enc);
if (real_type)
{
/* We have RTTI information, so use it */
val = value_full_object (val, real_type, full, top, using_enc);
fprintf_filtered (stream, "(%s%s) ",
TYPE_NAME (real_type),
full ? "" : _(" [incomplete object]"));
/* Print out object: enclosing type is same as real_type if full */
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
value_address (val), stream, 0,
&opts, current_language);
/* Note: When we look up RTTI entries, we don't get any information on
const or volatile attributes */
}
else if (type != check_typedef (value_enclosing_type (val)))
{
/* No RTTI information, so let's do our best */
fprintf_filtered (stream, "(%s ?) ",
TYPE_NAME (value_enclosing_type (val)));
return val_print (value_enclosing_type (val),
value_contents_all (val), 0,
value_address (val), stream, 0,
&opts, current_language);
}
/* Otherwise, we end up at the return outside this "if" */
}
return val_print (val_type, value_contents_all (val),
value_embedded_offset (val),
value_address (val),
stream, 0, &opts, current_language);
}
void
c_value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options)
{
struct type *type, *real_type, *val_type;
int full, top, using_enc;
struct value_print_options opts = *options;
opts.deref_ref = 1;
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
C++: if it is a member pointer, we will take care
of that when we print it. */
/* Preserve the original type before stripping typedefs. We prefer
to pass down the original type when possible, but for local
checks it is better to look past the typedefs. */
val_type = value_type (val);
type = check_typedef (val_type);
if (TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway.
(Don't use c_textual_element_type here; quoted strings
are always exactly (char *), (wchar_t *), or the like. */
if (TYPE_CODE (val_type) == TYPE_CODE_PTR
&& TYPE_NAME (val_type) == NULL
&& TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
&& (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
"char") == 0
|| textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
{
/* Print nothing. */
}
else if (options->objectprint
&& (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
if (is_ref)
val = value_addr (val);
/* Pointer to class, check real type of object. */
fprintf_filtered (stream, "(");
if (value_entirely_available (val))
{
real_type = value_rtti_indirect_type (val, &full, &top,
&using_enc);
if (real_type)
{
/* RTTI entry found. */
type = real_type;
/* Need to adjust pointer value. */
val = value_from_pointer (real_type,
value_as_address (val) - top);
if (is_ref)
{
val = value_ref (value_ind (val));
type = value_type (val);
}
/* Note: When we look up RTTI entries, we don't get
any information on const or volatile
attributes. */
}
}
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
val_type = type;
}
else
{
/* normal case */
fprintf_filtered (stream, "(");
type_print (value_type (val), "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
if (!value_initialized (val))
fprintf_filtered (stream, " [uninitialized] ");
if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
{
/* Attempt to determine real type of object. */
real_type = value_rtti_type (val, &full, &top, &using_enc);
if (real_type)
{
/* We have RTTI information, so use it. */
val = value_full_object (val, real_type,
full, top, using_enc);
fprintf_filtered (stream, "(%s%s) ",
TYPE_NAME (real_type),
full ? "" : _(" [incomplete object]"));
/* Print out object: enclosing type is same as real_type if
full. */
val_print (value_enclosing_type (val),
value_contents_for_printing (val), 0,
value_address (val), stream, 0,
val, &opts, current_language);
return;
/* Note: When we look up RTTI entries, we don't get any
information on const or volatile attributes. */
}
else if (type != check_typedef (value_enclosing_type (val)))
{
/* No RTTI information, so let's do our best. */
fprintf_filtered (stream, "(%s ?) ",
TYPE_NAME (value_enclosing_type (val)));
val_print (value_enclosing_type (val),
value_contents_for_printing (val), 0,
value_address (val), stream, 0,
val, &opts, current_language);
return;
}
/* Otherwise, we end up at the return outside this "if". */
}
val_print (val_type, value_contents_for_printing (val),
value_embedded_offset (val),
value_address (val),
stream, 0,
val, &opts, current_language);
}
int
c_value_print (value_ptr val, struct ui_file *stream, int format,
enum val_prettyprint pretty)
{
struct type *type = VALUE_TYPE (val);
struct type *real_type;
int full, top, using_enc;
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
C++: if it is a member pointer, we will take care
of that when we print it. */
if (TYPE_CODE (type) == TYPE_CODE_PTR ||
TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway. */
if (TYPE_CODE (type) == TYPE_CODE_PTR &&
TYPE_NAME (type) == NULL &&
TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL &&
STREQ (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char"))
{
/* Print nothing */
}
else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
if (TYPE_CODE(type) == TYPE_CODE_REF)
{
/* Copy value, change to pointer, so we don't get an
* error about a non-pointer type in value_rtti_target_type
*/
value_ptr temparg;
temparg=value_copy(val);
VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type));
val=temparg;
}
/* Pointer to class, check real type of object */
fprintf_filtered (stream, "(");
real_type = value_rtti_target_type (val, &full, &top, &using_enc);
if (real_type)
{
/* RTTI entry found */
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
/* create a pointer type pointing to the real type */
type = lookup_pointer_type (real_type);
}
else
{
/* create a reference type referencing the real type */
type = lookup_reference_type (real_type);
}
/* JYG: Need to adjust pointer value. */
val->aligner.contents[0] -= top;
/* Note: When we look up RTTI entries, we don't get any
information on const or volatile attributes */
}
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
else
{
/* normal case */
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
if (objectprint && (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_CLASS))
{
/* Attempt to determine real type of object */
real_type = value_rtti_type (val, &full, &top, &using_enc);
if (real_type)
{
/* We have RTTI information, so use it */
val = value_full_object (val, real_type, full, top, using_enc);
fprintf_filtered (stream, "(%s%s) ",
TYPE_NAME (real_type),
full ? "" : " [incomplete object]");
/* Print out object: enclosing type is same as real_type if full */
return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
/* Note: When we look up RTTI entries, we don't get any information on
const or volatile attributes */
}
else if (type != VALUE_ENCLOSING_TYPE (val))
{
/* No RTTI information, so let's do our best */
fprintf_filtered (stream, "(%s ?) ",
TYPE_NAME (VALUE_ENCLOSING_TYPE (val)));
return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
}
/* Otherwise, we end up at the return outside this "if" */
}
return val_print (type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val),
VALUE_ADDRESS (val),
stream, format, 1, 0, pretty);
}
