Many more changes

util/grind/dbxread.c

@@ -13,7 +13,6 @@
 #include "scope.h"
 #include "rd.h"
 
-extern char		*Malloc();
 extern char		*strindex();
 extern struct outname	*DbxString();
 

util/grind/dump.c

@@ -7,6 +7,8 @@
 #include "position.h"
 #include "tree.h"
 #include "message.h"
+#include "type.h"
+#include "expr.h"
 
 extern long	pointer_size;
 extern p_tree	get_from_item_list();
@@ -29,7 +31,7 @@ do_dump(p)
 	return;
   }
   p->t_args[0] = (struct tree *) d;
-  p->t_address = (t_addr) BUFTOA(d->mglobal.m_buf+PC_OFF*pointer_size);
+  p->t_address = (t_addr) get_int(d->mglobal.m_buf+PC_OFF*pointer_size, pointer_size, T_UNSIGNED);
   add_to_item_list(p);
 }
 

util/grind/expr.c

@@ -1,6 +1,7 @@
 /* $Header$ */
 
-/* This file contains the expression evaluator. It exports four routines:
+/* This file contains the expression evaluator. It exports the following
+   routines:
    - int eval_cond(p_tree p)
 	This routine evaluates the conditional expression indicated by p
 	and returns 1 if it evaluates to TRUE, or 0 if it could not be
@@ -26,6 +27,16 @@
 	while producing an error message. Otherwise, it returns 1 and
 	the resulting value, type and size are left in pbuf, ptp, and
 	psize, respectively.
+   - long get_int(char *buf, long size, int class)
+	Returns the value of size 'size', residing in 'buf', of 'class'
+	T_INTEGER, T_UNSIGNED, or T_ENUM.
+   - int put_int(char *buf, long size, long value)
+	Stores the value 'value' of size 'size' in 'buf'.
+   - double get_real(char *buf, long size)
+	Returns the real value of size 'size', residing in 'buf'.
+	T_INTEGER, T_UNSIGNED, or T_ENUM.
+   - int put_real(char *buf, long size, double value)
+	Stores the value 'value' of size 'size' in 'buf'.
 */
 
 #include <stdio.h>
@@ -41,10 +52,16 @@
 #include "langdep.h"
 
 extern FILE	*db_out;
+extern char	*strcpy();
+
+#define	malloc_succeeded(p)	if (! (p)) {\
+					error("could not allocate enough memory");\
+					return 0;\
+				}
 
 /* buffer to integer and vice versa routines */
 
-static long
+long
 get_int(buf, size, class)
   char	*buf;
   long	size;
@@ -68,7 +85,6 @@ get_int(buf, size, class)
   return l;
 }
 
-static
 put_int(buf, size, value)
   char	*buf;
   long	size;
@@ -90,7 +106,7 @@ put_int(buf, size, value)
 
 /* buffer to real and vice versa routines */
 
-static double
+double
 get_real(buf, size)
   char	*buf;
   long	size;
@@ -104,7 +120,6 @@ get_real(buf, size)
   /*NOTREACHED*/
 }
 
-static
 put_real(buf, size, value)
   char	*buf;
   long	size;
