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  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
  27 void *
  28 grub_memmove (void *dest, const void *src, grub_size_t n)
  29 {
  30   char *d = (char *) dest;
  31   const char *s = (const char *) src;
  32
  33   if (d < s)
  34     while (n--)
  35       *d++ = *s++;
  36   else
  37     {
  38       d += n;
  39       s += n;
  40
  41       while (n--)
  42         *--d = *--s;
  43     }
  44
  45   return dest;
  46 }
  47
  48 #ifndef APPLE_CC
  49 void *memmove (void *dest, const void *src, grub_size_t n)
  50   __attribute__ ((alias ("grub_memmove")));
  51 /* GCC emits references to memcpy() for struct copies etc.  */
  52 void *memcpy (void *dest, const void *src, grub_size_t n)
  53   __attribute__ ((alias ("grub_memmove")));
  54 #else
  55 void *memcpy (void *dest, const void *src, grub_size_t n)
  56 {
  57         return grub_memmove (dest, src, n);
  58 }
  59 void *memmove (void *dest, const void *src, grub_size_t n)
  60 {
  61         return grub_memmove (dest, src, n);
  62 }
  63 #endif
  64
  65 char *
  66 grub_strcpy (char *dest, const char *src)
  67 {
  68   char *p = dest;
  69
  70   while ((*p++ = *src++) != '\0')
  71     ;
  72
  73   return dest;
  74 }
  75
  76 char *
  77 grub_strncpy (char *dest, const char *src, int c)
  78 {
  79   char *p = dest;
  80
  81   while ((*p++ = *src++) != '\0' && --c)
  82     ;
  83
  84   return dest;
  85 }
  86
  87 char *
  88 grub_stpcpy (char *dest, const char *src)
  89 {
  90   char *d = dest;
  91   const char *s = src;
  92
  93   do
  94     *d++ = *s;
  95   while (*s++ != '\0');
  96
  97   return d - 1;
  98 }
  99
 100 char *
 101 grub_strcat (char *dest, const char *src)
 102 {
 103   char *p = dest;
 104
 105   while (*p)
 106     p++;
 107
 108   while ((*p = *src) != '\0')
 109     {
 110       p++;
 111       src++;
 112     }
 113
 114   return dest;
 115 }
 116
 117 char *
 118 grub_strncat (char *dest, const char *src, int c)
 119 {
 120   char *p = dest;
 121
 122   while (*p)
 123     p++;
 124
 125   while ((*p = *src) != '\0' && c--)
 126     {
 127       p++;
 128       src++;
 129     }
 130
 131   *p = '\0';
 132
 133   return dest;
 134 }
 135
 136 int
 137 grub_printf (const char *fmt, ...)
 138 {
 139   va_list ap;
 140   int ret;
 141
 142   va_start (ap, fmt);
 143   ret = grub_vprintf (fmt, ap);
 144   va_end (ap);
 145
 146   return ret;
 147 }
 148
 149 #if defined (APPLE_CC) && ! defined (GRUB_UTIL)
 150 int
 151 grub_err_printf (const char *fmt, ...)
 152 {
 153         va_list ap;
 154         int ret;
 155
 156         va_start (ap, fmt);
 157         ret = grub_vprintf (fmt, ap);
 158         va_end (ap);
 159
 160         return ret;
 161 }
 162 #endif
 163
 164 #if ! defined (APPLE_CC) && ! defined (GRUB_UTIL)
 165 int grub_err_printf (const char *fmt, ...)
 166 __attribute__ ((alias("grub_printf")));
 167 #endif
 168
 169 void
 170 grub_real_dprintf (const char *file, const int line, const char *condition,
 171                    const char *fmt, ...)
 172 {
 173   va_list args;
 174   const char *debug = grub_env_get ("debug");
 175
 176   if (! debug)
 177     return;
 178
 179   if (grub_strword (debug, "all") || grub_strword (debug, condition))
 180     {
 181       grub_printf ("%s:%d: ", file, line);
 182       va_start (args, fmt);
 183       grub_vprintf (fmt, args);
 184       va_end (args);
 185     }
 186 }
 187
 188 int
 189 grub_vprintf (const char *fmt, va_list args)
 190 {
 191   int ret;
 192
 193   ret = grub_vsprintf (0, fmt, args);
 194   grub_refresh ();
 195   return ret;
 196 }
 197
 198 int
 199 grub_memcmp (const void *s1, const void *s2, grub_size_t n)
 200 {
 201   const char *t1 = s1;
 202   const char *t2 = s2;
 203
 204   while (n--)
 205     {
 206       if (*t1 != *t2)
 207         return (int) *t1 - (int) *t2;
 208
 209       t1++;
 210       t2++;
 211     }
 212
 213   return 0;
 214 }
 215 #ifndef APPLE_CC
 216 int memcmp (const void *s1, const void *s2, grub_size_t n)
 217   __attribute__ ((alias ("grub_memcmp")));
 218 #endif
 219
 220 int
 221 grub_strcmp (const char *s1, const char *s2)
 222 {
 223   while (*s1 && *s2)
 224     {
 225       if (*s1 != *s2)
 226         break;
 227
 228       s1++;
 229       s2++;
 230     }
 231
 232   return (int) *s1 - (int) *s2;
 233 }
 234
 235 int
 236 grub_strncmp (const char *s1, const char *s2, grub_size_t n)
 237 {
 238   if (n == 0)
 239     return 0;
 240
 241   while (*s1 && *s2 && --n)
 242     {
 243       if (*s1 != *s2)
 244         break;
 245
 246       s1++;
 247       s2++;
 248     }
 249
 250   return (int) *s1 - (int) *s2;
 251 }
 252
 253 int
 254 grub_strcasecmp (const char *s1, const char *s2)
 255 {
 256   while (*s1 && *s2)
 257     {
 258       if (grub_tolower (*s1) != grub_tolower (*s2))
 259         break;
 260
 261       s1++;
 262       s2++;
 263     }
 264
 265   return (int) grub_tolower (*s1) - (int) grub_tolower (*s2);
 266 }
 267
 268 int
 269 grub_strncasecmp (const char *s1, const char *s2, grub_size_t n)
 270 {
 271   if (n == 0)
 272     return 0;
 273
 274   while (*s1 && *s2 && --n)
 275     {
 276       if (grub_tolower (*s1) != grub_tolower (*s2))
 277         break;
 278
 279       s1++;
 280       s2++;
 281     }
 282
 283   return (int) grub_tolower (*s1) - (int) grub_tolower (*s2);
 284 }
 285
 286 char *
 287 grub_strchr (const char *s, int c)
 288 {
 289   while (*s)
 290     {
 291       if (*s == c)
 292         return (char *) s;
 293       s++;
 294     }
 295
 296   return 0;
 297 }
 298
 299 char *
 300 grub_strrchr (const char *s, int c)
 301 {
 302   char *p = 0;
 303
 304   while (*s)
 305     {
 306       if (*s == c)
 307         p = (char *) s;
 308       s++;
 309     }
 310
 311   return p;
 312 }
 313
 314 /* Copied from gnulib.
 315    Written by Bruno Haible <bruno@clisp.org>, 2005. */
 316 char *
 317 grub_strstr (const char *haystack, const char *needle)
 318 {
 319   /* Be careful not to look at the entire extent of haystack or needle
 320      until needed.  This is useful because of these two cases:
 321        - haystack may be very long, and a match of needle found early,
 322        - needle may be very long, and not even a short initial segment of
 323        needle may be found in haystack.  */
 324   if (*needle != '\0')
 325     {
 326       /* Speed up the following searches of needle by caching its first
 327          character.  */
 328       char b = *needle++;
 329
 330       for (;; haystack++)
 331         {
 332           if (*haystack == '\0')
 333             /* No match.  */
 334             return NULL;
 335           if (*haystack == b)
 336             /* The first character matches.  */
 337             {
 338               const char *rhaystack = haystack + 1;
 339               const char *rneedle = needle;
 340
 341               for (;; rhaystack++, rneedle++)
 342                 {
 343                   if (*rneedle == '\0')
 344                     /* Found a match.  */
 345                     return (char *) haystack;
 346                   if (*rhaystack == '\0')
 347                     /* No match.  */
 348                     return NULL;
 349                   if (*rhaystack != *rneedle)
 350                     /* Nothing in this round.  */
 351                     break;
 352                 }
 353             }
 354         }
 355     }
 356   else
 357     return (char *) haystack;
 358 }
 359
 360 int
 361 grub_strword (const char *haystack, const char *needle)
 362 {
 363   const char *n_pos = needle;
 364
 365   while (grub_iswordseparator (*haystack))
 366     haystack++;
 367
 368   while (*haystack)
 369     {
 370       /* Crawl both the needle and the haystack word we're on.  */
 371       while(*haystack && !grub_iswordseparator (*haystack)
 372             && *haystack == *n_pos)
 373         {
 374           haystack++;
 375           n_pos++;
 376         }
 377
 378       /* If we reached the end of both words at the same time, the word
 379       is found. If not, eat everything in the haystack that isn't the
 380       next word (or the end of string) and "reset" the needle.  */
 381       if ( (!*haystack || grub_iswordseparator (*haystack))
 382          && (!*n_pos || grub_iswordseparator (*n_pos)))
 383         return 1;
 384       else
 385         {
 386           n_pos = needle;
 387           while (*haystack && !grub_iswordseparator (*haystack))
 388             haystack++;
 389           while (grub_iswordseparator (*haystack))
 390             haystack++;
 391         }
 392     }
 393
 394   return 0;
 395 }
 396
 397 int
 398 grub_iswordseparator (int c)
 399 {
 400   return (grub_isspace (c) || c == ',' || c == ';' || c == '|' || c == '&');
 401 }
 402
 403 int
 404 grub_isspace (int c)
 405 {
 406   return (c == '\n' || c == '\r' || c == ' ' || c == '\t');
 407 }
 408
 409 int
 410 grub_iscntrl (int c)
 411 {
 412   return (c >= 0x00 && c <= 0x1F) || c == 0x7F;
 413 }
 414
 415 int
 416 grub_isprint (int c)
 417 {
 418   return (c >= ' ' && c <= '~');
 419 }
 420
 421 int
 422 grub_isalpha (int c)
 423 {
 424   return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 425 }
 426
 427 int
 428 grub_isalnum (int c)
 429 {
 430   return grub_isalpha (c) || grub_isdigit (c);
 431 }
 432
 433 int
 434 grub_isdigit (int c)
 435 {
 436   return (c >= '0' && c <= '9');
 437 }
 438
 439 int
 440 grub_isgraph (int c)
 441 {
 442   return (c >= '!' && c <= '~');
 443 }
 444
 445 int
 446 grub_tolower (int c)
 447 {
 448   if (c >= 'A' && c <= 'Z')
 449     return c - 'A' + 'a';
 450
 451   return c;
 452 }
 453
 454 long
 455 grub_strtol (const char *str, char **end, int base)
 456 {
 457   int negative = 0;
 458
 459   while (*str && grub_isspace (*str))
 460     str++;
 461
 462   if (*str == '-')
 463     {
 464       negative = 1;
 465       str++;
 466     }
 467
 468   unsigned long long magnitude;
 469   magnitude = grub_strtoull (str, end, base);
 470   if (negative)
 471     {
 472       if (magnitude > -((long long) GRUB_LONG_MIN))
 473         {
 474           grub_error (GRUB_ERR_OUT_OF_RANGE, "negative overflow");
 475           return GRUB_LONG_MIN;
 476         }
 477       return -((long long) magnitude);
 478     }
 479   else
 480     {
 481       if (magnitude > GRUB_LONG_MAX)
 482         {
 483           grub_error (GRUB_ERR_OUT_OF_RANGE, "positive overflow");
 484           return GRUB_LONG_MAX;
 485         }
 486       return (long) magnitude;
 487     }
 488 }
 489
 490 unsigned long
 491 grub_strtoul (const char *str, char **end, int base)
 492 {
 493   unsigned long long num;
 494
 495   num = grub_strtoull (str, end, base);
 496   if (num > ~0UL)
 497     {
 498       grub_error (GRUB_ERR_OUT_OF_RANGE, "overflow is detected");
 499       return ~0UL;
 500     }
 501
 502   return (unsigned long) num;
 503 }
 504
 505 unsigned long long
 506 grub_strtoull (const char *str, char **end, int base)
 507 {
 508   unsigned long long num = 0;
 509   int found = 0;
 510
 511   /* Skip white spaces.  */
 512   while (*str && grub_isspace (*str))
 513     str++;
 514
 515   /* Guess the base, if not specified. The prefix `0x' means 16, and
 516      the prefix `0' means 8.  */
 517   if (str[0] == '0')
 518     {
 519       if (str[1] == 'x')
 520         {
 521           if (base == 0 || base == 16)
 522             {
 523               base = 16;
 524               str += 2;
 525             }
 526         }
 527       else if (base == 0 && str[1] >= '0' && str[1] <= '7')
 528         base = 8;
 529     }
 530
 531   if (base == 0)
 532     base = 10;
 533
 534   while (*str)
 535     {
 536       unsigned long digit;
 537
 538       digit = grub_tolower (*str) - '0';
 539       if (digit > 9)
 540         {
 541           digit += '0' - 'a' + 10;
 542           if (digit >= (unsigned long) base)
 543             break;
 544         }
 545
 546       found = 1;
 547
 548       /* NUM * BASE + DIGIT > ~0ULL */
 549       if (num > grub_divmod64 (~0ULL - digit, base, 0))
 550         {
 551           grub_error (GRUB_ERR_OUT_OF_RANGE, "overflow is detected");
 552           return ~0ULL;
 553         }
 554
 555       num = num * base + digit;
 556       str++;
 557     }
 558
 559   if (! found)
 560     {
 561       grub_error (GRUB_ERR_BAD_NUMBER, "unrecognized number");
 562       return 0;
 563     }
 564
 565   if (end)
 566     *end = (char *) str;
 567
 568   return num;
 569 }
 570
 571 char *
 572 grub_strdup (const char *s)
 573 {
 574   grub_size_t len;
 575   char *p;
 576
 577   len = grub_strlen (s) + 1;
 578   p = (char *) grub_malloc (len);
 579   if (! p)
 580     return 0;
 581
 582   return grub_memcpy (p, s, len);
 583 }
 584
 585 char *
 586 grub_strndup (const char *s, grub_size_t n)
 587 {
 588   grub_size_t len;
 589   char *p;
 590
 591   len = grub_strlen (s);
 592   if (len > n)
 593     len = n;
 594   p = (char *) grub_malloc (len + 1);
 595   if (! p)
 596     return 0;
 597
 598   grub_memcpy (p, s, len);
 599   p[len] = '\0';
 600   return p;
 601 }
 602
 603 void *
 604 grub_memset (void *s, int c, grub_size_t n)
 605 {
 606   unsigned char *p = (unsigned char *) s;
 607
 608   while (n--)
 609     *p++ = (unsigned char) c;
 610
 611   return s;
 612 }
 613 #ifndef APPLE_CC
 614 void *memset (void *s, int c, grub_size_t n)
 615   __attribute__ ((alias ("grub_memset")));
 616 #endif
 617
 618 grub_size_t
 619 grub_strlen (const char *s)
 620 {
 621   const char *p = s;
 622
 623   while (*p)
 624     p++;
 625
 626   return p - s;
 627 }
 628
 629 static inline void
 630 grub_reverse (char *str)
 631 {
 632   char *p = str + grub_strlen (str) - 1;
 633
 634   while (str < p)
 635     {
 636       char tmp;
 637
 638       tmp = *str;
 639       *str = *p;
 640       *p = tmp;
 641       str++;
 642       p--;
 643     }
 644 }
 645
 646 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 647 grub_uint64_t
 648 grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
 649 {
 650   /* This algorithm is typically implemented by hardware. The idea
 651      is to get the highest bit in N, 64 times, by keeping
 652      upper(N * 2^i) = upper((Q * 10 + M) * 2^i), where upper
 653      represents the high 64 bits in 128-bits space.  */
 654   unsigned bits = 64;
 655   unsigned long long q = 0;
 656   unsigned m = 0;
 657
 658   /* Skip the slow computation if 32-bit arithmetic is possible.  */
 659   if (n < 0xffffffff)
 660     {
 661       if (r)
 662         *r = ((grub_uint32_t) n) % d;
 663
 664       return ((grub_uint32_t) n) / d;
 665     }
 666
 667   while (bits--)
 668     {
 669       m <<= 1;
 670
 671       if (n & (1ULL << 63))
 672         m |= 1;
 673
 674       q <<= 1;
 675       n <<= 1;
 676
 677       if (m >= d)
 678         {
 679           q |= 1;
 680           m -= d;
 681         }
 682     }
 683
 684   if (r)
 685     *r = m;
 686
 687   return q;
 688 }
 689
 690 /* Convert a long long value to a string. This function avoids 64-bit
 691    modular arithmetic or divisions.  */
 692 static char *
 693 grub_lltoa (char *str, int c, unsigned long long n)
 694 {
 695   unsigned base = (c == 'x') ? 16 : 10;
 696   char *p;
 697
 698   if ((long long) n < 0 && c == 'd')
 699     {
 700       n = (unsigned long long) (-((long long) n));
 701       *str++ = '-';
 702     }
 703
 704   p = str;
 705
 706   if (base == 16)
 707     do
 708       {
 709         unsigned d = (unsigned) (n & 0xf);
 710         *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
 711       }
 712     while (n >>= 4);
 713   else
 714     /* BASE == 10 */
 715     do
 716       {
 717         unsigned m;
 718
 719         n = grub_divmod64 (n, 10, &m);
 720         *p++ = m + '0';
 721       }
 722     while (n);
 723
 724   *p = 0;
 725
 726   grub_reverse (str);
 727   return p;
 728 }
 729
 730 int
 731 grub_vsprintf (char *str, const char *fmt, va_list args)
 732 {
 733   char c;
 734   int count = 0;
 735   auto void write_char (unsigned char ch);
 736   auto void write_str (const char *s);
 737   auto void write_fill (const char ch, int n);
 738
 739   void write_char (unsigned char ch)
 740     {
 741       if (str)
 742         *str++ = ch;
 743       else
 744         grub_putchar (ch);
 745
 746       count++;
 747     }
 748
 749   void write_str (const char *s)
 750     {
 751       while (*s)
 752         write_char (*s++);
 753     }
 754
 755   void write_fill (const char ch, int n)
 756     {
 757       int i;
 758       for (i = 0; i < n; i++)
 759         write_char (ch);
 760     }
 761
 762   while ((c = *fmt++) != 0)
 763     {
 764       if (c != '%')
 765         write_char (c);
 766       else
 767         {
 768           char tmp[32];
 769           char *p;
 770           unsigned int format1 = 0;
 771           unsigned int format2 = ~ 0U;
 772           char zerofill = ' ';
 773           int rightfill = 0;
 774           int n;
 775           int longfmt = 0;
 776           int longlongfmt = 0;
 777           int unsig = 0;
 778
 779           if (*fmt && *fmt =='-')
 780             {
 781               rightfill = 1;
 782               fmt++;
 783             }
 784
 785           p = (char *) fmt;
 786           /* Read formatting parameters.  */
 787           while (*p && grub_isdigit (*p))
 788             p++;
 789
 790           if (p > fmt)
 791             {
 792               char s[p - fmt + 1];
 793               grub_strncpy (s, fmt, p - fmt);
 794               s[p - fmt] = 0;
 795               if (s[0] == '0')
 796                 zerofill = '0';
 797               format1 = grub_strtoul (s, 0, 10);
 798               fmt = p;
 799             }
 800
 801           if (*p && *p == '.')
 802             {
 803               p++;
 804               fmt++;
 805               while (*p && grub_isdigit (*p))
 806                 p++;
 807
 808               if (p > fmt)
 809                 {
 810                   char fstr[p - fmt + 1];
 811                   grub_strncpy (fstr, fmt, p - fmt);
 812                   fstr[p - fmt] = 0;
 813                   format2 = grub_strtoul (fstr, 0, 10);
 814                   fmt = p;
 815                 }
 816             }
 817
 818           c = *fmt++;
 819           if (c == 'l')
 820             {
 821               longfmt = 1;
 822               c = *fmt++;
 823               if (c == 'l')
 824                 {
 825                   longlongfmt = 1;
 826                   c = *fmt++;
 827                 }
 828             }
 829
 830           switch (c)
 831             {
 832             case 'p':
 833               write_str ("0x");
 834               c = 'x';
 835               longlongfmt |= (sizeof (void *) == sizeof (long long));
 836               /* Fall through. */
 837             case 'x':
 838             case 'u':
 839               unsig = 1;
 840               /* Fall through. */
 841             case 'd':
 842               if (longlongfmt)
 843                 {
 844                   long long ll;
 845
 846                   ll = va_arg (args, long long);
 847                   grub_lltoa (tmp, c, ll);
 848                 }
 849               else if (longfmt && unsig)
 850                 {
 851                   unsigned long l = va_arg (args, unsigned long);
 852                   grub_lltoa (tmp, c, l);
 853                 }
 854               else if (longfmt)
 855                 {
 856                   long l = va_arg (args, long);
 857                   grub_lltoa (tmp, c, l);
 858                 }
 859               else if (unsig)
 860                 {
 861                   unsigned u = va_arg (args, unsigned);
 862                   grub_lltoa (tmp, c, u);
 863                 }
 864               else
 865                 {
 866                   n = va_arg (args, int);
 867                   grub_lltoa (tmp, c, n);
 868                 }
 869               if (! rightfill && grub_strlen (tmp) < format1)
 870                 write_fill (zerofill, format1 - grub_strlen (tmp));
 871               write_str (tmp);
 872               if (rightfill && grub_strlen (tmp) < format1)
 873                 write_fill (zerofill, format1 - grub_strlen (tmp));
 874               break;
 875
 876             case 'c':
 877               n = va_arg (args, int);
 878               write_char (n & 0xff);
 879               break;
 880
 881             case 'C':
 882               {
 883                 grub_uint32_t code = va_arg (args, grub_uint32_t);
 884                 int shift;
 885                 unsigned mask;
 886
 887                 if (code <= 0x7f)
 888                   {
 889                     shift = 0;
 890                     mask = 0;
 891                   }
 892                 else if (code <= 0x7ff)
 893                   {
 894                     shift = 6;
 895                     mask = 0xc0;
 896                   }
 897                 else if (code <= 0xffff)
 898                   {
 899                     shift = 12;
 900                     mask = 0xe0;
 901                   }
 902                 else if (code <= 0x1fffff)
 903                   {
 904                     shift = 18;
 905                     mask = 0xf0;
 906                   }
 907                 else if (code <= 0x3ffffff)
 908                   {
 909                     shift = 24;
 910                     mask = 0xf8;
 911                   }
 912                 else if (code <= 0x7fffffff)
 913                   {
 914                     shift = 30;
 915                     mask = 0xfc;
 916                   }
 917                 else
 918                   {
 919                     code = '?';
 920                     shift = 0;
 921                     mask = 0;
 922                   }
 923
 924                 write_char (mask | (code >> shift));
 925
 926                 for (shift -= 6; shift >= 0; shift -= 6)
 927                   write_char (0x80 | (0x3f & (code >> shift)));
 928               }
 929               break;
 930
 931             case 's':
 932               p = va_arg (args, char *);
 933               if (p)
 934                 {
 935                   grub_size_t len = 0;
 936                   while (len < format2 && p[len])
 937                     len++;
 938
 939                   if (!rightfill && len < format1)
 940                     write_fill (zerofill, format1 - len);
 941
 942                   grub_size_t i;
 943                   for (i = 0; i < len; i++)
 944                     write_char (*p++);
 945
 946                   if (rightfill && len < format1)
 947                     write_fill (zerofill, format1 - len);
 948                 }
 949               else
 950                 write_str ("(null)");
 951
 952               break;
 953
 954             default:
 955               write_char (c);
 956               break;
 957             }
 958         }
 959     }
 960
 961   if (str)
 962     *str = '\0';
 963
 964   if (count && !str)
 965     grub_refresh ();
 966
 967   return count;
 968 }
 969
 970 int
 971 grub_sprintf (char *str, const char *fmt, ...)
 972 {
 973   va_list ap;
 974   int ret;
 975
 976   va_start (ap, fmt);
 977   ret = grub_vsprintf (str, fmt, ap);
 978   va_end (ap);
 979
 980   return ret;
 981 }
 982
 983 /* Convert UTF-16 to UTF-8.  */
 984 grub_uint8_t *
 985 grub_utf16_to_utf8 (grub_uint8_t *dest, grub_uint16_t *src,
 986                     grub_size_t size)
 987 {
 988   grub_uint32_t code_high = 0;
 989
 990   while (size--)
 991     {
 992       grub_uint32_t code = *src++;
 993
 994       if (code_high)
 995         {
 996           if (code >= 0xDC00 && code <= 0xDFFF)
 997             {
 998               /* Surrogate pair.  */
 999               code = ((code_high - 0xD800) << 12) + (code - 0xDC00) + 0x10000;
1000
1001               *dest++ = (code >> 18) | 0xF0;
1002               *dest++ = ((code >> 12) & 0x3F) | 0x80;
1003               *dest++ = ((code >> 6) & 0x3F) | 0x80;
1004               *dest++ = (code & 0x3F) | 0x80;
1005             }
1006           else
1007             {
1008               /* Error...  */
1009               *dest++ = '?';
1010             }
1011
1012           code_high = 0;
1013         }
1014       else
1015         {
1016           if (code <= 0x007F)
1017             *dest++ = code;
1018           else if (code <= 0x07FF)
1019             {
1020               *dest++ = (code >> 6) | 0xC0;
1021               *dest++ = (code & 0x3F) | 0x80;
1022             }
1023           else if (code >= 0xD800 && code <= 0xDBFF)
1024             {
1025               code_high = code;
1026               continue;
1027             }
1028           else if (code >= 0xDC00 && code <= 0xDFFF)
1029             {
1030               /* Error... */
1031               *dest++ = '?';
1032             }
1033           else
1034             {
1035               *dest++ = (code >> 12) | 0xE0;
1036               *dest++ = ((code >> 6) & 0x3F) | 0x80;
1037               *dest++ = (code & 0x3F) | 0x80;
1038             }
1039         }
1040     }
1041
1042   return dest;
1043 }
1044
1045 /* Convert a (possibly null-terminated) UTF-8 string of at most SRCSIZE
1046    bytes (if SRCSIZE is -1, it is ignored) in length to a UCS-4 string.
1047    Return the number of characters converted. DEST must be able to hold
1048    at least DESTSIZE characters. If an invalid sequence is found, return -1.
1049    If SRCEND is not NULL, then *SRCEND is set to the next byte after the
1050    last byte used in SRC.  */
1051 grub_ssize_t
1052 grub_utf8_to_ucs4 (grub_uint32_t *dest, grub_size_t destsize,
1053                    const grub_uint8_t *src, grub_size_t srcsize,
1054                    const grub_uint8_t **srcend)
1055 {
1056   grub_uint32_t *p = dest;
1057   int count = 0;
1058   grub_uint32_t code = 0;
1059
1060   if (srcend)
1061     *srcend = src;
1062
1063   while (srcsize && destsize)
1064     {
1065       grub_uint32_t c = *src++;
1066       if (srcsize != (grub_size_t)-1)
1067         srcsize--;
1068       if (count)
1069         {
1070           if ((c & 0xc0) != 0x80)
1071             {
1072               /* invalid */
1073               return -1;
1074             }
1075           else
1076             {
1077               code <<= 6;
1078               code |= (c & 0x3f);
1079               count--;
1080             }
1081         }
1082       else
1083         {
1084           if (c == 0)
1085             break;
1086
1087           if ((c & 0x80) == 0x00)
1088             code = c;
1089           else if ((c & 0xe0) == 0xc0)
1090             {
1091               count = 1;
1092               code = c & 0x1f;
1093             }
1094           else if ((c & 0xf0) == 0xe0)
1095             {
1096               count = 2;
1097               code = c & 0x0f;
1098             }
1099           else if ((c & 0xf8) == 0xf0)
1100             {
1101               count = 3;
1102               code = c & 0x07;
1103             }
1104           else if ((c & 0xfc) == 0xf8)
1105             {
1106               count = 4;
1107               code = c & 0x03;
1108             }
1109           else if ((c & 0xfe) == 0xfc)
1110             {
1111               count = 5;
1112               code = c & 0x01;
1113             }
1114           else
1115             return -1;
1116         }
1117
1118       if (count == 0)
1119         {
1120           *p++ = code;
1121           destsize--;
1122         }
1123     }
1124
1125   if (srcend)
1126     *srcend = src;
1127   return p - dest;
1128 }
1129
1130 /* Abort GRUB. This function does not return.  */
1131 void
1132 grub_abort (void)
1133 {
1134   if (grub_term_get_current_output ())
1135     {
1136       grub_printf ("\nAborted.");
1137
1138       if (grub_term_get_current_input ())
1139         {
1140           grub_printf (" Press any key to exit.");
1141           grub_getkey ();
1142         }
1143     }
1144
1145   grub_exit ();
1146 }
1147
1148 #ifndef APPLE_CC
1149 /* GCC emits references to abort().  */
1150 void abort (void) __attribute__ ((alias ("grub_abort")));
1151 #endif
1152
1153 #ifdef NEED_ENABLE_EXECUTE_STACK
1154 /* Some gcc versions generate a call to this function
1155    in trampolines for nested functions.  */
1156 void __enable_execute_stack (void *addr __attribute__ ((unused)))
1157 {
1158 }
1159 #endif
1160