[unix-history] / usr / src / sys.386bsd / ddb / db_output.c

/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS 
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */
/*
 * HISTORY
 * $Log: db_output.c,v $
 * Revision 1.1  1992/03/25  21:45:18  pace
 * Initial revision
 *
 * Revision 2.3  91/02/05  17:06:45  mrt
 * 	Changed to new Mach copyright
 * 	[91/01/31  16:18:41  mrt]
 * 
 * Revision 2.2  90/08/27  21:51:25  dbg
 * 	Put extra features of db_doprnt in _doprnt.
 * 	[90/08/20            dbg]
 * 	Reduce lint.
 * 	[90/08/07            dbg]
 * 	Created.
 * 	[90/07/25            dbg]
 * 
 */
/*
 * 	Author: David B. Golub, Carnegie Mellon University
 *	Date:	7/90
 */

/*
 * Printf and character output for debugger.
 */

#include "param.h"
#include <machine/stdarg.h>

/*
 *	Character output - tracks position in line.
 *	To do this correctly, we should know how wide
 *	the output device is - then we could zero
 *	the line position when the output device wraps
 *	around to the start of the next line.
 *
 *	Instead, we count the number of spaces printed
 *	since the last printing character so that we
 *	don't print trailing spaces.  This avoids most
 *	of the wraparounds.
 */
int	db_output_position = 0;		/* output column */
int	db_last_non_space = 0;		/* last non-space character */
int	db_tab_stop_width = 8;		/* how wide are tab stops? */
#define	NEXT_TAB(i) \
	((((i) + db_tab_stop_width) / db_tab_stop_width) * db_tab_stop_width)
int	db_max_width = 80;		/* output line width */

extern void	db_check_interrupt();

/*
 * Force pending whitespace.
 */
void
db_force_whitespace()
{
	register int last_print, next_tab;

	last_print = db_last_non_space;
	while (last_print < db_output_position) {
	    next_tab = NEXT_TAB(last_print);
	    if (next_tab <= db_output_position) {
		cnputc('\t');
		last_print = next_tab;
	    }
	    else {
		cnputc(' ');
		last_print++;
	    }
	}
	db_last_non_space = db_output_position;
}

/*
 * Output character.  Buffer whitespace.
 */
db_putchar(c)
	int	c;		/* character to output */
{
	if (c > ' ' && c <= '~') {
	    /*
	     * Printing character.
	     * If we have spaces to print, print them first.
	     * Use tabs if possible.
	     */
	    db_force_whitespace();
	    cnputc(c);
	    db_output_position++;
	    db_last_non_space = db_output_position;
	}
	else if (c == '\n') {
	    /* Return */
	    cnputc(c);
	    db_output_position = 0;
	    db_last_non_space = 0;
	    db_check_interrupt();
	}
	else if (c == '\t') {
	    /* assume tabs every 8 positions */
	    db_output_position = NEXT_TAB(db_output_position);
	}
	else if (c == ' ') {
	    /* space */
	    db_output_position++;
	}
	else if (c == '\007') {
	    /* bell */
	    cnputc(c);
	}
	/* other characters are assumed non-printing */
}

/*
 * Return output position
 */
int
db_print_position()
{
	return (db_output_position);
}

/*
 * End line if too long.
 */
void
db_end_line()
{
	if (db_output_position >= db_max_width)
	    db_printf("\n");
}

/*
 * Printing
 */
extern int	db_radix;

/*VARARGS1*/
db_printf(char *fmt, ...)
{
	va_list	listp;
	va_start(listp, fmt);
	db_printf_guts (fmt, listp);
	va_end(listp);
}

/* alternate name */

/*VARARGS1*/
kdbprintf(char *fmt, ...)
{
	va_list	listp;
	va_start(listp, fmt);
	db_printf_guts (fmt, listp);
	va_end(listp);
}

/*
 * Put a number (base <= 16) in a buffer in reverse order; return an
 * optional length and a pointer to the NULL terminated (preceded?)
 * buffer.
 */
static char *
db_ksprintn(ul, base, lenp)
	register u_long ul;
	register int base, *lenp;
{					/* A long in base 8, plus NULL. */
	static char buf[sizeof(long) * NBBY / 3 + 2];
	register char *p;

	p = buf;
	do {
		*++p = "0123456789abcdef"[ul % base];
	} while (ul /= base);
	if (lenp)
		*lenp = p - buf;
	return (p);
}

