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