regexp-delay.js 15 KB
Newer Older
1
// Copyright 2006-2009 the V8 project authors. All rights reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Expect $Object = global.Object;
// Expect $Array = global.Array;

const $RegExp = global.RegExp;

// A recursive descent parser for Patterns according to the grammar of
// ECMA-262 15.10.1, with deviations noted below.
function DoConstructRegExp(object, pattern, flags, isConstructorCall) {
  // RegExp : Called as constructor; see ECMA-262, section 15.10.4.
  if (IS_REGEXP(pattern)) {
    if (!IS_UNDEFINED(flags)) {
      throw MakeTypeError('regexp_flags', []);
    }
    flags = (pattern.global ? 'g' : '')
        + (pattern.ignoreCase ? 'i' : '')
        + (pattern.multiline ? 'm' : '');
    pattern = pattern.source;
  }

  pattern = IS_UNDEFINED(pattern) ? '' : ToString(pattern);
  flags = IS_UNDEFINED(flags) ? '' : ToString(flags);

  var global = false;
  var ignoreCase = false;
  var multiline = false;

  for (var i = 0; i < flags.length; i++) {
55
    var c = StringCharAt.call(flags, i);
56 57
    switch (c) {
      case 'g':
58
        // Allow duplicate flags to be consistent with JSC and others.
59 60 61 62 63 64 65 66 67 68
        global = true;
        break;
      case 'i':
        ignoreCase = true;
        break;
      case 'm':
        multiline = true;
        break;
      default:
        // Ignore flags that have no meaning to be consistent with
69
        // JSC.
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
        break;
    }
  }

  if (isConstructorCall) {
    // ECMA-262, section 15.10.7.1.
    %SetProperty(object, 'source', pattern,
                 DONT_DELETE |  READ_ONLY | DONT_ENUM);

    // ECMA-262, section 15.10.7.2.
    %SetProperty(object, 'global', global, DONT_DELETE | READ_ONLY | DONT_ENUM);

    // ECMA-262, section 15.10.7.3.
    %SetProperty(object, 'ignoreCase', ignoreCase,
                 DONT_DELETE | READ_ONLY | DONT_ENUM);

    // ECMA-262, section 15.10.7.4.
    %SetProperty(object, 'multiline', multiline,
                 DONT_DELETE | READ_ONLY | DONT_ENUM);

    // ECMA-262, section 15.10.7.5.
    %SetProperty(object, 'lastIndex', 0, DONT_DELETE | DONT_ENUM);
  } else { // RegExp is being recompiled via RegExp.prototype.compile.
    %IgnoreAttributesAndSetProperty(object, 'source', pattern);
    %IgnoreAttributesAndSetProperty(object, 'global', global);
    %IgnoreAttributesAndSetProperty(object, 'ignoreCase', ignoreCase);
    %IgnoreAttributesAndSetProperty(object, 'multiline', multiline);
    %IgnoreAttributesAndSetProperty(object, 'lastIndex', 0);
  }

  // Call internal function to compile the pattern.
  %RegExpCompile(object, pattern, flags);
102
}
103 104 105


function RegExpConstructor(pattern, flags) {
106
  if (%_IsConstructCall()) {
107 108 109 110 111 112 113 114
    DoConstructRegExp(this, pattern, flags, true);
  } else {
    // RegExp : Called as function; see ECMA-262, section 15.10.3.1.
    if (IS_REGEXP(pattern) && IS_UNDEFINED(flags)) {
      return pattern;
    }
    return new $RegExp(pattern, flags);
  }
115
}
116 117 118 119


// Deprecated RegExp.prototype.compile method.  We behave like the constructor
// were called again.  In SpiderMonkey, this method returns the regexp object.
120
// In JSC, it returns undefined.  For compatibility with JSC, we match their
121 122
// behavior.
function CompileRegExp(pattern, flags) {
123
  // Both JSC and SpiderMonkey treat a missing pattern argument as the
124
  // empty subject string, and an actual undefined value passed as the
125
  // pattern as the string 'undefined'.  Note that JSC is inconsistent
126 127
  // here, treating undefined values differently in
  // RegExp.prototype.compile and in the constructor, where they are
128
  // the empty string.  For compatibility with JSC, we match their
129 130 131 132 133 134 135 136 137 138
  // behavior.
  if (IS_UNDEFINED(pattern) && %_ArgumentsLength() != 0) {
    DoConstructRegExp(this, 'undefined', flags, false);
  } else {
    DoConstructRegExp(this, pattern, flags, false);
  }
}


