u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_plus.c

@@ -0,0 +1,33 @@
+#include "rb_includes.h"
+
+/* @overload +(other)
+ *   @param [U::String, #to_str] other
+ *   @raise [ArgumentError] If {#bytesize} + OTHER{#bytesize} > LONG_MAX
+ *   @return [U::String] The concatenation of OTHER to the receiver, inheriting
+ *     any taint on either */
+VALUE
+rb_u_string_plus(VALUE self, VALUE rbother)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *other = RVAL2USTRING_ANY(rbother);
+
+        long string_length = USTRING_LENGTH(string);
+        long other_length = USTRING_LENGTH(other);
+
+        /* TODO: Isn’t this off by one, as we add one to length for the
+         * ALLOC_N() call? */
+        if (string_length > LONG_MAX - other_length)
+                rb_u_raise(rb_eArgError, "length of resulting string would be too big");
+        long length = string_length + other_length;
+
+        char *sum = ALLOC_N(char, length + 1);
+        memcpy(sum, USTRING_STR(string), string_length);
+        memcpy(sum + string_length, USTRING_STR(other), other_length);
+        sum[length] = '\0';
+
+        VALUE result = rb_u_string_new_uninfected_own(sum, length);
+        if (OBJ_TAINTED(self) || OBJ_TAINTED(rbother))
+                OBJ_TAINT(result);
+
+        return result;
+}

data/ext/u/rb_u_string_print.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload print?
+ *   @return [Boolean] True if the receiver contains only characters not in the
+ *     general category Other */
+VALUE
+rb_u_string_print(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isprint);
+}

data/ext/u/rb_u_string_punct.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload punct?
+ *   @return [Boolean] True if the receiver contains only characters in the
+ *     general categories Punctuation and Symbol */
+VALUE
+rb_u_string_punct(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_ispunct);
+}

data/ext/u/rb_u_string_reverse.c

@@ -0,0 +1,13 @@
+#include "rb_includes.h"
+
+/* @return [U::String] The reversal of the receiver, inheriting any taint and
+ *   untrust from the receiver
+ * @note This doesn’t take into account proper handling of combining marks,
+ *   direction indicators, and similarly relevant characters, so this method is
+ *   mostly useful when you know the contents of the string is simple and the
+ *   result isn’t intended for display. */
+VALUE
+rb_u_string_reverse(VALUE self)
+{
+        return _rb_u_string_convert(self, u_reverse);
+}

data/ext/u/rb_u_string_rindex.c

@@ -0,0 +1,104 @@
+#include "rb_includes.h"
+
+long
+rb_u_string_rindex(VALUE self, VALUE rbsubstring, long offset)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *substring = RVAL2USTRING_ANY(rbsubstring);
+
+        if (USTRING_LENGTH(string) < USTRING_LENGTH(substring))
+                return -1;
+
+        const char *s = rb_u_string_begin_from_offset(string, offset);
+        if (s == NULL)
+                return -1;
+
+        if (USTRING_LENGTH(substring) == 0)
+                return offset;
+
+        const char *begin = USTRING_STR(string);
+        const char *t = USTRING_STR(substring);
+        long t_length = USTRING_LENGTH(substring);
+        while (s >= begin) {
+                if (rb_memcmp(s, t, t_length) == 0)
+                        return u_pointer_to_offset(begin, s);
+                s--;
+        }
+
+        return -1;
+}
+
+/* @overload rindex(pattern, offset = -1)
+ *
+ *   Returns the maximal index of the receiver where PATTERN matches, equal to
+ *   or less than _i_, where _i_ = OFFSET if OFFSET ≥ 0, _i_ = {#length} -
+ *   abs(OFFSET) otherwise, or nil if there is no match.
+ *
+ *   If PATTERN is a Regexp, the Regexp special variables `$&`, `$'`,
+ *   <code>$\`</code>, `$1`, `$2`, …, `$`_n_ are updated accordingly.
+ *
+ *   If PATTERN responds to `#to_str`, the matching is performed by a byte
+ *   comparison.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_int] offset
+ *   @return [Integer, nil]
+ *   @see #index */
+VALUE
+rb_u_string_rindex_m(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE sub, rboffset;
+        long offset;
+        if (rb_scan_args(argc, argv, "11", &sub, &rboffset) == 2)
+                offset = NUM2LONG(rboffset);
+        else
+                /* TODO: Why not simply use -1?  Benchmark which is faster. */
+                offset = u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string));
+
+        const char *begin = rb_u_string_begin_from_offset(string, offset);
+        const char *end = USTRING_END(string);
+        if (begin == NULL) {
+                if (offset <= 0) {
+                        if (TYPE(sub) == T_REGEXP)
+                                rb_backref_set(Qnil);
+
+                        return Qnil;
+                }
+
+                begin = end;
+                /* TODO: this converting back and forward can be optimized away
+                 * if rb_u_string_index_regexp() and rb_u_string_rindex() were split up
+                 * into two additional functions, adding
+                 * rb_u_string_index_regexp_pointer() and rb_u_string_rindex_pointer(),
+                 * so that one can pass a pointer to start at immediately
+                 * instead of an offset that gets calculated into a pointer. */
+                offset = u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string));
+        }
+
+        switch (TYPE(sub)) {
+        case T_REGEXP:
+                /* TODO: What’s this first test for, exactly? */
+                if (RREGEXP(sub)->ptr == NULL || RREGEXP_SRC_LEN(sub) > 0)
+                        offset = rb_u_string_index_regexp(self, begin, sub, true);
+                break;
+        default: {
+                VALUE tmp = rb_check_string_type(sub);
+                if (NIL_P(tmp))
+                        rb_u_raise(rb_eTypeError, "type mismatch: %s given",
+                                   rb_obj_classname(sub));
+
+                sub = tmp;
+        }
+                /* fall through */
+        case T_STRING:
+                offset = rb_u_string_rindex(self, sub, offset);
+                break;
+        }
+
+        if (offset < 0)
+                return Qnil;
+
+        return LONG2NUM(offset);
+}

