text: /*
   * Dealing with Unicode
   *
   * Copyright (C) 2013 Red Hat, Inc.
   *
   * Authors:
   *  Markus Armbruster <armbru@redhat.com>
   *
   * This work is licensed under the terms of the GNU GPL, version 2 or
   * later.  See the COPYING file in the top-level directory.
   */
  
  #include "qemu/osdep.h"
  #include "qemu/unicode.h"
  
  /**
   * mod_utf8_codepoint:
   * @s: string encoded in modified UTF-8
   * @n: maximum number of bytes to read from @s, if less than 6
   * @end: set to end of sequence on return
   *
   * Convert the modified UTF-8 sequence at the start of @s.  Modified
   * UTF-8 is exactly like UTF-8, except U+0000 is encoded as
   * "\xC0\x80".
   *
   * If @n is zero or @s points to a zero byte, the sequence is invalid,
   * and @end is set to @s.
   *
   * If @s points to an impossible byte (0xFE or 0xFF) or a continuation
   * byte, the sequence is invalid, and @end is set to @s + 1
   *
   * Else, the first byte determines how many continuation bytes are
   * expected.  If there are fewer, the sequence is invalid, and @end is
   * set to @s + 1 + actual number of continuation bytes.  Else, the
   * sequence is well-formed, and @end is set to @s + 1 + expected
   * number of continuation bytes.
   *
   * A well-formed sequence is valid unless it encodes a codepoint
   * outside the Unicode range U+0000..U+10FFFF, one of Unicode's 66
   * noncharacters, a surrogate codepoint, or is overlong.  Except the
   * overlong sequence "\xC0\x80" is valid.
   *
   * Conversion succeeds if and only if the sequence is valid.
   *
   * Returns: the Unicode codepoint on success, -1 on failure.
   */
  int mod_utf8_codepoint(const char *s, size_t n, char **end)
  {
      static int min_cp[5] = { 0x80, 0x800, 0x10000, 0x200000, 0x4000000 };
      const unsigned char *p;
      unsigned byte, mask, len, i;
      int cp;
  
      if (n == 0 || *s == 0) {
          /* empty sequence */
          *end = (char *)s;
          return -1;
      }
  
      p = (const unsigned char *)s;
      byte = *p++;
      if (byte < 0x80) {
          cp = byte;              /* one byte sequence */
      } else if (byte >= 0xFE) {
          cp = -1;                /* impossible bytes 0xFE, 0xFF */
      } else if ((byte & 0x40) == 0) {
          cp = -1;                /* unexpected continuation byte */
      } else {
          /* multi-byte sequence */
          len = 0;
          for (mask = 0x80; byte & mask; mask >>= 1) {
              len++;
          }
          assert(len > 1 && len < 7);
          cp = byte & (mask - 1);
          for (i = 1; i < len; i++) {
              byte = i < n ? *p : 0;
              if ((byte & 0xC0) != 0x80) {
                  cp = -1;        /* continuation byte missing */
                  goto out;
              }
              p++;
              cp <<= 6;
              cp |= byte & 0x3F;
          }
          if (cp > 0x10FFFF) {
              cp = -1;            /* beyond Unicode range */
          } else if ((cp >= 0xFDD0 && cp <= 0xFDEF)
                     || (cp & 0xFFFE) == 0xFFFE) {
              cp = -1;            /* noncharacter */
          } else if (cp >= 0xD800 && cp <= 0xDFFF) {
              cp = -1;            /* surrogate code point */
          } else if (cp < min_cp[len - 2] && !(cp == 0 && len == 2)) {
              cp = -1;            /* overlong, not \xC0\x80 */
          }
      }
  
  out:
      *end = (char *)p;
      return cp;
  }
  