function DoRegExpExec(regexp, string, index) {
139
  return %_RegExpExec(regexp, string, index, lastMatchInfo);
140 141
}

142 143

function RegExpExec(string) {
144
  if (!IS_REGEXP(this)) {
145 146
    throw MakeTypeError('method_called_on_incompatible',
                        ['RegExp.prototype.exec', this]);
147
  }
148
  if (%_ArgumentsLength() == 0) {
149
    var regExpInput = LAST_INPUT(lastMatchInfo);
150 151 152
    if (IS_UNDEFINED(regExpInput)) {
      throw MakeError('no_input_to_regexp', [this]);
    }
153
    string = regExpInput;
154 155 156 157 158 159 160 161 162 163 164
  }
  var s = ToString(string);
  var length = s.length;
  var lastIndex = this.lastIndex;
  var i = this.global ? TO_INTEGER(lastIndex) : 0;

  if (i < 0 || i > s.length) {
    this.lastIndex = 0;
    return null;
  }

165
  %_Log('regexp', 'regexp-exec,%0r,%1S,%2i', [this, s, lastIndex]);
166
  // matchIndices is either null or the lastMatchInfo array.
167
  var matchIndices = %_RegExpExec(this, s, i, lastMatchInfo);
168 169 170 171 172 173

  if (matchIndices == null) {
    if (this.global) this.lastIndex = 0;
    return matchIndices; // no match
  }

174
  var numResults = NUMBER_OF_CAPTURES(lastMatchInfo) >> 1;
175 176
  var result = new $Array(numResults);
  for (var i = 0; i < numResults; i++) {
177 178
    var matchStart = lastMatchInfo[CAPTURE(i << 1)];
    var matchEnd = lastMatchInfo[CAPTURE((i << 1) + 1)];
179
    if (matchStart != -1 && matchEnd != -1) {
180
      result[i] = SubString(s, matchStart, matchEnd);
181 182 183 184 185 186 187 188
    } else {
      // Make sure the element is present. Avoid reading the undefined
      // property from the global object since this may change.
      result[i] = void 0;
    }
  }

  if (this.global)
189 190
    this.lastIndex = lastMatchInfo[CAPTURE1];
  result.index = lastMatchInfo[CAPTURE0];
191 192
  result.input = s;
  return result;
193
}
194 195


196
// Section 15.10.6.3 doesn't actually make sense, but the intention seems to be
197 198 199
// that test is defined in terms of String.prototype.exec. However, it probably
// means the original value of String.prototype.exec, which is what everybody
// else implements.
200
function RegExpTest(string) {
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
  if (!IS_REGEXP(this)) {
    throw MakeTypeError('method_called_on_incompatible',
                        ['RegExp.prototype.test', this]);
  }
  if (%_ArgumentsLength() == 0) {
    var regExpInput = LAST_INPUT(lastMatchInfo);
    if (IS_UNDEFINED(regExpInput)) {
      throw MakeError('no_input_to_regexp', [this]);
    }
    string = regExpInput;
  }
  var s = ToString(string);
  var length = s.length;
  var lastIndex = this.lastIndex;
  var i = this.global ? TO_INTEGER(lastIndex) : 0;

  if (i < 0 || i > s.length) {
    this.lastIndex = 0;
    return false;
  }

  %_Log('regexp', 'regexp-exec,%0r,%1S,%2i', [this, s, lastIndex]);
  // matchIndices is either null or the lastMatchInfo array.
224
  var matchIndices = %_RegExpExec(this, s, i, lastMatchInfo);
225 226 227 228 229 230 231 232

  if (matchIndices == null) {
    if (this.global) this.lastIndex = 0;
    return false;
  }

  if (this.global) this.lastIndex = lastMatchInfo[CAPTURE1];
  return true;
233
}
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248


function RegExpToString() {
  // If this.source is an empty string, output /(?:)/.
  // http://bugzilla.mozilla.org/show_bug.cgi?id=225550
  // ecma_2/RegExp/properties-001.js.
  var src = this.source ? this.source : '(?:)';
  var result = '/' + src + '/';
  if (this.global)
    result += 'g';
  if (this.ignoreCase)
    result += 'i';
  if (this.multiline)
    result += 'm';
  return result;
249
}
250 251 252 253 254 255 256


