sys/lib/libsa/subr_prf.c

   1 /*      $NetBSD: subr_prf.c,v 1.21 2011/07/17 20:54:52 joerg Exp $      */
   2
   3 /*-
   4  * Copyright (c) 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)printf.c    8.1 (Berkeley) 6/11/93
  32  */
  33
  34 /*
  35  * Scaled down version of printf(3).
  36  */
  37
  38 #include <sys/cdefs.h>
  39 #include <sys/types.h>
  40 #include <sys/stdint.h>         /* XXX: for intptr_t */
  41
  42 #include "stand.h"
  43
  44 #ifdef LIBSA_PRINTF_LONGLONG_SUPPORT
  45 #define INTMAX_T        longlong_t
  46 #define UINTMAX_T       u_longlong_t
  47 #else
  48 #define INTMAX_T        long
  49 #define UINTMAX_T       u_long
  50 #endif
  51
  52 #if 0 /* XXX: abuse intptr_t until the situation with ptrdiff_t is clear */
  53 #define PTRDIFF_T       ptrdiff_t
  54 #else
  55 #define PTRDIFF_T       intptr_t
  56 #endif
  57
  58 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
  59 static void kprintn(void (*)(int), UINTMAX_T, int, int, int);
  60 #else
  61 static void kprintn(void (*)(int), UINTMAX_T, int);
  62 #endif
  63 static void sputchar(int);
  64 static void kdoprnt(void (*)(int), const char *, va_list);
  65
  66 static char *sbuf, *ebuf;
  67
  68 const char hexdigits[16] = "0123456789abcdef";
  69
  70 #define LONG            0x01
  71 #ifdef LIBSA_PRINTF_LONGLONG_SUPPORT
  72 #define LLONG           0x02
  73 #endif
  74 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
  75 #define ALT             0x04
  76 #define SPACE           0x08
  77 #define LADJUST         0x10
  78 #define SIGN            0x20
  79 #define ZEROPAD         0x40
  80 #define NEGATIVE        0x80
  81 #define KPRINTN(base)   kprintn(put, ul, base, lflag, width)
  82 #define RZERO()                                                 \
  83 do {                                                            \
  84         if ((lflag & (ZEROPAD|LADJUST)) == ZEROPAD) {           \
  85                 while (width-- > 0)                             \
  86                         put('0');                               \
  87         }                                                       \
  88 } while (/*CONSTCOND*/0)
  89 #define RPAD()                                                  \
  90 do {                                                            \
  91         if (lflag & LADJUST) {                                  \
  92                 while (width-- > 0)                             \
  93                         put(' ');                               \
  94         }                                                       \
  95 } while (/*CONSTCOND*/0)
  96 #define LPAD()                                                  \
  97 do {                                                            \
  98         if ((lflag & (ZEROPAD|LADJUST)) == 0) {                 \
  99                 while (width-- > 0)                             \
 100                         put(' ');                               \
 101         }                                                       \
 102 } while (/*CONSTCOND*/0)
 103 #else   /* LIBSA_PRINTF_WIDTH_SUPPORT */
 104 #define KPRINTN(base)   kprintn(put, ul, base)
 105 #define RZERO()         /**/
 106 #define RPAD()          /**/
 107 #define LPAD()          /**/
 108 #endif  /* LIBSA_PRINTF_WIDTH_SUPPORT */
 109
 110 #ifdef LIBSA_PRINTF_LONGLONG_SUPPORT
 111 #define KPRINT(base)                                            \
 112 do {                                                            \
 113         ul = (lflag & LLONG)                                    \
 114             ? va_arg(ap, u_longlong_t)                          \
 115             : (lflag & LONG)                                    \
 116                 ? va_arg(ap, u_long)                            \
 117                 : va_arg(ap, u_int);                            \
 118         KPRINTN(base);                                          \
 119 } while (/*CONSTCOND*/0)
 120 #else   /* LIBSA_PRINTF_LONGLONG_SUPPORT */
 121 #define KPRINT(base)                                            \
 122 do {                                                            \
 123         ul = (lflag & LONG)                                     \
 124             ? va_arg(ap, u_long) : va_arg(ap, u_int);           \
 125         KPRINTN(base);                                          \
 126 } while (/*CONSTCOND*/0)
 127 #endif  /* LIBSA_PRINTF_LONGLONG_SUPPORT */
 128
 129 static void
 130 sputchar(int c)
 131 {
 132
 133         if (sbuf < ebuf)
 134                 *sbuf++ = c;
 135 }
 136
 137 void
 138 vprintf(const char *fmt, va_list ap)
 139 {
 140
 141         kdoprnt(putchar, fmt, ap);
 142 }
 143
 144 int
 145 vsnprintf(char *buf, size_t size, const char *fmt, va_list ap)
 146 {
 147
 148         sbuf = buf;
 149         ebuf = buf + size - 1;
 150         kdoprnt(sputchar, fmt, ap);
 151         *sbuf = '\0';
 152         return sbuf - buf;
 153 }
 154
 155 static void
 156 kdoprnt(void (*put)(int), const char *fmt, va_list ap)
 157 {
 158         char *p;
 159         int ch;
 160         UINTMAX_T ul;
 161         int lflag;
 162 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 163         int width;
 164         char *q;
 165 #endif
 166
 167         for (;;) {
 168                 while ((ch = *fmt++) != '%') {
 169                         if (ch == '\0')
 170                                 return;
 171                         put(ch);
 172                 }
 173                 lflag = 0;
 174 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 175                 width = 0;
 176 #endif
 177 reswitch:
 178                 switch (ch = *fmt++) {
 179 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 180                 case '#':
 181                         lflag |= ALT;
 182                         goto reswitch;
 183                 case ' ':
 184                         lflag |= SPACE;
 185                         goto reswitch;
 186                 case '-':
 187                         lflag |= LADJUST;
 188                         goto reswitch;
 189                 case '+':
 190                         lflag |= SIGN;
 191                         goto reswitch;
 192                 case '0':
 193                         lflag |= ZEROPAD;
 194                         goto reswitch;
 195                 case '1': case '2': case '3': case '4': case '5':
 196                 case '6': case '7': case '8': case '9':
 197                         for (;;) {
 198                                 width *= 10;
 199                                 width += ch - '0';
 200                                 ch = *fmt;
 201                                 if ((unsigned)ch - '0' > 9)
 202                                         break;
 203                                 ++fmt;
 204                         }
 205 #endif
 206                         goto reswitch;
 207                 case 'l':
 208 #ifdef LIBSA_PRINTF_LONGLONG_SUPPORT
 209                         if (*fmt == 'l') {
 210                                 ++fmt;
 211                                 lflag |= LLONG;
 212                         } else
 213 #endif
 214                                 lflag |= LONG;
 215                         goto reswitch;
 216                 case 't':
 217                         if (sizeof(PTRDIFF_T) == sizeof(long))
 218                                 lflag |= LONG;
 219                         goto reswitch;
 220                 case 'z':
 221                         if (sizeof(ssize_t) == sizeof(long))
 222                                 lflag |= LONG;
 223                         goto reswitch;
 224                 case 'c':
 225                         ch = va_arg(ap, int);
 226 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 227                         --width;
 228 #endif
 229                         RPAD();
 230                         put(ch & 0xFF);
 231                         LPAD();
 232                         break;
 233                 case 's':
 234                         p = va_arg(ap, char *);
 235 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 236                         for (q = p; *q != '\0'; ++q)
 237                                 continue;
 238                         width -= q - p;
 239 #endif
 240                         RPAD();
 241                         while ((ch = (unsigned char)*p++))
 242                                 put(ch);
 243                         LPAD();
 244                         break;
 245                 case 'd':
 246                         ul =
 247 #ifdef LIBSA_PRINTF_LONGLONG_SUPPORT
 248                         (lflag & LLONG) ? va_arg(ap, longlong_t) :
 249 #endif
 250                         (lflag & LONG) ? va_arg(ap, long) : va_arg(ap, int);
 251                         if ((INTMAX_T)ul < 0) {
 252                                 ul = -(INTMAX_T)ul;
 253 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 254                                 lflag |= NEGATIVE;
 255 #else
 256                                 put('-');
 257 #endif
 258                         }
 259                         KPRINTN(10);
 260                         break;
 261                 case 'o':
 262                         KPRINT(8);
 263                         break;
 264                 case 'u':
 265                         KPRINT(10);
 266                         break;
 267                 case 'p':
 268 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 269                         lflag |= (LONG|ALT);
 270 #else
 271                         put('0');
 272                         put('x');
 273 #endif
 274                         /* FALLTHROUGH */
 275                 case 'x':
 276                         KPRINT(16);
 277                         break;
 278                 default:
 279                         if (ch == '\0')
 280                                 return;
 281                         put(ch);
 282                         break;
 283                 }
 284         }
 285 }
 286
 287 static void
 288 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 289 kprintn(void (*put)(int), UINTMAX_T ul, int base, int lflag, int width)
 290 #else
 291 kprintn(void (*put)(int), UINTMAX_T ul, int base)
 292 #endif
 293 {
 294                                         /* hold a INTMAX_T in base 8 */
 295         char *p, buf[(sizeof(INTMAX_T) * NBBY / 3) + 1 + 2 /* ALT + SIGN */];
 296 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 297         char *q;
 298 #endif
 299
 300         p = buf;
 301         do {
 302                 *p++ = hexdigits[ul % base];
 303         } while (ul /= base);
 304 #ifdef LIBSA_PRINTF_WIDTH_SUPPORT
 305         q = p;
 306         if (lflag & ALT && *(p - 1) != '0') {
 307                 if (base == 8) {
 308                         *p++ = '0';
 309                 } else if (base == 16) {
 310                         *p++ = 'x';
 311                         *p++ = '0';
 312                 }
 313         }
 314         if (lflag & NEGATIVE)
 315                 *p++ = '-';
 316         else if (lflag & SIGN)
 317                 *p++ = '+';
 318         else if (lflag & SPACE)
 319                 *p++ = ' ';
 320         width -= p - buf;
 321         if ((lflag & LADJUST) == 0) {
 322                 while (p > q)
 323                         put(*--p);
 324         }
 325 #endif
 326         RPAD();
 327         RZERO();
 328         do {
 329                 put(*--p);
 330         } while (p > buf);
 331         LPAD();
 332 }