u 0.5.0 → 1.0.0

data/ext/u/u_char_isspace.c

@@ -0,0 +1,28 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+
+/* {{{1
+ * Determine whether ‘c’ is some form of whitespace, such as space, tab or a
+ * line separator (newline, carriage return, etc.).
+ */
+bool
+u_char_isspace(uint32_t c)
+{
+	switch (c) {
+	case '\t':
+	case '\n':
+	case '\r':
+	case '\f':
+		return true;
+	default:
+                return IS(u_char_general_category(c),
+                          OR(U_GENERAL_CATEGORY_SEPARATOR_SPACE,
+                             OR(U_GENERAL_CATEGORY_SEPARATOR_LINE,
+                                OR(U_GENERAL_CATEGORY_SEPARATOR_PARAGRAPH, 0)))) ? true : false;
+	}
+}

data/ext/u/u_char_isupper.c

@@ -0,0 +1,16 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+
+/* {{{1
+ * Determine whether ‘c’ is an uppeercase letter, such as A, B, or C
+ */
+bool
+u_char_isupper(uint32_t c)
+{
+	return u_char_general_category(c) == U_GENERAL_CATEGORY_LETTER_UPPERCASE;
+}

data/ext/u/u_char_isvalid.c

@@ -0,0 +1,18 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+
+
+/* {{{1
+ * Check whether ‘c’ is a valid Unicode character.
+ */
+bool
+u_char_isvalid(uint32_t c)
+{
+	return ((c) < 0x110000 &&
+                (((c) & 0xffffff800) != 0xd800) &&
+                ((c) < 0xfdd0 || (c) > 0xfdef) &&
+                ((c) & 0xfffe) != 0xfffe);
+}

data/ext/u/u_char_iswide.c

@@ -0,0 +1,18 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "u.h"
+
+#include "private.h"
+
+#include "data/wide.h"
+
+/* Returns true if C is typically rendered a double-width cell on a terminal. */
+bool
+u_char_iswide(uint32_t c)
+{
+        return bsearch(&c, wide, lengthof(wide), sizeof(wide[0]),
+                       u_char_interval_compare) != NULL;
+}

data/ext/u/u_char_iswide_cjk.c

@@ -0,0 +1,22 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "u.h"
+
+#include "private.h"
+
+#include "data/wide-cjk.h"
+
+/* Returns true if C is typically rendered a double-width cell on a terminal
+ * under legacy East Asian locales.
+ *
+ * See http://www.unicode.org/reports/tr11/ for more details. */
+bool
+u_char_iswide_cjk(uint32_t c)
+{
+        return u_char_iswide(c) ||
+                bsearch(&c, wide, lengthof(wide), sizeof(wide[0]),
+                        u_char_interval_compare) != NULL;
+}

data/ext/u/u_char_isxdigit.c

@@ -0,0 +1,27 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+
+#define FULLWIDTH_A ((uint32_t)0xff21)
+#define FULLWIDTH_F ((uint32_t)0xff26)
+#define FULLWIDTH_a ((uint32_t)0xff41)
+#define FULLWIDTH_f ((uint32_t)0xff46)
+
+
+/* {{{1
+ * Determine whether ‘c’ is a hexadecimal digit, such as 0, 1, ..., 9, a, b,
+ * ..., f, or A, B, ..., F.
+ */
+bool
+u_char_isxdigit(uint32_t c)
+{
+	return ((c >= 'a' && c <= 'f') ||
+		(c >= 'A' && c <= 'F') ||
+                (c >= FULLWIDTH_a && c <= FULLWIDTH_f) ||
+                (c >= FULLWIDTH_A && c <= FULLWIDTH_F) ||
+                (u_char_general_category(c) == U_GENERAL_CATEGORY_NUMBER_DECIMAL));
+}

data/ext/u/u_char_iszerowidth.c

@@ -0,0 +1,29 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+
+#define SOFT_HYPHEN ((uint32_t)0x00ad)
+#define ZERO_WIDTH_SPACE ((uint32_t)0x200b)
+
+
+bool
+u_char_iszerowidth(uint32_t c)
+{
+        if (UNLIKELY(c == SOFT_HYPHEN))
+                return false;
+
+        if (UNLIKELY(IS(u_char_general_category(c),
+                        OR(U_GENERAL_CATEGORY_MARK_NON_SPACING,
+                           OR(U_GENERAL_CATEGORY_MARK_ENCLOSING,
+                              OR(U_GENERAL_CATEGORY_OTHER_FORMAT, 0))))))
+                return true;
+
+        if (UNLIKELY((0x1160 <= c && c < 0x1200) || c == ZERO_WIDTH_SPACE))
+                return true;
+
+        return false;
+}

data/ext/u/u_char_line_break.c