// Getters for the static properties lastMatch, lastParen, leftContext, and
// rightContext of the RegExp constructor.  The properties are computed based
// on the captures array of the last successful match and the subject string
// of the last successful match.
function RegExpGetLastMatch() {
257 258 259 260
  var regExpSubject = LAST_SUBJECT(lastMatchInfo);
  return SubString(regExpSubject,
                   lastMatchInfo[CAPTURE0],
                   lastMatchInfo[CAPTURE1]);
261 262
}

263 264

function RegExpGetLastParen() {
265 266
  var length = NUMBER_OF_CAPTURES(lastMatchInfo);
  if (length <= 2) return '';  // There were no captures.
267 268 269
  // We match the SpiderMonkey behavior: return the substring defined by the
  // last pair (after the first pair) of elements of the capture array even if
  // it is empty.
270 271 272 273 274 275 276
  var regExpSubject = LAST_SUBJECT(lastMatchInfo);
  var start = lastMatchInfo[CAPTURE(length - 2)];
  var end = lastMatchInfo[CAPTURE(length - 1)];
  if (start != -1 && end != -1) {
    return SubString(regExpSubject, start, end);
  }
  return "";
277 278
}

279 280

function RegExpGetLeftContext() {
281 282 283
  return SubString(LAST_SUBJECT(lastMatchInfo),
                   0,
                   lastMatchInfo[CAPTURE0]);
284 285
}

286 287

function RegExpGetRightContext() {
288 289 290 291
  var subject = LAST_SUBJECT(lastMatchInfo);
  return SubString(subject,
                   lastMatchInfo[CAPTURE1],
                   subject.length);
292
}
293 294 295 296


// The properties $1..$9 are the first nine capturing substrings of the last
// successful match, or ''.  The function RegExpMakeCaptureGetter will be
297
// called with indices from 1 to 9.
298 299 300
function RegExpMakeCaptureGetter(n) {
  return function() {
    var index = n * 2;
301 302 303
    if (index >= NUMBER_OF_CAPTURES(lastMatchInfo)) return '';
    var matchStart = lastMatchInfo[CAPTURE(index)];
    var matchEnd = lastMatchInfo[CAPTURE(index + 1)];
304
    if (matchStart == -1 || matchEnd == -1) return '';
305
    return SubString(LAST_SUBJECT(lastMatchInfo), matchStart, matchEnd);
306
  };
307
}
308 309


310 311 312 313 314 315 316 317 318 319
// Property of the builtins object for recording the result of the last
// regexp match.  The property lastMatchInfo includes the matchIndices
// array of the last successful regexp match (an array of start/end index
// pairs for the match and all the captured substrings), the invariant is
// that there are at least two capture indeces.  The array also contains
// the subject string for the last successful match.
var lastMatchInfo = [
    2,                 // REGEXP_NUMBER_OF_CAPTURES
    "",                // Last subject.
    void 0,            // Last input - settable with RegExpSetInput.
320 321
    0,                 // REGEXP_FIRST_CAPTURE + 0
    0,                 // REGEXP_FIRST_CAPTURE + 1
322
];
323 324 325 326 327 328

// -------------------------------------------------------------------

