From 463599739485b537deca3de0fac12f6d90f63540 Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Sun, 3 Feb 2013 10:25:55 +0100 Subject: [PATCH] Rename variables and functions Prepare for merging the Array class with ArrayObject Change-Id: I03a2b10f290e18f8933efc11f83c76716e3721f4 Reviewed-by: Simon Hausmann --- src/v4/qmljs_runtime.cpp | 4 +- src/v4/qv4argumentsobject.cpp | 2 +- src/v4/qv4array.cpp | 138 +++++++++++------------ src/v4/qv4array.h | 253 +++++++++++++++++++++--------------------- src/v4/qv4arrayobject.cpp | 54 ++++----- src/v4/qv4jsonobject.cpp | 8 +- src/v4/qv4object.cpp | 22 ++-- src/v4/qv4object.h | 2 +- src/v4/qv4objectiterator.cpp | 12 +- src/v4/qv4stringobject.cpp | 12 +- 10 files changed, 253 insertions(+), 254 deletions(-) diff --git a/src/v4/qmljs_runtime.cpp b/src/v4/qmljs_runtime.cpp index 2161d89..6330435 100644 --- a/src/v4/qmljs_runtime.cpp +++ b/src/v4/qmljs_runtime.cpp @@ -596,7 +596,7 @@ Value __qmljs_get_element(ExecutionContext *ctx, Value object, Value index) Object *o = object.objectValue(); if (idx < UINT_MAX) { - const PropertyDescriptor *p = o->array.nonSparseAt(idx); + const PropertyDescriptor *p = o->array.nonSparseArrayAt(idx); if (p && p->type == PropertyDescriptor::Data) return p->value; @@ -616,7 +616,7 @@ void __qmljs_set_element(ExecutionContext *ctx, Value object, Value index, Value uint idx = index.asArrayIndex(); if (idx < UINT_MAX) { - PropertyDescriptor *p = o->array.nonSparseAtRef(idx); + PropertyDescriptor *p = o->array.nonSparseArrayAtRef(idx); if (p && p->type == PropertyDescriptor::Data && p->isWritable()) { p->value = value; return; diff --git a/src/v4/qv4argumentsobject.cpp b/src/v4/qv4argumentsobject.cpp index f732750..cb88028 100644 --- a/src/v4/qv4argumentsobject.cpp +++ b/src/v4/qv4argumentsobject.cpp @@ -82,7 +82,7 @@ ArgumentsObject::ArgumentsObject(ExecutionContext *context, int formalParameterC bool ArgumentsObject::defineOwnProperty(ExecutionContext *ctx, uint index, const PropertyDescriptor *desc) { - PropertyDescriptor *pd = array.at(index); + PropertyDescriptor *pd = array.arrayAt(index); PropertyDescriptor map; bool isMapped = false; if (pd && index < (uint)mappedArguments.size()) diff --git a/src/v4/qv4array.cpp b/src/v4/qv4array.cpp index decef65..ffefd1b 100644 --- a/src/v4/qv4array.cpp +++ b/src/v4/qv4array.cpp @@ -463,23 +463,23 @@ SparseArrayNode *SparseArray::insert(uint akey) } Array::Array(const Array &other) - : len(other.len) + : arrayLen(other.arrayLen) , arrayObject(0) - , values(other.values) - , sparse(0) + , arrayData(other.arrayData) + , sparseArray(0) { - freeList = other.freeList; - if (other.sparse) - sparse = new SparseArray(*other.sparse); + arrayFreeList = other.arrayFreeList; + if (other.sparseArray) + sparseArray = new SparseArray(*other.sparseArray); } -Value Array::indexOf(Value v, uint fromIndex, uint endIndex, ExecutionContext *ctx, Object *o) +Value Array::arrayIndexOf(Value v, uint fromIndex, uint endIndex, ExecutionContext *ctx, Object *o) { bool protoHasArray = false; Object *p = o; while ((p = p->prototype)) - if (p->array.length()) + if (p->array.arrayLength()) protoHasArray = true; if (protoHasArray) { @@ -490,100 +490,100 @@ Value Array::indexOf(Value v, uint fromIndex, uint endIndex, ExecutionContext *c if (exists && __qmljs_strict_equal(value, v)) return Value::fromDouble(i); } - } else if (sparse) { - for (SparseArrayNode *n = sparse->lowerBound(fromIndex); n && n->key() < endIndex; n = n->nextNode()) { + } else if (sparseArray) { + for (SparseArrayNode *n = sparseArray->lowerBound(fromIndex); n && n->key() < endIndex; n = n->nextNode()) { bool exists; - Value value = o->getValueChecked(ctx, descriptor(n->value), &exists); + Value value = o->getValueChecked(ctx, arrayDecriptor(n->value), &exists); if (exists && __qmljs_strict_equal(value, v)) return Value::fromDouble(n->key()); } } else { - if ((int) endIndex > values.size()) - endIndex = values.size(); - PropertyDescriptor *pd = values.data() + offset; + if ((int) endIndex > arrayData.size()) + endIndex = arrayData.size(); + PropertyDescriptor *pd = arrayData.data() + arrayOffset; PropertyDescriptor *end = pd + endIndex; pd += fromIndex; while (pd < end) { bool exists; Value value = o->getValueChecked(ctx, pd, &exists); if (exists && __qmljs_strict_equal(value, v)) - return Value::fromDouble(pd - offset - values.constData()); + return Value::fromDouble(pd - arrayOffset - arrayData.constData()); ++pd; } } return Value::fromInt32(-1); } -void Array::concat(const Array &other) +void Array::arrayConcat(const Array &other) { initSparse(); - int newLen = len + other.length(); - if (other.sparse) + int newLen = arrayLen + other.arrayLength(); + if (other.sparseArray) initSparse(); - if (sparse) { - if (other.sparse) { - for (const SparseArrayNode *it = other.sparse->begin(); it != other.sparse->end(); it = it->nextNode()) - set(len + it->key(), other.descriptor(it->value)); + if (sparseArray) { + if (other.sparseArray) { + for (const SparseArrayNode *it = other.sparseArray->begin(); it != other.sparseArray->end(); it = it->nextNode()) + arraySet(arrayLen + it->key(), other.arrayDecriptor(it->value)); } else { - int oldSize = values.size(); - values.resize(oldSize + other.length()); - memcpy(values.data() + oldSize, other.values.constData() + other.offset, other.length()*sizeof(PropertyDescriptor)); - for (uint i = 0; i < other.length(); ++i) { - SparseArrayNode *n = sparse->insert(len + i); + int oldSize = arrayData.size(); + arrayData.resize(oldSize + other.arrayLength()); + memcpy(arrayData.data() + oldSize, other.arrayData.constData() + other.arrayOffset, other.arrayLength()*sizeof(PropertyDescriptor)); + for (uint i = 0; i < other.arrayLength(); ++i) { + SparseArrayNode *n = sparseArray->insert(arrayLen + i); n->value = oldSize + i; } } } else { - int oldSize = values.size(); - values.resize(oldSize + other.length()); - memcpy(values.data() + oldSize, other.values.constData() + other.offset, other.length()*sizeof(PropertyDescriptor)); + int oldSize = arrayData.size(); + arrayData.resize(oldSize + other.arrayLength()); + memcpy(arrayData.data() + oldSize, other.arrayData.constData() + other.arrayOffset, other.arrayLength()*sizeof(PropertyDescriptor)); } - setLengthUnchecked(newLen); + setArrayLengthUnchecked(newLen); } -void Array::sort(ExecutionContext *context, Object *thisObject, const Value &comparefn, uint len) +void Array::arraySort(ExecutionContext *context, Object *thisObject, const Value &comparefn, uint len) { - if (sparse) { + if (sparseArray) { context->throwUnimplemented("Array::sort unimplemented for sparse arrays"); return; - delete sparse; + delete sparseArray; } ArrayElementLessThan lessThan(context, thisObject, comparefn); - if (len > values.size() - offset) - len = values.size() - offset; - PropertyDescriptor *begin = values.begin() + offset; + if (len > arrayData.size() - arrayOffset) + len = arrayData.size() - arrayOffset; + PropertyDescriptor *begin = arrayData.begin() + arrayOffset; std::sort(begin, begin + len, lessThan); } void Array::initSparse() { - if (!sparse) { - sparse = new SparseArray; - for (int i = offset; i < values.size(); ++i) { - SparseArrayNode *n = sparse->insert(i - offset); + if (!sparseArray) { + sparseArray = new SparseArray; + for (int i = arrayOffset; i < arrayData.size(); ++i) { + SparseArrayNode *n = sparseArray->insert(i - arrayOffset); n->value = i; } - if (offset) { - int o = offset; + if (arrayOffset) { + int o = arrayOffset; for (int i = 0; i < o - 1; ++i) { - values[i].type = PropertyDescriptor::Generic; - values[i].value = Value::fromInt32(i + 1); + arrayData[i].type = PropertyDescriptor::Generic; + arrayData[i].value = Value::fromInt32(i + 1); } - values[o - 1].type = PropertyDescriptor::Generic; - values[o - 1].value = Value::fromInt32(values.size()); - freeList = 0; + arrayData[o - 1].type = PropertyDescriptor::Generic; + arrayData[o - 1].value = Value::fromInt32(arrayData.size()); + arrayFreeList = 0; } else { - freeList = values.size(); + arrayFreeList = arrayData.size(); } } } -void Array::setLengthUnchecked(uint l) +void Array::setArrayLengthUnchecked(uint l) { - len = l; + arrayLen = l; if (arrayObject) { // length is always the first property of an array PropertyDescriptor &lengthProperty = arrayObject->memberData[ArrayObject::LengthPropertyIndex]; @@ -591,18 +591,18 @@ void Array::setLengthUnchecked(uint l) } } -bool Array::setLength(uint newLen) { +bool Array::setArrayLength(uint newLen) { const PropertyDescriptor *lengthProperty = arrayObject->memberData.constData() + ArrayObject::LengthPropertyIndex; if (lengthProperty && !lengthProperty->isWritable()) return false; - uint oldLen = length(); + uint oldLen = arrayLength(); bool ok = true; if (newLen < oldLen) { - if (sparse) { - SparseArrayNode *begin = sparse->lowerBound(newLen); - SparseArrayNode *it = sparse->end()->previousNode(); + if (sparseArray) { + SparseArrayNode *begin = sparseArray->lowerBound(newLen); + SparseArrayNode *it = sparseArray->end()->previousNode(); while (1) { - PropertyDescriptor &pd = values[it->value]; + PropertyDescriptor &pd = arrayData[it->value]; if (pd.type != PropertyDescriptor::Generic && !pd.isConfigurable()) { ok = false; newLen = it->key() + 1; @@ -610,40 +610,40 @@ bool Array::setLength(uint newLen) { } pd.type = PropertyDescriptor::Generic; pd.value.tag = Value::_Undefined_Type; - pd.value.int_32 = freeList; - freeList = it->value; + pd.value.int_32 = arrayFreeList; + arrayFreeList = it->value; bool brk = (it == begin); SparseArrayNode *prev = it->previousNode(); - sparse->erase(it); + sparseArray->erase(it); if (brk) break; it = prev; } } else { - PropertyDescriptor *it = values.data() + values.size(); - const PropertyDescriptor *begin = values.constData() + offset + newLen; + PropertyDescriptor *it = arrayData.data() + arrayData.size(); + const PropertyDescriptor *begin = arrayData.constData() + arrayOffset + newLen; while (--it >= begin) { if (it->type != PropertyDescriptor::Generic && !it->isConfigurable()) { ok = false; - newLen = it - values.data() + offset + 1; + newLen = it - arrayData.data() + arrayOffset + 1; break; } } - values.resize(newLen + offset); + arrayData.resize(newLen + arrayOffset); } } else { if (newLen >= 0x100000) initSparse(); } - setLengthUnchecked(newLen); + setArrayLengthUnchecked(newLen); return ok; } -void Array::markObjects() const +void Array::markArrayObjects() const { - uint i = sparse ? 0 : offset; - for (; i < (uint)values.size(); ++i) { - const PropertyDescriptor &pd = values.at(i); + uint i = sparseArray ? 0 : arrayOffset; + for (; i < (uint)arrayData.size(); ++i) { + const PropertyDescriptor &pd = arrayData.at(i); if (pd.isData()) { if (Managed *m = pd.value.asManaged()) m->mark(); diff --git a/src/v4/qv4array.h b/src/v4/qv4array.h index b165ed2..d0057e4 100644 --- a/src/v4/qv4array.h +++ b/src/v4/qv4array.h @@ -366,14 +366,14 @@ class Array { friend struct ArrayPrototype; - uint len; + uint arrayLen; ArrayObject *arrayObject; union { - uint freeList; - uint offset; + uint arrayFreeList; + uint arrayOffset; }; - QVector values; - SparseArray *sparse; + QVector arrayData; + SparseArray *sparseArray; void fillDescriptor(PropertyDescriptor *pd, Value v) { @@ -384,105 +384,105 @@ class Array pd->value = v; } - uint allocValue() { - uint idx = freeList; - if (values.size() <= (int)freeList) - values.resize(++freeList); + uint allocArrayValue() { + uint idx = arrayFreeList; + if (arrayData.size() <= (int)arrayFreeList) + arrayData.resize(++arrayFreeList); else - freeList = values.at(freeList).value.integerValue(); + arrayFreeList = arrayData.at(arrayFreeList).value.integerValue(); return idx; } - uint allocValue(Value v) { - uint idx = allocValue(); - PropertyDescriptor *pd = &values[idx]; + uint allocArrayValue(Value v) { + uint idx = allocArrayValue(); + PropertyDescriptor *pd = &arrayData[idx]; fillDescriptor(pd, v); return idx; } - void freeValue(int idx) { - PropertyDescriptor &pd = values[idx]; + void freeArrayValue(int idx) { + PropertyDescriptor &pd = arrayData[idx]; pd.type = PropertyDescriptor::Generic; pd.value.tag = Value::_Undefined_Type; - pd.value.int_32 = freeList; - freeList = idx; + pd.value.int_32 = arrayFreeList; + arrayFreeList = idx; } - PropertyDescriptor *descriptor(uint index) { - PropertyDescriptor *pd = values.data() + index; - if (!sparse) - pd += offset; + PropertyDescriptor *arrayDecriptor(uint index) { + PropertyDescriptor *pd = arrayData.data() + index; + if (!sparseArray) + pd += arrayOffset; return pd; } - const PropertyDescriptor *descriptor(uint index) const { - const PropertyDescriptor *pd = values.data() + index; - if (!sparse) - pd += offset; + const PropertyDescriptor *arrayDecriptor(uint index) const { + const PropertyDescriptor *pd = arrayData.data() + index; + if (!sparseArray) + pd += arrayOffset; return pd; } - void getHeadRoom() { - assert(!sparse && !offset); - offset = qMax(values.size() >> 2, 16); - QVector newValues(values.size() + offset); - memcpy(newValues.data() + offset, values.constData(), values.size()*sizeof(PropertyDescriptor)); - values = newValues; + void getArrayHeadRoom() { + assert(!sparseArray && !arrayOffset); + arrayOffset = qMax(arrayData.size() >> 2, 16); + QVector newValues(arrayData.size() + arrayOffset); + memcpy(newValues.data() + arrayOffset, arrayData.constData(), arrayData.size()*sizeof(PropertyDescriptor)); + arrayData = newValues; } public: - Array() : len(0), arrayObject(0), offset(0), sparse(0) {} + Array() : arrayLen(0), arrayObject(0), arrayOffset(0), sparseArray(0) {} Array(const Array &other); - ~Array() { delete sparse; } + ~Array() { delete sparseArray; } void initSparse(); - uint length() const { return len; } - bool setLength(uint newLen); + uint arrayLength() const { return arrayLen; } + bool setArrayLength(uint newLen); void setArrayObject(ArrayObject *a) { arrayObject = a; } - void setLengthUnchecked(uint l); + void setArrayLengthUnchecked(uint l); - PropertyDescriptor *insert(uint index) { + PropertyDescriptor *arrayInsert(uint index) { PropertyDescriptor *pd; - if (!sparse && (index < 0x1000 || index < len + (len >> 2))) { - if (index + offset >= (uint)values.size()) { - values.resize(offset + index + 1); - for (uint i = len + 1; i < index; ++i) { - values[i].type = PropertyDescriptor::Generic; - values[i].value.tag = Value::_Undefined_Type; + if (!sparseArray && (index < 0x1000 || index < arrayLen + (arrayLen >> 2))) { + if (index + arrayOffset >= (uint)arrayData.size()) { + arrayData.resize(arrayOffset + index + 1); + for (uint i = arrayLen + 1; i < index; ++i) { + arrayData[i].type = PropertyDescriptor::Generic; + arrayData[i].value.tag = Value::_Undefined_Type; } } - pd = descriptor(index); + pd = arrayDecriptor(index); } else { initSparse(); - SparseArrayNode *n = sparse->insert(index); + SparseArrayNode *n = sparseArray->insert(index); if (n->value == UINT_MAX) - n->value = allocValue(); - pd = descriptor(n->value); + n->value = allocArrayValue(); + pd = arrayDecriptor(n->value); } - if (index >= len) - setLengthUnchecked(index + 1); + if (index >= arrayLen) + setArrayLengthUnchecked(index + 1); return pd; } - void set(uint index, const PropertyDescriptor *pd) { - *insert(index) = *pd; + void arraySet(uint index, const PropertyDescriptor *pd) { + *arrayInsert(index) = *pd; } - void set(uint index, Value value) { - PropertyDescriptor *pd = insert(index); + void arraySet(uint index, Value value) { + PropertyDescriptor *pd = arrayInsert(index); fillDescriptor(pd, value); } - bool deleteIndex(uint index) { - if (index >= len) + bool deleteArrayIndex(uint index) { + if (index >= arrayLen) return true; PropertyDescriptor *pd = 0; - if (!sparse) { - pd = at(index); + if (!sparseArray) { + pd = arrayAt(index); } else { - SparseArrayNode *n = sparse->findNode(index); + SparseArrayNode *n = sparseArray->findNode(index); if (n) - pd = descriptor(n->value); + pd = arrayDecriptor(n->value); } if (!pd || pd->type == PropertyDescriptor::Generic) return true; @@ -490,144 +490,143 @@ public: return false; pd->type = PropertyDescriptor::Generic; pd->value.tag = Value::_Undefined_Type; - if (sparse) { - pd->value.int_32 = freeList; - freeList = pd - values.constData(); + if (sparseArray) { + pd->value.int_32 = arrayFreeList; + arrayFreeList = pd - arrayData.constData(); } return true; } - PropertyDescriptor *at(uint index) { - if (!sparse) { - if (index >= values.size() - offset) + PropertyDescriptor *arrayAt(uint index) { + if (!sparseArray) { + if (index >= arrayData.size() - arrayOffset) return 0; - return values.data() + index + offset; + return arrayData.data() + index + arrayOffset; } else { - SparseArrayNode *n = sparse->findNode(index); + SparseArrayNode *n = sparseArray->findNode(index); if (!n) return 0; - return values.data() + n->value; + return arrayData.data() + n->value; } } - const PropertyDescriptor *nonSparseAt(uint index) const { - if (sparse) + const PropertyDescriptor *nonSparseArrayAt(uint index) const { + if (sparseArray) return 0; - index += offset; - if (index >= (uint)values.size()) + index += arrayOffset; + if (index >= (uint)arrayData.size()) return 0; - return values.constData() + index; + return arrayData.constData() + index; } - PropertyDescriptor *nonSparseAtRef(uint index) { - if (sparse) + PropertyDescriptor *nonSparseArrayAtRef(uint index) { + if (sparseArray) return 0; - index += offset; - if (index >= (uint)values.size()) + index += arrayOffset; + if (index >= (uint)arrayData.size()) return 0; - return values.data() + index; + return arrayData.data() + index; } - const PropertyDescriptor *at(uint index) const { - if (!sparse) { - if (index >= values.size() - offset) + const PropertyDescriptor *arrayAt(uint index) const { + if (!sparseArray) { + if (index >= arrayData.size() - arrayOffset) return 0; - return values.constData() + index + offset; + return arrayData.constData() + index + arrayOffset; } else { - SparseArrayNode *n = sparse->findNode(index); + SparseArrayNode *n = sparseArray->findNode(index); if (!n) return 0; - return values.constData() + n->value; + return arrayData.constData() + n->value; } } - void markObjects() const; + void markArrayObjects() const; void push_front(Value v) { - if (!sparse) { - if (!offset) - getHeadRoom(); + if (!sparseArray) { + if (!arrayOffset) + getArrayHeadRoom(); - --offset; + --arrayOffset; PropertyDescriptor &pd = values[offset]; fillDescriptor(&pd, v); } else { - uint idx = allocValue(v); - sparse->push_front(idx); + uint idx = allocArrayValue(v); + sparseArray->push_front(idx); } - setLengthUnchecked(len + 1); + setArrayLengthUnchecked(arrayLen + 1); } PropertyDescriptor *front() { PropertyDescriptor *pd = 0; - if (!sparse) { - if (len) - pd = values.data() + offset; + if (!sparseArray) { + if (arrayLen) + pd = arrayData.data() + arrayOffset; } else { - SparseArrayNode *n = sparse->findNode(0); + SparseArrayNode *n = sparseArray->findNode(0); if (n) - pd = descriptor(n->value); + pd = arrayDecriptor(n->value); } if (pd && pd->type == PropertyDescriptor::Generic) return 0; return pd; } void pop_front() { - if (!len) + if (!arrayLen) return; - if (!sparse) { - ++offset; + if (!sparseArray) { + ++arrayOffset; } else { - uint idx = sparse->pop_front(); - freeValue(idx); + uint idx = sparseArray->pop_front(); + freeArrayValue(idx); } - setLengthUnchecked(len - 1); + setArrayLengthUnchecked(arrayLen - 1); } void push_back(Value v) { - if (!sparse) { - if (len + offset >= (uint)values.size()) - values.resize(values.size() + 1); - PropertyDescriptor &pd = values[len + offset]; + if (!sparseArray) { + PropertyDescriptor pd; fillDescriptor(&pd, v); + arrayData.append(pd); } else { - uint idx = allocValue(v); - sparse->push_back(idx, len); + uint idx = allocArrayValue(v); + sparseArray->push_back(idx, arrayLen); } - setLengthUnchecked(len + 1); + setArrayLengthUnchecked(arrayLen + 1); } PropertyDescriptor *back() { PropertyDescriptor *pd = 0; - if (!sparse) { - if (len) - pd = values.data() + offset + len; + if (!sparseArray) { + if (arrayLen) + pd = arrayData.data() + arrayOffset + arrayLen; } else { - SparseArrayNode *n = sparse->findNode(len - 1); + SparseArrayNode *n = sparseArray->findNode(arrayLen - 1); if (n) - pd = descriptor(n->value); + pd = arrayDecriptor(n->value); } if (pd && pd->type == PropertyDescriptor::Generic) return 0; return pd; } void pop_back() { - if (!len) + if (!arrayLen) return; - if (!sparse) { - values.resize(values.size() - 1); + if (!sparseArray) { + arrayData.resize(arrayData.size() - 1); } else { - uint idx = sparse->pop_back(len); + uint idx = sparseArray->pop_back(arrayLen); if (idx != UINT_MAX) - freeValue(idx); + freeArrayValue(idx); } - setLengthUnchecked(len - 1); + setArrayLengthUnchecked(arrayLen - 1); } - SparseArrayNode *sparseLowerBound(uint idx) { return sparse ? sparse->lowerBound(idx) : 0; } - SparseArrayNode *sparseBegin() { return sparse ? sparse->begin() : 0; } - SparseArrayNode *sparseEnd() { return sparse ? sparse->end() : 0; } + SparseArrayNode *sparseArrayLowerBound(uint idx) { return sparseArray ? sparseArray->lowerBound(idx) : 0; } + SparseArrayNode *sparseArrayBegin() { return sparseArray ? sparseArray->begin() : 0; } + SparseArrayNode *sparseArrayEnd() { return sparseArray ? sparseArray->end() : 0; } - void concat(const Array &other); - void sort(ExecutionContext *context, Object *thisObject, const Value &comparefn, uint len); - Value indexOf(Value v, uint fromIndex, uint len, ExecutionContext *ctx, Object *o); + void arrayConcat(const Array &other); + void arraySort(ExecutionContext *context, Object *thisObject, const Value &comparefn, uint arrayLen); + Value arrayIndexOf(Value v, uint fromIndex, uint arrayLen, ExecutionContext *ctx, Object *o); }; } diff --git a/src/v4/qv4arrayobject.cpp b/src/v4/qv4arrayobject.cpp index 680a373..b24ca32 100644 --- a/src/v4/qv4arrayobject.cpp +++ b/src/v4/qv4arrayobject.cpp @@ -62,10 +62,10 @@ Value ArrayCtor::call(ExecutionContext *ctx) return Value::undefinedValue(); } - value.setLengthUnchecked(len); + value.setArrayLengthUnchecked(len); } else { for (unsigned int i = 0; i < ctx->argumentCount; ++i) { - value.set(i, ctx->argument(i)); + value.arraySet(i, ctx->argument(i)); } } @@ -104,7 +104,7 @@ void ArrayPrototype::init(ExecutionContext *ctx, const Value &ctor) uint ArrayPrototype::getLength(ExecutionContext *ctx, Object *o) { if (o->isArrayObject()) - return o->array.length(); + return o->array.arrayLength(); return o->__get__(ctx, ctx->engine->id_length).toUInt32(ctx); } @@ -133,18 +133,18 @@ Value ArrayPrototype::method_concat(ExecutionContext *ctx) result = instance->array; else { QString v = ctx->thisObject.toString(ctx)->toQString(); - result.set(0, Value::fromString(ctx, v)); + result.arraySet(0, Value::fromString(ctx, v)); } for (uint i = 0; i < ctx->argumentCount; ++i) { - quint32 k = result.length(); + quint32 k = result.arrayLength(); Value arg = ctx->argument(i); if (ArrayObject *elt = arg.asArrayObject()) - result.concat(elt->array); + result.arrayConcat(elt->array); else - result.set(k, arg); + result.arraySet(k, arg); } return Value::fromObject(ctx->engine->newArrayObject(ctx, result)); @@ -176,7 +176,7 @@ Value ArrayPrototype::method_join(ExecutionContext *ctx) // ### FIXME if (ArrayObject *a = self.asArrayObject()) { - for (uint i = 0; i < a->array.length(); ++i) { + for (uint i = 0; i < a->array.arrayLength(); ++i) { if (i) R += r4; @@ -222,7 +222,7 @@ Value ArrayPrototype::method_pop(ExecutionContext *ctx) instance->__delete__(ctx, len - 1); if (instance->isArrayObject()) - instance->array.setLengthUnchecked(len - 1); + instance->array.setArrayLengthUnchecked(len - 1); else instance->__put__(ctx, ctx->engine->id_length, Value::fromDouble(len - 1)); return result; @@ -251,10 +251,10 @@ Value ArrayPrototype::method_push(ExecutionContext *ctx) bool protoHasArray = false; Object *p = instance; while ((p = p->prototype)) - if (p->array.length()) + if (p->array.arrayLength()) protoHasArray = true; - if (!protoHasArray && len == instance->array.length()) { + if (!protoHasArray && len == instance->array.arrayLength()) { for (uint i = 0; i < ctx->argumentCount; ++i) { Value v = ctx->argument(i); instance->array.push_back(v); @@ -312,10 +312,10 @@ Value ArrayPrototype::method_shift(ExecutionContext *ctx) bool protoHasArray = false; Object *p = instance; while ((p = p->prototype)) - if (p->array.length()) + if (p->array.arrayLength()) protoHasArray = true; - if (!protoHasArray && len >= instance->array.length()) { + if (!protoHasArray && len >= instance->array.arrayLength()) { instance->array.pop_front(); } else { // do it the slow way @@ -365,7 +365,7 @@ Value ArrayPrototype::method_slice(ExecutionContext *ctx) bool exists; Value v = o->__get__(ctx, i, &exists); if (exists) - result.set(n, v); + result.arraySet(n, v); ++n; } return Value::fromObject(ctx->engine->newArrayObject(ctx, result)); @@ -378,7 +378,7 @@ Value ArrayPrototype::method_sort(ExecutionContext *ctx) uint len = getLength(ctx, instance); Value comparefn = ctx->argument(0); - instance->array.sort(ctx, instance, comparefn, len); + instance->array.arraySort(ctx, instance, comparefn, len); return ctx->thisObject; } @@ -398,8 +398,8 @@ Value ArrayPrototype::method_splice(ExecutionContext *ctx) uint deleteCount = (uint)qMin(qMax(ctx->argument(1).toInteger(ctx), 0.), (double)(len - start)); - newArray->array.values.resize(deleteCount); - PropertyDescriptor *pd = newArray->array.values.data(); + newArray->array.arrayData.resize(deleteCount); + PropertyDescriptor *pd = newArray->array.arrayData.data(); for (uint i = 0; i < deleteCount; ++i) { pd->type = PropertyDescriptor::Data; pd->writable = PropertyDescriptor::Enabled; @@ -408,7 +408,7 @@ Value ArrayPrototype::method_splice(ExecutionContext *ctx) pd->value = instance->__get__(ctx, start + i); ++pd; } - newArray->array.setLengthUnchecked(deleteCount); + newArray->array.setArrayLengthUnchecked(deleteCount); uint itemCount = ctx->argumentCount < 2 ? 0 : ctx->argumentCount - 2; @@ -417,7 +417,7 @@ Value ArrayPrototype::method_splice(ExecutionContext *ctx) bool exists; Value v = instance->__get__(ctx, k + deleteCount, &exists); if (exists) - instance->array.set(k + itemCount, v); + instance->array.arraySet(k + itemCount, v); else instance->__delete__(ctx, k + itemCount); } @@ -429,7 +429,7 @@ Value ArrayPrototype::method_splice(ExecutionContext *ctx) bool exists; Value v = instance->__get__(ctx, k + deleteCount - 1, &exists); if (exists) - instance->array.set(k + itemCount - 1, v); + instance->array.arraySet(k + itemCount - 1, v); else instance->__delete__(ctx, k + itemCount - 1); --k; @@ -437,7 +437,7 @@ Value ArrayPrototype::method_splice(ExecutionContext *ctx) } for (uint i = 0; i < itemCount; ++i) - instance->array.set(start + i, ctx->argument(i + 2)); + instance->array.arraySet(start + i, ctx->argument(i + 2)); ctx->strictMode = true; instance->__put__(ctx, ctx->engine->id_length, Value::fromDouble(len - deleteCount + itemCount)); @@ -453,10 +453,10 @@ Value ArrayPrototype::method_unshift(ExecutionContext *ctx) bool protoHasArray = false; Object *p = instance; while ((p = p->prototype)) - if (p->array.length()) + if (p->array.arrayLength()) protoHasArray = true; - if (!protoHasArray && len >= instance->array.length()) { + if (!protoHasArray && len >= instance->array.arrayLength()) { for (int i = ctx->argumentCount - 1; i >= 0; --i) { Value v = ctx->argument(i); instance->array.push_front(v); @@ -516,7 +516,7 @@ Value ArrayPrototype::method_indexOf(ExecutionContext *ctx) return Value::fromInt32(-1); } - return instance->array.indexOf(searchValue, fromIndex, len, ctx, instance); + return instance->array.arrayIndexOf(searchValue, fromIndex, len, ctx, instance); } Value ArrayPrototype::method_lastIndexOf(ExecutionContext *ctx) @@ -654,7 +654,7 @@ Value ArrayPrototype::method_map(ExecutionContext *ctx) Value thisArg = ctx->argument(1); ArrayObject *a = ctx->engine->newArrayObject(ctx); - a->array.setLengthUnchecked(len); + a->array.setArrayLengthUnchecked(len); for (uint k = 0; k < len; ++k) { bool exists; @@ -667,7 +667,7 @@ Value ArrayPrototype::method_map(ExecutionContext *ctx) args[1] = Value::fromDouble(k); args[2] = ctx->thisObject; Value mapped = callback->call(ctx, thisArg, args, 3); - a->array.set(k, mapped); + a->array.arraySet(k, mapped); } return Value::fromObject(a); } @@ -699,7 +699,7 @@ Value ArrayPrototype::method_filter(ExecutionContext *ctx) args[2] = ctx->thisObject; Value selected = callback->call(ctx, thisArg, args, 3); if (__qmljs_to_boolean(selected, ctx)) { - a->array.set(to, v); + a->array.arraySet(to, v); ++to; } } diff --git a/src/v4/qv4jsonobject.cpp b/src/v4/qv4jsonobject.cpp index 5c0027f..c5df590 100644 --- a/src/v4/qv4jsonobject.cpp +++ b/src/v4/qv4jsonobject.cpp @@ -314,7 +314,7 @@ Value Parser::parseArray() Value val; if (!parseValue(&val)) return Value::undefinedValue(); - array.set(index, val); + array.arraySet(index, val); QChar token = nextToken(); if (token == EndArray) break; @@ -329,7 +329,7 @@ Value Parser::parseArray() } } - DEBUG << "size =" << array.length(); + DEBUG << "size =" << array.arrayLength(); END; --nestingLevel; @@ -832,7 +832,7 @@ QString Stringify::JA(ArrayObject *a) indent += gap; QStringList partial; - uint len = a->array.length(); + uint len = a->array.arrayLength(); for (uint i = 0; i < len; ++i) { bool exists; Value v = a->__get__(ctx, i, &exists); @@ -897,7 +897,7 @@ Value JsonObject::method_stringify(ExecutionContext *ctx) if (o) { stringify.replacerFunction = o->asFunctionObject(); if (o->isArrayObject()) { - for (uint i = 0; i < o->array.length(); ++i) { + for (uint i = 0; i < o->array.arrayLength(); ++i) { Value v = o->__get__(ctx, i); if (v.asNumberObject() || v.asStringObject() || v.isNumber()) v = __qmljs_to_string(v, ctx); diff --git a/src/v4/qv4object.cpp b/src/v4/qv4object.cpp index 5903df4..e2e49eb 100644 --- a/src/v4/qv4object.cpp +++ b/src/v4/qv4object.cpp @@ -201,7 +201,7 @@ void Object::markObjects() } } } - array.markObjects(); + array.markArrayObjects(); } PropertyDescriptor *Object::insertMember(String *s) @@ -234,7 +234,7 @@ PropertyDescriptor *Object::__getOwnProperty__(ExecutionContext *ctx, String *na PropertyDescriptor *Object::__getOwnProperty__(ExecutionContext *ctx, uint index) { - PropertyDescriptor *p = array.at(index); + PropertyDescriptor *p = array.arrayAt(index); if(p && p->type != PropertyDescriptor::Generic) return p; if (isStringObject()) @@ -267,7 +267,7 @@ PropertyDescriptor *Object::__getPropertyDescriptor__(ExecutionContext *ctx, uin { Object *o = this; while (o) { - PropertyDescriptor *p = o->array.at(index); + PropertyDescriptor *p = o->array.arrayAt(index); if(p && p->type != PropertyDescriptor::Generic) return p; if (o->isStringObject()) { @@ -318,7 +318,7 @@ Value Object::__get__(ExecutionContext *ctx, uint index, bool *hasProperty) PropertyDescriptor *pd = 0; Object *o = this; while (o) { - PropertyDescriptor *p = o->array.at(index); + PropertyDescriptor *p = o->array.arrayAt(index); if (p && p->type != PropertyDescriptor::Generic) { pd = p; break; @@ -368,7 +368,7 @@ void Object::__put__(ExecutionContext *ctx, String *name, Value value) uint l = value.asArrayLength(ctx, &ok); if (!ok) ctx->throwRangeError(value); - ok = array.setLength(l); + ok = array.setArrayLength(l); if (!ok) goto reject; } else { @@ -480,7 +480,7 @@ void Object::__put__(ExecutionContext *ctx, uint index, Value value) return; } - array.set(index, value); + array.arraySet(index, value); return; reject: @@ -505,7 +505,7 @@ bool Object::__hasProperty__(const ExecutionContext *ctx, String *name) const bool Object::__hasProperty__(const ExecutionContext *ctx, uint index) const { - const PropertyDescriptor *p = array.at(index); + const PropertyDescriptor *p = array.arrayAt(index); if (p && p->type != PropertyDescriptor::Generic) return true; @@ -541,7 +541,7 @@ bool Object::__delete__(ExecutionContext *ctx, String *name) bool Object::__delete__(ExecutionContext *ctx, uint index) { - if (array.deleteIndex(index)) + if (array.deleteArrayIndex(index)) return true; if (ctx->strictMode) __qmljs_throw_type_error(ctx); @@ -572,7 +572,7 @@ bool Object::__defineOwnProperty__(ExecutionContext *ctx, String *name, const Pr uint l = desc->value.asArrayLength(ctx, &ok); if (!ok) ctx->throwRangeError(desc->value); - succeeded = array.setLength(l); + succeeded = array.setArrayLength(l); } if (desc->writable == PropertyDescriptor::Disabled) lp->writable = PropertyDescriptor::Disabled; @@ -609,7 +609,7 @@ bool Object::__defineOwnProperty__(ExecutionContext *ctx, uint index, const Prop PropertyDescriptor *current; // 15.4.5.1, 4b - if (isArrayObject() && index >= array.length() && !memberData.at(ArrayObject::LengthPropertyIndex).isWritable()) + if (isArrayObject() && index >= array.arrayLength() && !memberData.at(ArrayObject::LengthPropertyIndex).isWritable()) goto reject; if (isNonStrictArgumentsObject) @@ -622,7 +622,7 @@ bool Object::__defineOwnProperty__(ExecutionContext *ctx, uint index, const Prop if (!extensible) goto reject; // clause 4 - PropertyDescriptor *pd = array.insert(index); + PropertyDescriptor *pd = array.arrayInsert(index); *pd = *desc; pd->fullyPopulated(); return true; diff --git a/src/v4/qv4object.h b/src/v4/qv4object.h index dd67bee..d8c0e56 100644 --- a/src/v4/qv4object.h +++ b/src/v4/qv4object.h @@ -189,7 +189,7 @@ struct ArrayObject: Object { }; ArrayObject(ExecutionContext *ctx) { init(ctx); } - ArrayObject(ExecutionContext *ctx, const Array &value): Object(value) { init(ctx); array.setLengthUnchecked(array.length()); } + ArrayObject(ExecutionContext *ctx, const Array &value): Object(value) { init(ctx); array.setArrayLengthUnchecked(array.arrayLength()); } void init(ExecutionContext *context); }; diff --git a/src/v4/qv4objectiterator.cpp b/src/v4/qv4objectiterator.cpp index 62f3c30..ecbeaec 100644 --- a/src/v4/qv4objectiterator.cpp +++ b/src/v4/qv4objectiterator.cpp @@ -76,20 +76,20 @@ PropertyDescriptor *ObjectIterator::next(String **name, uint *index) return s->__getOwnProperty__(context, *index); } flags &= ~CurrentIsString; - arrayNode = current->array.sparseBegin(); + arrayNode = current->array.sparseArrayBegin(); // iterate until we're past the end of the string while (arrayNode && arrayNode->key() < slen) arrayNode = arrayNode->nextNode(); } if (!arrayIndex) - arrayNode = current->array.sparseBegin(); + arrayNode = current->array.sparseArrayBegin(); // sparse arrays if (arrayNode) { - while (arrayNode != current->array.sparseEnd()) { + while (arrayNode != current->array.sparseArrayEnd()) { int k = arrayNode->key(); - p = current->array.at(k); + p = current->array.arrayAt(k); arrayNode = arrayNode->nextNode(); if (p && (!(flags & EnumberableOnly) || p->isEnumerable())) { arrayIndex = k + 1; @@ -101,8 +101,8 @@ PropertyDescriptor *ObjectIterator::next(String **name, uint *index) arrayIndex = UINT_MAX; } // dense arrays - while (arrayIndex < current->array.length()) { - p = current->array.at(arrayIndex); + while (arrayIndex < current->array.arrayLength()) { + p = current->array.arrayAt(arrayIndex); ++arrayIndex; if (p && p->type != PropertyDescriptor::Generic && (!(flags & EnumberableOnly) || p->isEnumerable())) { *index = arrayIndex - 1; diff --git a/src/v4/qv4stringobject.cpp b/src/v4/qv4stringobject.cpp index 788d6cd..a026e46 100644 --- a/src/v4/qv4stringobject.cpp +++ b/src/v4/qv4stringobject.cpp @@ -337,7 +337,7 @@ Value StringPrototype::method_match(ExecutionContext *parentCtx, Value thisObjec previousLastIndex = thisIndex; } Value matchStr = result.objectValue()->__get__(parentCtx, (uint)0, (bool *)0); - a->array.set(n, matchStr); + a->array.arraySet(n, matchStr); ++n; } if (!n) @@ -572,18 +572,18 @@ Value StringPrototype::method_split(ExecutionContext *ctx) array->array.push_back(Value::fromString(ctx, text.mid(offset, matchOffsets[0] - offset))); offset = qMax(offset + 1, matchOffsets[1]); - if (array->array.length() >= limit) + if (array->array.arrayLength() >= limit) break; for (int i = 1; i < re->value->captureCount(); ++i) { uint start = matchOffsets[i * 2]; uint end = matchOffsets[i * 2 + 1]; array->array.push_back(Value::fromString(ctx, text.mid(start, end - start))); - if (array->array.length() >= limit) + if (array->array.arrayLength() >= limit) break; } } - if (array->array.length() < limit) + if (array->array.arrayLength() < limit) array->array.push_back(Value::fromString(ctx, text.mid(offset))); } else { QString separator = separatorValue.toString(ctx)->toQString(); @@ -598,10 +598,10 @@ Value StringPrototype::method_split(ExecutionContext *ctx) while ((end = text.indexOf(separator, start)) != -1) { array->array.push_back(Value::fromString(ctx, text.mid(start, end - start))); start = end + separator.size(); - if (array->array.length() >= limit) + if (array->array.arrayLength() >= limit) break; } - if (array->array.length() < limit && start != -1) + if (array->array.arrayLength() < limit && start != -1) array->array.push_back(Value::fromString(ctx, text.mid(start))); } return result; -- 2.7.4