data/ext/u/rb_u_string_rpartition.c

@@ -0,0 +1,81 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+static VALUE
+rb_u_string_rpartition_failure(VALUE self)
+{
+        return rb_ary_new3(3,
+                           rb_u_string_new_empty(self),
+                           rb_u_string_new_empty(self),
+                           self);
+}
+
+static VALUE
+rb_u_string_rpartition_success(VALUE self, VALUE rbseparator, long offset)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *separator = RVAL2USTRING_ANY(rbseparator);
+
+        long after = offset + USTRING_LENGTH(separator);
+
+        return rb_ary_new3(3,
+                           rb_u_string_new_subsequence(self, 0, offset),
+                           TYPE(rbseparator) == T_STRING ?
+                                rb_u_string_new_rb(rbseparator) :
+                                rbseparator,
+                           rb_u_string_new_subsequence(self,
+                                                       after,
+                                                       USTRING_LENGTH(string) - after));
+}
+
+static VALUE
+rb_u_string_rpartition_regex(VALUE self, VALUE regex)
+{
+        VALUE str = rb_str_to_str(self);
+
+        long offset = rb_reg_search(regex, str, RSTRING_LEN(str), 1);
+        if (offset < 0)
+                return rb_u_string_rpartition_failure(self);
+
+        VALUE separator = rb_u_pattern_match_reference(INT2FIX(0));
+
+        return rb_u_string_rpartition_success(self, separator, offset);
+}
+
+static VALUE
+rb_u_string_rpartition_string(VALUE self, VALUE rbseparator)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *begin = USTRING_STR(string);
+
+        VALUE validated = rb_u_string_validate_type(rbseparator);
+
+        long offset = rb_u_string_rindex(self,
+                                         validated,
+                                         u_n_chars_n(begin,
+                                                     USTRING_LENGTH(string)));
+        if (offset < 0)
+                return rb_u_string_rpartition_failure(self);
+
+        long byte_offset = u_offset_to_pointer(begin, offset) - begin;
+
+        return rb_u_string_rpartition_success(self, validated, byte_offset);
+}
+
+/* @overload rpartition(separator)
+ *   @param [Regexp, #to_str] separator
+ *   @return [Array<U::String>] The receiver split into _s₁_ = {#slice}(0, _i_),
+ *     _s₂_ = {#slice}(_i_, _n_), _s₃_ = {#slice}(_i_ + _n_, -1), where _i_ = _j_ if _j_ ≠
+ *     nil, _i_ = 0 otherwise, _j_ = {#rindex}(SEPARATOR), _n_ =
+ *     SEPARATOR{#length}, where _s₁_ and _s₃_ inherit any taint and untrust
+ *     from the receiver and _s₂_ inherits any taint and untrust from SEPARATOR
+ *     and also from the receiver if SEPARATOR is a Regexp
+ *   @see #partition */
+VALUE
+rb_u_string_rpartition(VALUE self, VALUE separator)
+{
+        if (TYPE(separator) == T_REGEXP)
+                return rb_u_string_rpartition_regex(self, separator);
+
+        return rb_u_string_rpartition_string(self, separator);
+}

