+2014-03-12 Commit Queue <commit-queue@webkit.org>
+
+ Unreviewed, rolling out r165482.
+ https://bugs.webkit.org/show_bug.cgi?id=130157
+
+ Broke the windows build; "error C2466: cannot allocate an
+ array of constant size 0" (Requested by jernoble on #webkit).
+
+ Reverted changeset:
+
+ "Reduce memory use for static property maps"
+ https://bugs.webkit.org/show_bug.cgi?id=129986
+ http://trac.webkit.org/changeset/165482
+
2014-03-12 Simon Fraser <simon.fraser@apple.com>
Have the scrolling tree track the viewport size, not the viewport rect
CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 18: Error: error message
CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
PASS a["hick"] is 4
PASS a["hock"] is 5
PASS a["snood"] is 6
-PASS a["charset"] is
-PASS a["coords"] is
+PASS a["origin"] is file://
+PASS a["hash"] is
+PASS a["search"] is
+PASS a["text"] is nerget
+PASS a["hostname"] is
+PASS a["rel"] is
PASS a["hreflang"] is
-PASS a["name"] is
PASS a["ping"] is
-PASS a["rel"] is
PASS a["rev"] is
-PASS a["shape"] is
+PASS a["host"] is
+PASS a["charset"] is
PASS a["target"] is
PASS a["type"] is
-PASS a["hash"] is
-PASS a["host"] is
-PASS a["hostname"] is
+PASS a["coords"] is
+PASS a["name"] is
+PASS a["shape"] is
PASS a["port"] is
PASS a["protocol"] is file:
-PASS a["search"] is
-PASS a["origin"] is file://
-PASS a["text"] is nerget
+PASS a["outerHTML"] is <a id="foo" href="bar">nerget</a>
+PASS a["spellcheck"] is true
+PASS a["webkitdropzone"] is
PASS a["title"] is
PASS a["lang"] is
PASS a["translate"] is true
+PASS a["hidden"] is false
+PASS a["innerText"] is nerget
PASS a["dir"] is
+PASS a["innerHTML"] is nerget
+PASS a["contentEditable"] is inherit
PASS a["tabIndex"] is 0
PASS a["draggable"] is true
-PASS a["webkitdropzone"] is
-PASS a["hidden"] is false
-PASS a["accessKey"] is
-PASS a["innerHTML"] is nerget
-PASS a["innerText"] is nerget
-PASS a["outerHTML"] is <a id="foo" href="bar">nerget</a>
PASS a["outerText"] is nerget
+PASS a["accessKey"] is
PASS a["children"] is [object HTMLCollection]
-PASS a["contentEditable"] is inherit
PASS a["isContentEditable"] is false
-PASS a["spellcheck"] is true
-PASS a["tagName"] is A
-PASS a["attributes"] is [object NamedNodeMap]
PASS a["style"] is [object CSSStyleDeclaration]
PASS a["id"] is foo
-PASS a["offsetLeft"] is 8
-PASS a["offsetTop"] is 774
-PASS a["offsetWidth"] is 39
-PASS a["offsetHeight"] is 18
-PASS a["offsetParent"] is [object HTMLBodyElement]
-PASS a["clientLeft"] is 0
-PASS a["clientTop"] is 0
+PASS a["dataset"] is [object DOMStringMap]
PASS a["clientWidth"] is 0
-PASS a["clientHeight"] is 0
-PASS a["scrollLeft"] is 0
-PASS a["scrollTop"] is 0
PASS a["scrollWidth"] is 0
-PASS a["scrollHeight"] is 0
-PASS a["className"] is
+PASS a["attributes"] is [object NamedNodeMap]
+PASS a["webkitRegionOverset"] is undefined
+PASS a["ALLOW_KEYBOARD_INPUT"] is 1
+PASS a["offsetWidth"] is 39
PASS a["classList"] is
-PASS a["dataset"] is [object DOMStringMap]
-PASS a["firstElementChild"] is null
+PASS a["offsetLeft"] is 8
+PASS a["className"] is
+PASS a["clientTop"] is 0
PASS a["lastElementChild"] is null
-PASS a["previousElementSibling"] is [object HTMLDivElement]
+PASS a["offsetParent"] is [object HTMLBodyElement]
PASS a["nextElementSibling"] is [object HTMLScriptElement]
+PASS a["tagName"] is A
+PASS a["previousElementSibling"] is [object HTMLDivElement]
PASS a["childElementCount"] is 0
+PASS a["scrollLeft"] is 0
+PASS a["firstElementChild"] is null
PASS a["uiactions"] is
-PASS a["webkitRegionOverset"] is undefined
-PASS a["ALLOW_KEYBOARD_INPUT"] is 1
-PASS a["nodeName"] is A
+PASS a["clientLeft"] is 0
+PASS a["offsetHeight"] is 18
+PASS a["clientHeight"] is 0
+PASS a["offsetTop"] is 1074
+PASS a["scrollTop"] is 0
+PASS a["scrollHeight"] is 0
+PASS a["previousSibling"] is [object Text]
+PASS a["NOTATION_NODE"] is 12
+PASS a["CDATA_SECTION_NODE"] is 4
+PASS a["lastChild"] is [object Text]
+PASS a["ELEMENT_NODE"] is 1
PASS a["nodeValue"] is null
+PASS a["DOCUMENT_POSITION_DISCONNECTED"] is 1
+PASS a["ENTITY_NODE"] is 6
+PASS a["TEXT_NODE"] is 3
+PASS a["ENTITY_REFERENCE_NODE"] is 5
+PASS a["textContent"] is nerget
PASS a["nodeType"] is 1
+PASS a["DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC"] is 32
+PASS a["ownerDocument"] is [object HTMLDocument]
+PASS a["PROCESSING_INSTRUCTION_NODE"] is 7
+PASS a["localName"] is a
PASS a["parentNode"] is [object HTMLBodyElement]
-PASS a["childNodes"] is [object NodeList]
PASS a["firstChild"] is [object Text]
-PASS a["lastChild"] is [object Text]
-PASS a["previousSibling"] is [object Text]
+PASS a["DOCUMENT_POSITION_PRECEDING"] is 2
+PASS a["DOCUMENT_TYPE_NODE"] is 10
+PASS a["COMMENT_NODE"] is 8
+PASS a["nodeName"] is A
+PASS a["DOCUMENT_POSITION_FOLLOWING"] is 4
+PASS a["prefix"] is null
+PASS a["childNodes"] is [object NodeList]
PASS a["nextSibling"] is [object Text]
-PASS a["ownerDocument"] is [object HTMLDocument]
+PASS a["ATTRIBUTE_NODE"] is 2
+PASS a["DOCUMENT_POSITION_CONTAINED_BY"] is 16
PASS a["namespaceURI"] is http://www.w3.org/1999/xhtml
-PASS a["prefix"] is null
-PASS a["localName"] is a
-PASS a["textContent"] is nerget
PASS a["parentElement"] is [object HTMLBodyElement]
-PASS a["ELEMENT_NODE"] is 1
-PASS a["ATTRIBUTE_NODE"] is 2
-PASS a["TEXT_NODE"] is 3
-PASS a["CDATA_SECTION_NODE"] is 4
-PASS a["ENTITY_REFERENCE_NODE"] is 5
-PASS a["ENTITY_NODE"] is 6
-PASS a["PROCESSING_INSTRUCTION_NODE"] is 7
-PASS a["COMMENT_NODE"] is 8
PASS a["DOCUMENT_NODE"] is 9
-PASS a["DOCUMENT_TYPE_NODE"] is 10
PASS a["DOCUMENT_FRAGMENT_NODE"] is 11
-PASS a["NOTATION_NODE"] is 12
-PASS a["DOCUMENT_POSITION_DISCONNECTED"] is 1
-PASS a["DOCUMENT_POSITION_PRECEDING"] is 2
-PASS a["DOCUMENT_POSITION_FOLLOWING"] is 4
PASS a["DOCUMENT_POSITION_CONTAINS"] is 8
-PASS a["DOCUMENT_POSITION_CONTAINED_BY"] is 16
-PASS a["DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC"] is 32
PASS successfullyParsed is true
TEST COMPLETE
+2014-03-12 Commit Queue <commit-queue@webkit.org>
+
+ Unreviewed, rolling out r165482.
+ https://bugs.webkit.org/show_bug.cgi?id=130157
+
+ Broke the windows build; "error C2466: cannot allocate an
+ array of constant size 0" (Requested by jernoble on #webkit).
+
+ Reverted changeset:
+
+ "Reduce memory use for static property maps"
+ https://bugs.webkit.org/show_bug.cgi?id=129986
+ http://trac.webkit.org/changeset/165482
+
2014-03-12 Mark Hahnenberg <mhahnenberg@apple.com>
Remove HandleSet::m_nextToFinalize
my @attrs = ();
my @values = ();
my @hashes = ();
-my @table = ();
-my @links = ();
my $hasSetter = "false";
@attrs = ();
@values = ();
@hashes = ();
- @table = ();
- @links = ();
$inside = 0;
} elsif (/^(\S+)\s*(\S+)\s*([\w\|]*)\s*(\w*)\s*$/ && $inside) {
sub calcCompactHashSize()
{
+ my @table = ();
+ my @links = ();
my $compactHashSize = ceilingToPowerOf2(2 * @keys);
$compactHashSizeMask = $compactHashSize - 1;
$compactSize = $compactHashSize;
my $nameEntries = "${name}Values";
$nameEntries =~ s/:/_/g;
- my $nameIndex = "${name}Index";
- $nameIndex =~ s/:/_/g;
print "\n#include \"JSCBuiltins.h\"\n";
print "\n#include \"Lookup.h\"\n" if ($includelookup);
} else {
print "\nnamespace JSC {\n";
}
-
- print "\nstatic const struct CompactHashIndex ${nameIndex}\[$compactSize\] = {\n";
- for (my $i = 0; $i < $compactSize; $i++) {
- my $T = -1;
- if (defined($table[$i])) { $T = $table[$i]; }
- my $L = -1;
- if (defined($links[$i])) { $L = $links[$i]; }
- print " { $T, $L },\n";
- }
- print "};\n\n";
-
- my $packedSize = scalar @keys;
- print "\nstatic const struct HashTableValue ${nameEntries}\[$packedSize\] = {\n";
+ my $count = scalar @keys + 1;
+ print "\nstatic const struct HashTableValue ${nameEntries}\[$count\] = {\n";
my $i = 0;
foreach my $key (@keys) {
my $firstValue = "";
}
$i++;
}
+ print " { 0, 0, NoIntrinsic, 0, 0 }\n";
print "};\n\n";
print "extern const struct HashTable $name =\n";
- print " \{ $packedSize, $compactHashSizeMask, $hasSetter, $nameEntries, 0, $nameIndex \};\n";
+ print " \{ $compactSize, $compactHashSizeMask, $hasSetter, $nameEntries, 0 \};\n";
print "} // namespace\n";
}
if (UNLIKELY((remaining < maxTokenLength) && !(lexerFlags & LexerFlagsIgnoreReservedWords)) && !isPrivateName) {
ASSERT(shouldCreateIdentifier);
if (remaining < maxTokenLength) {
- const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
+ const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
ASSERT((remaining < maxTokenLength) || !entry);
if (!entry)
return IDENT;
if (UNLIKELY((remaining < maxTokenLength) && !(lexerFlags & LexerFlagsIgnoreReservedWords)) && !isPrivateName) {
ASSERT(shouldCreateIdentifier);
if (remaining < maxTokenLength) {
- const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
+ const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
ASSERT((remaining < maxTokenLength) || !entry);
if (!entry)
return IDENT;
ASSERT(shouldCreateIdentifier);
// Keywords must not be recognized if there was an \uXXXX in the identifier.
if (remaining < maxTokenLength) {
- const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
+ const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
ASSERT((remaining < maxTokenLength) || !entry);
if (!entry)
return IDENT;
return m_keywordTable.entry(m_vm, ident);
}
- const HashTableValue* getKeyword(const Identifier& ident) const
+ const HashEntry* getKeyword(const Identifier& ident) const
{
return m_keywordTable.entry(m_vm, ident);
}
namespace JSC {
+class HashEntry;
class JSArrayBufferView;
struct HashTable;
static inline void getClassPropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames, EnumerationMode mode, bool didReify)
{
- VM& vm = exec->vm();
-
// Add properties from the static hashtables of properties
for (; classInfo; classInfo = classInfo->parentClass) {
- const HashTable* table = classInfo->propHashTable(vm);
+ const HashTable* table = classInfo->propHashTable(exec);
if (!table)
continue;
-
- for (auto iter = table->begin(vm); iter != table->end(vm); ++iter) {
- if ((!(iter->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)) && !((iter->attributes() & BuiltinOrFunction) && didReify))
- propertyNames.add(iter.key());
+ table->initializeIfNeeded(exec);
+ ASSERT(table->table);
+
+ int hashSizeMask = table->compactSize - 1;
+ const HashEntry* entry = table->table;
+ for (int i = 0; i <= hashSizeMask; ++i, ++entry) {
+ if (entry->key() && (!(entry->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)) && !((entry->attributes() & BuiltinOrFunction) && didReify))
+ propertyNames.add(entry->key());
}
}
}
}
const ClassInfo* info = obj->classInfo();
if (info->hasStaticSetterOrReadonlyProperties(vm)) {
- if (const HashTableValue* entry = obj->findPropertyHashEntry(vm, propertyName)) {
+ if (const HashEntry* entry = obj->findPropertyHashEntry(vm, propertyName)) {
putEntry(exec, entry, obj, propertyName, value, slot);
return;
}
}
// Look in the static hashtable of properties
- const HashTableValue* entry = thisObject->findPropertyHashEntry(vm, propertyName);
+ const HashEntry* entry = thisObject->findPropertyHashEntry(vm, propertyName);
if (entry) {
if (entry->attributes() & DontDelete && !vm.isInDefineOwnProperty())
return false; // this builtin property can't be deleted
return exec->vm().throwException(exec, createTypeError(exec, ASCIILiteral("No default value")));
}
-const HashTableValue* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
+const HashEntry* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
{
for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
if (const HashTable* propHashTable = info->propHashTable(vm)) {
- if (const HashTableValue* entry = propHashTable->entry(vm, propertyName))
+ if (const HashEntry* entry = propHashTable->entry(vm, propertyName))
return entry;
}
}
setStructure(vm, Structure::toUncacheableDictionaryTransition(vm, structure(vm)));
for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
- const HashTable* hashTable = info->propHashTable(vm);
+ const HashTable* hashTable = info->propHashTable(globalObject()->globalExec());
if (!hashTable)
continue;
PropertySlot slot(this);
- for (auto iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
+ for (HashTable::ConstIterator iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
if (iter->attributes() & BuiltinOrFunction)
- setUpStaticFunctionSlot(globalObject()->globalExec(), iter.value(), this, Identifier(&vm, iter.key()), slot);
+ setUpStaticFunctionSlot(globalObject()->globalExec(), *iter, this, Identifier(&vm, iter->key()), slot);
}
}
}
class GetterSetter;
+class HashEntry;
class InternalFunction;
class JSFunction;
class LLIntOffsetsExtractor;
class PropertyNameArray;
class Structure;
struct HashTable;
-struct HashTableValue;
JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const String&);
extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError;
friend class JSCell;
friend class JSFinalObject;
friend class MarkedBlock;
- JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject*, PropertyName, PropertySlot&);
+ JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject*, PropertyName, PropertySlot&);
enum PutMode {
PutModePut,
bool inlineGetOwnPropertySlot(ExecState*, VM&, Structure&, PropertyName, PropertySlot&);
JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, JSValue, unsigned, PropertyOffset);
- const HashTableValue* findPropertyHashEntry(VM&, PropertyName) const;
+ const HashEntry* findPropertyHashEntry(VM&, PropertyName) const;
void putIndexedDescriptor(ExecState*, SparseArrayEntry*, const PropertyDescriptor&, PropertyDescriptor& old);
void HashTable::createTable(VM& vm) const
{
- ASSERT(!keys);
- keys = new StringImpl*[numberOfValues];
+ ASSERT(!table);
+ int linkIndex = compactHashSizeMask + 1;
+ HashEntry* entries = new HashEntry[compactSize];
+ for (int i = 0; i < compactSize; ++i)
+ entries[i].setKey(0);
+ for (int i = 0; values[i].key; ++i) {
+ StringImpl& identifier = Identifier::add(&vm, values[i].key).leakRef();
+ int hashIndex = identifier.existingHash() & compactHashSizeMask;
+ HashEntry* entry = &entries[hashIndex];
- for (int i = 0; i < numberOfValues; ++i) {
- if (values[i].m_key)
- keys[i] = &Identifier::add(&vm, values[i].m_key).leakRef();
- else
- keys[i] = 0;
+ if (entry->key()) {
+ while (entry->next()) {
+ entry = entry->next();
+ }
+ ASSERT(linkIndex < compactSize);
+ entry->setNext(&entries[linkIndex++]);
+ entry = entry->next();
+ }
+
+ entry->initialize(&identifier, values[i].attributes, values[i].value1, values[i].value2, values[i].intrinsic);
}
+ table = entries;
}
void HashTable::deleteTable() const
{
- if (keys) {
- for (int i = 0; i != numberOfValues; ++i) {
- if (keys[i])
- keys[i]->deref();
+ if (table) {
+ int max = compactSize;
+ for (int i = 0; i != max; ++i) {
+ if (StringImpl* key = table[i].key())
+ key->deref();
}
- delete [] keys;
- keys = nullptr;
+ delete [] table;
+ table = 0;
}
}
-bool setUpStaticFunctionSlot(ExecState* exec, const HashTableValue* entry, JSObject* thisObj, PropertyName propertyName, PropertySlot& slot)
+bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, PropertyName propertyName, PropertySlot& slot)
{
ASSERT(thisObj->globalObject());
ASSERT(entry->attributes() & BuiltinOrFunction);
#include <wtf/Assertions.h>
namespace JSC {
- struct CompactHashIndex {
- const int16_t value;
- const int16_t next;
+ // Hash table generated by the create_hash_table script.
+ struct HashTableValue {
+ const char* key; // property name
+ unsigned char attributes; // JSObject attributes
+ Intrinsic intrinsic;
+ intptr_t value1;
+ intptr_t value2;
};
// FIXME: There is no reason this get function can't be simpler.
typedef PutPropertySlot::PutValueFunc PutFunction;
typedef FunctionExecutable* (*BuiltinGenerator)(VM&);
- // Hash table generated by the create_hash_table script.
- struct HashTableValue {
- const char* m_key; // property name
- unsigned char m_attributes; // JSObject attributes
- Intrinsic m_intrinsic;
- intptr_t m_value1;
- intptr_t m_value2;
+ class HashEntry {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
+ void initialize(StringImpl* key, unsigned char attributes, intptr_t v1, intptr_t v2, Intrinsic intrinsic)
+ {
+ m_key = key;
+ m_attributes = attributes;
+ m_u.store.value1 = v1;
+ m_u.store.value2 = v2;
+ m_intrinsic = intrinsic;
+ m_next = 0;
+ }
+
+ void setKey(StringImpl* key) { m_key = key; }
+ StringImpl* key() const { return m_key; }
unsigned char attributes() const { return m_attributes; }
return m_intrinsic;
}
- BuiltinGenerator builtinGenerator() const { ASSERT(m_attributes & Builtin); return reinterpret_cast<BuiltinGenerator>(m_value1); }
- NativeFunction function() const { ASSERT(m_attributes & Function); return reinterpret_cast<NativeFunction>(m_value1); }
- unsigned char functionLength() const { ASSERT(m_attributes & Function); return static_cast<unsigned char>(m_value2); }
+ BuiltinGenerator builtinGenerator() const { ASSERT(m_attributes & Builtin); return m_u.builtinGenerator.generatorValue; }
+ NativeFunction function() const { ASSERT(m_attributes & Function); return m_u.function.functionValue; }
+ unsigned char functionLength() const { ASSERT(m_attributes & Function); return static_cast<unsigned char>(m_u.function.length); }
+
+ GetFunction propertyGetter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return m_u.property.get; }
+ PutFunction propertyPutter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return m_u.property.put; }
- GetFunction propertyGetter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return reinterpret_cast<GetFunction>(m_value1); }
- PutFunction propertyPutter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return reinterpret_cast<PutFunction>(m_value2); }
+ intptr_t lexerValue() const { ASSERT(!m_attributes); return m_u.lexer.value; }
- intptr_t lexerValue() const { ASSERT(!m_attributes); return m_value1; }
+ void setNext(HashEntry *next) { m_next = next; }
+ HashEntry* next() const { return m_next; }
+
+ private:
+ StringImpl* m_key;
+ unsigned char m_attributes; // JSObject attributes
+ Intrinsic m_intrinsic;
+
+ union {
+ struct {
+ intptr_t value1;
+ intptr_t value2;
+ } store;
+ struct {
+ NativeFunction functionValue;
+ intptr_t length; // number of arguments for function
+ } function;
+ struct {
+ BuiltinGenerator generatorValue;
+ intptr_t unused;
+ } builtinGenerator;
+ struct {
+ GetFunction get;
+ PutFunction put;
+ } property;
+ struct {
+ intptr_t value;
+ intptr_t unused;
+ } lexer;
+ } m_u;
+
+ HashEntry* m_next;
};
struct HashTable {
- mutable int numberOfValues;
- int indexMask;
+ int compactSize;
+ int compactHashSizeMask;
bool hasSetterOrReadonlyProperties;
const HashTableValue* values; // Fixed values generated by script.
- mutable StringImpl** keys; // Table allocated at runtime.
- const CompactHashIndex* index;
+ mutable const HashEntry* table; // Table allocated at runtime.
ALWAYS_INLINE HashTable copy() const
{
// Don't copy dynamic table since it's thread specific.
- HashTable result = { numberOfValues, indexMask, hasSetterOrReadonlyProperties, values, 0, index };
+ HashTable result = { compactSize, compactHashSizeMask, hasSetterOrReadonlyProperties, values, 0 };
return result;
}
ALWAYS_INLINE void initializeIfNeeded(VM& vm) const
{
- if (!keys)
+ if (!table)
createTable(vm);
}
ALWAYS_INLINE void initializeIfNeeded(ExecState* exec) const
{
- if (!keys)
+ if (!table)
createTable(exec->vm());
}
JS_EXPORT_PRIVATE void deleteTable() const;
// Find an entry in the table, and return the entry.
- ALWAYS_INLINE const HashTableValue* entry(VM& vm, PropertyName identifier) const
+ ALWAYS_INLINE const HashEntry* entry(VM& vm, PropertyName identifier) const
{
initializeIfNeeded(vm);
return entry(identifier);
}
- ALWAYS_INLINE const HashTableValue* entry(ExecState* exec, PropertyName identifier) const
+ ALWAYS_INLINE const HashEntry* entry(ExecState* exec, PropertyName identifier) const
{
initializeIfNeeded(exec);
return entry(identifier);
skipInvalidKeys();
}
- const HashTableValue* value()
+ const HashEntry* operator->()
{
- return &m_table->values[m_position];
+ return &m_table->table[m_position];
}
- StringImpl* key()
+ const HashEntry* operator*()
{
- return m_table->keys[m_position];
- }
-
- const HashTableValue* operator->()
- {
- return value();
+ return &m_table->table[m_position];
}
bool operator!=(const ConstIterator& other)
ConstIterator& operator++()
{
- ASSERT(m_position < m_table->numberOfValues);
+ ASSERT(m_position < m_table->compactSize);
++m_position;
skipInvalidKeys();
return *this;
private:
void skipInvalidKeys()
{
- ASSERT(m_position <= m_table->numberOfValues);
- while (m_position < m_table->numberOfValues && !m_table->keys[m_position])
+ ASSERT(m_position <= m_table->compactSize);
+ while (m_position < m_table->compactSize && !m_table->table[m_position].key())
++m_position;
- ASSERT(m_position <= m_table->numberOfValues);
+ ASSERT(m_position <= m_table->compactSize);
}
const HashTable* m_table;
ConstIterator end(VM& vm) const
{
initializeIfNeeded(vm);
- return ConstIterator(this, numberOfValues);
+ return ConstIterator(this, compactSize);
}
private:
- ALWAYS_INLINE const HashTableValue* entry(PropertyName propertyName) const
+ ALWAYS_INLINE const HashEntry* entry(PropertyName propertyName) const
{
StringImpl* impl = propertyName.uid();
if (!impl)
return 0;
- ASSERT(keys);
+ ASSERT(table);
+
+ const HashEntry* entry = &table[impl->existingHash() & compactHashSizeMask];
- int indexEntry = impl->existingHash() & indexMask;
- int valueIndex = index[indexEntry].value;
- if (valueIndex == -1)
+ if (!entry->key())
return 0;
- while (true) {
- if (keys[valueIndex] == impl)
- return &values[valueIndex];
+ do {
+ if (entry->key() == impl)
+ return entry;
+ entry = entry->next();
+ } while (entry);
- indexEntry = index[indexEntry].next;
- if (indexEntry == -1)
- return nullptr;
- valueIndex = index[indexEntry].value;
- ASSERT(valueIndex != -1);
- };
+ return 0;
}
// Convert the hash table keys to identifiers.
JS_EXPORT_PRIVATE void createTable(VM&) const;
};
- JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject* thisObject, PropertyName, PropertySlot&);
+ JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, PropertyName, PropertySlot&);
/**
* This method does it all (looking in the hashtable, checking for function
template <class ThisImp, class ParentImp>
inline bool getStaticPropertySlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
{
- const HashTableValue* entry = table.entry(exec, propertyName);
+ const HashEntry* entry = table.entry(exec, propertyName);
if (!entry) // not found, forward to parent
return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
if (ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot))
return true;
- const HashTableValue* entry = table.entry(exec, propertyName);
+ const HashEntry* entry = table.entry(exec, propertyName);
if (!entry)
return false;
template <class ThisImp, class ParentImp>
inline bool getStaticValueSlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
{
- const HashTableValue* entry = table.entry(exec, propertyName);
+ const HashEntry* entry = table.entry(exec, propertyName);
if (!entry) // not found, forward to parent
return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
return true;
}
- inline void putEntry(ExecState* exec, const HashTableValue* entry, JSObject* base, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
+ inline void putEntry(ExecState* exec, const HashEntry* entry, JSObject* base, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
// If this is a function put it as an override property.
if (entry->attributes() & BuiltinOrFunction) {
*/
inline bool lookupPut(ExecState* exec, PropertyName propertyName, JSObject* base, JSValue value, const HashTable& table, PutPropertySlot& slot)
{
- const HashTableValue* entry = table.entry(exec, propertyName);
+ const HashEntry* entry = table.entry(exec, propertyName);
if (!entry)
return false;
+2014-03-12 Commit Queue <commit-queue@webkit.org>
+
+ Unreviewed, rolling out r165482.
+ https://bugs.webkit.org/show_bug.cgi?id=130157
+
+ Broke the windows build; "error C2466: cannot allocate an
+ array of constant size 0" (Requested by jernoble on #webkit).
+
+ Reverted changeset:
+
+ "Reduce memory use for static property maps"
+ https://bugs.webkit.org/show_bug.cgi?id=129986
+ http://trac.webkit.org/changeset/165482
+
2014-03-12 Brian Burg <bburg@apple.com>
Web Inspector receives spurious setScriptEnabled instrumentation calls
}
template <class ThisImp>
-inline const JSC::HashTableValue* getStaticValueSlotEntryWithoutCaching(JSC::ExecState* exec, JSC::PropertyName propertyName)
+inline const JSC::HashEntry* getStaticValueSlotEntryWithoutCaching(JSC::ExecState* exec, JSC::PropertyName propertyName)
{
const JSC::HashTable* table = ThisImp::info()->propHashTable(exec);
if (!table)
return getStaticValueSlotEntryWithoutCaching<typename ThisImp::Base>(exec, propertyName);
- const JSC::HashTableValue* entry = table->entry(exec, propertyName);
+ const JSC::HashEntry* entry = table->entry(exec, propertyName);
if (!entry) // not found, forward to parent
return getStaticValueSlotEntryWithoutCaching<typename ThisImp::Base>(exec, propertyName);
return entry;
}
template <>
-inline const JSC::HashTableValue* getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>(JSC::ExecState*, JSC::PropertyName)
+inline const JSC::HashEntry* getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>(JSC::ExecState*, JSC::PropertyName)
{
return 0;
}
// are not affected by properties changed on the Window or anything in its prototype chain.
// This is consistent with the behavior of Firefox.
- const HashTableValue* entry;
+ const HashEntry* entry;
// We don't want any properties other than "close" and "closed" on a frameless window (i.e. one whose page got closed,
// or whose iframe got removed).
// Check for the few functions that we allow, even when called cross-domain.
// Make these read-only / non-configurable to prevent writes via defineProperty.
- const HashTableValue* entry = JSHistoryPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
+ const HashEntry* entry = JSHistoryPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
if (entry) {
// Allow access to back(), forward() and go() from any frame.
if (entry->attributes() & JSC::Function) {
// Check for the few functions that we allow, even when called cross-domain.
// Make these read-only / non-configurable to prevent writes via defineProperty.
- const HashTableValue* entry = JSLocationPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
+ const HashEntry* entry = JSLocationPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
if (entry && (entry->attributes() & JSC::Function)) {
if (entry->function() == jsLocationPrototypeFunctionReplace) {
slot.setCustom(this, ReadOnly | DontDelete | DontEnum, nonCachingStaticReplaceFunctionGetter);
bool sameDomainAccess = shouldAllowAccessToFrame(exec, frame);
- const HashTableValue* entry = JSLocation::info()->propHashTable(exec)->entry(exec, propertyName);
+ const HashEntry* entry = JSLocation::info()->propHashTable(exec)->entry(exec, propertyName);
if (!entry) {
if (sameDomainAccess)
JSObject::put(this, exec, propertyName, value, slot);
my $manualLookupGetterGeneration = sub {
my $requiresManualLookup = ($indexedGetterFunction && !$hasNumericIndexedGetter) || $namedGetterFunction;
if ($requiresManualLookup) {
- push(@getOwnPropertySlotImpl, " const ${namespaceMaybe}HashTableValue* entry = getStaticValueSlotEntryWithoutCaching<$className>(exec, propertyName);\n");
+ push(@getOwnPropertySlotImpl, " const ${namespaceMaybe}HashEntry* entry = getStaticValueSlotEntryWithoutCaching<$className>(exec, propertyName);\n");
push(@getOwnPropertySlotImpl, " if (entry) {\n");
push(@getOwnPropertySlotImpl, " slot.setCustom(thisObject, entry->attributes(), entry->propertyGetter());\n");
push(@getOwnPropertySlotImpl, " return true;\n");
# Start outputing the hashtables
my $nameEntries = "${name}Values";
$nameEntries =~ s/:/_/g;
- my $nameIndex = "${name}Index";
- $nameIndex =~ s/:/_/g;
my $hasSetter = "false";
if (($name =~ /Prototype/) or ($name =~ /Constructor/)) {
push(@implContent, "/* Hash table */\n");
}
- push(@implContent, "\nstatic const struct CompactHashIndex ${nameIndex}\[$compactSize\] = {\n");
- for (my $i = 0; $i < $compactSize; $i++) {
- my $T = -1;
- if (defined($table[$i])) { $T = $table[$i]; }
- my $L = -1;
- if (defined($links[$i])) { $L = $links[$i]; }
- push(@implContent, " { $T, $L },\n");
- }
- push(@implContent, "};\n\n");
-
# Dump the hash table
- my $packedSize = scalar @{$keys};
- push(@implContent, "\nstatic const HashTableValue $nameEntries\[$packedSize\] =\n\{\n");
+ push(@implContent, "\nstatic const HashTableValue $nameEntries\[\] =\n\{\n");
$i = 0;
foreach my $key (@{$keys}) {
my $conditional;
$hasSetter = "true";
}
push(@implContent, " { \"$key\", @$specials[$i], NoIntrinsic, (intptr_t)" . $firstTargetType . "(@$value1[$i]), (intptr_t) " . $secondTargetType . "(@$value2[$i]) },\n");
- if ($conditional) {
- push(@implContent, "#else\n") ;
- push(@implContent, " { 0, 0, NoIntrinsic, 0, 0 },\n");
- push(@implContent, "#endif\n") ;
- }
+ push(@implContent, "#endif\n") if $conditional;
++$i;
}
+ push(@implContent, " { 0, 0, NoIntrinsic, 0, 0 }\n");
push(@implContent, "};\n\n");
my $compactSizeMask = $numEntries - 1;
- push(@implContent, "static const HashTable $name = { $packedSize, $compactSizeMask, $hasSetter, $nameEntries, 0, $nameIndex };\n");
+ push(@implContent, "static const HashTable $name = { $compactSize, $compactSizeMask, $hasSetter, $nameEntries, 0 };\n");
}
sub WriteData
/* Hash table */
-static const struct CompactHashIndex JSTestActiveDOMObjectTableIndex[4] = {
- { 1, -1 },
- { 0, -1 },
- { -1, -1 },
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestActiveDOMObjectTableValues[2] =
+static const HashTableValue JSTestActiveDOMObjectTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestActiveDOMObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "excitingAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestActiveDOMObjectExcitingAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestActiveDOMObjectTable = { 2, 3, true, JSTestActiveDOMObjectTableValues, 0, JSTestActiveDOMObjectTableIndex };
+static const HashTable JSTestActiveDOMObjectTable = { 4, 3, true, JSTestActiveDOMObjectTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestActiveDOMObjectConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestActiveDOMObjectConstructorTableValues[0] =
+static const HashTableValue JSTestActiveDOMObjectConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestActiveDOMObjectConstructorTable = { 0, 0, false, JSTestActiveDOMObjectConstructorTableValues, 0, JSTestActiveDOMObjectConstructorTableIndex };
+static const HashTable JSTestActiveDOMObjectConstructorTable = { 1, 0, false, JSTestActiveDOMObjectConstructorTableValues, 0 };
const ClassInfo JSTestActiveDOMObjectConstructor::s_info = { "TestActiveDOMObjectConstructor", &Base::s_info, &JSTestActiveDOMObjectConstructorTable, 0, CREATE_METHOD_TABLE(JSTestActiveDOMObjectConstructor) };
JSTestActiveDOMObjectConstructor::JSTestActiveDOMObjectConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestActiveDOMObjectPrototypeTableIndex[4] = {
- { 0, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestActiveDOMObjectPrototypeTableValues[2] =
+static const HashTableValue JSTestActiveDOMObjectPrototypeTableValues[] =
{
{ "excitingFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestActiveDOMObjectPrototypeFunctionExcitingFunction), (intptr_t) (1) },
{ "postMessage", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestActiveDOMObjectPrototypeFunctionPostMessage), (intptr_t) (1) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestActiveDOMObjectPrototypeTable = { 2, 3, false, JSTestActiveDOMObjectPrototypeTableValues, 0, JSTestActiveDOMObjectPrototypeTableIndex };
+static const HashTable JSTestActiveDOMObjectPrototypeTable = { 4, 3, false, JSTestActiveDOMObjectPrototypeTableValues, 0 };
const ClassInfo JSTestActiveDOMObjectPrototype::s_info = { "TestActiveDOMObjectPrototype", &Base::s_info, &JSTestActiveDOMObjectPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestActiveDOMObjectPrototype) };
JSObject* JSTestActiveDOMObjectPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table */
-static const struct CompactHashIndex JSTestCustomNamedGetterTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestCustomNamedGetterTableValues[1] =
+static const HashTableValue JSTestCustomNamedGetterTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestCustomNamedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestCustomNamedGetterTable = { 1, 1, true, JSTestCustomNamedGetterTableValues, 0, JSTestCustomNamedGetterTableIndex };
+static const HashTable JSTestCustomNamedGetterTable = { 2, 1, true, JSTestCustomNamedGetterTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestCustomNamedGetterConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestCustomNamedGetterConstructorTableValues[0] =
+static const HashTableValue JSTestCustomNamedGetterConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestCustomNamedGetterConstructorTable = { 0, 0, false, JSTestCustomNamedGetterConstructorTableValues, 0, JSTestCustomNamedGetterConstructorTableIndex };
+static const HashTable JSTestCustomNamedGetterConstructorTable = { 1, 0, false, JSTestCustomNamedGetterConstructorTableValues, 0 };
const ClassInfo JSTestCustomNamedGetterConstructor::s_info = { "TestCustomNamedGetterConstructor", &Base::s_info, &JSTestCustomNamedGetterConstructorTable, 0, CREATE_METHOD_TABLE(JSTestCustomNamedGetterConstructor) };
JSTestCustomNamedGetterConstructor::JSTestCustomNamedGetterConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestCustomNamedGetterPrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestCustomNamedGetterPrototypeTableValues[1] =
+static const HashTableValue JSTestCustomNamedGetterPrototypeTableValues[] =
{
{ "anotherFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestCustomNamedGetterPrototypeFunctionAnotherFunction), (intptr_t) (1) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestCustomNamedGetterPrototypeTable = { 1, 1, false, JSTestCustomNamedGetterPrototypeTableValues, 0, JSTestCustomNamedGetterPrototypeTableIndex };
+static const HashTable JSTestCustomNamedGetterPrototypeTable = { 2, 1, false, JSTestCustomNamedGetterPrototypeTableValues, 0 };
const ClassInfo JSTestCustomNamedGetterPrototype::s_info = { "TestCustomNamedGetterPrototype", &Base::s_info, &JSTestCustomNamedGetterPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestCustomNamedGetterPrototype) };
JSObject* JSTestCustomNamedGetterPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestEventConstructorConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestEventConstructorConstructorTableValues[0] =
+static const HashTableValue JSTestEventConstructorConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestEventConstructorConstructorTable = { 0, 0, false, JSTestEventConstructorConstructorTableValues, 0, JSTestEventConstructorConstructorTableIndex };
+static const HashTable JSTestEventConstructorConstructorTable = { 1, 0, false, JSTestEventConstructorConstructorTableValues, 0 };
EncodedJSValue JSC_HOST_CALL JSTestEventConstructorConstructor::constructJSTestEventConstructor(ExecState* exec)
{
JSTestEventConstructorConstructor* jsConstructor = jsCast<JSTestEventConstructorConstructor*>(exec->callee());
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestEventConstructorPrototypeTableIndex[9] = {
- { -1, -1 },
- { 0, 8 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 2, -1 },
-};
-
-
-static const HashTableValue JSTestEventConstructorPrototypeTableValues[3] =
+static const HashTableValue JSTestEventConstructorPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "attr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "attr2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestEventConstructorPrototypeTable = { 3, 7, true, JSTestEventConstructorPrototypeTableValues, 0, JSTestEventConstructorPrototypeTableIndex };
+static const HashTable JSTestEventConstructorPrototypeTable = { 9, 7, true, JSTestEventConstructorPrototypeTableValues, 0 };
const ClassInfo JSTestEventConstructorPrototype::s_info = { "TestEventConstructorPrototype", &Base::s_info, &JSTestEventConstructorPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestEventConstructorPrototype) };
JSObject* JSTestEventConstructorPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table */
-static const struct CompactHashIndex JSTestEventTargetTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestEventTargetTableValues[1] =
+static const HashTableValue JSTestEventTargetTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestEventTargetTable = { 1, 1, true, JSTestEventTargetTableValues, 0, JSTestEventTargetTableIndex };
+static const HashTable JSTestEventTargetTable = { 2, 1, true, JSTestEventTargetTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestEventTargetConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestEventTargetConstructorTableValues[0] =
+static const HashTableValue JSTestEventTargetConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestEventTargetConstructorTable = { 0, 0, false, JSTestEventTargetConstructorTableValues, 0, JSTestEventTargetConstructorTableIndex };
+static const HashTable JSTestEventTargetConstructorTable = { 1, 0, false, JSTestEventTargetConstructorTableValues, 0 };
const ClassInfo JSTestEventTargetConstructor::s_info = { "TestEventTargetConstructor", &Base::s_info, &JSTestEventTargetConstructorTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetConstructor) };
JSTestEventTargetConstructor::JSTestEventTargetConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestEventTargetPrototypeTableIndex[8] = {
- { 2, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 3, -1 },
- { 1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestEventTargetPrototypeTableValues[4] =
+static const HashTableValue JSTestEventTargetPrototypeTableValues[] =
{
{ "item", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionItem), (intptr_t) (1) },
{ "addEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionAddEventListener), (intptr_t) (2) },
{ "removeEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionRemoveEventListener), (intptr_t) (2) },
{ "dispatchEvent", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionDispatchEvent), (intptr_t) (1) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestEventTargetPrototypeTable = { 4, 7, false, JSTestEventTargetPrototypeTableValues, 0, JSTestEventTargetPrototypeTableIndex };
+static const HashTable JSTestEventTargetPrototypeTable = { 8, 7, false, JSTestEventTargetPrototypeTableValues, 0 };
const ClassInfo JSTestEventTargetPrototype::s_info = { "TestEventTargetPrototype", &Base::s_info, &JSTestEventTargetPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetPrototype) };
JSObject* JSTestEventTargetPrototype::self(VM& vm, JSGlobalObject* globalObject)
{
JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(object);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
- const HashTableValue* entry = getStaticValueSlotEntryWithoutCaching<JSTestEventTarget>(exec, propertyName);
+ const HashEntry* entry = getStaticValueSlotEntryWithoutCaching<JSTestEventTarget>(exec, propertyName);
if (entry) {
slot.setCustom(thisObject, entry->attributes(), entry->propertyGetter());
return true;
/* Hash table */
-static const struct CompactHashIndex JSTestExceptionTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestExceptionTableValues[1] =
+static const HashTableValue JSTestExceptionTableValues[] =
{
{ "name", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionName), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestExceptionTable = { 1, 1, true, JSTestExceptionTableValues, 0, JSTestExceptionTableIndex };
+static const HashTable JSTestExceptionTable = { 2, 1, true, JSTestExceptionTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestExceptionConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestExceptionConstructorTableValues[0] =
+static const HashTableValue JSTestExceptionConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestExceptionConstructorTable = { 0, 0, false, JSTestExceptionConstructorTableValues, 0, JSTestExceptionConstructorTableIndex };
+static const HashTable JSTestExceptionConstructorTable = { 1, 0, false, JSTestExceptionConstructorTableValues, 0 };
const ClassInfo JSTestExceptionConstructor::s_info = { "TestExceptionConstructor", &Base::s_info, &JSTestExceptionConstructorTable, 0, CREATE_METHOD_TABLE(JSTestExceptionConstructor) };
JSTestExceptionConstructor::JSTestExceptionConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestExceptionPrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestExceptionPrototypeTableValues[1] =
+static const HashTableValue JSTestExceptionPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestExceptionPrototypeTable = { 1, 1, true, JSTestExceptionPrototypeTableValues, 0, JSTestExceptionPrototypeTableIndex };
+static const HashTable JSTestExceptionPrototypeTable = { 2, 1, true, JSTestExceptionPrototypeTableValues, 0 };
const ClassInfo JSTestExceptionPrototype::s_info = { "TestExceptionPrototype", &Base::s_info, &JSTestExceptionPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestExceptionPrototype) };
JSObject* JSTestExceptionPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestGenerateIsReachableConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestGenerateIsReachableConstructorTableValues[0] =
+static const HashTableValue JSTestGenerateIsReachableConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestGenerateIsReachableConstructorTable = { 0, 0, false, JSTestGenerateIsReachableConstructorTableValues, 0, JSTestGenerateIsReachableConstructorTableIndex };
+static const HashTable JSTestGenerateIsReachableConstructorTable = { 1, 0, false, JSTestGenerateIsReachableConstructorTableValues, 0 };
const ClassInfo JSTestGenerateIsReachableConstructor::s_info = { "TestGenerateIsReachableConstructor", &Base::s_info, &JSTestGenerateIsReachableConstructorTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachableConstructor) };
JSTestGenerateIsReachableConstructor::JSTestGenerateIsReachableConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestGenerateIsReachablePrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestGenerateIsReachablePrototypeTableValues[1] =
+static const HashTableValue JSTestGenerateIsReachablePrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGenerateIsReachableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestGenerateIsReachablePrototypeTable = { 1, 1, true, JSTestGenerateIsReachablePrototypeTableValues, 0, JSTestGenerateIsReachablePrototypeTableIndex };
+static const HashTable JSTestGenerateIsReachablePrototypeTable = { 2, 1, true, JSTestGenerateIsReachablePrototypeTableValues, 0 };
const ClassInfo JSTestGenerateIsReachablePrototype::s_info = { "TestGenerateIsReachablePrototype", &Base::s_info, &JSTestGenerateIsReachablePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachablePrototype) };
JSObject* JSTestGenerateIsReachablePrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table */
-static const struct CompactHashIndex JSTestInterfaceTableIndex[4] = {
- { -1, -1 },
- { 0, -1 },
- { -1, -1 },
- { 1, -1 },
-};
-
-
-static const HashTableValue JSTestInterfaceTableValues[2] =
+static const HashTableValue JSTestInterfaceTableValues[] =
{
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestInterfaceTable = { 2, 3, true, JSTestInterfaceTableValues, 0, JSTestInterfaceTableIndex };
+static const HashTable JSTestInterfaceTable = { 4, 3, true, JSTestInterfaceTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestInterfaceConstructorTableIndex[11] = {
- { 8, -1 },
- { 5, -1 },
- { -1, -1 },
- { 0, 9 },
- { 6, 10 },
- { 7, -1 },
- { 2, -1 },
- { 1, 8 },
- { 3, -1 },
- { 4, -1 },
- { 9, -1 },
-};
-
-
-static const HashTableValue JSTestInterfaceConstructorTableValues[10] =
+static const HashTableValue JSTestInterfaceConstructorTableValues[] =
{
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorSupplementalStaticAttr) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestInterfaceConstructorTable = { 10, 7, true, JSTestInterfaceConstructorTableValues, 0, JSTestInterfaceConstructorTableIndex };
+static const HashTable JSTestInterfaceConstructorTable = { 11, 7, true, JSTestInterfaceConstructorTableValues, 0 };
#if ENABLE(Condition22) || ENABLE(Condition23)
COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestInterfacePrototypeTableIndex[65] = {
- { -1, -1 },
- { 3, 64 },
- { 14, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 13, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 10, -1 },
- { -1, -1 },
- { 5, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 4, -1 },
- { -1, -1 },
- { 0, -1 },
- { -1, -1 },
- { 7, -1 },
- { -1, -1 },
- { -1, -1 },
- { 15, -1 },
- { 1, -1 },
- { 6, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 11, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 8, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 16, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 2, -1 },
- { 9, -1 },
- { -1, -1 },
- { 12, -1 },
-};
-
-
-static const HashTableValue JSTestInterfacePrototypeTableValues[17] =
+static const HashTableValue JSTestInterfacePrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t) (2) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition22) || ENABLE(Condition23)
{ "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t) (2) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition11) || ENABLE(Condition12)
{ "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestInterfacePrototypeTable = { 17, 63, true, JSTestInterfacePrototypeTableValues, 0, JSTestInterfacePrototypeTableIndex };
+static const HashTable JSTestInterfacePrototypeTable = { 65, 63, true, JSTestInterfacePrototypeTableValues, 0 };
const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
JSObject* JSTestInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestMediaQueryListListenerConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestMediaQueryListListenerConstructorTableValues[0] =
+static const HashTableValue JSTestMediaQueryListListenerConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestMediaQueryListListenerConstructorTable = { 0, 0, false, JSTestMediaQueryListListenerConstructorTableValues, 0, JSTestMediaQueryListListenerConstructorTableIndex };
+static const HashTable JSTestMediaQueryListListenerConstructorTable = { 1, 0, false, JSTestMediaQueryListListenerConstructorTableValues, 0 };
const ClassInfo JSTestMediaQueryListListenerConstructor::s_info = { "TestMediaQueryListListenerConstructor", &Base::s_info, &JSTestMediaQueryListListenerConstructorTable, 0, CREATE_METHOD_TABLE(JSTestMediaQueryListListenerConstructor) };
JSTestMediaQueryListListenerConstructor::JSTestMediaQueryListListenerConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestMediaQueryListListenerPrototypeTableIndex[4] = {
- { 1, -1 },
- { 0, -1 },
- { -1, -1 },
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestMediaQueryListListenerPrototypeTableValues[2] =
+static const HashTableValue JSTestMediaQueryListListenerPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestMediaQueryListListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "method", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestMediaQueryListListenerPrototypeFunctionMethod), (intptr_t) (1) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestMediaQueryListListenerPrototypeTable = { 2, 3, true, JSTestMediaQueryListListenerPrototypeTableValues, 0, JSTestMediaQueryListListenerPrototypeTableIndex };
+static const HashTable JSTestMediaQueryListListenerPrototypeTable = { 4, 3, true, JSTestMediaQueryListListenerPrototypeTableValues, 0 };
const ClassInfo JSTestMediaQueryListListenerPrototype::s_info = { "TestMediaQueryListListenerPrototype", &Base::s_info, &JSTestMediaQueryListListenerPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestMediaQueryListListenerPrototype) };
JSObject* JSTestMediaQueryListListenerPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestNamedConstructorConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestNamedConstructorConstructorTableValues[0] =
+static const HashTableValue JSTestNamedConstructorConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestNamedConstructorConstructorTable = { 0, 0, false, JSTestNamedConstructorConstructorTableValues, 0, JSTestNamedConstructorConstructorTableIndex };
+static const HashTable JSTestNamedConstructorConstructorTable = { 1, 0, false, JSTestNamedConstructorConstructorTableValues, 0 };
const ClassInfo JSTestNamedConstructorConstructor::s_info = { "TestNamedConstructorConstructor", &Base::s_info, &JSTestNamedConstructorConstructorTable, 0, CREATE_METHOD_TABLE(JSTestNamedConstructorConstructor) };
JSTestNamedConstructorConstructor::JSTestNamedConstructorConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestNamedConstructorPrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestNamedConstructorPrototypeTableValues[1] =
+static const HashTableValue JSTestNamedConstructorPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNamedConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestNamedConstructorPrototypeTable = { 1, 1, true, JSTestNamedConstructorPrototypeTableValues, 0, JSTestNamedConstructorPrototypeTableIndex };
+static const HashTable JSTestNamedConstructorPrototypeTable = { 2, 1, true, JSTestNamedConstructorPrototypeTableValues, 0 };
const ClassInfo JSTestNamedConstructorPrototype::s_info = { "TestNamedConstructorPrototype", &Base::s_info, &JSTestNamedConstructorPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestNamedConstructorPrototype) };
JSObject* JSTestNamedConstructorPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestNodeConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestNodeConstructorTableValues[0] =
+static const HashTableValue JSTestNodeConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestNodeConstructorTable = { 0, 0, false, JSTestNodeConstructorTableValues, 0, JSTestNodeConstructorTableIndex };
+static const HashTable JSTestNodeConstructorTable = { 1, 0, false, JSTestNodeConstructorTableValues, 0 };
EncodedJSValue JSC_HOST_CALL JSTestNodeConstructor::constructJSTestNode(ExecState* exec)
{
JSTestNodeConstructor* castedThis = jsCast<JSTestNodeConstructor*>(exec->callee());
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestNodePrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestNodePrototypeTableValues[1] =
+static const HashTableValue JSTestNodePrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestNodePrototypeTable = { 1, 1, true, JSTestNodePrototypeTableValues, 0, JSTestNodePrototypeTableIndex };
+static const HashTable JSTestNodePrototypeTable = { 2, 1, true, JSTestNodePrototypeTableValues, 0 };
const ClassInfo JSTestNodePrototype::s_info = { "TestNodePrototype", &Base::s_info, &JSTestNodePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestNodePrototype) };
JSObject* JSTestNodePrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table */
-static const struct CompactHashIndex JSTestObjTableIndex[17] = {
- { 5, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 4, -1 },
- { -1, -1 },
- { -1, -1 },
- { 2, -1 },
- { 0, 16 },
- { -1, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 3, -1 },
-};
-
-
-static const HashTableValue JSTestObjTableValues[6] =
+static const HashTableValue JSTestObjTableValues[] =
{
{ "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) },
{ "customAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) },
#if ENABLE(Condition1)
{ "conditionalAttr4", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) && ENABLE(Condition2)
{ "conditionalAttr5", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) || ENABLE(Condition2)
{ "conditionalAttr6", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
{ "contentDocument", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, 0, JSTestObjTableIndex };
+static const HashTable JSTestObjTable = { 17, 15, true, JSTestObjTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestObjConstructorTableIndex[39] = {
- { -1, -1 },
- { 9, 34 },
- { 21, -1 },
- { 2, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 0, -1 },
- { 12, -1 },
- { 16, -1 },
- { 5, 32 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 10, -1 },
- { 7, 36 },
- { 15, -1 },
- { 3, -1 },
- { -1, -1 },
- { 11, 33 },
- { -1, -1 },
- { -1, -1 },
- { 8, 37 },
- { 18, -1 },
- { -1, -1 },
- { -1, -1 },
- { 4, -1 },
- { 6, -1 },
- { 13, -1 },
- { 14, 35 },
- { 17, -1 },
- { 19, 38 },
- { 20, -1 },
- { 22, -1 },
-};
-
-
-static const HashTableValue JSTestObjConstructorTableValues[23] =
+static const HashTableValue JSTestObjConstructorTableValues[] =
{
#if ENABLE(Condition1)
{ "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
{ "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "classMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) },
#if ENABLE(Condition1)
{ "overloadedMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestObjConstructorTable = { 23, 31, true, JSTestObjConstructorTableValues, 0, JSTestObjConstructorTableIndex };
+static const HashTable JSTestObjConstructorTable = { 39, 31, true, JSTestObjConstructorTableValues, 0 };
#if ENABLE(Condition1)
COMPILE_ASSERT(0 == TestObj::CONDITIONAL_CONST, TestObjEnumCONDITIONAL_CONSTIsWrongUseDoNotCheckConstants);
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestObjPrototypeTableIndex[530] = {
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 23, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 49, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 16, 513 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 47, -1 },
- { 73, -1 },
- { -1, -1 },
- { 41, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 102, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 15, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 110, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 27, 522 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 126, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 101, -1 },
- { 100, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 4, -1 },
- { -1, -1 },
- { 17, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 5, -1 },
- { 134, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 53, -1 },
- { 32, 517 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 93, -1 },
- { 87, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 31, -1 },
- { -1, -1 },
- { 55, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 117, -1 },
- { -1, -1 },
- { -1, -1 },
- { 78, -1 },
- { 70, -1 },
- { -1, -1 },
- { 25, -1 },
- { -1, -1 },
- { -1, -1 },
- { 22, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 96, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 114, -1 },
- { -1, -1 },
- { 6, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 86, -1 },
- { -1, -1 },
- { -1, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 33, -1 },
- { 51, -1 },
- { -1, -1 },
- { 71, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 92, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 127, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 72, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 67, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 24, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 89, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 82, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 3, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 45, -1 },
- { -1, -1 },
- { 77, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 36, 526 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 8, 512 },
- { -1, -1 },
- { 130, -1 },
- { -1, -1 },
- { 58, 528 },
- { 135, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 64, 524 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 131, -1 },
- { -1, -1 },
- { 103, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 39, 515 },
- { -1, -1 },
- { -1, -1 },
- { 113, -1 },
- { 90, -1 },
- { 120, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 34, -1 },
- { -1, -1 },
- { 18, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 61, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 128, -1 },
- { 123, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 26, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 76, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 84, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 43, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 12, -1 },
- { -1, -1 },
- { 59, -1 },
- { -1, -1 },
- { -1, -1 },
- { 0, -1 },
- { -1, -1 },
- { 99, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 30, -1 },
- { 28, -1 },
- { -1, -1 },
- { -1, -1 },
- { 124, -1 },
- { -1, -1 },
- { 35, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 65, 518 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 88, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 46, 521 },
- { 80, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 44, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 69, -1 },
- { -1, -1 },
- { 62, -1 },
- { -1, -1 },
- { 2, -1 },
- { -1, -1 },
- { 50, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 95, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 38, 523 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 57, -1 },
- { 68, -1 },
- { -1, -1 },
- { -1, -1 },
- { 107, 527 },
- { -1, -1 },
- { 108, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 14, -1 },
- { 20, 529 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 112, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 118, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 79, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 60, -1 },
- { 52, -1 },
- { -1, -1 },
- { 74, -1 },
- { 132, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 54, 516 },
- { -1, -1 },
- { 85, -1 },
- { 9, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 105, -1 },
- { 29, -1 },
- { -1, -1 },
- { -1, -1 },
- { 37, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 19, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 109, -1 },
- { 13, 514 },
- { 40, -1 },
- { 111, -1 },
- { -1, -1 },
- { 7, 525 },
- { -1, -1 },
- { 125, -1 },
- { 106, -1 },
- { 75, 520 },
- { -1, -1 },
- { 122, -1 },
- { 83, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 119, -1 },
- { -1, -1 },
- { 10, 519 },
- { 11, -1 },
- { 21, -1 },
- { 42, -1 },
- { 48, -1 },
- { 56, -1 },
- { 63, -1 },
- { 66, -1 },
- { 81, -1 },
- { 91, -1 },
- { 94, -1 },
- { 97, -1 },
- { 98, -1 },
- { 104, -1 },
- { 115, -1 },
- { 116, -1 },
- { 121, -1 },
- { 129, -1 },
- { 133, -1 },
-};
-
-
-static const HashTableValue JSTestObjPrototypeTableValues[136] =
+static const HashTableValue JSTestObjPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "readOnlyLongAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "withScriptArgumentsAndCallStackAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) },
#if ENABLE(Condition1)
{ "conditionalAttr1", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) && ENABLE(Condition2)
{ "conditionalAttr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) || ENABLE(Condition2)
{ "conditionalAttr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
{ "cachedAttribute1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "cachedAttribute2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "attributeWithReservedEnumType", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) },
#if ENABLE(Condition1)
{ "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
{ "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) },
#if ENABLE(Condition1)
{ "conditionalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) && ENABLE(Condition2)
{ "conditionalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
#if ENABLE(Condition1) || ENABLE(Condition2)
{ "conditionalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) },
-#else
- { 0, 0, NoIntrinsic, 0, 0 },
#endif
{ "overloadedMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) },
{ "classMethodWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) },
{ "variadicDoubleMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (2) },
{ "variadicNodeMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (2) },
{ "any", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestObjPrototypeTable = { 136, 511, true, JSTestObjPrototypeTableValues, 0, JSTestObjPrototypeTableIndex };
+static const HashTable JSTestObjPrototypeTable = { 530, 511, true, JSTestObjPrototypeTableValues, 0 };
const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, &JSTestObjPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
JSObject* JSTestObjPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestOverloadedConstructorsConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestOverloadedConstructorsConstructorTableValues[0] =
+static const HashTableValue JSTestOverloadedConstructorsConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestOverloadedConstructorsConstructorTable = { 0, 0, false, JSTestOverloadedConstructorsConstructorTableValues, 0, JSTestOverloadedConstructorsConstructorTableIndex };
+static const HashTable JSTestOverloadedConstructorsConstructorTable = { 1, 0, false, JSTestOverloadedConstructorsConstructorTableValues, 0 };
EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors1(ExecState* exec)
{
JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestOverloadedConstructorsPrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestOverloadedConstructorsPrototypeTableValues[1] =
+static const HashTableValue JSTestOverloadedConstructorsPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestOverloadedConstructorsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestOverloadedConstructorsPrototypeTable = { 1, 1, true, JSTestOverloadedConstructorsPrototypeTableValues, 0, JSTestOverloadedConstructorsPrototypeTableIndex };
+static const HashTable JSTestOverloadedConstructorsPrototypeTable = { 2, 1, true, JSTestOverloadedConstructorsPrototypeTableValues, 0 };
const ClassInfo JSTestOverloadedConstructorsPrototype::s_info = { "TestOverloadedConstructorsPrototype", &Base::s_info, &JSTestOverloadedConstructorsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestOverloadedConstructorsPrototype) };
JSObject* JSTestOverloadedConstructorsPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestSerializedScriptValueInterfaceConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestSerializedScriptValueInterfaceConstructorTableValues[0] =
+static const HashTableValue JSTestSerializedScriptValueInterfaceConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestSerializedScriptValueInterfaceConstructorTable = { 0, 0, false, JSTestSerializedScriptValueInterfaceConstructorTableValues, 0, JSTestSerializedScriptValueInterfaceConstructorTableIndex };
+static const HashTable JSTestSerializedScriptValueInterfaceConstructorTable = { 1, 0, false, JSTestSerializedScriptValueInterfaceConstructorTableValues, 0 };
const ClassInfo JSTestSerializedScriptValueInterfaceConstructor::s_info = { "TestSerializedScriptValueInterfaceConstructor", &Base::s_info, &JSTestSerializedScriptValueInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfaceConstructor) };
JSTestSerializedScriptValueInterfaceConstructor::JSTestSerializedScriptValueInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestSerializedScriptValueInterfacePrototypeTableIndex[17] = {
- { -1, -1 },
- { -1, -1 },
- { 3, -1 },
- { -1, -1 },
- { -1, -1 },
- { 2, 16 },
- { -1, -1 },
- { 4, -1 },
- { -1, -1 },
- { 0, -1 },
- { -1, -1 },
- { 1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 5, -1 },
-};
-
-
-static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[6] =
+static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "value", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceValue) },
{ "cachedValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceCachedValue) },
{ "ports", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfacePorts), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "cachedReadonlyValue", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestSerializedScriptValueInterfacePrototypeTable = { 6, 15, true, JSTestSerializedScriptValueInterfacePrototypeTableValues, 0, JSTestSerializedScriptValueInterfacePrototypeTableIndex };
+static const HashTable JSTestSerializedScriptValueInterfacePrototypeTable = { 17, 15, true, JSTestSerializedScriptValueInterfacePrototypeTableValues, 0 };
const ClassInfo JSTestSerializedScriptValueInterfacePrototype::s_info = { "TestSerializedScriptValueInterfacePrototype", &Base::s_info, &JSTestSerializedScriptValueInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfacePrototype) };
JSObject* JSTestSerializedScriptValueInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table */
-static const struct CompactHashIndex JSTestTypedefsTableIndex[2] = {
- { -1, -1 },
- { -1, -1 },
-};
-
-
-static const HashTableValue JSTestTypedefsTableValues[0] =
+static const HashTableValue JSTestTypedefsTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestTypedefsTable = { 0, 1, false, JSTestTypedefsTableValues, 0, JSTestTypedefsTableIndex };
+static const HashTable JSTestTypedefsTable = { 2, 1, false, JSTestTypedefsTableValues, 0 };
/* Hash table for constructor */
-static const struct CompactHashIndex JSTestTypedefsConstructorTableIndex[1] = {
- { 0, -1 },
-};
-
-
-static const HashTableValue JSTestTypedefsConstructorTableValues[1] =
+static const HashTableValue JSTestTypedefsConstructorTableValues[] =
{
{ "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0, JSTestTypedefsConstructorTableIndex };
+static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0 };
EncodedJSValue JSC_HOST_CALL JSTestTypedefsConstructor::constructJSTestTypedefs(ExecState* exec)
{
JSTestTypedefsConstructor* castedThis = jsCast<JSTestTypedefsConstructor*>(exec->callee());
/* Hash table for prototype */
-static const struct CompactHashIndex JSTestTypedefsPrototypeTableIndex[66] = {
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 9, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 16, -1 },
- { -1, -1 },
- { -1, -1 },
- { 2, -1 },
- { -1, -1 },
- { -1, -1 },
- { 0, 64 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 11, -1 },
- { -1, -1 },
- { -1, -1 },
- { 5, -1 },
- { -1, -1 },
- { 8, -1 },
- { -1, -1 },
- { 12, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 15, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { -1, -1 },
- { 14, -1 },
- { -1, -1 },
- { 1, -1 },
- { 3, -1 },
- { 4, 65 },
- { -1, -1 },
- { -1, -1 },
- { 10, -1 },
- { -1, -1 },
- { -1, -1 },
- { 13, -1 },
- { -1, -1 },
- { -1, -1 },
- { 6, -1 },
- { 7, -1 },
-};
-
-
-static const HashTableValue JSTestTypedefsPrototypeTableValues[17] =
+static const HashTableValue JSTestTypedefsPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsUnsignedLongLongAttr) },
{ "stringArrayFunction2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction2), (intptr_t) (1) },
{ "callWithSequenceThatRequiresInclude", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude), (intptr_t) (1) },
{ "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithException), (intptr_t) (0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSTestTypedefsPrototypeTable = { 17, 63, true, JSTestTypedefsPrototypeTableValues, 0, JSTestTypedefsPrototypeTableIndex };
+static const HashTable JSTestTypedefsPrototypeTable = { 66, 63, true, JSTestTypedefsPrototypeTableValues, 0 };
const ClassInfo JSTestTypedefsPrototype::s_info = { "TestTypedefsPrototype", &Base::s_info, &JSTestTypedefsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsPrototype) };
JSObject* JSTestTypedefsPrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSattributeConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSattributeConstructorTableValues[0] =
+static const HashTableValue JSattributeConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSattributeConstructorTable = { 0, 0, false, JSattributeConstructorTableValues, 0, JSattributeConstructorTableIndex };
+static const HashTable JSattributeConstructorTable = { 1, 0, false, JSattributeConstructorTableValues, 0 };
const ClassInfo JSattributeConstructor::s_info = { "attributeConstructor", &Base::s_info, &JSattributeConstructorTable, 0, CREATE_METHOD_TABLE(JSattributeConstructor) };
JSattributeConstructor::JSattributeConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSattributePrototypeTableIndex[4] = {
- { 1, -1 },
- { 0, -1 },
- { -1, -1 },
- { -1, -1 },
-};
-
-
-static const HashTableValue JSattributePrototypeTableValues[2] =
+static const HashTableValue JSattributePrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
{ "readonly", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSattributePrototypeTable = { 2, 3, true, JSattributePrototypeTableValues, 0, JSattributePrototypeTableIndex };
+static const HashTable JSattributePrototypeTable = { 4, 3, true, JSattributePrototypeTableValues, 0 };
const ClassInfo JSattributePrototype::s_info = { "attributePrototype", &Base::s_info, &JSattributePrototypeTable, 0, CREATE_METHOD_TABLE(JSattributePrototype) };
JSObject* JSattributePrototype::self(VM& vm, JSGlobalObject* globalObject)
/* Hash table for constructor */
-static const struct CompactHashIndex JSreadonlyConstructorTableIndex[1] = {
- { -1, -1 },
-};
-
-
-static const HashTableValue JSreadonlyConstructorTableValues[0] =
+static const HashTableValue JSreadonlyConstructorTableValues[] =
{
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSreadonlyConstructorTable = { 0, 0, false, JSreadonlyConstructorTableValues, 0, JSreadonlyConstructorTableIndex };
+static const HashTable JSreadonlyConstructorTable = { 1, 0, false, JSreadonlyConstructorTableValues, 0 };
const ClassInfo JSreadonlyConstructor::s_info = { "readonlyConstructor", &Base::s_info, &JSreadonlyConstructorTable, 0, CREATE_METHOD_TABLE(JSreadonlyConstructor) };
JSreadonlyConstructor::JSreadonlyConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
/* Hash table for prototype */
-static const struct CompactHashIndex JSreadonlyPrototypeTableIndex[2] = {
- { -1, -1 },
- { 0, -1 },
-};
-
-
-static const HashTableValue JSreadonlyPrototypeTableValues[1] =
+static const HashTableValue JSreadonlyPrototypeTableValues[] =
{
{ "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsreadonlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+ { 0, 0, NoIntrinsic, 0, 0 }
};
-static const HashTable JSreadonlyPrototypeTable = { 1, 1, true, JSreadonlyPrototypeTableValues, 0, JSreadonlyPrototypeTableIndex };
+static const HashTable JSreadonlyPrototypeTable = { 2, 1, true, JSreadonlyPrototypeTableValues, 0 };
const ClassInfo JSreadonlyPrototype::s_info = { "readonlyPrototype", &Base::s_info, &JSreadonlyPrototypeTable, 0, CREATE_METHOD_TABLE(JSreadonlyPrototype) };
JSObject* JSreadonlyPrototype::self(VM& vm, JSGlobalObject* globalObject)
git://git.webkit.org / WebKit-https.git / commitdiff