/********************************************************************** re.c - $Author$ created at: Mon Aug 9 18:24:49 JST 1993 Copyright (C) 1993-2007 Yukihiro Matsumoto **********************************************************************/ #include "ruby/ruby.h" #include "ruby/re.h" #include "ruby/encoding.h" #include "regint.h" #include VALUE rb_eRegexpError; typedef char onig_errmsg_buffer[ONIG_MAX_ERROR_MESSAGE_LEN]; #define BEG(no) regs->beg[no] #define END(no) regs->end[no] #if 'a' == 97 /* it's ascii */ static const char casetable[] = { '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', /* ' ' '!' '"' '#' '$' '%' '&' ''' */ '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', /* '(' ')' '*' '+' ',' '-' '.' '/' */ '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', /* '0' '1' '2' '3' '4' '5' '6' '7' */ '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', /* '8' '9' ':' ';' '<' '=' '>' '?' */ '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', /* '@' 'A' 'B' 'C' 'D' 'E' 'F' 'G' */ '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', /* 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' */ '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', /* 'P' 'Q' 'R' 'S' 'T' 'U' 'V' 'W' */ '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', /* 'X' 'Y' 'Z' '[' '\' ']' '^' '_' */ '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', /* '`' 'a' 'b' 'c' 'd' 'e' 'f' 'g' */ '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', /* 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' */ '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', /* 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' */ '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', /* 'x' 'y' 'z' '{' '|' '}' '~' */ '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307', '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317', '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327', '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337', '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', }; #else # error >>> "You lose. You will need a translation table for your character set." <<< #endif int rb_memcicmp(const void *x, const void *y, long len) { const unsigned char *p1 = x, *p2 = y; int tmp; while (len--) { if ((tmp = casetable[(unsigned)*p1++] - casetable[(unsigned)*p2++])) return tmp; } return 0; } #undef rb_memcmp int rb_memcmp(const void *p1, const void *p2, long len) { return memcmp(p1, p2, len); } long rb_memsearch(const void *x0, long m, const void *y0, long n) { const unsigned char *x = x0, *y = y0; const unsigned char *s, *e; long i; int d; unsigned long hx, hy; #define KR_REHASH(a, b, h) (((h) << 1) - (((unsigned long)(a))< n) return -1; s = y; e = s + n - m; /* Preprocessing */ /* computes d = 2^(m-1) with the left-shift operator */ d = sizeof(hx) * CHAR_BIT - 1; if (d > m) d = m; if (n == m) { return memcmp(x, s, m) == 0 ? 0 : -1; } /* Prepare hash value */ for (hy = hx = i = 0; i < d; ++i) { hx = KR_REHASH(0, x[i], hx); hy = KR_REHASH(0, s[i], hy); } /* Searching */ while (hx != hy || memcmp(x, s, m)) { if (s >= e) return -1; hy = KR_REHASH(*s, *(s+d), hy); s++; } return s-y; } #define REG_LITERAL FL_USER5 #define REG_CASESTATE FL_USER0 #define KCODE_FIXED FL_USER4 #define ARG_REG_OPTION_MASK \ (ONIG_OPTION_IGNORECASE|ONIG_OPTION_MULTILINE|ONIG_OPTION_EXTEND) #define ARG_ENCODING_FIXED 16 #define ARG_KCODE_NONE 0 #define ARG_KCODE_EUC 1 #define ARG_KCODE_SJIS 2 #define ARG_KCODE_UTF8 3 static int char_to_option(int c) { int val; switch (c) { case 'i': val = ONIG_OPTION_IGNORECASE; break; case 'x': val = ONIG_OPTION_EXTEND; break; case 'm': val = ONIG_OPTION_MULTILINE; break; default: val = 0; break; } return val; } static char * option_to_str(char str[4], int options) { char *p = str; if (options & ONIG_OPTION_MULTILINE) *p++ = 'm'; if (options & ONIG_OPTION_IGNORECASE) *p++ = 'i'; if (options & ONIG_OPTION_EXTEND) *p++ = 'x'; *p = 0; return str; } extern int rb_char_to_option_kcode(int c, int *option, int *kcode) { *option = 0; switch (c) { case 'n': *kcode = ARG_KCODE_NONE; break; case 'e': *kcode = ARG_KCODE_EUC; break; case 's': *kcode = ARG_KCODE_SJIS; break; case 'u': *kcode = ARG_KCODE_UTF8; break; default: *kcode = -1; return (*option = char_to_option(c)); } *option = ARG_ENCODING_FIXED; return 1; } static void rb_reg_check(VALUE re) { if (!RREGEXP(re)->ptr || !RREGEXP(re)->str) { rb_raise(rb_eTypeError, "uninitialized Regexp"); } } static void rb_reg_expr_str(VALUE str, const char *s, long len) { rb_encoding *enc = rb_enc_get(str); const char *p, *pend; int need_escape = 0; p = s; pend = p + len; while (pptr->options)) rb_str_buf_cat2(str, opts); } OBJ_INFECT(str, re); return str; } /* * call-seq: * rxp.source => str * * Returns the original string of the pattern. * * /ab+c/ix.source #=> "ab+c" */ static VALUE rb_reg_source(VALUE re) { VALUE str; rb_reg_check(re); str = rb_str_new(RREGEXP(re)->str,RREGEXP(re)->len); if (OBJ_TAINTED(re)) OBJ_TAINT(str); return str; } /* * call-seq: * rxp.inspect => string * * Produce a nicely formatted string-version of _rxp_. Perhaps surprisingly, * #inspect actually produces the more natural version of * the string than #to_s. * * /ab+c/ix.to_s #=> /ab+c/ix */ static VALUE rb_reg_inspect(VALUE re) { rb_reg_check(re); return rb_reg_desc(RREGEXP(re)->str, RREGEXP(re)->len, re); } /* * call-seq: * rxp.to_s => str * * Returns a string containing the regular expression and its options (using the * (?xxx:yyy) notation. This string can be fed back in to * Regexp::new to a regular expression with the same semantics as * the original. (However, Regexp#== may not return true when * comparing the two, as the source of the regular expression itself may * differ, as the example shows). Regexp#inspect produces a * generally more readable version of rxp. * * r1 = /ab+c/ix #=> /ab+c/ix * s1 = r1.to_s #=> "(?ix-m:ab+c)" * r2 = Regexp.new(s1) #=> /(?ix-m:ab+c)/ * r1 == r2 #=> false * r1.source #=> "ab+c" * r2.source #=> "(?ix-m:ab+c)" */ static VALUE rb_reg_to_s(VALUE re) { int options, opt; const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND; long len; const UChar* ptr; VALUE str = rb_str_buf_new2("(?"); char optbuf[5]; rb_reg_check(re); rb_enc_copy(str, re); options = RREGEXP(re)->ptr->options; ptr = (UChar*)RREGEXP(re)->str; len = RREGEXP(re)->len; again: if (len >= 4 && ptr[0] == '(' && ptr[1] == '?') { int err = 1; ptr += 2; if ((len -= 2) > 0) { do { opt = char_to_option((int )*ptr); if (opt != 0) { options |= opt; } else { break; } ++ptr; } while (--len > 0); } if (len > 1 && *ptr == '-') { ++ptr; --len; do { opt = char_to_option((int )*ptr); if (opt != 0) { options &= ~opt; } else { break; } ++ptr; } while (--len > 0); } if (*ptr == ')') { --len; ++ptr; goto again; } if (*ptr == ':' && ptr[len-1] == ')') { int r; Regexp *rp; r = onig_alloc_init(&rp, ONIG_OPTION_DEFAULT, ONIGENC_CASE_FOLD_DEFAULT, rb_enc_get(re), OnigDefaultSyntax); if (r == 0) { ++ptr; len -= 2; err = (onig_compile(rp, ptr, ptr + len, NULL) != 0); } onig_free(rp); } if (err) { options = RREGEXP(re)->ptr->options; ptr = (UChar*)RREGEXP(re)->str; len = RREGEXP(re)->len; } } if (*option_to_str(optbuf, options)) rb_str_buf_cat2(str, optbuf); if ((options & embeddable) != embeddable) { optbuf[0] = '-'; option_to_str(optbuf + 1, ~options); rb_str_buf_cat2(str, optbuf); } rb_str_buf_cat2(str, ":"); rb_reg_expr_str(str, (char*)ptr, len); rb_str_buf_cat2(str, ")"); rb_enc_copy(str, re); OBJ_INFECT(str, re); return str; } static void rb_reg_raise(const char *s, long len, const char *err, VALUE re) { VALUE desc = rb_reg_desc(s, len, re); rb_raise(rb_eRegexpError, "%s: %s", err, RSTRING_PTR(desc)); } static VALUE rb_reg_error_desc(VALUE str, int options, const char *err) { char opts[6]; VALUE desc = rb_str_buf_new2(err); rb_enc_copy(desc, str); rb_str_buf_cat2(desc, ": /"); rb_reg_expr_str(desc, RSTRING_PTR(str), RSTRING_LEN(str)); opts[0] = '/'; option_to_str(opts + 1, options); rb_str_buf_cat2(desc, opts); return rb_exc_new3(rb_eRegexpError, desc); } static void rb_reg_raise_str(VALUE str, int options, const char *err) { rb_exc_raise(rb_reg_error_desc(str, options, err)); } /* * call-seq: * rxp.casefold? => true or false * * Returns the value of the case-insensitive flag. */ static VALUE rb_reg_casefold_p(VALUE re) { rb_reg_check(re); if (RREGEXP(re)->ptr->options & ONIG_OPTION_IGNORECASE) return Qtrue; return Qfalse; } /* * call-seq: * rxp.options => fixnum * * Returns the set of bits corresponding to the options used when creating this * Regexp (see Regexp::new for details. Note that additional bits * may be set in the returned options: these are used internally by the regular * expression code. These extra bits are ignored if the options are passed to * Regexp::new. * * Regexp::IGNORECASE #=> 1 * Regexp::EXTENDED #=> 2 * Regexp::MULTILINE #=> 4 * * /cat/.options #=> 128 * /cat/ix.options #=> 131 * Regexp.new('cat', true).options #=> 129 * Regexp.new('cat', 0, 's').options #=> 384 * * r = /cat/ix * Regexp.new(r.source, r.options) #=> /cat/ix */ static VALUE rb_reg_options_m(VALUE re) { int options = rb_reg_options(re); return INT2NUM(options); } static Regexp* make_regexp(const char *s, long len, rb_encoding *enc, int flags, onig_errmsg_buffer err) { Regexp *rp; int r; OnigErrorInfo einfo; /* Handle escaped characters first. */ /* Build a copy of the string (in dest) with the escaped characters translated, and generate the regex from that. */ r = onig_alloc_init(&rp, flags, ONIGENC_CASE_FOLD_DEFAULT, enc, OnigDefaultSyntax); if (r) { onig_error_code_to_str((UChar*)err, r); return 0; } r = onig_compile(rp, (UChar*)s, (UChar*)(s + len), &einfo); if (r != 0) { onig_free(rp); (void )onig_error_code_to_str((UChar*)err, r, &einfo); return 0; } return rp; } /* * Document-class: MatchData * * MatchData is the type of the special variable $~, * and is the type of the object returned by Regexp#match and * Regexp#last_match. It encapsulates all the results of a pattern * match, results normally accessed through the special variables * $&, $', $`, $1, * $2, and so on. Matchdata is also known as * MatchingData. * */ VALUE rb_cMatch; static VALUE match_alloc(VALUE klass) { NEWOBJ(match, struct RMatch); OBJSETUP(match, klass, T_MATCH); match->str = 0; match->regs = 0; match->regexp = 0; match->regs = ALLOC(struct re_registers); MEMZERO(match->regs, struct re_registers, 1); return (VALUE)match; } /* :nodoc: */ static VALUE match_init_copy(VALUE obj, VALUE orig) { if (obj == orig) return obj; if (!rb_obj_is_instance_of(orig, rb_obj_class(obj))) { rb_raise(rb_eTypeError, "wrong argument class"); } RMATCH(obj)->str = RMATCH(orig)->str; onig_region_free(RMATCH(obj)->regs, 0); RMATCH(obj)->regs->allocated = 0; onig_region_copy(RMATCH(obj)->regs, RMATCH(orig)->regs); return obj; } /* * call-seq: * mtch.length => integer * mtch.size => integer * * Returns the number of elements in the match array. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.length #=> 5 * m.size #=> 5 */ static VALUE match_size(VALUE match) { return INT2FIX(RMATCH(match)->regs->num_regs); } /* * call-seq: * mtch.offset(n) => array * * Returns a two-element array containing the beginning and ending offsets of * the nth match. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.offset(0) #=> [1, 7] * m.offset(4) #=> [6, 7] */ static VALUE match_offset(VALUE match, VALUE n) { int i = NUM2INT(n); if (i < 0 || RMATCH(match)->regs->num_regs <= i) rb_raise(rb_eIndexError, "index %d out of matches", i); if (RMATCH(match)->regs->beg[i] < 0) return rb_assoc_new(Qnil, Qnil); return rb_assoc_new(INT2FIX(RMATCH(match)->regs->beg[i]), INT2FIX(RMATCH(match)->regs->end[i])); } /* * call-seq: * mtch.begin(n) => integer * * Returns the offset of the start of the nth element of the match * array in the string. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.begin(0) #=> 1 * m.begin(2) #=> 2 */ static VALUE match_begin(VALUE match, VALUE n) { int i = NUM2INT(n); if (i < 0 || RMATCH(match)->regs->num_regs <= i) rb_raise(rb_eIndexError, "index %d out of matches", i); if (RMATCH(match)->regs->beg[i] < 0) return Qnil; return INT2FIX(RMATCH(match)->regs->beg[i]); } /* * call-seq: * mtch.end(n) => integer * * Returns the offset of the character immediately following the end of the * nth element of the match array in the string. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.end(0) #=> 7 * m.end(2) #=> 3 */ static VALUE match_end(VALUE match, VALUE n) { int i = NUM2INT(n); if (i < 0 || RMATCH(match)->regs->num_regs <= i) rb_raise(rb_eIndexError, "index %d out of matches", i); if (RMATCH(match)->regs->beg[i] < 0) return Qnil; return INT2FIX(RMATCH(match)->regs->end[i]); } #define MATCH_BUSY FL_USER2 void rb_match_busy(VALUE match) { FL_SET(match, MATCH_BUSY); } static void rb_reg_prepare_re(VALUE re, VALUE str) { int need_recompile = 0; int state; rb_encoding *enc; rb_reg_check(re); state = FL_TEST(re, REG_CASESTATE); /* ignorecase status */ if (ENCODING_GET(re) == 0 && !FL_TEST(re, KCODE_FIXED) && (enc = rb_enc_get(str)) != 0 && RREGEXP(re)->ptr->enc != enc) { need_recompile = 1; } if (need_recompile) { onig_errmsg_buffer err; int r; OnigErrorInfo einfo; regex_t *reg, *reg2; UChar *pattern; rb_reg_check(re); reg = RREGEXP(re)->ptr; pattern = ((UChar*)RREGEXP(re)->str); r = onig_new(®2, (UChar* )pattern, (UChar* )(pattern + RREGEXP(re)->len), reg->options, enc, OnigDefaultSyntax, &einfo); if (r) { onig_error_code_to_str((UChar*)err, r, &einfo); rb_reg_raise((char* )pattern, RREGEXP(re)->len, err, re); } RREGEXP(re)->ptr = reg2; onig_free(reg); } } long rb_reg_adjust_startpos(VALUE re, VALUE str, long pos, long reverse) { long range; OnigEncoding enc; UChar *p, *string; rb_reg_check(re); rb_reg_prepare_re(re, str); if (reverse) { range = -pos; } else { range = RSTRING_LEN(str) - pos; } enc = (RREGEXP(re)->ptr)->enc; if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) { string = (UChar*)RSTRING_PTR(str); if (range > 0) { p = onigenc_get_right_adjust_char_head(enc, string, string + pos); } else { p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, string, string + pos); } return p - string; } return pos; } long rb_reg_search(VALUE re, VALUE str, long pos, long reverse) { long result; VALUE match; static struct re_registers regs; long range; if (pos > RSTRING_LEN(str) || pos < 0) { rb_backref_set(Qnil); return -1; } rb_reg_check(re); rb_reg_prepare_re(re, str); if (reverse) { range = -pos; } else { range = RSTRING_LEN(str) - pos; } result = onig_search(RREGEXP(re)->ptr, (UChar*)(RSTRING_PTR(str)), ((UChar*)(RSTRING_PTR(str)) + RSTRING_LEN(str)), ((UChar*)(RSTRING_PTR(str)) + pos), ((UChar*)(RSTRING_PTR(str)) + pos + range), ®s, ONIG_OPTION_NONE); if (result < 0) { if (result == ONIG_MISMATCH) { rb_backref_set(Qnil); return result; } else { onig_errmsg_buffer err; onig_error_code_to_str((UChar*)err, result); rb_reg_raise(RREGEXP(re)->str, RREGEXP(re)->len, err, 0); } } match = rb_backref_get(); if (NIL_P(match) || FL_TEST(match, MATCH_BUSY)) { match = match_alloc(rb_cMatch); } else { if (rb_safe_level() >= 3) OBJ_TAINT(match); else FL_UNSET(match, FL_TAINT); } onig_region_copy(RMATCH(match)->regs, ®s); RMATCH(match)->str = rb_str_new4(str); RMATCH(match)->regexp = re; rb_backref_set(match); OBJ_INFECT(match, re); OBJ_INFECT(match, str); return result; } VALUE rb_reg_nth_defined(int nth, VALUE match) { if (NIL_P(match)) return Qnil; if (nth >= RMATCH(match)->regs->num_regs) { return Qnil; } if (nth < 0) { nth += RMATCH(match)->regs->num_regs; if (nth <= 0) return Qnil; } if (RMATCH(match)->BEG(nth) == -1) return Qfalse; return Qtrue; } VALUE rb_reg_nth_match(int nth, VALUE match) { VALUE str; long start, end, len; if (NIL_P(match)) return Qnil; if (nth >= RMATCH(match)->regs->num_regs) { return Qnil; } if (nth < 0) { nth += RMATCH(match)->regs->num_regs; if (nth <= 0) return Qnil; } start = RMATCH(match)->BEG(nth); if (start == -1) return Qnil; end = RMATCH(match)->END(nth); len = end - start; str = rb_str_subseq(RMATCH(match)->str, start, len); OBJ_INFECT(str, match); return str; } VALUE rb_reg_last_match(VALUE match) { return rb_reg_nth_match(0, match); } /* * call-seq: * mtch.pre_match => str * * Returns the portion of the original string before the current match. * Equivalent to the special variable $`. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.pre_match #=> "T" */ VALUE rb_reg_match_pre(VALUE match) { VALUE str; if (NIL_P(match)) return Qnil; if (RMATCH(match)->BEG(0) == -1) return Qnil; str = rb_str_subseq(RMATCH(match)->str, 0, RMATCH(match)->BEG(0)); if (OBJ_TAINTED(match)) OBJ_TAINT(str); return str; } /* * call-seq: * mtch.post_match => str * * Returns the portion of the original string after the current match. * Equivalent to the special variable $'. * * m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie") * m.post_match #=> ": The Movie" */ VALUE rb_reg_match_post(VALUE match) { VALUE str; long pos; if (NIL_P(match)) return Qnil; if (RMATCH(match)->BEG(0) == -1) return Qnil; str = RMATCH(match)->str; pos = RMATCH(match)->END(0); str = rb_str_subseq(str, pos, RSTRING_LEN(str) - pos); if (OBJ_TAINTED(match)) OBJ_TAINT(str); return str; } VALUE rb_reg_match_last(VALUE match) { int i; if (NIL_P(match)) return Qnil; if (RMATCH(match)->BEG(0) == -1) return Qnil; for (i=RMATCH(match)->regs->num_regs-1; RMATCH(match)->BEG(i) == -1 && i > 0; i--) ; if (i == 0) return Qnil; return rb_reg_nth_match(i, match); } static VALUE last_match_getter(void) { return rb_reg_last_match(rb_backref_get()); } static VALUE prematch_getter(void) { return rb_reg_match_pre(rb_backref_get()); } static VALUE postmatch_getter(void) { return rb_reg_match_post(rb_backref_get()); } static VALUE last_paren_match_getter(void) { return rb_reg_match_last(rb_backref_get()); } static VALUE match_array(VALUE match, int start) { struct re_registers *regs = RMATCH(match)->regs; VALUE ary = rb_ary_new2(regs->num_regs); VALUE target = RMATCH(match)->str; int i; int taint = OBJ_TAINTED(match); for (i=start; inum_regs; i++) { if (regs->beg[i] == -1) { rb_ary_push(ary, Qnil); } else { VALUE str = rb_str_subseq(target, regs->beg[i], regs->end[i]-regs->beg[i]); if (taint) OBJ_TAINT(str); rb_ary_push(ary, str); } } return ary; } /* [MG]:FIXME: I put parens around the /.../.match() in the first line of the second example to prevent the '*' followed by a '/' from ending the comment. */ /* * call-seq: * mtch.to_a => anArray * * Returns the array of matches. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.to_a #=> ["HX1138", "H", "X", "113", "8"] * * Because to_a is called when expanding * *variable, there's a useful assignment * shortcut for extracting matched fields. This is slightly slower than * accessing the fields directly (as an intermediate array is * generated). * * all,f1,f2,f3 = *(/(.)(.)(\d+)(\d)/.match("THX1138.")) * all #=> "HX1138" * f1 #=> "H" * f2 #=> "X" * f3 #=> "113" */ static VALUE match_to_a(VALUE match) { return match_array(match, 0); } /* * call-seq: * mtch.captures => array * * Returns the array of captures; equivalent to mtch.to_a[1..-1]. * * f1,f2,f3,f4 = /(.)(.)(\d+)(\d)/.match("THX1138.").captures * f1 #=> "H" * f2 #=> "X" * f3 #=> "113" * f4 #=> "8" */ static VALUE match_captures(VALUE match) { return match_array(match, 1); } static int name_to_backref_number(struct re_registers *regs, VALUE regexp, const char* name, const char* name_end) { int num; num = onig_name_to_backref_number(RREGEXP(regexp)->ptr, (const unsigned char* )name, (const unsigned char* )name_end, regs); if (num >= 1) { return num; } else { VALUE s = rb_str_new(name, (long )(name_end - name)); rb_raise(rb_eRuntimeError, "undefined group name reference: %s", StringValuePtr(s)); } } /* * call-seq: * mtch[i] => str or nil * mtch[start, length] => array * mtch[range] => array * mtch[name] => str or nil * * Match Reference---MatchData acts as an array, and may be * accessed using the normal array indexing techniques. mtch[0] is * equivalent to the special variable $&, and returns the entire * matched string. mtch[1], mtch[2], and so on return the values * of the matched backreferences (portions of the pattern between parentheses). * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m[0] #=> "HX1138" * m[1, 2] #=> ["H", "X"] * m[1..3] #=> ["H", "X", "113"] * m[-3, 2] #=> ["X", "113"] * * m = /(?a+)b/.match("ccaaab") * m["foo"] #=> "aaa" * m[:foo] #=> "aaa" */ static VALUE match_aref(int argc, VALUE *argv, VALUE match) { VALUE idx, rest; rb_scan_args(argc, argv, "11", &idx, &rest); if (NIL_P(rest)) { if (FIXNUM_P(idx)) { if (FIX2INT(idx) >= 0) { return rb_reg_nth_match(FIX2INT(idx), match); } } else { const char *p; int num; switch (TYPE(idx)) { case T_SYMBOL: p = rb_id2name(SYM2ID(idx)); goto name_to_backref; break; case T_STRING: p = StringValuePtr(idx); name_to_backref: num = name_to_backref_number(RMATCH(match)->regs, RMATCH(match)->regexp, p, p + strlen(p)); return rb_reg_nth_match(num, match); break; default: break; } } } return rb_ary_aref(argc, argv, match_to_a(match)); } static VALUE match_entry(VALUE match, long n) { return rb_reg_nth_match(n, match); } /* * call-seq: * * mtch.values_at([index]*) => array * mtch.select([index]*) => array * * Uses each index to access the matching values, returning an array of * the corresponding matches. * * m = /(.)(.)(\d+)(\d)/.match("THX1138: The Movie") * m.to_a #=> ["HX1138", "H", "X", "113", "8"] * m.values_at(0, 2, -2) #=> ["HX1138", "X", "113"] */ static VALUE match_values_at(int argc, VALUE *argv, VALUE match) { return rb_get_values_at(match, RMATCH(match)->regs->num_regs, argc, argv, match_entry); } /* * call-seq: * mtch.to_s => str * * Returns the entire matched string. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.to_s #=> "HX1138" */ static VALUE match_to_s(VALUE match) { VALUE str = rb_reg_last_match(match); if (NIL_P(str)) str = rb_str_new(0,0); if (OBJ_TAINTED(match)) OBJ_TAINT(str); if (OBJ_TAINTED(RMATCH(match)->str)) OBJ_TAINT(str); return str; } /* * call-seq: * mtch.string => str * * Returns a frozen copy of the string passed in to match. * * m = /(.)(.)(\d+)(\d)/.match("THX1138.") * m.string #=> "THX1138." */ static VALUE match_string(VALUE match) { return RMATCH(match)->str; /* str is frozen */ } static VALUE match_inspect(VALUE match) { char *cname = rb_obj_classname(match); VALUE str; int i; str = rb_str_buf_new2("#<"); rb_str_buf_cat2(str, cname); for (i = 0; i < RMATCH(match)->regs->num_regs; i++) { VALUE v; rb_str_buf_cat2(str, " "); v = rb_reg_nth_match(i, match); if (v == Qnil) rb_str_buf_cat2(str, "nil"); else rb_str_buf_append(str, rb_str_inspect(v)); } rb_str_buf_cat2(str, ">"); return str; } VALUE rb_cRegexp; static int rb_reg_initialize(VALUE obj, const char *s, int len, rb_encoding *enc, int options, onig_errmsg_buffer err) { struct RRegexp *re = RREGEXP(obj); if (!OBJ_TAINTED(obj) && rb_safe_level() >= 4) rb_raise(rb_eSecurityError, "Insecure: can't modify regexp"); rb_check_frozen(obj); if (FL_TEST(obj, REG_LITERAL)) rb_raise(rb_eSecurityError, "can't modify literal regexp"); if (re->ptr) onig_free(re->ptr); if (re->str) free(re->str); re->ptr = 0; re->str = 0; rb_enc_associate((VALUE)re, enc); if (options & ARG_ENCODING_FIXED) { re->basic.flags |= KCODE_FIXED; } re->ptr = make_regexp(s, len, enc, options & ARG_REG_OPTION_MASK, err); if (!re->ptr) return -1; re->str = ALLOC_N(char, len+1); memcpy(re->str, s, len); re->str[len] = '\0'; re->len = len; return 0; } static int rb_reg_initialize_str(VALUE obj, VALUE str, int options, onig_errmsg_buffer err) { if (rb_enc_str_coderange(str) != ENC_CODERANGE_SINGLE) { options |= ARG_ENCODING_FIXED; } return rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), rb_enc_get(str), options, err); } static VALUE rb_reg_s_alloc(VALUE klass) { NEWOBJ(re, struct RRegexp); OBJSETUP(re, klass, T_REGEXP); re->ptr = 0; re->len = 0; re->str = 0; return (VALUE)re; } VALUE rb_reg_new(VALUE s, int options) { VALUE re = rb_reg_s_alloc(rb_cRegexp); onig_errmsg_buffer err; if (rb_reg_initialize_str(re, s, options, err) != 0) { rb_reg_raise_str(s, options, err); } return re; } VALUE rb_reg_compile(VALUE str, int options) { VALUE re = rb_reg_s_alloc(rb_cRegexp); onig_errmsg_buffer err; if (!str) str = rb_str_new(0,0); if (rb_reg_initialize_str(re, str, options, err) != 0) { rb_set_errinfo(rb_reg_error_desc(str, options, err)); return Qnil; } FL_SET(re, REG_LITERAL); return re; } static VALUE reg_cache; VALUE rb_reg_regcomp(VALUE str) { volatile VALUE save_str = str; if (reg_cache && RREGEXP(reg_cache)->len == RSTRING_LEN(str) && ENCODING_GET(reg_cache) == ENCODING_GET(str) && memcmp(RREGEXP(reg_cache)->str, RSTRING_PTR(str), RSTRING_LEN(str)) == 0) return reg_cache; return reg_cache = rb_reg_new(save_str, 0); } /* * call-seq: * rxp.hash => fixnum * * Produce a hash based on the text and options of this regular expression. */ static VALUE rb_reg_hash(VALUE re) { int hashval, len; char *p; rb_reg_check(re); hashval = RREGEXP(re)->ptr->options; len = RREGEXP(re)->len; p = RREGEXP(re)->str; while (len--) { hashval = hashval * 33 + *p++; } hashval = hashval + (hashval>>5); return INT2FIX(hashval); } /* * call-seq: * rxp == other_rxp => true or false * rxp.eql?(other_rxp) => true or false * * Equality---Two regexps are equal if their patterns are identical, they have * the same character set code, and their casefold? values are the * same. * * /abc/ == /abc/x #=> false * /abc/ == /abc/i #=> false * /abc/u == /abc/n #=> false */ static VALUE rb_reg_equal(VALUE re1, VALUE re2) { if (re1 == re2) return Qtrue; if (TYPE(re2) != T_REGEXP) return Qfalse; rb_reg_check(re1); rb_reg_check(re2); if (RREGEXP(re1)->ptr->options != RREGEXP(re2)->ptr->options) return Qfalse; if (RREGEXP(re1)->len != RREGEXP(re2)->len) return Qfalse; if (ENCODING_GET(re1) != ENCODING_GET(re2)) return Qfalse; if (memcmp(RREGEXP(re1)->str, RREGEXP(re2)->str, RREGEXP(re1)->len) == 0) { return Qtrue; } return Qfalse; } static VALUE reg_operand(VALUE s, int check) { if (SYMBOL_P(s)) { return rb_sym_to_s(s); } else { VALUE tmp = rb_check_string_type(s); if (check && NIL_P(tmp)) { rb_raise(rb_eTypeError, "can't convert %s to String", rb_obj_classname(s)); } return tmp; } } static VALUE rb_reg_match_pos(VALUE re, VALUE str, long pos) { if (NIL_P(str)) { rb_backref_set(Qnil); return Qnil; } str = reg_operand(str, Qtrue); if (pos != 0) { if (pos < 0) { pos += RSTRING_LEN(str); if (pos < 0) { return Qnil; } } pos = rb_reg_adjust_startpos(re, str, pos, 0); } pos = rb_reg_search(re, str, pos, 0); if (pos < 0) { return Qnil; } return LONG2FIX(pos); } /* * call-seq: * rxp =~ str => integer or nil * * Match---Matches rxp against str. * * /at/ =~ "input data" #=> 7 */ VALUE rb_reg_match(VALUE re, VALUE str) { return rb_reg_match_pos(re, str, 0); } /* * call-seq: * rxp === str => true or false * * Case Equality---Synonym for Regexp#=~ used in case statements. * * a = "HELLO" * case a * when /^[a-z]*$/; print "Lower case\n" * when /^[A-Z]*$/; print "Upper case\n" * else; print "Mixed case\n" * end * * produces: * * Upper case */ VALUE rb_reg_eqq(VALUE re, VALUE str) { long start; str = reg_operand(str, Qfalse); if (NIL_P(str)) { rb_backref_set(Qnil); return Qfalse; } start = rb_reg_search(re, str, 0, 0); if (start < 0) { return Qfalse; } return Qtrue; } /* * call-seq: * ~ rxp => integer or nil * * Match---Matches rxp against the contents of $_. * Equivalent to rxp =~ $_. * * $_ = "input data" * ~ /at/ #=> 7 */ VALUE rb_reg_match2(VALUE re) { long start; VALUE line = rb_lastline_get(); if (TYPE(line) != T_STRING) { rb_backref_set(Qnil); return Qnil; } start = rb_reg_search(re, line, 0, 0); if (start < 0) { return Qnil; } return LONG2FIX(start); } /* * call-seq: * rxp.match(str) => matchdata or nil * rxp.match(str,pos) => matchdata or nil * * Returns a MatchData object describing the match, or * nil if there was no match. This is equivalent to retrieving the * value of the special variable $~ following a normal match. * If the second parameter is present, it specifies the position in the string * to begin the search. * * /(.)(.)(.)/.match("abc")[2] #=> "b" * /(.)(.)/.match("abc", 1)[2] #=> "c" * * If a block is given, invoke the block with MatchData if match succeed, so * that you can write * * pat.match(str) {|m| ...} * * instead of * * if m = pat.match(str) * ... * end * * The retuen value is a value from block exection in this case. */ static VALUE rb_reg_match_m(int argc, VALUE *argv, VALUE re) { VALUE result, str, initpos; long pos; if (rb_scan_args(argc, argv, "11", &str, &initpos) == 2) { pos = NUM2LONG(initpos); } else { pos = 0; } result = rb_reg_match_pos(re, str, pos); if (NIL_P(result)) { rb_backref_set(Qnil); return Qnil; } result = rb_backref_get(); rb_match_busy(result); if (!NIL_P(result) && rb_block_given_p()) { return rb_yield(result); } return result; } /* * Document-method: compile * * Synonym for Regexp.new */ /* * call-seq: * Regexp.new(string [, options]) => regexp * Regexp.new(regexp) => regexp * Regexp.compile(string [, options]) => regexp * Regexp.compile(regexp) => regexp * * Constructs a new regular expression from pattern, which can be either * a String or a Regexp (in which case that regexp's * options are propagated, and new options may not be specified (a change as of * Ruby 1.8). If options is a Fixnum, it should be one or * more of the constants Regexp::EXTENDED, * Regexp::IGNORECASE, and Regexp::MULTILINE, * or-ed together. Otherwise, if options is not * nil, the regexp will be case insensitive. The lang * parameter enables multibyte support for the regexp: `n', `N' = none, `e', * `E' = EUC, `s', `S' = SJIS, `u', `U' = UTF-8. * * r1 = Regexp.new('^a-z+:\\s+\w+') #=> /^a-z+:\s+\w+/ * r2 = Regexp.new('cat', true) #=> /cat/i * r3 = Regexp.new('dog', Regexp::EXTENDED) #=> /dog/x * r4 = Regexp.new(r2) #=>n /cat/i */ static VALUE rb_reg_initialize_m(int argc, VALUE *argv, VALUE self) { onig_errmsg_buffer err; int flags = 0; VALUE str; rb_encoding *enc; const char *ptr; long len; if (argc == 0 || argc > 3) { rb_raise(rb_eArgError, "wrong number of arguments"); } if (TYPE(argv[0]) == T_REGEXP) { VALUE re = argv[0]; if (argc > 1) { rb_warn("flags ignored"); } rb_reg_check(re); flags = rb_reg_options(re); ptr = RREGEXP(re)->str; len = RREGEXP(re)->len; enc = rb_enc_get(re); if (rb_reg_initialize(self, ptr, len, enc, flags, err)) { str = rb_enc_str_new(ptr, len, enc); rb_reg_raise_str(str, flags, err); } } else { if (argc >= 2) { if (FIXNUM_P(argv[1])) flags = FIX2INT(argv[1]); else if (RTEST(argv[1])) flags = ONIG_OPTION_IGNORECASE; } enc = 0; if (argc == 3 && !NIL_P(argv[2])) { char *kcode = StringValuePtr(argv[2]); if (kcode[0] == 'n' || kcode[1] == 'N') { enc = rb_enc_from_index(0); flags |= ARG_ENCODING_FIXED; } else { rb_warning("encoding option is obsolete - %s", kcode); } } str = argv[0]; ptr = StringValueCStr(str); if (enc ? rb_reg_initialize(self, ptr, RSTRING_LEN(str), enc, flags, err) : rb_reg_initialize_str(self, str, flags, err)) { rb_reg_raise_str(str, flags, err); } } return self; } VALUE rb_reg_quote(VALUE str) { rb_encoding *enc = rb_enc_get(str); char *s, *send, *t; VALUE tmp; int c; s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); for (; s < send; s++) { c = *s; if (ismbchar(s, send, enc)) { int n = mbclen(s, send, enc); while (n-- && s < send) s++; s--; continue; } switch (c) { case '[': case ']': case '{': case '}': case '(': case ')': case '|': case '-': case '*': case '.': case '\\': case '?': case '+': case '^': case '$': case ' ': case '#': case '\t': case '\f': case '\n': case '\r': goto meta_found; } } return str; meta_found: tmp = rb_str_new(0, RSTRING_LEN(str)*2); rb_enc_copy(tmp, str); t = RSTRING_PTR(tmp); /* copy upto metacharacter */ memcpy(t, RSTRING_PTR(str), s - RSTRING_PTR(str)); t += s - RSTRING_PTR(str); for (; s < send; s++) { c = *s; if (ismbchar(s, send, enc)) { int n = mbclen(s, send, enc); while (n-- && s < send) *t++ = *s++; s--; continue; } switch (c) { case '[': case ']': case '{': case '}': case '(': case ')': case '|': case '-': case '*': case '.': case '\\': case '?': case '+': case '^': case '$': case '#': *t++ = '\\'; break; case ' ': *t++ = '\\'; *t++ = ' '; continue; case '\t': *t++ = '\\'; *t++ = 't'; continue; case '\n': *t++ = '\\'; *t++ = 'n'; continue; case '\r': *t++ = '\\'; *t++ = 'r'; continue; case '\f': *t++ = '\\'; *t++ = 'f'; continue; } *t++ = c; } rb_str_resize(tmp, t - RSTRING_PTR(tmp)); OBJ_INFECT(tmp, str); return tmp; } /* * call-seq: * Regexp.escape(str) => a_str * Regexp.quote(str) => a_str * * Escapes any characters that would have special meaning in a regular * expression. Returns a new escaped string, or self if no characters are * escaped. For any string, * Regexp.escape(str)=~str will be true. * * Regexp.escape('\\*?{}.') #=> \\\\\*\?\{\}\. */ static VALUE rb_reg_s_quote(VALUE c, VALUE str) { return rb_reg_quote(reg_operand(str, Qtrue)); } int rb_reg_options(VALUE re) { int options; rb_reg_check(re); options = RREGEXP(re)->ptr->options & ARG_REG_OPTION_MASK; if (RBASIC(re)->flags & KCODE_FIXED) options |= ARG_ENCODING_FIXED; return options; } VALUE rb_check_regexp_type(VALUE re) { return rb_check_convert_type(re, T_REGEXP, "Regexp", "to_regexp"); } /* * call-seq: * Regexp.try_convert(obj) -> re or nil * * Try to convert obj into a Regexp, using to_regexp method. * Returns converted regexp or nil if obj cannot be converted * for any reason. * * Regexp.try_convert(/re/) # => /re/ * Regexp.try_convert("re") # => nil */ static VALUE rb_reg_s_try_convert(VALUE dummy, VALUE re) { return rb_check_regexp_type(re); } static VALUE rb_reg_s_union(VALUE self, VALUE args0) { long argc = RARRAY_LEN(args0); if (argc == 0) { VALUE args[1]; args[0] = rb_str_new2("(?!)"); return rb_class_new_instance(1, args, rb_cRegexp); } else if (argc == 1) { VALUE v; v = rb_check_regexp_type(rb_ary_entry(args0, 0)); if (!NIL_P(v)) return v; else { VALUE args[1]; args[0] = rb_reg_s_quote(Qnil, RARRAY_PTR(args0)[0]); return rb_class_new_instance(1, args, rb_cRegexp); } } else { int i; VALUE source = rb_str_buf_new(0); int mbs = Qfalse; rb_encoding *enc = 0; for (i = 0; i < argc; i++) { volatile VALUE v; VALUE e = rb_ary_entry(args0, i); if (0 < i) rb_str_buf_cat2(source, "|"); v = rb_check_regexp_type(e); if (!NIL_P(v)) { v = rb_reg_to_s(v); } else { v = rb_reg_s_quote(Qnil, e); } if (mbs || rb_enc_str_coderange(v) != ENC_CODERANGE_SINGLE) { if (!enc) enc = rb_enc_get(v); else if (mbs && enc != rb_enc_get(v)) { rb_raise(rb_eArgError, "regexp encodings differ"); } mbs = Qtrue; } rb_str_append(source, v); } return rb_class_new_instance(1, &source, rb_cRegexp); } } /* * call-seq: * Regexp.union(pat1, pat2, ...) => new_regexp * Regexp.union(pats_ary) => new_regexp * * Return a Regexp object that is the union of the given * patterns, i.e., will match any of its parts. The patterns * can be Regexp objects, in which case their options will be preserved, or * Strings. If no patterns are given, returns /(?!)/. * * Regexp.union #=> /(?!)/ * Regexp.union("penzance") #=> /penzance/ * Regexp.union("a+b*c") #=> /a\+b\*c/ * Regexp.union("skiing", "sledding") #=> /skiing|sledding/ * Regexp.union(["skiing", "sledding"]) #=> /skiing|sledding/ * Regexp.union(/dogs/, /cats/i) #=> /(?-mix:dogs)|(?i-mx:cats)/ */ static VALUE rb_reg_s_union_m(VALUE self, VALUE args) { VALUE v; if (RARRAY_LEN(args) == 1 && !NIL_P(v = rb_check_array_type(rb_ary_entry(args, 0)))) { return rb_reg_s_union(self, v); } return rb_reg_s_union(self, args); } /* :nodoc: */ static VALUE rb_reg_init_copy(VALUE copy, VALUE re) { onig_errmsg_buffer err; const char *s; long len; if (copy == re) return copy; rb_check_frozen(copy); /* need better argument type check */ if (!rb_obj_is_instance_of(re, rb_obj_class(copy))) { rb_raise(rb_eTypeError, "wrong argument type"); } rb_reg_check(re); s = RREGEXP(re)->str; len = RREGEXP(re)->len; if (rb_reg_initialize(copy, s, len, rb_enc_get(re), rb_reg_options(re), err) != 0) { rb_reg_raise(s, len, err, re); } return copy; } VALUE rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp) { VALUE val = 0; char *p, *s, *e; unsigned char uc; int no; rb_encoding *enc = rb_enc_check(str, src); rb_enc_check(str, regexp); p = s = RSTRING_PTR(str); e = s + RSTRING_LEN(str); while (s < e) { char *ss = s++; if (ismbchar(ss, e, enc)) { s += mbclen(ss, e, enc) - 1; continue; } if (*ss != '\\' || s == e) continue; if (!val) { val = rb_str_buf_new(ss-p); rb_str_buf_cat(val, p, ss-p); } else { rb_str_buf_cat(val, p, ss-p); } uc = (unsigned char)*s++; p = s; switch (uc) { case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (onig_noname_group_capture_is_active(RREGEXP(regexp)->ptr)) { no = uc - '0'; } else { continue; } break; case 'k': if (s < e && *s == '<') { char *name, *name_end; name_end = name = s + 1; while (name_end < e) { if (*name_end == '>') break; name_end += mbclen(name_end, e, enc); } if (name_end < e) { no = name_to_backref_number(regs, regexp, name, name_end); p = s = name_end + 1; break; } else { rb_raise(rb_eRuntimeError, "invalid group name reference format"); } } rb_str_buf_cat(val, s-2, 2); continue; case '0': case '&': no = 0; break; case '`': rb_str_buf_cat(val, RSTRING_PTR(src), BEG(0)); continue; case '\'': rb_str_buf_cat(val, RSTRING_PTR(src)+END(0), RSTRING_LEN(src)-END(0)); continue; case '+': no = regs->num_regs-1; while (BEG(no) == -1 && no > 0) no--; if (no == 0) continue; break; case '\\': rb_str_buf_cat(val, s-1, 1); continue; default: rb_str_buf_cat(val, s-2, 2); continue; } if (no >= 0) { if (no >= regs->num_regs) continue; if (BEG(no) == -1) continue; rb_str_buf_cat(val, RSTRING_PTR(src)+BEG(no), END(no)-BEG(no)); } } if (p < e) { if (!val) { val = rb_str_buf_new(e-p); rb_str_buf_cat(val, p, e-p); } else { rb_str_buf_cat(val, p, e-p); } } if (!val) return str; return val; } static VALUE kcode_getter(void) { rb_warn("variable $KCODE is no longer effective"); return Qnil; } static void kcode_setter(VALUE val, ID id) { rb_warn("variable $KCODE is no longer effective; ignored"); } static VALUE ignorecase_getter(void) { rb_warn("variable $= is no longer effective"); return Qfalse; } static void ignorecase_setter(VALUE val, ID id) { rb_warn("variable $= is no longer effective; ignored"); } static VALUE match_getter(void) { VALUE match = rb_backref_get(); if (NIL_P(match)) return Qnil; rb_match_busy(match); return match; } static void match_setter(VALUE val) { if (!NIL_P(val)) { Check_Type(val, T_MATCH); } rb_backref_set(val); } /* * call-seq: * Regexp.last_match => matchdata * Regexp.last_match(fixnum) => str * * The first form returns the MatchData object generated by the * last successful pattern match. Equivalent to reading the global variable * $~. The second form returns the nth field in this * MatchData object. * * /c(.)t/ =~ 'cat' #=> 0 * Regexp.last_match #=> # * Regexp.last_match(0) #=> "cat" * Regexp.last_match(1) #=> "a" * Regexp.last_match(2) #=> nil */ static VALUE rb_reg_s_last_match(int argc, VALUE *argv) { VALUE nth; if (rb_scan_args(argc, argv, "01", &nth) == 1) { return rb_reg_nth_match(NUM2INT(nth), rb_backref_get()); } return match_getter(); } /* * Document-class: Regexp * * A Regexp holds a regular expression, used to match a pattern * against strings. Regexps are created using the /.../ and * %r{...} literals, and by the Regexp::new * constructor. * */ void Init_Regexp(void) { rb_eRegexpError = rb_define_class("RegexpError", rb_eStandardError); onigenc_set_default_caseconv_table((UChar*)casetable); onigenc_set_default_encoding(ONIG_ENCODING_ASCII); rb_define_virtual_variable("$~", match_getter, match_setter); rb_define_virtual_variable("$&", last_match_getter, 0); rb_define_virtual_variable("$`", prematch_getter, 0); rb_define_virtual_variable("$'", postmatch_getter, 0); rb_define_virtual_variable("$+", last_paren_match_getter, 0); rb_define_virtual_variable("$=", ignorecase_getter, ignorecase_setter); rb_define_virtual_variable("$KCODE", kcode_getter, kcode_setter); rb_define_virtual_variable("$-K", kcode_getter, kcode_setter); rb_cRegexp = rb_define_class("Regexp", rb_cObject); rb_define_alloc_func(rb_cRegexp, rb_reg_s_alloc); rb_define_singleton_method(rb_cRegexp, "compile", rb_class_new_instance, -1); rb_define_singleton_method(rb_cRegexp, "quote", rb_reg_s_quote, 1); rb_define_singleton_method(rb_cRegexp, "escape", rb_reg_s_quote, 1); rb_define_singleton_method(rb_cRegexp, "union", rb_reg_s_union_m, -2); rb_define_singleton_method(rb_cRegexp, "last_match", rb_reg_s_last_match, -1); rb_define_singleton_method(rb_cRegexp, "try_convert", rb_reg_s_try_convert, 1); rb_define_method(rb_cRegexp, "initialize", rb_reg_initialize_m, -1); rb_define_method(rb_cRegexp, "initialize_copy", rb_reg_init_copy, 1); rb_define_method(rb_cRegexp, "hash", rb_reg_hash, 0); rb_define_method(rb_cRegexp, "eql?", rb_reg_equal, 1); rb_define_method(rb_cRegexp, "==", rb_reg_equal, 1); rb_define_method(rb_cRegexp, "=~", rb_reg_match, 1); rb_define_method(rb_cRegexp, "===", rb_reg_eqq, 1); rb_define_method(rb_cRegexp, "~", rb_reg_match2, 0); rb_define_method(rb_cRegexp, "match", rb_reg_match_m, -1); rb_define_method(rb_cRegexp, "to_s", rb_reg_to_s, 0); rb_define_method(rb_cRegexp, "inspect", rb_reg_inspect, 0); rb_define_method(rb_cRegexp, "source", rb_reg_source, 0); rb_define_method(rb_cRegexp, "casefold?", rb_reg_casefold_p, 0); rb_define_method(rb_cRegexp, "options", rb_reg_options_m, 0); rb_define_method(rb_cRegexp, "encoding", rb_obj_encoding, 0); /* in encoding.c */ rb_define_const(rb_cRegexp, "IGNORECASE", INT2FIX(ONIG_OPTION_IGNORECASE)); rb_define_const(rb_cRegexp, "EXTENDED", INT2FIX(ONIG_OPTION_EXTEND)); rb_define_const(rb_cRegexp, "MULTILINE", INT2FIX(ONIG_OPTION_MULTILINE)); rb_global_variable(®_cache); rb_cMatch = rb_define_class("MatchData", rb_cObject); rb_define_alloc_func(rb_cMatch, match_alloc); rb_undef_method(CLASS_OF(rb_cMatch), "new"); rb_define_method(rb_cMatch, "initialize_copy", match_init_copy, 1); rb_define_method(rb_cMatch, "size", match_size, 0); rb_define_method(rb_cMatch, "length", match_size, 0); rb_define_method(rb_cMatch, "offset", match_offset, 1); rb_define_method(rb_cMatch, "begin", match_begin, 1); rb_define_method(rb_cMatch, "end", match_end, 1); rb_define_method(rb_cMatch, "to_a", match_to_a, 0); rb_define_method(rb_cMatch, "[]", match_aref, -1); rb_define_method(rb_cMatch, "captures", match_captures, 0); rb_define_method(rb_cMatch, "values_at", match_values_at, -1); rb_define_method(rb_cMatch, "select", match_values_at, -1); rb_define_method(rb_cMatch, "pre_match", rb_reg_match_pre, 0); rb_define_method(rb_cMatch, "post_match", rb_reg_match_post, 0); rb_define_method(rb_cMatch, "to_s", match_to_s, 0); rb_define_method(rb_cMatch, "inspect", match_inspect, 0); rb_define_method(rb_cMatch, "string", match_string, 0); }