Line data    Source code

       1             : // Copyright 2017 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_OBJECTS_JS_REGEXP_INL_H_
       6             : #define V8_OBJECTS_JS_REGEXP_INL_H_
       7             : 
       8             : #include "src/objects/js-regexp.h"
       9             : 
      10             : #include "src/objects-inl.h"  // Needed for write barriers
      11             : #include "src/objects/smi.h"
      12             : #include "src/objects/string.h"
      13             : 
      14             : // Has to be the last include (doesn't have include guards):
      15             : #include "src/objects/object-macros.h"
      16             : 
      17             : namespace v8 {
      18             : namespace internal {
      19             : 
      20     9912200 : OBJECT_CONSTRUCTORS_IMPL(JSRegExp, JSObject)
      21             : 
      22     4956100 : CAST_ACCESSOR(JSRegExp)
      23             : 
      24    29608292 : ACCESSORS(JSRegExp, data, Object, kDataOffset)
      25     2285574 : ACCESSORS(JSRegExp, flags, Object, kFlagsOffset)
      26     2285592 : ACCESSORS(JSRegExp, source, Object, kSourceOffset)
      27       16380 : ACCESSORS(JSRegExp, last_index, Object, kLastIndexOffset)
      28             : 
      29     4776558 : JSRegExp::Type JSRegExp::TypeTag() const {
      30     4776558 :   Object data = this->data();
      31     4776558 :   if (data->IsUndefined()) return JSRegExp::NOT_COMPILED;
      32             :   Smi smi = Smi::cast(FixedArray::cast(data)->get(kTagIndex));
      33     4776558 :   return static_cast<JSRegExp::Type>(smi->value());
      34             : }
      35             : 
      36      188789 : int JSRegExp::CaptureCount() {
      37      188789 :   switch (TypeTag()) {
      38             :     case ATOM:
      39             :       return 0;
      40             :     case IRREGEXP:
      41        8324 :       return Smi::ToInt(DataAt(kIrregexpCaptureCountIndex));
      42             :     default:
      43           0 :       UNREACHABLE();
      44             :   }
      45             : }
      46             : 
      47      194007 : JSRegExp::Flags JSRegExp::GetFlags() {
      48             :   DCHECK(this->data()->IsFixedArray());
      49             :   Object data = this->data();
      50             :   Smi smi = Smi::cast(FixedArray::cast(data)->get(kFlagsIndex));
      51      194007 :   return Flags(smi->value());
      52             : }
      53             : 
      54       86034 : String JSRegExp::Pattern() {
      55             :   DCHECK(this->data()->IsFixedArray());
      56             :   Object data = this->data();
      57             :   String pattern = String::cast(FixedArray::cast(data)->get(kSourceIndex));
      58       86034 :   return pattern;
      59             : }
      60             : 
      61         108 : Object JSRegExp::CaptureNameMap() {
      62             :   DCHECK(this->data()->IsFixedArray());
      63             :   DCHECK_EQ(TypeTag(), IRREGEXP);
      64      177003 :   Object value = DataAt(kIrregexpCaptureNameMapIndex);
      65             :   DCHECK_NE(value, Smi::FromInt(JSRegExp::kUninitializedValue));
      66      177003 :   return value;
      67             : }
      68             : 
      69     4747262 : Object JSRegExp::DataAt(int index) const {
      70             :   DCHECK(TypeTag() != NOT_COMPILED);
      71     4747262 :   return FixedArray::cast(data())->get(index);
      72             : }
      73             : 
      74          10 : void JSRegExp::SetDataAt(int index, Object value) {
      75             :   DCHECK(TypeTag() != NOT_COMPILED);
      76             :   DCHECK_GE(index,
      77             :             kDataIndex);  // Only implementation data can be set this way.
      78          10 :   FixedArray::cast(data())->set(index, value);
      79          10 : }
      80             : 
      81          30 : bool JSRegExp::HasCompiledCode() const {
      82          30 :   if (TypeTag() != IRREGEXP) return false;
      83             : #ifdef DEBUG
      84             :   DCHECK(DataAt(kIrregexpLatin1CodeIndex)->IsCode() ||
      85             :          DataAt(kIrregexpLatin1CodeIndex)->IsByteArray() ||
      86             :          DataAt(kIrregexpLatin1CodeIndex) == Smi::FromInt(kUninitializedValue));
      87             :   DCHECK(DataAt(kIrregexpUC16CodeIndex)->IsCode() ||
      88             :          DataAt(kIrregexpUC16CodeIndex)->IsByteArray() ||
      89             :          DataAt(kIrregexpUC16CodeIndex) == Smi::FromInt(kUninitializedValue));
      90             : #endif  // DEBUG
      91             :   Smi uninitialized = Smi::FromInt(kUninitializedValue);
      92          50 :   return (DataAt(kIrregexpLatin1CodeIndex) != uninitialized ||
      93          20 :           DataAt(kIrregexpUC16CodeIndex) != uninitialized);
      94             : }
      95             : 
      96           5 : void JSRegExp::DiscardCompiledCodeForSerialization() {
      97             :   DCHECK(HasCompiledCode());
      98           5 :   SetDataAt(kIrregexpLatin1CodeIndex, Smi::FromInt(kUninitializedValue));
      99           5 :   SetDataAt(kIrregexpUC16CodeIndex, Smi::FromInt(kUninitializedValue));
     100           5 : }
     101             : 
     102             : }  // namespace internal
     103             : }  // namespace v8
     104             : 
     105             : #include "src/objects/object-macros-undef.h"
     106             : 
     107             : #endif  // V8_OBJECTS_JS_REGEXP_INL_H_