Return to output.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb

Power 6/32 Unix version 1.2b

/*
 *
 *	UNIX debugger
 *
 */

#include "defs.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;

printc(c)
	CHAR		c;
{
	CHAR		d;
	REG	STRING	q;
	REG		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
}

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

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

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

	fptr = fmat; dptr = (L_INT *)&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;
		 rptr=(L_REAL *)dptr; x = lx = *dptr++;
		 s=0;
		 switch (c = *fptr++) {

		    case 'd':
			printnum(x, -10); break;
		    case 'u':
			printnum((unsigned short)x, 10); break;
		    case 'o':
			printnum((unsigned short)x, 8); break;
		    case 'q':
			printnum(x, -8); break;
		    case 'x':
			printnum((unsigned short)x, 16); break;
		    case 'z':
			printnum((unsigned short)x, -16); break;
		    case 'R':
			printnum(lx, radix); break;
		    case 'Y':
			printdate(lx); break;
		    case 'D':
			printnum(lx, -10); break;
		    case 'U':
			printnum(lx, 10); break;
		    case 'O':
			printnum(lx, 8); break;
		    case 'Q':
			printnum(lx, -8); break;
		    case 'X':
			printnum(lx, 16); break;
		    case 'Z':
			printnum(lx, -16); break;
		    case 'c':
			printc(x); break;
		    case 's':
			s=(STRING)lx; break;
#ifndef EDDT
		    case 'f':
		    case 'F':
			dptr++;
			sprintf(s=digits, "%*.*f", width, prec, *rptr); prec= -1; break;
#endif
		    case 'm':
			break;
		    case 'M':
			width=x; break;
		    case 'T':
		    case 't':
			IF c=='T'
			THEN width=x;
			ELSE dptr--;
			FI
			IF width
			THEN width -= charpos()%width;
			FI
			break;
		    default:
			printc(c); dptr--;
		}

		IF s==0
		THEN *digitptr=0; s=digits;
		FI
		n=strlen(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		i;
	REG STRING	timeptr;
	STRING		ctime();

#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*/

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, base)
	REG POS		n;
{
	REG CHAR	*dptr;
	CHAR		digs[15];
	dptr=digs;
	IF base<0 THEN base = -base;
		IF (L_INT)n<0 THEN n = -n; *digitptr++ = '-'; FI
	FI
	WHILE n
	DO  *dptr++ = n%base;
	    n /= base;
	OD
	IF dptr==digs THEN *dptr++=0; FI
	WHILE dptr!=digs
	DO  n = *--dptr;
	    *digitptr++ = (n+(n<=9 ? '0' : 'a'-10));
	OD
}

iclose()
{
	IF infile
	THEN	close(infile); infile=0;
	FI
}

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

endline()
{

	if (maxpos <= charpos())
		printf("\n");
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.