character-encodings 0.2.0

data/ext/encoding/character/utf-8/rb_utf_rstrip.c

@@ -0,0 +1,51 @@
+/*
+ * contents: UTF8.rstrip module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+
+VALUE
+rb_utf_rstrip_bang(UNUSED(VALUE self), VALUE str)
+{
+        StringValue(str);
+        const char *begin = RSTRING(str)->ptr;
+        if (begin == NULL || RSTRING(str)->len == 0)
+                return Qnil;
+
+        const char *end = begin + RSTRING(str)->len;
+        const char *t = end;
+
+        /* Remove trailing '\0'’s. */
+        while (t > begin && t[-1] == '\0')
+                t--;
+
+        /* Remove trailing spaces. */
+        while (t > begin) {
+                /* FIXME: Should we be validating here? */
+                const char *prev = rb_utf_prev_validated(begin, t);
+                
+                if (!unichar_isspace(utf_char(prev)))
+                        break;
+
+                t = prev;
+        }
+
+        if (t == end)
+                return Qnil;
+
+        rb_str_modify(str);
+        RSTRING(str)->len = t - begin;
+        RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+
+        return str;
+}
+
+VALUE
+rb_utf_rstrip(VALUE self, VALUE str)
+{
+        str = rb_utf_dup(str);
+        rb_utf_rstrip_bang(self, str);
+        return str;
+}

data/ext/encoding/character/utf-8/rb_utf_squeeze.c

@@ -0,0 +1,70 @@
+/*
+ * contents: UTF8.squeeze module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+#include "rb_utf_internal_tr.h"
+
+VALUE
+rb_utf_squeeze_bang(int argc, VALUE *argv, UNUSED(VALUE self))
+{
+        need_at_least_n_arguments(argc, 1);
+
+        VALUE str = argv[0];
+        StringValue(str);
+        if (RSTRING(str)->len == 0)
+                return Qnil;
+
+        unsigned int table[TR_TABLE_SIZE];
+        if (argc == 1)
+                for (int i = 0; i < TR_TABLE_SIZE; i++)
+                        table[i] = ~0U;
+        else
+                tr_setup_table_from_strings(table, argc - 1, &argv[1]);
+
+        rb_str_modify(str);
+
+        char *begin = RSTRING(str)->ptr;
+        char const *end = begin + RSTRING(str)->len;
+
+        /* We know that there is a character to eat (if the input isn’t
+         * invalid), as we’ve already verified that RSTRING(str)->len > 0, so
+         * ‘s_end’ must lay beyond ‘s’.  Also, as we validate when we fetch the
+         * character, there’s no need to validate the call to utf_next(). */
+        unichar previous = _utf_char_validated(begin, end);
+        char *s = utf_next(begin);
+        char *t = s;
+        while (s < end) {
+                unichar c = _utf_char_validated(s, end);
+                char *next = utf_next(s);
+
+                if (c != previous || !tr_table_lookup(table, c)) {
+                        memmove(t, s, next - s);
+                        t += next - s;
+                        previous = c;
+                }
+
+                s = next;
+        }
+        *t = '\0';
+
+        if (t - begin != RSTRING(str)->len) {
+                RSTRING(str)->len = t - begin;
+                return str;
+        }
+
+        return Qnil;
+}
+
+VALUE
+rb_utf_squeeze(int argc, VALUE *argv, VALUE self)
+{
+        need_at_least_n_arguments(argc, 1);
+
+        StringValue(argv[0]);
+        argv[0] = rb_utf_dup(argv[0]);
+        rb_utf_squeeze_bang(argc, argv, self);
+        return argv[0];
+}

data/ext/encoding/character/utf-8/rb_utf_strip.c

