regexp-utils.cc 7.27 KB
Newer Older
1 2 3 4 5 6
// 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-utils.h"

7
#include "src/execution/isolate.h"
8
#include "src/execution/protectors-inl.h"
9
#include "src/heap/factory.h"
10
#include "src/objects/js-regexp-inl.h"
11
#include "src/objects/objects-inl.h"
12
#include "src/regexp/regexp.h"
13 14 15 16

namespace v8 {
namespace internal {

17 18 19
Handle<String> RegExpUtils::GenericCaptureGetter(
    Isolate* isolate, Handle<RegExpMatchInfo> match_info, int capture,
    bool* ok) {
20
  const int index = capture * 2;
21
  if (index >= match_info->NumberOfCaptureRegisters()) {
22 23 24 25
    if (ok != nullptr) *ok = false;
    return isolate->factory()->empty_string();
  }

26 27
  const int match_start = match_info->Capture(index);
  const int match_end = match_info->Capture(index + 1);
28 29 30 31 32 33
  if (match_start == -1 || match_end == -1) {
    if (ok != nullptr) *ok = false;
    return isolate->factory()->empty_string();
  }

  if (ok != nullptr) *ok = true;
34
  Handle<String> last_subject(match_info->LastSubject(), isolate);
35 36 37 38 39
  return isolate->factory()->NewSubString(last_subject, match_start, match_end);
}

namespace {

40
V8_INLINE bool HasInitialRegExpMap(Isolate* isolate, JSReceiver recv) {
41
  return recv.map() == isolate->regexp_function()->initial_map();
42 43 44 45 46 47
}

}  // namespace

MaybeHandle<Object> RegExpUtils::SetLastIndex(Isolate* isolate,
                                              Handle<JSReceiver> recv,
48 49 50
                                              uint64_t value) {
  Handle<Object> value_as_object =
      isolate->factory()->NewNumberFromInt64(value);
51
  if (HasInitialRegExpMap(isolate, *recv)) {
52 53
    JSRegExp::cast(*recv).set_last_index(*value_as_object,
                                         UPDATE_WRITE_BARRIER);
54 55
    return recv;
  } else {
56 57
    return Object::SetProperty(
        isolate, recv, isolate->factory()->lastIndex_string(), value_as_object,
58
        StoreOrigin::kMaybeKeyed, Just(kThrowOnError));
59 60 61 62 63
  }
}

MaybeHandle<Object> RegExpUtils::GetLastIndex(Isolate* isolate,
                                              Handle<JSReceiver> recv) {
64
  if (HasInitialRegExpMap(isolate, *recv)) {
65
    return handle(JSRegExp::cast(*recv).last_index(), isolate);
66
  } else {
67 68
    return Object::GetProperty(isolate, recv,
                               isolate->factory()->lastIndex_string());
69 70 71 72 73 74 75 76 77 78 79 80 81
  }
}

// ES#sec-regexpexec Runtime Semantics: RegExpExec ( R, S )
// Also takes an optional exec method in case our caller
// has already fetched exec.
MaybeHandle<Object> RegExpUtils::RegExpExec(Isolate* isolate,
                                            Handle<JSReceiver> regexp,
                                            Handle<String> string,
                                            Handle<Object> exec) {
  if (exec->IsUndefined(isolate)) {
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate, exec,
82 83
        Object::GetProperty(isolate, regexp, isolate->factory()->exec_string()),
        Object);
84 85 86 87
  }

  if (exec->IsCallable()) {
    const int argc = 1;
88
    base::ScopedVector<Handle<Object>> argv(argc);
89 90 91 92 93
    argv[0] = string;

    Handle<Object> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate, result,
94
        Execution::Call(isolate, exec, regexp, argc, argv.begin()), Object);
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116

    if (!result->IsJSReceiver() && !result->IsNull(isolate)) {
      THROW_NEW_ERROR(isolate,
                      NewTypeError(MessageTemplate::kInvalidRegExpExecResult),
                      Object);
    }
    return result;
  }

  if (!regexp->IsJSRegExp()) {
    THROW_NEW_ERROR(isolate,
                    NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
                                 isolate->factory()->NewStringFromAsciiChecked(
                                     "RegExp.prototype.exec"),
                                 regexp),
                    Object);
  }

  {
    Handle<JSFunction> regexp_exec = isolate->regexp_exec_function();

    const int argc = 1;
117
    base::ScopedVector<Handle<Object>> argv(argc);
118 119
    argv[0] = string;

120
    return Execution::Call(isolate, regexp_exec, regexp, argc, argv.begin());
121 122 123
  }
}

