format: Trivial reorganisation

[pulseaudio] / src / pulse / utf8.c

diff --git a/src/pulse/utf8.c b/src/pulse/utf8.c
index 923e021df7eeace2d969a114f0d97ec551c62c2e..773a1f8383f4df998d5d552873aca72723d04f7d 100644 (file)
--- a/src/pulse/utf8.c
+++ b/src/pulse/utf8.c
@@ -1,5 +1,3 @@
-/* $Id$ */
-
 /***
   This file is part of PulseAudio.
 
@@ -50,7 +48,6 @@
 #include <config.h>
 #endif
 
-#include <assert.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <inttypes.h>
@@ -60,27 +57,31 @@
 #include <iconv.h>
 #endif
 
+#include <pulse/xmalloc.h>
+#include <pulsecore/macro.h>
+
 #include "utf8.h"
-#include "xmalloc.h"
 
 #define FILTER_CHAR '_'
 
-static inline int is_unicode_valid(uint32_t ch) {
+static inline pa_bool_t is_unicode_valid(uint32_t ch) {
+
     if (ch >= 0x110000) /* End of unicode space */
-        return 0;
+        return FALSE;
     if ((ch & 0xFFFFF800) == 0xD800) /* Reserved area for UTF-16 */
-        return 0;
+        return FALSE;
     if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) /* Reserved */
-        return 0;
+        return FALSE;
     if ((ch & 0xFFFE) == 0xFFFE) /* BOM (Byte Order Mark) */
-        return 0;
-    return 1;
+        return FALSE;
+
+    return TRUE;
 }
 
-static inline int is_continuation_char(uint8_t ch) {
+static inline pa_bool_t is_continuation_char(uint8_t ch) {
     if ((ch & 0xc0) != 0x80) /* 10xxxxxx */
-        return 0;
-    return 1;
+        return FALSE;
+    return TRUE;
 }
 
 static inline void merge_continuation_char(uint32_t *u_ch, uint8_t ch) {
@@ -95,6 +96,8 @@ static char* utf8_validate(const char *str, char *output) {
     int size;
     uint8_t *o;
 
+    pa_assert(str);
+
     o = (uint8_t*) output;
     for (p = (const uint8_t*) str; *p; p++) {
         if (*p < 128) {
@@ -106,21 +109,19 @@ static char* utf8_validate(const char *str, char *output) {
             if ((*p & 0xe0) == 0xc0) { /* 110xxxxx two-char seq. */
                 size = 2;
                 min = 128;
-                val = *p & 0x1e;
+                val = (uint32_t) (*p & 0x1e);
                 goto ONE_REMAINING;
             } else if ((*p & 0xf0) == 0xe0) { /* 1110xxxx three-char seq.*/
                 size = 3;
                 min = (1 << 11);
-                val = *p & 0x0f;
+                val = (uint32_t) (*p & 0x0f);
                 goto TWO_REMAINING;
             } else if ((*p & 0xf8) == 0xf0) { /* 11110xxx four-char seq */
                 size = 4;
                 min = (1 << 16);
-                val = *p & 0x07;
-            } else {
-                size = 1;
+                val = (uint32_t) (*p & 0x07);
+            } else
                 goto error;
-            }
 
             p++;
             if (!is_continuation_char(*p))
@@ -146,13 +147,10 @@ ONE_REMAINING:
                 goto error;
 
             if (o) {
-                memcpy(o, last, size);
-                o += size - 1;
+                memcpy(o, last, (size_t) size);
+                o += size;
             }
 
-            if (o)
-                o++;
-
             continue;
 
 error:
@@ -178,15 +176,15 @@ failure:
     return NULL;
 }
 
-const char* pa_utf8_valid (const char *str) {
+char* pa_utf8_valid (const char *str) {
     return utf8_validate(str, NULL);
 }
 
 char* pa_utf8_filter (const char *str) {
     char *new_str;
 
-    new_str = pa_xnew(char, strlen(str) + 1);
-
+    pa_assert(str);
+    new_str = pa_xmalloc(strlen(str) + 1);
     return utf8_validate(str, new_str);
 }
 
@@ -195,22 +193,24 @@ char* pa_utf8_filter (const char *str) {
 static char* iconv_simple(const char *str, const char *to, const char *from) {
     char *new_str;
     size_t len, inlen;
-
     iconv_t cd;
     ICONV_CONST char *inbuf;
     char *outbuf;
     size_t res, inbytes, outbytes;
 
+    pa_assert(str);
+    pa_assert(to);
+    pa_assert(from);
+
     cd = iconv_open(to, from);
     if (cd == (iconv_t)-1)
         return NULL;
 
     inlen = len = strlen(str) + 1;
     new_str = pa_xmalloc(len);
-    assert(new_str);
 
-    while (1) {
-        inbuf = (ICONV_CONST char*)str; /* Brain dead prototype for iconv() */
+    for (;;) {
+        inbuf = (ICONV_CONST char*) str; /* Brain dead prototype for iconv() */
         inbytes = inlen;
         outbuf = new_str;
         outbytes = len;
@@ -226,11 +226,10 @@ static char* iconv_simple(const char *str, const char *to, const char *from) {
             break;
         }
 
-        assert(inbytes != 0);
+        pa_assert(inbytes != 0);
 
         len += inbytes;
         new_str = pa_xrealloc(new_str, len);
-        assert(new_str);
     }
 
     iconv_close(cd);
@@ -249,11 +248,44 @@ char* pa_locale_to_utf8 (const char *str) {
 #else
 
 char* pa_utf8_to_locale (const char *str) {
-    return NULL;
+    pa_assert(str);
+
+    return pa_ascii_filter(str);
 }
 
 char* pa_locale_to_utf8 (const char *str) {
+    pa_assert(str);
+
+    if (pa_utf8_valid(str))
+        return pa_xstrdup(str);
+
     return NULL;
 }
 
 #endif
+
+char *pa_ascii_valid(const char *str) {
+    const char *p;
+    pa_assert(str);
+
+    for (p = str; *p; p++)
+        if ((unsigned char) *p >= 128)
+            return NULL;
+
+    return (char*) str;
+}
+
+char *pa_ascii_filter(const char *str) {
+    char *r, *s, *d;
+    pa_assert(str);
+
+    r = pa_xstrdup(str);
+
+    for (s = r, d = r; *s; s++)
+        if ((unsigned char) *s < 128)
+            *(d++) = *s;
+
+    *d = 0;
+
+    return r;
+}