BSD 4_4 release

[unix-history] / usr / src / sys / stand.att / printf.c

diff --git a/usr/src/sys/stand.att/printf.c b/usr/src/sys/stand.att/printf.c
index 336ee2f..04175a9 100644 (file)
--- a/usr/src/sys/stand.att/printf.c
+++ b/usr/src/sys/stand.att/printf.c
@@ -1,22 +1,44 @@
 /*-
 /*-

- * Copyright (c) 1991 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  *

- * %sccs.include.redist.c%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.

  *
  *

- *     @(#)printf.c    5.1 (Berkeley) %G%
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)printf.c    8.1 (Berkeley) 6/11/93

  */
 
  */
 

-#include <sys/param.h>
-

 /*
 /*

- * Scaled down version of C Library printf.
+ * Scaled down version of printf(3).

  *
  *

- * Used to print diagnostic information directly on the console tty.  Since
- * it is not interrupt driven, all system activities are suspended.  Printf
- * should not be used for chit-chat.
+ * One additional format:

  *
  *

- * One additional format: %b is supported to decode error registers.
+ * The format %b is supported to decode error registers.

  * Its usage is:
  *
  *     printf("reg=%b\n", regval, "<base><arg>*");
  * Its usage is:
  *
  *     printf("reg=%b\n", regval, "<base><arg>*");


@@ -34,35 +56,34 @@
  *     reg=3<BITTWO,BITONE>
  */
 
  *     reg=3<BITTWO,BITONE>
  */
 

-#if __STDC__
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
+#include <sys/cdefs.h>
+#include <sys/types.h>

 
 

-static void abort(){}                          /* Needed by stdarg macros. */
-static void number();
+/*
+ * Note that stdarg.h and the ANSI style va_start macro is used for both
+ * ANSI and traditional C compilers.
+ */
+#define KERNEL
+#include <machine/stdarg.h>
+#undef KERNEL
+
+static void kprintn __P((u_long, int));

 
 void
 #if __STDC__
 printf(const char *fmt, ...)
 #else
 
 void
 #if __STDC__
 printf(const char *fmt, ...)
 #else

-printf(fmt, va_alist)
+printf(fmt /* , va_alist */)

        char *fmt;
        char *fmt;

-        va_dcl

 #endif
 {
        register char *p;
        register int ch, n;
 #endif
 {
        register char *p;
        register int ch, n;

-       unsigned long _ulong;
+       unsigned long ul;

        int lflag, set;
        int lflag, set;

-

        va_list ap;
        va_list ap;

-#if __STDC__
+

        va_start(ap, fmt);
        va_start(ap, fmt);

-#else
-       va_start(ap);
-#endif

        for (;;) {
                while ((ch = *fmt++) != '%') {
                        if (ch == '\0')
        for (;;) {
                while ((ch = *fmt++) != '%') {
                        if (ch == '\0')


@@ -75,15 +96,15 @@ reswitch:   switch (ch = *fmt++) {
                        lflag = 1;
                        goto reswitch;
                case 'b':
                        lflag = 1;
                        goto reswitch;
                case 'b':

-                       _ulong = va_arg(ap, int);
+                       ul = va_arg(ap, int);

                        p = va_arg(ap, char *);
                        p = va_arg(ap, char *);

-                       number(_ulong, *p++);
+                       kprintn(ul, *p++);

 
 

-                       if (!_ulong)
+                       if (!ul)

                                break;
 
                        for (set = 0; n = *p++;) {
                                break;
 
                        for (set = 0; n = *p++;) {

-                               if (_ulong & (1 << (n - 1))) {
+                               if (ul & (1 << (n - 1))) {

                                        putchar(set ? ',' : '<');
                                        for (; (n = *p) > ' '; ++p)
                                                putchar(n);
                                        putchar(set ? ',' : '<');
                                        for (; (n = *p) > ' '; ++p)
                                                putchar(n);


@@ -104,28 +125,28 @@ reswitch: switch (ch = *fmt++) {
                                putchar(ch);
                        break;
                case 'd':
                                putchar(ch);
                        break;
                case 'd':

-                       _ulong = lflag ?
+                       ul = lflag ?

                            va_arg(ap, long) : va_arg(ap, int);
                            va_arg(ap, long) : va_arg(ap, int);

-                       if ((long)_ulong < 0) {
+                       if ((long)ul < 0) {

                                putchar('-');
                                putchar('-');

-                               _ulong = -_ulong;
+                               ul = -(long)ul;

                        }
                        }

-                       number(_ulong, 10);
+                       kprintn(ul, 10);

                        break;
                case 'o':
                        break;
                case 'o':

-                       _ulong = lflag ?
-                           va_arg(ap, long) : va_arg(ap, unsigned int);
-                       number(_ulong, 8);
+                       ul = lflag ?
+                           va_arg(ap, u_long) : va_arg(ap, u_int);
+                       kprintn(ul, 8);

                        break;
                case 'u':
                        break;
                case 'u':

-                       _ulong = lflag ?
-                           va_arg(ap, long) : va_arg(ap, unsigned int);
-                       number(_ulong, 10);
+                       ul = lflag ?
+                           va_arg(ap, u_long) : va_arg(ap, u_int);
+                       kprintn(ul, 10);

                        break;
                case 'x':
                        break;
                case 'x':

-                       _ulong = lflag ?
-                           va_arg(ap, long) : va_arg(ap, unsigned int);
-                       number(_ulong, 16);
+                       ul = lflag ?
+                           va_arg(ap, u_long) : va_arg(ap, u_int);
+                       kprintn(ul, 16);

                        break;
                default:
                        putchar('%');
                        break;
                default:
                        putchar('%');


@@ -138,16 +159,17 @@ reswitch: switch (ch = *fmt++) {
 }
 
 static void
 }
 
 static void

-number(_ulong, base)
-       unsigned long _ulong;
+kprintn(ul, base)
+       unsigned long ul;

        int base;
 {
        int base;
 {

-       char *p, buf[11];                       /* hold 2^32 in base 8 */
+                                       /* hold a long in base 8 */
+       char *p, buf[(sizeof(long) * NBBY / 3) + 1];

 
        p = buf;
        do {
 
        p = buf;
        do {

-               *p++ = "0123456789abcdef"[_ulong % base];
-       } while (_ulong /= base);
+               *p++ = "0123456789abcdef"[ul % base];
+       } while (ul /= base);

        do {
                putchar(*--p);
        } while (p > buf);
        do {
                putchar(*--p);
        } while (p > buf);