Delete #if 0'd out code.
* language.c (binop_result_type): Delete. (simple_type, ordered_type, same_type, integral_type): Delete. (numeric_type, character_type, string_type, boolean_type): Delete. (float_type, structured_type): Delete. * language.h: Update.
This commit is contained in:
Doug Evans
parent
0f5b75627b
commit
5953832c5a
|
|
@ -1,3 +1,12 @@
|
|||
2012-01-04 Doug Evans <dje@google.com>
|
||||
|
||||
Delete #if 0'd out code.
|
||||
* language.c (binop_result_type): Delete.
|
||||
(simple_type, ordered_type, same_type, integral_type): Delete.
|
||||
(numeric_type, character_type, string_type, boolean_type): Delete.
|
||||
(float_type, structured_type): Delete.
|
||||
* language.h: Update.
|
||||
|
||||
2012-01-04 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* python/py-value.c (valpy_binop): Initialize 'res_val'.
|
||||
|
|
|
|||
266
gdb/language.c
266
gdb/language.c
|
|
@ -470,243 +470,6 @@ language_info (int quietly)
|
|||
}
|
||||
}
|
||||
|
||||
/* Return the result of a binary operation. */
|
||||
|
||||
#if 0 /* Currently unused */
|
||||
|
||||
struct type *
|
||||
binop_result_type (struct value *v1, struct value *v2)
|
||||
{
|
||||
int size, uns;
|
||||
struct type *t1 = check_typedef (VALUE_TYPE (v1));
|
||||
struct type *t2 = check_typedef (VALUE_TYPE (v2));
|
||||
|
||||
int l1 = TYPE_LENGTH (t1);
|
||||
int l2 = TYPE_LENGTH (t2);
|
||||
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
if (TYPE_CODE (t1) == TYPE_CODE_FLT)
|
||||
return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
|
||||
VALUE_TYPE (v2) : VALUE_TYPE (v1);
|
||||
else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
|
||||
return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
|
||||
VALUE_TYPE (v1) : VALUE_TYPE (v2);
|
||||
else if (TYPE_UNSIGNED (t1) && l1 > l2)
|
||||
return VALUE_TYPE (v1);
|
||||
else if (TYPE_UNSIGNED (t2) && l2 > l1)
|
||||
return VALUE_TYPE (v2);
|
||||
else /* Both are signed. Result is the
|
||||
longer type. */
|
||||
return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
|
||||
break;
|
||||
case language_m2:
|
||||
/* If we are doing type-checking, l1 should equal l2, so this is
|
||||
not needed. */
|
||||
return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
|
||||
break;
|
||||
}
|
||||
internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
|
||||
return (struct type *) 0; /* For lint */
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
#if 0
|
||||
/* This page contains functions that are used in type/range checking.
|
||||
They all return zero if the type/range check fails.
|
||||
|
||||
It is hoped that these will make extending GDB to parse different
|
||||
languages a little easier. These are primarily used in eval.c when
|
||||
evaluating expressions and making sure that their types are correct.
|
||||
Instead of having a mess of conjucted/disjuncted expressions in an "if",
|
||||
the ideas of type can be wrapped up in the following functions.
|
||||
|
||||
Note that some of them are not currently dependent upon which language
|
||||
is currently being parsed. For example, floats are the same in
|
||||
C and Modula-2 (ie. the only floating point type has TYPE_CODE of
|
||||
TYPE_CODE_FLT), while booleans are different. */
|
||||
|
||||
/* Returns non-zero if its argument is a simple type. This is the same for
|
||||
both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur,
|
||||
and thus will never cause the failure of the test. */
|
||||
int
|
||||
simple_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_INT:
|
||||
case TYPE_CODE_CHAR:
|
||||
case TYPE_CODE_ENUM:
|
||||
case TYPE_CODE_FLT:
|
||||
case TYPE_CODE_RANGE:
|
||||
case TYPE_CODE_BOOL:
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if its argument is of an ordered type.
|
||||
An ordered type is one in which the elements can be tested for the
|
||||
properties of "greater than", "less than", etc, or for which the
|
||||
operations "increment" or "decrement" make sense. */
|
||||
int
|
||||
ordered_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_INT:
|
||||
case TYPE_CODE_CHAR:
|
||||
case TYPE_CODE_ENUM:
|
||||
case TYPE_CODE_FLT:
|
||||
case TYPE_CODE_RANGE:
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if the two types are the same. */
|
||||
int
|
||||
same_type (struct type *arg1, struct type *arg2)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
if (structured_type (arg1)
|
||||
? !structured_type (arg2) : structured_type (arg2))
|
||||
/* One is structured and one isn't. */
|
||||
return 0;
|
||||
else if (structured_type (arg1) && structured_type (arg2))
|
||||
return arg1 == arg2;
|
||||
else if (numeric_type (arg1) && numeric_type (arg2))
|
||||
return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
|
||||
(TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
|
||||
? 1 : 0;
|
||||
else
|
||||
return arg1 == arg2;
|
||||
}
|
||||
|
||||
/* Returns non-zero if the type is integral. */
|
||||
int
|
||||
integral_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
return (TYPE_CODE (type) != TYPE_CODE_INT) &&
|
||||
(TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
|
||||
case language_m2:
|
||||
case language_pascal:
|
||||
return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
|
||||
default:
|
||||
error (_("Language not supported."));
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if the value is numeric. */
|
||||
int
|
||||
numeric_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_INT:
|
||||
case TYPE_CODE_FLT:
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if the value is a character type. */
|
||||
int
|
||||
character_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_m2:
|
||||
case language_pascal:
|
||||
return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
|
||||
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
return (TYPE_CODE (type) == TYPE_CODE_INT) &&
|
||||
TYPE_LENGTH (type) == sizeof (char)
|
||||
? 1 : 0;
|
||||
default:
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if the value is a string type. */
|
||||
int
|
||||
string_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_m2:
|
||||
case language_pascal:
|
||||
return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
|
||||
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
/* C does not have distinct string type. */
|
||||
return (0);
|
||||
default:
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns non-zero if the value is a boolean type. */
|
||||
int
|
||||
boolean_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
if (TYPE_CODE (type) == TYPE_CODE_BOOL)
|
||||
return 1;
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
/* Might be more cleanly handled by having a
|
||||
TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
|
||||
languages, or a TYPE_CODE_INT_OR_BOOL for C. */
|
||||
if (TYPE_CODE (type) == TYPE_CODE_INT)
|
||||
return 1;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Returns non-zero if the value is a floating-point type. */
|
||||
int
|
||||
float_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
return TYPE_CODE (type) == TYPE_CODE_FLT;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Returns non-zero if the value is a pointer type. */
|
||||
int
|
||||
|
|
@ -716,35 +479,6 @@ pointer_type (struct type *type)
|
|||
TYPE_CODE (type) == TYPE_CODE_REF;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Returns non-zero if the value is a structured type. */
|
||||
int
|
||||
structured_type (struct type *type)
|
||||
{
|
||||
CHECK_TYPEDEF (type);
|
||||
switch (current_language->la_language)
|
||||
{
|
||||
case language_c:
|
||||
case language_cplus:
|
||||
case language_d:
|
||||
case language_objc:
|
||||
return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
|
||||
(TYPE_CODE (type) == TYPE_CODE_UNION) ||
|
||||
(TYPE_CODE (type) == TYPE_CODE_ARRAY);
|
||||
case language_pascal:
|
||||
return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
|
||||
(TYPE_CODE(type) == TYPE_CODE_UNION) ||
|
||||
(TYPE_CODE(type) == TYPE_CODE_SET) ||
|
||||
(TYPE_CODE(type) == TYPE_CODE_ARRAY);
|
||||
case language_m2:
|
||||
return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
|
||||
(TYPE_CODE (type) == TYPE_CODE_SET) ||
|
||||
(TYPE_CODE (type) == TYPE_CODE_ARRAY);
|
||||
default:
|
||||
return (0);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This page contains functions that return info about
|
||||
(struct value) values used in GDB. */
|
||||
|
|
|
|||
|
|
@ -473,26 +473,8 @@ extern enum language set_language (enum language);
|
|||
|
||||
/* Type predicates */
|
||||
|
||||
extern int simple_type (struct type *);
|
||||
|
||||
extern int ordered_type (struct type *);
|
||||
|
||||
extern int same_type (struct type *, struct type *);
|
||||
|
||||
extern int integral_type (struct type *);
|
||||
|
||||
extern int numeric_type (struct type *);
|
||||
|
||||
extern int character_type (struct type *);
|
||||
|
||||
extern int boolean_type (struct type *);
|
||||
|
||||
extern int float_type (struct type *);
|
||||
|
||||
extern int pointer_type (struct type *);
|
||||
|
||||
extern int structured_type (struct type *);
|
||||
|
||||
/* Checks Binary and Unary operations for semantic type correctness. */
|
||||
/* FIXME: Does not appear to be used. */
|
||||
#define unop_type_check(v,o) binop_type_check((v),NULL,(o))
|
||||
|
|
|
|||
Loading…
Reference in New Issue