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