@@ -0,0 +1,27 @@
+/*
+ * contents: UTF8.strip module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+
+VALUE
+rb_utf_strip_bang(VALUE self, VALUE str)
+{
+        VALUE left = rb_utf_lstrip_bang(self, str);
+        VALUE right = rb_utf_rstrip_bang(self, str);
+
+        if (NIL_P(left) && NIL_P(right))
+                return Qnil;
+
+        return str;
+}
+
+VALUE
+rb_utf_strip(VALUE self, VALUE str)
+{
+        str = rb_utf_dup(str);
+        rb_utf_strip_bang(self, str);
+        return str;
+}

data/ext/encoding/character/utf-8/rb_utf_to_i.c

@@ -0,0 +1,25 @@
+/*
+ * contents: UTF8.to_i module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+#include "rb_utf_internal_bignum.h"
+
+VALUE
+rb_utf_to_i(int argc, VALUE *argv, UNUSED(VALUE self))
+{
+        VALUE str, rbbase;
+
+        int base = 10;
+        if (rb_scan_args(argc, argv, "11", &str, &rbbase) == 2)
+                base = NUM2INT(rbbase);
+
+        /* XXX: this test is actually unnecessary, as this will be checked in
+         * rb_utf_to_inum() as well. */
+        if (base < 0)
+                rb_raise(rb_eArgError, "illegal radix %d", base);
+
+        return rb_utf_to_inum(str, base, false);
+}

data/ext/encoding/character/utf-8/rb_utf_tr.c

