to make prototypes for all functions declared here.
* cplus-dem.c: Avoid declaring xmalloc and xrealloc.
* c-exp.y: Rename SIGNED, OR, and AND to avoid conflict.
* environ.c: Include <stdio.h> before defs.h. Minor cleanup.
* ieee-float.h: Use PARAMS for prototypes; make some params const.
* ieee-float.c, valarith.c: Include <stdio.h>. Lint. b*=>mem*.
* m2-exp.y: Remove unused CONST; Rename OR and AND.
* utils.c: Avoid declaring malloc and realloc. Lint.
(request_quit): Accept signal-number parameter.
+Thu Feb 20 09:04:18 1992 John Gilmore (gnu at cygnus.com)
+
+ * defs.h: Include ansidecl.h and PARAMS macro. Use PARAMS
+ to make prototypes for all functions declared here.
+ * cplus-dem.c: Avoid declaring xmalloc and xrealloc.
+ * c-exp.y: Rename SIGNED, OR, and AND to avoid conflict.
+ * environ.c: Include <stdio.h> before defs.h. Minor cleanup.
+ * ieee-float.h: Use PARAMS for prototypes; make some params const.
+ * ieee-float.c, valarith.c: Include <stdio.h>. Lint. b*=>mem*.
+ * m2-exp.y: Remove unused CONST; Rename OR and AND.
+ * utils.c: Avoid declaring malloc and realloc. Lint.
+ (request_quit): Accept signal-number parameter.
+
Mon Feb 17 07:13:27 1992 Fred Fish (fnf at cygnus.com)
* dwarfread.c (process_dies): Add case to handle TAG_pointer_type
/* Special type cases, put in to allow the parser to distinguish different
legal basetypes. */
-%token SIGNED LONG SHORT INT_KEYWORD
+%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD
%token <lval> LAST REGNAME
%left ABOVE_COMMA
%right '=' ASSIGN_MODIFY
%right '?'
-%left OR
-%left AND
+%left OROR
+%left ANDAND
%left '|'
%left '^'
%left '&'
{ write_exp_elt_opcode (BINOP_LOGIOR); }
;
-exp : exp AND exp
+exp : exp ANDAND exp
{ write_exp_elt_opcode (BINOP_AND); }
;
-exp : exp OR exp
+exp : exp OROR exp
{ write_exp_elt_opcode (BINOP_OR); }
;
{ $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
| UNSIGNED
{ $$ = builtin_type_unsigned_int; }
- | SIGNED typename
+ | SIGNED_KEYWORD typename
{ $$ = $2.type; }
- | SIGNED
+ | SIGNED_KEYWORD
{ $$ = builtin_type_int; }
| TEMPLATE name '<' type '>'
{ $$ = lookup_template_type(copy_name($2), $4,
{"++", INCREMENT, BINOP_END},
{"--", DECREMENT, BINOP_END},
{"->", ARROW, BINOP_END},
- {"&&", AND, BINOP_END},
- {"||", OR, BINOP_END},
+ {"&&", ANDAND, BINOP_END},
+ {"||", OROR, BINOP_END},
{"::", COLONCOLON, BINOP_END},
{"<<", LSH, BINOP_END},
{">>", RSH, BINOP_END},
if (!strncmp (tokstart, "struct", 6))
return STRUCT;
if (!strncmp (tokstart, "signed", 6))
- return SIGNED;
+ return SIGNED_KEYWORD;
if (!strncmp (tokstart, "sizeof", 6))
return SIZEOF;
break;
#ifdef __STDC__
/* GDB prototypes these as void* in defs.h, so we better too, at least
as long as we're including defs.h. */
-extern void *xmalloc (int);
-extern void *xrealloc (char *, int);
+/* FIXME extern void *xmalloc (int);
+ extern void *xrealloc (char *, int); */
extern void free (void *);
#else
extern char *xmalloc ();
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+#include <stdio.h>
+
#include "defs.h"
#include "ieee-float.h"
#include <math.h> /* ldexp */
void
ieee_extended_to_double (ext_format, from, to)
- struct ext_format *ext_format;
+ const struct ext_format *ext_format;
char *from;
double *to;
{
double dto;
unsigned long mant0, mant1, exponent;
- bcopy (&from[MANBYTE_H], &mant0, 4);
- bcopy (&from[MANBYTE_L], &mant1, 4);
+ memcpy (&mant0, &from[MANBYTE_H], 4);
+ memcpy (&mant1, &from[MANBYTE_L], 4);
exponent = ((ufrom[EXPBYTE_H] & (unsigned char)~SIGNMASK) << 8) | ufrom[EXPBYTE_L];
#if 0
void
double_to_ieee_extended (ext_format, from, to)
- struct ext_format *ext_format;
+ const struct ext_format *ext_format;
double *from;
char *to;
{
/* The following code assumes that the host has IEEE doubles. FIXME-someday.
It also assumes longs are 32 bits! FIXME-someday. */
- bcopy (from, twolongs, 8);
- bcopy (from, tobytes, 8);
+ memcpy (twolongs, from, 8);
+ memcpy (tobytes, from, 8);
#if HOST_BYTE_ORDER == BIG_ENDIAN
exponent = ((tobytes[1] & 0xF0) >> 4) | (tobytes[0] & 0x7F) << 4;
mant0 = (twolongs[0] << 11) | twolongs[1] >> 21;
to[EXPBYTE_H] |= (unsigned char)(exponent >> 8); /* Retain sign */
to[EXPBYTE_L] = (unsigned char) exponent;
- bcopy (&mant0, &to[MANBYTE_H], 4);
- bcopy (&mant1, &to[MANBYTE_L], 4);
+ memcpy (&to[MANBYTE_H], &mant0, 4);
+ memcpy (&to[MANBYTE_L], &mant1, 4);
}
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+#if !defined (IEEE_FLOAT_H)
+#define IEEE_FLOAT_H 1
+
/* Parameters for extended float format: */
struct ext_format {
Store the double in *TO. */
extern void
-ieee_extended_to_double (
-#ifdef __STDC__
- struct ext_format *ext_format, char *from, double *to
-#endif
-);
+ieee_extended_to_double PARAMS ((const struct ext_format *, char *, double *));
/* The converse: convert the double *FROM to an extended float
and store where TO points. */
-void
-double_to_ieee_extended (
-#ifdef __STDC__
- struct ext_format *ext_format, double *from, char *to
-#endif
-);
+extern void
+double_to_ieee_extended PARAMS ((const struct ext_format *, double *, char *));
+
+#endif /* defined (IEEE_FLOAT_H) */
nonterminal "name", which matches either NAME or TYPENAME. */
%token <sval> STRING
-%token <sval> NAME BLOCKNAME IDENT CONST VARNAME
+%token <sval> NAME BLOCKNAME IDENT VARNAME
%token <sval> TYPENAME
%token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
%left ABOVE_COMMA
%nonassoc ASSIGN
%left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
-%left OR
-%left AND '&'
+%left OROR
+%left ANDAND '&'
%left '@'
%left '+' '-'
%left '*' '/' DIV MOD
{ write_exp_elt_opcode (BINOP_GTR); }
;
-exp : exp AND exp
+exp : exp ANDAND exp
{ write_exp_elt_opcode (BINOP_AND); }
;
{ write_exp_elt_opcode (BINOP_AND); }
;
-exp : exp OR exp
+exp : exp OROR exp
{ write_exp_elt_opcode (BINOP_OR); }
;
static struct keyword keytab[] =
{
- {"OR" , OR },
+ {"OR" , OROR },
{"IN", IN },/* Note space after IN */
- {"AND", AND },
+ {"AND", ANDAND },
{"ABS", ABS },
{"CHR", CHR },
{"DEC", DEC },
extern volatile void exit ();
extern char *gdb_readline ();
extern char *getenv();
-extern char *malloc();
-extern char *realloc();
/* If this definition isn't overridden by the header files, assume
that isatty and fileno exist on this system. */
{
free (*location);
}
+
+/* Provide a known function that does nothing, to use as a base for
+ for a possibly long chain of cleanups. This is useful where we
+ use the cleanup chain for handling normal cleanups as well as dealing
+ with cleanups that need to be done as a result of a call to error().
+ In such cases, we may not be certain where the first cleanup is, unless
+ we have a do-nothing one to always use as the base. */
+
+/* ARGSUSED */
+void
+null_cleanup (arg)
+ char **arg;
+{
+}
+
\f
/* Provide a hook for modules wishing to print their own warning messages
to set up the terminal state in a compatible way, without them having
/* Control C comes here */
void
-request_quit ()
+request_quit (signo)
+ int signo;
{
quit_flag = 1;
#ifdef USG
/* Restore the signal handler. */
- signal (SIGINT, request_quit);
+ signal (signo, request_quit);
#endif
if (immediate_quit)
char *
savestring (ptr, size)
- char *ptr;
+ const char *ptr;
int size;
{
register char *p = (char *) xmalloc (size + 1);
}
}
\f
-/* Print the character CH on STREAM as part of the contents
+/* Print the character C on STREAM as part of the contents
of a literal string whose delimiter is QUOTER. */
void
-printchar (ch, stream, quoter)
- unsigned char ch;
+printchar (c, stream, quoter)
+ register int c;
FILE *stream;
int quoter;
{
- register int c = ch;
if (c < 040 || (sevenbit_strings && c >= 0177)) {
switch (c)
void
fputs_filtered (linebuffer, stream)
- char *linebuffer;
+ const char *linebuffer;
FILE *stream;
{
char *lineptr;
/* Perform arithmetic and other operations on values, for GDB.
- Copyright (C) 1986, 1989 Free Software Foundation, Inc.
+ Copyright 1986, 1989, 1991 Free Software Foundation, Inc.
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <stdio.h>
#include "defs.h"
-#include "param.h"
#include "value.h"
+#include "symtab.h"
#include "expression.h"
#include "target.h"
#include <string.h>
-\f
-value value_x_binop ();
-value value_subscripted_rvalue ();
+static value
+value_subscripted_rvalue PARAMS ((value, value));
+\f
value
value_add (arg1, arg2)
value arg1, arg2;
{
- register value val, valint, valptr;
+ register value valint, valptr;
register int len;
COERCE_ARRAY (arg1);
}
len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
if (len == 0) len = 1; /* For (void *) */
- val = value_from_long (builtin_type_long,
- value_as_long (valptr)
- + (len * value_as_long (valint)));
- VALUE_TYPE (val) = VALUE_TYPE (valptr);
- return val;
+ return value_from_longest (VALUE_TYPE (valptr),
+ value_as_long (valptr)
+ + (len * value_as_long (valint)));
}
return value_binop (arg1, arg2, BINOP_ADD);
value_sub (arg1, arg2)
value arg1, arg2;
{
- register value val;
COERCE_ARRAY (arg1);
COERCE_ARRAY (arg2);
if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
{
/* pointer - integer. */
- val = value_from_long
- (builtin_type_long,
+ return value_from_longest
+ (VALUE_TYPE (arg1),
value_as_long (arg1)
- (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
* value_as_long (arg2)));
- VALUE_TYPE (val) = VALUE_TYPE (arg1);
- return val;
}
else if (VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
{
/* pointer to <type x> - pointer to <type x>. */
- val = value_from_long
- (builtin_type_long,
+ return value_from_longest
+ (builtin_type_long, /* FIXME -- should be ptrdiff_t */
(value_as_long (arg1) - value_as_long (arg2))
/ TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
- return val;
}
else
{
(eg, a vector register). This routine used to promote floats
to doubles, but no longer does. */
-value
+static value
value_subscripted_rvalue (array, idx)
value array, idx;
{
struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
int elt_size = TYPE_LENGTH (elt_type);
- int elt_offs = elt_size * value_as_long (idx);
+ int elt_offs = elt_size * longest_to_int (value_as_long (idx));
value v;
if (elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
/* We know either arg1 or arg2 is a structure, so try to find the right
user defined function. Create an argument vector that calls
arg1.operator @ (arg1,arg2) and return that value (where '@' is any
- binary operator which is legal for GNU C++). */
+ binary operator which is legal for GNU C++).
+
+ OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
+ is the opcode saying how to modify it. Otherwise, OTHEROP is
+ unused. */
value
value_x_binop (arg1, arg2, op, otherop)
char tstr[13];
int static_memfuncp;
+ COERCE_REF (arg1);
+ COERCE_REF (arg2);
COERCE_ENUM (arg1);
COERCE_ENUM (arg2);
value
value_binop (arg1, arg2, op)
value arg1, arg2;
- int op;
+ enum exp_opcode op;
{
register value val;
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
return value_as_double (arg1) == value_as_double (arg2);
- else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
- || (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
- return (char *) value_as_long (arg1) == (char *) value_as_long (arg2);
+
+ /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
+ is bigger. */
+ else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
+ return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
+ else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
+ return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
+
else if (code1 == code2
&& ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
== TYPE_LENGTH (VALUE_TYPE (arg2))))
{
if (TYPE_UNSIGNED (VALUE_TYPE (arg1))
|| TYPE_UNSIGNED (VALUE_TYPE (arg2)))
- return (unsigned)value_as_long (arg1) < (unsigned)value_as_long (arg2);
+ return ((unsigned LONGEST) value_as_long (arg1)
+ < (unsigned LONGEST) value_as_long (arg2));
else
return value_as_long (arg1) < value_as_long (arg2);
}
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
return value_as_double (arg1) < value_as_double (arg2);
- else if ((code1 == TYPE_CODE_PTR || code1 == TYPE_CODE_INT)
- && (code2 == TYPE_CODE_PTR || code2 == TYPE_CODE_INT))
- {
- /* FIXME, this assumes that host and target char *'s are the same! */
- return (char *) value_as_long (arg1) < (char *) value_as_long (arg2);
- }
+ else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
+ return value_as_pointer (arg1) < value_as_pointer (arg2);
+
+ /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
+ is bigger. */
+ else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
+ return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
+ else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
+ return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
+
else
{
error ("Invalid type combination in ordering comparison.");
if (TYPE_CODE (type) == TYPE_CODE_FLT)
return value_from_double (type, - value_as_double (arg1));
else if (TYPE_CODE (type) == TYPE_CODE_INT)
- return value_from_long (type, - value_as_long (arg1));
+ return value_from_longest (type, - value_as_long (arg1));
else {
error ("Argument to negate operation not a number.");
return 0; /* For lint -- never reached */
if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
error ("Argument to complement operation not an integer.");
- return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
+ return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
}
\f
projects / binutils-gdb.git / commitdiff