[regexp] Create property on result for each named capture

src/regexp/regexp-parser.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/regexp/regexp-parser.h"
 
 #include "src/char-predicates-inl.h"
 #include "src/factory.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 750 matching lines @@
   return name;
 }
 
 bool RegExpParser::CreateNamedCaptureAtIndex(const ZoneVector<uc16>* name,
                                              int index) {
   DCHECK(FLAG_harmony_regexp_named_captures);
   DCHECK(unicode());
   DCHECK(0 < index && index <= captures_started_);
   DCHECK_NOT_NULL(name);
 
+  static std::vector<uc16> illegal_names[] = {
+      {
+          'i', 'n', 'd', 'e', 'x',

[Yang, 2017/01/18 13:25:36]

Is it possible to use wide string literals here?
http://en.cppreference.com/w/cpp/language/string_literal

[jgruber, 2017/01/19 15:59:12]

I didn't find a way to do that for this use case. The solution above works
because we use the C++11 initializer list constructor. That doesn't fly anymore
when using wide string literals since that produces 'const char16[6]' and 'const
char16[7]' types.

Anyway, it looks like the blacklist will only consist of __proto__ and we can
definitely use wide string literals in that case.

+      },
+      {
+          'i', 'n', 'p', 'u', 't',
+      },
+      {
+          'l', 'e', 'n', 'g', 't', 'h',
+      },
+  };
+
+  for (const auto& illegal_name : illegal_names) {
+    if (name->size() != illegal_name.size()) continue;
+    if (std::equal(name->begin(), name->end(), illegal_name.begin())) {
+      ReportError(CStrVector("Illegal capture group name"));
+      return false;
+    }
+  }
+
   if (named_captures_ == nullptr) {
     named_captures_ = new (zone()) ZoneList<RegExpCapture*>(1, zone());
   } else {
     // Check for duplicates and bail if we find any.
     for (const auto& named_capture : *named_captures_) {
       if (*named_capture->name() == *name) {
         ReportError(CStrVector("Duplicate capture group name"));
         return false;
       }
     }
@@ skipping 1010 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8