@@ -0,0 +1,250 @@
+/*
+ * contents: UTF8.tr module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+#include "rb_utf_internal_tr.h"
+
+struct tr_range
+{
+        unichar begin;
+        unichar end;
+};
+
+static int
+tr_ranges_setup(struct tr *tr, struct tr_range *ranges)
+{
+        int n = 0;
+        bool was_inside_range = false;
+        while (tr_next(tr) != TR_FINISHED) {
+                if (tr->inside_range) {
+                        if (!was_inside_range) {
+                                ranges[n].begin = tr->now;
+                                was_inside_range = true;
+                        }
+                } else {
+                        if (was_inside_range)
+                                ranges[n].end = tr->now;
+                        else
+                                ranges[n].begin = ranges[n].end = tr->now;
+                        n++;
+                        was_inside_range = false;
+                }
+        }
+
+        return n;
+}
+
+
+struct tr_trans_closure
+{
+        struct tr_range *from;
+        int n_from;
+        struct tr_range *to;
+        int n_to;
+};
+
+static unichar
+tr_trans_replace_exclude(UNUSED(unichar c), void *closure)
+{
+        return *((unichar *)closure);
+}
+
+static int
+tr_trans_replace_include_offset_of(struct tr_range *ranges, int range)
+{
+        int offset = 0;
+
+        for (int i = 0; i < range; i++)
+                offset += ranges[i].end - ranges[i].begin + 1;
+
+        return offset;
+}
+
+static unichar
+tr_trans_replace_include(unichar c, void *v_closure)
+{
+        struct tr_trans_closure *closure = (struct tr_trans_closure *)v_closure;
+
+        for (int i = closure->n_from - 1; i >= 0; i--) {
+                if (closure->from[i].begin >= c && closure->from[i].end <= c) {
+                        int offset = tr_trans_replace_include_offset_of(closure->from, i);
+                        int j;
+                        for (j = 0; j < closure->n_to && offset > 0; j++)
+                                offset -= closure->to[j].end - closure->to[j].begin + 1;
+
+                        if (offset > 0)
+                                return closure->to[closure->n_to - 1].end;
+
+                        return closure->to[j].end - offset;
+                }
+        }
+
+        return closure->to[closure->n_to - 1].end;
+}
+
+static VALUE
+tr_trans_do(VALUE src, unsigned int *translation,
+            unichar (*replace)(unichar, void *), void *closure, bool squeeze,
+            UNUSED(bool replace_content))
+{
+        VALUE dst = Qnil;
+        long len;
+
+again:
+        len = 0;
+
+        const char *s = RSTRING(src)->ptr;
+        const char *s_end = s + RSTRING(src)->len;
+
+        char *t = NULL;
+        
+        if (dst != Qnil)
+                t = RSTRING(dst)->ptr;
+
+        bool modified = false;
+
+        /* TODO: this should really be refactored… */
+        if (squeeze) {
+                unichar prev_c = -1;
+
+                while (s < s_end) {
+                        unichar c0 = utf_char(s);
+
+                        const char *prev = s;
+                        s = utf_next(s);
+
+                        if (tr_table_lookup(translation, c0)) {
+                                unichar c = replace(c0, closure);
+                                if (prev_c == c)
+                                        continue;
+                                prev_c = c;
+                                len += unichar_to_utf(c, (t != NULL) ? t + len : NULL);
+                                modified = true;
+                        } else {
+                                prev_c = -1;
+                                if (t != NULL)
+                                        memcpy(t + len, prev, s - prev);
+                                len += s - prev;
+                        }
+
+                }
+
+                if (RSTRING(src)->len > (t + len - RSTRING(src)->ptr))
+                        modified = true;
+        } else {
+                while (s < s_end) {
+                        unichar c = utf_char(s);
+
+                        const char *prev = s;
+                        s = utf_next(s);
+
+                        if (tr_table_lookup(translation, c)) {
+                                len += unichar_to_utf(replace(c, closure),
+                                                      (t != NULL) ? t + len : NULL);
+                                modified = true;
+                        } else {
+                                if (t != NULL)
+                                        memcpy(t + len, prev, s - prev);
+                                len += s - prev;
+                        }
+                }
+        }
+
+#ifdef RB_STR_REPLACE_IS_EXTERN
+        if (replace_content && !modified)
+                return Qnil;
+#endif
+
+        if (dst == Qnil) {
+#ifdef RB_STR_REPLACE_IS_EXTERN
+                if (replace_content && len <= RSTRING(src)->len)
+                        dst = src;
+                else
+#endif
+                        dst = rb_str_buf_new(len);
+                goto again;
+        }
+
+        t[len] = '\0';
+        RSTRING(dst)->len = len;
+
+#ifdef RB_STR_REPLACE_IS_EXTERN
+        if (dst != src && replace_content) {
+                rb_str_replace(src, dst);
+                return src;
+        }
+#endif
+
+        return dst;
+}
+
+static VALUE
+tr_trans(VALUE str, VALUE from, VALUE to, bool squeeze, bool replace_content)
+{
+        StringValue(str);
+        StringValue(from);
+        StringValue(to);
+
+        if (RSTRING(str)->ptr == NULL || RSTRING(str)->len == 0)
+                return replace_content ? Qnil : str;
+
+        if (RSTRING(to)->len == 0)
+                return rb_utf_delete_bang(1, &from, str);
+
+        struct tr tr_from;
+        tr_init(&tr_from,
+                RSTRING(from)->ptr,
+                RSTRING(from)->ptr + RSTRING(from)->len);
+
+        struct tr tr_to;
+        tr_init(&tr_to,
+                RSTRING(to)->ptr,
+                RSTRING(to)->ptr + RSTRING(to)->len);
+
+        unsigned int translation[TR_TABLE_SIZE];
+        tr_setup_table(from, translation, true);
+
+        tr_init(&tr_from,
+                RSTRING(from)->ptr,
+                RSTRING(from)->ptr + RSTRING(from)->len);
+        if (tr_should_exclude(&tr_from)) {
+                /* This case is easy.  Just include everything by default and
+                 * exclude the rest as always.  Replace characters found by the
+                 * last character found in tr_to. */
+                while (tr_next(&tr_to) != TR_FINISHED)
+                       ; /* We just need the last replacement character. */
+                return tr_trans_do(str, translation, tr_trans_replace_exclude,
+                                   &tr_to.now, squeeze, replace_content);
+        } else {
+                /* This case is hard.  We need a full-fledged lookup of what
+                 * character to translate to, not simply a check whether to
+                 * include it or not. */
+                struct tr_trans_closure trans_closure;
+
+                struct tr_range from_ranges[utf_length_n(RSTRING(from)->ptr, RSTRING(from)->len)];
+                trans_closure.from = from_ranges;
+                trans_closure.n_from = tr_ranges_setup(&tr_from, from_ranges);
+
+                struct tr_range to_ranges[utf_length_n(RSTRING(to)->ptr, RSTRING(to)->len)];
+                trans_closure.to = to_ranges;
+                trans_closure.n_to = tr_ranges_setup(&tr_to, to_ranges);
+
+                return tr_trans_do(str, translation, tr_trans_replace_include,
+                                   &trans_closure, squeeze, replace_content);
+        }
+}
+
+VALUE
+rb_utf_tr(UNUSED(VALUE self), VALUE str, VALUE from, VALUE to)
+{
+        return tr_trans(str, from, to, false, false);
+}
+
+VALUE
+rb_utf_tr_s(UNUSED(VALUE self), VALUE str, VALUE from, VALUE to)
+{
+        return tr_trans(str, from, to, true, false);
+}

