compiler/arossupport/kprintf.c

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