@@ -0,0 +1,29 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "data/constants.h"
+#include "data/line-break.h"
+#include "private.h"
+
+/* Figure out what break type the Unicode character ‘c’ possesses, if any.
+ * This information is used for finding word and line boundaries, which is
+ * useful when displaying Unicode text on screen. */
+enum u_line_break
+u_char_line_break(uint32_t c)
+{
+        int16_t index;
+
+	if (c <= UNICODE_LAST_CHAR_PART1)
+                index = line_break_property_table_part1[c >> 8];
+        else if (UNICODE_FIRST_CHAR_PART2 <= c && c <= UNICODE_LAST_CHAR)
+                index = line_break_property_table_part2[(c - UNICODE_FIRST_CHAR_PART2) >> 8];
+	else
+		return U_LINE_BREAK_UNKNOWN;
+
+	if (index >= UNICODE_MAX_TABLE_INDEX)
+		return index - UNICODE_MAX_TABLE_INDEX;
+
+        return line_break_property_data[index][c & 0xff];
+}

data/ext/u/u_char_mirror.c

@@ -0,0 +1,16 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "u.h"
+
+#include "data/bidi-mirroring.h"
+#include "private.h"
+
+uint32_t
+u_char_mirror(uint32_t c)
+{
+        size_t i;
+        return unicode_table_lookup(bidi_mirroring_table, c, &i) ?
+                bidi_mirroring_table[i].mirrored_ch :
+                c;
+}

data/ext/u/u_char_normalized.c

@@ -0,0 +1,23 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "u.h"
+
+#include "data/constants.h"
+#include "data/normalization-quick-check.h"
+
+enum u_normalized
+u_char_normalized(uint32_t c, enum u_normalization_form form)
+{
+        int16_t i;
+	if (c <= UNICODE_LAST_CHAR_PART1)
+                i = normalization_quick_check_table_part1[c >> 8];
+        else if (UNICODE_FIRST_CHAR_PART2 <= c && c <= UNICODE_LAST_CHAR)
+                i = normalization_quick_check_table_part2[(c - UNICODE_FIRST_CHAR_PART2) >> 8];
+	else
+		return U_NORMALIZED_YES;
+
+        return (i >= UNICODE_MAX_TABLE_INDEX ?
+		i - UNICODE_MAX_TABLE_INDEX :
+                normalization_quick_check_data[i][c & 0xff]) & (((1 << 2) - 1) << (2 * form));
+}

data/ext/u/u_char_script.c

@@ -0,0 +1,41 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+
+#include "private.h"
+
+#include "data/script.h"
+
+
+static inline enum u_script
+u_char_script_bsearch(uint32_t c)
+{
+	int begin = 0;
+        int end = lengthof(script_table) - 1;
+        static int cached_middle = lengthof(script_table) / 2;
+        int middle = cached_middle;
+
+        do {
+                uint32_t probe = script_table[middle].start;
+                if (c < probe)
+                        end = middle - 1;
+                else if (c >= probe + script_table[middle].chars)
+                        begin = middle + 1;
+                else
+                        return script_table[cached_middle = middle].script;
+
+                middle = binary_search_middle_of(begin, end);
+        } while (begin <= end);
+
+        return U_SCRIPT_UNKNOWN;
+}
+
+enum u_script
+u_char_script(uint32_t c)
+{
+        return c < EASY_SCRIPTS_RANGE ?
+                script_easy_table[c] :
+                u_char_script_bsearch(c);
+}

data/ext/u/u_char_to_u.c

@@ -0,0 +1,48 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+
+
+/* {{{1
+ * Turn an Unicode character (UTF-32) into an UTF-8 character sequence and
+ * store it in ‘result’, returning the length of the stored sequence.
+ */
+int
+u_char_to_u_n(uint32_t c, char *result, size_t n)
+{
+        if (c < 0x80) {
+                if (n > 0)
+                        result[0] = c;
+                return 1;
+        }
+
+        size_t m;
+        if (c < 0x800)
+                m = 2;
+        else if (c < 0x10000) {
+                if (0xd800 <= c && c < 0xe000)
+                        return 0;
+                m = 3;
+        } else if (c < U_N_CODEPOINTS)
+                m = 4;
+        else
+                return 0;
+
+        if (result != NULL && n >= m) {
+                switch (m) {
+                case 4: result[3] = 0x80 | (c & 0x3f); c = c >> 6; c |= 0x10000;
+                case 3: result[2] = 0x80 | (c & 0x3f); c = c >> 6; c |= 0x800;
+                case 2: result[1] = 0x80 | (c & 0x3f); c = c >> 6; c |= 0xc0;
+                        result[0] = c;
+                }
+        }
+        return (int)m;
+}
+
+int
+u_char_to_u(uint32_t c, char *result)
+{
+        return u_char_to_u_n(c, result, 4);
+}

data/ext/u/u_char_upcase.c

