arch/all-pc/boot/grub2-aros/grub-core/kern/misc.c

   1 /* misc.c - definitions of misc functions */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/misc.h>
  21 #include <grub/err.h>
  22 #include <grub/mm.h>
  23 #include <stdarg.h>
  24 #include <grub/term.h>
  25 #include <grub/env.h>
  26 #include <grub/i18n.h>
  27
  28 union printf_arg
  29 {
  30   /* Yes, type is also part of union as the moment we fill the value
  31      we don't need to store its type anymore (when we'll need it, we'll
  32      have format spec again. So save some space.  */
  33   enum
  34     {
  35       INT, LONG, LONGLONG,
  36       UNSIGNED_INT = 3, UNSIGNED_LONG, UNSIGNED_LONGLONG
  37     } type;
  38   long long ll;
  39 };
  40
  41 struct printf_args
  42 {
  43   union printf_arg prealloc[32];
  44   union printf_arg *ptr;
  45   grub_size_t count;
  46 };
  47
  48 static void
  49 parse_printf_args (const char *fmt0, struct printf_args *args,
  50                    va_list args_in);
  51 static int
  52 grub_vsnprintf_real (char *str, grub_size_t max_len, const char *fmt0,
  53                      struct printf_args *args);
  54
  55 static void
  56 free_printf_args (struct printf_args *args)
  57 {
  58   if (args->ptr != args->prealloc)
  59     grub_free (args->ptr);
  60 }
  61
  62 static int
  63 grub_iswordseparator (int c)
  64 {
  65   return (grub_isspace (c) || c == ',' || c == ';' || c == '|' || c == '&');
  66 }
  67
  68 /* grub_gettext_dummy is not translating anything.  */
  69 static const char *
  70 grub_gettext_dummy (const char *s)
  71 {
  72   return s;
  73 }
  74
  75 const char* (*grub_gettext) (const char *s) = grub_gettext_dummy;
  76
  77 void *
  78 grub_memmove (void *dest, const void *src, grub_size_t n)
  79 {
  80   char *d = (char *) dest;
  81   const char *s = (const char *) src;
  82
  83   if (d < s)
  84     while (n--)
  85       *d++ = *s++;
  86   else
  87     {
  88       d += n;
  89       s += n;
  90
  91       while (n--)
  92         *--d = *--s;
  93     }
  94
  95   return dest;
  96 }
  97
  98 #ifndef __APPLE__
  99 void *memmove (void *dest, const void *src, grub_size_t n)
 100   __attribute__ ((alias ("grub_memmove")));
 101 /* GCC emits references to memcpy() for struct copies etc.  */
 102 void *memcpy (void *dest, const void *src, grub_size_t n)
 103   __attribute__ ((alias ("grub_memmove")));
 104 #else
 105 void * GRUB_BUILTIN_ATTR
 106 memcpy (void *dest, const void *src, grub_size_t n)
 107 {
 108         return grub_memmove (dest, src, n);
 109 }
 110 void * GRUB_BUILTIN_ATTR
 111 memmove (void *dest, const void *src, grub_size_t n)
 112 {
 113         return grub_memmove (dest, src, n);
 114 }
 115 #endif
 116
 117 char *
 118 grub_strcpy (char *dest, const char *src)
 119 {
 120   char *p = dest;
 121
 122   while ((*p++ = *src++) != '\0')
 123     ;
 124
 125   return dest;
 126 }
 127
 128 int
 129 grub_printf (const char *fmt, ...)
 130 {
 131   va_list ap;
 132   int ret;
 133
 134   va_start (ap, fmt);
 135   ret = grub_vprintf (fmt, ap);
 136   va_end (ap);
 137
 138   return ret;
 139 }
 140
 141 int
 142 grub_printf_ (const char *fmt, ...)
 143 {
 144   va_list ap;
 145   int ret;
 146
 147   va_start (ap, fmt);
 148   ret = grub_vprintf (_(fmt), ap);
 149   va_end (ap);
 150
 151   return ret;
 152 }
 153
 154 int
 155 grub_puts_ (const char *s)
 156 {
 157   return grub_puts (_(s));
 158 }
 159
 160 #if defined (__APPLE__) && ! defined (GRUB_UTIL)
 161 int
 162 grub_err_printf (const char *fmt, ...)
 163 {
 164         va_list ap;
 165         int ret;
 166
 167         va_start (ap, fmt);
 168         ret = grub_vprintf (fmt, ap);
 169         va_end (ap);
 170
 171         return ret;
 172 }
 173 #endif
 174
 175 #if ! defined (__APPLE__) && ! defined (GRUB_UTIL)
 176 int grub_err_printf (const char *fmt, ...)
 177 __attribute__ ((alias("grub_printf")));
 178 #endif
 179
 180 void
 181 grub_real_dprintf (const char *file, const int line, const char *condition,
 182                    const char *fmt, ...)
 183 {
 184   va_list args;
 185   const char *debug = grub_env_get ("debug");
 186
 187   if (! debug)
 188     return;
 189
 190   if (grub_strword (debug, "all") || grub_strword (debug, condition))
 191     {
 192       grub_printf ("%s:%d: ", file, line);
 193       va_start (args, fmt);
 194       grub_vprintf (fmt, args);
 195       va_end (args);
 196       grub_refresh ();
 197     }
 198 }
 199
 200 #define PREALLOC_SIZE 255
 201
 202 int
 203 grub_vprintf (const char *fmt, va_list ap)
 204 {
 205   grub_size_t s;
 206   static char buf[PREALLOC_SIZE + 1];
 207   char *curbuf = buf;
 208   struct printf_args args;
 209
 210   parse_printf_args (fmt, &args, ap);
 211
 212   s = grub_vsnprintf_real (buf, PREALLOC_SIZE, fmt, &args);
 213   if (s > PREALLOC_SIZE)
 214     {
 215       curbuf = grub_malloc (s + 1);
 216       if (!curbuf)
 217         {
 218           grub_errno = GRUB_ERR_NONE;
 219           buf[PREALLOC_SIZE - 3] = '.';
 220           buf[PREALLOC_SIZE - 2] = '.';
 221           buf[PREALLOC_SIZE - 1] = '.';
 222           buf[PREALLOC_SIZE] = 0;
 223           curbuf = buf;
 224         }
 225       else
 226         s = grub_vsnprintf_real (curbuf, s, fmt, &args);
 227     }
 228
 229   free_printf_args (&args);
 230
 231   grub_xputs (curbuf);
 232
 233   if (curbuf != buf)
 234     grub_free (curbuf);
 235
 236   return s;
 237 }
 238
 239 int
 240 grub_memcmp (const void *s1, const void *s2, grub_size_t n)
 241 {
 242   const grub_uint8_t *t1 = s1;
 243   const grub_uint8_t *t2 = s2;
 244
 245   while (n--)
 246     {
 247       if (*t1 != *t2)
 248         return (int) *t1 - (int) *t2;
 249
 250       t1++;
 251       t2++;
 252     }
 253
 254   return 0;
 255 }
 256 #ifndef __APPLE__
 257 int memcmp (const void *s1, const void *s2, grub_size_t n)
 258   __attribute__ ((alias ("grub_memcmp")));
 259 #else
 260 int GRUB_BUILTIN_ATTR
 261 memcmp (const void *s1, const void *s2, grub_size_t n)
 262 {
 263   return grub_memcmp (s1, s2, n);
 264 }
 265 #endif
 266
 267 int
 268 grub_strcmp (const char *s1, const char *s2)
 269 {
 270   while (*s1 && *s2)
 271     {
 272       if (*s1 != *s2)
 273         break;
 274
 275       s1++;
 276       s2++;
 277     }
 278
 279   return (int) (grub_uint8_t) *s1 - (int) (grub_uint8_t) *s2;
 280 }
 281
 282 int
 283 grub_strncmp (const char *s1, const char *s2, grub_size_t n)
 284 {
 285   if (n == 0)
 286     return 0;
 287
 288   while (*s1 && *s2 && --n)
 289     {
 290       if (*s1 != *s2)
 291         break;
 292
 293       s1++;
 294       s2++;
 295     }
 296
 297   return (int) (grub_uint8_t) *s1 - (int) (grub_uint8_t)  *s2;
 298 }
 299
 300 char *
 301 grub_strchr (const char *s, int c)
 302 {
 303   do
 304     {
 305       if (*s == c)
 306         return (char *) s;
 307     }
 308   while (*s++);
 309
 310   return 0;
 311 }
 312
 313 char *
 314 grub_strrchr (const char *s, int c)
 315 {
 316   char *p = NULL;
 317
 318   do
 319     {
 320       if (*s == c)
 321         p = (char *) s;
 322     }
 323   while (*s++);
 324
 325   return p;
 326 }
 327
 328 int
 329 grub_strword (const char *haystack, const char *needle)
 330 {
 331   const char *n_pos = needle;
 332
 333   while (grub_iswordseparator (*haystack))
 334     haystack++;
 335
 336   while (*haystack)
 337     {
 338       /* Crawl both the needle and the haystack word we're on.  */
 339       while(*haystack && !grub_iswordseparator (*haystack)
 340             && *haystack == *n_pos)
 341         {
 342           haystack++;
 343           n_pos++;
 344         }
 345
 346       /* If we reached the end of both words at the same time, the word
 347       is found. If not, eat everything in the haystack that isn't the
 348       next word (or the end of string) and "reset" the needle.  */
 349       if ( (!*haystack || grub_iswordseparator (*haystack))
 350          && (!*n_pos || grub_iswordseparator (*n_pos)))
 351         return 1;
 352       else
 353         {
 354           n_pos = needle;
 355           while (*haystack && !grub_iswordseparator (*haystack))
 356             haystack++;
 357           while (grub_iswordseparator (*haystack))
 358             haystack++;
 359         }
 360     }
 361
 362   return 0;
 363 }
 364
 365 int
 366 grub_isspace (int c)
 367 {
 368   return (c == '\n' || c == '\r' || c == ' ' || c == '\t');
 369 }
 370
 371 unsigned long
 372 grub_strtoul (const char *str, char **end, int base)
 373 {
 374   unsigned long long num;
 375
 376   num = grub_strtoull (str, end, base);
 377 #if GRUB_CPU_SIZEOF_LONG != 8
 378   if (num > ~0UL)
 379     {
 380       grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));
 381       return ~0UL;
 382     }
 383 #endif
 384
 385   return (unsigned long) num;
 386 }
 387
 388 unsigned long long
 389 grub_strtoull (const char *str, char **end, int base)
 390 {
 391   unsigned long long num = 0;
 392   int found = 0;
 393
 394   /* Skip white spaces.  */
 395   /* grub_isspace checks that *str != '\0'.  */
 396   while (grub_isspace (*str))
 397     str++;
 398
 399   /* Guess the base, if not specified. The prefix `0x' means 16, and
 400      the prefix `0' means 8.  */
 401   if (str[0] == '0')
 402     {
 403       if (str[1] == 'x')
 404         {
 405           if (base == 0 || base == 16)
 406             {
 407               base = 16;
 408               str += 2;
 409             }
 410         }
 411       else if (base == 0 && str[1] >= '0' && str[1] <= '7')
 412         base = 8;
 413     }
 414
 415   if (base == 0)
 416     base = 10;
 417
 418   while (*str)
 419     {
 420       unsigned long digit;
 421
 422       digit = grub_tolower (*str) - '0';
 423       if (digit > 9)
 424         {
 425           digit += '0' - 'a' + 10;
 426           if (digit >= (unsigned long) base)
 427             break;
 428         }
 429
 430       found = 1;
 431
 432       /* NUM * BASE + DIGIT > ~0ULL */
 433       if (num > grub_divmod64 (~0ULL - digit, base, 0))
 434         {
 435           grub_error (GRUB_ERR_OUT_OF_RANGE,
 436                       N_("overflow is detected"));
 437           return ~0ULL;
 438         }
 439
 440       num = num * base + digit;
 441       str++;
 442     }
 443
 444   if (! found)
 445     {
 446       grub_error (GRUB_ERR_BAD_NUMBER,
 447                   N_("unrecognized number"));
 448       return 0;
 449     }
 450
 451   if (end)
 452     *end = (char *) str;
 453
 454   return num;
 455 }
 456
 457 char *
 458 grub_strdup (const char *s)
 459 {
 460   grub_size_t len;
 461   char *p;
 462
 463   len = grub_strlen (s) + 1;
 464   p = (char *) grub_malloc (len);
 465   if (! p)
 466     return 0;
 467
 468   return grub_memcpy (p, s, len);
 469 }
 470
 471 char *
 472 grub_strndup (const char *s, grub_size_t n)
 473 {
 474   grub_size_t len;
 475   char *p;
 476
 477   len = grub_strlen (s);
 478   if (len > n)
 479     len = n;
 480   p = (char *) grub_malloc (len + 1);
 481   if (! p)
 482     return 0;
 483
 484   grub_memcpy (p, s, len);
 485   p[len] = '\0';
 486   return p;
 487 }
 488
 489 /* clang detects that we're implementing here a memset so it decides to
 490    optimise and calls memset resulting in infinite recursion. With volatile
 491    we make it not optimise in this way.  */
 492 #ifdef __clang__
 493 #define VOLATILE_CLANG volatile
 494 #else
 495 #define VOLATILE_CLANG
 496 #endif
 497
 498 void *
 499 grub_memset (void *s, int c, grub_size_t len)
 500 {
 501   void *p = s;
 502   grub_uint8_t pattern8 = c;
 503
 504   if (len >= 3 * sizeof (unsigned long))
 505     {
 506       unsigned long patternl = 0;
 507       grub_size_t i;
 508
 509       for (i = 0; i < sizeof (unsigned long); i++)
 510         patternl |= ((unsigned long) pattern8) << (8 * i);
 511
 512       while (len > 0 && (((grub_addr_t) p) & (sizeof (unsigned long) - 1)))
 513         {
 514           *(VOLATILE_CLANG grub_uint8_t *) p = pattern8;
 515           p = (grub_uint8_t *) p + 1;
 516           len--;
 517         }
 518       while (len >= sizeof (unsigned long))
 519         {
 520           *(VOLATILE_CLANG unsigned long *) p = patternl;
 521           p = (unsigned long *) p + 1;
 522           len -= sizeof (unsigned long);
 523         }
 524     }
 525
 526   while (len > 0)
 527     {
 528       *(VOLATILE_CLANG grub_uint8_t *) p = pattern8;
 529       p = (grub_uint8_t *) p + 1;
 530       len--;
 531     }
 532
 533   return s;
 534 }
 535 #ifndef __APPLE__
 536 void *memset (void *s, int c, grub_size_t n)
 537   __attribute__ ((alias ("grub_memset")));
 538 #else
 539 void * GRUB_BUILTIN_ATTR
 540 memset (void *s, int c, grub_size_t n)
 541 {
 542   return grub_memset (s, c, n);
 543 }
 544
 545 #endif
 546
 547 #if !defined(GRUB_UTIL) && defined(__APPLE__)
 548 void GRUB_BUILTIN_ATTR
 549 __bzero (void *s, grub_size_t n)
 550 {
 551   grub_memset (s, 0, n);
 552 }
 553
 554 #endif
 555
 556 grub_size_t
 557 grub_strlen (const char *s)
 558 {
 559   const char *p = s;
 560
 561   while (*p)
 562     p++;
 563
 564   return p - s;
 565 }
 566
 567 static inline void
 568 grub_reverse (char *str)
 569 {
 570   char *p = str + grub_strlen (str) - 1;
 571
 572   while (str < p)
 573     {
 574       char tmp;
 575
 576       tmp = *str;
 577       *str = *p;
 578       *p = tmp;
 579       str++;
 580       p--;
 581     }
 582 }
 583
 584 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 585 grub_uint64_t
 586 grub_divmod64 (grub_uint64_t n, grub_uint64_t d, grub_uint64_t *r)
 587 {
 588   /* This algorithm is typically implemented by hardware. The idea
 589      is to get the highest bit in N, 64 times, by keeping
 590      upper(N * 2^i) = (Q * D + M), where upper
 591      represents the high 64 bits in 128-bits space.  */
 592   unsigned bits = 64;
 593   grub_uint64_t q = 0;
 594   grub_uint64_t m = 0;
 595
 596   /* ARM and IA64 don't have a fast 32-bit division.
 597      Using that code would just make us use libgcc routines, calling
 598      them twice (once for modulo and once for quotient.
 599   */
 600 #if !defined (__arm__) && !defined (__ia64__)
 601   /* Skip the slow computation if 32-bit arithmetic is possible.  */
 602   if (n < 0xffffffff && d < 0xffffffff)
 603     {
 604       if (r)
 605         *r = ((grub_uint32_t) n) % (grub_uint32_t) d;
 606
 607       return ((grub_uint32_t) n) / (grub_uint32_t) d;
 608     }
 609 #endif
 610
 611   while (bits--)
 612     {
 613       m <<= 1;
 614
 615       if (n & (1ULL << 63))
 616         m |= 1;
 617
 618       q <<= 1;
 619       n <<= 1;
 620
 621       if (m >= d)
 622         {
 623           q |= 1;
 624           m -= d;
 625         }
 626     }
 627
 628   if (r)
 629     *r = m;
 630
 631   return q;
 632 }
 633
 634 #if !defined (GRUB_UTIL) && !defined (GRUB_MACHINE_EMU)
 635
 636 #if defined (__arm__)
 637
 638 grub_uint32_t
 639 __udivsi3 (grub_uint32_t a, grub_uint32_t b)
 640 {
 641   return grub_divmod64 (a, b, 0);
 642 }
 643
 644 grub_uint32_t
 645 __umodsi3 (grub_uint32_t a, grub_uint32_t b)
 646 {
 647   grub_uint64_t ret;
 648   grub_divmod64 (a, b, &ret);
 649   return ret;
 650 }
 651
 652 #endif
 653
 654 #ifdef NEED_CTZDI2
 655
 656 unsigned
 657 __ctzdi2 (grub_uint64_t x)
 658 {
 659   unsigned ret = 0;
 660   if (!x)
 661     return 64;
 662   if (!(x & 0xffffffff))
 663     {
 664       x >>= 32;
 665       ret |= 32;
 666     }
 667   if (!(x & 0xffff))
 668     {
 669       x >>= 16;
 670       ret |= 16;
 671     }
 672   if (!(x & 0xff))
 673     {
 674       x >>= 8;
 675       ret |= 8;
 676     }
 677   if (!(x & 0xf))
 678     {
 679       x >>= 4;
 680       ret |= 4;
 681     }
 682   if (!(x & 0x3))
 683     {
 684       x >>= 2;
 685       ret |= 2;
 686     }
 687   if (!(x & 0x1))
 688     {
 689       x >>= 1;
 690       ret |= 1;
 691     }
 692   return ret;
 693 }
 694 #endif
 695
 696 #ifdef NEED_CTZSI2
 697 unsigned
 698 __ctzsi2 (grub_uint32_t x)
 699 {
 700   unsigned ret = 0;
 701   if (!x)
 702     return 32;
 703
 704   if (!(x & 0xffff))
 705     {
 706       x >>= 16;
 707       ret |= 16;
 708     }
 709   if (!(x & 0xff))
 710     {
 711       x >>= 8;
 712       ret |= 8;
 713     }
 714   if (!(x & 0xf))
 715     {
 716       x >>= 4;
 717       ret |= 4;
 718     }
 719   if (!(x & 0x3))
 720     {
 721       x >>= 2;
 722       ret |= 2;
 723     }
 724   if (!(x & 0x1))
 725     {
 726       x >>= 1;
 727       ret |= 1;
 728     }
 729   return ret;
 730 }
 731
 732 #endif
 733
 734 #ifdef __arm__
 735 grub_uint32_t
 736 __aeabi_uidiv (grub_uint32_t a, grub_uint32_t b)
 737   __attribute__ ((alias ("__udivsi3")));
 738 #endif
 739
 740 #if defined (__ia64__)
 741
 742 grub_uint64_t
 743 __udivdi3 (grub_uint64_t a, grub_uint64_t b)
 744 {
 745   return grub_divmod64 (a, b, 0);
 746 }
 747
 748 grub_uint64_t
 749 __umoddi3 (grub_uint64_t a, grub_uint64_t b)
 750 {
 751   grub_uint64_t ret;
 752   grub_divmod64 (a, b, &ret);
 753   return ret;
 754 }
 755
 756 #endif
 757
 758 #endif /* GRUB_UTIL */
 759
 760 /* Convert a long long value to a string. This function avoids 64-bit
 761    modular arithmetic or divisions.  */
 762 static inline char *
 763 grub_lltoa (char *str, int c, unsigned long long n)
 764 {
 765   unsigned base = (c == 'x') ? 16 : 10;
 766   char *p;
 767
 768   if ((long long) n < 0 && c == 'd')
 769     {
 770       n = (unsigned long long) (-((long long) n));
 771       *str++ = '-';
 772     }
 773
 774   p = str;
 775
 776   if (base == 16)
 777     do
 778       {
 779         unsigned d = (unsigned) (n & 0xf);
 780         *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
 781       }
 782     while (n >>= 4);
 783   else
 784     /* BASE == 10 */
 785     do
 786       {
 787         grub_uint64_t m;
 788
 789         n = grub_divmod64 (n, 10, &m);
 790         *p++ = m + '0';
 791       }
 792     while (n);
 793
 794   *p = 0;
 795
 796   grub_reverse (str);
 797   return p;
 798 }
 799
 800 static void
 801 parse_printf_args (const char *fmt0, struct printf_args *args,
 802                    va_list args_in)
 803 {
 804   const char *fmt;
 805   char c;
 806   grub_size_t n = 0;
 807
 808   args->count = 0;
 809
 810   COMPILE_TIME_ASSERT (sizeof (int) == sizeof (grub_uint32_t));
 811   COMPILE_TIME_ASSERT (sizeof (int) <= sizeof (long long));
 812   COMPILE_TIME_ASSERT (sizeof (long) <= sizeof (long long));
 813   COMPILE_TIME_ASSERT (sizeof (long long) == sizeof (void *)
 814                        || sizeof (int) == sizeof (void *));
 815
 816   fmt = fmt0;
 817   while ((c = *fmt++) != 0)
 818     {
 819       if (c != '%')
 820         continue;
 821
 822       if (*fmt =='-')
 823         fmt++;
 824
 825       while (grub_isdigit (*fmt))
 826         fmt++;
 827
 828       if (*fmt == '$')
 829         fmt++;
 830
 831       if (*fmt =='-')
 832         fmt++;
 833
 834       while (grub_isdigit (*fmt))
 835         fmt++;
 836
 837       if (*fmt =='.')
 838         fmt++;
 839
 840       while (grub_isdigit (*fmt))
 841         fmt++;
 842
 843       c = *fmt++;
 844       if (c == 'l')
 845         c = *fmt++;
 846       if (c == 'l')
 847         c = *fmt++;
 848
 849       switch (c)
 850         {
 851         case 'p':
 852         case 'x':
 853         case 'u':
 854         case 'd':
 855         case 'c':
 856         case 'C':
 857         case 's':
 858           args->count++;
 859           break;
 860         }
 861     }
 862
 863   if (args->count <= ARRAY_SIZE (args->prealloc))
 864     args->ptr = args->prealloc;
 865   else
 866     {
 867       args->ptr = grub_malloc (args->count * sizeof (args->ptr[0]));
 868       if (!args->ptr)
 869         {
 870           grub_errno = GRUB_ERR_NONE;
 871           args->ptr = args->prealloc;
 872           args->count = ARRAY_SIZE (args->prealloc);
 873         }
 874     }
 875
 876   grub_memset (args->ptr, 0, args->count * sizeof (args->ptr[0]));
 877
 878   fmt = fmt0;
 879   n = 0;
 880   while ((c = *fmt++) != 0)
 881     {
 882       int longfmt = 0;
 883       grub_size_t curn;
 884       const char *p;
 885
 886       if (c != '%')
 887         continue;
 888
 889       curn = n++;
 890
 891       if (*fmt =='-')
 892         fmt++;
 893
 894       p = fmt;
 895
 896       while (grub_isdigit (*fmt))
 897         fmt++;
 898
 899       if (*fmt == '$')
 900         {
 901           curn = grub_strtoull (p, 0, 10) - 1;
 902           fmt++;
 903         }
 904
 905       if (*fmt =='-')
 906         fmt++;
 907
 908       while (grub_isdigit (*fmt))
 909         fmt++;
 910
 911       if (*fmt =='.')
 912         fmt++;
 913
 914       while (grub_isdigit (*fmt))
 915         fmt++;
 916
 917       c = *fmt++;
 918       if (c == 'l')
 919         {
 920           c = *fmt++;
 921           longfmt = 1;
 922         }
 923       if (c == 'l')
 924         {
 925           c = *fmt++;
 926           longfmt = 2;
 927         }
 928       if (curn >= args->count)
 929         continue;
 930       switch (c)
 931         {
 932         case 'x':
 933         case 'u':
 934           args->ptr[curn].type = UNSIGNED_INT + longfmt;
 935           break;
 936         case 'd':
 937           args->ptr[curn].type = INT + longfmt;
 938           break;
 939         case 'p':
 940         case 's':
 941           if (sizeof (void *) == sizeof (long long))
 942             args->ptr[curn].type = UNSIGNED_LONGLONG;
 943           else
 944             args->ptr[curn].type = UNSIGNED_INT;
 945           break;
 946         case 'C':
 947         case 'c':
 948           args->ptr[curn].type = INT;
 949           break;
 950         }
 951     }
 952
 953   for (n = 0; n < args->count; n++)
 954     switch (args->ptr[n].type)
 955       {
 956       case INT:
 957         args->ptr[n].ll = va_arg (args_in, int);
 958         break;
 959       case LONG:
 960         args->ptr[n].ll = va_arg (args_in, long);
 961         break;
 962       case UNSIGNED_INT:
 963         args->ptr[n].ll = va_arg (args_in, unsigned int);
 964         break;
 965       case UNSIGNED_LONG:
 966         args->ptr[n].ll = va_arg (args_in, unsigned long);
 967         break;
 968       case LONGLONG:
 969       case UNSIGNED_LONGLONG:
 970         args->ptr[n].ll = va_arg (args_in, long long);
 971         break;
 972       }
 973 }
 974
 975 static inline void __attribute__ ((always_inline))
 976 write_char (char *str, grub_size_t *count, grub_size_t max_len, unsigned char ch)
 977 {
 978   if (*count < max_len)
 979     str[*count] = ch;
 980
 981   (*count)++;
 982 }
 983
 984 static int
 985 grub_vsnprintf_real (char *str, grub_size_t max_len, const char *fmt0,
 986                      struct printf_args *args)
 987 {
 988   char c;
 989   grub_size_t n = 0;
 990   grub_size_t count = 0;
 991   const char *fmt;
 992
 993   fmt = fmt0;
 994
 995   while ((c = *fmt++) != 0)
 996     {
 997       unsigned int format1 = 0;
 998       unsigned int format2 = ~ 0U;
 999       char zerofill = ' ';
1000       char rightfill = 0;
1001       grub_size_t curn;
1002
1003       if (c != '%')
1004         {
1005           write_char (str, &count, max_len,c);
1006           continue;
1007         }
1008
1009       curn = n++;
1010
1011     rescan:;
1012
1013       if (*fmt =='-')
1014         {
1015           rightfill = 1;
1016           fmt++;
1017         }
1018
1019       /* Read formatting parameters.  */
1020       if (grub_isdigit (*fmt))
1021         {
1022           if (fmt[0] == '0')
1023             zerofill = '0';
1024           format1 = grub_strtoul (fmt, (char **) &fmt, 10);
1025         }
1026
1027       if (*fmt == '.')
1028         fmt++;
1029
1030       if (grub_isdigit (*fmt))
1031         format2 = grub_strtoul (fmt, (char **) &fmt, 10);
1032
1033       if (*fmt == '$')
1034         {
1035           curn = format1 - 1;
1036           fmt++;
1037           format1 = 0;
1038           format2 = ~ 0U;
1039           zerofill = ' ';
1040           rightfill = 0;
1041
1042           goto rescan;
1043         }
1044
1045       c = *fmt++;
1046       if (c == 'l')
1047         c = *fmt++;
1048       if (c == 'l')
1049         c = *fmt++;
1050
1051       if (c == '%')
1052         {
1053           write_char (str, &count, max_len,c);
1054           continue;
1055         }
1056
1057       if (curn >= args->count)
1058         continue;
1059
1060       long long curarg = args->ptr[curn].ll;
1061
1062       switch (c)
1063         {
1064         case 'p':
1065           write_char (str, &count, max_len, '0');
1066           write_char (str, &count, max_len, 'x');
1067           c = 'x';
1068           /* Fall through. */
1069         case 'x':
1070         case 'u':
1071         case 'd':
1072           {
1073             char tmp[32];
1074             const char *p = tmp;
1075             grub_size_t len;
1076             grub_size_t fill;
1077
1078             len = grub_lltoa (tmp, c, curarg) - tmp;
1079             fill = len < format1 ? format1 - len : 0;
1080             if (! rightfill)
1081               while (fill--)
1082                 write_char (str, &count, max_len, zerofill);
1083             while (*p)
1084               write_char (str, &count, max_len, *p++);
1085             if (rightfill)
1086               while (fill--)
1087                 write_char (str, &count, max_len, zerofill);
1088           }
1089           break;
1090
1091         case 'c':
1092           write_char (str, &count, max_len,curarg & 0xff);
1093           break;
1094
1095         case 'C':
1096           {
1097             grub_uint32_t code = curarg;
1098             int shift;
1099             unsigned mask;
1100
1101             if (code <= 0x7f)
1102               {
1103                 shift = 0;
1104                 mask = 0;
1105               }
1106             else if (code <= 0x7ff)
1107               {
1108                 shift = 6;
1109                 mask = 0xc0;
1110               }
1111             else if (code <= 0xffff)
1112               {
1113                 shift = 12;
1114                 mask = 0xe0;
1115               }
1116             else if (code <= 0x10ffff)
1117               {
1118                 shift = 18;
1119                 mask = 0xf0;
1120               }
1121             else
1122               {
1123                 code = '?';
1124                 shift = 0;
1125                 mask = 0;
1126               }
1127
1128             write_char (str, &count, max_len,mask | (code >> shift));
1129
1130             for (shift -= 6; shift >= 0; shift -= 6)
1131               write_char (str, &count, max_len,0x80 | (0x3f & (code >> shift)));
1132           }
1133           break;
1134
1135         case 's':
1136           {
1137             grub_size_t len = 0;
1138             grub_size_t fill;
1139             const char *p = ((char *) (grub_addr_t) curarg) ? : "(null)";
1140             grub_size_t i;
1141
1142             while (len < format2 && p[len])
1143               len++;
1144
1145             fill = len < format1 ? format1 - len : 0;
1146
1147             if (!rightfill)
1148               while (fill--)
1149                 write_char (str, &count, max_len, zerofill);
1150
1151             for (i = 0; i < len; i++)
1152               write_char (str, &count, max_len,*p++);
1153
1154             if (rightfill)
1155               while (fill--)
1156                 write_char (str, &count, max_len, zerofill);
1157           }
1158
1159           break;
1160
1161         default:
1162           write_char (str, &count, max_len,c);
1163           break;
1164         }
1165     }
1166
1167   if (count < max_len)
1168     str[count] = '\0';
1169   else
1170     str[max_len] = '\0';
1171   return count;
1172 }
1173
1174 int
1175 grub_vsnprintf (char *str, grub_size_t n, const char *fmt, va_list ap)
1176 {
1177   grub_size_t ret;
1178   struct printf_args args;
1179
1180   if (!n)
1181     return 0;
1182
1183   n--;
1184
1185   parse_printf_args (fmt, &args, ap);
1186
1187   ret = grub_vsnprintf_real (str, n, fmt, &args);
1188
1189   free_printf_args (&args);
1190
1191   return ret < n ? ret : n;
1192 }
1193
1194 int
1195 grub_snprintf (char *str, grub_size_t n, const char *fmt, ...)
1196 {
1197   va_list ap;
1198   int ret;
1199
1200   va_start (ap, fmt);
1201   ret = grub_vsnprintf (str, n, fmt, ap);
1202   va_end (ap);
1203
1204   return ret;
1205 }
1206
1207 char *
1208 grub_xvasprintf (const char *fmt, va_list ap)
1209 {
1210   grub_size_t s, as = PREALLOC_SIZE;
1211   char *ret;
1212   struct printf_args args;
1213
1214   parse_printf_args (fmt, &args, ap);
1215
1216   while (1)
1217     {
1218       ret = grub_malloc (as + 1);
1219       if (!ret)
1220         {
1221           free_printf_args (&args);
1222           return NULL;
1223         }
1224
1225       s = grub_vsnprintf_real (ret, as, fmt, &args);
1226
1227       if (s <= as)
1228         {
1229           free_printf_args (&args);
1230           return ret;
1231         }
1232
1233       grub_free (ret);
1234       as = s;
1235     }
1236 }
1237
1238 char *
1239 grub_xasprintf (const char *fmt, ...)
1240 {
1241   va_list ap;
1242   char *ret;
1243
1244   va_start (ap, fmt);
1245   ret = grub_xvasprintf (fmt, ap);
1246   va_end (ap);
1247
1248   return ret;
1249 }
1250
1251 /* Abort GRUB. This function does not return.  */
1252 static void __attribute__ ((noreturn))
1253 grub_abort (void)
1254 {
1255   grub_printf ("\nAborted.");
1256
1257 #ifndef GRUB_UTIL
1258   if (grub_term_inputs)
1259 #endif
1260     {
1261       grub_printf (" Press any key to exit.");
1262       grub_getkey ();
1263     }
1264
1265   grub_exit ();
1266 }
1267
1268 #if defined (__clang__) && !defined (GRUB_UTIL)
1269 /* clang emits references to abort().  */
1270 void __attribute__ ((noreturn))
1271 abort (void)
1272 {
1273   grub_abort ();
1274 }
1275 #endif
1276
1277 void
1278 grub_fatal (const char *fmt, ...)
1279 {
1280   va_list ap;
1281
1282   va_start (ap, fmt);
1283   grub_vprintf (_(fmt), ap);
1284   va_end (ap);
1285
1286   grub_abort ();
1287 }
1288
1289 #if (defined (__MINGW32__) || defined (__CYGWIN__)) && !defined(GRUB_UTIL)
1290 void __register_frame_info (void)
1291 {
1292 }
1293
1294 void __deregister_frame_info (void)
1295 {
1296 }
1297 void ___chkstk_ms (void)
1298 {
1299 }
1300
1301 void __chkstk_ms (void)
1302 {
1303 }
1304 #endif
1305
1306 #if BOOT_TIME_STATS
1307
1308 #include <grub/time.h>
1309
1310 struct grub_boot_time *grub_boot_time_head;
1311 static struct grub_boot_time **boot_time_last = &grub_boot_time_head;
1312
1313 void
1314 grub_real_boot_time (const char *file,
1315                      const int line,
1316                      const char *fmt, ...)
1317 {
1318   struct grub_boot_time *n;
1319   va_list args;
1320
1321   grub_error_push ();
1322   n = grub_malloc (sizeof (*n));
1323   if (!n)
1324     {
1325       grub_errno = 0;
1326       grub_error_pop ();
1327       return;
1328     }
1329   n->file = file;
1330   n->line = line;
1331   n->tp = grub_get_time_ms ();
1332   n->next = 0;
1333
1334   va_start (args, fmt);
1335   n->msg = grub_xvasprintf (fmt, args);
1336   va_end (args);
1337
1338   *boot_time_last = n;
1339   boot_time_last = &n->next;
1340
1341   grub_errno = 0;
1342   grub_error_pop ();
1343 }
1344 #endif