compiler/arossupport/kprintf.c

   1 /*
   2     Copyright © 1995-2001, 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 <proto/exec.h>
  16 #include <proto/arossupport.h>
  17 #undef kprintf
  18 #undef vkprintf
  19 #include <unistd.h>
  20 #include <exec/execbase.h>
  21
  22 #define AROSBase        ((struct AROSBase *)(SysBase->DebugData))
  23
  24 /* Can't use ctypt.h *sigh* */
  25 #define isdigit(x)      ((x) >= '0' && (x) <= '9')
  26 #define isprint(x)      (((x) >= ' ' && (x) <= 128) || (x) >= 160)
  27
  28 /*****************************************************************************
  29
  30     NAME */
  31         #include <proto/arossupport.h>
  32
  33         int kprintf (
  34
  35 /*  SYNOPSIS */
  36         const UBYTE * fmt,
  37         ...)
  38
  39 /*  FUNCTION
  40         Formats fmt with the specified arguments like printf() (and *not*
  41         like RawDoFmt()) and uses a secure way to deliver the message to
  42         the user; ie. the user *will* see this message no matter what.
  43
  44     INPUTS
  45         fmt - printf()-style format string
  46
  47     RESULT
  48         The number of characters output.
  49
  50     NOTES
  51         This function is not part of a library and may thus be called
  52         any time.
  53
  54     EXAMPLE
  55
  56     BUGS
  57
  58     SEE ALSO
  59
  60     INTERNALS
  61
  62     HISTORY
  63         24-12-95    digulla created
  64
  65 ******************************************************************************/
  66 {
  67     va_list      ap;
  68     int          result;
  69
  70     va_start (ap, fmt);
  71     result = vkprintf (fmt, ap);
  72     va_end (ap);
  73
  74     return result;
  75 } /* kprintf */
  76
  77
  78
  79 int vkprintf (const UBYTE * fmt, va_list args)
  80 {
  81     AROS_GET_SYSBASE_OK
  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 's':
 150             case 'S': {
 151                 char * str = va_arg (args, char *);
 152                 int len;
 153
 154                 if (!str)
 155                     str = "(null)";
 156
 157                 if (*fmt == 'S')
 158                 {
 159                     RawPutChar ('"');
 160                     ret ++;
 161                 }
 162
 163                 if (precision)
 164                     len = precision;
 165                 else
 166                     len = strlen (str);
 167
 168                 RawPutChars (str, len);
 169                 ret += len;
 170
 171                 if (*fmt == 'S')
 172                 {
 173                     RawPutChar ('"');
 174                     ret ++;
 175                 }
 176
 177                 break; }
 178
 179             case 'p': {
 180                 int t;
 181                 char puffer[sizeof (void *)*2];
 182                 ULONG val;
 183
 184                 t = sizeof (void *)*2;
 185                 val = va_arg (args, ULONG);
 186
 187                 while (t)
 188                 {
 189                     puffer[--t] = lhex[val & 0x0F];
 190                     val >>= 4;
 191                 }
 192
 193                 RawPutChars (puffer, sizeof (void *)*2);
 194
 195                 break; }
 196
 197             case 'c': {
 198                 UBYTE c;
 199
 200                 c = va_arg (args, int);
 201
 202                 if (isprint (c))
 203                     RawPutChar (c);
 204                 else
 205                 {
 206                     RawPutChars ("'\\0x", 4);
 207                     RawPutChar (lhex[c / 16]);
 208                     RawPutChar (lhex[c & 15]);
 209                     RawPutChar ('\'');
 210                 }
 211
 212                 break; }
 213
 214             case 'l': {
 215                 int t;
 216                 char puffer[32];
 217
 218                 if (fmt[1] == 'u' || fmt[1] == 'd' || fmt[1] == 'x' || fmt[1] == 'X')
 219                     fmt ++;
 220
 221                 if (*fmt == 'd')
 222                 {
 223                     lval = va_arg (args, LONG);
 224
 225                     val = (lval < 0) ? -lval : lval;
 226                 }
 227                 else
 228                 {
 229                     val = va_arg (args, ULONG);
 230                 }
 231
 232 print_int:
 233                 if (val==0)
 234                 {
 235                     if (width == 0)
 236                         width = 1;
 237
 238                     if (*fill == ' ')
 239                         width --;
 240
 241                     while (width > 0)
 242                     {
 243                         RawPutChars (fill, (width < 8) ? width : 8);
 244                         width -= 8;
 245                     }
 246
 247                     if (*fill == ' ')
 248                         RawPutChar ('0');
 249
 250                     ret ++;
 251                     break;
 252                 }
 253
 254                 t = 32;
 255
 256                 if (*fmt == 'd' || *fmt == 'u')
 257                 {
 258                     if (*fmt == 'd')
 259                     {
 260                         if (lval < 0)
 261                         {
 262                             RawPutChar ('-');
 263                             ret ++;
 264                             val = -lval;
 265                         }
 266                         else
 267                             val = lval;
 268                     }
 269
 270                     while (val && t)
 271                     {
 272                         puffer[--t] = lhex[val % 10];
 273
 274                         val /= 10;
 275                     }
 276                 }
 277                 else if (*fmt == 'x')
 278                 {
 279                     while (val && t)
 280                     {
 281                         puffer[--t] = lhex[val & 0x0F];
 282
 283                         val >>= 4;
 284                     }
 285                 }
 286                 else
 287                 {
 288                     while (val && t)
 289                     {
 290                         puffer[--t] = uhex[val & 0x0F];
 291
 292                         val >>= 4;
 293                     }
 294                 }
 295
 296                 width -= 32-t;
 297
 298                 while (width > 0)
 299                 {
 300                     RawPutChars (fill, (width < 8) ? width : 8);
 301                     width -= 8;
 302                 }
 303
 304                 RawPutChars (&puffer[t], 32-t);
 305                 ret += 32-t;
 306
 307                 break; }
 308
 309             default: {
 310                 if (*fmt == 'd')
 311                 {
 312                     lval = va_arg (args, int);
 313
 314                     val = (lval < 0) ? -lval : lval;
 315                 }
 316                 else
 317                 {
 318                     val = va_arg (args, unsigned int);
 319                 }
 320
 321                 goto print_int;
 322
 323                 break; }
 324             } /* switch */
 325         }
 326         else
 327         {
 328             RawPutChar (*fmt);
 329             ret ++;
 330         }
 331
 332         fmt ++; /* Next char */
 333     } /* while (*fmt); */
 334
 335     return ret;
 336 } /* vkprintf */
 337