data/ext/encoding/character/utf-8/rb_utf_upcase.c

@@ -0,0 +1,13 @@
+/*
+ * contents: UTF8.upcase module function.
+ *
+ * Copyright © 2006 Nikolai Weibull <now@bitwi.se>
+ */
+
+#include "rb_includes.h"
+
+VALUE
+rb_utf_upcase(UNUSED(VALUE self), VALUE str)
+{
+        return rb_utf_alloc_using(utf_upcase(StringValuePtr(str)));
+}

data/ext/encoding/character/utf-8/unicode.c

@@ -0,0 +1,319 @@
+/*
+ * contents: Unicode class.
+ *
+ * Copyright © 2005 Nikolai Weibull <work@rawuncut.elitemail.org>
+ */
+
+
+#include <ruby.h>
+#include <re.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include "unicode.h"
+#include "private.h"
+#include "rb_methods.h"
+
+static VALUE mUTF8Methods;
+
+void
+need_at_least_n_arguments(int argc, int n)
+{
+        static const char *const words[] = {
+                NULL,   NULL, "two",   "three", "four",
+                "five", "six", "seven", "eight", "nine"
+        };
+
+        if (argc >= n)
+                return;
+
+        if (n == 1)
+                rb_raise(rb_eArgError, "need at least one argument");
+        else if (1 < n && n < 10)
+                rb_raise(rb_eArgError, "need at least %s arguments", words[n]);
+        else
+                rb_raise(rb_eArgError, "need at least %d arguments", n);
+}
+
+unichar
+_utf_char_validated(char const *const str, char const *const str_end)
+{
+        unichar c = utf_char_validated_n(str, str_end - str);
+        switch (c) {
+        case UTF_BAD_INPUT_UNICHAR:
+                rb_raise(rb_eArgError, "input isn’t valid UTF-8");
+        case UTF_INCOMPLETE_INPUT_UNICHAR:
+                rb_raise(rb_eArgError,
+                         "input contains an incomplete UTF-8-encoded character");
+        default:
+                return c;
+        }
+}
+
+/* TODO: instead of ‘end’, perhaps use a len/max-type parameter? */
+char *
+_utf_offset_to_pointer_validated_impl(const char *str, long offset,
+                                      const char *limit, bool noisy)
+{
+	const char *p = str;
+        long saved_offset = offset;
+
+        if (offset > 0) {
+                while (p < limit && offset-- > 0)
+                        p = utf_next(p);
+
+                if (offset > 0) {
+                        if (noisy)
+                                rb_raise(rb_eIndexError,
+                                         "index %ld lays beyond end of string",
+                                         saved_offset);
+                        else
+                                return NULL;
+                }
+        } else {
+                while (offset != 0) {
+                        const char *base = p;
+                        p += offset;
+                        while (p >= limit && (*p & 0xc0) == 0x80)
+                                p--;
+
+                        if (p < limit) {
+                                if (noisy)
+                                        rb_raise(rb_eIndexError,
+                                                "index %ld lays before beginning of string",
+                                                saved_offset);
+                                else
+                                        return NULL;
+                                                break;
+                        }
+         
+                        offset += utf_pointer_to_offset(p, base);
+                 }
+        }
+
+	return (char *)p;
+}
+
+char *
+_utf_offset_to_pointer_validated(const char *str, long offset, const char *end)
+{
+        return _utf_offset_to_pointer_validated_impl(str, offset, end, true);
+}
+
+char *
+_utf_offset_to_pointer_failable(const char *str, long offset, const char *end)
+{
+        return _utf_offset_to_pointer_validated_impl(str, offset, end, false);
+}
+
+static char *
+rb_utf_begin_setup(VALUE str, long offset, char **base_limit, char **limit)
+{
+        char *base = RSTRING(str)->ptr;
+
+        *base_limit = RSTRING(str)->ptr + RSTRING(str)->len;
+        *limit = *base_limit;
+
+        if (offset < 0) {
+                char *tmp = base;
+                base = *base_limit;
+                *base_limit = tmp;
+        }
+
+        return base;
+}
+
+bool
+rb_utf_begin_from_offset(VALUE str, long offset, char **begin, char **limit)
+{
+        char *base_limit;
+        char *base = rb_utf_begin_setup(str, offset, &base_limit, limit);
+
+        *begin = _utf_offset_to_pointer_failable(base, offset, base_limit);
+
+        return (*begin != NULL);
+}
+
+void
+rb_utf_begin_from_offset_validated(VALUE str, long offset, char **begin,
+                                   char **limit)
+{
+        char *base_limit;
+        char *base = rb_utf_begin_setup(str, offset, &base_limit, limit);
+
+        *begin = _utf_offset_to_pointer_validated(base, offset, base_limit);
+}
+
+char *
+rb_utf_prev_validated(const char *begin, const char *p)
+{
+        char *prev = utf_find_prev(begin, p);
+        if (prev == NULL)
+                rb_raise(rb_eArgError, "input isn’t valid UTF-8");
+        return prev;
+}
+
+char *
+rb_utf_next_validated(const char *p, const char *end)
+{
+        char *next = (char *)utf_next(p);
+        if (next > end)
+                rb_raise(rb_eArgError, "input isn’t valid UTF-8");
+        return next;
+}
+
+VALUE
+rb_utf_update(VALUE str, long offset, long len, VALUE replacement)
+{
+        if (len < 0)
+                rb_raise(rb_eIndexError, "negative length %ld", len);
+
+        char *begin, *limit;
+        rb_utf_begin_from_offset_validated(str, offset, &begin, &limit);
+        char *end = _utf_offset_to_pointer_failable(begin, len, limit);
+        if (end == NULL)
+                end = limit;
+
+        rb_str_update(str, begin - RSTRING(str)->ptr, end - begin, replacement);
+
+        return replacement;
+}
+
+VALUE
+rb_utf_new(const char *str, long len)
+{
+        VALUE rbstr = rb_str_new(str, len);
+        rb_extend_object(rbstr, mUTF8Methods);
+        return rbstr;
+}
+
+VALUE
+rb_utf_new2(const char *str)
+{
+        VALUE rbstr = rb_str_new2(str);
+        rb_extend_object(rbstr, mUTF8Methods);
+        return rbstr;
+}
+
+VALUE
+rb_utf_new5(VALUE obj, const char *str, long len)
+{
+        VALUE rbstr = rb_str_new5(obj, str, len);
+        rb_extend_object(rbstr, mUTF8Methods);
+        return rbstr;
+}
+
+VALUE
+rb_utf_alloc_using(char *str)
+{
+        VALUE rbstr = rb_utf_new(NULL, 0);
+        long len = strlen(str);
+
+        RSTRING(rbstr)->ptr = str;
+        RSTRING(rbstr)->aux.capa = len;
+        RSTRING(rbstr)->len = len;
+        RSTRING(rbstr)->ptr[len] = '\0';
+
+        return rbstr;
+}
+
+VALUE
+rb_utf_dup(VALUE str)
+{
+        str = rb_str_dup(str);
+        rb_extend_object(str, mUTF8Methods);
+        return str;
+}
+
+/* TODO: rewrite this using the new offset-calculating functions. */
+long
+rb_utf_index(VALUE str, VALUE sub, long offset)
+{
+        long n_chars = utf_length_n(RSTRING(str)->ptr, RSTRING(str)->len);
+
+        if (offset < 0) {
+                offset += n_chars;
+
+                if (offset < 0)
+                        return -1;
+        }
+
+        if (n_chars - offset < utf_length(RSTRING(sub)->ptr))
+                return -1;
+
+        if (RSTRING(sub)->len == 0)
+                return offset;
+
+        char *begin = utf_offset_to_pointer(RSTRING(str)->ptr, offset);
+        long pos = rb_memsearch(RSTRING(sub)->ptr, RSTRING(sub)->len,
+                                begin, RSTRING(str)->len - (begin - RSTRING(str)->ptr));
+
+        if (pos < 0)
+                return -1;
+
+        return offset + utf_pointer_to_offset(begin, begin + pos);
+}
+
+long
+rb_utf_index_regexp(VALUE str, const char *s, const char *end, VALUE sub,
+                    long offset, bool reverse)
+{
+        long byte_offset = _utf_offset_to_pointer_validated(s, offset, end) - s;
+        long byte_startpos = rb_reg_adjust_startpos(sub, str, byte_offset, reverse);
+        long byte_index = rb_reg_search(sub, str, byte_startpos, reverse);
+        if (byte_index == -1)
+                return -1;
+        return utf_pointer_to_offset(s, s + byte_index);
+}
+
+void Init_utf8(void);
+void
+Init_utf8(void)
+{
+        VALUE mEncoding = rb_define_module("Encoding");
+        VALUE mCharacter = rb_define_module_under(mEncoding, "Character");
+        VALUE mUTF8 = rb_define_module_under(mCharacter, "UTF8");
+
+        mUTF8Methods = rb_define_module_under(mUTF8, "Methods");
+
+        rb_define_module_function(mUTF8, "collate", rb_utf_collate, 2);
+        rb_define_module_function(mUTF8, "aref", rb_utf_aref_m, -1);
+        rb_define_module_function(mUTF8, "aset", rb_utf_aset_m, -1);
+        rb_define_module_function(mUTF8, "casecmp", rb_utf_casecmp, 2);
+        rb_define_module_function(mUTF8, "center", rb_utf_center, -1);
+        rb_define_module_function(mUTF8, "chomp", rb_utf_chomp, -1);
+        rb_define_module_function(mUTF8, "chomp!", rb_utf_chomp_bang, -1);
+        rb_define_module_function(mUTF8, "chop", rb_utf_chop, 1);
+        rb_define_module_function(mUTF8, "chop!", rb_utf_chop_bang, 1);
+        rb_define_module_function(mUTF8, "count", rb_utf_count, -1);
+        rb_define_module_function(mUTF8, "delete", rb_utf_delete, -1);
+        rb_define_module_function(mUTF8, "delete!", rb_utf_delete_bang, -1);
+        rb_define_module_function(mUTF8, "each_char", rb_utf_each_char, 1);
+        rb_define_module_function(mUTF8, "index", rb_utf_index_m, -1);
+        rb_define_module_function(mUTF8, "insert", rb_utf_insert, 3);
+        rb_define_module_function(mUTF8, "lstrip", rb_utf_lstrip, 1);
+        rb_define_module_function(mUTF8, "lstrip!", rb_utf_lstrip_bang, 1);
+        rb_define_module_function(mUTF8, "rindex", rb_utf_rindex_m, -1);
+        rb_define_module_function(mUTF8, "rstrip", rb_utf_rstrip, 1);
+        rb_define_module_function(mUTF8, "rstrip!", rb_utf_rstrip_bang, 1);
+        rb_define_module_function(mUTF8, "squeeze", rb_utf_squeeze, -1);
+        rb_define_module_function(mUTF8, "squeeze!", rb_utf_squeeze_bang, -1);
+        rb_define_module_function(mUTF8, "strip", rb_utf_strip, 1);
+        rb_define_module_function(mUTF8, "strip!", rb_utf_strip_bang, 1);
+        rb_define_module_function(mUTF8, "to_i", rb_utf_to_i, -1);
+        rb_define_module_function(mUTF8, "hex", rb_utf_hex, 1);
+        rb_define_module_function(mUTF8, "oct", rb_utf_oct, 1);
+        rb_define_module_function(mUTF8, "tr", rb_utf_tr, 3);
+        rb_define_module_function(mUTF8, "tr_s", rb_utf_tr_s, 3);
+
+        rb_define_module_function(mUTF8, "downcase", rb_utf_downcase, 1);
+        rb_define_module_function(mUTF8, "ljust", rb_utf_ljust, -1);
+        rb_define_module_function(mUTF8, "length", rb_utf_length, 1);
+        rb_define_module_function(mUTF8, "reverse", rb_utf_reverse, 1);
+        rb_define_module_function(mUTF8, "rjust", rb_utf_rjust, -1);
+        rb_define_module_function(mUTF8, "upcase", rb_utf_upcase, 1);
+
+        rb_define_module_function(mUTF8, "foldcase", rb_utf_foldcase, 1);
+        rb_define_module_function(mUTF8, "normalize", rb_utf_normalize, -1);
+}