re2 2.0.0-x86_64-linux → 2.1.1-x86_64-linux

data/ext/re2/re2.cc

@@ -6,77 +6,21 @@
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
-#include <ruby.h>
-#include <re2/re2.h>
-#include <re2/set.h>
 #include <stdint.h>
-#include <string>
+
+#include <map>
 #include <sstream>
+#include <string>
 #include <vector>
-using std::string;
-using std::ostringstream;
-using std::nothrow;
-using std::map;
-using std::vector;
+
+#include <re2/re2.h>
+#include <re2/set.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
 
 #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
 #define UNUSED(x) ((void)x)
 
-#ifndef RSTRING_LEN
-  #define RSTRING_LEN(x) (RSTRING(x)->len)
-#endif
-
-#ifndef RSTRING_PTR
-  #define RSTRING_PTR(x) (RSTRING(x)->ptr)
-#endif
-
-#ifdef HAVE_RUBY_ENCODING_H
-  #include <ruby/encoding.h>
-  #define ENCODED_STR_NEW(str, length, encoding) \
-    ({ \
-      VALUE _string = rb_str_new(str, length); \
-      int _enc = rb_enc_find_index(encoding); \
-      rb_enc_associate_index(_string, _enc); \
-      _string; \
-    })
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    ({ \
-      VALUE _string = rb_str_new(str, length); \
-      int _enc = rb_enc_get_index(str2); \
-      rb_enc_associate_index(_string, _enc); \
-      _string; \
-    })
-#else
-  #define ENCODED_STR_NEW(str, length, encoding) \
-    rb_str_new((const char *)str, (long)length)
-  #define ENCODED_STR_NEW2(str, length, str2) \
-    rb_str_new((const char *)str, (long)length)
-#endif
-
-#ifdef HAVE_RB_STR_SUBLEN
-  #define ENCODED_STR_SUBLEN(str, offset, encoding) \
-     LONG2NUM(rb_str_sublen(str, offset))
-#else
-  #ifdef HAVE_RUBY_ENCODING_H
-    #define ENCODED_STR_SUBLEN(str, offset, encoding) \
-      ({ \
-        VALUE _string = ENCODED_STR_NEW(RSTRING_PTR(str), offset, encoding); \
-        rb_str_length(_string); \
-      })
-  #else
-    #define ENCODED_STR_SUBLEN(str, offset, encoding) \
-      LONG2NUM(offset)
-  #endif
-#endif
-
-#ifdef HAVE_ENDPOS_ARGUMENT
-  #define match(pattern, text, startpos, endpos, anchor, match, nmatch) \
-          (pattern->Match(text, startpos, endpos, anchor, match, nmatch))
-#else
-  #define match(pattern, text, startpos, endpos, anchor, match, nmatch) \
-          (pattern->Match(text, startpos, anchor, match, nmatch))
-#endif
-
 typedef struct {
   RE2 *pattern;
 } re2_pattern;
@@ -107,95 +51,103 @@ static ID id_utf8, id_posix_syntax, id_longest_match, id_log_errors,
           id_perl_classes, id_word_boundary, id_one_line,
           id_unanchored, id_anchor_start, id_anchor_both, id_exception;
 
-void parse_re2_options(RE2::Options& re2_options, VALUE options) {
+inline VALUE encoded_str_new(const char *str, long length, RE2::Options::Encoding encoding) {
+  if (encoding == RE2::Options::EncodingUTF8) {
+    return rb_utf8_str_new(str, length);
+  }
+
+  VALUE string = rb_str_new(str, length);
+  rb_enc_associate_index(string, rb_enc_find_index("ISO-8859-1"));
+
+  return string;
+}
+
+static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
   if (TYPE(options) != T_HASH) {
     rb_raise(rb_eArgError, "options should be a hash");
   }
-  VALUE utf8, posix_syntax, longest_match, log_errors,
-        max_mem, literal, never_nl, case_sensitive, perl_classes,
-        word_boundary, one_line;
 
-  utf8 = rb_hash_aref(options, ID2SYM(id_utf8));
+  VALUE utf8 = rb_hash_aref(options, ID2SYM(id_utf8));
   if (!NIL_P(utf8)) {
-    re2_options.set_encoding(RTEST(utf8) ? RE2::Options::EncodingUTF8 : RE2::Options::EncodingLatin1);
+    re2_options->set_encoding(RTEST(utf8) ? RE2::Options::EncodingUTF8 : RE2::Options::EncodingLatin1);
   }
 
-  posix_syntax = rb_hash_aref(options, ID2SYM(id_posix_syntax));
+  VALUE posix_syntax = rb_hash_aref(options, ID2SYM(id_posix_syntax));
   if (!NIL_P(posix_syntax)) {
-    re2_options.set_posix_syntax(RTEST(posix_syntax));
+    re2_options->set_posix_syntax(RTEST(posix_syntax));
   }
 
-  longest_match = rb_hash_aref(options, ID2SYM(id_longest_match));
+  VALUE longest_match = rb_hash_aref(options, ID2SYM(id_longest_match));
   if (!NIL_P(longest_match)) {
-    re2_options.set_longest_match(RTEST(longest_match));
+    re2_options->set_longest_match(RTEST(longest_match));
   }
 
-  log_errors = rb_hash_aref(options, ID2SYM(id_log_errors));
+  VALUE log_errors = rb_hash_aref(options, ID2SYM(id_log_errors));
   if (!NIL_P(log_errors)) {
-    re2_options.set_log_errors(RTEST(log_errors));
+    re2_options->set_log_errors(RTEST(log_errors));
   }
 
-  max_mem = rb_hash_aref(options, ID2SYM(id_max_mem));
+  VALUE max_mem = rb_hash_aref(options, ID2SYM(id_max_mem));
   if (!NIL_P(max_mem)) {
-    re2_options.set_max_mem(NUM2INT(max_mem));
+    re2_options->set_max_mem(NUM2INT(max_mem));
   }
 
-  literal = rb_hash_aref(options, ID2SYM(id_literal));
+  VALUE literal = rb_hash_aref(options, ID2SYM(id_literal));
   if (!NIL_P(literal)) {
-    re2_options.set_literal(RTEST(literal));
+    re2_options->set_literal(RTEST(literal));
   }
 
-  never_nl = rb_hash_aref(options, ID2SYM(id_never_nl));
+  VALUE never_nl = rb_hash_aref(options, ID2SYM(id_never_nl));
   if (!NIL_P(never_nl)) {
-    re2_options.set_never_nl(RTEST(never_nl));
+    re2_options->set_never_nl(RTEST(never_nl));
   }
 
-  case_sensitive = rb_hash_aref(options, ID2SYM(id_case_sensitive));
+  VALUE case_sensitive = rb_hash_aref(options, ID2SYM(id_case_sensitive));
   if (!NIL_P(case_sensitive)) {
-    re2_options.set_case_sensitive(RTEST(case_sensitive));
+    re2_options->set_case_sensitive(RTEST(case_sensitive));
   }
 
-  perl_classes = rb_hash_aref(options, ID2SYM(id_perl_classes));
+  VALUE perl_classes = rb_hash_aref(options, ID2SYM(id_perl_classes));
   if (!NIL_P(perl_classes)) {
-    re2_options.set_perl_classes(RTEST(perl_classes));
+    re2_options->set_perl_classes(RTEST(perl_classes));
   }
 
-  word_boundary = rb_hash_aref(options, ID2SYM(id_word_boundary));
+  VALUE word_boundary = rb_hash_aref(options, ID2SYM(id_word_boundary));
   if (!NIL_P(word_boundary)) {
-    re2_options.set_word_boundary(RTEST(word_boundary));
+    re2_options->set_word_boundary(RTEST(word_boundary));
   }
 
-  one_line = rb_hash_aref(options, ID2SYM(id_one_line));
+  VALUE one_line = rb_hash_aref(options, ID2SYM(id_one_line));
   if (!NIL_P(one_line)) {
-    re2_options.set_one_line(RTEST(one_line));
+    re2_options->set_one_line(RTEST(one_line));
   }
 }
 
