u 0.5.0 → 1.0.0

data/ext/u/u_normalized.c

@@ -0,0 +1,28 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "u.h"
+
+enum u_normalized
+u_normalized(const char *u, size_t n, enum u_normalization_form form)
+{
+        enum u_canonical_combining_class pcc = 0;
+        enum u_normalized r = U_NORMALIZED_YES;
+        for (const char *p = u, *end = u + n; p < end; ) {
+                uint32_t c = u_decode(&p, p, end);
+                enum u_canonical_combining_class cc = u_char_canonical_combining_class(c);
+                if (pcc > cc && cc != 0)
+                        return U_NORMALIZED_NO;
+                switch (u_char_normalized(c, form)) {
+                case U_NORMALIZED_NO:
+                        return U_NORMALIZED_NO;
+                case U_NORMALIZED_MAYBE:
+                        r = U_NORMALIZED_MAYBE;
+                        break;
+                case U_NORMALIZED_YES:
+                        break;
+                }
+                pcc = cc;
+        }
+        return r;
+}

data/ext/u/u_offset_to_pointer.c

@@ -0,0 +1,62 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+#include "private.h"
+
+/* {{{1
+ * Convert an integer offset to a pointer within ‘str’.
+ *
+ */
+char *
+u_offset_to_pointer(const char *str, long offset)
+{
+	const char *p = str;
+
+        if (offset > 0) {
+                while (offset-- > 0)
+                        p = u_next(p);
+        } else {
+                while (offset != 0) {
+                        const char *base = p;
+                        p += offset;
+                        while ((*p & 0xc0) == 0x80)
+                                p--;
+
+                        offset += u_pointer_to_offset(p, base);
+                 }
+        }
+
+	return (char *)p;
+}
+
+char *
+u_offset_to_pointer_n(const char *str, long offset, size_t n)
+{
+	const char *p = str;
+
+        if (offset > 0) {
+                const char *end = p + n;
+                while (p < end && offset-- > 0)
+                        p = u_next(p);
+
+                if (offset > 0)
+                        return NULL;
+        } else {
+                const char *end = p - n;
+                while (offset != 0) {
+                        const char *base = p;
+                        p += offset;
+                        while (p >= end && (*p & 0xc0) == 0x80)
+                                p--;
+
+                        if (p < end)
+                                return NULL;
+
+                        offset += u_pointer_to_offset(p, base);
+                 }
+        }
+
+	return (char *)p;
+}

data/ext/u/u_pointer_to_offset.c

@@ -0,0 +1,23 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+#include "private.h"
+
+
+/* {{{1
+ * Convert a pointer to an integer offset within ‘str’.
+ */
+long
+u_pointer_to_offset(const char *str, const char *pos)
+{
+        if (pos < str)
+                return -u_pointer_to_offset(pos, str);
+
+	long offset = 0;
+	for (const char *p = str; p < pos; p = u_next(p))
+		offset++;
+
+	return offset;
+}

data/ext/u/u_recode.c

@@ -0,0 +1,73 @@
+#include "extconf.h"
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "u.h"
+
+#ifdef HAVE_ICONV
+#  include <iconv.h>
+#  include <limits.h>
+#endif
+
+size_t
+u_recode(char *result, size_t m, const char *string, size_t n,
+         const char *codeset)
+{
+        iconv_t cd = iconv_open(codeset, "UTF-8");
+        if (cd == (iconv_t)-1)
+                return 0;
+
+        bool done = false;
+        bool failed = false;
+        bool final = false;
+        bool too_big = false;
+        char *p = (char *)string;
+        size_t p_left = n;
+        // We need to align the buffer.
+        union { unsigned int align; char buffer[4096]; } b;
+        char *base = m > 0 ? result : b.buffer;
+        char *q = base;
+        size_t q_left = m > 0 ? m : sizeof(b.buffer);
+        size_t written = 0;
+        while (!done && !failed) {
+                size_t err = final ?
+                        iconv(cd, NULL, NULL, &q, &q_left) :
+                        iconv(cd, &p, &p_left, &q, &q_left);
+                if (err == (size_t)-1) {
+                        switch (errno) {
+                        case EINVAL:
+                                done = true;
+                                break;
+                        case E2BIG:
+                                written += q - base;
+                                if (!too_big) {
+                                        too_big = true;
+                                        base = b.buffer;
+                                }
+                                q = base;
+                                q_left = sizeof(b.buffer);
+                                errno = 0;
+                                break;
+                        default:
+                                failed = true;
+                                break;
+                        }
+                } else {
+                        if (!final)
+                                final = true;
+                        else
+                                done = true;
+                }
+        }
+        *q = '\0';
+
+        int saved_errno = errno;
+        if (iconv_close(cd) < 0 && failed)
+                errno = saved_errno;
+
+        return written + (q - base);
+}