db_printf_guts(fmt, ap)
	register const char *fmt;
	va_list ap;
{
	register char *p;
	register int ch, n;
	u_long ul;
	int base, lflag, tmp, width;
	char padc;
	int ladjust;
	int sharpflag;
	int neg;

	for (;;) {
		padc = ' ';
		width = 0;
		while ((ch = *(u_char *)fmt++) != '%') {
			if (ch == '\0')
				return;
			db_putchar(ch);
		}
		lflag = 0;
		ladjust = 0;
		sharpflag = 0;
		neg = 0;
reswitch:	switch (ch = *(u_char *)fmt++) {
		case '0':
			padc = '0';
			goto reswitch;
		case '1': case '2': case '3': case '4':
		case '5': case '6': case '7': case '8': case '9':
			for (width = 0;; ++fmt) {
				width = width * 10 + ch - '0';
				ch = *fmt;
				if (ch < '0' || ch > '9')
					break;
			}
			goto reswitch;
		case 'l':
			lflag = 1;
			goto reswitch;
		case '-':
			ladjust = 1;
			goto reswitch;
		case '#':
			sharpflag = 1;
			goto reswitch;
		case 'b':
			ul = va_arg(ap, int);
			p = va_arg(ap, char *);
			for (p = db_ksprintn(ul, *p++, NULL); ch = *p--;)
				db_putchar(ch);

			if (!ul)
				break;

			for (tmp = 0; n = *p++;) {
				if (ul & (1 << (n - 1))) {
					db_putchar(tmp ? ',' : '<');
					for (; (n = *p) > ' '; ++p)
						db_putchar(n);
					tmp = 1;
				} else
					for (; *p > ' '; ++p);
			}
			if (tmp)
				db_putchar('>');
			break;
		case '*':
			width = va_arg (ap, int);
			if (width < 0) {
				ladjust = !ladjust;
				width = -width;
			}
			goto reswitch;
		case 'c':
			db_putchar(va_arg(ap, int));
			break;
		case 's':
			p = va_arg(ap, char *);
			width -= strlen (p);
			if (!ladjust && width > 0)
				while (width--)
					db_putchar (padc);
			while (ch = *p++)
				db_putchar(ch);
			if (ladjust && width > 0)
				while (width--)
					db_putchar (padc);
			break;
		case 'r':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			if ((long)ul < 0) {
				neg = 1;
				ul = -(long)ul;
			}
			base = db_radix;
			if (base < 8 || base > 16)
				base = 10;
			goto number;
		case 'n':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			base = db_radix;
			if (base < 8 || base > 16)
				base = 10;
			goto number;
		case 'd':
			ul = lflag ? va_arg(ap, long) : va_arg(ap, int);
			if ((long)ul < 0) {
				neg = 1;
				ul = -(long)ul;
			}
			base = 10;
			goto number;
		case 'o':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			base = 8;
			goto number;
		case 'u':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			base = 10;
			goto number;
		case 'z':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			if ((long)ul < 0) {
				neg = 1;
				ul = -(long)ul;
			}
			base = 16;
			goto number;
		case 'x':
			ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
			base = 16;
number:			p = (char *)db_ksprintn(ul, base, &tmp);
			if (sharpflag && ul != 0) {
				if (base == 8)
					tmp++;
				else if (base == 16)
					tmp += 2;
			}
			if (neg)
				tmp++;

			if (!ladjust && width && (width -= tmp) > 0)
				while (width--)
					db_putchar(padc);
			if (neg)
				db_putchar ('-');
			if (sharpflag && ul != 0) {
				if (base == 8) {
					db_putchar ('0');
				} else if (base == 16) {
					db_putchar ('0');
					db_putchar ('x');
				}
			}
			if (ladjust && width && (width -= tmp) > 0)
				while (width--)
					db_putchar(padc);

			while (ch = *p--)
				db_putchar(ch);
			break;
		default:
			db_putchar('%');
			if (lflag)
				db_putchar('l');
			/* FALLTHROUGH */
		case '%':
			db_putchar(ch);
		}
	}
}
Commit	Line	Data
c1cfdb7a WJ	1	/*
	2	* Mach Operating System
	3	* Copyright (c) 1991,1990 Carnegie Mellon University
	4	* All Rights Reserved.
	5	*
	6	* Permission to use, copy, modify and distribute this software and its
	7	* documentation is hereby granted, provided that both the copyright
	8	* notice and this permission notice appear in all copies of the
	9	* software, derivative works or modified versions, and any portions
	10	* thereof, and that both notices appear in supporting documentation.
	11	*
	12	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
	13	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	14	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	15	*
	16	* Carnegie Mellon requests users of this software to return to
	17	*
	18	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	19	* School of Computer Science
	20	* Carnegie Mellon University
	21	* Pittsburgh PA 15213-3890
	22	*
	23	* any improvements or extensions that they make and grant Carnegie the
	24	* rights to redistribute these changes.
	25	*/
	26	/*
	27	* HISTORY
	28	* $Log: db_output.c,v $
	29	* Revision 1.1 1992/03/25 21:45:18 pace
	30	* Initial revision
	31	*
	32	* Revision 2.3 91/02/05 17:06:45 mrt
	33	* Changed to new Mach copyright
	34	* [91/01/31 16:18:41 mrt]
	35	*
	36	* Revision 2.2 90/08/27 21:51:25 dbg
	37	* Put extra features of db_doprnt in _doprnt.
	38	* [90/08/20 dbg]
	39	* Reduce lint.
	40	* [90/08/07 dbg]
	41	* Created.
	42	* [90/07/25 dbg]
	43	*
	44	*/
	45	/*
	46	* Author: David B. Golub, Carnegie Mellon University
	47	* Date: 7/90
	48	*/
	49
	50	/*
	51	* Printf and character output for debugger.
	52	*/
	53
	54	#include "param.h"
	55	#include <machine/stdarg.h>
	56
	57	/*
	58	* Character output - tracks position in line.
	59	* To do this correctly, we should know how wide
	60	* the output device is - then we could zero
	61	* the line position when the output device wraps
	62	* around to the start of the next line.
	63	*
	64	* Instead, we count the number of spaces printed
65	* since the last printing character so that we
66	* don't print trailing spaces. This avoids most
67	* of the wraparounds.
68	*/
69	int db_output_position = 0; /* output column */
70	int db_last_non_space = 0; /* last non-space character */
71	int db_tab_stop_width = 8; /* how wide are tab stops? */
72	#define NEXT_TAB(i) \
73	((((i) + db_tab_stop_width) / db_tab_stop_width) * db_tab_stop_width)
74	int db_max_width = 80; /* output line width */
75
76	extern void db_check_interrupt();
77
78	/*
79	* Force pending whitespace.
80	*/
81	void
82	db_force_whitespace()
83	{
84	register int last_print, next_tab;
85
86	last_print = db_last_non_space;
87	while (last_print < db_output_position) {
88	next_tab = NEXT_TAB(last_print);
89	if (next_tab <= db_output_position) {
90	cnputc('\t');
91	last_print = next_tab;
92	}
93	else {
94	cnputc(' ');
95	last_print++;
96	}
97	}
98	db_last_non_space = db_output_position;
99	}
100
101	/*
102	* Output character. Buffer whitespace.
103	*/
104	db_putchar(c)
105	int c; /* character to output */
106	{
107	if (c > ' ' && c <= '~') {
108	/*
109	* Printing character.
110	* If we have spaces to print, print them first.
111	* Use tabs if possible.
112	*/
113	db_force_whitespace();
114	cnputc(c);
115	db_output_position++;
116	db_last_non_space = db_output_position;
117	}
118	else if (c == '\n') {
119	/* Return */
120	cnputc(c);
121	db_output_position = 0;
122	db_last_non_space = 0;
123	db_check_interrupt();
124	}
125	else if (c == '\t') {
126	/* assume tabs every 8 positions */
127	db_output_position = NEXT_TAB(db_output_position);
128	}
129	else if (c == ' ') {
130	/* space */
131	db_output_position++;
132	}
133	else if (c == '\007') {
134	/* bell */
135	cnputc(c);
136	}
137	/* other characters are assumed non-printing */
138	}
139
140	/*
141	* Return output position
142	*/
143	int
144	db_print_position()
145	{
146	return (db_output_position);
147	}
148
149	/*
150	* End line if too long.
151	*/
152	void
153	db_end_line()
154	{
155	if (db_output_position >= db_max_width)
156	db_printf("\n");
157	}
158
159	/*
160	* Printing
161	*/
162	extern int db_radix;
163
164	/VARARGS1/
165	db_printf(char *fmt, ...)
166	{
167	va_list listp;
168	va_start(listp, fmt);
169	db_printf_guts (fmt, listp);
170	va_end(listp);
171	}
172
173	/* alternate name */
174
175	/VARARGS1/
176	kdbprintf(char *fmt, ...)
177	{
178	va_list listp;
179	va_start(listp, fmt);
180	db_printf_guts (fmt, listp);
181	va_end(listp);
182	}
183
184	/*
185	* Put a number (base <= 16) in a buffer in reverse order; return an
186	* optional length and a pointer to the NULL terminated (preceded?)
187	* buffer.
188	*/
189	static char *
190	db_ksprintn(ul, base, lenp)
191	register u_long ul;
192	register int base, *lenp;
193	{ /* A long in base 8, plus NULL. */
194	static char buf[sizeof(long) * NBBY / 3 + 2];
195	register char *p;
196
197	p = buf;
198	do {
199	*++p = "0123456789abcdef"[ul % base];
200	} while (ul /= base);
201	if (lenp)
202	*lenp = p - buf;
203	return (p);
204	}
205
206	db_printf_guts(fmt, ap)
207	register const char *fmt;
208	va_list ap;
209	{
210	register char *p;
211	register int ch, n;
212	u_long ul;
213	int base, lflag, tmp, width;
214	char padc;
215	int ladjust;
216	int sharpflag;
217	int neg;
218
219	for (;;) {
220	padc = ' ';
221	width = 0;
222	while ((ch = (u_char )fmt++) != '%') {
223	if (ch == '\0')
224	return;
225	db_putchar(ch);
226	}
227	lflag = 0;
228	ladjust = 0;
229	sharpflag = 0;
230	neg = 0;
231	reswitch: switch (ch = (u_char )fmt++) {
232	case '0':
233	padc = '0';
234	goto reswitch;
235	case '1': case '2': case '3': case '4':
236	case '5': case '6': case '7': case '8': case '9':
237	for (width = 0;; ++fmt) {
238	width = width * 10 + ch - '0';
239	ch = *fmt;
240	if (ch < '0' \|\| ch > '9')
241	break;
242	}
243	goto reswitch;
244	case 'l':
245	lflag = 1;
246	goto reswitch;
247	case '-':
248	ladjust = 1;
249	goto reswitch;
250	case '#':
251	sharpflag = 1;
252	goto reswitch;
253	case 'b':
254	ul = va_arg(ap, int);
255	p = va_arg(ap, char *);
256	for (p = db_ksprintn(ul, p++, NULL); ch = p--;)
257	db_putchar(ch);
258
259	if (!ul)
260	break;
261
262	for (tmp = 0; n = *p++;) {
263	if (ul & (1 << (n - 1))) {
264	db_putchar(tmp ? ',' : '<');
265	for (; (n = *p) > ' '; ++p)
266	db_putchar(n);
267	tmp = 1;
268	} else
269	for (; *p > ' '; ++p);
270	}
271	if (tmp)
272	db_putchar('>');
273	break;
274	case '*':
275	width = va_arg (ap, int);
276	if (width < 0) {
277	ladjust = !ladjust;
278	width = -width;
279	}
280	goto reswitch;
281	case 'c':
282	db_putchar(va_arg(ap, int));
283	break;
284	case 's':
285	p = va_arg(ap, char *);
286	width -= strlen (p);
287	if (!ladjust && width > 0)
288	while (width--)
289	db_putchar (padc);
290	while (ch = *p++)
291	db_putchar(ch);
292	if (ladjust && width > 0)
293	while (width--)
294	db_putchar (padc);
295	break;
296	case 'r':
297	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
298	if ((long)ul < 0) {
299	neg = 1;
300	ul = -(long)ul;
301	}
302	base = db_radix;
303	if (base < 8 \|\| base > 16)
304	base = 10;
305	goto number;
306	case 'n':
307	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
308	base = db_radix;
309	if (base < 8 \|\| base > 16)
310	base = 10;
311	goto number;
312	case 'd':
313	ul = lflag ? va_arg(ap, long) : va_arg(ap, int);
314	if ((long)ul < 0) {
315	neg = 1;
316	ul = -(long)ul;
317	}
318	base = 10;
319	goto number;
320	case 'o':
321	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
322	base = 8;
323	goto number;
324	case 'u':
325	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
326	base = 10;
327	goto number;
328	case 'z':
329	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
330	if ((long)ul < 0) {
331	neg = 1;
332	ul = -(long)ul;
333	}
334	base = 16;
335	goto number;
336	case 'x':
337	ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
338	base = 16;
339	number: p = (char *)db_ksprintn(ul, base, &tmp);
340	if (sharpflag && ul != 0) {
341	if (base == 8)
342	tmp++;
343	else if (base == 16)
344	tmp += 2;
345	}
346	if (neg)
347	tmp++;
348
349	if (!ladjust && width && (width -= tmp) > 0)
350	while (width--)
351	db_putchar(padc);
352	if (neg)
353	db_putchar ('-');
354	if (sharpflag && ul != 0) {
355	if (base == 8) {
356	db_putchar ('0');
357	} else if (base == 16) {
358	db_putchar ('0');
359	db_putchar ('x');
360	}
361	}
362	if (ladjust && width && (width -= tmp) > 0)
363	while (width--)
364	db_putchar(padc);
365
366	while (ch = *p--)
367	db_putchar(ch);
368	break;
369	default:
370	db_putchar('%');
371	if (lflag)
372	db_putchar('l');
373	/* FALLTHROUGH */
374	case '%':
375	db_putchar(ch);
376	}
377	}
378	}
379