-void re2_matchdata_mark(re2_matchdata* self) {
+static void re2_matchdata_mark(re2_matchdata* self) {
   rb_gc_mark(self->regexp);
   rb_gc_mark(self->text);
 }
 
-void re2_matchdata_free(re2_matchdata* self) {
+static void re2_matchdata_free(re2_matchdata* self) {
   if (self->matches) {
     delete[] self->matches;
   }
   free(self);
 }
 
-void re2_scanner_mark(re2_scanner* self) {
+static void re2_scanner_mark(re2_scanner* self) {
   rb_gc_mark(self->regexp);
   rb_gc_mark(self->text);
 }
 
-void re2_scanner_free(re2_scanner* self) {
+static void re2_scanner_free(re2_scanner* self) {
   if (self->input) {
     delete self->input;
   }
   free(self);
 }
 
-void re2_regexp_free(re2_pattern* self) {
+static void re2_regexp_free(re2_pattern* self) {
   if (self->pattern) {
     delete self->pattern;
   }
@@ -204,12 +156,14 @@ void re2_regexp_free(re2_pattern* self) {
 
 static VALUE re2_matchdata_allocate(VALUE klass) {
   re2_matchdata *m;
+
   return Data_Make_Struct(klass, re2_matchdata, re2_matchdata_mark,
       re2_matchdata_free, m);
 }
 
 static VALUE re2_scanner_allocate(VALUE klass) {
   re2_scanner *c;
+
   return Data_Make_Struct(klass, re2_scanner, re2_scanner_mark,
       re2_scanner_free, c);
 }
@@ -222,7 +176,7 @@ static VALUE re2_scanner_allocate(VALUE klass) {
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
  *   m.string  #=> "bob 123"
  */
-static VALUE re2_matchdata_string(VALUE self) {
+static VALUE re2_matchdata_string(const VALUE self) {
   re2_matchdata *m;
   Data_Get_Struct(self, re2_matchdata, m);
 
@@ -237,7 +191,7 @@ static VALUE re2_matchdata_string(VALUE self) {
  *   c = RE2::Regexp.new('(\d+)').scan("foo")
  *   c.string #=> "foo"
  */
-static VALUE re2_scanner_string(VALUE self) {
+static VALUE re2_scanner_string(const VALUE self) {
   re2_scanner *c;
   Data_Get_Struct(self, re2_scanner, c);
 
@@ -252,7 +206,7 @@ static VALUE re2_scanner_string(VALUE self) {
  *   c = RE2::Regexp.new('(\d+)').scan("foo")
  *   c.eof? #=> true
  */
-static VALUE re2_scanner_eof(VALUE self) {
+static VALUE re2_scanner_eof(const VALUE self) {
   re2_scanner *c;
   Data_Get_Struct(self, re2_scanner, c);
 
@@ -274,7 +228,7 @@ static VALUE re2_scanner_rewind(VALUE self) {
   re2_scanner *c;
   Data_Get_Struct(self, re2_scanner, c);
 
-  c->input = new(nothrow) re2::StringPiece(StringValuePtr(c->text));
+  c->input = new(std::nothrow) re2::StringPiece(StringValuePtr(c->text));
   c->eof = false;
 
   return self;
@@ -284,6 +238,10 @@ static VALUE re2_scanner_rewind(VALUE self) {
  * Scan the given text incrementally for matches, returning an array of
  * matches on each subsequent call. Returns nil if no matches are found.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String>] the matches.
  * @example
  *   s = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
@@ -291,45 +249,41 @@ static VALUE re2_scanner_rewind(VALUE self) {
  *   s.scan #=> ["bar"]
  */
 static VALUE re2_scanner_scan(VALUE self) {
-  int i;
-  size_t original_input_size, new_input_size;
-  bool input_advanced;
   re2_pattern *p;
   re2_scanner *c;
-  VALUE result;
 
   Data_Get_Struct(self, re2_scanner, c);
   Data_Get_Struct(c->regexp, re2_pattern, p);
 
-  vector<RE2::Arg> argv(c->number_of_capturing_groups);
-  vector<RE2::Arg*> args(c->number_of_capturing_groups);
-  vector<string> matches(c->number_of_capturing_groups);
+  std::vector<RE2::Arg> argv(c->number_of_capturing_groups);
+  std::vector<RE2::Arg*> args(c->number_of_capturing_groups);
+  std::vector<std::string> matches(c->number_of_capturing_groups);
 
   if (c->eof) {
     return Qnil;
   }
 
-  original_input_size = c->input->size();
+  re2::StringPiece::size_type original_input_size = c->input->size();
 
-  for (i = 0; i < c->number_of_capturing_groups; i++) {
-    matches[i] = "";
+  for (int i = 0; i < c->number_of_capturing_groups; ++i) {
     argv[i] = &matches[i];
     args[i] = &argv[i];
   }
 
   if (RE2::FindAndConsumeN(c->input, *p->pattern, &args[0],
         c->number_of_capturing_groups)) {
-    result = rb_ary_new2(c->number_of_capturing_groups);
-    new_input_size = c->input->size();
-    input_advanced = new_input_size < original_input_size;
+    re2::StringPiece::size_type new_input_size = c->input->size();
+    bool input_advanced = new_input_size < original_input_size;
 
-    for (i = 0; i < c->number_of_capturing_groups; i++) {
+    VALUE result = rb_ary_new2(c->number_of_capturing_groups);
+
+    for (int i = 0; i < c->number_of_capturing_groups; ++i) {
       if (matches[i].empty()) {
         rb_ary_push(result, Qnil);
       } else {
-        rb_ary_push(result, ENCODED_STR_NEW(matches[i].data(),
+        rb_ary_push(result, encoded_str_new(matches[i].data(),
               matches[i].size(),
-              p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1"));
+              p->pattern->options().encoding()));
       }
     }
 
@@ -340,47 +294,40 @@ static VALUE re2_scanner_scan(VALUE self) {
     if (!input_advanced && new_input_size > 0) {
       c->input->remove_prefix(1);
     }
+
+    return result;
   } else {
-    result = Qnil;
+    return Qnil;
   }
-
-  return result;
 }
 
 /*
  * Retrieve a matchdata by index or name.
  */
-re2::StringPiece *re2_matchdata_find_match(VALUE idx, VALUE self) {
-  int id;
+static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  map<string, int> groups;
-  string name;
-  re2::StringPiece *match;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
+  int id;
+
   if (FIXNUM_P(idx)) {
     id = FIX2INT(idx);
   } else {
-    if (SYMBOL_P(idx)) {
-      name = rb_id2name(SYM2ID(idx));
-    } else {
-      name = StringValuePtr(idx);
-    }
-
-    groups = p->pattern->NamedCapturingGroups();
+    const char *name = SYMBOL_P(idx) ? rb_id2name(SYM2ID(idx)) : StringValuePtr(idx);
+    const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
 
-    if (groups.count(name) == 1) {
-      id = groups[name];
+    if (std::map<std::string, int>::const_iterator search = groups.find(name); search != groups.end()) {
+      id = search->second;
     } else {
       return NULL;
     }
   }
 
   if (id >= 0 && id < m->number_of_matches) {
-    match = &m->matches[id];
+    re2::StringPiece *match = &m->matches[id];
 
     if (!match->empty()) {
       return match;
@@ -399,7 +346,7 @@ re2::StringPiece *re2_matchdata_find_match(VALUE idx, VALUE self) {
  *   m.size      #=> 2
  *   m.length    #=> 2
  */
-static VALUE re2_matchdata_size(VALUE self) {
+static VALUE re2_matchdata_size(const VALUE self) {
   re2_matchdata *m;
   Data_Get_Struct(self, re2_matchdata, m);
 
@@ -416,23 +363,18 @@ static VALUE re2_matchdata_size(VALUE self) {
  *   m.begin(0)  #=> 1
  *   m.begin(1)  #=> 4
  */
-static VALUE re2_matchdata_begin(VALUE self, VALUE n) {
+static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
   re2_matchdata *m;
-  re2_pattern *p;
-  re2::StringPiece *match;
-  long offset;
 
   Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
 
-  match = re2_matchdata_find_match(n, self);
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
     return Qnil;
   } else {
-    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text));
+    long offset = match->data() - StringValuePtr(m->text);
 
-    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
-           p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+    return LONG2NUM(rb_str_sublen(StringValue(m->text), offset));
   }
 }
 
@@ -446,24 +388,18 @@ static VALUE re2_matchdata_begin(VALUE self, VALUE n) {
  *   m.end(0)  #=> 9
  *   m.end(1)  #=> 7
  */
-static VALUE re2_matchdata_end(VALUE self, VALUE n) {
+static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   re2_matchdata *m;
-  re2_pattern *p;
-  re2::StringPiece *match;
-  long offset;
 
   Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
-
-  match = re2_matchdata_find_match(n, self);
 
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
     return Qnil;
   } else {
-    offset = reinterpret_cast<uintptr_t>(match->data()) - reinterpret_cast<uintptr_t>(StringValuePtr(m->text)) + match->size();
+    long offset = (match->data() - StringValuePtr(m->text)) + match->size();
 
-    return ENCODED_STR_SUBLEN(StringValue(m->text), offset,
-           p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+    return LONG2NUM(rb_str_sublen(StringValue(m->text), offset));
   }
 }
 
@@ -475,9 +411,10 @@ static VALUE re2_matchdata_end(VALUE self, VALUE n) {
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
  *   m.regexp    #=> #<RE2::Regexp /(\d+)/>
  */
-static VALUE re2_matchdata_regexp(VALUE self) {
+static VALUE re2_matchdata_regexp(const VALUE self) {
   re2_matchdata *m;
   Data_Get_Struct(self, re2_matchdata, m);
+
   return m->regexp;
 }
 
@@ -489,7 +426,7 @@ static VALUE re2_matchdata_regexp(VALUE self) {
  *   c = RE2::Regexp.new('(\d+)').scan("bob 123")
  *   c.regexp    #=> #<RE2::Regexp /(\d+)/>
  */
-static VALUE re2_scanner_regexp(VALUE self) {
+static VALUE re2_scanner_regexp(const VALUE self) {
   re2_scanner *c;
   Data_Get_Struct(self, re2_scanner, c);
 
@@ -498,46 +435,47 @@ static VALUE re2_scanner_regexp(VALUE self) {
 
 static VALUE re2_regexp_allocate(VALUE klass) {
   re2_pattern *p;
+
   return Data_Make_Struct(klass, re2_pattern, 0, re2_regexp_free, p);
 }
 
 /*
  * Returns the array of matches.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>] the array of matches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
  *   m.to_a    #=> ["123", "123"]
  */
-static VALUE re2_matchdata_to_a(VALUE self) {
-  int i;
+static VALUE re2_matchdata_to_a(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  re2::StringPiece *match;
-  VALUE array;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
-  array = rb_ary_new2(m->number_of_matches);
-  for (i = 0; i < m->number_of_matches; i++) {
-    match = &m->matches[i];
+  VALUE array = rb_ary_new2(m->number_of_matches);
+  for (int i = 0; i < m->number_of_matches; ++i) {
+    re2::StringPiece *match = &m->matches[i];
 
     if (match->empty()) {
       rb_ary_push(array, Qnil);
     } else {
-      rb_ary_push(array, ENCODED_STR_NEW(match->data(), match->size(),
-            p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1"));
+      rb_ary_push(array, encoded_str_new(match->data(), match->size(),
+            p->pattern->options().encoding()));
     }
   }
 
   return array;
 }
 
-static VALUE re2_matchdata_nth_match(int nth, VALUE self) {
+static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  re2::StringPiece *match;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
@@ -545,32 +483,28 @@ static VALUE re2_matchdata_nth_match(int nth, VALUE self) {
   if (nth < 0 || nth >= m->number_of_matches) {
     return Qnil;
   } else {
-    match = &m->matches[nth];
+    re2::StringPiece *match = &m->matches[nth];
 
     if (match->empty()) {
       return Qnil;
     } else {
-      return ENCODED_STR_NEW(match->data(), match->size(),
-          p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+      return encoded_str_new(match->data(), match->size(),
+          p->pattern->options().encoding());
     }
   }
 }
 
-static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
-  int idx;
+static VALUE re2_matchdata_named_match(const char* name, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  map<string, int> groups;
-  string name_as_string(name);
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
-  groups = p->pattern->NamedCapturingGroups();
+  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
 
-  if (groups.count(name_as_string) == 1) {
-    idx = groups[name_as_string];
-    return re2_matchdata_nth_match(idx, self);
+  if (std::map<std::string, int>::const_iterator search = groups.find(name); search != groups.end()) {
+    return re2_matchdata_nth_match(search->second, self);
   } else {
     return Qnil;
   }
@@ -579,6 +513,10 @@ static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
 /*
  * Retrieve zero, one or more matches by index or name.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>, String, Boolean]
  *
  * @overload [](index)
@@ -619,7 +557,7 @@ static VALUE re2_matchdata_named_match(const char* name, VALUE self) {
  *     m["number"] #=> "123"
  *     m[:number]  #=> "123"
  */
-static VALUE re2_matchdata_aref(int argc, VALUE *argv, VALUE self) {
+static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
   VALUE idx, rest;
   rb_scan_args(argc, argv, "11", &idx, &rest);
 
@@ -639,38 +577,40 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, VALUE self) {
  *
  * @return [String] the entire matched string
  */
-static VALUE re2_matchdata_to_s(VALUE self) {
+static VALUE re2_matchdata_to_s(const VALUE self) {
   return re2_matchdata_nth_match(0, self);
 }
 
 /*
  * Returns a printable version of the match.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a printable version of the match
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
  *   m.inspect    #=> "#<RE2::MatchData \"123\" 1:\"123\">"
  */
-static VALUE re2_matchdata_inspect(VALUE self) {
-  int i;
+static VALUE re2_matchdata_inspect(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  VALUE match, result;
-  ostringstream output;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
+  std::ostringstream output;
   output << "#<RE2::MatchData";
 
-  for (i = 0; i < m->number_of_matches; i++) {
+  for (int i = 0; i < m->number_of_matches; ++i) {
     output << " ";
 
     if (i > 0) {
       output << i << ":";
     }
 
-    match = re2_matchdata_nth_match(i, self);
+    VALUE match = re2_matchdata_nth_match(i, self);
 
     if (match == Qnil) {
       output << "nil";
@@ -681,15 +621,17 @@ static VALUE re2_matchdata_inspect(VALUE self) {
 
   output << ">";
 
-  result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
-      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
-
-  return result;
+  return encoded_str_new(output.str().data(), output.str().length(),
+      p->pattern->options().encoding());
 }
 
 /*
  * Returns the array of submatches for pattern matching.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Array<String, nil>] the array of submatches
  * @example
  *   m = RE2::Regexp.new('(\d+)').match("bob 123")
@@ -703,25 +645,22 @@ static VALUE re2_matchdata_inspect(VALUE self) {
  *     puts "Unrecognised match"
  *   end
  */
-static VALUE re2_matchdata_deconstruct(VALUE self) {
-  int i;
+static VALUE re2_matchdata_deconstruct(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
-  re2::StringPiece *match;
-  VALUE array;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
-  array = rb_ary_new2(m->number_of_matches - 1);
-  for (i = 1; i < m->number_of_matches; i++) {
-    match = &m->matches[i];
+  VALUE array = rb_ary_new2(m->number_of_matches - 1);
+  for (int i = 1; i < m->number_of_matches; ++i) {
+    re2::StringPiece *match = &m->matches[i];
 
     if (match->empty()) {
       rb_ary_push(array, Qnil);
     } else {
-      rb_ary_push(array, ENCODED_STR_NEW(match->data(), match->size(),
-            p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1"));
+      rb_ary_push(array, encoded_str_new(match->data(), match->size(),
+            p->pattern->options().encoding()));
     }
   }
 
@@ -735,6 +674,10 @@ static VALUE re2_matchdata_deconstruct(VALUE self) {
  * more keys than there are capturing groups. Given keys will populate the hash in
  * order but an invalid name will cause the hash to be immediately returned.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Hash] a hash of capturing group names to submatches
  * @param [Array<Symbol>, nil] keys an array of Symbol capturing group names or nil to return all names
  * @example
@@ -752,40 +695,36 @@ static VALUE re2_matchdata_deconstruct(VALUE self) {
  *     puts "Unrecognised match"
  *   end
  */
-static VALUE re2_matchdata_deconstruct_keys(VALUE self, VALUE keys) {
-  int i;
-  VALUE capturing_groups, key;
+static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys) {
   re2_matchdata *m;
   re2_pattern *p;
-  map<string, int> groups;
-  map<string, int>::iterator iterator;
 
   Data_Get_Struct(self, re2_matchdata, m);
   Data_Get_Struct(m->regexp, re2_pattern, p);
 
-  groups = p->pattern->NamedCapturingGroups();
-  capturing_groups = rb_hash_new();
+  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  VALUE capturing_groups = rb_hash_new();
 
   if (NIL_P(keys)) {
-    for (iterator = groups.begin(); iterator != groups.end(); iterator++) {
+    for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern(iterator->first.data())),
-          re2_matchdata_nth_match(iterator->second, self));
+          ID2SYM(rb_intern(it->first.data())),
+          re2_matchdata_nth_match(it->second, self));
     }
   } else {
     Check_Type(keys, T_ARRAY);
 
     if (p->pattern->NumberOfCapturingGroups() >= RARRAY_LEN(keys)) {
-      for (i = 0; i < RARRAY_LEN(keys); i++) {
-        key = rb_ary_entry(keys, i);
+      for (int i = 0; i < RARRAY_LEN(keys); ++i) {
+        VALUE key = rb_ary_entry(keys, i);
         Check_Type(key, T_SYMBOL);
-        string name(rb_id2name(SYM2ID(key)));
+        const char *name = rb_id2name(SYM2ID(key));
 
-        if (groups.count(name) == 0) {
+        if (std::map<std::string, int>::const_iterator search = groups.find(name); search != groups.end()) {
+          rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(search->second, self));
+        } else {
           break;
         }
-
-        rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(groups[name], self));
       }
     }
   }
@@ -802,6 +741,7 @@ static VALUE re2_matchdata_deconstruct_keys(VALUE self, VALUE keys) {
  */
 static VALUE re2_re2(int argc, VALUE *argv, VALUE self) {
   UNUSED(self);
+
   return rb_class_new_instance(argc, argv, re2_cRegexp);
 }
 
@@ -849,11 +789,11 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   if (RTEST(options)) {
     RE2::Options re2_options;
-    parse_re2_options(re2_options, options);
+    parse_re2_options(&re2_options, options);
 
-    p->pattern = new(nothrow) RE2(StringValuePtr(pattern), re2_options);
+    p->pattern = new(std::nothrow) RE2(StringValuePtr(pattern), re2_options);
   } else {
-    p->pattern = new(nothrow) RE2(StringValuePtr(pattern));
+    p->pattern = new(std::nothrow) RE2(StringValuePtr(pattern));
   }
 
   if (p->pattern == 0) {
@@ -866,40 +806,47 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 /*
  * Returns a printable version of the regular expression +re2+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a printable version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
  *   re2.inspect    #=> "#<RE2::Regexp /woo?/>"
  */
-static VALUE re2_regexp_inspect(VALUE self) {
+static VALUE re2_regexp_inspect(const VALUE self) {
   re2_pattern *p;
-  VALUE result;
-  ostringstream output;
 
   Data_Get_Struct(self, re2_pattern, p);
 
-  output << "#<RE2::Regexp /" << p->pattern->pattern() << "/>";
+  std::ostringstream output;
 
-  result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
-      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+  output << "#<RE2::Regexp /" << p->pattern->pattern() << "/>";
 
-  return result;
+  return encoded_str_new(output.str().data(), output.str().length(),
+      p->pattern->options().encoding());
 }
 
 /*
  * Returns a string version of the regular expression +re2+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String] a string version of the regular expression
  * @example
  *   re2 = RE2::Regexp.new("woo?")
  *   re2.to_s    #=> "woo?"
  */
-static VALUE re2_regexp_to_s(VALUE self) {
+static VALUE re2_regexp_to_s(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
-  return ENCODED_STR_NEW(p->pattern->pattern().data(),
+
+  return encoded_str_new(p->pattern->pattern().data(),
       p->pattern->pattern().size(),
-      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+      p->pattern->options().encoding());
 }
 
 /*
@@ -911,9 +858,10 @@ static VALUE re2_regexp_to_s(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?")
  *   re2.ok?    #=> true
  */
-static VALUE re2_regexp_ok(VALUE self) {
+static VALUE re2_regexp_ok(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->ok());
 }
 
@@ -926,9 +874,10 @@ static VALUE re2_regexp_ok(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :utf8 => true)
  *   re2.utf8?    #=> true
  */
-static VALUE re2_regexp_utf8(VALUE self) {
+static VALUE re2_regexp_utf8(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
 }
 
@@ -941,9 +890,10 @@ static VALUE re2_regexp_utf8(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :posix_syntax => true)
  *   re2.posix_syntax?    #=> true
  */
-static VALUE re2_regexp_posix_syntax(VALUE self) {
+static VALUE re2_regexp_posix_syntax(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().posix_syntax());
 }
 
@@ -956,9 +906,10 @@ static VALUE re2_regexp_posix_syntax(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :longest_match => true)
  *   re2.longest_match?    #=> true
  */
-static VALUE re2_regexp_longest_match(VALUE self) {
+static VALUE re2_regexp_longest_match(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().longest_match());
 }
 
@@ -971,9 +922,10 @@ static VALUE re2_regexp_longest_match(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :log_errors => true)
  *   re2.log_errors?    #=> true
  */
-static VALUE re2_regexp_log_errors(VALUE self) {
+static VALUE re2_regexp_log_errors(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().log_errors());
 }
 
@@ -986,9 +938,10 @@ static VALUE re2_regexp_log_errors(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :max_mem => 1024)
  *   re2.max_mem    #=> 1024
  */
-static VALUE re2_regexp_max_mem(VALUE self) {
+static VALUE re2_regexp_max_mem(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return INT2FIX(p->pattern->options().max_mem());
 }
 
@@ -1001,9 +954,10 @@ static VALUE re2_regexp_max_mem(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :literal => true)
  *   re2.literal?    #=> true
  */
-static VALUE re2_regexp_literal(VALUE self) {
+static VALUE re2_regexp_literal(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().literal());
 }
 
@@ -1016,9 +970,10 @@ static VALUE re2_regexp_literal(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :never_nl => true)
  *   re2.never_nl?    #=> true
  */
-static VALUE re2_regexp_never_nl(VALUE self) {
+static VALUE re2_regexp_never_nl(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().never_nl());
 }
 
@@ -1031,9 +986,10 @@ static VALUE re2_regexp_never_nl(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :case_sensitive => true)
  *   re2.case_sensitive?    #=> true
  */
-static VALUE re2_regexp_case_sensitive(VALUE self) {
+static VALUE re2_regexp_case_sensitive(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().case_sensitive());
 }
 
@@ -1047,7 +1003,7 @@ static VALUE re2_regexp_case_sensitive(VALUE self) {
  *   re2.case_insensitive?    #=> false
  *   re2.casefold?    #=> false
  */
-static VALUE re2_regexp_case_insensitive(VALUE self) {
+static VALUE re2_regexp_case_insensitive(const VALUE self) {
   return BOOL2RUBY(re2_regexp_case_sensitive(self) != Qtrue);
 }
 
@@ -1060,9 +1016,10 @@ static VALUE re2_regexp_case_insensitive(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :perl_classes => true)
  *   re2.perl_classes?    #=> true
  */
-static VALUE re2_regexp_perl_classes(VALUE self) {
+static VALUE re2_regexp_perl_classes(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().perl_classes());
 }
 
@@ -1075,9 +1032,10 @@ static VALUE re2_regexp_perl_classes(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :word_boundary => true)
  *   re2.word_boundary?    #=> true
  */
-static VALUE re2_regexp_word_boundary(VALUE self) {
+static VALUE re2_regexp_word_boundary(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().word_boundary());
 }
 
@@ -1090,9 +1048,10 @@ static VALUE re2_regexp_word_boundary(VALUE self) {
  *   re2 = RE2::Regexp.new("woo?", :one_line => true)
  *   re2.one_line?    #=> true
  */
-static VALUE re2_regexp_one_line(VALUE self) {
+static VALUE re2_regexp_one_line(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return BOOL2RUBY(p->pattern->options().one_line());
 }
 
@@ -1102,9 +1061,10 @@ static VALUE re2_regexp_one_line(VALUE self) {
  *
  * @return [String, nil] the error string or nil
  */
-static VALUE re2_regexp_error(VALUE self) {
+static VALUE re2_regexp_error(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   if (p->pattern->ok()) {
     return Qnil;
   } else {
@@ -1116,17 +1076,22 @@ static VALUE re2_regexp_error(VALUE self) {
  * If the RE2 could not be created properly, returns
  * the offending portion of the regexp otherwise returns nil.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [String, nil] the offending portion of the regexp or nil
  */
-static VALUE re2_regexp_error_arg(VALUE self) {
+static VALUE re2_regexp_error_arg(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   if (p->pattern->ok()) {
     return Qnil;
   } else {
-    return ENCODED_STR_NEW(p->pattern->error_arg().data(),
+    return encoded_str_new(p->pattern->error_arg().data(),
         p->pattern->error_arg().size(),
-        p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+        p->pattern->options().encoding());
   }
 }
 
@@ -1137,9 +1102,10 @@ static VALUE re2_regexp_error_arg(VALUE self) {
  *
  * @return [Integer] the regexp "cost"
  */
-static VALUE re2_regexp_program_size(VALUE self) {
+static VALUE re2_regexp_program_size(const VALUE self) {
   re2_pattern *p;
   Data_Get_Struct(self, re2_pattern, p);
+
   return INT2FIX(p->pattern->ProgramSize());
 }
 
@@ -1149,12 +1115,11 @@ static VALUE re2_regexp_program_size(VALUE self) {
  *
  * @return [Hash] the options
  */
-static VALUE re2_regexp_options(VALUE self) {
-  VALUE options;
+static VALUE re2_regexp_options(const VALUE self) {
   re2_pattern *p;
 
   Data_Get_Struct(self, re2_pattern, p);
-  options = rb_hash_new();
+  VALUE options = rb_hash_new();
 
   rb_hash_aset(options, ID2SYM(id_utf8),
       BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8));
@@ -1202,33 +1167,34 @@ static VALUE re2_regexp_options(VALUE self) {
  *
  * @return [Integer] the number of capturing subpatterns
  */
-static VALUE re2_regexp_number_of_capturing_groups(VALUE self) {
+static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
   re2_pattern *p;
-
   Data_Get_Struct(self, re2_pattern, p);
+
   return INT2FIX(p->pattern->NumberOfCapturingGroups());
 }
 
 /*
  * Returns a hash of names to capturing indices of groups.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @return [Hash] a hash of names to capturing indices
  */
-static VALUE re2_regexp_named_capturing_groups(VALUE self) {
-  VALUE capturing_groups;
+static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
   re2_pattern *p;
-  map<string, int> groups;
-  map<string, int>::iterator iterator;
 
   Data_Get_Struct(self, re2_pattern, p);
-  groups = p->pattern->NamedCapturingGroups();
-  capturing_groups = rb_hash_new();
+  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  VALUE capturing_groups = rb_hash_new();
 
-  for (iterator = groups.begin(); iterator != groups.end(); iterator++) {
+  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
     rb_hash_aset(capturing_groups,
-        ENCODED_STR_NEW(iterator->first.data(), iterator->first.size(),
-          p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1"),
-        INT2FIX(iterator->second));
+        encoded_str_new(it->first.data(), it->first.size(),
+          p->pattern->options().encoding()),
+        INT2FIX(it->second));
   }
 
   return capturing_groups;
@@ -1242,16 +1208,23 @@ static VALUE re2_regexp_named_capturing_groups(VALUE self) {
  * @return [Boolean, RE2::MatchData]
  *
  * @overload match(text)
- *   Returns an {RE2::MatchData} containing the matching
- *   pattern and all subpatterns resulting from looking for
- *   the regexp in +text+.
+ *   Returns an {RE2::MatchData} containing the matching pattern and all
+ *   subpatterns resulting from looking for the regexp in +text+ if the pattern
+ *   contains capturing groups.
+ *
+ *   Returns either true or false indicating whether a successful match was
+ *   made if the pattern contains no capturing groups.
  *
  *   @param [String] text the text to search
- *   @return [RE2::MatchData] the matches
+ *   @return [RE2::MatchData] if the pattern contains capturing groups
+ *   @return [Boolean] if the pattern does not contain capturing groups
  *   @raise [NoMemoryError] if there was not enough memory to allocate the matches
- *   @example
+ *   @example Matching with capturing groups
  *     r = RE2::Regexp.new('w(o)(o)')
  *     r.match('woo')    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+ *   @example Matching without capturing groups
+ *     r = RE2::Regexp.new('woo')
+ *     r.match('woo')    #=> true
  *
  * @overload match(text, 0)
  *   Returns either true or false indicating whether a
@@ -1279,20 +1252,20 @@ static VALUE re2_regexp_named_capturing_groups(VALUE self) {
  *     r.match('woo', 1) #=> #<RE2::MatchData "woo" 1:"o">
  *     r.match('woo', 3) #=> #<RE2::MatchData "woo" 1:"o" 2:"o" 3:nil>
  */
-static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
-  int n;
-  bool matched;
+static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   re2_pattern *p;
   re2_matchdata *m;
-  VALUE text, number_of_matches, matchdata;
+  VALUE text, number_of_matches;
 
   rb_scan_args(argc, argv, "11", &text, &number_of_matches);
 
   /* Ensure text is a string. */
-  text = StringValue(text);
+  StringValue(text);
 
   Data_Get_Struct(self, re2_pattern, p);
 
+  int n;
+
   if (RTEST(number_of_matches)) {
     n = NUM2INT(number_of_matches);
 
@@ -1308,17 +1281,21 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
   }
 
   if (n == 0) {
-    matched = match(p->pattern, StringValuePtr(text), 0,
-        static_cast<int>(RSTRING_LEN(text)), RE2::UNANCHORED, 0, 0);
+#ifdef HAVE_ENDPOS_ARGUMENT
+    bool matched = p->pattern->Match(StringValuePtr(text), 0,
+        RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
+#else
+    bool matched = p->pattern->Match(StringValuePtr(text), 0, RE2::UNANCHORED,
+        0, 0);
+#endif
     return BOOL2RUBY(matched);
   } else {
-
     /* Because match returns the whole match as well. */
     n += 1;
 
-    matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
+    VALUE matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
     Data_Get_Struct(matchdata, re2_matchdata, m);
-    m->matches = new(nothrow) re2::StringPiece[n];
+    m->matches = new(std::nothrow) re2::StringPiece[n];
     m->regexp = self;
     m->text = rb_str_dup(text);
     rb_str_freeze(m->text);
@@ -1330,10 +1307,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
 
     m->number_of_matches = n;
 
-    matched = match(p->pattern, StringValuePtr(m->text), 0,
-                    static_cast<int>(RSTRING_LEN(m->text)),
-                    RE2::UNANCHORED, m->matches, n);
-
+#ifdef HAVE_ENDPOS_ARGUMENT
+    bool matched = p->pattern->Match(StringValuePtr(m->text), 0,
+        RSTRING_LEN(m->text), RE2::UNANCHORED, m->matches, n);
+#else
+    bool matched = p->pattern->Match(StringValuePtr(m->text), 0,
+        RE2::UNANCHORED, m->matches, n);
+#endif
     if (matched) {
       return matchdata;
     } else {
@@ -1348,10 +1328,8 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
  *
  * @return [Boolean] whether the match was successful
  */
-static VALUE re2_regexp_match_p(VALUE self, VALUE text) {
-  VALUE argv[2];
-  argv[0] = text;
-  argv[1] = INT2FIX(0);
+static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
+  VALUE argv[2] = { text, INT2FIX(0) };
 
   return re2_regexp_match(2, argv, self);
 }
@@ -1362,16 +1340,15 @@ static VALUE re2_regexp_match_p(VALUE self, VALUE text) {
  * @example
  *   c = RE2::Regexp.new('(\w+)').scan("Foo bar baz")
  */
-static VALUE re2_regexp_scan(VALUE self, VALUE text) {
+static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   re2_pattern *p;
   re2_scanner *c;
-  VALUE scanner;
 
   Data_Get_Struct(self, re2_pattern, p);
-  scanner = rb_class_new_instance(0, 0, re2_cScanner);
+  VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   Data_Get_Struct(scanner, re2_scanner, c);
 
-  c->input = new(nothrow) re2::StringPiece(StringValuePtr(text));
+  c->input = new(std::nothrow) re2::StringPiece(StringValuePtr(text));
   c->regexp = self;
   c->text = text;
 
@@ -1390,6 +1367,10 @@ static VALUE re2_regexp_scan(VALUE self, VALUE text) {
  * Returns a copy of +str+ with the first occurrence +pattern+
  * replaced with +rewrite+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @param [String] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1404,29 +1385,33 @@ static VALUE re2_Replace(VALUE self, VALUE str, VALUE pattern,
   UNUSED(self);
   re2_pattern *p;
 
-  /* Convert all the inputs to be pumped into RE2::Replace. */
-  string str_as_string(StringValuePtr(str));
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::Replace.
+   */
+  std::string str_as_string(StringValuePtr(str));
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     Data_Get_Struct(pattern, re2_pattern, p);
     RE2::Replace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
-        p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        p->pattern->options().encoding());
   } else {
     RE2::Replace(&str_as_string, StringValuePtr(pattern),
         StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
-
 }
 
 /*
  * Return a copy of +str+ with +pattern+ replaced by +rewrite+.
  *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the :utf8 option for the
+ * RE2::Regexp is set to false (any other encoding's behaviour is undefined).
+ *
  * @param [String] str the string to modify
  * @param [String, RE2::Regexp] pattern a regexp matching text to be replaced
  * @param [String] rewrite the string to replace with
@@ -1440,23 +1425,24 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
                                VALUE rewrite) {
   UNUSED(self);
 
-  /* Convert all the inputs to be pumped into RE2::GlobalReplace. */
+  /* Take a copy of str so it can be modified in-place by
+   * RE2::GlobalReplace.
+   */
   re2_pattern *p;
-  string str_as_string(StringValuePtr(str));
+  std::string str_as_string(StringValuePtr(str));
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     Data_Get_Struct(pattern, re2_pattern, p);
     RE2::GlobalReplace(&str_as_string, *p->pattern, StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW(str_as_string.data(), str_as_string.size(),
-        p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        p->pattern->options().encoding());
   } else {
     RE2::GlobalReplace(&str_as_string, StringValuePtr(pattern),
                        StringValuePtr(rewrite));
 
-    return ENCODED_STR_NEW2(str_as_string.data(), str_as_string.size(),
-        pattern);
+    return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
   }
 }
 
@@ -1472,11 +1458,12 @@ static VALUE re2_GlobalReplace(VALUE self, VALUE str, VALUE pattern,
  */
 static VALUE re2_QuoteMeta(VALUE self, VALUE unquoted) {
   UNUSED(self);
-  string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
+  std::string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
+
   return rb_str_new(quoted_string.data(), quoted_string.size());
 }
 
-void re2_set_free(re2_set *self) {
+static void re2_set_free(re2_set *self) {
   if (self->set) {
     delete self->set;
   }
@@ -1486,6 +1473,7 @@ void re2_set_free(re2_set *self) {
 static VALUE re2_set_allocate(VALUE klass) {
   re2_set *s;
   VALUE result = Data_Make_Struct(klass, re2_set, 0, re2_set_free, s);
+
   return result;
 }
 
@@ -1533,18 +1521,16 @@ static VALUE re2_set_allocate(VALUE klass) {
 static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE anchor, options;
   re2_set *s;
-  RE2::Anchor re2_anchor;
+  RE2::Anchor re2_anchor = RE2::UNANCHORED;
   RE2::Options re2_options;
 
   rb_scan_args(argc, argv, "02", &anchor, &options);
   Data_Get_Struct(self, re2_set, s);
 
   if (RTEST(options)) {
-    parse_re2_options(re2_options, options);
+    parse_re2_options(&re2_options, options);
   }
-  if (NIL_P(anchor)) {
-    re2_anchor = RE2::UNANCHORED;
-  } else {
+  if (!NIL_P(anchor)) {
     Check_Type(anchor, T_SYMBOL);
     ID id_anchor = SYM2ID(anchor);
     if (id_anchor == id_unanchored) {
@@ -1558,7 +1544,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     }
   }
 
-  s->set = new(nothrow) RE2::Set(re2_options, re2_anchor);
+  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");
   }
@@ -1579,11 +1565,12 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
  *   set.add("def")    #=> 1
  */
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
-  Check_Type(pattern, T_STRING);
+  StringValue(pattern);
   re2::StringPiece regex(RSTRING_PTR(pattern), RSTRING_LEN(pattern));
   std::string err;
   re2_set *s;
   Data_Get_Struct(self, re2_set, s);
+
   int index = s->set->Add(regex, &err);
   if (index < 0) {
     rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", err.c_str());
@@ -1665,25 +1652,27 @@ static VALUE re2_set_match_raises_errors_p(VALUE self) {
  *     set.compile
  *     set.match("abcdef", :exception => true)    # => [0, 1]
  */
-static VALUE re2_set_match(int argc, VALUE *argv, VALUE self) {
-  VALUE str, options, exception_option;
+static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
+  VALUE str, options;
   bool raise_exception = true;
   rb_scan_args(argc, argv, "11", &str, &options);
-  Check_Type(str, T_STRING);
+
+  StringValue(str);
   re2::StringPiece data(RSTRING_PTR(str), RSTRING_LEN(str));
-  std::vector<int> v;
   re2_set *s;
   Data_Get_Struct(self, re2_set, s);
 
   if (RTEST(options)) {
     Check_Type(options, T_HASH);
 
-    exception_option = rb_hash_aref(options, ID2SYM(id_exception));
+    VALUE exception_option = rb_hash_aref(options, ID2SYM(id_exception));
     if (!NIL_P(exception_option)) {
       raise_exception = RTEST(exception_option);
     }
   }
 
+  std::vector<int> v;
+
   if (raise_exception) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
     RE2::Set::ErrorInfo e;
@@ -1704,7 +1693,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, VALUE self) {
           rb_raise(re2_eSetMatchError, "Unknown RE2::Set::ErrorKind: %d", e.kind);
       }
     } else {
-      for (size_t i = 0; i < v.size(); i++) {
+      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
         rb_ary_push(result, INT2FIX(v[i]));
       }
     }
@@ -1718,7 +1707,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, VALUE self) {
     VALUE result = rb_ary_new2(v.size());
 
     if (matched) {
-      for (size_t i = 0; i < v.size(); i++) {
+      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
         rb_ary_push(result, INT2FIX(v[i]));
       }
     }
@@ -1868,7 +1857,7 @@ void Init_re2(void) {
   rb_define_singleton_method(re2_cRegexp, "compile",
       RUBY_METHOD_FUNC(rb_class_new_instance), -1);
 
-  rb_define_global_function("RE2", RUBY_METHOD_FUNC(re2_re2), -1);
+  rb_define_module_function(rb_mKernel, "RE2", RUBY_METHOD_FUNC(re2_re2), -1);
 
   /* Create the symbols used in options. */
   id_utf8 = rb_intern("utf8");