data/ext/u/rb_u_string_rstrip.c

@@ -0,0 +1,29 @@
+#include "rb_includes.h"
+
+/* @return [U::String] The receiver with its maximum {#space?} suffix removed,
+ *   inheriting any taint and untrust from the receiver
+ * @see #lstrip
+ * @see #strip */
+VALUE
+rb_u_string_rstrip(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = USTRING_STR(string);
+        if (begin == NULL)
+                return self;
+
+        const char *end = USTRING_END(string);
+        const char *q = end;
+        while (begin < q) {
+                const char *p;
+                uint32_t c = u_decode_r(&p, begin, q);
+                if (c != '\0' && !u_char_isspace(c))
+                        break;
+                q = p;
+        }
+        if (q == end)
+                return self;
+
+        return rb_u_string_new_c(self, begin, q - begin);
+}

data/ext/u/rb_u_string_scan.c

@@ -0,0 +1,109 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+static VALUE
+rb_u_string_scan_once(VALUE string, VALUE pattern, long *start, long *last)
+{
+        if (rb_reg_search(pattern, string, *start, false) < 0) {
+                if (*last >= 0)
+                        rb_reg_search(pattern, string, *last, false);
+
+                return Qnil;
+        }
+
+        *last = *start;
+
+        VALUE match = rb_backref_get();
+        struct re_registers *registers = RMATCH_REGS(match);
+        if (registers->beg[0] == registers->end[0]) {
+                if (RSTRING_LEN(string) > registers->end[0])
+                        *start = registers->end[0] +
+                                (u_next(RSTRING_PTR(string) + registers->end[0]) -
+                                 (RSTRING_PTR(string) + registers->end[0]));
+                else
+                        *start = registers->end[0] + 1;
+        } else {
+                *start = registers->end[0];
+        }
+
+        if (registers->num_regs == 1)
+                return rb_u_string_new_rb(rb_reg_nth_match(0, match));
+
+        VALUE result = rb_ary_new2(registers->num_regs);
+        for (int i = 1; i < registers->num_regs; i++)
+                rb_ary_push(result, rb_u_string_new_rb(rb_reg_nth_match(i, match)));
+
+        return result;
+}
+
+static VALUE
+rb_u_string_scan_block(VALUE self, VALUE string, VALUE pattern)
+{
+        VALUE result;
+        long start = 0;
+        long last = -1;
+
+        while (!NIL_P(result = rb_u_string_scan_once(string, pattern, &start, &last)))
+                rb_yield(result);
+
+        return self;
+}
+
+static VALUE
+rb_u_string_scan_array(VALUE string, VALUE pattern)
+{
+        VALUE result;
+        long start = 0;
+        long last = -1;
+
+        VALUE array = rb_ary_new();
+        while (!NIL_P(result = rb_u_string_scan_once(string, pattern, &start, &last)))
+                rb_ary_push(array, result);
+
+        return array;
+}
+
+/* @overload scan(pattern)
+ *   @param [Regexp] pattern
+ *   @return [Array<U::String>, Array<Array<U::String>>] All matches – or
+ *     sub-matches, if they exist – of matches of PATTERN in the receiver, each
+ *     inheriting any taint and untrust from both the receiver and from PATTERN
+ *   @note The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`,
+ *     `$2`, …, `$`_n_ are updated accordingly.
+ *
+ * @overload scan(pattern)
+ *   @param [#to_str] pattern
+ *   @return [Array<U::String>] All matches of PATTERN in the receiver, each
+ *     inheriting any taint and untrust from the receiver
+ *
+ * @overload scan(pattern){ |*submatches| … }
+ *
+ *   Enumerates the sub-matches of matches of PATTERN in the receiver, each
+ *   inheriting any taint and untrust from both the receiver and from PATTERN.
+ *
+ *   @param [Regexp] pattern
+ *   @yieldparam [Array<U::String>] submatches
+ *   @return [self]
+ *   @note The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`,
+ *     `$2`, …, `$`_n_ are updated accordingly.
+ *
+ * @overload scan(pattern){ |match| … }
+ *
+ *   Enumerates the matches of PATTERN in the receiver, each inheriting any
+ *   taint and untrust from the receiver.
+ *
+ *   @param [#to_str] pattern
+ *   @yieldparam [U::String] match
+ *   @return [self] */
+VALUE
+rb_u_string_scan(VALUE self, VALUE pattern)
+{
+        pattern = rb_u_pattern_argument(pattern, true);
+
+        VALUE string = rb_str_to_str(self);
+
+        if (rb_block_given_p())
+                return rb_u_string_scan_block(self, string, pattern);
+
+        return rb_u_string_scan_array(string, pattern);
+}