@@ -138,7 +153,8 @@ convert(pbuf, psize, ptp, tp, size)
 
   if (*ptp == tp) return 1;
   if (size > *psize) {
-	*pbuf = Realloc(*pbuf, (unsigned int) size);
+	*pbuf = realloc(*pbuf, (unsigned int) size);
+	malloc_succeeded(*pbuf);
   }
   if ((*ptp)->ty_class == T_SUBRANGE) *ptp = (*ptp)->ty_base;
   switch((*ptp)->ty_class) {
@@ -298,7 +314,8 @@ do_deref(p, pbuf, psize, ptp)
   t_addr addr;
 
   if (ptr_addr(p, &addr, psize, ptp)) {
-	*pbuf = Malloc((unsigned) *psize);
+	*pbuf = malloc((unsigned) *psize);
+	malloc_succeeded(*pbuf);
 	if (! get_bytes(*psize, addr, *pbuf)) {
 		error("could not get value");
 	}
@@ -317,7 +334,8 @@ do_addr(p, pbuf, psize, ptp)
   t_addr addr;
 
   if (eval_desig(p->t_args[0], &addr, psize, ptp)) {
-	*pbuf = Malloc((unsigned) pointer_size);
+	*pbuf = malloc((unsigned) pointer_size);
+	malloc_succeeded(*pbuf);
 	put_int(*pbuf, pointer_size, (long) addr);
 	return 1;
   }
@@ -780,8 +798,8 @@ do_cmp(p, pbuf, psize, ptp)
 	}
 	if (*psize < int_size) {
 		*psize = int_size;
-		free(*pbuf);
+		*pbuf = realloc(*pbuf, (unsigned int) int_size);
-		*pbuf = Malloc((unsigned int) int_size);
+		malloc_succeeded(*pbuf);
 	}
 	else	*psize = int_size;
 	if (currlang->has_bool_type) {
@@ -824,7 +842,8 @@ do_in(p, pbuf, psize, ptp)
 	    && l <= (size << 3) 
 	    && (((int *) buf)[(int)(l>>sft)] & (1 << (l & ((1 << sft)-1))));
 	free(buf);
-	*pbuf = Realloc(*pbuf, (unsigned) int_size);
+	*pbuf = realloc(*pbuf, (unsigned) int_size);
+	malloc_succeeded(*pbuf);
 	*psize = int_size;
 	*ptp = currlang->has_bool_type ? bool_type : int_type;
 	put_int(*pbuf, *psize, l);
@@ -889,7 +908,8 @@ do_array(p, pbuf, psize, ptp)
   t_addr	a;
 
   if (array_addr(p, &a, psize, ptp)) {
-	*pbuf = Malloc((unsigned int) *psize);
+	*pbuf = malloc((unsigned int) *psize);
+	malloc_succeeded(*pbuf);
 	if (! get_bytes(*psize, a, *pbuf)) {
 		return 0;
 	}
@@ -945,7 +965,8 @@ do_select(p, pbuf, psize, ptp)
 {
   t_addr	a;
   if (select_addr(p, &a, psize, ptp)) {
-	*pbuf = Malloc((unsigned int) *psize);
+	*pbuf = malloc((unsigned int) *psize);
+	malloc_succeeded(*pbuf);
 	if (! get_bytes(*psize, a, *pbuf)) {
 		return 0;
 	}
@@ -1011,26 +1032,29 @@ eval_expr(p, pbuf, psize, ptp)
 	break;
 
   case OP_INTEGER:
-	*pbuf = Malloc(sizeof(long));
+	*pbuf = malloc((unsigned int) long_size);
-	*psize = sizeof(long);
+	malloc_succeeded(*pbuf);
+	*psize = long_size;
 	*ptp = long_type;
-	*((long *) (*pbuf)) = p->t_ival;
+	put_int(*pbuf, long_size, p->t_ival);
 	retval = 1;
 	break;
 
   case OP_REAL:
-	*pbuf = Malloc(sizeof(double));
+	*pbuf = malloc((unsigned int) double_size);
-	*psize = sizeof(double);
+	malloc_succeeded(*pbuf);
+	*psize = double_size;
 	*ptp = double_type;
-	*((double *) (*pbuf)) = p->t_fval;
+	put_real(*pbuf, double_size, p->t_fval);
 	retval = 1;
 	break;
 
   case OP_STRING:
-	*pbuf = Malloc(sizeof(char *));
+	*psize = strlen(p->t_sval)+1;
-	*psize = sizeof(char *);
+	*pbuf = malloc((unsigned int)*psize);
+	malloc_succeeded(*pbuf);
 	*ptp = string_type;
-	*((char **) (*pbuf)) = p->t_sval;
+	strcpy(*pbuf, p->t_sval);
 	retval = 1;
 	break;
 

util/grind/expr.h

@@ -4,33 +4,92 @@
    indices into arrays.
 */
 
-#define E_NOT	1
+#define E_NOT	     1
-#define E_DEREF	2
+#define E_DEREF	     2
-#define E_AND	3
+#define E_AND	     3
-#define E_OR	4
+#define E_OR	     4
-#define E_DIV	5		/* equal to truncated quotient */
+#define E_DIV	     5		/* equal to truncated quotient */
-#define E_MOD	6		/* x = (x E_DIV y) * y + x E_MOD y,
+#define E_MOD	     6		/* x = (x E_DIV y) * y + x E_MOD y,
 				   0 <= (x E_MOD y) < y
 				*/
-#define E_ZDIV	7		/* quotient rounded to 0 */
+#define E_ZDIV	     7		/* quotient rounded to 0 */
-#define E_ZMOD	8		/* remainder of E_ZDIV */
+#define E_ZMOD	     8		/* remainder of E_ZDIV */
-#define E_IN	9		/* set membership */
+#define E_IN	     9		/* set membership */
-#define E_ARRAY	10
+#define E_ARRAY	    10
-#define E_PLUS	11
+#define E_PLUS	    11
-#define E_MIN	12
+#define E_MIN	    12
-#define E_MUL	13
+#define E_MUL	    13
-#define E_EQUAL	14
+#define E_EQUAL	    14
-#define E_NOTEQUAL 15
+#define E_NOTEQUAL  15
-#define E_LTEQUAL 16
+#define E_LTEQUAL   16
-#define E_GTEQUAL 17
+#define E_GTEQUAL   17
-#define E_LT	18
+#define E_LT	    18
-#define E_GT	19
+#define E_GT	    19
-#define E_SELECT 20
+#define E_SELECT    20
-#define E_BAND	21		/* bitwise and */
+#define E_BAND	    21		/* bitwise and */
-#define E_BOR	22		/* bitwise or */
+#define E_BOR	    22		/* bitwise or */
-#define E_BXOR	23
+#define E_BXOR	    23
-#define E_BNOT	24
+#define E_BNOT	    24
 #define E_DERSELECT 25		/* -> in C */
-#define E_LSFT	26
+#define E_LSFT	    26
-#define E_RSFT	27
+#define E_RSFT	    27
-#define E_ADDR	28
+#define E_ADDR	    28
+
+/* long get_int(char *buf, long size, int class)
+   Returns the value of size 'size', residing in 'buf', of 'class'
+   T_INTEGER, T_UNSIGNED, or T_ENUM.
+*/
+extern long	get_int();
+
+/* int put_int(char *buf, long size, long value)
+   Stores the value 'value' of size 'size' in 'buf'.
+*/
+extern int	put_int();
+
+/* double get_real(char *buf, long size)
+   Returns the real value of size 'size', residing in 'buf'.
+   T_INTEGER, T_UNSIGNED, or T_ENUM.
+*/
+extern double	get_real();
+
+/* int put_real(char *buf, long size, double value)
+   Stores the value 'value' of size 'size' in 'buf'.
+*/
+extern int	put_real();
+
+/* int eval_cond(p_tree p)
+   This routine evaluates the conditional expression indicated by p
+   and returns 1 if it evaluates to TRUE, or 0 if it could not be
+   evaluated for some reason or if it evalutes to FALSE.
+   If the expression cannot be evaluated, an error message is given.
+*/
+extern int	eval_cond();
+
+/* int eval_desig(p_tree p, t_addr *pbuf, long **psize, p_type *ptp)
+   This routine evaluates the expression indicated by p, which should
+   result in a designator. The result of the expression is an address
+   which is to be found in *pbuf. *psize will contain the size of the
+   designated object, and *ptp its type.
+   If the expression cannot be evaluated or does not result in a
+   designator, 0 is returned and an error message is given.
+   Otherwise, 1 is returned.
+*/
+extern int	eval_desig();
+
+/* int eval_expr(p_tree p, char **pbuf, long **psize, p_type *ptp)
+   This routine evaluates the expression indicated by p.
+   The result of the expression is left in *pbuf.
+   *psize will contain the size of the value, and *ptp its type.
+   If the expression cannot be evaluated, 0 is returned and an error
+   message is given.  Otherwise, 1 is returned.
+*/
+extern int	eval_expr();
+
+/* int convert(char **pbuf, long *psize, p_type *ptp, p_type tp, long size)
+   This routine tries to convert the value in pbuf of size psize
+   and type ptp to type tp with size size. It returns 0 if this fails,
+   while producing an error message. Otherwise, it returns 1 and
+   the resulting value, type and size are left in pbuf, ptp, and
+   psize, respectively.
+*/
+extern int	convert();

util/grind/grind.1

@@ -13,15 +13,15 @@ grind \- source-level debugger for ACK
 .SH DESCRIPTION
 .B Grind
 is a utility for source-level debugging and execution of
-programs written in C or Modula-2 (Pascal will be added later).
+programs written in C, Modula-2, or Pascal.
 Its operation resembles the operation of 
 .IR dbx ,
 a source-level debugger
 available on many Unix systems. However, some
-.B Grind
+.B grind
 commands are not available in
 .IR dbx ,
-and some more
+some more
 .I dbx
 commands are not available in
 .BR grind ,
@@ -48,8 +48,8 @@ Some
 .B grind
 commands take an expression argument.
 .SS Expressions
-.B Grind expressions
+.B Grind
-are combinations of variables, constants, and operators.
+expressions are combinations of variables, constants, and operators.
 The syntax and the operators depend on the source language of the program
 being debugged. However, the type rules are probably less strict than the
 rules of this language. For instance, in Modula-2 one cannot combine
@@ -57,8 +57,6 @@ values of type INTEGER with values of type REAL in an expression without
 using conversion routines. In
 .BR grind ,
 the conversions needed are performed automatically.
-Expressions cannot involve strings, structures, or
-arrays, although elements of structures or arrays may be used.
 .SS Operators
 .LP
 .B Grind
@@ -72,19 +70,19 @@ The syntax and priority of these operators depends on the source language.
 Parentheses can be used for grouping.
 .SS "Scope Rules"
 .LP
-.B dbx
+.B Grind
 uses the current file and function to resolve scope conflicts.
 Their values are updated as files and functions are entered and exited
 during execution.
 Names can also be qualified with procedure- or module names, as in
 \fImodule\fP`\fIproc\fP`\fIname\fP.
 .B Grind
-tries to be intelligent about names, so qualification is only needed when
+tries to be intelligent about names; qualification is only needed when
 names are used for more than one object in a program and the current scope
 does not help.
 .SS "Positions"
 In general, there are two ways to specify a position; the first way is
-to specify filename and linenumber, in a so-called at-clause, like this:
+to specify file name and line number, in a so-called at-clause, like this:
 .RS
 \fBat\fP [ "\fIfilename\fP": ] \fIlinenumber\fP
 .RE
@@ -99,7 +97,7 @@ This indicates the first statement within the named function (except for
 the trace command discussed later).
 .SS "Commands"
 .TP
-.B \s+2^\s0C
+.B ^C
 Interrupt.  Stop the program being debugged and enter
 .BR grind .
 .TP
@@ -114,11 +112,18 @@ and possible redirection of standard input and/or standard output.
 Repeats the last
 .B run
 command.
+.TP
 \fBcont\fP [ \fBat\fP \fIsourceline\fP ]
+.ti -0.5i
+\fBc\fP [ \fBat\fP \fIsourceline\fP ]
+.br
 Continue execution from where it stopped, or, if \fIsourceline\fP is
 given, at that source line.
 .TP
 \fBtrace\fP [ \fBon\fP \fIexpression\fP ] [ \fIposition\fP ] [ \fBif\fP \fIcondition\fP ]
+.ti -0.5i
+\fBt\fP [ \fBon\fP \fIexpression\fP ] [ \fIposition\fP ] [ \fBif\fP \fIcondition\fP ]
+.br
 Display tracing information.
 If no argument is specified, each source line is displayed before
 execution.
@@ -167,10 +172,13 @@ If no condition is given, stop when
 is reached.
 Either a position or a condition (or both) must be given.
 .TP
-\fBprint\fP \fIexpression\fP [ ',' \fIexpression\fP ] ...
+\fBprint\fP \fIexpression\fP [ , \fIexpression\fP ] ...
+.ti -0.5i
+\fBp\fP \fIexpression\fP [ , \fIexpression\fP ] ...
+.br
 Print the value of each expression.
 .TP
-\fBdisplay\fP \fIexpression\fP [ ',' \fIexpression\fP ] ...
+\fBdisplay\fP \fIexpression\fP [ , \fIexpression\fP ] ...
 Print the value of each expression whenever the program stops.
 .TP
 .B dump
@@ -197,11 +205,17 @@ Also display current
 records.
 .TP
 \fBdelete\fP \fIcommandnumber\fP
+.ti -0.5i
+\fBd\fP \fIcommandnumber\fP
+.br
 Remove the command corresponding to \fIcommandnumber\fP
 (as displayed by
 .BR status ).
 .TP
 \fBrestore\fP \fIcommandnumber\fP
+.ti -0.5i
+\fBr\fP \fIcommandnumber\fP
+.br
 Restore the data corresponding to the dump of \fIcommandnumber\fP
 (as displayed by
 .BR status ).
@@ -215,6 +229,9 @@ Apart from this,
 even works when the program is finished.
 .TP
 \fBstep\fP [ \fIn\fP ]
+.ti -0.5i
+\fBs\fP [ \fIn\fP ]
+.br
 Execute the next
 .I n
 source lines.
@@ -224,6 +241,9 @@ is taken to be 1.
 This command steps into functions.
 .TP
 \fBnext\fP [ \fIn\fP ]
+.ti -0.5i
+\fBn\fP [ \fIn\fP ]
+.br
 Execute the next
 .I n
 source lines.
@@ -258,12 +278,14 @@ List all, or the top
 active functions on the stack.
 .TP
 \fBfile\fP [ \fIfilename\fP ]
-.br
 Print the name of the current source file, or
 change the current source file to
 .IR filename .
 .TP
 \fBlist\fP [ \fIstartline\fP [ , \fIendline\fP ]  | \fIfunction\fP ]
+.ti -0.5i
+\fBl\fP [ \fIstartline\fP [ , \fIendline\fP ]  | \fIfunction\fP ]
+.br
 If no arguments are given, list the next ten lines from current source file,
 if a
 .I startline
@@ -279,15 +301,20 @@ the first statement of
 .B quit
 Exit
 .BR grind .
+.LP
+Some commands can be repeated by entering an empty command line: step,
+next, print, list, status, cont.
 .SH ENVIRONMENT
 P.M.
 .SH SEE ALSO
-.BR ack (1ACK).
+.IR ack (1ACK).
-.BR led (6ACK).
+.IR led (6ACK).
+.SH REMARKS
+.LP
+.B Grind
+does not understand the scope of WITH statements. The scope information needed
+is not available in the symbol table.
 .SH BUGS
 .LP
 .B Grind
 does not correctly handle bit-fields.
-.LP
-.B Grind
-does not understand WITH statements.

util/grind/list.c

@@ -54,18 +54,6 @@ open_file(fn, mode, ffn)
   return NULL;
 }
 
-#define	window_size	21
-/*	Print a window of window_size lines around line "line" of
-	file "file".
-*/
-window(file, line)
-  p_file	file;
-  int		line;
-{
-  lines(file,
-	line + ((window_size >> 1) - window_size), line + (window_size >> 1));
-}
-
 lines(file, l1, l2)
   register p_file file;
   int		l1, l2;

util/grind/main.c

@@ -6,6 +6,7 @@
 #include "file.h"
 #include "symbol.h"
 #include "scope.h"
+#include "Lpars.h"
 
 static char	*usage = "Usage: %s [<ack.out>] [<a.out>]";
 static char	*progname;
@@ -18,6 +19,18 @@ int		debug;
 extern struct tokenname tkidf[];
 extern char	*strindex();
 
+static struct tokenname shorts[] = {
+	{LIST, "l"},
+	{CONT, "c"},
+	{STEP, "s"},
+	{NEXT, "n"},
+	{DELETE, "d"},
+	{PRINT, "p"},
+	{RESTORE, "r"},
+	{TRACE, "t"},
+	{ 0, 0}
+};
+
 main(argc, argv)
   char	*argv[];
 {
@@ -52,6 +65,7 @@ main(argc, argv)
   if (DbxRead(AckObj) && AObj == 0) AObj = AckObj;
   else if (AObj == 0) AObj = "a.out";
   reserve(tkidf);
+  reserve(shorts);
   if (currfile) CurrentScope = currfile->sy_file->f_scope;
   if (! init_run()) {
 	fatal("something wrong with file descriptors");

util/grind/make.tokfile

@@ -3,4 +3,4 @@ sed '
 s/.*{//
 s/,.*//
 s/.*/%token	&;/
-'
+' | sort | uniq

util/grind/message.h

@@ -48,12 +48,3 @@ struct message_hdr {
 
 #define IN_FD	3
 #define OUT_FD	6
-
-#define BUFTOL(c)	(*((long *) (c)))
-#define LTOBUF(c,l)	(*((long *) (c)) = (l))
-#define BUFTOA(c)	(*((char **) (c)))
-#define ATOBUF(c,p)	(*((char **) (c)) = (p))
-#define BUFTOS(c)	(*((short *) (c)))
-#define BUFTOI(c)	(*((int *) (c)))
-#define BUFTOF(c)	(*((float *) (c)))
-#define BUFTOD(c)	(*((double *) (c)))

util/grind/position.c

@@ -36,35 +36,6 @@ get_map_from_addr(t)
   return oldp ? oldp : p->f_start->on_valu <= t ? p : 0;
 }
 
-/* extern char *get_filename_from_addr(t_addr t);
-   Returns the source filename that contains the code at the address 't',
-   or 0 if there is no information available, or 't' represents an address
-   below the start address of the first file.
-*/
-char *
-get_filename_from_addr(t)
-  t_addr t;
-{
-  register p_file map = get_map_from_addr(t);
-
-  if (! map) return 0;
-  return map->f_sym->sy_idf->id_text;
-}
-
-/* extern t_lineno get_lineno_from_addr(t_addr t);
-   Returns the source line number of the line that contains the code at address
-   't'.  0 is returned if no source line number could be found.
-*/
-t_lineno
-get_lineno_from_addr(t)
-  t_addr t;
-{
-  p_position p;
-
-  p = get_position_from_addr(t);
-  return p == 0 ? 0 : p->lineno;
-}
-
 /* extern p_position get_position_from_addr(t_addr t);
    Returns a pointer to a structure containing the source position of the code
    at address 't'.  0 is returned if no source position could be found.
@@ -161,21 +132,6 @@ add_position_addr(filename, n)
   map->f_line_addr[HASH(n->on_desc)] = n;
 }
 
-/* extern struct scope  *get_scope_from_position(p_position p);
-   Returns the scope of the code at position 'p', or 0 if it could not be found.
-*/
-struct scope *
-get_scope_from_position(p)
-  p_position p;
-{
-  t_addr a = get_addr_from_position(p);
-
-  if (a != ILL_ADDR) {
-	return get_scope_from_addr(a);
-  }
-  return 0;
-}
-
 /* extern p_position print_position(t_addr a, int print_function);
    Prints position 'a' and returns it. If 'print_function' is set,
    an attempt is made to print the function name as well.

util/grind/position.h

@@ -14,19 +14,6 @@ typedef struct pos {
   char		*filename;
 } t_position, *p_position;
 
-/* extern char *get_filename_from_addr(t_addr t);
-   Returns the source filename that contains the code at the address 't',
-   or 0 if there is no information available, or 't' represents an address
-   below the start address of the first file.
-*/
-extern char		*get_filename_from_addr();
-
-/* extern t_lineno	get_lineno_from_addr(t_addr t);
-   Returns the source line number of the line that contains the code at address
-   't'.  0 is returned if no source line number could be found.
-*/
-extern t_lineno		get_lineno_from_addr();
-
 /* extern p_position	get_position_from_addr(t_addr t);
    Returns a pointer to a structure containing the source position of the code
    at address 't'.  0 is returned if no source position could be found.
@@ -45,11 +32,6 @@ extern t_addr		get_addr_from_position();
 */
 extern 			add_position_addr();
 
-/* extern struct scope	*get_scope_from_position(p_position p);
-   Returns the scope of the code at position 'p', or 0 if it could not be found.
-*/
-extern struct scope	*get_scope_from_position();
-
 /* extern p_position print_position(t_addr a, int print_function);
    Prints position 'a' and returns it. If 'print_function' is set,
    an attempt is made to print the function name as well.

util/grind/print.c

@@ -11,6 +11,7 @@
 #include "symbol.h"
 #include "position.h"
 #include "idf.h"
+#include "expr.h"
 
 extern FILE *db_out;
 extern long float_size, pointer_size, int_size;
@@ -18,7 +19,7 @@ extern long float_size, pointer_size, int_size;
 static
 print_literal(tp, v)
   p_type	tp;
-  int		v;
+  long		v;
 {
   register struct literal *lit = tp->ty_literals;
   register int i;
@@ -75,7 +76,11 @@ print_params(tp, AB, static_link)
   par = tp->ty_params;
   size = tp->ty_nbparams;
   if (static_link) size += pointer_size;
-  param_bytes = p = Malloc((unsigned)size);
+  param_bytes = p = malloc((unsigned)size);
+  if (! p) {
+	error("could not allocate enough memory");
+	return;
+  }
   if (static_link) p += pointer_size;
   if (! get_bytes(size, AB, param_bytes)) {
 	error("no debuggee");
@@ -90,13 +95,19 @@ print_params(tp, AB, static_link)
 		   try and get value.
 		*/
 		char	*q;
+		t_addr	addr = get_int(p, pointer_size, T_UNSIGNED);
 
 		if ((size = par->par_type->ty_size) == 0) {
 			size = compute_size(par->par_type, param_bytes);
 		}
-		q = Malloc((unsigned) size);
+		q = malloc((unsigned) size);
-		if (! get_bytes(size, (t_addr) BUFTOA(p), q)) {
+  		if (! q) {
-			fprintf(db_out, currlang->addr_fmt, BUFTOA(p));
+			error("could not allocate enough memory");
+			free(param_bytes);
+			return;
+  		}
+		if (! get_bytes(size, addr, q)) {
+			fprintf(db_out, currlang->addr_fmt, (long) addr);
 		}
 		else {
 			print_val(par->par_type, size, q, 1, 0);
@@ -176,7 +187,7 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	for (i = tp->ty_nfields; i; i--, fld++) {
 		long sz = fld->fld_type->ty_size;
 		if (! compressed) fprintf(db_out, "%s = ", fld->fld_name);
-		if (fld->fld_bitsize < sz << 3) {
+		if (fld->fld_bitsize < (sz << 3)) {
 			/* apparently a bit field */
 			/* ??? */
 			fprintf(db_out, "<bitfield, %d, %ld>", fld->fld_bitsize, sz);
@@ -199,14 +210,10 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	fprintf(db_out, "<union>");
 	break;
   case T_ENUM:
-	print_literal(tp,  tp_sz == 1 
+	print_literal(tp, get_int(addr, tp_sz, T_ENUM));
-			   ? (*addr & 0xFF)
-			   : tp_sz == 2
-			      ? (BUFTOS(addr) & 0xFFFF)
-			      : (int) BUFTOL(addr));
 	break;
   case T_PROCEDURE: {
-	register p_scope sc = get_scope_from_addr((t_addr) BUFTOA(addr));
+	register p_scope sc = get_scope_from_addr((t_addr) get_int(addr, pointer_size, T_UNSIGNED));
 
 	if (sc && sc->sc_definedby) {
 		fprintf(db_out, sc->sc_definedby->sy_idf->id_text);
@@ -215,7 +222,7 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	}
 	/* Fall through */
   case T_POINTER:
-	fprintf(db_out, currlang->addr_fmt, (long) BUFTOA(addr));
+	fprintf(db_out, currlang->addr_fmt, get_int(addr, pointer_size, T_UNSIGNED));
 	break;
   case T_FILE:
 	fprintf(db_out, "<file>");
@@ -226,7 +233,7 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	long	nelements = tp->ty_size << 3;
 	int	count = 0;
 	int	rsft = 3 + (int_size == 2 ? 1 : 2);
-	long	mask = int_size == 2 ? 0xFFFF : 0xFFFFFFFF;
+	long	mask = int_size == 2 ? 017: 037;
 
 	if (base->ty_class == T_SUBRANGE) base = base->ty_base;
 	if (compressed) {
@@ -241,7 +248,7 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	}
 	indent += 4;
 	for (i = 0; i < nelements; i++) {
-		if (*((int *) addr + (i >> rsft)) & (1 << (i & mask))) {
+		if (get_int(addr + (i >> rsft), int_size, T_UNSIGNED) & (1 << (i & mask))) {
 			count++;
 			if (count > 1) {
 				if (compressed) {
@@ -258,7 +265,7 @@ print_val(tp, tp_sz, addr, compressed, indent)
 				print_unsigned(base, val+i);
 				break;
 			case T_ENUM:
-				print_literal(base, (int)val+i);
+				print_literal(base, val+i);
 				break;
 			default:
 				assert(0);
@@ -272,26 +279,14 @@ print_val(tp, tp_sz, addr, compressed, indent)
 	fprintf(db_out, currlang->close_set_display);
   	}
 	break;
-  case T_REAL: {
+  case T_REAL:
-	double val = tp->ty_size == float_size
+	fprintf(db_out, currlang->real_fmt, get_real(addr, tp->ty_size));
-		? BUFTOF(addr)
-		: BUFTOD(addr);
-	fprintf(db_out, currlang->real_fmt, val);
 	break;
-	}
   case T_UNSIGNED:
-	print_unsigned(tp, tp_sz == 1 
+	print_unsigned(tp, get_int(addr, tp_sz, T_UNSIGNED));
-				? (*addr & 0xFF)
-				: tp_sz == 2
-			  	    ? (BUFTOS(addr) & 0xFFFF)
-			  	    : BUFTOL(addr));
 	break;
   case T_INTEGER:
-	print_integer(tp, tp_sz == 1 
+	print_integer(tp, get_int(addr, tp_sz, T_INTEGER));
-				? *addr
-				: tp_sz == 2
-			  	    ? BUFTOS(addr)
-			  	    : BUFTOL(addr));
 	break;
   case T_STRING:
 	(*currlang->printstring)(addr, (int) tp_sz);

util/grind/run.c

@@ -15,6 +15,8 @@
 #include "symbol.h"
 #include "idf.h"
 #include "scope.h"
+#include "type.h"
+#include "expr.h"
 
 #define MAXARG	128
 
@@ -126,25 +128,26 @@ start_child(p)
 	/* I/O redirection */
 	if (in_redirect) {
 		int fd;
+
 		close(0);
-		if ((fd = open(in_redirect, 0)) < 0) {
+		if ((fd = open(in_redirect, 0)) < 0 ||
+		    (fd != 0 && dup2(fd, 0) < 0)) {
 			error("could not open input file");
-			exit(-1);
+			exit(1);
 		}
 		if (fd != 0) {
-			dup2(fd, 0);
 			close(fd);
 		}
 	}
 	if (out_redirect) {
 		int fd;
 		close(1);
-		if ((fd = creat(in_redirect, 0666)) < 0) {
+		if ((fd = creat(in_redirect, 0666)) < 0 ||
+		    (fd != 1 && dup2(fd, 1) < 0)) {
 			error("could not open output file");
-			exit(-1);
+			exit(1);
 		}
 		if (fd != 1) {
-			dup2(fd, 1);
 			close(fd);
 		}
 	}
@@ -152,7 +155,7 @@ start_child(p)
 	/* and run process to be debugged */
 	execv(AObj, argp);
 	error("could not exec %s", AObj);
-	exit(-1);
+	exit(1);
   }
 
   /* debugger */
@@ -369,7 +372,7 @@ get_bytes(size, from, to)
 
   m.m_type = GETBYTES;
   m.m_size = size;
-  ATOBUF(m.m_buf, (char *) from);
+  put_int(m.m_buf, pointer_size, (long)from);
 
   if (! could_send(&m, 0)) {
 	return 0;
@@ -394,7 +397,7 @@ set_bytes(size, from, to)
 
   m.m_type = SETBYTES;
   m.m_size = size;
-  ATOBUF(m.m_buf, (char *) to);
+  put_int(m.m_buf, pointer_size, (long) to);
 
   return uputm(&m)
 	 && usend(from, size)
@@ -428,8 +431,8 @@ get_dump(globmessage, globbuf, stackmessage, stackbuf)
 	free(*stackbuf);
 	return 0;
   }
-  ATOBUF(globmessage->m_buf+SP_OFF*pointer_size,
+  put_int(globmessage->m_buf+SP_OFF*pointer_size, pointer_size,
-	 BUFTOA(stackmessage->m_buf+SP_OFF*pointer_size));
+	 get_int(stackmessage->m_buf+SP_OFF*pointer_size, pointer_size, T_UNSIGNED));
   return 1;
 }
 
@@ -467,11 +470,11 @@ get_EM_regs(level)
 	return 0;
   }
   if (answer.m_type == FAIL) return 0;
-  *to++ = (t_addr) BUFTOA(answer.m_buf);
+  *to++ = (t_addr) get_int(answer.m_buf, pointer_size, T_UNSIGNED);
-  *to++ = (t_addr) BUFTOA(answer.m_buf+pointer_size);
+  *to++ = (t_addr) get_int(answer.m_buf+pointer_size, pointer_size, T_UNSIGNED);
-  *to++ = (t_addr) BUFTOA(answer.m_buf+2*pointer_size);
+  *to++ = (t_addr) get_int(answer.m_buf+2*pointer_size, pointer_size, T_UNSIGNED);
-  *to++ = (t_addr) BUFTOA(answer.m_buf+3*pointer_size);
+  *to++ = (t_addr) get_int(answer.m_buf+3*pointer_size, pointer_size, T_UNSIGNED);
-  *to++ = (t_addr) BUFTOA(answer.m_buf+4*pointer_size);
+  *to++ = (t_addr) get_int(answer.m_buf+4*pointer_size, pointer_size, T_UNSIGNED);
   return buf;
 }
 
@@ -483,7 +486,7 @@ set_pc(PC)
 
   m.m_type = SETEMREGS;
   m.m_size = 0;
-  ATOBUF(m.m_buf+PC_OFF*pointer_size, (char *)PC);
+  put_int(m.m_buf+PC_OFF*pointer_size, pointer_size, (long)PC);
   return could_send(&m, 0) && answer.m_type != FAIL;
 }
 
@@ -540,8 +543,8 @@ set_or_clear_trace(start, end, type)
   struct message_hdr m;
 
   m.m_type = type;
-  ATOBUF(m.m_buf, (char *) start);
+  put_int(m.m_buf, pointer_size, (long)start);
-  ATOBUF(m.m_buf+pointer_size, (char *) end);
+  put_int(m.m_buf+pointer_size, pointer_size, (long)end);
   if (debug) printf("%s trace at [0x%lx,0x%lx]\n", type == SETTRACE ? "setting" : "clearing", (long) start, (long) end);
   if (! could_send(&m, 0)) { }
 

util/grind/tree.c

@@ -24,7 +24,6 @@ extern long	pointer_size;
 extern char	*strrindex();
 
 p_tree		run_command;
-t_lineno	list_line;
 
 
 /*VARARGS1*/
@@ -107,7 +106,7 @@ freenode(p)
 }
 
 static t_addr
-get_addr(p)
+get_addr_from_node(p)
   p_tree	p;
 {
   t_addr	a = ILL_ADDR;
@@ -132,7 +131,7 @@ get_addr(p)
 	break;
 	
   case OP_IN:
-	a =  get_addr(p->t_args[0]);
+	a =  get_addr_from_node(p->t_args[0]);
 	p->t_address = a;
 	break;
 
@@ -365,7 +364,7 @@ do_list(p)
 		l2 = p->t_args[1]->t_ival;
 	}
 	else {
-  		t_addr	a = get_addr(p->t_args[0]);
+  		t_addr	a = get_addr_from_node(p->t_args[0]);
 		p_position pos;
 
 		if (a == ILL_ADDR) {
@@ -414,7 +413,7 @@ newfile(id)
 do_stop(p)
   p_tree	p;
 {
-  t_addr	a = get_addr(p->t_args[0]);
+  t_addr	a = get_addr_from_node(p->t_args[0]);
 
   if (a == ILL_ADDR) {
 	return;
@@ -437,7 +436,7 @@ do_trace(p)
 
   p->t_address = NO_ADDR;
   if (p->t_args[0]) {
-	a = get_addr(p->t_args[0]);
+	a = get_addr_from_node(p->t_args[0]);
 	if (a == ILL_ADDR) return;
 	if (p->t_args[0]->t_oper == OP_AT) {
 		e = a;
@@ -569,7 +568,7 @@ do_delete(p)
   if (p) switch(p->t_oper) {
   case OP_WHEN:
   case OP_STOP: {
-	t_addr a = get_addr(p->t_args[0]);
+	t_addr a = get_addr_from_node(p->t_args[0]);
 
 	if (a != ILL_ADDR && a != NO_ADDR) {
 		set_or_clear_breakpoint(a, CLRBP);
@@ -577,7 +576,7 @@ do_delete(p)
 	break;
 	}
   case OP_TRACE: {
-	t_addr a = get_addr(p->t_args[0]);
+	t_addr a = get_addr_from_node(p->t_args[0]);
 	
 	if (a != ILL_ADDR && a != NO_ADDR) {
 		t_addr e;

util/grind/type.c

@@ -11,6 +11,7 @@
 #include "scope.h"
 #include "message.h"
 #include "langdep.h"
+#include "expr.h"
 
 p_type	int_type, char_type, short_type, long_type, bool_type;
 p_type	uint_type, uchar_type, ushort_type, ulong_type;
@@ -401,11 +402,11 @@ compute_size(tp, AB)
   assert(tp->ty_index->ty_A != 0);
 
   if (tp->ty_index->ty_A & 1) {
-	low = BUFTOI(AB+tp->ty_index->ty_low);
+	low = get_int(AB+tp->ty_index->ty_low, int_size, T_INTEGER);
   } else low = tp->ty_index->ty_low;
   tp->ty_lb = low;
   if (tp->ty_index->ty_A & 2) {
-	high = BUFTOI(AB+tp->ty_index->ty_up);
+	high = get_int(AB+tp->ty_index->ty_up, int_size, T_INTEGER);
   } else high = tp->ty_index->ty_up;
   tp->ty_hb = high;
   return (high - low + 1) * tp->ty_elements->ty_size;

util/grind/type.hh

@@ -119,5 +119,5 @@ extern long
 extern p_type	char_type, uchar_type, bool_type, int_type,
 		long_type, double_type, string_type;
 extern p_type	void_type, incomplete_type;
-extern long	int_size, pointer_size;
+extern long	int_size, pointer_size, long_size, double_size;
 

util/grind/value.c

@@ -9,6 +9,7 @@
 #include "type.h"
 #include "message.h"
 #include "langdep.h"
+#include "expr.h"
 
 int stack_offset;		/* for up and down commands */
 
@@ -83,7 +84,11 @@ get_addr(sym, psize)
 
 		size = proctype->ty_nbparams;
 		if (has_static_link(sc)) size += pointer_size;
-		AB = Malloc((unsigned) size);
+		AB = malloc((unsigned) size);
+		if (! AB) {
+			error("could not allocate enough memory");
+			break;
+		}
 		if (! get_bytes(size, EM_regs[AB_OFF], AB)) {
 			break;
 		}
@@ -91,7 +96,7 @@ get_addr(sym, psize)
 			size = compute_size(tp, AB);
 			*psize = size;
 		}
-		a = (t_addr) BUFTOA(AB+sym->sy_name.nm_value);
+		a = (t_addr) get_int(AB+sym->sy_name.nm_value, pointer_size, T_UNSIGNED);
 		free(AB);
 		return a;
 	}
@@ -105,7 +110,7 @@ get_addr(sym, psize)
    Return 0 on failure,
 	  1 on success.
    On success, 'buf' contains the value, and 'size' contains the size.
-   For 'buf', storage is allocated by Malloc; this storage must
+   For 'buf', storage is allocated by malloc; this storage must
    be freed by caller (I don't like this any more than you do, but caller
    does not know sizes).
 */
@@ -123,27 +128,20 @@ get_value(sym, buf, psize)
   *buf = 0;
   switch(sym->sy_class) {
   case CONST:
-	*buf = Malloc((unsigned) size);
+	*buf = malloc((unsigned) size);
+	if (! *buf) {
+		error("could not allocate enough memory");
+		break;
+	}
 	switch(tp->ty_class) {
 	case T_REAL:
-		if (size != sizeof(double)) {
+		put_real(*buf, size, sym->sy_const.co_rval);
-			*((float *) *buf) = sym->sy_const.co_rval;
-		}
-		else	*((double *) *buf) = sym->sy_const.co_rval;
 		break;
 	case T_INTEGER:
 	case T_SUBRANGE:
 	case T_UNSIGNED:
 	case T_ENUM:
-		if (size == sizeof(char)) {
+		put_int(*buf, size, sym->sy_const.co_ival);
-			*((char *) *buf) = sym->sy_const.co_ival;
-		}
-		else if (size == sizeof(short)) {
-			*((short *) *buf) = sym->sy_const.co_ival;
-		}
-		else {
-			*((long *) *buf) = sym->sy_const.co_ival;
-		}
 		break;
 	case T_SET:
 		memcpy(*buf, sym->sy_const.co_setval, (int) size);
@@ -162,7 +160,11 @@ get_value(sym, buf, psize)
 	a = get_addr(sym, psize);
 	if (a) {
 		size = *psize;
-		*buf = Malloc((unsigned) size);
+		*buf = malloc((unsigned) size);
+		if (! *buf) {
+			error("Could not allocate enough memory");
+			break;
+		}
 		if (get_bytes(size, a, *buf)) {
 			retval = 1;
 		}