data/ext/u/u_reverse.c

@@ -0,0 +1,21 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "u.h"
+#include "private.h"
+#include "output.h"
+
+
+size_t
+u_reverse(char *result, size_t m, const char *string, size_t n)
+{
+	assert(string != NULL);
+        assert(result != NULL || m == 0);
+        struct output output = OUTPUT_INIT(result, m);
+        for (const char *p = string + n; p > string; )
+                output_char(&output, u_decode_r(&p, string, p));
+        return output_finalize(&output);
+}

data/ext/u/u_rindex.c

@@ -0,0 +1,132 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "u.h"
+#include "private.h"
+
+/*
+ * Retrieve the index/offset of the right-most occurence of NEEDLE in
+ * HAYSTACK, or -1 if it doesn’t exist.
+ */
+static U_PURE size_t
+str_rindex(const char *haystack, const char *needle)
+{
+	assert(haystack != NULL);
+	assert(needle != NULL);
+
+	size_t needle_n = strlen(needle);
+	size_t haystack_n = strlen(haystack);
+
+	if (needle_n == 0)
+		return haystack_n;
+
+	if (haystack_n < needle_n)
+		return -1;
+
+	for (const char *p = haystack + haystack_n - needle_n; p >= haystack; p--) {
+		size_t i;
+
+		for (i = 0; i < needle_n; i++) {
+			if (p[i] != needle[i])
+				break;
+		}
+
+		if (i == needle_n)
+			return p - haystack;
+	}
+
+	return -1;
+}
+
+
+/*
+ * Retrieve the index/offset of the right-most occurence of NEEDLE in
+ * HAYSTACK, or -1 if it doesn’t exist.
+ */
+static U_PURE size_t
+str_rindex_n(const char *haystack, const char *needle, size_t haystack_n)
+{
+	assert(haystack != NULL);
+	assert(needle != NULL);
+
+	size_t needle_n = strlen(needle);
+	const char *haystack_max = haystack + haystack_n;
+	const char *p = haystack;
+
+	while (p < haystack_max && *p != '\0')
+		p++;
+
+	if (p < haystack + needle_n)
+		return -1;
+
+	p -= needle_n;
+
+	for ( ; p >= haystack; p--) {
+		size_t i;
+
+		for (i = 0; i < needle_n; i++) {
+			if (p[i] != needle[i])
+				break;
+		}
+
+		if (i == needle_n)
+			return p - haystack;
+	}
+
+	return -1;
+}
+
+
+/* {{{1
+ * Retrieve the index of the right-most occurence of ‘c’ in ‘str’, or -1 if it
+ * doesn't exist.
+ */
+size_t
+u_char_rindex(const char *str, uint32_t c)
+{
+	char ch[7];
+
+	ch[u_char_to_u(c, ch)] = '\0';
+
+	return str_rindex(str, ch);
+}
+
+
+/* {{{1
+ * Retrieve the index of the right-most occurence of ‘c’ in ‘str’, or -1 if it
+ * doesn't exist, going over at most ‘len’ bytes in ‘str’.
+ */
+size_t
+u_char_rindex_n(const char *str, uint32_t c, size_t n)
+{
+	char ch[7];
+
+	ch[u_char_to_u(c, ch)] = '\0';
+
+	return str_rindex_n(str, ch, n);
+}
+
+
+/* {{{1
+ * Retrieve the index of the right-most occurence of ‘needle’ in ‘haystack’, or
+ * -1 if it doesn't exist.
+ */
+size_t
+u_rindex(const char *haystack, const char *needle)
+{
+	return str_rindex(haystack, needle);
+}
+
+
+/* {{{1
+ * Retrieve the index of the right-most occurence of ‘needle’ in ‘haystack’, or
+ * -1 if it doesn't exist, going over at most ‘len’ bytes in ‘haystack’.
+ */
+size_t
+u_rindex_n(const char *haystack, const char *needle, size_t n)
+{
+	return str_rindex_n(haystack, needle, n);
+}

data/ext/u/u_titlecase.c