@@ -0,0 +1,24 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+#include "data/constants.h"
+#include "attributes.h"
+#include "titled.h"
+
+
+uint32_t
+u_char_upcase(uint32_t c)
+{
+	switch (u_char_general_category(c)) {
+        case U_GENERAL_CATEGORY_LETTER_LOWERCASE:
+                return _u_special_case_table_lookup(c);
+        case U_GENERAL_CATEGORY_LETTER_TITLECASE:
+                return _u_titlecase_table_lookup(c, true);
+        default:
+                return c;
+        }
+}

data/ext/u/u_char_width.c

@@ -0,0 +1,12 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+
+
+size_t
+u_char_width(uint32_t c)
+{
+        return u_char_iswide(c) ? 2 : u_char_iszerowidth(c) ? 0 : 1;
+}

data/ext/u/u_char_word_break.c

@@ -0,0 +1,28 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "u.h"
+#include "private.h"
+
+#include "data/constants.h"
+#include "data/word-break.h"
+
+
+enum u_word_break
+u_char_word_break(uint32_t c)
+{
+        int16_t index;
+
+	if (c <= UNICODE_LAST_CHAR_PART1)
+                index = word_break_property_table_part1[c >> 8];
+        else if (UNICODE_FIRST_CHAR_PART2 <= c && c <= UNICODE_LAST_CHAR)
+                index = word_break_property_table_part2[(c - UNICODE_FIRST_CHAR_PART2) >> 8];
+	else
+		return U_WORD_BREAK_OTHER;
+
+	if (index >= UNICODE_MAX_TABLE_INDEX)
+		return index - UNICODE_MAX_TABLE_INDEX;
+
+        return word_break_property_data[index][c & 0xff];
+}

data/ext/u/u_char_xdigit_value.c

@@ -0,0 +1,31 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "u.h"
+#include "private.h"
+
+
+#define FULLWIDTH_A ((uint32_t)0xff21)
+#define FULLWIDTH_F ((uint32_t)0xff26)
+#define FULLWIDTH_a ((uint32_t)0xff41)
+#define FULLWIDTH_f ((uint32_t)0xff46)
+
+
+/* {{{1
+ * Return the numeric value of ‘c’ if it's a hexadecimal digit, or -1 if not.
+ */
+int
+u_char_xdigit_value(uint32_t c)
+{
+	if (c >= 'a' && c <= 'f')
+		return c - 'a' + 10;
+	else if (c >= 'A' && c <= 'F')
+		return c - 'A' + 10;
+        else if (c >= FULLWIDTH_a && c <= FULLWIDTH_f)
+                return c - FULLWIDTH_a + 10;
+        else if (c >= FULLWIDTH_A && c <= FULLWIDTH_F)
+                return c - FULLWIDTH_A + 10;
+	else
+		return u_char_digit_value(c);
+}

data/ext/u/u_collate.c

@@ -0,0 +1,83 @@
+#include "extconf.h"
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "u.h"
+#include "private.h"
+
+static int
+compare(const char *a, size_t a_n, const char *b, size_t b_n)
+{
+        int r = memcmp(a, b, a_n < b_n ? a_n : b_n);
+        if (r == 0) {
+                if (a_n < b_n)
+                        return -1;
+                else if (a_n > b_n)
+                        return 1;
+        }
+        return r;
+}
+
+static size_t
+ckey(char **result, char *buf, size_t m,
+     const char *string, size_t n,
+     const char *locale)
+{
+        errno = 0;
+        size_t key_n = u_collation_key(buf, m, string, n, locale);
+        if (errno != 0)
+                return 0;
+        if (key_n < m) {
+                *result = buf;
+                return key_n;
+        }
+        char *key = malloc(key_n + 1);
+        if (key == NULL)
+                return 0;
+        key_n = u_collation_key(key, key_n + 1, string, n, locale);
+        if (errno != 0) {
+                free(key);
+                return 0;
+        }
+        *result = key;
+        return key_n;
+}
+
+int
+u_collate(const char *a, size_t a_n, const char *b, size_t b_n,
+          const char *locale)
+{
+        char a_buf[2048];
+        char *a_key = NULL;
+        size_t a_key_n = ckey(&a_key, a_buf, sizeof(a_buf), a, a_n, locale);
+        int a_errno = errno;
+
+        char b_buf[2048];
+        char *b_key = NULL;
+        size_t b_key_n = ckey(&b_key, b_buf, sizeof(b_buf), b, b_n, locale);
+        int b_errno = errno;
+
+        int r;
+        if (a_errno != 0) {
+                if (b_errno != 0)
+                        r = compare(a, a_n, b, b_n);
+                else
+                        r = 1;
+                errno = a_errno;
+        } else if (b_errno != 0) {
+                r = -1;
+                errno = b_errno;
+        } else
+                r = compare(a_key, a_key_n, b_key, b_key_n);
+
+        if (a_key != a_buf)
+                free(a_key);
+        if (b_key != b_buf)
+                free(b_key);
+
+        return r;
+}