re2 2.23.0-arm-linux-gnu → 2.24.0-arm-linux-gnu

data/ext/re2/re2.cc

@@ -245,6 +245,33 @@ static const rb_data_type_t re2_regexp_data_type = {
   RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
+static re2_pattern *unwrap_re2_regexp(VALUE self) {
+  re2_pattern *p;
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  if (!p->pattern) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Regexp");
+  }
+  return p;
+}
+
+static re2_matchdata *unwrap_re2_matchdata(VALUE self) {
+  re2_matchdata *m;
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  if (!RTEST(m->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::MatchData");
+  }
+  return m;
+}
+
+static re2_scanner *unwrap_re2_scanner(VALUE self) {
+  re2_scanner *c;
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  if (!RTEST(c->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Scanner");
+  }
+  return c;
+}
+
 static VALUE re2_matchdata_allocate(VALUE klass) {
   re2_matchdata *m;
 
@@ -269,8 +296,7 @@ static VALUE re2_scanner_allocate(VALUE klass) {
  *   m.string #=> "bob 123"
  */
 static VALUE re2_matchdata_string(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->text;
 }
@@ -287,8 +313,7 @@ static VALUE re2_matchdata_string(const VALUE self) {
  *   c.string #=> "foo"
  */
 static VALUE re2_scanner_string(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->text;
 }
@@ -302,8 +327,7 @@ static VALUE re2_scanner_string(const VALUE self) {
  *   c.eof? #=> true
  */
 static VALUE re2_scanner_eof(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return BOOL2RUBY(c->eof);
 }
@@ -320,8 +344,7 @@ static VALUE re2_scanner_eof(const VALUE self) {
  *   e.scan #=> ["1"]
  */
 static VALUE re2_scanner_rewind(VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   delete c->input;
   c->input = new(std::nothrow) re2::StringPiece(
@@ -336,6 +359,34 @@ static VALUE re2_scanner_rewind(VALUE self) {
   return self;
 }
 
+static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
+  re2_scanner *self_c;
+  re2_scanner *other_c = unwrap_re2_scanner(other);
+
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, self_c);
+
+  if (self_c->input) {
+    delete self_c->input;
+  }
+
+  RB_OBJ_WRITE(self, &self_c->regexp, other_c->regexp);
+  RB_OBJ_WRITE(self, &self_c->text, other_c->text);
+  self_c->number_of_capturing_groups = other_c->number_of_capturing_groups;
+  self_c->eof = other_c->eof;
+
+  if (other_c->input) {
+    self_c->input = new(std::nothrow) re2::StringPiece(*other_c->input);
+    if (self_c->input == 0) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for input");
+    }
+  } else {
+    self_c->input = NULL;
+  }
+
+  return self;
+}
+
 /*
  * Scan the given text incrementally for matches using
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L447-L463
@@ -356,11 +407,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
  *   s.scan #=> ["bar"]
  */
 static VALUE re2_scanner_scan(VALUE self) {
-  re2_pattern *p;
-  re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
-  TypedData_Get_Struct(c->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_scanner *c = unwrap_re2_scanner(self);
+  re2_pattern *p = unwrap_re2_regexp(c->regexp);
 
   std::vector<RE2::Arg> argv(c->number_of_capturing_groups);
   std::vector<RE2::Arg*> args(c->number_of_capturing_groups);
@@ -409,11 +457,8 @@ static VALUE re2_scanner_scan(VALUE self) {
 }
 
 static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   int id;
 
@@ -463,9 +508,7 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
  *   m.length #=> 2
  */
 static VALUE re2_matchdata_size(const VALUE self) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return INT2FIX(m->number_of_matches);
 }
@@ -482,9 +525,7 @@ static VALUE re2_matchdata_size(const VALUE self) {
  *   m.begin(1) #=> 4
  */
 static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -509,9 +550,7 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
  *   m.end(1) #=> 7
  */
 static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -532,8 +571,7 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
  *   m.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_matchdata_regexp(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->regexp;
 }
@@ -547,8 +585,7 @@ static VALUE re2_matchdata_regexp(const VALUE self) {
  *   c.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_scanner_regexp(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->regexp;
 }
@@ -573,11 +610,8 @@ static VALUE re2_regexp_allocate(VALUE klass) {
  *   m.to_a #=> ["123", "123"]
  */
 static VALUE re2_matchdata_to_a(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches);
   for (int i = 0; i < m->number_of_matches; ++i) {
@@ -595,11 +629,8 @@ static VALUE re2_matchdata_to_a(const VALUE self) {
 }
 
 static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   if (nth < 0 || nth >= m->number_of_matches) {
     return Qnil;
@@ -616,11 +647,8 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
 }
 
 static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   std::map<std::string, int>::const_iterator search = groups.find(name);
@@ -715,11 +743,8 @@ static VALUE re2_matchdata_to_s(const VALUE self) {
  *   m.inspect #=> "#<RE2::MatchData \"123\" 1:\"123\">"
  */
 static VALUE re2_matchdata_inspect(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   std::ostringstream output;
   output << "#<RE2::MatchData";
@@ -770,11 +795,8 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches - 1);
   for (int i = 1; i < m->number_of_matches; ++i) {
@@ -821,11 +843,8 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
@@ -858,6 +877,36 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   return capturing_groups;
 }
 
+static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
+  re2_matchdata *self_m;
+  re2_matchdata *other_m = unwrap_re2_matchdata(other);
+
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, self_m);
+
+  if (self_m->matches) {
+    delete[] self_m->matches;
+  }
+
+  self_m->number_of_matches = other_m->number_of_matches;
+  RB_OBJ_WRITE(self, &self_m->regexp, other_m->regexp);
+  RB_OBJ_WRITE(self, &self_m->text, other_m->text);
+
+  if (other_m->matches) {
+    self_m->matches = new(std::nothrow) re2::StringPiece[other_m->number_of_matches];
+    if (self_m->matches == 0) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for matches");
+    }
+    for (int i = 0; i < other_m->number_of_matches; ++i) {
+      self_m->matches[i] = other_m->matches[i];
+    }
+  } else {
+    self_m->matches = NULL;
+  }
+
+  return self;
+}
+
 /*
  * Shorthand to compile a new {RE2::Regexp}.
  *
@@ -913,6 +962,10 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
+  if (p->pattern) {
+    delete p->pattern;
+  }
+
   if (RTEST(options)) {
     RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
@@ -931,6 +984,25 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
+  re2_pattern *self_p;
+  re2_pattern *other_p = unwrap_re2_regexp(other);
+
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, self_p);
+
+  if (self_p->pattern) {
+    delete self_p->pattern;
+  }
+
+  self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
+                                          other_p->pattern->options());
+  if (self_p->pattern == 0) {
+    rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
+  }
+
+  return self;
+}
+
 /*
  * Returns a printable version of the regular expression.
  *
@@ -945,9 +1017,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
  *   re2.inspect #=> "#<RE2::Regexp /woo?/>"
  */
 static VALUE re2_regexp_inspect(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   std::ostringstream output;
 
@@ -970,8 +1040,7 @@ static VALUE re2_regexp_inspect(const VALUE self) {
  *   re2.to_s #=> "woo?"
  */
 static VALUE re2_regexp_to_s(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return encoded_str_new(p->pattern->pattern().data(),
       p->pattern->pattern().size(),
@@ -987,8 +1056,7 @@ static VALUE re2_regexp_to_s(const VALUE self) {
  *   re2.ok? #=> true
  */
 static VALUE re2_regexp_ok(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->ok());
 }
@@ -1003,8 +1071,7 @@ static VALUE re2_regexp_ok(const VALUE self) {
  *   re2.utf8? #=> true
  */
 static VALUE re2_regexp_utf8(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
 }
@@ -1019,8 +1086,7 @@ static VALUE re2_regexp_utf8(const VALUE self) {
  *   re2.posix_syntax? #=> true
  */
 static VALUE re2_regexp_posix_syntax(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().posix_syntax());
 }
@@ -1035,8 +1101,7 @@ static VALUE re2_regexp_posix_syntax(const VALUE self) {
  *   re2.longest_match? #=> true
  */
 static VALUE re2_regexp_longest_match(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().longest_match());
 }
@@ -1051,8 +1116,7 @@ static VALUE re2_regexp_longest_match(const VALUE self) {
  *   re2.log_errors? #=> true
  */
 static VALUE re2_regexp_log_errors(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().log_errors());
 }
@@ -1066,8 +1130,7 @@ static VALUE re2_regexp_log_errors(const VALUE self) {
  *   re2.max_mem #=> 1024
  */
 static VALUE re2_regexp_max_mem(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->options().max_mem());
 }
@@ -1082,8 +1145,7 @@ static VALUE re2_regexp_max_mem(const VALUE self) {
  *   re2.literal? #=> true
  */
 static VALUE re2_regexp_literal(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().literal());
 }
@@ -1098,8 +1160,7 @@ static VALUE re2_regexp_literal(const VALUE self) {
  *   re2.never_nl? #=> true
  */
 static VALUE re2_regexp_never_nl(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().never_nl());
 }
@@ -1114,8 +1175,7 @@ static VALUE re2_regexp_never_nl(const VALUE self) {
  *   re2.case_sensitive? #=> true
  */
 static VALUE re2_regexp_case_sensitive(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().case_sensitive());
 }
@@ -1144,8 +1204,7 @@ static VALUE re2_regexp_case_insensitive(const VALUE self) {
  *   re2.perl_classes? #=> true
  */
 static VALUE re2_regexp_perl_classes(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().perl_classes());
 }
@@ -1160,8 +1219,7 @@ static VALUE re2_regexp_perl_classes(const VALUE self) {
  *   re2.word_boundary? #=> true
  */
 static VALUE re2_regexp_word_boundary(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().word_boundary());
 }
@@ -1176,8 +1234,7 @@ static VALUE re2_regexp_word_boundary(const VALUE self) {
  *   re2.one_line? #=> true
  */
 static VALUE re2_regexp_one_line(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().one_line());
 }
@@ -1189,8 +1246,7 @@ static VALUE re2_regexp_one_line(const VALUE self) {
  * @return [String, nil] the error string or `nil`
  */
 static VALUE re2_regexp_error(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1210,8 +1266,7 @@ static VALUE re2_regexp_error(const VALUE self) {
  * @return [String, nil] the offending portion of the regexp or `nil`
  */
 static VALUE re2_regexp_error_arg(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1230,8 +1285,7 @@ static VALUE re2_regexp_error_arg(const VALUE self) {
  * @return [Integer] the regexp "cost"
  */
 static VALUE re2_regexp_program_size(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->ProgramSize());
 }
@@ -1242,9 +1296,7 @@ static VALUE re2_regexp_program_size(const VALUE self) {
  * @return [Hash] the options
  */
 static VALUE re2_regexp_options(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
   VALUE options = rb_hash_new();
 
   rb_hash_aset(options, ID2SYM(id_utf8),
@@ -1294,8 +1346,7 @@ static VALUE re2_regexp_options(const VALUE self) {
  * @return [Integer] the number of capturing subpatterns
  */
 static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->NumberOfCapturingGroups());
 }
@@ -1310,9 +1361,7 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
  * @return [Hash] a hash of names to capturing indices
  */
 static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
@@ -1418,7 +1467,7 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  p = unwrap_re2_regexp(self);
 
   int n;
   int startpos = 0;
@@ -1565,12 +1614,10 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(RE2::PartialMatch(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
@@ -1585,12 +1632,10 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
   /* Ensure text is a string. */
   StringValue(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(RE2::FullMatch(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
@@ -1612,10 +1657,8 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   /* Ensure text is a string. */
   StringValue(text);
 
-  re2_pattern *p;
+  re2_pattern *p = unwrap_re2_regexp(self);
   re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
@@ -1694,7 +1737,7 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
+    p = unwrap_re2_regexp(pattern);
     RE2::Replace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
@@ -1746,7 +1789,7 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
+    p = unwrap_re2_regexp(pattern);
     RE2::GlobalReplace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
@@ -1818,6 +1861,15 @@ static const rb_data_type_t re2_set_data_type = {
   RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
+static re2_set *unwrap_re2_set(VALUE self) {
+  re2_set *s;
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  if (!s->set) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Set");
+  }
+  return s;
+}
+
 static VALUE re2_set_allocate(VALUE klass) {
   re2_set *s;
   VALUE result = TypedData_Make_Struct(klass, re2_set, &re2_set_data_type, s);
@@ -1825,6 +1877,10 @@ static VALUE re2_set_allocate(VALUE klass) {
   return result;
 }
 
+static VALUE re2_set_initialize_copy(VALUE, VALUE) {
+  rb_raise(rb_eTypeError, "cannot copy RE2::Set");
+}
+
 /*
  * Returns a new {RE2::Set} object, a collection of patterns that can be
  * searched for simultaneously.
@@ -1895,6 +1951,10 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     parse_re2_options(&re2_options, options);
   }
 
+  if (s->set) {
+    delete s->set;
+  }
+
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
   if (s->set == 0) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Set object");
@@ -1919,8 +1979,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
   StringValue(pattern);
 
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   int index;
   VALUE msg;
@@ -1951,8 +2010,7 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
  *   set.compile #=> true
  */
 static VALUE re2_set_compile(VALUE self) {
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   return BOOL2RUBY(s->set->Compile());
 }
@@ -1968,8 +2026,7 @@ static VALUE re2_set_compile(VALUE self) {
  */
 static VALUE re2_set_size(VALUE self) {
 #ifdef HAVE_SET_SIZE
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   return INT2FIX(s->set->Size());
 #else
@@ -2052,8 +2109,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &str, &options);
 
   StringValue(str);
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   if (RTEST(options)) {
     Check_Type(options, T_HASH);
@@ -2157,6 +2213,8 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct), 0);
   rb_define_method(re2_cMatchData, "deconstruct_keys",
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct_keys), 1);
+  rb_define_method(re2_cMatchData, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_matchdata_initialize_copy), 1);
 
   rb_define_method(re2_cScanner, "string",
       RUBY_METHOD_FUNC(re2_scanner_string), 0);
@@ -2168,11 +2226,15 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_scanner_scan), 0);
   rb_define_method(re2_cScanner, "rewind",
       RUBY_METHOD_FUNC(re2_scanner_rewind), 0);
+  rb_define_method(re2_cScanner, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_scanner_initialize_copy), 1);
 
   rb_define_singleton_method(re2_cRegexp, "match_has_endpos_argument?",
       RUBY_METHOD_FUNC(re2_regexp_match_has_endpos_argument_p), 0);
   rb_define_method(re2_cRegexp, "initialize",
       RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
+  rb_define_method(re2_cRegexp, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_regexp_initialize_copy), 1);
   rb_define_method(re2_cRegexp, "ok?", RUBY_METHOD_FUNC(re2_regexp_ok), 0);
   rb_define_method(re2_cRegexp, "error", RUBY_METHOD_FUNC(re2_regexp_error),
       0);
@@ -2240,6 +2302,8 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_set_size_p), 0);
   rb_define_method(re2_cSet, "initialize",
       RUBY_METHOD_FUNC(re2_set_initialize), -1);
+  rb_define_method(re2_cSet, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_set_initialize_copy), 1);
   rb_define_method(re2_cSet, "add", RUBY_METHOD_FUNC(re2_set_add), 1);
   rb_define_method(re2_cSet, "compile", RUBY_METHOD_FUNC(re2_set_compile), 0);
   rb_define_method(re2_cSet, "match", RUBY_METHOD_FUNC(re2_set_match), -1);