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