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

#ifndef lint
static	char sccsid[] = "@(#)output.c	4.3 8/11/83";
#endif
/*
 *
 *	UNIX debugger
 *
 */

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