yarp 0.8.0 → 0.10.0

data/src/enc/yp_big5.c

@@ -1,69 +1,42 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_big5_codepoint_t;
-
-static yp_big5_codepoint_t
-yp_big5_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_big5_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
-    if ((n > 1) && (uc[0] >= 0xA1 && uc[0] <= 0xFE) && (uc[1] >= 0x40 && uc[1] <= 0xFE)) {
-        *width = 2;
-        return (yp_big5_codepoint_t) (uc[0] << 8 | uc[1]);
+    if ((n > 1) && (b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xFE)) {
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_big5_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_big5_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_big5_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_big5_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_big5_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_big5_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_big5_codepoint_t codepoint = yp_big5_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_big5_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_big5_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return false;
     }

data/src/enc/yp_euc_jp.c

@@ -1,75 +1,48 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_euc_jp_codepoint_t;
-
-static yp_euc_jp_codepoint_t
-yp_euc_jp_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_euc_jp_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
         (
-            ((uc[0] == 0x8E) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) ||
-            ((uc[0] >= 0xA1 && uc[0] <= 0xFE) && (uc[1] >= 0xA1 && uc[1] <= 0xFE))
+            ((b[0] == 0x8E) && (b[1] >= 0xA1 && b[1] <= 0xFE)) ||
+            ((b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0xA1 && b[1] <= 0xFE))
         )
     ) {
-        *width = 2;
-        return (yp_euc_jp_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_euc_jp_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_euc_jp_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_euc_jp_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_euc_jp_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_euc_jp_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_euc_jp_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_euc_jp_codepoint_t codepoint = yp_euc_jp_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_euc_jp_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return 0;
     }

data/src/enc/yp_gbk.c

@@ -1,78 +1,51 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_gbk_codepoint_t;
-
-static yp_gbk_codepoint_t
-yp_gbk_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_gbk_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
         (
-            ((uc[0] >= 0xA1 && uc[0] <= 0xA9) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) || // GBK/1
-            ((uc[0] >= 0xB0 && uc[0] <= 0xF7) && (uc[1] >= 0xA1 && uc[1] <= 0xFE)) || // GBK/2
-            ((uc[0] >= 0x81 && uc[0] <= 0xA0) && (uc[1] >= 0x40 && uc[1] <= 0xFE) && (uc[1] != 0x7F)) || // GBK/3
-            ((uc[0] >= 0xAA && uc[0] <= 0xFE) && (uc[1] >= 0x40 && uc[1] <= 0xA0) && (uc[1] != 0x7F)) || // GBK/4
-            ((uc[0] >= 0xA8 && uc[0] <= 0xA9) && (uc[1] >= 0x40 && uc[1] <= 0xA0) && (uc[1] != 0x7F)) // GBK/5
+            ((b[0] >= 0xA1 && b[0] <= 0xA9) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/1
+            ((b[0] >= 0xB0 && b[0] <= 0xF7) && (b[1] >= 0xA1 && b[1] <= 0xFE)) || // GBK/2
+            ((b[0] >= 0x81 && b[0] <= 0xA0) && (b[1] >= 0x40 && b[1] <= 0xFE) && (b[1] != 0x7F)) || // GBK/3
+            ((b[0] >= 0xAA && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) || // GBK/4
+            ((b[0] >= 0xA8 && b[0] <= 0xA9) && (b[1] >= 0x40 && b[1] <= 0xA0) && (b[1] != 0x7F)) // GBK/5
         )
     ) {
-        *width = 2;
-        return (yp_gbk_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_gbk_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_gbk_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_gbk_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_gbk_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_gbk_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_gbk_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_gbk_codepoint_t codepoint = yp_gbk_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_gbk_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_gbk_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return false;
     }

data/src/enc/yp_shift_jis.c

@@ -1,73 +1,46 @@
 #include "yarp/enc/yp_encoding.h"
 
-typedef uint16_t yp_shift_jis_codepoint_t;
-
-static yp_shift_jis_codepoint_t
-yp_shift_jis_codepoint(const char *c, ptrdiff_t n, size_t *width) {
-    const unsigned char *uc = (const unsigned char *) c;
-
+static size_t
+yp_encoding_shift_jis_char_width(const uint8_t *b, ptrdiff_t n) {
     // These are the single byte characters.
-    if (*uc < 0x80 || (*uc >= 0xA1 && *uc <= 0xDF)) {
-        *width = 1;
-        return *uc;
+    if (*b < 0x80 || (*b >= 0xA1 && *b <= 0xDF)) {
+        return 1;
     }
 
     // These are the double byte characters.
     if (
         (n > 1) &&
-        ((uc[0] >= 0x81 && uc[0] <= 0x9F) || (uc[0] >= 0xE0 && uc[0] <= 0xFC)) &&
-        (uc[1] >= 0x40 && uc[1] <= 0xFC)
+        ((b[0] >= 0x81 && b[0] <= 0x9F) || (b[0] >= 0xE0 && b[0] <= 0xFC)) &&
+        (b[1] >= 0x40 && b[1] <= 0xFC)
     ) {
-        *width = 2;
-        return (yp_shift_jis_codepoint_t) (uc[0] << 8 | uc[1]);
+        return 2;
     }
 
-    *width = 0;
     return 0;
 }
 
 static size_t
-yp_encoding_shift_jis_char_width(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint(c, n, &width);
-
-    return width;
-}
-
-static size_t
-yp_encoding_shift_jis_alpha_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alpha_char(&value, n);
+yp_encoding_shift_jis_alpha_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alpha_char(b, n);
     } else {
         return 0;
     }
 }
 
 static size_t
-yp_encoding_shift_jis_alnum_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_alnum_char(&value, n);
+yp_encoding_shift_jis_alnum_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_alnum_char(b, n);
     } else {
         return 0;
     }
 }
 
 static bool
-yp_encoding_shift_jis_isupper_char(const char *c, ptrdiff_t n) {
-    size_t width;
-    yp_shift_jis_codepoint_t codepoint = yp_shift_jis_codepoint(c, n, &width);
-
-    if (width == 1) {
-        const char value = (const char) codepoint;
-        return yp_encoding_ascii_isupper_char(&value, n);
+yp_encoding_shift_jis_isupper_char(const uint8_t *b, ptrdiff_t n) {
+    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
+        return yp_encoding_ascii_isupper_char(b, n);
     } else {
         return 0;
     }

data/src/enc/yp_tables.c

@@ -2,7 +2,7 @@
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ASCII character.
-static unsigned char yp_encoding_ascii_table[256] = {
+static uint8_t yp_encoding_ascii_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -24,7 +24,7 @@ static unsigned char yp_encoding_ascii_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-1 character.
-static unsigned char yp_encoding_iso_8859_1_table[256] = {
+static uint8_t yp_encoding_iso_8859_1_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -46,7 +46,7 @@ static unsigned char yp_encoding_iso_8859_1_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-2 character.
-static unsigned char yp_encoding_iso_8859_2_table[256] = {
+static uint8_t yp_encoding_iso_8859_2_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -68,7 +68,7 @@ static unsigned char yp_encoding_iso_8859_2_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-3 character.
-static unsigned char yp_encoding_iso_8859_3_table[256] = {
+static uint8_t yp_encoding_iso_8859_3_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -90,7 +90,7 @@ static unsigned char yp_encoding_iso_8859_3_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-4 character.
-static unsigned char yp_encoding_iso_8859_4_table[256] = {
+static uint8_t yp_encoding_iso_8859_4_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -112,7 +112,7 @@ static unsigned char yp_encoding_iso_8859_4_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-5 character.
-static unsigned char yp_encoding_iso_8859_5_table[256] = {
+static uint8_t yp_encoding_iso_8859_5_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -134,7 +134,7 @@ static unsigned char yp_encoding_iso_8859_5_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-6 character.
-static unsigned char yp_encoding_iso_8859_6_table[256] = {
+static uint8_t yp_encoding_iso_8859_6_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -156,7 +156,7 @@ static unsigned char yp_encoding_iso_8859_6_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-7 character.
-static unsigned char yp_encoding_iso_8859_7_table[256] = {
+static uint8_t yp_encoding_iso_8859_7_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -178,7 +178,7 @@ static unsigned char yp_encoding_iso_8859_7_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-8 character.
-static unsigned char yp_encoding_iso_8859_8_table[256] = {
+static uint8_t yp_encoding_iso_8859_8_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -200,7 +200,7 @@ static unsigned char yp_encoding_iso_8859_8_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-9 character.
-static unsigned char yp_encoding_iso_8859_9_table[256] = {
+static uint8_t yp_encoding_iso_8859_9_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -222,7 +222,7 @@ static unsigned char yp_encoding_iso_8859_9_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-10 character.
-static unsigned char yp_encoding_iso_8859_10_table[256] = {
+static uint8_t yp_encoding_iso_8859_10_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -244,7 +244,7 @@ static unsigned char yp_encoding_iso_8859_10_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-11 character.
-static unsigned char yp_encoding_iso_8859_11_table[256] = {
+static uint8_t yp_encoding_iso_8859_11_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -266,7 +266,7 @@ static unsigned char yp_encoding_iso_8859_11_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-13 character.
-static unsigned char yp_encoding_iso_8859_13_table[256] = {
+static uint8_t yp_encoding_iso_8859_13_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -288,7 +288,7 @@ static unsigned char yp_encoding_iso_8859_13_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-14 character.
-static unsigned char yp_encoding_iso_8859_14_table[256] = {
+static uint8_t yp_encoding_iso_8859_14_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -310,7 +310,7 @@ static unsigned char yp_encoding_iso_8859_14_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-15 character.
-static unsigned char yp_encoding_iso_8859_15_table[256] = {
+static uint8_t yp_encoding_iso_8859_15_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -332,7 +332,7 @@ static unsigned char yp_encoding_iso_8859_15_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding ISO-8859-16 character.
-static unsigned char yp_encoding_iso_8859_16_table[256] = {
+static uint8_t yp_encoding_iso_8859_16_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -354,7 +354,7 @@ static unsigned char yp_encoding_iso_8859_16_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding KOI8-R character.
-static unsigned char yp_encoding_koi8_r_table[256] = {
+static uint8_t yp_encoding_koi8_r_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -376,7 +376,7 @@ static unsigned char yp_encoding_koi8_r_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding windows-1251 character.
-static unsigned char yp_encoding_windows_1251_table[256] = {
+static uint8_t yp_encoding_windows_1251_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -398,7 +398,7 @@ static unsigned char yp_encoding_windows_1251_table[256] = {
 
 // Each element of the following table contains a bitfield that indicates a
 // piece of information about the corresponding windows-1252 character.
-static unsigned char yp_encoding_windows_1252_table[256] = {
+static uint8_t yp_encoding_windows_1252_table[256] = {
 //  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
@@ -419,34 +419,32 @@ static unsigned char yp_encoding_windows_1252_table[256] = {
 };
 
 static size_t
-yp_encoding_ascii_char_width(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    const unsigned char v = (const unsigned char) *c;
-    return v < 0x80 ? 1 : 0;
+yp_encoding_ascii_char_width(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+    return *b < 0x80 ? 1 : 0;
 }
 
 size_t
-yp_encoding_ascii_alpha_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    return (yp_encoding_ascii_table[(const unsigned char) *c] & YP_ENCODING_ALPHABETIC_BIT);
+yp_encoding_ascii_alpha_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+    return (yp_encoding_ascii_table[*b] & YP_ENCODING_ALPHABETIC_BIT);
 }
 
 size_t
-yp_encoding_ascii_alnum_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    return (yp_encoding_ascii_table[(const unsigned char) *c] & YP_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0;
+yp_encoding_ascii_alnum_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+    return (yp_encoding_ascii_table[*b] & YP_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0;
 }
 
 bool
-yp_encoding_ascii_isupper_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    return (yp_encoding_ascii_table[(const unsigned char) *c] & YP_ENCODING_UPPERCASE_BIT);
+yp_encoding_ascii_isupper_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+    return (yp_encoding_ascii_table[*b] & YP_ENCODING_UPPERCASE_BIT);
 }
 
 static size_t
-yp_encoding_koi8_r_char_width(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
-    const unsigned char v = (const unsigned char) *c;
-    return ((v >= 0x20 && v <= 0x7E) || (v >= 0x80)) ? 1 : 0;
+yp_encoding_koi8_r_char_width(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+    return ((*b >= 0x20 && *b <= 0x7E) || (*b >= 0x80)) ? 1 : 0;
 }
 
 static size_t
-yp_encoding_single_char_width(YP_ATTRIBUTE_UNUSED const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
+yp_encoding_single_char_width(YP_ATTRIBUTE_UNUSED const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {
     return 1;
 }
 
@@ -469,14 +467,14 @@ yp_encoding_t yp_encoding_ascii_8bit = {
 };
 
 #define YP_ENCODING_TABLE(s, i, w) \
-    static size_t yp_encoding_ ##i ## _alpha_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
-        return (yp_encoding_ ##i ## _table[(const unsigned char) *c] & YP_ENCODING_ALPHABETIC_BIT);           \
+    static size_t yp_encoding_ ##i ## _alpha_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
+        return (yp_encoding_ ##i ## _table[*b] & YP_ENCODING_ALPHABETIC_BIT);           \
     }                                                                                                         \
-    static size_t yp_encoding_ ##i ## _alnum_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
-        return (yp_encoding_ ##i ## _table[(const unsigned char) *c] & YP_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0; \
+    static size_t yp_encoding_ ##i ## _alnum_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
+        return (yp_encoding_ ##i ## _table[*b] & YP_ENCODING_ALPHANUMERIC_BIT) ? 1 : 0; \
     }                                                                                                         \
-    static bool yp_encoding_ ##i ## _isupper_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
-        return (yp_encoding_ ##i ## _table[(const unsigned char) *c] & YP_ENCODING_UPPERCASE_BIT);            \
+    static bool yp_encoding_ ##i ## _isupper_char(const uint8_t *b, YP_ATTRIBUTE_UNUSED ptrdiff_t n) {           \
+        return (yp_encoding_ ##i ## _table[*b] & YP_ENCODING_UPPERCASE_BIT);            \
     }                                                                                                         \
     yp_encoding_t yp_encoding_ ##i = {                                                                        \
         .name = s,                                                                                            \