compiler/arossupport/kprintf.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Formats a message and makes sure the user will see it.
   6     Lang: english
   7 */
   8
   9 #include <aros/config.h>
  10 #include <aros/arossupportbase.h>
  11 #include <stdarg.h>
  12
  13 #include <aros/system.h>
  14 #include <dos/bptr.h>
  15 #include <proto/exec.h>
  16 #include <proto/arossupport.h>
  17 #undef kprintf
  18 #undef vkprintf
  19 #include <exec/execbase.h>
  20
  21 /* Can't use ctype.h *sigh* */
  22 #define isdigit(x)      ((x) >= '0' && (x) <= '9')
  23 #define isprint(x)      (((x) >= ' ' && (x) <= 128) || (x) >= 160)
  24
  25 /* Nor string.h */
  26 static inline int my_strlen(const char *c)
  27 {
  28     int i = 0;
  29     while (*(c++)) i++;
  30     return i;
  31 }
  32
  33 /* Nor atoi */
  34 static inline int atoi(const char *c)
  35 {
  36     int i;
  37     int isneg = 0;
  38
  39     if (*c == '+')
  40         c++;
  41
  42     if (*c == '-') {
  43         isneg = 1;
  44         c++;
  45     }
  46
  47     for (i = 0; *c && isdigit(*c); c++) {
  48         i *= 10;
  49         i += *c - '0';
  50     }
  51
  52     return (isneg) ? -i : i;
  53 }
  54
  55 /*****************************************************************************
  56
  57     NAME */
  58         #include <proto/arossupport.h>
  59
  60         int kprintf (
  61
  62 /*  SYNOPSIS */
  63         const char * fmt,
  64         ...)
  65
  66 /*  FUNCTION
  67         Formats fmt with the specified arguments like printf() (and *not*
  68         like RawDoFmt()) and uses a secure way to deliver the message to
  69         the user; ie. the user *will* see this message no matter what.
  70
  71     INPUTS
  72         fmt - printf()-style format string
  73
  74     RESULT
  75         The number of characters output.
  76
  77     NOTES
  78         This function is not part of a library and may thus be called
  79         any time.
  80
  81     EXAMPLE
  82
  83     BUGS
  84
  85     SEE ALSO
  86
  87     INTERNALS
  88
  89     HISTORY
  90         24-12-95    digulla created
  91
  92 ******************************************************************************/
  93 {
  94     va_list      ap;
  95     int          result;
  96
  97     va_start (ap, fmt);
  98     result = vkprintf (fmt, ap);
  99     va_end (ap);
 100
 101     return result;
 102 } /* kprintf */
 103
 104
 105
 106 int vkprintf (const char * fmt, va_list args)
 107 {
 108     int          ret;
 109     static const char uhex[] = "0123456789ABCDEF";
 110     static const char lhex[] = "0123456789abcdef";
 111     char       * fill;
 112     unsigned long val;
 113     long         lval = 0;
 114
 115     if (!fmt)
 116     {
 117         RawPutChars ("(null)", 6);
 118         return 6;
 119     }
 120
 121     ret = 0;
 122
 123     while (*fmt)
 124     {
 125         if (*fmt == '%')
 126         {
 127             int width = 0;
 128             int precision = 0;
 129
 130             fmt ++;
 131
 132             if (*fmt == '0')
 133             {
 134                 fill = "00000000";
 135                 fmt ++;
 136             }
 137             else
 138             {
 139                 fill = "        ";
 140             }
 141
 142             if (*fmt == '*')
 143             {
 144                 width = va_arg (args, int);
 145                 fmt++;
 146             }
 147             else
 148             if (isdigit (*fmt))
 149             {
 150                 width = atoi (fmt);
 151                 while (isdigit(*fmt)) fmt++;
 152             }
 153
 154             if (*fmt == '.') fmt++;
 155
 156             if (*fmt == '*')
 157             {
 158                 precision = va_arg (args, int);
 159                 fmt++;
 160             }
 161             else
 162             if (isdigit (*fmt))
 163                 precision = atoi (fmt);
 164
 165             while (isdigit(*fmt) || *fmt=='.' || *fmt=='-' || *fmt=='+')
 166                 fmt ++;
 167
 168             switch (*fmt)
 169             {
 170             case '%':
 171                 RawPutChar (*fmt);
 172                 ret ++;
 173                 break;
 174
 175             case 'b':
 176 #ifndef AROS_FAST_BPTR
 177             {
 178                 char * str = va_arg (args, char *);
 179                 int len;
 180
 181                 if (str) {
 182                     str = (char *)((unsigned long)str << 2);
 183                     len = *str++;
 184                 } else {
 185                     str = "(null)";
 186                     len = 6;
 187                 }
 188
 189                 if (precision)
 190                     len = precision;
 191
 192                 RawPutChars (str, len);
 193                 ret += len;
 194
 195                 break; }
 196 #endif
 197             case 's':
 198             case 'S': {
 199                 char * str = va_arg (args, char *);
 200                 int len;
 201
 202                 if (!str)
 203                     str = "(null)";
 204
 205                 if (*fmt == 'S')
 206                 {
 207                     RawPutChar ('"');
 208                     ret ++;
 209                 }
 210
 211                 if (precision)
 212                     len = precision;
 213                 else
 214                     len = my_strlen (str);
 215
 216                 RawPutChars (str, len);
 217                 ret += len;
 218
 219                 if (*fmt == 'S')
 220                 {
 221                     RawPutChar ('"');
 222                     ret ++;
 223                 }
 224
 225                 break; }
 226
 227             case 'p': {
 228                 int t;
 229                 char puffer[sizeof (void *)*2];
 230
 231                 t = sizeof (void *)*2;
 232                 val = va_arg (args, IPTR);
 233
 234                 while (t)
 235                 {
 236                     puffer[--t] = lhex[val & 0x0F];
 237                     val >>= 4;
 238                 }
 239
 240                 RawPutChars (puffer, sizeof (void *)*2);
 241
 242                 break; }
 243
 244             case 'c': {
 245                 UBYTE c;
 246
 247                 c = va_arg (args, int);
 248
 249                 if (isprint (c))
 250                     RawPutChar (c);
 251                 else
 252                 {
 253                     RawPutChars ("'\\0x", 4);
 254                     RawPutChar (lhex[c / 16]);
 255                     RawPutChar (lhex[c & 15]);
 256                     RawPutChar ('\'');
 257                 }
 258
 259                 break; }
 260
 261             case 'l': {
 262                 int t;
 263                 char puffer[32];
 264
 265                 if (fmt[1] == 'u' || fmt[1] == 'd' || fmt[1] == 'x' || fmt[1] == 'X')
 266                     fmt ++;
 267
 268                 if (*fmt == 'd')
 269                 {
 270                     lval = va_arg (args, long);
 271
 272                     val = (lval < 0) ? -lval : lval;
 273                 }
 274                 else
 275                 {
 276                     val = va_arg (args, unsigned long);
 277                 }
 278
 279 print_int:
 280                 if (val==0)
 281                 {
 282                     if (width == 0)
 283                         width = 1;
 284
 285                     if (*fill == ' ')
 286                         width --;
 287
 288                     while (width > 0)
 289                     {
 290                         RawPutChars (fill, (width < 8) ? width : 8);
 291                         width -= 8;
 292                     }
 293
 294                     if (*fill == ' ')
 295                         RawPutChar ('0');
 296
 297                     ret ++;
 298                     break;
 299                 }
 300
 301                 t = 32;
 302
 303                 if (*fmt == 'd' || *fmt == 'u')
 304                 {
 305                     if (*fmt == 'd')
 306                     {
 307                         if (lval < 0)
 308                         {
 309                             RawPutChar ('-');
 310                             ret ++;
 311                             val = -lval;
 312                         }
 313                         else
 314                             val = lval;
 315                     }
 316
 317                     while (val && t)
 318                     {
 319                         puffer[--t] = lhex[val % 10];
 320
 321                         val /= 10;
 322                     }
 323                 }
 324                 else if (*fmt == 'x')
 325                 {
 326                     while (val && t)
 327                     {
 328                         puffer[--t] = lhex[val & 0x0F];
 329
 330                         val >>= 4;
 331                     }
 332                 }
 333                 else
 334                 {
 335                     while (val && t)
 336                     {
 337                         puffer[--t] = uhex[val & 0x0F];
 338
 339                         val >>= 4;
 340                     }
 341                 }
 342
 343                 width -= 32-t;
 344
 345                 while (width > 0)
 346                 {
 347                     RawPutChars (fill, (width < 8) ? width : 8);
 348                     width -= 8;
 349                 }
 350
 351                 RawPutChars (&puffer[t], 32-t);
 352                 ret += 32-t;
 353
 354                 break; }
 355
 356             default: {
 357                 if (*fmt == 'd')
 358                 {
 359                     lval = va_arg (args, int);
 360
 361                     val = (lval < 0) ? -lval : lval;
 362                 }
 363                 else
 364                 {
 365                     val = va_arg (args, unsigned int);
 366                 }
 367
 368                 goto print_int;
 369
 370                 break; }
 371             } /* switch */
 372         }
 373         else
 374         {
 375             RawPutChar (*fmt);
 376             ret ++;
 377         }
 378
 379         fmt ++; /* Next char */
 380     } /* while (*fmt); */
 381
 382     return ret;
 383 } /* vkprintf */
 384