124
bool RegExpUtils::IsUnmodifiedRegExp(Isolate* isolate, Handle<Object> obj) {
125
#ifdef V8_ENABLE_FORCE_SLOW_PATH
126 127 128
  if (isolate->force_slow_path()) return false;
#endif

129
  if (!obj->IsJSReceiver()) return false;
130

131
  JSReceiver recv = JSReceiver::cast(*obj);
132

133
  if (!HasInitialRegExpMap(isolate, recv)) return false;
134 135

  // Check the receiver's prototype's map.
136 137
  Object proto = recv.map().prototype();
  if (!proto.IsJSReceiver()) return false;
138 139

  Handle<Map> initial_proto_initial_map = isolate->regexp_prototype_map();
140
  Map proto_map = JSReceiver::cast(proto).map();
141
  if (proto_map != *initial_proto_initial_map) {
142 143 144
    return false;
  }

145
  // Check that the "exec" method is unmodified.
146 147
  // Check that the index refers to "exec" method (this has to be consistent
  // with the init order in the bootstrapper).
148
  InternalIndex kExecIndex(JSRegExp::kExecFunctionDescriptorIndex);
149
  DCHECK_EQ(*(isolate->factory()->exec_string()),
150 151
            proto_map.instance_descriptors(isolate).GetKey(kExecIndex));
  if (proto_map.instance_descriptors(isolate)
152 153
          .GetDetails(kExecIndex)
          .constness() != PropertyConstness::kConst) {
154
    return false;
155 156
  }

157 158 159 160 161 162
  // Note: Unlike the more involved check in CSA (see BranchIfFastRegExp), this
  // does not go on to check the actual value of the exec property. This would
  // not be valid since this method is called from places that access the flags
  // property. Similar spots in CSA would use BranchIfFastRegExp_Strict in this
  // case.

163
  if (!Protectors::IsRegExpSpeciesLookupChainIntact(isolate)) return false;
164

165 166
  // The smi check is required to omit ToLength(lastIndex) calls with possible
  // user-code execution on the fast path.
167 168
  Object last_index = JSRegExp::cast(recv).last_index();
  return last_index.IsSmi() && Smi::ToInt(last_index) >= 0;
169 170
}

171
uint64_t RegExpUtils::AdvanceStringIndex(Handle<String> string, uint64_t index,
172 173 174 175 176 177 178 179
                                         bool unicode) {
  DCHECK_LE(static_cast<double>(index), kMaxSafeInteger);
  const uint64_t string_length = static_cast<uint64_t>(string->length());
  if (unicode && index < string_length) {
    const uint16_t first = string->Get(static_cast<uint32_t>(index));
    if (first >= 0xD800 && first <= 0xDBFF && index + 1 < string_length) {
      DCHECK_LT(index, std::numeric_limits<uint64_t>::max());
      const uint16_t second = string->Get(static_cast<uint32_t>(index + 1));
180
      if (second >= 0xDC00 && second <= 0xDFFF) {
181
        return index + 2;
182 183 184 185
      }
    }
  }

186
  return index + 1;
187 188 189 190 191 192 193 194
}

MaybeHandle<Object> RegExpUtils::SetAdvancedStringIndex(
    Isolate* isolate, Handle<JSReceiver> regexp, Handle<String> string,
    bool unicode) {
  Handle<Object> last_index_obj;
  ASSIGN_RETURN_ON_EXCEPTION(
      isolate, last_index_obj,
195 196
      Object::GetProperty(isolate, regexp,
                          isolate->factory()->lastIndex_string()),
197 198 199 200
      Object);

  ASSIGN_RETURN_ON_EXCEPTION(isolate, last_index_obj,
                             Object::ToLength(isolate, last_index_obj), Object);
201 202
  const uint64_t last_index = PositiveNumberToUint64(*last_index_obj);
  const uint64_t new_last_index =
203
      AdvanceStringIndex(string, last_index, unicode);
204 205 206 207 208 209

  return SetLastIndex(isolate, regexp, new_last_index);
}

}  // namespace internal
}  // namespace v8