Changes in common/str.c [0600976:28c39f3] in mainline

File:

• common/str.c (modified) (12 diffs)

common/str.c

@@ -156 +156 @@
 static inline int _char_continuation_bytes(char32_t c)
 {
-        if ((c & ~LO_MASK_32(7)) == 0)
-                return 0;
-
         if ((c & ~LO_MASK_32(11)) == 0)
                 return 1;
@@ -210 +207 @@
 char32_t str_decode(const char *str, size_t *offset, size_t size)
 {
-        if (*offset >= size)
+        if (*offset + 1 > size)
                 return 0;
 
@@ -226 +223 @@
         /* Determine code length */
 
-        int cbytes = _continuation_bytes(b0);
-        int b0_bits = 6 - cbytes;  /* Data bits in first byte */
-
-        if (cbytes < 0 || *offset + cbytes > size)
+        unsigned int cbytes = _continuation_bytes(b0);
+        unsigned int b0_bits = 6 - cbytes;  /* Data bits in first byte */
+
+        if (*offset + cbytes > size)
                 return U_SPECIAL;
 
@@ -235 +232 @@
 
         /* Decode continuation bytes */
-        for (int i = 0; i < cbytes; i++) {
-                uint8_t b = (uint8_t) str[*offset];
+        while (cbytes > 0) {
+                uint8_t b = (uint8_t) str[(*offset)++];
 
                 if (!_is_continuation_byte(b))
                         return U_SPECIAL;
 
-                (*offset)++;
-
                 /* Shift data bits to ch */
                 ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
-        }
-
-        /*
-         * Reject non-shortest form encodings.
-         * See https://www.unicode.org/versions/corrigendum1.html
-         */
-        if (cbytes != _char_continuation_bytes(ch))
-                return U_SPECIAL;
+                cbytes--;
+        }
 
         return ch;
@@ -356 +345 @@
 
 /* Convert in place any bytes that don't form a valid character into U_SPECIAL. */
-static void _sanitize_string(char *str, size_t n)
-{
-        uint8_t *b = (uint8_t *) str;
-
-        for (; *b && n > 0; b++, n--) {
-                int cont = _continuation_bytes(b[0]);
-                if (__builtin_expect(cont, 0) == 0)
+static void _repair_string(char *str, size_t n)
+{
+        for (; *str && n > 0; str++, n--) {
+                int cont = _continuation_bytes(*str);
+                if (cont == 0)
                         continue;
 
                 if (cont < 0 || n <= (size_t) cont) {
-                        b[0] = U_SPECIAL;
+                        *str = U_SPECIAL;
                         continue;
                 }
 
-                /* Check continuation bytes. */
                 for (int i = 1; i <= cont; i++) {
-                        if (!_is_continuation_byte(b[i])) {
-                                b[0] = U_SPECIAL;
+                        if (!_is_continuation_byte(str[i])) {
+                                *str = U_SPECIAL;
                                 continue;
                         }
-                }
-
-                /*
-                 * Check for non-shortest form encoding.
-                 * See https://www.unicode.org/versions/corrigendum1.html
-                 */
-
-                switch (cont) {
-                case 1:
-                        /* 0b110!!!!x 0b10xxxxxx */
-                        if (!(b[0] & 0b00011110))
-                                b[0] = U_SPECIAL;
-
-                        continue;
-                case 2:
-                        /* 0b1110!!!! 0b10!xxxxx 0b10xxxxxx */
-                        if (!(b[0] & 0b00001111) && !(b[1] & 0b00100000))
-                                b[0] = U_SPECIAL;
-
-                        continue;
-                case 3:
-                        /* 0b11110!!! 0b10!!xxxx 0b10xxxxxx 0b10xxxxxx */
-                        if (!(b[0] & 0b00000111) && !(b[1] & 0b00110000))
-                                b[0] = U_SPECIAL;
-
-                        continue;
                 }
         }
@@ -921 +881 @@
 static void _str_cpyn(char *dest, size_t size, const char *src)
 {
-        assert(dest && src && size);
-
-        if (!dest || !src || !size)
-                return;
-
-        if (size == STR_NO_LIMIT)
-                return _str_cpy(dest, src);
-
         char *dest_top = dest + size - 1;
-        assert(size == 1 || dest < dest_top);
 
         while (*src && dest < dest_top)
@@ -956 +907 @@
         assert(src != NULL);
         assert(dest != NULL);
-        assert(size == STR_NO_LIMIT || dest + size > dest);
 
         /* Copy data. */
@@ -962 +912 @@
 
         /* In-place translate invalid bytes to U_SPECIAL. */
-        _sanitize_string(dest, size);
+        _repair_string(dest, size);
 }
 
@@ -991 +941 @@
 
         /* In-place translate invalid bytes to U_SPECIAL. */
-        _sanitize_string(dest, size);
+        _repair_string(dest, size);
 }
 
@@ -1010 +960 @@
         assert(dest != NULL);
         assert(size > 0);
-        assert(size == STR_NO_LIMIT || dest + size > dest);
 
         size_t dstr_size = _str_nsize(dest, size);
-        if (dstr_size < size) {
-                _str_cpyn(dest + dstr_size, size - dstr_size, src);
-                _sanitize_string(dest + dstr_size, size - dstr_size);
-        }
+        _str_cpyn(dest + dstr_size, size - dstr_size, src);
+        _repair_string(dest + dstr_size, size - dstr_size);
 }
 
@@ -1593 +1540 @@
                 return NULL;
 
-        memcpy(dest, src, size);
-        _sanitize_string(dest, size);
+        _str_cpy(dest, src);
+        _repair_string(dest, size);
         return dest;
 }
@@ -1620 +1567 @@
 char *str_ndup(const char *src, size_t n)
 {
-        size_t size = _str_nsize(src, n);
-
-        char *dest = malloc(size + 1);
+        size_t size = _str_nsize(src, n) + 1;
+
+        char *dest = malloc(size);
         if (!dest)
                 return NULL;
 
-        memcpy(dest, src, size);
-        _sanitize_string(dest, size);
-        dest[size] = 0;
+        _str_cpyn(dest, size, src);
+        _repair_string(dest, size);
         return dest;
 }