qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

unicode.c (4588B)

      1 /*
      2  * Dealing with Unicode
      3  *
      4  * Copyright (C) 2013 Red Hat, Inc.
      5  *
      6  * Authors:
      7  *  Markus Armbruster <armbru@redhat.com>
      8  *
      9  * This work is licensed under the terms of the GNU GPL, version 2 or
     10  * later.  See the COPYING file in the top-level directory.
     11  */
     12 
     13 #include "qemu/osdep.h"
     14 #include "qemu/unicode.h"
     15 
     16 static bool is_valid_codepoint(int codepoint)
     17 {
     18     if (codepoint > 0x10FFFFu) {
     19         return false;            /* beyond Unicode range */
     20     }
     21     if ((codepoint >= 0xFDD0 && codepoint <= 0xFDEF)
     22         || (codepoint & 0xFFFE) == 0xFFFE) {
     23         return false;            /* noncharacter */
     24     }
     25     if (codepoint >= 0xD800 && codepoint <= 0xDFFF) {
     26         return false;            /* surrogate code point */
     27     }
     28     return true;
     29 }
     30 
     31 /**
     32  * mod_utf8_codepoint:
     33  * @s: string encoded in modified UTF-8
     34  * @n: maximum number of bytes to read from @s, if less than 6
     35  * @end: set to end of sequence on return
     36  *
     37  * Convert the modified UTF-8 sequence at the start of @s.  Modified
     38  * UTF-8 is exactly like UTF-8, except U+0000 is encoded as
     39  * "\xC0\x80".
     40  *
     41  * If @n is zero or @s points to a zero byte, the sequence is invalid,
     42  * and @end is set to @s.
     43  *
     44  * If @s points to an impossible byte (0xFE or 0xFF) or a continuation
     45  * byte, the sequence is invalid, and @end is set to @s + 1
     46  *
     47  * Else, the first byte determines how many continuation bytes are
     48  * expected.  If there are fewer, the sequence is invalid, and @end is
     49  * set to @s + 1 + actual number of continuation bytes.  Else, the
     50  * sequence is well-formed, and @end is set to @s + 1 + expected
     51  * number of continuation bytes.
     52  *
     53  * A well-formed sequence is valid unless it encodes a codepoint
     54  * outside the Unicode range U+0000..U+10FFFF, one of Unicode's 66
     55  * noncharacters, a surrogate codepoint, or is overlong.  Except the
     56  * overlong sequence "\xC0\x80" is valid.
     57  *
     58  * Conversion succeeds if and only if the sequence is valid.
     59  *
     60  * Returns: the Unicode codepoint on success, -1 on failure.
     61  */
     62 int mod_utf8_codepoint(const char *s, size_t n, char **end)
     63 {
     64     static int min_cp[5] = { 0x80, 0x800, 0x10000, 0x200000, 0x4000000 };
     65     const unsigned char *p;
     66     unsigned byte, mask, len, i;
     67     int cp;
     68 
     69     if (n == 0 || *s == 0) {
     70         /* empty sequence */
     71         *end = (char *)s;
     72         return -1;
     73     }
     74 
     75     p = (const unsigned char *)s;
     76     byte = *p++;
     77     if (byte < 0x80) {
     78         cp = byte;              /* one byte sequence */
     79     } else if (byte >= 0xFE) {
     80         cp = -1;                /* impossible bytes 0xFE, 0xFF */
     81     } else if ((byte & 0x40) == 0) {
     82         cp = -1;                /* unexpected continuation byte */
     83     } else {
     84         /* multi-byte sequence */
     85         len = 0;
     86         for (mask = 0x80; byte & mask; mask >>= 1) {
     87             len++;
     88         }
     89         assert(len > 1 && len < 7);
     90         cp = byte & (mask - 1);
     91         for (i = 1; i < len; i++) {
     92             byte = i < n ? *p : 0;
     93             if ((byte & 0xC0) != 0x80) {
     94                 cp = -1;        /* continuation byte missing */
     95                 goto out;
     96             }
     97             p++;
     98             cp <<= 6;
     99             cp |= byte & 0x3F;
    100         }
    101         if (!is_valid_codepoint(cp)) {
    102             cp = -1;
    103         } else if (cp < min_cp[len - 2] && !(cp == 0 && len == 2)) {
    104             cp = -1;            /* overlong, not \xC0\x80 */
    105         }
    106     }
    107 
    108 out:
    109     *end = (char *)p;
    110     return cp;
    111 }
    112 
    113 /**
    114  * mod_utf8_encode:
    115  * @buf: Destination buffer
    116  * @bufsz: size of @buf, at least 5.
    117  * @codepoint: Unicode codepoint to encode
    118  *
    119  * Convert Unicode codepoint @codepoint to modified UTF-8.
    120  *
    121  * Returns: the length of the UTF-8 sequence on success, -1 when
    122  * @codepoint is invalid.
    123  */
    124 ssize_t mod_utf8_encode(char buf[], size_t bufsz, int codepoint)
    125 {
    126     assert(bufsz >= 5);
    127 
    128     if (!is_valid_codepoint(codepoint)) {
    129         return -1;
    130     }
    131 
    132     if (codepoint > 0 && codepoint <= 0x7F) {
    133         buf[0] = codepoint & 0x7F;
    134         buf[1] = 0;
    135         return 1;
    136     }
    137     if (codepoint <= 0x7FF) {
    138         buf[0] = 0xC0 | ((codepoint >> 6) & 0x1F);
    139         buf[1] = 0x80 | (codepoint & 0x3F);
    140         buf[2] = 0;
    141         return 2;
    142     }
    143     if (codepoint <= 0xFFFF) {
    144         buf[0] = 0xE0 | ((codepoint >> 12) & 0x0F);
    145         buf[1] = 0x80 | ((codepoint >> 6) & 0x3F);
    146         buf[2] = 0x80 | (codepoint & 0x3F);
    147         buf[3] = 0;
    148         return 3;
    149     }
    150     buf[0] = 0xF0 | ((codepoint >> 18) & 0x07);
    151     buf[1] = 0x80 | ((codepoint >> 12) & 0x3F);
    152     buf[2] = 0x80 | ((codepoint >> 6) & 0x3F);
    153     buf[3] = 0x80 | (codepoint & 0x3F);
    154     buf[4] = 0;
    155     return 4;
    156 }