Integrate the Irregexp Regular Expression Engine.

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 5341 matching lines @@
       break;
     case RawFunction::kMethodExtractor:
       return "kMethodExtractor";
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       return "kNoSuchMethodDispatcher";
       break;
     case RawFunction::kInvokeFieldDispatcher:
       return "kInvokeFieldDispatcher";
       break;
+    case RawFunction::kIrregexpFunction:
+      return "kIrregexpFunction";
+      break;
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void Function::SetRedirectionType(const Type& type) const {
   ASSERT(IsFactory());
   Object& obj = Object::Handle(raw_ptr()->data_);
@@ skipping 65 matching lines @@
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void Function::set_owner(const Object& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
 
+RawJSRegExp* Function::regexp() const {
+  ASSERT(kind() == RawFunction::kIrregexpFunction);
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  return JSRegExp::Cast(obj).raw();
+}
+
+
+void Function::set_regexp(const JSRegExp& value) const {
+  ASSERT(kind() == RawFunction::kIrregexpFunction);
+  ASSERT(raw_ptr()->data_ == Object::null());
+  set_data(value);
+}
+
+
+void Function::set_regexp_cid(intptr_t regexp_cid) const {
+    ASSERT((regexp_cid == kIllegalCid) ||
+           (kind() == RawFunction::kIrregexpFunction));
+    ASSERT((regexp_cid == kIllegalCid) ||
+           RawObject::IsStringClassId(regexp_cid));
+    StoreNonPointer(&raw_ptr()->regexp_cid_, regexp_cid);
+}
+
+
 void Function::set_result_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->result_type_, value.raw());
 }
 
 
 RawAbstractType* Function::ParameterTypeAt(intptr_t index) const {
   const Array& parameter_types = Array::Handle(raw_ptr()->parameter_types_);
   return AbstractType::RawCast(parameter_types.At(index));
 }
@@ skipping 660 matching lines @@
   result.set_is_async_closure(false);
   result.set_always_inline(false);
   result.set_is_polymorphic_target(false);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
+  result.set_regexp_cid(kIllegalCid);
   result.set_optimized_instruction_count(0);
   result.set_optimized_call_site_count(0);
   result.set_is_optimizable(is_native ? false : true);
   result.set_is_inlinable(true);
   result.set_allows_hoisting_check_class(true);
   result.set_allows_bounds_check_generalization(true);
   StubCode* stub_code = Isolate::Current()->stub_code();
   result.SetInstructions(Code::Handle(stub_code->LazyCompile_entry()->code()));
   if (kind == RawFunction::kClosureFunction) {
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
 
   return result.raw();
 }
 
 
 RawFunction* Function::Clone(const Class& new_owner) const {
   ASSERT(!IsConstructor());
   Function& clone = Function::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& origin = Class::Handle(this->origin());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
   clone.ClearCode();
   clone.set_usage_counter(0);
   clone.set_deoptimization_counter(0);
+  clone.set_regexp_cid(kIllegalCid);
   clone.set_optimized_instruction_count(0);
   clone.set_optimized_call_site_count(0);
   clone.set_ic_data_array(Array::Handle());
   return clone.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
@@ skipping 532 matching lines @@
       break;
     case RawFunction::kMethodExtractor:
       kind_str = " method-extractor";
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       kind_str = " no-such-method-dispatcher";
       break;
     case RawFunction::kInvokeFieldDispatcher:
       kind_str = "invoke-field-dispatcher";
       break;
+    case RawFunction::kIrregexpFunction:
+      kind_str = "irregexp-function";
+      break;
     default:
       UNREACHABLE();
   }
   const char* kFormat = "Function '%s':%s%s%s%s.";
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
@@ skipping 3656 matching lines @@
     OS::Print("Function not found %s.%s\n", #class_name, #function_name);      \
   } else if (func.SourceFingerprint() != fp) {                                 \
     has_errors = true;                                                         \
     OS::Print("Wrong fingerprint for '%s': expecting %d found %d\n",           \
         func.ToFullyQualifiedCString(), fp, func.SourceFingerprint());         \
     collected_fp_diffs.Add(FpDiff(fp, func.SourceFingerprint()));              \
   }                                                                            \
 
   all_libs.Add(&Library::ZoneHandle(Library::CoreLibrary()));
   CORE_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
+  CORE_REGEXP_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
   CORE_INTEGER_LIB_INTRINSIC_LIST(CHECK_FINGERPRINTS);
 
   all_libs.Add(&Library::ZoneHandle(Library::MathLibrary()));
   all_libs.Add(&Library::ZoneHandle(Library::TypedDataLibrary()));
   OTHER_RECOGNIZED_LIST(CHECK_FINGERPRINTS);
   INLINE_WHITE_LIST(CHECK_FINGERPRINTS);
   POLYMORPHIC_TARGET_LIST(CHECK_FINGERPRINTS);
 
   all_libs.Clear();
   all_libs.Add(&Library::ZoneHandle(Library::MathLibrary()));
@@ skipping 9574 matching lines @@
   chars[total_len] = '\0';
   return chars;
 }
 
 
 void JSRegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
+void JSRegExp::set_function(intptr_t cid, const Function& value) const {
+  StorePointer(FunctionAddr(cid), value.raw());
+}
+
+
 void JSRegExp::set_num_bracket_expressions(intptr_t value) const {
   StoreSmi(&raw_ptr()->num_bracket_expressions_, Smi::New(value));
 }
 
 
 RawJSRegExp* JSRegExp::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in JSRegexp::New: invalid len %" Pd "\n", len);
   }
@@ skipping 316 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart