[unix-history] / usr / src / old / adb / adb.vax / output.c

#
/*
 *
 *	UNIX debugger
 *
 */

#include "defs.h"
static	char sccsid[] = "@(#)output.c 4.2 %G%";
#include <stdio.h>


INT		mkfault;
INT		infile;
INT		outfile = 1;
L_INT		maxpos;
L_INT		maxoff;
INT		radix = 16;

CHAR		printbuf[MAXLIN];
CHAR		*printptr = printbuf;
CHAR		*digitptr;
MSG		TOODEEP;


eqstr(s1, s2)
	REG STRING	s1, s2;
{
	REG STRING	 es1;
	WHILE *s1++ == *s2
	DO IF *s2++ == 0
	   THEN return(1);
	   FI
	OD
	return(0);
}

length(s)
	REG STRING		s;
{
	INT		n = 0;
	WHILE *s++ DO n++; OD
	return(n);
}

printc(c)
	CHAR		c;
{
	CHAR		d;
	STRING		q;
	INT		posn, tabs, p;

	IF mkfault
	THEN	return;
	ELIF (*printptr=c)==EOR
	THEN tabs=0; posn=0; q=printbuf;
	     FOR p=0; p<printptr-printbuf; p++
	     DO d=printbuf[p];
		IF (p&7)==0 ANDF posn
		THEN tabs++; posn=0;
		FI
		IF d==SP
		THEN posn++;
		ELSE WHILE tabs>0 DO *q++=TB; tabs--; OD
		     WHILE posn>0 DO *q++=SP; posn--; OD
		     *q++=d;
		FI
	     OD
	     *q++=EOR;
#ifdef EDDT
		printptr=printbuf; do putchar(*printptr++); while (printptr<q);
#else
	     write(outfile,printbuf,q-printbuf);
#endif
	     printptr=printbuf;
	ELIF c==TB
	THEN *printptr++=SP;
	     WHILE (printptr-printbuf)&7 DO *printptr++=SP; OD
	ELIF c
	THEN printptr++;
	FI
	IF printptr >= &printbuf[MAXLIN-9] THEN
		write(outfile, printbuf, printptr - printbuf);
		printptr = printbuf;
	FI
}

charpos()
{	return(printptr-printbuf);
}

flushbuf()
{	IF printptr!=printbuf
	THEN printc(EOR);
	FI
}

printf(fmat,a1)
	STRING		fmat;
	STRING		*a1;
{
	STRING		fptr, s;
	INT		*vptr;
	L_INT		*dptr;
	L_REAL		*rptr;
	INT		width, prec;
	CHAR		c, adj;
	INT		x, decpt, n;
	L_INT		lx;
	CHAR		digits[64];

	fptr = fmat; dptr = vptr = &a1;

	WHILE c = *fptr++
	DO  IF c!='%'
	    THEN printc(c);
	    ELSE IF *fptr=='-' THEN adj='l'; fptr++; ELSE adj='r'; FI
		 width=convert(&fptr);
		 IF *fptr=='.' THEN fptr++; prec=convert(&fptr); ELSE prec = -1; FI
		 digitptr=digits;
#ifndef vax
		 dptr=rptr=vptr; lx = *dptr; x = *vptr++;
#else
		 rptr=dptr; x = shorten(lx = *dptr++);
#endif
		 s=0;
		 switch (c = *fptr++) {

		    case 'd':
		    case 'u':
			printnum(x,c,10); break;
		    case 'o':
#ifndef vax
			printoct(0,x,0); break;
#else
			printoct(itol(0,x),0); break;
#endif
		    case 'q':
			lx=x; printoct(lx,-1); break;
		    case 'x':
#ifndef vax
			printdbl(0,x,c,16); break;
#else
			printdbl(itol(0,x),c,16); break;
#endif
			case 'r':
			printdbl(lx=x,c,radix); break;
			case 'R':
			printdbl(lx,c,radix); vptr++; break;
		    case 'Y':
			printdate(lx); vptr++; break;
		    case 'D':
		    case 'U':
			printdbl(lx,c,10); vptr++; break;
		    case 'O':
			printoct(lx,0); vptr++; break;
		    case 'Q':
			printoct(lx,-1); vptr++; break;
		    case 'X':
			printdbl(lx,'x',16); vptr++; break;
		    case 'c':
			printc(x); break;
		    case 's':
#ifndef vax
			s=x; break;
#else
			s=lx; break;
#endif
#ifndef EDDT
		    case 'f':
		    case 'F':
#ifdef vax
			dptr++;
			sprintf(s=digits,"%+.16e",*rptr,*(rptr+4)); prec= -1; break;
#else
			vptr += 7;
			s=ecvt(*rptr, prec, &decpt, &n);
			*digitptr++=(n?'-':'+');
			*digitptr++ = (decpt<=0 ? '0' : *s++);
			IF decpt>0 THEN decpt--; FI
			*digitptr++ = '.';
			WHILE *s ANDF prec-- DO *digitptr++ = *s++; OD
			WHILE *--digitptr=='0' DONE
			digitptr += (digitptr-digits>=3 ? 1 : 2);
			IF decpt
			THEN *digitptr++ = 'e'; printnum(decpt,'d',10);
			FI
			s=0; prec = -1; break;
#endif
#endif
		    case 'm':
			vptr--; break;
		    case 'M':
			width=x; break;
		    case 'T':
		    case 't':
			IF c=='T'
			THEN width=x;
#ifndef vax
			ELSE vptr--;
#else
			ELSE dptr--;
#endif
			FI
			IF width
			THEN width -= charpos()%width;
			FI
			break;
		    default:
#ifndef vax
			printc(c); vptr--;
#else
			printc(c); dptr--;
#endif
		}

		IF s==0
		THEN *digitptr=0; s=digits;
		FI
		n=length(s);
		n=(prec<n ANDF prec>=0 ? prec : n);
		width -= n;
		IF adj=='r'
		THEN WHILE width-- > 0
		     DO printc(SP); OD
		FI
		WHILE n-- DO printc(*s++); OD
		WHILE width-- > 0 DO printc(SP); OD
		digitptr=digits;
	    FI
	OD
}

printdate(tvec)
	L_INT		tvec;
{
	REG INT		i;
	REG STRING	timeptr;
#ifndef EDDT
	timeptr = ctime(&tvec);
#else
	timeptr="????????????????????????";
#endif
	FOR i=20; i<24; i++ DO *digitptr++ = *(timeptr+i); OD
	FOR i=3; i<19; i++ DO *digitptr++ = *(timeptr+i); OD
} /*printdate*/

prints(s)
char *s;
{	printf("%s",s);
}

newline()
{
	printc(EOR);
}

convert(cp)
REG STRING	*cp;
{
	REG CHAR	c;
	INT		n;
	n=0;
	WHILE ((c = *(*cp)++)>='0') ANDF (c<='9') DO n=n*10+c-'0'; OD
	(*cp)--;
	return(n);
}

printnum(n,fmat,base)
	REG INT		n;
{
	REG CHAR	k;
	REG INT		*dptr;
	INT		digs[15];
	dptr=digs;
	IF n<0 ANDF fmat=='d' THEN n = -n; *digitptr++ = '-'; FI
	n &= 0xffff;
	WHILE n
	DO  *dptr++ = ((POS)(n&0xffff))%base;
	    n=((POS)(n&0xffff))/base;
	OD
	IF dptr==digs THEN *dptr++=0; FI
	WHILE dptr!=digs
	DO  k = *--dptr;
	    *digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
	OD
}

