From 2bb4c7e384c31de4727f1330da3f4de2f0bb7784 Mon Sep 17 00:00:00 2001
From: Tom Gundersen <teg@jklm.no>
Date: Mon, 22 Dec 2014 00:58:26 +0100
Subject: shared: utf8 - support ucs4 -> utf8

Originally we only supported ucs2, so move the ucs4 version from libsystemd-terminal to shared
and use that everywhere.
---
 src/shared/json.c |  2 +-
 src/shared/utf8.c | 51 ++++++++++++++++++++++++++++++++++++++-------------
 src/shared/utf8.h |  2 +-
 3 files changed, 40 insertions(+), 15 deletions(-)

(limited to 'src/shared')

diff --git a/src/shared/json.c b/src/shared/json.c
index f1495e99c8..47f801c858 100644
--- a/src/shared/json.c
+++ b/src/shared/json.c
@@ -150,7 +150,7 @@ static int json_parse_string(const char **p, char **ret) {
                                 if (!GREEDY_REALLOC(s, allocated, n + 4))
                                         return -ENOMEM;
 
-                                n += utf8_encode_unichar(x, s + n);
+                                n += utf8_encode_unichar(s + n, x);
                                 c += 5;
                                 continue;
                         } else
diff --git a/src/shared/utf8.c b/src/shared/utf8.c
index 03a0abe44b..ab57f4276b 100644
--- a/src/shared/utf8.c
+++ b/src/shared/utf8.c
@@ -263,21 +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;
-
-        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;
         }
 }
 
@@ -290,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;
diff --git a/src/shared/utf8.h b/src/shared/utf8.h
index dcf8588d32..3d5a4c3a9c 100644
--- a/src/shared/utf8.h
+++ b/src/shared/utf8.h
@@ -36,7 +36,7 @@ bool utf8_is_printable_newline(const char* str, size_t length, bool newline) _pu
 char *utf8_escape_invalid(const char *s);
 char *utf8_escape_non_printable(const char *str);
 
-int utf8_encode_unichar(uint16_t c, char *p);
+size_t utf8_encode_unichar(char *out_utf8, uint32_t g);
 char *utf16_to_utf8(const void *s, size_t length);
 
 int utf8_encoded_valid_unichar(const char *str);
-- 
cgit v1.2.3-54-g00ecf