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