printoct(o,s)
	L_INT		o;
	INT		s;
{
	INT		i;
	L_INT		po = o;
	CHAR		digs[12];

	IF s
	THEN IF po<0
	     THEN po = -po; *digitptr++='-';
	     ELSE IF s>0 THEN *digitptr++='+'; FI
	     FI
	FI
	FOR i=0;i<=11;i++
	DO digs[i] = po&7; po >>= 3; OD
	digs[10] &= 03; digs[11]=0;
	FOR i=11;i>=0;i--
	DO IF digs[i] THEN break; FI OD
	FOR i++;i>=0;i--
	DO *digitptr++=digs[i]+'0'; OD
}

#ifndef vax
printdbl(lx,ly,fmat,base)
INT lx, ly; char fmat; int base;
#else
printdbl(lxy,fmat,base)
L_INT lxy; char fmat; int base;
#endif
{	int digs[20]; int *dptr; char k;
#ifndef MULD2
	register char *cp1;
	cp1=digs; if ((lxy&0xFFFF0000L)==0xFFFF0000L) {*cp1++='-'; lxy= -lxy;}
	sprintf(cp1,base==16 ? "%X" : "%D",lxy);
	cp1=digs; while (*digitptr++= *cp1++); --digitptr;
#else
	L_REAL f ,g; long q;
#ifdef vax
	INT lx,ly;
	ly=lxy; lx=(lxy>>16)&0xFFFF;
#endif
	dptr=digs;
	IF fmat=='D' ORF fmat=='r'
	THEN	f=itol(lx,ly);
		IF f<0 THEN *digitptr++='-'; f = -f; FI
	ELSE
		IF lx==-1
		THEN *digitptr++='-'; f=leng(-ly);
		ELSE f=leng(lx); f *= itol(1,0); f += leng(ly);
		FI
		IF fmat=='x' THEN *digitptr++='#'; FI
	FI
	WHILE f
	DO  q=f/base; g=q;
	    *dptr++ = f-g*base;
	    f=q;
	OD
	IF dptr==digs ORF dptr[-1]>9 THEN *dptr++=0; FI
	WHILE dptr!=digs
	DO  k = *--dptr;
	    *digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
	OD
#endif
}

#define	MAXIFD	5
struct {
	int	fd;
	int	r9;
} istack[MAXIFD];
int	ifiledepth;

iclose(stack, err)
{
	IF err
	THEN	IF infile
		THEN	close(infile); infile=0;
		FI
		WHILE --ifiledepth >= 0
		DO	IF istack[ifiledepth].fd
			THEN	close(istack[ifiledepth].fd);
			FI
		OD
		ifiledepth = 0;
	ELIF stack == 0
	THEN	IF infile
		THEN	close(infile); infile=0;
		FI
	ELIF stack > 0
	THEN	IF ifiledepth >= MAXIFD
		THEN	error(TOODEEP);
		FI
		istack[ifiledepth].fd = infile;
		istack[ifiledepth].r9 = var[9];
		ifiledepth++;
		infile = 0;
	ELSE	IF infile
		THEN	close(infile); infile=0;
		FI
		IF ifiledepth > 0
		THEN	infile = istack[--ifiledepth].fd;
			var[9] = istack[ifiledepth].r9;
		FI
	FI
}

oclose()
{
	IF outfile!=1
	THEN	flushbuf(); close(outfile); outfile=1;
	FI
}

endline()
{

	if (maxpos <= charpos())
		printf("\n");
}
Commit	Line	Data
b4497ed1 BJ	1	#
	2	/*
	3	*
	4	* UNIX debugger
	5	*
	6	*/
	7
	8	#include "defs.h"
