kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* re.c (update_char_offset): position should be long.

Browse source 
* re.c (match_hash, match_equal): new methods.  [ruby-core:24748]

* re.c (reg_match_pos, rb_reg_eqq, rb_reg_s_quote): get rid of use
  VALUE as int.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@24754 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nobu 2009-09-04 23:51:44 +00:00
parent 7633eb4c51
commit 605e7d4a60
3 changed files with 64 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
ChangeLog
View file

@ -1,12 +1,11 @@
Sat Sep 5 08:49:16 2009 Nobuyoshi Nakada <nobu@ruby-lang.org>
Sat Sep 5 08:51:43 2009 Nobuyoshi Nakada <nobu@ruby-lang.org>
* re.c (update_char_offset):
* re.c (rb_reg_equal):
* re.c (reg_match_pos):
* re.c (rb_reg_eqq):
* re.c (static VALUE):
* re.c (Init_Regexp):
[ruby-core:24748]
* re.c (update_char_offset): position should be long.
* re.c (match_hash, match_equal): new methods. [ruby-core:24748]
* re.c (reg_match_pos, rb_reg_eqq, rb_reg_s_quote): get rid of use
VALUE as int.
Fri Sep 4 20:40:57 2009 Nobuyoshi Nakada <nobu@ruby-lang.org>

49
re.c
View file

@ -2543,6 +2543,55 @@ rb_reg_equal(VALUE re1, VALUE re2)
return Qfalse;
}
/*
* call-seq:
* mtch.hash => integer
*
* Produce a hash based on the target string, regexp and matched
* positions of this matchdata.
*/
static VALUE
match_hash(VALUE match)
{
const struct re_registers *regs;
VALUE h;
unsigned long hashval = rb_hash_start(rb_str_hash(RMATCH(match)->str));
h = rb_reg_hash(RMATCH(match)->regexp);
rb_hash_uint(hashval, FIX2LONG(h));
regs = RMATCH_REGS(match);
hashval = rb_hash_uint(hashval, regs->num_regs);
hashval = rb_hash_uint(hashval, rb_memhash(regs->beg, regs->num_regs * sizeof(*regs->beg)));
hashval = rb_hash_uint(hashval, rb_memhash(regs->end, regs->num_regs * sizeof(*regs->end)));
hashval = rb_hash_end(hashval);
return LONG2FIX(hashval);
}
/*
* call-seq:
* mtch == mtch2 => true or false
*
* Equality---Two matchdata are equal if their target strings,
* patterns, and matched positions are identical.
*/
static VALUE
match_equal(VALUE match1, VALUE match2)
{
const struct re_registers *regs1, *regs2;
if (match1 == match2) return Qtrue;
if (TYPE(match2) != T_MATCH) return Qfalse;
if (!rb_str_equal(RMATCH(match1)->str, RMATCH(match2)->str)) return Qfalse;
if (!rb_reg_equal(RMATCH(match1)->regexp, RMATCH(match2)->regexp)) return Qfalse;
regs1 = RMATCH_REGS(match1);
regs2 = RMATCH_REGS(match2);
if (regs1->num_regs != regs2->num_regs) return Qfalse;
if (memcmp(regs1->beg, regs2->beg, regs1->num_regs * sizeof(*regs1->beg))) return Qfalse;
if (memcmp(regs1->end, regs2->end, regs1->num_regs * sizeof(*regs1->end))) return Qfalse;
return Qtrue;
}
static VALUE
reg_operand(VALUE s, int check)
{

8
test/ruby/test_regexp.rb
View file

@ -778,4 +778,12 @@ class TestRegexp < Test::Unit::TestCase
assert_nothing_raised { 0x03ffffff.chr("utf-8").size }
assert_nothing_raised { 0x7fffffff.chr("utf-8").size }
end
def test_matchdata
a = "haystack".match(/hay/)
b = "haystack".match(/hay/)
assert_equal(a, b, '[ruby-core:24748]')
h = {a => 42}
assert_equal(42, h[b], '[ruby-core:24748]')
end
end