shared: utf8 - support ucs4 -> utf8

[elogind.git] / src / shared / utf8.c

diff --git a/src/shared/utf8.c b/src/shared/utf8.c
index 67f6285eec81fc2df359ef62baf5cb4e646dfb47..ab57f4276b038734f6c65a6e39b41b954c90502f 100644 (file)
--- a/src/shared/utf8.c
+++ b/src/shared/utf8.c
@@ -263,22 +263,46 @@ char *ascii_is_valid(const char *str) {
         return (char*) str;
 }
 
-int utf8_encode_unichar(uint16_t c, char *p) {
-        uint8_t *t = (uint8_t*) p;
-        int d;
-
-        if (c < 0x80) {
-                t[0] = (uint8_t) c;
+/**
+ * utf8_encode_unichar() - Encode single UCS-4 character as UTF-8
+ * @out_utf8: output buffer of at least 4 bytes or NULL
+ * @g: UCS-4 character to encode
+ *
+ * This encodes a single UCS-4 character as UTF-8 and writes it into @out_utf8.
+ * The length of the character is returned. It is not zero-terminated! If the
+ * output buffer is NULL, only the length is returned.
+ *
+ * Returns: The length in bytes that the UTF-8 representation does or would
+ *          occupy.
+ */
+size_t utf8_encode_unichar(char *out_utf8, uint32_t g) {
+        if (g < (1 << 7)) {
+                if (out_utf8)
+                        out_utf8[0] = g & 0x7f;
                 return 1;
-        } else if (c < 0x800) {
-                t[0] = (uint8_t) (0xc0 | (c >> 6));
-                t[1] = (uint8_t) (0x80 | (c & 0x3f));
+        } else if (g < (1 << 11)) {
+                if (out_utf8) {
+                        out_utf8[0] = 0xc0 | ((g >> 6) & 0x1f);
+                        out_utf8[1] = 0x80 | (g & 0x3f);
+                }
                 return 2;
-        } else {
-                t[0] = (uint8_t) (0xe0 | (c >> 12));
-                t[1] = (uint8_t) (0x80 | ((c >> 6) & 0x3f));
-                t[2] = (uint8_t) (0x80 | (c & 0x3f));
+        } else if (g < (1 << 16)) {
+                if (out_utf8) {
+                        out_utf8[0] = 0xe0 | ((g >> 12) & 0x0f);
+                        out_utf8[1] = 0x80 | ((g >> 6) & 0x3f);
+                        out_utf8[2] = 0x80 | (g & 0x3f);
+                }
                 return 3;
+        } else if (g < (1 << 21)) {
+                if (out_utf8) {
+                        out_utf8[0] = 0xf0 | ((g >> 18) & 0x07);
+                        out_utf8[1] = 0x80 | ((g >> 12) & 0x3f);
+                        out_utf8[2] = 0x80 | ((g >> 6) & 0x3f);
+                        out_utf8[3] = 0x80 | (g & 0x3f);
+                }
+                return 4;
+        } else {
+                return 0;
         }
 }
 
@@ -291,7 +315,7 @@ char *utf16_to_utf8(const void *s, size_t length) {
                 return NULL;
 
         for (f = s, t = r; f < (const uint8_t*) s + length; f += 2)
-                t += utf8_encode_unichar((f[1] << 8) | f[0], t);
+                t += utf8_encode_unichar(t, (f[1] << 8) | f[0]);
 
         *t = 0;
         return r;