data/ext/u/rb_u_string_script.c

@@ -0,0 +1,253 @@
+#include "rb_includes.h"
+
+#define SCRIPT2ID(script, symbol) \
+        case U_SCRIPT_##script: { \
+                static ID id_##symbol; \
+                if (id_##symbol == 0) \
+                        id_##symbol = rb_intern(#symbol); \
+                return ID2SYM(id_##symbol); \
+        }
+
+static VALUE
+script_to_symbol(enum u_script script)
+{
+        switch (script) {
+        SCRIPT2ID(COMMON, common)
+        SCRIPT2ID(INHERITED, inherited)
+        SCRIPT2ID(ARABIC, arabic)
+        SCRIPT2ID(ARMENIAN, armenian)
+        SCRIPT2ID(BENGALI, bengali)
+        SCRIPT2ID(BOPOMOFO, bopomofo)
+        SCRIPT2ID(CHEROKEE, cherokee)
+        SCRIPT2ID(COPTIC, coptic)
+        SCRIPT2ID(CYRILLIC, cyrillic)
+        SCRIPT2ID(DESERET, deseret)
+        SCRIPT2ID(DEVANAGARI, devanagari)
+        SCRIPT2ID(ETHIOPIC, ethiopic)
+        SCRIPT2ID(GEORGIAN, georgian)
+        SCRIPT2ID(GOTHIC, gothic)
+        SCRIPT2ID(GREEK, greek)
+        SCRIPT2ID(GUJARATI, gujarati)
+        SCRIPT2ID(GURMUKHI, gurmukhi)
+        SCRIPT2ID(HAN, han)
+        SCRIPT2ID(HANGUL, hangul)
+        SCRIPT2ID(HEBREW, hebrew)
+        SCRIPT2ID(HIRAGANA, hiragana)
+        SCRIPT2ID(KANNADA, kannada)
+        SCRIPT2ID(KATAKANA, katakana)
+        SCRIPT2ID(KHMER, khmer)
+        SCRIPT2ID(LAO, lao)
+        SCRIPT2ID(LATIN, latin)
+        SCRIPT2ID(MALAYALAM, malayalam)
+        SCRIPT2ID(MONGOLIAN, mongolian)
+        SCRIPT2ID(MYANMAR, myanmar)
+        SCRIPT2ID(OGHAM, ogham)
+        SCRIPT2ID(OLD_ITALIC, old_italic)
+        SCRIPT2ID(ORIYA, oriya)
+        SCRIPT2ID(RUNIC, runic)
+        SCRIPT2ID(SINHALA, sinhala)
+        SCRIPT2ID(SYRIAC, syriac)
+        SCRIPT2ID(TAMIL, tamil)
+        SCRIPT2ID(TELUGU, telugu)
+        SCRIPT2ID(THAANA, thaana)
+        SCRIPT2ID(THAI, thai)
+        SCRIPT2ID(TIBETAN, tibetan)
+        SCRIPT2ID(CANADIAN_ABORIGINAL, canadian_aboriginal)
+        SCRIPT2ID(YI, yi)
+        SCRIPT2ID(TAGALOG, tagalog)
+        SCRIPT2ID(HANUNOO, hanunoo)
+        SCRIPT2ID(BUHID, buhid)
+        SCRIPT2ID(TAGBANWA, tagbanwa)
+        SCRIPT2ID(BRAILLE, braille)
+        SCRIPT2ID(CYPRIOT, cypriot)
+        SCRIPT2ID(LIMBU, limbu)
+        SCRIPT2ID(OSMANYA, osmanya)
+        SCRIPT2ID(SHAVIAN, shavian)
+        SCRIPT2ID(LINEAR_B, linear_b)
+        SCRIPT2ID(TAI_LE, tai_le)
+        SCRIPT2ID(UGARITIC, ugaritic)
+        SCRIPT2ID(NEW_TAI_LUE, new_tai_lue)
+        SCRIPT2ID(BUGINESE, buginese)
+        SCRIPT2ID(GLAGOLITIC, glagolitic)
+        SCRIPT2ID(TIFINAGH, tifinagh)
+        SCRIPT2ID(SYLOTI_NAGRI, syloti_nagri)
+        SCRIPT2ID(OLD_PERSIAN, old_persian)
+        SCRIPT2ID(KHAROSHTHI, kharoshthi)
+        SCRIPT2ID(UNKNOWN, unknown)
+        SCRIPT2ID(BALINESE, balinese)
+        SCRIPT2ID(CUNEIFORM, cuneiform)
+        SCRIPT2ID(PHOENICIAN, phoenician)
+        SCRIPT2ID(PHAGS_PA, phags_pa)
+        SCRIPT2ID(NKO, nko)
+        SCRIPT2ID(KAYAH_LI, kayah_li)
+        SCRIPT2ID(LEPCHA, lepcha)
+        SCRIPT2ID(REJANG, rejang)
+        SCRIPT2ID(SUNDANESE, sundanese)
+        SCRIPT2ID(SAURASHTRA, saurashtra)
+        SCRIPT2ID(CHAM, cham)
+        SCRIPT2ID(OL_CHIKI, ol_chiki)
+        SCRIPT2ID(VAI, vai)
+        SCRIPT2ID(CARIAN, carian)
+        SCRIPT2ID(LYCIAN, lycian)
+        SCRIPT2ID(LYDIAN, lydian)
+        SCRIPT2ID(AVESTAN, avestan)
+        SCRIPT2ID(BAMUM, bamum)
+        SCRIPT2ID(EGYPTIAN_HIEROGLYPHS, egyptian_hieroglyphs)
+        SCRIPT2ID(IMPERIAL_ARAMAIC, imperial_aramaic)
+        SCRIPT2ID(INSCRIPTIONAL_PAHLAVI, inscriptional_pahlavi)
+        SCRIPT2ID(INSCRIPTIONAL_PARTHIAN, inscriptional_parthian)
+        SCRIPT2ID(JAVANESE, javanese)
+        SCRIPT2ID(KAITHI, kaithi)
+        SCRIPT2ID(LISU, lisu)
+        SCRIPT2ID(MEETEI_MAYEK, meetei_mayek)
+        SCRIPT2ID(OLD_SOUTH_ARABIAN, old_south_arabian)
+        SCRIPT2ID(OLD_TURKIC, old_turkic)
+        SCRIPT2ID(SAMARITAN, samaritan)
+        SCRIPT2ID(TAI_THAM, tai_tham)
+        SCRIPT2ID(TAI_VIET, tai_viet)
+        SCRIPT2ID(BATAK, batak)
+        SCRIPT2ID(BRAHMI, brahmi)
+        SCRIPT2ID(MANDAIC, mandaic)
+        SCRIPT2ID(MEROITIC_HIEROGLYPHS, meroitic_hieroglyphs)
+        SCRIPT2ID(MEROITIC_CURSIVE, meroitic_cursive)
+        SCRIPT2ID(SORA_SOMPENG, sora_sompeng)
+        SCRIPT2ID(CHAKMA, chakma)
+        SCRIPT2ID(SHARADA, sharada)
+        SCRIPT2ID(TAKRI, takri)
+        SCRIPT2ID(MIAO, miao)
+        default:
+                rb_u_raise(rb_eNotImpError, "unknown script: %d", script);
+        }
+}
+
+/* Returns the script of the characters of the receiver.
+ *
+ * The script of a character identifies the primary writing system that uses
+ * the character.
+ *
+ * <table>
+ *   <thead><tr><th>Script</th><th>Description</th></tr></thead>
+ *   <tbody>
+ *     <tr><td>:arabic</td><td>Arabic</td></tr>
+ *     <tr><td>:armenian</td><td>Armenian</td></tr>
+ *     <tr><td>:avestan</td><td>Avestan</td></tr>
+ *     <tr><td>:balinese</td><td>Balinese</td></tr>
+ *     <tr><td>:bamum</td><td>Bamum</td></tr>
+ *     <tr><td>:batak</td><td>Batak</td></tr>
+ *     <tr><td>:bengali</td><td>Bengali</td></tr>
+ *     <tr><td>:bopomofo</td><td>Bopomofo</td></tr>
+ *     <tr><td>:brahmi</td><td>Brahmi</td></tr>
+ *     <tr><td>:braille</td><td>Braille</td></tr>
+ *     <tr><td>:buginese</td><td>Buginese</td></tr>
+ *     <tr><td>:buhid</td><td>Buhid</td></tr>
+ *     <tr><td>:canadian_aboriginal</td><td>Canadian Aboriginal</td></tr>
+ *     <tr><td>:carian</td><td>Carian</td></tr>
+ *     <tr><td>:chakma</td><td>Chakma</td></tr>
+ *     <tr><td>:cham</td><td>Cham</td></tr>
+ *     <tr><td>:cherokee</td><td>Cherokee</td></tr>
+ *     <tr><td>:common</td><td>For other characters that may be used with multiple scripts</td></tr>
+ *     <tr><td>:coptic</td><td>Coptic</td></tr>
+ *     <tr><td>:cuneiform</td><td>Cuneiform</td></tr>
+ *     <tr><td>:cypriot</td><td>Cypriot</td></tr>
+ *     <tr><td>:cyrillic</td><td>Cyrillic</td></tr>
+ *     <tr><td>:deseret</td><td>Deseret</td></tr>
+ *     <tr><td>:devanagari</td><td>Devanagari</td></tr>
+ *     <tr><td>:egyptian_hieroglyphs</td><td>Egyptian Hieroglpyhs</td></tr>
+ *     <tr><td>:ethiopic</td><td>Ethiopic</td></tr>
+ *     <tr><td>:georgian</td><td>Georgian</td></tr>
+ *     <tr><td>:glagolitic</td><td>Glagolitic</td></tr>
+ *     <tr><td>:gothic</td><td>Gothic</td></tr>
+ *     <tr><td>:greek</td><td>Greek</td></tr>
+ *     <tr><td>:gujarati</td><td>Gujarati</td></tr>
+ *     <tr><td>:gurmukhi</td><td>Gurmukhi</td></tr>
+ *     <tr><td>:han</td><td>Han</td></tr>
+ *     <tr><td>:hangul</td><td>Hangul</td></tr>
+ *     <tr><td>:hanunoo</td><td>Hanunoo</td></tr>
+ *     <tr><td>:hebrew</td><td>Hebrew</td></tr>
+ *     <tr><td>:hiragana</td><td>Hiragana</td></tr>
+ *     <tr><td>:imperial_aramaic</td><td>Imperial Aramaic</td></tr>
+ *     <tr><td>:inherited</td><td>For characters that may be used with multiple
+ *     scripts, and that inherit their script from the preceding characters;
+ *     these include nonspacing marks, enclosing marks, and the zero-width
+ *     joiner/non-joiner characters</td></tr>
+ *     <tr><td>:inscriptional_pahlavi</td><td>Inscriptional Pahlavi</td></tr>
+ *     <tr><td>:inscriptional_parthian</td><td>Inscriptional Parthian</td></tr>
+ *     <tr><td>:javanese</td><td>Javanese</td></tr>
+ *     <tr><td>:kaithi</td><td>Kaithi</td></tr>
+ *     <tr><td>:kannada</td><td>Kannada</td></tr>
+ *     <tr><td>:katakana</td><td>Katakana</td></tr>
+ *     <tr><td>:kayah_li</td><td>Kayah Li</td></tr>
+ *     <tr><td>:kharoshthi</td><td>Kharoshthi</td></tr>
+ *     <tr><td>:khmer</td><td>Khmer</td></tr>
+ *     <tr><td>:lao</td><td>Lao</td></tr>
+ *     <tr><td>:latin</td><td>Latin</td></tr>
+ *     <tr><td>:lepcha</td><td>Lepcha</td></tr>
+ *     <tr><td>:limbu</td><td>Limbu</td></tr>
+ *     <tr><td>:linear_b</td><td>Linear B</td></tr>
+ *     <tr><td>:lisu</td><td>Lisu</td></tr>
+ *     <tr><td>:lycian</td><td>Lycian</td></tr>
+ *     <tr><td>:lydian</td><td>Lydian</td></tr>
+ *     <tr><td>:malayalam</td><td>Malayalam</td></tr>
+ *     <tr><td>:mandaic</td><td>Mandaic</td></tr>
+ *     <tr><td>:meetei_mayek</td><td>Meetei Mayek</td></tr>
+ *     <tr><td>:meroitic_hieroglyphs</td><td>Meroitic Hieroglyphs</td></tr>
+ *     <tr><td>:meroitic_cursive</td><td>Meroitic Cursives</td></tr>
+ *     <tr><td>:miao</td><td>Miao</td></tr>
+ *     <tr><td>:mongolian</td><td>Mongolian</td></tr>
+ *     <tr><td>:myanmar</td><td>Myanmar</td></tr>
+ *     <tr><td>:new_tai_lue</td><td>New Tai Lue</td></tr>
+ *     <tr><td>:nko</td><td>N'Ko</td></tr>
+ *     <tr><td>:ogham</td><td>Ogham</td></tr>
+ *     <tr><td>:old_italic</td><td>Old Italic</td></tr>
+ *     <tr><td>:old_persian</td><td>Old Persian</td></tr>
+ *     <tr><td>:old_south_arabian</td><td>Old South Arabian</td></tr>
+ *     <tr><td>:old_turkic</td><td>Old Turkic</td></tr>
+ *     <tr><td>:ol_chiki</td><td>Ol Chiki</td></tr>
+ *     <tr><td>:oriya</td><td>Oriya</td></tr>
+ *     <tr><td>:osmanya</td><td>Osmanya</td></tr>
+ *     <tr><td>:phags_pa</td><td>Phags-pa</td></tr>
+ *     <tr><td>:phoenician</td><td>Phoenician</td></tr>
+ *     <tr><td>:rejang</td><td>Rejang</td></tr>
+ *     <tr><td>:runic</td><td>Runic</td></tr>
+ *     <tr><td>:samaritan</td><td>Samaritan</td></tr>
+ *     <tr><td>:saurashtra</td><td>Saurashtra</td></tr>
+ *     <tr><td>:sharada</td><td>Sharada</td></tr>
+ *     <tr><td>:shavian</td><td>Shavian</td></tr>
+ *     <tr><td>:sinhala</td><td>Sinhala</td></tr>
+ *     <tr><td>:sora_sompeng</td><td>Sora Sompeng</td></tr>
+ *     <tr><td>:sundanese</td><td>Sundanese</td></tr>
+ *     <tr><td>:syloti_nagri</td><td>Syloti Nagri</td></tr>
+ *     <tr><td>:syriac</td><td>Syriac</td></tr>
+ *     <tr><td>:tagalog</td><td>Tagalog</td></tr>
+ *     <tr><td>:tagbanwa</td><td>Tagbanwa</td></tr>
+ *     <tr><td>:tai_le</td><td>Tai Le</td></tr>
+ *     <tr><td>:tai_tham</td><td>Tai Tham</td></tr>
+ *     <tr><td>:tai_viet</td><td>Tai Viet</td></tr>
+ *     <tr><td>:takri</td><td>Takri</td></tr>
+ *     <tr><td>:tamil</td><td>Tamil</td></tr>
+ *     <tr><td>:telugu</td><td>Telugu</td></tr>
+ *     <tr><td>:thaana</td><td>Thaana</td></tr>
+ *     <tr><td>:thai</td><td>Thai</td></tr>
+ *     <tr><td>:tibetan</td><td>Tibetan</td></tr>
+ *     <tr><td>:tifinagh</td><td>Tifinagh</td></tr>
+ *     <tr><td>:ugaritic</td><td>Ugaritic</td></tr>
+ *     <tr><td>:unknown</td><td>For not assigned, private-use, non-character, and surrogate code points</td></tr>
+ *     <tr><td>:vai</td><td>Vai</td></tr>
+ *     <tr><td>:yi</td><td>Yi</td></tr>
+ *   </tbody>
+ * </table>
+ *
+ * @raise [ArgumentError] If the receiver contains two characters belonging to
+ *   different scripts
+ * @raise [ArgumentError] If the receiver contains an incomplete UTF-8 sequence
+ * @raise [ArgumentError] If the receiver contains an invalid UTF-8 sequence
+ * @return [Symbol]
+ * @see http://www.unicode.org/reports/tr24/
+ *   Unicode Standard Annex #24 Unicode Script Property */
+VALUE
+rb_u_string_script(VALUE self)
+{
+        return _rb_u_string_property(self, "script", U_SCRIPT_UNKNOWN,
+                                     (int (*)(uint32_t))u_char_script,
+                                     (VALUE (*)(int))script_to_symbol);
+}