52bff713	9	static char sccsid[] = "@(#)output.c 4.2 %G%";
b4497ed1 BJ	10	#include <stdio.h>
	11
	12
	13	INT mkfault;
	14	INT infile;
	15	INT outfile = 1;
	16	L_INT maxpos;
	17	L_INT maxoff;
	18	INT radix = 16;
	19
	20	CHAR printbuf[MAXLIN];
	21	CHAR *printptr = printbuf;
	22	CHAR *digitptr;
	23	MSG TOODEEP;
	24
	25
	26	eqstr(s1, s2)
	27	REG STRING s1, s2;
	28	{
	29	REG STRING es1;
	30	WHILE s1++ == s2
	31	DO IF *s2++ == 0
	32	THEN return(1);
	33	FI
	34	OD
	35	return(0);
	36	}
	37
	38	length(s)
	39	REG STRING s;
	40	{
	41	INT n = 0;
	42	WHILE *s++ DO n++; OD
	43	return(n);
	44	}
	45
	46	printc(c)
	47	CHAR c;
	48	{
	49	CHAR d;
	50	STRING q;
	51	INT posn, tabs, p;
	52
	53	IF mkfault
	54	THEN return;
	55	ELIF (*printptr=c)==EOR
	56	THEN tabs=0; posn=0; q=printbuf;
	57	FOR p=0; p<printptr-printbuf; p++
	58	DO d=printbuf[p];
	59	IF (p&7)==0 ANDF posn
	60	THEN tabs++; posn=0;
	61	FI
	62	IF d==SP
	63	THEN posn++;
	64	ELSE WHILE tabs>0 DO *q++=TB; tabs--; OD
	65	WHILE posn>0 DO *q++=SP; posn--; OD
	66	*q++=d;
	67	FI
	68	OD
	69	*q++=EOR;
	70	#ifdef EDDT
	71	printptr=printbuf; do putchar(*printptr++); while (printptr<q);
	72	#else
	73	write(outfile,printbuf,q-printbuf);
74	#endif
75	printptr=printbuf;
76	ELIF c==TB
77	THEN *printptr++=SP;
78	WHILE (printptr-printbuf)&7 DO *printptr++=SP; OD
79	ELIF c
80	THEN printptr++;
81	FI
52bff713 BJ	82	IF printptr >= &printbuf[MAXLIN-9] THEN
	83	write(outfile, printbuf, printptr - printbuf);
	84	printptr = printbuf;
	85	FI
b4497ed1 BJ	86	}
	87
	88	charpos()
	89	{ return(printptr-printbuf);
	90	}
	91
	92	flushbuf()
	93	{ IF printptr!=printbuf
	94	THEN printc(EOR);
	95	FI
	96	}
	97
	98	printf(fmat,a1)
	99	STRING fmat;
	100	STRING *a1;
	101	{
	102	STRING fptr, s;
	103	INT *vptr;
	104	L_INT *dptr;
	105	L_REAL *rptr;
	106	INT width, prec;
	107	CHAR c, adj;
	108	INT x, decpt, n;
	109	L_INT lx;
	110	CHAR digits[64];
	111
	112	fptr = fmat; dptr = vptr = &a1;
	113
	114	WHILE c = *fptr++
	115	DO IF c!='%'
	116	THEN printc(c);
	117	ELSE IF *fptr=='-' THEN adj='l'; fptr++; ELSE adj='r'; FI
	118	width=convert(&fptr);
	119	IF *fptr=='.' THEN fptr++; prec=convert(&fptr); ELSE prec = -1; FI
	120	digitptr=digits;
	121	#ifndef vax
	122	dptr=rptr=vptr; lx = dptr; x = vptr++;
	123	#else
	124	rptr=dptr; x = shorten(lx = *dptr++);
	125	#endif
	126	s=0;
	127	switch (c = *fptr++) {
	128
	129	case 'd':
	130	case 'u':
	131	printnum(x,c,10); break;
	132	case 'o':
	133	#ifndef vax
	134	printoct(0,x,0); break;
	135	#else
	136	printoct(itol(0,x),0); break;
	137	#endif
	138	case 'q':
	139	lx=x; printoct(lx,-1); break;
	140	case 'x':
	141	#ifndef vax
	142	printdbl(0,x,c,16); break;
	143	#else
	144	printdbl(itol(0,x),c,16); break;
	145	#endif
	146	case 'r':
	147	printdbl(lx=x,c,radix); break;
	148	case 'R':
	149	printdbl(lx,c,radix); vptr++; break;
150	case 'Y':
151	printdate(lx); vptr++; break;
152	case 'D':
153	case 'U':
154	printdbl(lx,c,10); vptr++; break;
155	case 'O':
156	printoct(lx,0); vptr++; break;
157	case 'Q':
158	printoct(lx,-1); vptr++; break;
159	case 'X':
160	printdbl(lx,'x',16); vptr++; break;
161	case 'c':
162	printc(x); break;
163	case 's':
164	#ifndef vax
165	s=x; break;
166	#else
167	s=lx; break;
168	#endif
169	#ifndef EDDT
170	case 'f':
171	case 'F':
172	#ifdef vax
173	dptr++;
174	sprintf(s=digits,"%+.16e",rptr,(rptr+4)); prec= -1; break;
175	#else
176	vptr += 7;
177	s=ecvt(*rptr, prec, &decpt, &n);
178	*digitptr++=(n?'-':'+');
179	digitptr++ = (decpt<=0 ? '0' : s++);
180	IF decpt>0 THEN decpt--; FI
181	*digitptr++ = '.';
182	WHILE s ANDF prec-- DO digitptr++ = *s++; OD
183	WHILE *--digitptr=='0' DONE
184	digitptr += (digitptr-digits>=3 ? 1 : 2);
185	IF decpt
186	THEN *digitptr++ = 'e'; printnum(decpt,'d',10);
187	FI
188	s=0; prec = -1; break;
189	#endif
190	#endif
191	case 'm':
192	vptr--; break;
193	case 'M':
194	width=x; break;
195	case 'T':
196	case 't':
197	IF c=='T'
198	THEN width=x;
199	#ifndef vax
200	ELSE vptr--;
201	#else
202	ELSE dptr--;
203	#endif
204	FI
205	IF width
206	THEN width -= charpos()%width;
207	FI
208	break;
209	default:
210	#ifndef vax
211	printc(c); vptr--;
212	#else
213	printc(c); dptr--;
214	#endif
215	}
216
217	IF s==0
218	THEN *digitptr=0; s=digits;
219	FI
220	n=length(s);
221	n=(prec<n ANDF prec>=0 ? prec : n);
222	width -= n;
223	IF adj=='r'
224	THEN WHILE width-- > 0
225	DO printc(SP); OD
226	FI
227	WHILE n-- DO printc(*s++); OD
228	WHILE width-- > 0 DO printc(SP); OD
229	digitptr=digits;
230	FI
231	OD
232	}
233
234	printdate(tvec)
235	L_INT tvec;
236	{
237	REG INT i;
238	REG STRING timeptr;
239	#ifndef EDDT
240	timeptr = ctime(&tvec);
241	#else
242	timeptr="????????????????????????";
243	#endif
244	FOR i=20; i<24; i++ DO digitptr++ = (timeptr+i); OD
245	FOR i=3; i<19; i++ DO digitptr++ = (timeptr+i); OD
246	} /printdate/
247
248	prints(s)
249	char *s;
250	{ printf("%s",s);
251	}
252
253	newline()
254	{
255	printc(EOR);
256	}
257
258	convert(cp)
259	REG STRING *cp;
260	{
261	REG CHAR c;
262	INT n;
263	n=0;
264	WHILE ((c = (cp)++)>='0') ANDF (c<='9') DO n=n*10+c-'0'; OD
265	(*cp)--;
266	return(n);
267	}
268
269	printnum(n,fmat,base)
270	REG INT n;
271	{
272	REG CHAR k;
273	REG INT *dptr;
274	INT digs[15];
275	dptr=digs;
276	IF n<0 ANDF fmat=='d' THEN n = -n; *digitptr++ = '-'; FI
277	n &= 0xffff;
278	WHILE n
279	DO *dptr++ = ((POS)(n&0xffff))%base;
280	n=((POS)(n&0xffff))/base;
281	OD
282	IF dptr==digs THEN *dptr++=0; FI
283	WHILE dptr!=digs
284	DO k = *--dptr;
285	*digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
286	OD
287	}
288
289	printoct(o,s)
290	L_INT o;
291	INT s;
292	{
293	INT i;
294	L_INT po = o;
295	CHAR digs[12];
296
297	IF s
298	THEN IF po<0
299	THEN po = -po; *digitptr++='-';
300	ELSE IF s>0 THEN *digitptr++='+'; FI
301	FI
302	FI
303	FOR i=0;i<=11;i++
304	DO digs[i] = po&7; po >>= 3; OD
305	digs[10] &= 03; digs[11]=0;
306	FOR i=11;i>=0;i--
307	DO IF digs[i] THEN break; FI OD
308	FOR i++;i>=0;i--
309	DO *digitptr++=digs[i]+'0'; OD
310	}
311
312	#ifndef vax
313	printdbl(lx,ly,fmat,base)
314	INT lx, ly; char fmat; int base;
315	#else
316	printdbl(lxy,fmat,base)
317	L_INT lxy; char fmat; int base;
318	#endif
319	{ int digs[20]; int *dptr; char k;
320	#ifndef MULD2
321	register char *cp1;
322	cp1=digs; if ((lxy&0xFFFF0000L)==0xFFFF0000L) {*cp1++='-'; lxy= -lxy;}
323	sprintf(cp1,base==16 ? "%X" : "%D",lxy);
324	cp1=digs; while (digitptr++= cp1++); --digitptr;
325	#else
326	L_REAL f ,g; long q;
327	#ifdef vax
328	INT lx,ly;
329	ly=lxy; lx=(lxy>>16)&0xFFFF;
330	#endif
331	dptr=digs;
332	IF fmat=='D' ORF fmat=='r'
333	THEN f=itol(lx,ly);
334	IF f<0 THEN *digitptr++='-'; f = -f; FI
335	ELSE
336	IF lx==-1
337	THEN *digitptr++='-'; f=leng(-ly);
338	ELSE f=leng(lx); f *= itol(1,0); f += leng(ly);
339	FI
340	IF fmat=='x' THEN *digitptr++='#'; FI
341	FI
342	WHILE f
343	DO q=f/base; g=q;
344	dptr++ = f-gbase;
345	f=q;
346	OD
347	IF dptr==digs ORF dptr[-1]>9 THEN *dptr++=0; FI
348	WHILE dptr!=digs
349	DO k = *--dptr;
350	*digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
351	OD
352	#endif
353	}
354
355	#define MAXIFD 5
356	struct {
357	int fd;
358	int r9;
359	} istack[MAXIFD];
360	int ifiledepth;
361
362	iclose(stack, err)
363	{
364	IF err
365	THEN IF infile
366	THEN close(infile); infile=0;
367	FI
368	WHILE --ifiledepth >= 0
369	DO IF istack[ifiledepth].fd
370	THEN close(istack[ifiledepth].fd);
371	FI
372	OD
373	ifiledepth = 0;
374	ELIF stack == 0
375	THEN IF infile
376	THEN close(infile); infile=0;
377	FI
378	ELIF stack > 0
379	THEN IF ifiledepth >= MAXIFD
380	THEN error(TOODEEP);
381	FI
382	istack[ifiledepth].fd = infile;
383	istack[ifiledepth].r9 = var[9];
384	ifiledepth++;
385	infile = 0;
386	ELSE IF infile
387	THEN close(infile); infile=0;
388	FI
389	IF ifiledepth > 0
390	THEN infile = istack[--ifiledepth].fd;
391	var[9] = istack[ifiledepth].r9;
392	FI
393	FI
394	}
395
396	oclose()
397	{
398	IF outfile!=1
399	THEN flushbuf(); close(outfile); outfile=1;
400	FI
401	}
402
403	endline()
404	{
405
406	if (maxpos <= charpos())
407	printf("\n");
408	}