#include "src/interface.h"
+#include "src/base/lazy-instance.h"
+
namespace v8 {
namespace internal {
+// ---------------------------------------------------------------------------
+// Initialization.
+
+struct Interface::Cache {
+ template<int flags>
+ struct Create {
+ static void Construct(Interface* ptr) { ::new (ptr) Interface(flags); }
+ };
+ typedef Create<VALUE + FROZEN> ValueCreate;
+ typedef Create<VALUE + CONST + FROZEN> ConstCreate;
+
+ static base::LazyInstance<Interface, ValueCreate>::type value_interface;
+ static base::LazyInstance<Interface, ConstCreate>::type const_interface;
+};
+
+
+base::LazyInstance<Interface, Interface::Cache::ValueCreate>::type
+ Interface::Cache::value_interface = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<Interface, Interface::Cache::ConstCreate>::type
+ Interface::Cache::const_interface = LAZY_INSTANCE_INITIALIZER;
+
+
+Interface* Interface::NewValue() {
+ return Cache::value_interface.Pointer(); // Cached.
+}
+
+
+Interface* Interface::NewConst() {
+ return Cache::const_interface.Pointer(); // Cached.
+}
+
+
+// ---------------------------------------------------------------------------
+// Lookup.
+
Interface* Interface::Lookup(Handle<String> name, Zone* zone) {
DCHECK(IsModule());
ZoneHashMap* map = Chase()->exports_;
- if (map == NULL) return NULL;
+ if (map == nullptr) return nullptr;
ZoneAllocationPolicy allocator(zone);
- ZoneHashMap::Entry* p = map->Lookup(name.location(), name->Hash(), false,
- allocator);
- if (p == NULL) return NULL;
+ ZoneHashMap::Entry* p =
+ map->Lookup(name.location(), name->Hash(), false, allocator);
+ if (p == nullptr) return nullptr;
DCHECK(*static_cast<String**>(p->key) == *name);
- DCHECK(p->value != NULL);
+ DCHECK(p->value != nullptr);
return static_cast<Interface*>(p->value);
}
+// ---------------------------------------------------------------------------
+// Addition.
+
#ifdef DEBUG
// Current nesting depth for debug output.
class Nesting {
PrintF("%*s# Adding...\n", Nesting::current(), "");
PrintF("%*sthis = ", Nesting::current(), "");
this->Print(Nesting::current());
- const AstRawString* symbol = static_cast<const AstRawString*>(name);
- PrintF("%*s%.*s : ", Nesting::current(), "", symbol->length(),
- symbol->raw_data());
+ const AstRawString* raw = static_cast<const AstRawString*>(name);
+ PrintF("%*s%.*s : ", Nesting::current(), "",
+ raw->length(), raw->raw_data());
interface->Print(Nesting::current());
}
#endif
ZoneHashMap** map = &Chase()->exports_;
ZoneAllocationPolicy allocator(zone);
- if (*map == NULL) {
+ if (*map == nullptr) {
*map = new(zone->New(sizeof(ZoneHashMap)))
ZoneHashMap(ZoneHashMap::PointersMatch,
ZoneHashMap::kDefaultHashMapCapacity, allocator);
ZoneHashMap::Entry* p =
(*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator);
- if (p == NULL) {
+ if (p == nullptr) {
// This didn't have name but was frozen already, that's an error.
*ok = false;
- } else if (p->value == NULL) {
+ } else if (p->value == nullptr) {
p->value = interface;
} else {
#ifdef DEBUG
}
+// ---------------------------------------------------------------------------
+// Unification.
+
void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
if (this->forward_) return this->Chase()->Unify(that, zone, ok);
if (that->forward_) return this->Unify(that->Chase(), zone, ok);
- DCHECK(this->forward_ == NULL);
- DCHECK(that->forward_ == NULL);
+ DCHECK(this->forward_ == nullptr);
+ DCHECK(that->forward_ == nullptr);
*ok = true;
if (this == that) return;
#endif
// Merge the smaller interface into the larger, for performance.
- if (this->exports_ != NULL && (that->exports_ == NULL ||
+ if (this->exports_ != nullptr && (that->exports_ == nullptr ||
this->exports_->occupancy() >= that->exports_->occupancy())) {
this->DoUnify(that, ok, zone);
} else {
void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
- DCHECK(this->forward_ == NULL);
- DCHECK(that->forward_ == NULL);
+ DCHECK(this->forward_ == nullptr);
+ DCHECK(that->forward_ == nullptr);
DCHECK(!this->IsValue());
DCHECK(!that->IsValue());
DCHECK(this->index_ == -1);
// Try to merge all members from that into this.
ZoneHashMap* map = that->exports_;
- if (map != NULL) {
- for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
+ if (map != nullptr) {
+ for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok);
if (!*ok) return;
}
// If the new interface is larger than that's, then there were members in
// 'this' which 'that' didn't have. If 'that' was frozen that is an error.
- int this_size = this->exports_ == NULL ? 0 : this->exports_->occupancy();
- int that_size = map == NULL ? 0 : map->occupancy();
+ int this_size = this->exports_ == nullptr ? 0 : this->exports_->occupancy();
+ int that_size = map == nullptr ? 0 : map->occupancy();
if (that->IsFrozen() && this_size > that_size) {
*ok = false;
return;
}
+// ---------------------------------------------------------------------------
+// Printing.
+
#ifdef DEBUG
void Interface::Print(int n) {
int n0 = n > 0 ? n : 0;
if (FLAG_print_interface_details) {
PrintF("%p", static_cast<void*>(this));
- for (Interface* link = this->forward_; link != NULL; link = link->forward_)
+ for (Interface* link = this->forward_; link != nullptr;
+ link = link->forward_) {
PrintF("->%p", static_cast<void*>(link));
+ }
PrintF(" ");
}
} else if (IsModule()) {
PrintF("module %d %s{", Index(), IsFrozen() ? "" : "(unresolved) ");
ZoneHashMap* map = Chase()->exports_;
- if (map == NULL || map->occupancy() == 0) {
+ if (map == nullptr || map->occupancy() == 0) {
PrintF("}\n");
} else if (n < 0 || n0 >= 2 * FLAG_print_interface_depth) {
// Avoid infinite recursion on cyclic types.
PrintF("...}\n");
} else {
PrintF("\n");
- for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
+ for (ZoneHashMap::Entry* p = map->Start();
+ p != nullptr; p = map->Next(p)) {
String* name = *static_cast<String**>(p->key);
Interface* interface = static_cast<Interface*>(p->value);
PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray());
projects / platform / framework / web / crosswalk.git / blobdiff