@@ -0,0 +1,68 @@
+#include <ruby.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "u.h"
+#include "private.h"
+#include "data/constants.h"
+#include "attributes.h"
+#include "titled.h"
+#include "output.h"
+#include "u_locale.h"
+#include "case.h"
+
+#define LATIN_CAPITAL_LETTER_I ((uint32_t)0x0049)
+#define LATIN_CAPITAL_LETTER_J ((uint32_t)0x004a)
+#define LATIN_SMALL_LETTER_I ((uint32_t)0x0069)
+#define LATIN_SMALL_LETTER_J ((uint32_t)0x006a)
+
+struct titlecase_closure {
+        const char *string;
+        enum locale locale;
+        struct output *output;
+};
+
+static void
+titlecase_step(const char *p, const char *q, struct titlecase_closure *closure)
+{
+        const char *t = p;
+        const char *u;
+        while (t < q && !u_char_iscased(u_decode(&u, t, q)))
+                t = u;
+        output_string(closure->output, p, t - p);
+        if (t == q)
+                return;
+        _u_upcase_step(closure->string, t, q, closure->locale, true,
+                       closure->output);
+        if (u < q && closure->locale == LOCALE_DUTCH &&
+            (*t == LATIN_CAPITAL_LETTER_I || *t == LATIN_SMALL_LETTER_I) &&
+            (*u == LATIN_CAPITAL_LETTER_J || *u == LATIN_SMALL_LETTER_J)) {
+                output_char(closure->output, LATIN_CAPITAL_LETTER_J);
+                u++;
+        }
+        while (u < q)
+                u = _u_downcase_step(closure->string, u, q, closure->locale,
+                                     closure->output);
+}
+
+static void
+titlecase_words(const char *p, size_t n, struct titlecase_closure *closure)
+{
+        titlecase_step(p, p + n, closure);
+}
+
+size_t
+u_titlecase(char *result, size_t m, const char *string, size_t n,
+            const char *locale)
+{
+	assert(string != NULL);
+        assert(result != NULL || m == 0);
+        struct output output = OUTPUT_INIT(result, m);
+        struct titlecase_closure closure =
+                { string, _u_locale_from_string(locale), &output };
+        u_words(string, n, (u_substring_fn)titlecase_words, &closure);
+        return output_finalize(&output);
+}

data/ext/u/u_upcase.c

@@ -0,0 +1,89 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "u.h"
+#include "private.h"
+
+#include "data/constants.h"
+#include "attributes.h"
+#include "titled.h"
+#include "output.h"
+#include "u_locale.h"
+#include "case.h"
+
+#define LATIN_SMALL_LETTER_I ((uint32_t)0x0069)
+#define LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE ((uint32_t)0x0130)
+#define COMBINING_DOT_ABOVE ((uint32_t)0x0307)
+#define COMBINING_GREEK_YPOGEGRAMMENI ((uint32_t)0x0345)
+#define GREEK_CAPITAL_LETTER_IOTA ((uint32_t)0x0399)
+
+
+static inline bool
+ismark(int category)
+{
+        return IS(category,
+                  OR(U_GENERAL_CATEGORY_MARK_NON_SPACING,
+                     OR(U_GENERAL_CATEGORY_MARK_SPACING_COMBINING,
+                        OR(U_GENERAL_CATEGORY_MARK_ENCLOSING, 0))));
+}
+
+static inline const char *
+output_marks(const char *q, const char *end,
+             struct output *output)
+{
+        while (q < end) {
+                const char *r;
+		uint32_t c = u_decode(&r, q, end);
+                if (!ismark(u_char_general_category(c)))
+                        break;
+                output_char(output, c);
+                q = r;
+	}
+        return q;
+}
+
+const char *
+_u_upcase_step(const char *string, const char *p, const char *end,
+               enum locale locale, bool title, struct output *output)
+{
+        const char *q;
+        uint32_t c = u_decode(&q, p, end);
+        enum u_general_category gc;
+        if (!title && c == COMBINING_GREEK_YPOGEGRAMMENI) {
+                q = output_marks(q, end, output);
+                output_char(output, GREEK_CAPITAL_LETTER_IOTA);
+        } else if (locale == LOCALE_LITHUANIAN &&
+                   c == COMBINING_DOT_ABOVE &&
+                   is_after(string, p, u_char_issoftdotted))
+                ;
+        else if (locale == LOCALE_TURKIC && c == LATIN_SMALL_LETTER_I)
+                output_char(output, LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE);
+        else if (IS(gc = u_char_general_category(c),
+                    OR(U_GENERAL_CATEGORY_LETTER_LOWERCASE,
+                       OR(U_GENERAL_CATEGORY_LETTER_TITLECASE, 0))))
+                case_simple(c, gc,
+                            title || gc != U_GENERAL_CATEGORY_LETTER_LOWERCASE,
+                            true,
+                            output);
+        else
+                output_string(output, p, q - p);
+        return q;
+}
+
+size_t
+u_upcase(char *result, size_t m, const char *string, size_t n,
+         const char *locale)
+{
+	assert(string != NULL);
+        assert(result != NULL || m == 0);
+	enum locale l = _u_locale_from_string(locale);
+        const char *end = string + n;
+        struct output output = OUTPUT_INIT(result, m);
+        for (const char *p = string; p < end; )
+                p = _u_upcase_step(string, p, end, l, false, &output);
+        return output_finalize(&output);
+}