tests/lib.c

   1 /*
   2  * Regression tests for KQEMU
   3  * (c) 2005-2007 Fabrice Bellard
   4  */
   5
   6 void put_string(const char *s)
   7 {
   8     while (*s)
   9         putchar(*s++);
  10 }
  11
  12 void put_int(unsigned int v)
  13 {
  14     static const char hexchars[] = "0123456789abcdef";
  15     putchar(hexchars[(v >> 28) & 0xf]);
  16     putchar(hexchars[(v >> 24) & 0xf]);
  17     putchar(hexchars[(v >> 20) & 0xf]);
  18     putchar(hexchars[(v >> 16) & 0xf]);
  19     putchar(hexchars[(v >> 12) & 0xf]);
  20     putchar(hexchars[(v >> 8) & 0xf]);
  21     putchar(hexchars[(v >> 4) & 0xf]);
  22     putchar(hexchars[(v >> 0) & 0xf]);
  23 }
  24
  25 void *memset(void *d1, int val, size_t len)
  26 {
  27     uint8_t *d = d1;
  28
  29     while (len--) {
  30         *d++ = val;
  31     }
  32     return d1;
  33 }
  34
  35 void *memcpy(void *d1, const void *s1, size_t len)
  36 {
  37     uint8_t *d = d1;
  38     const uint8_t *s = s1;
  39
  40     while (len--) {
  41         *d++ = *s++;
  42     }
  43     return d1;
  44 }
  45
  46 void *memmove(void *d1, const void *s1, size_t len)
  47 {
  48     uint8_t *d = d1;
  49     const uint8_t *s = s1;
  50
  51     if (d <= s) {
  52         while (len--) {
  53             *d++ = *s++;
  54         }
  55     } else {
  56         d += len;
  57         s += len;
  58         while (len--) {
  59             *--d = *--s;
  60         }
  61     }
  62     return d1;
  63 }
  64
  65 size_t strlen(const char *s)
  66 {
  67     const char *s1;
  68     for(s1 = s; *s1 != '\0'; s1++);
  69     return s1 - s;
  70 }
  71
  72 static inline int mon_isdigit(int c)
  73 {
  74     return c >= '0' && c <= '9';
  75 }
  76
  77 #define OUTCHAR(c)      (buflen > 0? (--buflen, *buf++ = (c)): 0)
  78
  79 /* from BSD ppp sources */
  80 int vsnprintf(char *buf, int buflen, const char *fmt, va_list args)
  81 {
  82     int c, n;
  83     int width, prec, fillch;
  84     int base, len, neg, is_long;
  85     unsigned long val = 0;
  86     const char *f;
  87     char *str, *buf0;
  88     char num[32];
  89     static const char hexchars[] = "0123456789abcdef";
  90
  91     buf0 = buf;
  92     --buflen;
  93     while (buflen > 0) {
  94         for (f = fmt; *f != '%' && *f != 0; ++f)
  95             ;
  96         if (f > fmt) {
  97             len = f - fmt;
  98             if (len > buflen)
  99                 len = buflen;
 100             memcpy(buf, fmt, len);
 101             buf += len;
 102             buflen -= len;
 103             fmt = f;
 104         }
 105         if (*fmt == 0)
 106             break;
 107         c = *++fmt;
 108         width = prec = 0;
 109         fillch = ' ';
 110         if (c == '0') {
 111             fillch = '0';
 112             c = *++fmt;
 113         }
 114         if (c == '*') {
 115             width = va_arg(args, int);
 116             c = *++fmt;
 117         } else {
 118             while (mon_isdigit(c)) {
 119                 width = width * 10 + c - '0';
 120                 c = *++fmt;
 121             }
 122         }
 123         if (c == '.') {
 124             c = *++fmt;
 125             if (c == '*') {
 126                 prec = va_arg(args, int);
 127                 c = *++fmt;
 128             } else {
 129                 while (mon_isdigit(c)) {
 130                     prec = prec * 10 + c - '0';
 131                     c = *++fmt;
 132                 }
 133             }
 134         }
 135         /* modifiers */
 136         is_long = 0;
 137         switch(c) {
 138         case 'l':
 139             is_long = 1;
 140             c = *++fmt;
 141             break;
 142         default:
 143             break;
 144         }
 145         str = 0;
 146         base = 0;
 147         neg = 0;
 148         ++fmt;
 149         switch (c) {
 150         case 'd':
 151             if (is_long)
 152                 val = va_arg(args, long);
 153             else
 154                 val = va_arg(args, int);
 155             if ((long)val < 0) {
 156                 neg = 1;
 157                 val = -val;
 158             }
 159             base = 10;
 160             break;
 161         case 'o':
 162             if (is_long)
 163                 val = va_arg(args, unsigned long);
 164             else
 165                 val = va_arg(args, unsigned int);
 166             base = 8;
 167             break;
 168         case 'x':
 169         case 'X':
 170             if (is_long)
 171                 val = va_arg(args, unsigned long);
 172             else
 173                 val = va_arg(args, unsigned int);
 174             base = 16;
 175             break;
 176         case 'p':
 177             val = (unsigned long) va_arg(args, void *);
 178             base = 16;
 179             neg = 2;
 180             break;
 181         case 's':
 182             str = va_arg(args, char *);
 183             break;
 184         case 'c':
 185             num[0] = va_arg(args, int);
 186             num[1] = 0;
 187             str = num;
 188             break;
 189         default:
 190             *buf++ = '%';
 191             if (c != '%')
 192                 --fmt;          /* so %z outputs %z etc. */
 193             --buflen;
 194             continue;
 195         }
 196         if (base != 0) {
 197             str = num + sizeof(num);
 198             *--str = 0;
 199             while (str > num + neg) {
 200                 *--str = hexchars[val % base];
 201                 val = val / base;
 202                 if (--prec <= 0 && val == 0)
 203                     break;
 204             }
 205             switch (neg) {
 206             case 1:
 207                 *--str = '-';
 208                 break;
 209             case 2:
 210                 *--str = 'x';
 211                 *--str = '0';
 212                 break;
 213             }
 214             len = num + sizeof(num) - 1 - str;
 215         } else {
 216             len = strlen(str);
 217             if (prec > 0 && len > prec)
 218                 len = prec;
 219         }
 220         if (width > 0) {
 221             if (width > buflen)
 222                 width = buflen;
 223             if ((n = width - len) > 0) {
 224                 buflen -= n;
 225                 for (; n > 0; --n)
 226                     *buf++ = fillch;
 227             }
 228         }
 229         if (len > buflen)
 230             len = buflen;
 231         memcpy(buf, str, len);
 232         buf += len;
 233         buflen -= len;
 234     }
 235     *buf = 0;
 236     return buf - buf0;
 237 }
 238
 239 void __attribute((format (printf, 1, 2))) printf(const char *fmt, ...)
 240 {
 241     char buf[1024];
 242     va_list ap;
 243     va_start(ap, fmt);
 244     vsnprintf(buf, sizeof(buf), fmt, ap);
 245     put_string(buf);
 246     va_end(ap);
 247 }
 248