mirror of
https://gitee.com/openharmony/arkcompiler_ets_runtime
synced 2025-04-14 05:30:54 +00:00
515 lines
23 KiB
C++
515 lines
23 KiB
C++
/*
|
|
* Copyright (c) 2022-2024 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "ecmascript/js_api/js_api_lightweightmap.h"
|
|
|
|
#include "ecmascript/containers/containers_errors.h"
|
|
#include "ecmascript/js_object-inl.h"
|
|
|
|
#include <codecvt>
|
|
|
|
namespace panda::ecmascript {
|
|
using ContainerError = containers::ContainerError;
|
|
using ErrorFlag = containers::ErrorFlag;
|
|
JSTaggedValue JSAPILightWeightMap::IncreaseCapacityTo(JSThread *thread,
|
|
const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index)
|
|
{
|
|
uint32_t num = lightWeightMap->GetSize();
|
|
if (index < DEFAULT_CAPACITY_LENGTH || static_cast<int32_t>(num) >= index) {
|
|
return JSTaggedValue::False();
|
|
}
|
|
JSHandle<TaggedArray> hashArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::HASH);
|
|
JSHandle<TaggedArray> keyArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::KEY);
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
JSHandle<TaggedArray> newHashArray = GrowCapacity(thread, hashArray, index);
|
|
JSHandle<TaggedArray> newKeyArray = GrowCapacity(thread, keyArray, index);
|
|
JSHandle<TaggedArray> newValueArray = GrowCapacity(thread, valueArray, index);
|
|
lightWeightMap->SetHashes(thread, newHashArray);
|
|
lightWeightMap->SetKeys(thread, newKeyArray);
|
|
lightWeightMap->SetValues(thread, newValueArray);
|
|
return JSTaggedValue::True();
|
|
}
|
|
|
|
void JSAPILightWeightMap::InsertValue(const JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index, const JSHandle<JSTaggedValue> &value, AccossorsKind kind)
|
|
{
|
|
JSHandle<TaggedArray> array = GetArrayByKind(thread, lightWeightMap, kind);
|
|
uint32_t len = lightWeightMap->GetSize();
|
|
JSHandle<TaggedArray> newArray = GrowCapacity(thread, array, len + 1);
|
|
TaggedArray::InsertElementByIndex(thread, newArray, value, index, len);
|
|
SetArrayByKind(thread, lightWeightMap, newArray, kind);
|
|
}
|
|
|
|
void JSAPILightWeightMap::ReplaceValue(const JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index, const JSHandle<JSTaggedValue> &value, AccossorsKind kind)
|
|
{
|
|
JSHandle<TaggedArray> array = GetArrayByKind(thread, lightWeightMap, kind);
|
|
ASSERT(0 <= index || index < static_cast<int32_t>(lightWeightMap->GetSize()));
|
|
array->Set(thread, index, value.GetTaggedValue());
|
|
}
|
|
|
|
void JSAPILightWeightMap::RemoveValue(const JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
uint32_t index, AccossorsKind kind)
|
|
{
|
|
JSHandle<TaggedArray> array = GetArrayByKind(thread, lightWeightMap, kind);
|
|
uint32_t len = lightWeightMap->GetLength();
|
|
ASSERT(index < len);
|
|
TaggedArray::RemoveElementByIndex(thread, array, index, len);
|
|
}
|
|
|
|
void JSAPILightWeightMap::Set(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key, const JSHandle<JSTaggedValue> &value)
|
|
{
|
|
KeyState keyState = GetStateOfKey(thread, lightWeightMap, key);
|
|
int32_t index = keyState.index;
|
|
if (keyState.existed) {
|
|
ReplaceValue(thread, lightWeightMap, index, value, AccossorsKind::VALUE);
|
|
} else {
|
|
JSHandle<JSTaggedValue> hashHandle(thread, JSTaggedValue(keyState.hash));
|
|
InsertValue(thread, lightWeightMap, index, hashHandle, AccossorsKind::HASH);
|
|
InsertValue(thread, lightWeightMap, index, key, AccossorsKind::KEY);
|
|
InsertValue(thread, lightWeightMap, index, value, AccossorsKind::VALUE);
|
|
lightWeightMap->SetLength(lightWeightMap->GetLength() + 1);
|
|
}
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::Get(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key)
|
|
{
|
|
int32_t index = GetIndexOfKey(thread, lightWeightMap, key);
|
|
if (index < 0) {
|
|
return JSTaggedValue::Undefined();
|
|
}
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
return valueArray->Get(index);
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::HasAll(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSAPILightWeightMap> &newLightWeightMap)
|
|
{
|
|
uint32_t length = newLightWeightMap->GetSize();
|
|
uint32_t len = lightWeightMap->GetSize();
|
|
if (length > len) {
|
|
return JSTaggedValue::False();
|
|
}
|
|
JSHandle<TaggedArray> oldHashArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::HASH);
|
|
JSHandle<TaggedArray> oldKeyArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::KEY);
|
|
JSHandle<TaggedArray> oldValueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
JSHandle<TaggedArray> newKeyArray = GetArrayByKind(thread, newLightWeightMap, AccossorsKind::KEY);
|
|
JSHandle<TaggedArray> newValueArray = GetArrayByKind(thread, newLightWeightMap, AccossorsKind::VALUE);
|
|
JSTaggedValue dealKey = JSTaggedValue::Undefined();
|
|
int32_t index = -1;
|
|
int32_t hash = 0;
|
|
|
|
for (uint32_t num = 0; num < length; num++) {
|
|
dealKey = newKeyArray->Get(num);
|
|
hash = Hash(thread, dealKey);
|
|
index = BinarySearchHashes(oldHashArray, hash, static_cast<int32_t>(len));
|
|
if (index < 0 || index >= static_cast<int32_t>(len)) {
|
|
return JSTaggedValue::False();
|
|
}
|
|
HashParams params { oldHashArray, oldKeyArray, &dealKey };
|
|
index = AvoidHashCollision(params, index, len, hash);
|
|
if (!JSTaggedValue::SameValue(oldKeyArray->Get(index), dealKey) ||
|
|
!JSTaggedValue::SameValue(oldValueArray->Get(index), newValueArray->Get(num))) {
|
|
// avoid Hash collision
|
|
return JSTaggedValue::False();
|
|
}
|
|
}
|
|
return JSTaggedValue::True();
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::HasKey(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key)
|
|
{
|
|
KeyState keyState = GetStateOfKey(thread, lightWeightMap, key);
|
|
return keyState.existed ? JSTaggedValue::True() : JSTaggedValue::False();
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::HasValue(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &value)
|
|
{
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
uint32_t length = lightWeightMap->GetSize();
|
|
for (uint32_t num = 0; num < length; num++) {
|
|
if (JSTaggedValue::SameValue(valueArray->Get(num), value.GetTaggedValue())) {
|
|
return JSTaggedValue::True();
|
|
}
|
|
}
|
|
return JSTaggedValue::False();
|
|
}
|
|
|
|
int32_t JSAPILightWeightMap::GetIndexOfKey(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key)
|
|
{
|
|
KeyState keyState = GetStateOfKey(thread, lightWeightMap, key);
|
|
return keyState.existed ? keyState.index : -1;
|
|
}
|
|
|
|
KeyState JSAPILightWeightMap::GetStateOfKey(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key)
|
|
{
|
|
int32_t hash = Hash(thread, key.GetTaggedValue());
|
|
int32_t length = static_cast<int32_t>(lightWeightMap->GetSize());
|
|
JSHandle<TaggedArray> hashArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::HASH);
|
|
int32_t index = BinarySearchHashes(hashArray, hash, length);
|
|
if (index >= 0) {
|
|
// avoid Hash Collision
|
|
JSHandle<TaggedArray> keyArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::KEY);
|
|
int32_t right = index;
|
|
while ((right < length) && (hashArray->Get(right).GetInt() == hash)) {
|
|
if (JSTaggedValue::SameValue(keyArray->Get(right), key.GetTaggedValue())) {
|
|
return KeyState {true, hash, right};
|
|
}
|
|
right++;
|
|
}
|
|
int32_t left = index - 1;
|
|
while ((left >= 0) && ((hashArray->Get(left).GetInt() == hash))) {
|
|
if (JSTaggedValue::SameValue(keyArray->Get(left), key.GetTaggedValue())) {
|
|
return KeyState {true, hash, left};
|
|
}
|
|
left--;
|
|
}
|
|
return KeyState {false, hash, right}; // first index whose element is bigger than hash
|
|
}
|
|
return KeyState {false, hash, index ^ HASH_REBELLION}; // first index whose element is bigger than hash
|
|
}
|
|
|
|
int32_t JSAPILightWeightMap::GetIndexOfValue(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &value)
|
|
{
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
uint32_t length = lightWeightMap->GetSize();
|
|
JSTaggedValue compValue = value.GetTaggedValue();
|
|
for (uint32_t i = 0; i < length; i++) {
|
|
if (valueArray->Get(i) == compValue) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1; // not find, default return -1
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::GetKeyAt(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index)
|
|
{
|
|
int32_t length = static_cast<int32_t>(lightWeightMap->GetSize());
|
|
if (length <= 0) {
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, "Container is empty");
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
if (index < 0 || length <= index) {
|
|
std::ostringstream oss;
|
|
oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
|
|
<< ". Received value is: " << index;
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
JSHandle<TaggedArray> keyArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::KEY);
|
|
return keyArray->Get(index);
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::GetValueAt(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index)
|
|
{
|
|
int32_t length = static_cast<int32_t>(lightWeightMap->GetSize());
|
|
if (length <= 0) {
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, "Container is empty");
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
if (index < 0 || length <= index) {
|
|
std::ostringstream oss;
|
|
oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
|
|
<< ". Received value is: " << index;
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
return valueArray->Get(index);
|
|
}
|
|
|
|
void JSAPILightWeightMap::SetAll(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSAPILightWeightMap> &needLightWeightMap)
|
|
{
|
|
JSHandle<TaggedArray> needKeyArray = GetArrayByKind(thread, needLightWeightMap, AccossorsKind::KEY);
|
|
JSHandle<TaggedArray> needValueArray = GetArrayByKind(thread, needLightWeightMap, AccossorsKind::VALUE);
|
|
JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
|
|
JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
|
|
uint32_t length = needLightWeightMap->GetSize();
|
|
for (uint32_t num = 0; num < length; num++) {
|
|
key.Update(needKeyArray->Get(num));
|
|
value.Update(needValueArray->Get(num));
|
|
JSAPILightWeightMap::Set(thread, lightWeightMap, key, value);
|
|
}
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::Remove(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<JSTaggedValue> &key)
|
|
{
|
|
KeyState keyState = GetStateOfKey(thread, lightWeightMap, key);
|
|
if (!keyState.existed) {
|
|
return JSTaggedValue::Undefined();
|
|
}
|
|
int32_t index = keyState.index;
|
|
JSHandle<TaggedArray> valueArray = GetArrayByKind(thread, lightWeightMap, AccossorsKind::VALUE);
|
|
JSTaggedValue value = valueArray->Get(index);
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::HASH);
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::VALUE);
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::KEY);
|
|
ASSERT(lightWeightMap->GetLength() > 0);
|
|
lightWeightMap->SetLength(lightWeightMap->GetLength() - 1);
|
|
return value;
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::RemoveAt(JSThread *thread,
|
|
const JSHandle<JSAPILightWeightMap> &lightWeightMap, int32_t index)
|
|
{
|
|
uint32_t length = lightWeightMap->GetSize();
|
|
if (index < 0 || static_cast<int32_t>(length) <= index) {
|
|
return JSTaggedValue::False();
|
|
}
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::HASH);
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::VALUE);
|
|
RemoveValue(thread, lightWeightMap, index, AccossorsKind::KEY);
|
|
lightWeightMap->SetLength(length - 1);
|
|
return JSTaggedValue::True();
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::IsEmpty()
|
|
{
|
|
if (GetLength() == 0) {
|
|
return JSTaggedValue::True();
|
|
} else {
|
|
return JSTaggedValue::False();
|
|
}
|
|
}
|
|
|
|
void JSAPILightWeightMap::Clear(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap)
|
|
{
|
|
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
|
JSHandle<TaggedArray> hashArray = factory->NewTaggedArray(DEFAULT_CAPACITY_LENGTH);
|
|
JSHandle<TaggedArray> keyArray = factory->NewTaggedArray(DEFAULT_CAPACITY_LENGTH);
|
|
JSHandle<TaggedArray> valueArray = factory->NewTaggedArray(DEFAULT_CAPACITY_LENGTH);
|
|
lightWeightMap->SetHashes(thread, hashArray.GetTaggedValue());
|
|
lightWeightMap->SetKeys(thread, keyArray.GetTaggedValue());
|
|
lightWeightMap->SetValues(thread, valueArray.GetTaggedValue());
|
|
lightWeightMap->SetLength(0);
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::SetValueAt(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
int32_t index, const JSHandle<JSTaggedValue> &value)
|
|
{
|
|
int32_t length = static_cast<int32_t>(lightWeightMap->GetSize());
|
|
if (length <= 0) {
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, "Container is empty");
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
if (index < 0 || length <= index) {
|
|
std::ostringstream oss;
|
|
oss << "The value of \"index\" is out of range. It must be >= 0 && <= " << (length - 1)
|
|
<< ". Received value is: " << index;
|
|
JSTaggedValue error = ContainerError::BusinessError(thread, ErrorFlag::RANGE_ERROR, oss.str().c_str());
|
|
THROW_NEW_ERROR_AND_RETURN_VALUE(thread, error, JSTaggedValue::Exception());
|
|
}
|
|
ReplaceValue(thread, lightWeightMap, index, value, AccossorsKind::VALUE);
|
|
return JSTaggedValue::True();
|
|
}
|
|
|
|
int32_t JSAPILightWeightMap::AvoidHashCollision(HashParams ¶ms, int32_t index, uint32_t size, int32_t hash)
|
|
{
|
|
int32_t right = index;
|
|
while ((right < static_cast<int32_t>(size)) && ((params.hashArray)->Get(right).GetInt() == hash)) {
|
|
if (JSTaggedValue::SameValue((params.keyArray)->Get(right), *(params.key))) {
|
|
return right;
|
|
}
|
|
right++;
|
|
}
|
|
int32_t left = index - 1;
|
|
while ((left >= 0) && ((params.hashArray)->Get(left).GetInt() == hash)) {
|
|
if (JSTaggedValue::SameValue((params.keyArray)->Get(left), *(params.key))) {
|
|
return left;
|
|
}
|
|
left--;
|
|
}
|
|
|
|
int32_t res = (-right) ^ HASH_REBELLION;
|
|
return res;
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::GetIteratorObj(JSThread *thread, const JSHandle<JSAPILightWeightMap> &obj,
|
|
IterationKind type)
|
|
{
|
|
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
|
JSHandle<JSAPILightWeightMapIterator> iter(factory->NewJSAPILightWeightMapIterator(obj, type));
|
|
|
|
return iter.GetTaggedValue();
|
|
}
|
|
|
|
JSTaggedValue JSAPILightWeightMap::ToString(JSThread *thread, const JSHandle<JSAPILightWeightMap> &lightWeightMap)
|
|
{
|
|
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
|
std::u16string sepStr = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(",");
|
|
std::u16string colonStr = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(":");
|
|
uint32_t length = lightWeightMap->GetLength();
|
|
std::u16string concatStr;
|
|
JSMutableHandle<JSTaggedValue> valueHandle(thread, JSTaggedValue::Undefined());
|
|
JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
|
|
|
|
for (uint32_t k = 0; k < length; k++) {
|
|
std::u16string valueStr;
|
|
valueHandle.Update(lightWeightMap->GetValueAt(thread, lightWeightMap, k));
|
|
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
|
|
if (!valueHandle->IsUndefined() && !valueHandle->IsNull()) {
|
|
JSHandle<EcmaString> valueStringHandle = JSTaggedValue::ToString(thread, valueHandle);
|
|
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
|
|
valueStr = EcmaStringAccessor(valueStringHandle).ToU16String();
|
|
}
|
|
|
|
std::u16string nextStr;
|
|
keyHandle.Update(lightWeightMap->GetKeyAt(thread, lightWeightMap, k));
|
|
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
|
|
if (!keyHandle->IsUndefined() && !keyHandle->IsNull()) {
|
|
JSHandle<EcmaString> keyStringHandle = JSTaggedValue::ToString(thread, keyHandle);
|
|
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
|
|
nextStr = EcmaStringAccessor(keyStringHandle).ToU16String();
|
|
}
|
|
|
|
nextStr.append(colonStr);
|
|
nextStr.append(valueStr);
|
|
|
|
if (k > 0) {
|
|
concatStr.append(sepStr);
|
|
concatStr.append(nextStr);
|
|
continue;
|
|
}
|
|
concatStr.append(nextStr);
|
|
}
|
|
|
|
char16_t *char16tData = concatStr.data();
|
|
auto *uint16tData = reinterpret_cast<uint16_t *>(char16tData);
|
|
uint32_t u16strSize = concatStr.size();
|
|
return factory->NewFromUtf16Literal(uint16tData, u16strSize).GetTaggedValue();
|
|
}
|
|
|
|
JSHandle<TaggedArray> JSAPILightWeightMap::GrowCapacity(const JSThread *thread, JSHandle<TaggedArray> &oldArray,
|
|
uint32_t needCapacity)
|
|
{
|
|
uint32_t oldLength = oldArray->GetLength();
|
|
if (needCapacity <= oldLength) {
|
|
return oldArray;
|
|
}
|
|
uint32_t newCapacity = ComputeCapacity(needCapacity);
|
|
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
|
|
JSHandle<TaggedArray> newArray = factory->CopyArray(oldArray, oldLength, newCapacity);
|
|
return newArray;
|
|
}
|
|
|
|
void JSAPILightWeightMap::SetArrayByKind(const JSThread *thread,
|
|
const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
const JSHandle<TaggedArray> &array,
|
|
AccossorsKind kind)
|
|
{
|
|
switch (kind) {
|
|
case AccossorsKind::HASH:
|
|
lightWeightMap->SetHashes(thread, array);
|
|
break;
|
|
case AccossorsKind::KEY:
|
|
lightWeightMap->SetKeys(thread, array);
|
|
break;
|
|
case AccossorsKind::VALUE:
|
|
lightWeightMap->SetValues(thread, array);
|
|
break;
|
|
default:
|
|
LOG_ECMA(FATAL) << "this branch is unreachable";
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
JSHandle<TaggedArray> JSAPILightWeightMap::GetArrayByKind(const JSThread *thread,
|
|
const JSHandle<JSAPILightWeightMap> &lightWeightMap,
|
|
AccossorsKind kind)
|
|
{
|
|
JSHandle<TaggedArray> array;
|
|
switch (kind) {
|
|
case AccossorsKind::HASH:
|
|
array = JSHandle<TaggedArray>(thread, lightWeightMap->GetHashes());
|
|
break;
|
|
case AccossorsKind::KEY:
|
|
array = JSHandle<TaggedArray>(thread, lightWeightMap->GetKeys());
|
|
break;
|
|
case AccossorsKind::VALUE:
|
|
array = JSHandle<TaggedArray>(thread, lightWeightMap->GetValues());
|
|
break;
|
|
default:
|
|
LOG_ECMA(FATAL) << "this branch is unreachable";
|
|
UNREACHABLE();
|
|
}
|
|
return array;
|
|
}
|
|
|
|
int32_t JSAPILightWeightMap::Hash(const JSThread *thread, JSTaggedValue key)
|
|
{
|
|
if (key.IsDouble() && key.GetDouble() == 0.0) {
|
|
key = JSTaggedValue(0);
|
|
}
|
|
if (key.IsSymbol()) {
|
|
auto symbolString = JSSymbol::Cast(key.GetTaggedObject());
|
|
return symbolString->GetHashField();
|
|
}
|
|
if (key.IsString()) {
|
|
auto keyString = EcmaString::Cast(key.GetTaggedObject());
|
|
return EcmaStringAccessor(keyString).GetHashcode();
|
|
}
|
|
if (key.IsECMAObject()) {
|
|
uint32_t hash = static_cast<uint32_t>(ECMAObject::Cast(key.GetTaggedObject())->GetHash());
|
|
if (hash == 0) {
|
|
hash = base::RandomGenerator::GenerateIdentityHash();
|
|
JSHandle<ECMAObject> ecmaObj(thread, key);
|
|
ECMAObject::SetHash(thread, hash, ecmaObj);
|
|
}
|
|
return hash;
|
|
}
|
|
if (key.IsInt()) {
|
|
int32_t hash = key.GetInt();
|
|
return hash;
|
|
}
|
|
if (key.IsBigInt()) {
|
|
uint32_t keyValue = BigInt::Cast(key.GetTaggedObject())->GetDigit(0);
|
|
return GetHash32(reinterpret_cast<uint8_t *>(&keyValue), sizeof(keyValue) / sizeof(uint8_t));
|
|
}
|
|
uint64_t keyValue = key.GetRawData();
|
|
return GetHash32(reinterpret_cast<uint8_t *>(&keyValue), sizeof(keyValue) / sizeof(uint8_t));
|
|
}
|
|
|
|
int32_t JSAPILightWeightMap::BinarySearchHashes(JSHandle<TaggedArray> &array, int32_t hash, int32_t size)
|
|
{
|
|
int32_t low = 0;
|
|
int32_t high = size - 1;
|
|
while (low <= high) {
|
|
uint32_t mid = static_cast<uint32_t>(low + high) >> 1U;
|
|
int32_t midHash = array->Get(mid).GetInt();
|
|
if (midHash < hash) {
|
|
low = static_cast<int32_t>(mid) + 1;
|
|
} else {
|
|
if (midHash == hash) {
|
|
return mid;
|
|
}
|
|
high = static_cast<int32_t>(mid) - 1;
|
|
}
|
|
}
|
|
return -(low + 1);
|
|
}
|
|
} // namespace panda::ecmascript
|