function SetupRegExp() {
  %FunctionSetInstanceClassName($RegExp, 'RegExp');
  %FunctionSetPrototype($RegExp, new $Object());
329
  %SetProperty($RegExp.prototype, 'constructor', $RegExp, DONT_ENUM);
330 331 332 333 334 335 336 337 338 339 340 341 342
  %SetCode($RegExp, RegExpConstructor);

  InstallFunctions($RegExp.prototype, DONT_ENUM, $Array(
    "exec", RegExpExec,
    "test", RegExpTest,
    "toString", RegExpToString,
    "compile", CompileRegExp
  ));

  // The length of compile is 1 in SpiderMonkey.
  %FunctionSetLength($RegExp.prototype.compile, 1);

  // The properties input, $input, and $_ are aliases for each other.  When this
343
  // value is set the value it is set to is coerced to a string. 
344
  // Getter and setter for the input.
345
  function RegExpGetInput() {
346
    var regExpInput = LAST_INPUT(lastMatchInfo);
347 348
    return IS_UNDEFINED(regExpInput) ? "" : regExpInput;
  }
349
  function RegExpSetInput(string) {
350
    LAST_INPUT(lastMatchInfo) = ToString(string);
351
  };
352 353

  %DefineAccessor($RegExp, 'input', GETTER, RegExpGetInput, DONT_DELETE);
354
  %DefineAccessor($RegExp, 'input', SETTER, RegExpSetInput, DONT_DELETE);
355
  %DefineAccessor($RegExp, '$_', GETTER, RegExpGetInput, DONT_ENUM | DONT_DELETE);
356
  %DefineAccessor($RegExp, '$_', SETTER, RegExpSetInput, DONT_ENUM | DONT_DELETE);
357
  %DefineAccessor($RegExp, '$input', GETTER, RegExpGetInput, DONT_ENUM | DONT_DELETE);
358
  %DefineAccessor($RegExp, '$input', SETTER, RegExpSetInput, DONT_ENUM | DONT_DELETE);
359 360 361 362 363 364 365

  // The properties multiline and $* are aliases for each other.  When this
  // value is set in SpiderMonkey, the value it is set to is coerced to a
  // boolean.  We mimic that behavior with a slight difference: in SpiderMonkey
  // the value of the expression 'RegExp.multiline = null' (for instance) is the
  // boolean false (ie, the value after coercion), while in V8 it is the value
  // null (ie, the value before coercion).
366 367 368 369 370 371 372

  // Getter and setter for multiline.
  var multiline = false;
  function RegExpGetMultiline() { return multiline; };
  function RegExpSetMultiline(flag) { multiline = flag ? true : false; };

  %DefineAccessor($RegExp, 'multiline', GETTER, RegExpGetMultiline, DONT_DELETE);
373
  %DefineAccessor($RegExp, 'multiline', SETTER, RegExpSetMultiline, DONT_DELETE);
374
  %DefineAccessor($RegExp, '$*', GETTER, RegExpGetMultiline, DONT_ENUM | DONT_DELETE);
375
  %DefineAccessor($RegExp, '$*', SETTER, RegExpSetMultiline, DONT_ENUM | DONT_DELETE);
376 377 378 379 380 381 382


  function NoOpSetter(ignored) {}


  // Static properties set by a successful match.
  %DefineAccessor($RegExp, 'lastMatch', GETTER, RegExpGetLastMatch, DONT_DELETE);
383
  %DefineAccessor($RegExp, 'lastMatch', SETTER, NoOpSetter, DONT_DELETE);
384
  %DefineAccessor($RegExp, '$&', GETTER, RegExpGetLastMatch, DONT_ENUM | DONT_DELETE);
385
  %DefineAccessor($RegExp, '$&', SETTER, NoOpSetter, DONT_ENUM | DONT_DELETE);
386
  %DefineAccessor($RegExp, 'lastParen', GETTER, RegExpGetLastParen, DONT_DELETE);
387
  %DefineAccessor($RegExp, 'lastParen', SETTER, NoOpSetter, DONT_DELETE);
388
  %DefineAccessor($RegExp, '$+', GETTER, RegExpGetLastParen, DONT_ENUM | DONT_DELETE);
389
  %DefineAccessor($RegExp, '$+', SETTER, NoOpSetter, DONT_ENUM | DONT_DELETE);
390
  %DefineAccessor($RegExp, 'leftContext', GETTER, RegExpGetLeftContext, DONT_DELETE);
391
  %DefineAccessor($RegExp, 'leftContext', SETTER, NoOpSetter, DONT_DELETE);
392
  %DefineAccessor($RegExp, '$`', GETTER, RegExpGetLeftContext, DONT_ENUM | DONT_DELETE);
393
  %DefineAccessor($RegExp, '$`', SETTER, NoOpSetter, DONT_ENUM | DONT_DELETE);
394
  %DefineAccessor($RegExp, 'rightContext', GETTER, RegExpGetRightContext, DONT_DELETE);
395
  %DefineAccessor($RegExp, 'rightContext', SETTER, NoOpSetter, DONT_DELETE);
396
  %DefineAccessor($RegExp, "$'", GETTER, RegExpGetRightContext, DONT_ENUM | DONT_DELETE);
397
  %DefineAccessor($RegExp, "$'", SETTER, NoOpSetter, DONT_ENUM | DONT_DELETE);
398

399 400
  for (var i = 1; i < 10; ++i) {
    %DefineAccessor($RegExp, '$' + i, GETTER, RegExpMakeCaptureGetter(i), DONT_DELETE);
401
    %DefineAccessor($RegExp, '$' + i, SETTER, NoOpSetter, DONT_DELETE);
402
  }
403 404 405 406
}


SetupRegExp();