AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Reland "[base] Move most of src/numbers into base"

Browse Source 
This is a reland of 9701d4a420
with a small fix for some code landed in between the dry-run and
submission.

Original change's description:
> [base] Move most of src/numbers into base
>
> Moves all but conversions.*, hash-seed-inl.h and math-random.* into
> base, in preparation for moving the parts of conversions that don't
> access HeapObjects.
>
> Also moves uc16 and uc32 out of commons/globals.h into base/strings.h.
>
> Bug: v8:11917
> Change-Id: Ife359148bb0961a63833aff40d26331454b6afb6
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2979595
> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
> Reviewed-by: Clemens Backes <clemensb@chromium.org>
> Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
> Auto-Submit: Dan Elphick <delphick@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#75354}

Bug: v8:11917
Change-Id: Ie1ec9032fe56646a7c7303185cecc70fce5694ae
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2982607
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Commit-Queue: Dan Elphick <delphick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#75368}
This commit is contained in:
Dan Elphick 2021-06-24 14:32:01 +01:00 committed by V8 LUCI CQ
parent 84da489d08
commit 44e73e0b78
154 changed files with 1461 additions and 1475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
BUILD.bazel
View File

@ -246,6 +246,23 @@ filegroup(
"src/base/logging.h",
"src/base/macros.h",
"src/base/memory.h",
"src/base/numbers/bignum-dtoa.cc",
"src/base/numbers/bignum-dtoa.h",
"src/base/numbers/bignum.cc",
"src/base/numbers/bignum.h",
"src/base/numbers/cached-powers.cc",
"src/base/numbers/cached-powers.h",
"src/base/numbers/diy-fp.cc",
"src/base/numbers/diy-fp.h",
"src/base/numbers/double.h",
"src/base/numbers/dtoa.cc",
"src/base/numbers/dtoa.h",
"src/base/numbers/fast-dtoa.cc",
"src/base/numbers/fast-dtoa.h",
"src/base/numbers/fixed-dtoa.cc",
"src/base/numbers/fixed-dtoa.h",
"src/base/numbers/strtod.cc",
"src/base/numbers/strtod.h",
"src/base/once.cc",
"src/base/once.h",
"src/base/optional.h",
@ -1144,29 +1161,12 @@ filegroup(
"src/logging/tracing-flags.h",
"src/logging/runtime-call-stats.h",
"src/logging/runtime-call-stats-scope.h",
"src/numbers/bignum-dtoa.cc",
"src/numbers/bignum-dtoa.h",
"src/numbers/bignum.cc",
"src/numbers/bignum.h",
"src/numbers/cached-powers.cc",
"src/numbers/cached-powers.h",
"src/numbers/conversions-inl.h",
"src/numbers/conversions.cc",
"src/numbers/conversions.h",
"src/numbers/diy-fp.cc",
"src/numbers/diy-fp.h",
"src/numbers/double.h",
"src/numbers/dtoa.cc",
"src/numbers/dtoa.h",
"src/numbers/fast-dtoa.cc",
"src/numbers/fast-dtoa.h",
"src/numbers/fixed-dtoa.cc",
"src/numbers/fixed-dtoa.h",
"src/numbers/hash-seed-inl.h",
"src/numbers/math-random.cc",
"src/numbers/math-random.h",
"src/numbers/strtod.cc",
"src/numbers/strtod.h",
"src/objects/all-objects-inl.h",
"src/objects/allocation-site-inl.h",
"src/objects/allocation-site-scopes-inl.h",

34
BUILD.gn
View File

@ -2815,19 +2815,10 @@ v8_header_set("v8_internal_headers") {
"src/logging/runtime-call-stats-scope.h",
"src/logging/runtime-call-stats.h",
"src/logging/tracing-flags.h",
"src/numbers/bignum-dtoa.h",
"src/numbers/bignum.h",
"src/numbers/cached-powers.h",
"src/numbers/conversions-inl.h",
"src/numbers/conversions.h",
"src/numbers/diy-fp.h",
"src/numbers/double.h",
"src/numbers/dtoa.h",
"src/numbers/fast-dtoa.h",
"src/numbers/fixed-dtoa.h",
"src/numbers/hash-seed-inl.h",
"src/numbers/math-random.h",
"src/numbers/strtod.h",
"src/objects/all-objects-inl.h",
"src/objects/allocation-site-inl.h",
"src/objects/allocation-site-scopes-inl.h",
@ -3908,16 +3899,8 @@ v8_source_set("v8_base_without_compiler") {
"src/logging/metrics.cc",
"src/logging/runtime-call-stats.cc",
"src/logging/tracing-flags.cc",
"src/numbers/bignum-dtoa.cc",
"src/numbers/bignum.cc",
"src/numbers/cached-powers.cc",
"src/numbers/conversions.cc",
"src/numbers/diy-fp.cc",
"src/numbers/dtoa.cc",
"src/numbers/fast-dtoa.cc",
"src/numbers/fixed-dtoa.cc",
"src/numbers/math-random.cc",
"src/numbers/strtod.cc",
"src/objects/backing-store.cc",
"src/objects/bigint.cc",
"src/objects/code-kind.cc",
@ -4669,6 +4652,23 @@ v8_component("v8_libbase") {
"src/base/logging.h",
"src/base/macros.h",
"src/base/memory.h",
"src/base/numbers/bignum-dtoa.cc",
"src/base/numbers/bignum-dtoa.h",
"src/base/numbers/bignum.cc",
"src/base/numbers/bignum.h",
"src/base/numbers/cached-powers.cc",
"src/base/numbers/cached-powers.h",
"src/base/numbers/diy-fp.cc",
"src/base/numbers/diy-fp.h",
"src/base/numbers/double.h",
"src/base/numbers/dtoa.cc",
"src/base/numbers/dtoa.h",
"src/base/numbers/fast-dtoa.cc",
"src/base/numbers/fast-dtoa.h",
"src/base/numbers/fixed-dtoa.cc",
"src/base/numbers/fixed-dtoa.h",
"src/base/numbers/strtod.cc",
"src/base/numbers/strtod.h",
"src/base/once.cc",
"src/base/once.h",
"src/base/optional.h",

26
src/asmjs/asm-scanner.cc
View File

@ -85,7 +85,7 @@ void AsmJsScanner::Next() {
for (;;) {
position_ = stream_->pos();
uc32 ch = stream_->Advance();
base::uc32 ch = stream_->Advance();
switch (ch) {
case ' ':
case '\t':
@ -223,7 +223,7 @@ void AsmJsScanner::Seek(size_t pos) {
Next();
}
void AsmJsScanner::ConsumeIdentifier(uc32 ch) {
void AsmJsScanner::ConsumeIdentifier(base::uc32 ch) {
// Consume characters while still part of the identifier.
identifier_string_.clear();
while (IsIdentifierPart(ch)) {
@ -271,7 +271,7 @@ void AsmJsScanner::ConsumeIdentifier(uc32 ch) {
}
}
void AsmJsScanner::ConsumeNumber(uc32 ch) {
void AsmJsScanner::ConsumeNumber(base::uc32 ch) {
std::string number;
number.assign(1, ch);
bool has_dot = ch == '.';
@ -344,7 +344,7 @@ void AsmJsScanner::ConsumeNumber(uc32 ch) {
bool AsmJsScanner::ConsumeCComment() {
for (;;) {
uc32 ch = stream_->Advance();
base::uc32 ch = stream_->Advance();
while (ch == '*') {
ch = stream_->Advance();
if (ch == '/') {
@ -362,7 +362,7 @@ bool AsmJsScanner::ConsumeCComment() {
void AsmJsScanner::ConsumeCPPComment() {
for (;;) {
uc32 ch = stream_->Advance();
base::uc32 ch = stream_->Advance();
if (ch == '\n') {
preceded_by_newline_ = true;
return;
@ -373,11 +373,11 @@ void AsmJsScanner::ConsumeCPPComment() {
}
}
void AsmJsScanner::ConsumeString(uc32 quote) {
void AsmJsScanner::ConsumeString(base::uc32 quote) {
// Only string allowed is 'use asm' / "use asm".
const char* expected = "use asm";
for (; *expected != '\0'; ++expected) {
if (stream_->Advance() != static_cast<uc32>(*expected)) {
if (stream_->Advance() != static_cast<base::uc32>(*expected)) {
token_ = kParseError;
return;
}
@ -389,8 +389,8 @@ void AsmJsScanner::ConsumeString(uc32 quote) {
token_ = kToken_UseAsm;
}
void AsmJsScanner::ConsumeCompareOrShift(uc32 ch) {
uc32 next_ch = stream_->Advance();
void AsmJsScanner::ConsumeCompareOrShift(base::uc32 ch) {
base::uc32 next_ch = stream_->Advance();
if (next_ch == '=') {
switch (ch) {
case '<':
@ -423,14 +423,16 @@ void AsmJsScanner::ConsumeCompareOrShift(uc32 ch) {
}
}
bool AsmJsScanner::IsIdentifierStart(uc32 ch) {
bool AsmJsScanner::IsIdentifierStart(base::uc32 ch) {
return base::IsInRange(AsciiAlphaToLower(ch), 'a', 'z') || ch == '_' ||
ch == '$';
}
bool AsmJsScanner::IsIdentifierPart(uc32 ch) { return IsAsciiIdentifier(ch); }
bool AsmJsScanner::IsIdentifierPart(base::uc32 ch) {
return IsAsciiIdentifier(ch);
}
bool AsmJsScanner::IsNumberStart(uc32 ch) {
bool AsmJsScanner::IsNumberStart(base::uc32 ch) {
return ch == '.' || IsDecimalDigit(ch);
}

18
src/asmjs/asm-scanner.h
View File

@ -11,6 +11,7 @@
#include "src/asmjs/asm-names.h"
#include "src/base/logging.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
namespace v8 {
@ -135,7 +136,8 @@ class V8_EXPORT_PRIVATE AsmJsScanner {
};
// clang-format on
static constexpr uc32 kEndOfInputU = static_cast<uc32>(kEndOfInput);
static constexpr base::uc32 kEndOfInputU =
static_cast<base::uc32>(kEndOfInput);
private:
Utf16CharacterStream* stream_;
@ -157,17 +159,17 @@ class V8_EXPORT_PRIVATE AsmJsScanner {
bool preceded_by_newline_;
// Consume multiple characters.
void ConsumeIdentifier(uc32 ch);
void ConsumeNumber(uc32 ch);
void ConsumeIdentifier(base::uc32 ch);
void ConsumeNumber(base::uc32 ch);
bool ConsumeCComment();
void ConsumeCPPComment();
void ConsumeString(uc32 quote);
void ConsumeCompareOrShift(uc32 ch);
void ConsumeString(base::uc32 quote);
void ConsumeCompareOrShift(base::uc32 ch);
// Classify character categories.
bool IsIdentifierStart(uc32 ch);
bool IsIdentifierPart(uc32 ch);
bool IsNumberStart(uc32 ch);
bool IsIdentifierStart(base::uc32 ch);
bool IsIdentifierPart(base::uc32 ch);
bool IsNumberStart(base::uc32 ch);
};
} // namespace internal

4
src/ast/ast.cc
View File

@ -11,13 +11,13 @@
#include "src/ast/scopes.h"
#include "src/base/hashmap.h"
#include "src/base/logging.h"
#include "src/base/numbers/double.h"
#include "src/base/platform/wrappers.h"
#include "src/builtins/builtins-constructor.h"
#include "src/builtins/builtins.h"
#include "src/common/assert-scope.h"
#include "src/heap/local-factory-inl.h"
#include "src/numbers/conversions-inl.h"
#include "src/numbers/double.h"
#include "src/objects/contexts.h"
#include "src/objects/elements-kind.h"
#include "src/objects/elements.h"
@ -1044,7 +1044,7 @@ uint32_t Literal::Hash() {
return ComputeLongHash(index);
}
return IsString() ? AsRawString()->Hash()
: ComputeLongHash(double_to_uint64(AsNumber()));
: ComputeLongHash(base::double_to_uint64(AsNumber()));
}
// static

25
src/numbers/bignum-dtoa.cc → src/base/numbers/bignum-dtoa.cc
View File

@ -2,17 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/numbers/bignum-dtoa.h"
#include "src/base/numbers/bignum-dtoa.h"
#include <cmath>
#include "src/base/logging.h"
#include "src/numbers/bignum.h"
#include "src/numbers/double.h"
#include "src/utils/utils.h"
#include "src/base/numbers/bignum.h"
#include "src/base/numbers/double.h"
namespace v8 {
namespace internal {
namespace base {
static int NormalizedExponent(uint64_t significand, int exponent) {
DCHECK_NE(significand, 0);
@ -45,22 +44,22 @@ static void FixupMultiply10(int estimated_power, bool is_even,
// digits yield the shortest decimal representation of v.
static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus,
bool is_even, base::Vector<char> buffer,
bool is_even, Vector<char> buffer,
int* length);
// Generates 'requested_digits' after the decimal point.
static void BignumToFixed(int requested_digits, int* decimal_point,
Bignum* numerator, Bignum* denominator,
base::Vector<char>(buffer), int* length);
Vector<char>(buffer), int* length);
// Generates 'count' digits of numerator/denominator.
// Once 'count' digits have been produced rounds the result depending on the
// remainder (remainders of exactly .5 round upwards). Might update the
// decimal_point when rounding up (for example for 0.9999).
static void GenerateCountedDigits(int count, int* decimal_point,
Bignum* numerator, Bignum* denominator,
base::Vector<char>(buffer), int* length);
Vector<char>(buffer), int* length);
void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
base::Vector<char> buffer, int* length, int* decimal_point) {
Vector<char> buffer, int* length, int* decimal_point) {
DCHECK_GT(v, 0);
DCHECK(!Double(v).IsSpecial());
uint64_t significand = Double(v).Significand();
@ -135,7 +134,7 @@ void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
// will be produced. This should be the standard precondition.
static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus,
bool is_even, base::Vector<char> buffer,
bool is_even, Vector<char> buffer,
int* length) {
// Small optimization: if delta_minus and delta_plus are the same just reuse
// one of the two bignums.
@ -232,7 +231,7 @@ static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
// exponent (decimal_point), when rounding upwards.
static void GenerateCountedDigits(int count, int* decimal_point,
Bignum* numerator, Bignum* denominator,
base::Vector<char>(buffer), int* length) {
Vector<char>(buffer), int* length) {
DCHECK_GE(count, 0);
for (int i = 0; i < count - 1; ++i) {
uint16_t digit;
@ -273,7 +272,7 @@ static void GenerateCountedDigits(int count, int* decimal_point,
// Input verifies: 1 <= (numerator + delta) / denominator < 10.
static void BignumToFixed(int requested_digits, int* decimal_point,
Bignum* numerator, Bignum* denominator,
base::Vector<char>(buffer), int* length) {
Vector<char>(buffer), int* length) {
// Note that we have to look at more than just the requested_digits, since
// a number could be rounded up. Example: v=0.5 with requested_digits=0.
// Even though the power of v equals 0 we can't just stop here.
@ -604,5 +603,5 @@ static void FixupMultiply10(int estimated_power, bool is_even,
}
}
} // namespace internal
} // namespace base
} // namespace v8

17
src/numbers/bignum-dtoa.h → src/base/numbers/bignum-dtoa.h
View File

@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_BIGNUM_DTOA_H_
#define V8_NUMBERS_BIGNUM_DTOA_H_
#ifndef V8_BASE_NUMBERS_BIGNUM_DTOA_H_
#define V8_BASE_NUMBERS_BIGNUM_DTOA_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
enum BignumDtoaMode {
// Return the shortest correct representation.
@ -52,12 +52,11 @@ enum BignumDtoaMode {
// Halfway cases are again rounded up.
// 'BignumDtoa' expects the given buffer to be big enough to hold all digits
// and a terminating null-character.
V8_EXPORT_PRIVATE void BignumDtoa(double v, BignumDtoaMode mode,
int requested_digits,
base::Vector<char> buffer, int* length,
int* point);
V8_BASE_EXPORT void BignumDtoa(double v, BignumDtoaMode mode,
int requested_digits, Vector<char> buffer,
int* length, int* point);
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_BIGNUM_DTOA_H_
#endif // V8_BASE_NUMBERS_BIGNUM_DTOA_H_

15
src/numbers/bignum.cc → src/base/numbers/bignum.cc
View File

@ -2,11 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/numbers/bignum.h"
#include "src/utils/utils.h"
#include "src/base/numbers/bignum.h"
#include "src/base/strings.h"
namespace v8 {
namespace internal {
namespace base {
Bignum::Bignum()
: bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) {
@ -59,7 +60,7 @@ void Bignum::AssignBignum(const Bignum& other) {
used_digits_ = other.used_digits_;
}
static uint64_t ReadUInt64(base::Vector<const char> buffer, int from,
static uint64_t ReadUInt64(Vector<const char> buffer, int from,
int digits_to_read) {
uint64_t result = 0;
int to = from + digits_to_read;
@ -72,7 +73,7 @@ static uint64_t ReadUInt64(base::Vector<const char> buffer, int from,
return result;
}
void Bignum::AssignDecimalString(base::Vector<const char> value) {
void Bignum::AssignDecimalString(Vector<const char> value) {
// 2^64 = 18446744073709551616 > 10^19
const int kMaxUint64DecimalDigits = 19;
Zero();
@ -99,7 +100,7 @@ static int HexCharValue(char c) {
UNREACHABLE();
}
void Bignum::AssignHexString(base::Vector<const char> value) {
void Bignum::AssignHexString(Vector<const char> value) {
Zero();
int length = value.length();
@ -712,5 +713,5 @@ void Bignum::SubtractTimes(const Bignum& other, int factor) {
DCHECK(Bignum::Equal(a, *this));
}
} // namespace internal
} // namespace base
} // namespace v8

18
src/numbers/bignum.h → src/base/numbers/bignum.h
View File

@ -2,15 +2,15 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_BIGNUM_H_
#define V8_NUMBERS_BIGNUM_H_
#ifndef V8_BASE_NUMBERS_BIGNUM_H_
#define V8_BASE_NUMBERS_BIGNUM_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
class V8_EXPORT_PRIVATE Bignum {
class V8_BASE_EXPORT Bignum {
public:
// 3584 = 128 * 28. We can represent 2^3584 > 10^1000 accurately.
// This bignum can encode much bigger numbers, since it contains an
@ -24,8 +24,8 @@ class V8_EXPORT_PRIVATE Bignum {
void AssignUInt64(uint64_t value);
void AssignBignum(const Bignum& other);
void AssignDecimalString(base::Vector<const char> value);
void AssignHexString(base::Vector<const char> value);
void AssignDecimalString(Vector<const char> value);
void AssignHexString(Vector<const char> value);
void AssignPowerUInt16(uint16_t base, int exponent);
@ -109,13 +109,13 @@ class V8_EXPORT_PRIVATE Bignum {
Chunk bigits_buffer_[kBigitCapacity];
// A vector backed by bigits_buffer_. This way accesses to the array are
// checked for out-of-bounds errors.
base::Vector<Chunk> bigits_;
Vector<Chunk> bigits_;
int used_digits_;
// The Bignum's value equals value(bigits_) * 2^(exponent_ * kBigitSize).
int exponent_;
};
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_BIGNUM_H_
#endif // V8_BASE_NUMBERS_BIGNUM_H_

8
src/numbers/cached-powers.cc → src/base/numbers/cached-powers.cc
View File

@ -2,18 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/numbers/cached-powers.h"
#include "src/base/numbers/cached-powers.h"
#include <limits.h>
#include <stdarg.h>
#include <stdint.h>
#include <cmath>
#include "src/base/logging.h"
#include "src/common/globals.h"
namespace v8 {
namespace internal {
namespace base {
struct CachedPower {
uint64_t significand;
@ -109,5 +109,5 @@ void PowersOfTenCache::GetCachedPowerForDecimalExponent(int requested_exponent,
DCHECK(requested_exponent < *found_exponent + kDecimalExponentDistance);
}
} // namespace internal
} // namespace base
} // namespace v8

12
src/numbers/cached-powers.h → src/base/numbers/cached-powers.h
View File

@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_CACHED_POWERS_H_
#define V8_NUMBERS_CACHED_POWERS_H_
#ifndef V8_BASE_NUMBERS_CACHED_POWERS_H_
#define V8_BASE_NUMBERS_CACHED_POWERS_H_
#include "src/base/logging.h"
#include "src/numbers/diy-fp.h"
#include "src/base/numbers/diy-fp.h"
namespace v8 {
namespace internal {
namespace base {
class PowersOfTenCache {
public:
@ -37,7 +37,7 @@ class PowersOfTenCache {
int* found_exponent);
};
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_CACHED_POWERS_H_
#endif // V8_BASE_NUMBERS_CACHED_POWERS_H_

6
src/numbers/diy-fp.cc → src/base/numbers/diy-fp.cc
View File

@ -2,12 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/numbers/diy-fp.h"
#include "src/base/numbers/diy-fp.h"
#include <stdint.h>
namespace v8 {
namespace internal {
namespace base {
void DiyFp::Multiply(const DiyFp& other) {
// Simply "emulates" a 128 bit multiplication.
@ -32,5 +32,5 @@ void DiyFp::Multiply(const DiyFp& other) {
f_ = result_f;
}
} // namespace internal
} // namespace base
} // namespace v8

12
src/numbers/diy-fp.h → src/base/numbers/diy-fp.h
View File

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_DIY_FP_H_
#define V8_NUMBERS_DIY_FP_H_
#ifndef V8_BASE_NUMBERS_DIY_FP_H_
#define V8_BASE_NUMBERS_DIY_FP_H_
#include <stdint.h>
@ -11,7 +11,7 @@
#include "src/base/macros.h"
namespace v8 {
namespace internal {
namespace base {
// This "Do It Yourself Floating Point" class implements a floating-point number
// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
@ -45,7 +45,7 @@ class DiyFp {
}
// this = this * other.
V8_EXPORT_PRIVATE void Multiply(const DiyFp& other);
V8_BASE_EXPORT void Multiply(const DiyFp& other);
// returns a * b;
static DiyFp Times(const DiyFp& a, const DiyFp& b) {
@ -93,7 +93,7 @@ class DiyFp {
int e_;
};
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_DIY_FP_H_
#endif // V8_BASE_NUMBERS_DIY_FP_H_

12
src/numbers/double.h → src/base/numbers/double.h
View File

@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_DOUBLE_H_
#define V8_NUMBERS_DOUBLE_H_
#ifndef V8_BASE_NUMBERS_DOUBLE_H_
#define V8_BASE_NUMBERS_DOUBLE_H_
#include "src/base/macros.h"
#include "src/numbers/diy-fp.h"
#include "src/base/numbers/diy-fp.h"
namespace v8 {
namespace internal {
namespace base {
// We assume that doubles and uint64_t have the same endianness.
inline uint64_t double_to_uint64(double d) { return bit_cast<uint64_t>(d); }
@ -204,7 +204,7 @@ class Double {
}
};
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_DOUBLE_H_
#endif // V8_BASE_NUMBERS_DOUBLE_H_

21
src/numbers/dtoa.cc → src/base/numbers/dtoa.cc
View File

@ -2,20 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/numbers/dtoa.h"
#include <cmath>
#include "src/base/logging.h"
#include "src/utils/utils.h"
#include "src/numbers/dtoa.h"
#include "src/numbers/bignum-dtoa.h"
#include "src/numbers/double.h"
#include "src/numbers/fast-dtoa.h"
#include "src/numbers/fixed-dtoa.h"
#include "src/base/numbers/bignum-dtoa.h"
#include "src/base/numbers/double.h"
#include "src/base/numbers/fast-dtoa.h"
#include "src/base/numbers/fixed-dtoa.h"
namespace v8 {
namespace internal {
namespace base {
static BignumDtoaMode DtoaToBignumDtoaMode(DtoaMode dtoa_mode) {
switch (dtoa_mode) {
@ -31,8 +29,7 @@ static BignumDtoaMode DtoaToBignumDtoaMode(DtoaMode dtoa_mode) {
}
void DoubleToAscii(double v, DtoaMode mode, int requested_digits,
base::Vector<char> buffer, int* sign, int* length,
int* point) {
Vector<char> buffer, int* sign, int* length, int* point) {
DCHECK(!Double(v).IsSpecial());
DCHECK(mode == DTOA_SHORTEST || requested_digits >= 0);
@ -80,5 +77,5 @@ void DoubleToAscii(double v, DtoaMode mode, int requested_digits,
buffer[*length] = '\0';
}
} // namespace internal
} // namespace base
} // namespace v8

17
src/numbers/dtoa.h → src/base/numbers/dtoa.h
View File

@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_DTOA_H_
#define V8_NUMBERS_DTOA_H_
#ifndef V8_BASE_NUMBERS_DTOA_H_
#define V8_BASE_NUMBERS_DTOA_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
enum DtoaMode {
// Return the shortest correct representation.
@ -61,12 +61,11 @@ const int kBase10MaximalLength = 17;
// and a terminating null-character. In SHORTEST-mode it expects a buffer of
// at least kBase10MaximalLength + 1. Otherwise, the size of the output is
// limited to requested_digits digits plus the null terminator.
V8_EXPORT_PRIVATE void DoubleToAscii(double v, DtoaMode mode,
int requested_digits,
base::Vector<char> buffer, int* sign,
int* length, int* point);
V8_BASE_EXPORT void DoubleToAscii(double v, DtoaMode mode, int requested_digits,
Vector<char> buffer, int* sign, int* length,
int* point);
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_DTOA_H_
#endif // V8_BASE_NUMBERS_DTOA_H_

41
src/numbers/fast-dtoa.cc → src/base/numbers/fast-dtoa.cc
View File

@ -2,18 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/numbers/fast-dtoa.h"
#include <stdint.h>
#include "src/base/logging.h"
#include "src/utils/utils.h"
#include "src/numbers/fast-dtoa.h"
#include "src/numbers/cached-powers.h"
#include "src/numbers/diy-fp.h"
#include "src/numbers/double.h"
#include "src/base/numbers/cached-powers.h"
#include "src/base/numbers/diy-fp.h"
#include "src/base/numbers/double.h"
#include "src/base/v8-fallthrough.h"
namespace v8 {
namespace internal {
namespace base {
// The minimal and maximal target exponent define the range of w's binary
// exponent, where 'w' is the result of multiplying the input by a cached power
@ -39,7 +39,7 @@ static const int kMaximalTargetExponent = -32;
// Output: returns true if the buffer is guaranteed to contain the closest
// representable number to the input.
// Modifies the generated digits in the buffer to approach (round towards) w.
static bool RoundWeed(base::Vector<char> buffer, int length,
static bool RoundWeed(Vector<char> buffer, int length,
uint64_t distance_too_high_w, uint64_t unsafe_interval,
uint64_t rest, uint64_t ten_kappa, uint64_t unit) {
uint64_t small_distance = distance_too_high_w - unit;
@ -153,9 +153,8 @@ static bool RoundWeed(base::Vector<char> buffer, int length,
// unambiguously determined.
//
// Precondition: rest < ten_kappa.
static bool RoundWeedCounted(base::Vector<char> buffer, int length,
uint64_t rest, uint64_t ten_kappa, uint64_t unit,
int* kappa) {
static bool RoundWeedCounted(Vector<char> buffer, int length, uint64_t rest,
uint64_t ten_kappa, uint64_t unit, int* kappa) {
DCHECK(rest < ten_kappa);
// The following tests are done in a specific order to avoid overflows. They
// will work correctly with any uint64 values of rest < ten_kappa and unit.
@ -355,7 +354,7 @@ static void BiggestPowerTen(uint32_t number, int number_bits, uint32_t* power,
// represent 'w' we can stop. Everything inside the interval low - high
// represents w. However we have to pay attention to low, high and w's
// imprecision.
static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, base::Vector<char> buffer,
static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, Vector<char> buffer,
int* length, int* kappa) {
DCHECK(low.e() == w.e() && w.e() == high.e());
DCHECK(low.f() + 1 <= high.f() - 1);
@ -475,9 +474,8 @@ static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, base::Vector<char> buffer,
// numbers. If the precision is not enough to guarantee all the postconditions
// then false is returned. This usually happens rarely, but the failure-rate
// increases with higher requested_digits.
static bool DigitGenCounted(DiyFp w, int requested_digits,
base::Vector<char> buffer, int* length,
int* kappa) {
static bool DigitGenCounted(DiyFp w, int requested_digits, Vector<char> buffer,
int* length, int* kappa) {
DCHECK(kMinimalTargetExponent <= w.e() && w.e() <= kMaximalTargetExponent);
DCHECK_GE(kMinimalTargetExponent, -60);
DCHECK_LE(kMaximalTargetExponent, -32);
@ -561,7 +559,7 @@ static bool DigitGenCounted(DiyFp w, int requested_digits,
// The last digit will be closest to the actual v. That is, even if several
// digits might correctly yield 'v' when read again, the closest will be
// computed.
static bool Grisu3(double v, base::Vector<char> buffer, int* length,
static bool Grisu3(double v, Vector<char> buffer, int* length,
int* decimal_exponent) {
DiyFp w = Double(v).AsNormalizedDiyFp();
// boundary_minus and boundary_plus are the boundaries between v and its
@ -622,9 +620,8 @@ static bool Grisu3(double v, base::Vector<char> buffer, int* length,
// and with enough requested digits 0.1 will at some point print as 0.9999999...
// Grisu3 is too imprecise for real halfway cases (1.5 will not work) and
// therefore the rounding strategy for halfway cases is irrelevant.
static bool Grisu3Counted(double v, int requested_digits,
base::Vector<char> buffer, int* length,
int* decimal_exponent) {
static bool Grisu3Counted(double v, int requested_digits, Vector<char> buffer,
int* length, int* decimal_exponent) {
DiyFp w = Double(v).AsNormalizedDiyFp();
DiyFp ten_mk; // Cached power of ten: 10^-k
int mk; // -k
@ -663,7 +660,7 @@ static bool Grisu3Counted(double v, int requested_digits,
}
bool FastDtoa(double v, FastDtoaMode mode, int requested_digits,
base::Vector<char> buffer, int* length, int* decimal_point) {
Vector<char> buffer, int* length, int* decimal_point) {
DCHECK_GT(v, 0);
DCHECK(!Double(v).IsSpecial());
@ -687,5 +684,5 @@ bool FastDtoa(double v, FastDtoaMode mode, int requested_digits,
return result;
}
} // namespace internal
} // namespace base
} // namespace v8

16
src/numbers/fast-dtoa.h → src/base/numbers/fast-dtoa.h
View File

@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_FAST_DTOA_H_
#define V8_NUMBERS_FAST_DTOA_H_
#ifndef V8_BASE_NUMBERS_FAST_DTOA_H_
#define V8_BASE_NUMBERS_FAST_DTOA_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
enum FastDtoaMode {
// Computes the shortest representation of the given input. The returned
@ -50,11 +50,11 @@ const int kFastDtoaMaximalLength = 17;
// If there are two values that are equally close, then FastDtoa returns
// false.
// For both modes the buffer must be large enough to hold the result.
V8_EXPORT_PRIVATE bool FastDtoa(double d, FastDtoaMode mode,
int requested_digits, base::Vector<char> buffer,
int* length, int* decimal_point);
V8_BASE_EXPORT bool FastDtoa(double d, FastDtoaMode mode, int requested_digits,
Vector<char> buffer, int* length,
int* decimal_point);
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_FAST_DTOA_H_
#endif // V8_BASE_NUMBERS_FAST_DTOA_H_

31
src/numbers/fixed-dtoa.cc → src/base/numbers/fixed-dtoa.cc
View File

@ -2,18 +2,17 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/numbers/fixed-dtoa.h"
#include <stdint.h>
#include <cmath>
#include "src/base/logging.h"
#include "src/utils/utils.h"
#include "src/numbers/double.h"
#include "src/numbers/fixed-dtoa.h"
#include "src/base/numbers/double.h"
namespace v8 {
namespace internal {
namespace base {
// Represents a 128bit type. This class should be replaced by a native type on
// platforms that support 128bit integers.
@ -97,7 +96,7 @@ class UInt128 {
static const int kDoubleSignificandSize = 53; // Includes the hidden bit.
static void FillDigits32FixedLength(uint32_t number, int requested_length,
base::Vector<char> buffer, int* length) {
Vector<char> buffer, int* length) {
for (int i = requested_length - 1; i >= 0; --i) {
buffer[(*length) + i] = '0' + number % 10;
number /= 10;
@ -105,8 +104,7 @@ static void FillDigits32FixedLength(uint32_t number, int requested_length,
*length += requested_length;
}
static void FillDigits32(uint32_t number, base::Vector<char> buffer,
int* length) {
static void FillDigits32(uint32_t number, Vector<char> buffer, int* length) {
int number_length = 0;
// We fill the digits in reverse order and exchange them afterwards.
while (number != 0) {
@ -129,7 +127,7 @@ static void FillDigits32(uint32_t number, base::Vector<char> buffer,
}
static void FillDigits64FixedLength(uint64_t number, int requested_length,
base::Vector<char> buffer, int* length) {
Vector<char> buffer, int* length) {
const uint32_t kTen7 = 10000000;
// For efficiency cut the number into 3 uint32_t parts, and print those.
uint32_t part2 = static_cast<uint32_t>(number % kTen7);
@ -142,8 +140,7 @@ static void FillDigits64FixedLength(uint64_t number, int requested_length,
FillDigits32FixedLength(part2, 7, buffer, length);
}
static void FillDigits64(uint64_t number, base::Vector<char> buffer,
int* length) {
static void FillDigits64(uint64_t number, Vector<char> buffer, int* length) {
const uint32_t kTen7 = 10000000;
// For efficiency cut the number into 3 uint32_t parts, and print those.
uint32_t part2 = static_cast<uint32_t>(number % kTen7);
@ -163,8 +160,7 @@ static void FillDigits64(uint64_t number, base::Vector<char> buffer,
}
}
static void DtoaRoundUp(base::Vector<char> buffer, int* length,
int* decimal_point) {
static void DtoaRoundUp(Vector<char> buffer, int* length, int* decimal_point) {
// An empty buffer represents 0.
if (*length == 0) {
buffer[0] = '1';
@ -205,7 +201,7 @@ static void DtoaRoundUp(base::Vector<char> buffer, int* length,
// already contained "199" (thus yielding a buffer of "19999") then a
// rounding-up will change the contents of the buffer to "20000".
static void FillFractionals(uint64_t fractionals, int exponent,
int fractional_count, base::Vector<char> buffer,
int fractional_count, Vector<char> buffer,
int* length, int* decimal_point) {
DCHECK(-128 <= exponent && exponent <= 0);
// 'fractionals' is a fixed-point number, with binary point at bit
@ -262,8 +258,7 @@ static void FillFractionals(uint64_t fractionals, int exponent,
// Removes leading and trailing zeros.
// If leading zeros are removed then the decimal point position is adjusted.
static void TrimZeros(base::Vector<char> buffer, int* length,
int* decimal_point) {
static void TrimZeros(Vector<char> buffer, int* length, int* decimal_point) {
while (*length > 0 && buffer[(*length) - 1] == '0') {
(*length)--;
}
@ -280,7 +275,7 @@ static void TrimZeros(base::Vector<char> buffer, int* length,
}
}
bool FastFixedDtoa(double v, int fractional_count, base::Vector<char> buffer,
bool FastFixedDtoa(double v, int fractional_count, Vector<char> buffer,
int* length, int* decimal_point) {
const uint32_t kMaxUInt32 = 0xFFFFFFFF;
uint64_t significand = Double(v).Significand();
@ -372,5 +367,5 @@ bool FastFixedDtoa(double v, int fractional_count, base::Vector<char> buffer,
return true;
}
} // namespace internal
} // namespace base
} // namespace v8

16
src/numbers/fixed-dtoa.h → src/base/numbers/fixed-dtoa.h
View File

@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_FIXED_DTOA_H_
#define V8_NUMBERS_FIXED_DTOA_H_
#ifndef V8_BASE_NUMBERS_FIXED_DTOA_H_
#define V8_BASE_NUMBERS_FIXED_DTOA_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
// Produces digits necessary to print a given number with
// 'fractional_count' digits after the decimal point.
@ -26,11 +26,11 @@ namespace internal {
//
// This method only works for some parameters. If it can't handle the input it
// returns false. The output is null-terminated when the function succeeds.
V8_EXPORT_PRIVATE bool FastFixedDtoa(double v, int fractional_count,
base::Vector<char> buffer, int* length,
int* decimal_point);
V8_BASE_EXPORT bool FastFixedDtoa(double v, int fractional_count,
Vector<char> buffer, int* length,
int* decimal_point);
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_FIXED_DTOA_H_
#endif // V8_BASE_NUMBERS_FIXED_DTOA_H_

59
src/numbers/strtod.cc → src/base/numbers/strtod.cc
View File

@ -2,19 +2,19 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/numbers/strtod.h"
#include "src/base/numbers/strtod.h"
#include <stdarg.h>
#include <cmath>
#include "src/common/globals.h"
#include "src/numbers/bignum.h"
#include "src/numbers/cached-powers.h"
#include "src/numbers/double.h"
#include "src/utils/utils.h"
#include <cmath>
#include <limits>
#include "src/base/numbers/bignum.h"
#include "src/base/numbers/cached-powers.h"
#include "src/base/numbers/double.h"
namespace v8 {
namespace internal {
namespace base {
// 2^53 = 9007199254740992.
// Any integer with at most 15 decimal digits will hence fit into a double
@ -70,28 +70,26 @@ static const int kExactPowersOfTenSize = arraysize(exact_powers_of_ten);
// we round up to 780.
static const int kMaxSignificantDecimalDigits = 780;
static base::Vector<const char> TrimLeadingZeros(
base::Vector<const char> buffer) {
static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
for (int i = 0; i < buffer.length(); i++) {
if (buffer[i] != '0') {
return buffer.SubVector(i, buffer.length());
}
}
return base::Vector<const char>(buffer.begin(), 0);
return Vector<const char>(buffer.begin(), 0);
}
static base::Vector<const char> TrimTrailingZeros(
base::Vector<const char> buffer) {
static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
for (int i = buffer.length() - 1; i >= 0; --i) {
if (buffer[i] != '0') {
return buffer.SubVector(0, i + 1);
}
}
return base::Vector<const char>(buffer.begin(), 0);
return Vector<const char>(buffer.begin(), 0);
}
static void TrimToMaxSignificantDigits(base::Vector<const char> buffer,
int exponent, char* significant_buffer,
static void TrimToMaxSignificantDigits(Vector<const char> buffer, int exponent,
char* significant_buffer,
int* significant_exponent) {
for (int i = 0; i < kMaxSignificantDecimalDigits - 1; ++i) {
significant_buffer[i] = buffer[i];
@ -111,7 +109,7 @@ static void TrimToMaxSignificantDigits(base::Vector<const char> buffer,
// When the string starts with "1844674407370955161" no further digit is read.
// Since 2^64 = 18446744073709551616 it would still be possible read another
// digit if it was less or equal than 6, but this would complicate the code.
static uint64_t ReadUint64(base::Vector<const char> buffer,
static uint64_t ReadUint64(Vector<const char> buffer,
int* number_of_read_digits) {
uint64_t result = 0;
int i = 0;
@ -128,7 +126,7 @@ static uint64_t ReadUint64(base::Vector<const char> buffer,
// The returned DiyFp is not necessarily normalized.
// If remaining_decimals is zero then the returned DiyFp is accurate.
// Otherwise it has been rounded and has error of at most 1/2 ulp.
static void ReadDiyFp(base::Vector<const char> buffer, DiyFp* result,
static void ReadDiyFp(Vector<const char> buffer, DiyFp* result,
int* remaining_decimals) {
int read_digits;
uint64_t significand = ReadUint64(buffer, &read_digits);
@ -147,7 +145,7 @@ static void ReadDiyFp(base::Vector<const char> buffer, DiyFp* result,
}
}
static bool DoubleStrtod(base::Vector<const char> trimmed, int exponent,
static bool DoubleStrtod(Vector<const char> trimmed, int exponent,
double* result) {
#if (V8_TARGET_ARCH_IA32 || defined(USE_SIMULATOR)) && !defined(_MSC_VER)
// On x86 the floating-point stack can be 64 or 80 bits wide. If it is
@ -233,7 +231,7 @@ static DiyFp AdjustmentPowerOfTen(int exponent) {
// If the function returns true then the result is the correct double.
// Otherwise it is either the correct double or the double that is just below
// the correct double.
static bool DiyFpStrtod(base::Vector<const char> buffer, int exponent,
static bool DiyFpStrtod(Vector<const char> buffer, int exponent,
double* result) {
DiyFp input;
int remaining_decimals;
@ -347,9 +345,9 @@ static bool DiyFpStrtod(base::Vector<const char> buffer, int exponent,
// buffer.length() + exponent <= kMaxDecimalPower + 1
// buffer.length() + exponent > kMinDecimalPower
// buffer.length() <= kMaxDecimalSignificantDigits
static double BignumStrtod(base::Vector<const char> buffer, int exponent,
static double BignumStrtod(Vector<const char> buffer, int exponent,
double guess) {
if (guess == V8_INFINITY) {
if (guess == std::numeric_limits<double>::infinity()) {
return guess;
}
@ -390,9 +388,9 @@ static double BignumStrtod(base::Vector<const char> buffer, int exponent,
}
}
double Strtod(base::Vector<const char> buffer, int exponent) {
base::Vector<const char> left_trimmed = TrimLeadingZeros(buffer);
base::Vector<const char> trimmed = TrimTrailingZeros(left_trimmed);
double Strtod(Vector<const char> buffer, int exponent) {
Vector<const char> left_trimmed = TrimLeadingZeros(buffer);
Vector<const char> trimmed = TrimTrailingZeros(left_trimmed);
exponent += left_trimmed.length() - trimmed.length();
if (trimmed.length() == 0) return 0.0;
if (trimmed.length() > kMaxSignificantDecimalDigits) {
@ -400,11 +398,12 @@ double Strtod(base::Vector<const char> buffer, int exponent) {
int significant_exponent;
TrimToMaxSignificantDigits(trimmed, exponent, significant_buffer,
&significant_exponent);
return Strtod(base::Vector<const char>(significant_buffer,
kMaxSignificantDecimalDigits),
significant_exponent);
return Strtod(
Vector<const char>(significant_buffer, kMaxSignificantDecimalDigits),
significant_exponent);
}
if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) return V8_INFINITY;
if (exponent + trimmed.length() - 1 >= kMaxDecimalPower)
return std::numeric_limits<double>::infinity();
if (exponent + trimmed.length() <= kMinDecimalPower) return 0.0;
double guess;
@ -415,5 +414,5 @@ double Strtod(base::Vector<const char> buffer, int exponent) {
return BignumStrtod(trimmed, exponent, guess);
}
} // namespace internal
} // namespace base
} // namespace v8

12
src/numbers/strtod.h → src/base/numbers/strtod.h
View File

@ -2,19 +2,19 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_NUMBERS_STRTOD_H_
#define V8_NUMBERS_STRTOD_H_
#ifndef V8_BASE_NUMBERS_STRTOD_H_
#define V8_BASE_NUMBERS_STRTOD_H_
#include "src/base/vector.h"
namespace v8 {
namespace internal {
namespace base {
// The buffer must only contain digits in the range [0-9]. It must not
// contain a dot or a sign. It must not start with '0', and must not be empty.
V8_EXPORT_PRIVATE double Strtod(base::Vector<const char> buffer, int exponent);
V8_BASE_EXPORT double Strtod(Vector<const char> buffer, int exponent);
} // namespace internal
} // namespace base
} // namespace v8
#endif // V8_NUMBERS_STRTOD_H_
#endif // V8_BASE_NUMBERS_STRTOD_H_

23
src/base/strings.h
View File

@ -12,6 +12,13 @@
namespace v8 {
namespace base {
// Latin1/UTF-16 constants
// Code-point values in Unicode 4.0 are 21 bits wide.
// Code units in UTF-16 are 16 bits wide.
using uc16 = uint16_t;
using uc32 = uint32_t;
constexpr int kUC16Size = sizeof(uc16);
V8_BASE_EXPORT int PRINTF_FORMAT(2, 0)
VSNPrintF(Vector<char> str, const char* format, va_list args);
@ -22,6 +29,22 @@ V8_BASE_EXPORT int PRINTF_FORMAT(2, 3)
V8_BASE_EXPORT void StrNCpy(base::Vector<char> dest, const char* src, size_t n);
// Returns the value (0 .. 15) of a hexadecimal character c.
// If c is not a legal hexadecimal character, returns a value < 0.
inline int HexValue(uc32 c) {
c -= '0';
if (static_cast<unsigned>(c) <= 9) return c;
c = (c | 0x20) - ('a' - '0'); // detect 0x11..0x16 and 0x31..0x36.
if (static_cast<unsigned>(c) <= 5) return c + 10;
return -1;
}
inline char HexCharOfValue(int value) {
DCHECK(0 <= value && value <= 16);
if (value < 10) return value + '0';
return value - 10 + 'A';
}
} // namespace base
} // namespace v8

2
src/builtins/arm/builtins-arm.cc
View File

@ -525,7 +525,7 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
pushed_stack_space += kNumDoubleCalleeSaved * kDoubleSize;
// Set up the reserved register for 0.0.
__ vmov(kDoubleRegZero, Double(0.0));
__ vmov(kDoubleRegZero, base::Double(0.0));
// Initialize the root register.
// C calling convention. The first argument is passed in r0.

7
src/builtins/builtins-string-gen.cc
View File

@ -4,6 +4,7 @@
#include "src/builtins/builtins-string-gen.h"
#include "src/base/strings.h"
#include "src/builtins/builtins-regexp-gen.h"
#include "src/builtins/builtins-utils-gen.h"
#include "src/builtins/builtins.h"
@ -73,7 +74,7 @@ TNode<IntPtrT> StringBuiltinsAssembler::SearchOneByteStringInTwoByteString(
const TNode<RawPtrT> subject_ptr, const TNode<IntPtrT> subject_length,
const TNode<RawPtrT> search_ptr, const TNode<IntPtrT> search_length,
const TNode<IntPtrT> start_position) {
return CallSearchStringRaw<const uc16, const uint8_t>(
return CallSearchStringRaw<const base::uc16, const uint8_t>(
subject_ptr, subject_length, search_ptr, search_length, start_position);
}
TNode<IntPtrT> StringBuiltinsAssembler::SearchOneByteStringInOneByteString(
@ -87,14 +88,14 @@ TNode<IntPtrT> StringBuiltinsAssembler::SearchTwoByteStringInTwoByteString(
const TNode<RawPtrT> subject_ptr, const TNode<IntPtrT> subject_length,
const TNode<RawPtrT> search_ptr, const TNode<IntPtrT> search_length,
const TNode<IntPtrT> start_position) {
return CallSearchStringRaw<const uc16, const uc16>(
return CallSearchStringRaw<const base::uc16, const base::uc16>(
subject_ptr, subject_length, search_ptr, search_length, start_position);
}
TNode<IntPtrT> StringBuiltinsAssembler::SearchTwoByteStringInOneByteString(
const TNode<RawPtrT> subject_ptr, const TNode<IntPtrT> subject_length,
const TNode<RawPtrT> search_ptr, const TNode<IntPtrT> search_length,
const TNode<IntPtrT> start_position) {
return CallSearchStringRaw<const uint8_t, const uc16>(
return CallSearchStringRaw<const uint8_t, const base::uc16>(
subject_ptr, subject_length, search_ptr, search_length, start_position);
}
TNode<IntPtrT> StringBuiltinsAssembler::SearchOneByteInOneByteString(

24
src/builtins/builtins-string.cc
View File

@ -11,6 +11,7 @@
#ifdef V8_INTL_SUPPORT
#include "src/objects/intl-objects.h"
#endif
#include "src/base/strings.h"
#include "src/regexp/regexp-utils.h"
#include "src/strings/string-builder-inl.h"
#include "src/strings/string-case.h"
@ -40,9 +41,9 @@ bool IsValidCodePoint(Isolate* isolate, Handle<Object> value) {
return true;
}
static constexpr uc32 kInvalidCodePoint = static_cast<uc32>(-1);
static constexpr base::uc32 kInvalidCodePoint = static_cast<base::uc32>(-1);
uc32 NextCodePoint(Isolate* isolate, BuiltinArguments args, int index) {
base::uc32 NextCodePoint(Isolate* isolate, BuiltinArguments args, int index) {
Handle<Object> value = args.at(1 + index);
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, value, Object::ToNumber(isolate, value), kInvalidCodePoint);
@ -67,7 +68,7 @@ BUILTIN(StringFromCodePoint) {
// characters.
std::vector<uint8_t> one_byte_buffer;
one_byte_buffer.reserve(length);
uc32 code = 0;
base::uc32 code = 0;
int index;
for (index = 0; index < length; index++) {
code = NextCodePoint(isolate, args, index);
@ -86,11 +87,12 @@ BUILTIN(StringFromCodePoint) {
one_byte_buffer.data(), one_byte_buffer.size())));
}
std::vector<uc16> two_byte_buffer;
std::vector<base::uc16> two_byte_buffer;
two_byte_buffer.reserve(length - index);
while (true) {
if (code <= static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
if (code <=
static_cast<base::uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
two_byte_buffer.push_back(code);
} else {
two_byte_buffer.push_back(unibrow::Utf16::LeadSurrogate(code));
@ -230,11 +232,11 @@ BUILTIN(StringPrototypeNormalize) {
#ifndef V8_INTL_SUPPORT
namespace {
inline bool ToUpperOverflows(uc32 character) {
inline bool ToUpperOverflows(base::uc32 character) {
// y with umlauts and the micro sign are the only characters that stop
// fitting into one-byte when converting to uppercase.
static const uc32 yuml_code = 0xFF;
static const uc32 micro_code = 0xB5;
static const base::uc32 yuml_code = 0xFF;
static const base::uc32 micro_code = 0xB5;
return (character == yuml_code || character == micro_code);
}
@ -259,11 +261,11 @@ V8_WARN_UNUSED_RESULT static Object ConvertCaseHelper(
StringCharacterStream stream(string);
unibrow::uchar chars[Converter::kMaxWidth];
// We can assume that the string is not empty
uc32 current = stream.GetNext();
base::uc32 current = stream.GetNext();
bool ignore_overflow = Converter::kIsToLower || result.IsSeqTwoByteString();
for (int i = 0; i < result_length;) {
bool has_next = stream.HasMore();
uc32 next = has_next ? stream.GetNext() : 0;
base::uc32 next = has_next ? stream.GetNext() : 0;
int char_length = mapping->get(current, next, chars);
if (char_length == 0) {
// The case conversion of this character is the character itself.
@ -272,7 +274,7 @@ V8_WARN_UNUSED_RESULT static Object ConvertCaseHelper(
} else if (char_length == 1 &&
(ignore_overflow || !ToUpperOverflows(current))) {
// Common case: converting the letter resulted in one character.
DCHECK(static_cast<uc32>(chars[0]) != current);
DCHECK(static_cast<base::uc32>(chars[0]) != current);
result.Set(i, chars[0]);
has_changed_character = true;
i++;

10
src/builtins/ia32/builtins-ia32.cc
View File

@ -3103,7 +3103,8 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ j(below, &process_64_bits);
// Result is entirely in lower 32-bits of mantissa
int delta = HeapNumber::kExponentBias + Double::kPhysicalSignificandSize;
int delta =
HeapNumber::kExponentBias + base::Double::kPhysicalSignificandSize;
if (CpuFeatures::IsSupported(SSE3)) {
__ fstp(0);
}
@ -3129,10 +3130,11 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ sub(ecx, Immediate(delta));
__ neg(ecx);
__ mov(result_reg, exponent_operand);
__ and_(result_reg,
Immediate(static_cast<uint32_t>(Double::kSignificandMask >> 32)));
__ and_(
result_reg,
Immediate(static_cast<uint32_t>(base::Double::kSignificandMask >> 32)));
__ add(result_reg,
Immediate(static_cast<uint32_t>(Double::kHiddenBit >> 32)));
Immediate(static_cast<uint32_t>(base::Double::kHiddenBit >> 32)));
__ shrd_cl(scratch1, result_reg);
__ shr_cl(result_reg);
__ test(ecx, Immediate(32));

2
src/builtins/ppc/builtins-ppc.cc
View File

@ -527,7 +527,7 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
// Save callee-saved double registers.
__ MultiPushDoubles(kCalleeSavedDoubles);
// Set up the reserved register for 0.0.
__ LoadDoubleLiteral(kDoubleRegZero, Double(0.0), r0);
__ LoadDoubleLiteral(kDoubleRegZero, base::Double(0.0), r0);
// Initialize the root register.
// C calling convention. The first argument is passed in r3.

3
src/builtins/x64/builtins-x64.cc
View File

@ -3772,7 +3772,8 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ j(below, &process_64_bits, Label::kNear);
// Result is entirely in lower 32-bits of mantissa
int delta = HeapNumber::kExponentBias + Double::kPhysicalSignificandSize;
int delta =
HeapNumber::kExponentBias + base::Double::kPhysicalSignificandSize;
__ subl(rcx, Immediate(delta));
__ xorl(result_reg, result_reg);
__ cmpl(rcx, Immediate(31));

8
src/codegen/arm/assembler-arm.cc
View File

@ -2674,7 +2674,7 @@ void Assembler::vstm(BlockAddrMode am, Register base, SwVfpRegister first,
0xA * B8 | count);
}
static void DoubleAsTwoUInt32(Double d, uint32_t* lo, uint32_t* hi) {
static void DoubleAsTwoUInt32(base::Double d, uint32_t* lo, uint32_t* hi) {
uint64_t i = d.AsUint64();
*lo = i & 0xFFFFFFFF;
@ -2747,7 +2747,7 @@ void Assembler::vmov(const QwNeonRegister dst, uint64_t imm) {
// Only works for little endian floating point formats.
// We don't support VFP on the mixed endian floating point platform.
static bool FitsVmovFPImmediate(Double d, uint32_t* encoding) {
static bool FitsVmovFPImmediate(base::Double d, uint32_t* encoding) {
// VMOV can accept an immediate of the form:
//
// +/- m * 2^(-n) where 16 <= m <= 31 and 0 <= n <= 7
@ -2796,7 +2796,7 @@ static bool FitsVmovFPImmediate(Double d, uint32_t* encoding) {
void Assembler::vmov(const SwVfpRegister dst, Float32 imm) {
uint32_t enc;
if (CpuFeatures::IsSupported(VFPv3) &&
FitsVmovFPImmediate(Double(imm.get_scalar()), &enc)) {
FitsVmovFPImmediate(base::Double(imm.get_scalar()), &enc)) {
CpuFeatureScope scope(this, VFPv3);
// The float can be encoded in the instruction.
//
@ -2815,7 +2815,7 @@ void Assembler::vmov(const SwVfpRegister dst, Float32 imm) {
}
}
void Assembler::vmov(const DwVfpRegister dst, Double imm,
void Assembler::vmov(const DwVfpRegister dst, base::Double imm,
const Register extra_scratch) {
DCHECK(VfpRegisterIsAvailable(dst));
uint32_t enc;

4
src/codegen/arm/assembler-arm.h
View File

@ -45,13 +45,13 @@
#include <memory>
#include <vector>
#include "src/base/numbers/double.h"
#include "src/base/small-vector.h"
#include "src/codegen/arm/constants-arm.h"
#include "src/codegen/arm/register-arm.h"
#include "src/codegen/assembler.h"
#include "src/codegen/constant-pool.h"
#include "src/codegen/machine-type.h"
#include "src/numbers/double.h"
#include "src/utils/boxed-float.h"
namespace v8 {
@ -712,7 +712,7 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
SwVfpRegister last, Condition cond = al);
void vmov(const SwVfpRegister dst, Float32 imm);
void vmov(const DwVfpRegister dst, Double imm,
void vmov(const DwVfpRegister dst, base::Double imm,
const Register extra_scratch = no_reg);
void vmov(const SwVfpRegister dst, const SwVfpRegister src,
const Condition cond = al);

2
src/codegen/arm/macro-assembler-arm.cc
View File

@ -8,6 +8,7 @@
#include "src/base/bits.h"
#include "src/base/division-by-constant.h"
#include "src/base/numbers/double.h"
#include "src/base/utils/random-number-generator.h"
#include "src/codegen/assembler-inl.h"
#include "src/codegen/callable.h"
@ -21,7 +22,6 @@
#include "src/heap/memory-chunk.h"
#include "src/init/bootstrapper.h"
#include "src/logging/counters.h"
#include "src/numbers/double.h"
#include "src/objects/objects-inl.h"
#include "src/runtime/runtime.h"
#include "src/snapshot/snapshot.h"

8
src/codegen/constant-pool.h
View File

@ -7,10 +7,10 @@
#include <map>
#include "src/base/numbers/double.h"
#include "src/codegen/label.h"
#include "src/codegen/reloc-info.h"
#include "src/common/globals.h"
#include "src/numbers/double.h"
namespace v8 {
namespace internal {
@ -29,7 +29,7 @@ class ConstantPoolEntry {
merged_index_(sharing_ok ? SHARING_ALLOWED : SHARING_PROHIBITED),
value_(value),
rmode_(rmode) {}
ConstantPoolEntry(int position, Double value,
ConstantPoolEntry(int position, base::Double value,
RelocInfo::Mode rmode = RelocInfo::NONE)
: position_(position),
merged_index_(SHARING_ALLOWED),
@ -106,14 +106,14 @@ class ConstantPoolBuilder {
}
// Add double constant to the embedded constant pool
ConstantPoolEntry::Access AddEntry(int position, Double value) {
ConstantPoolEntry::Access AddEntry(int position, base::Double value) {
ConstantPoolEntry entry(position, value);
return AddEntry(&entry, ConstantPoolEntry::DOUBLE);
}
// Add double constant to the embedded constant pool
ConstantPoolEntry::Access AddEntry(int position, double value) {
return AddEntry(position, Double(value));
return AddEntry(position, base::Double(value));
}
// Previews the access type required for the next new entry to be added.

13
src/codegen/external-reference.cc
View File

@ -37,6 +37,7 @@
#ifdef V8_INTL_SUPPORT
#include "src/base/platform/wrappers.h"
#include "src/base/strings.h"
#include "src/objects/intl-objects.h"
#endif // V8_INTL_SUPPORT
@ -835,15 +836,15 @@ ExternalReference ExternalReference::search_string_raw_one_one() {
}
ExternalReference ExternalReference::search_string_raw_one_two() {
return search_string_raw<const uint8_t, const uc16>();
return search_string_raw<const uint8_t, const base::uc16>();
}
ExternalReference ExternalReference::search_string_raw_two_one() {
return search_string_raw<const uc16, const uint8_t>();
return search_string_raw<const base::uc16, const uint8_t>();
}
ExternalReference ExternalReference::search_string_raw_two_two() {
return search_string_raw<const uc16, const uc16>();
return search_string_raw<const base::uc16, const base::uc16>();
}
namespace {
@ -961,11 +962,11 @@ ExternalReference ExternalReference::intl_to_latin1_lower_table() {
template ExternalReference
ExternalReference::search_string_raw<const uint8_t, const uint8_t>();
template ExternalReference
ExternalReference::search_string_raw<const uint8_t, const uc16>();
ExternalReference::search_string_raw<const uint8_t, const base::uc16>();
template ExternalReference
ExternalReference::search_string_raw<const uc16, const uint8_t>();
ExternalReference::search_string_raw<const base::uc16, const uint8_t>();
template ExternalReference
ExternalReference::search_string_raw<const uc16, const uc16>();
ExternalReference::search_string_raw<const base::uc16, const base::uc16>();
ExternalReference ExternalReference::FromRawAddress(Address address) {
return ExternalReference(address);

2
src/codegen/mips64/macro-assembler-mips64.cc
View File

@ -2142,7 +2142,7 @@ void TurboAssembler::Neg_d(FPURegister fd, FPURegister fs) {
neg_d(fd, fs); // In delay slot.
bind(&is_nan);
dmfc1(scratch1, fs);
li(scratch2, Double::kSignMask);
li(scratch2, base::Double::kSignMask);
Xor(scratch1, scratch1, scratch2);
dmtc1(scratch1, fd);
bind(&done);

5
src/codegen/ppc/assembler-ppc.h
View File

@ -41,16 +41,17 @@
#define V8_CODEGEN_PPC_ASSEMBLER_PPC_H_
#include <stdio.h>
#include <memory>
#include <vector>
#include "src/base/numbers/double.h"
#include "src/codegen/assembler.h"
#include "src/codegen/constant-pool.h"
#include "src/codegen/external-reference.h"
#include "src/codegen/label.h"
#include "src/codegen/ppc/constants-ppc.h"
#include "src/codegen/ppc/register-ppc.h"
#include "src/numbers/double.h"
#include "src/objects/smi.h"
namespace v8 {
@ -1251,7 +1252,7 @@ class Assembler : public AssemblerBase {
!RelocInfo::IsWasmCall(rmode) && !RelocInfo::IsWasmStubCall(rmode));
return constant_pool_builder_.AddEntry(pc_offset(), value, sharing_ok);
}
ConstantPoolEntry::Access ConstantPoolAddEntry(Double value) {
ConstantPoolEntry::Access ConstantPoolAddEntry(base::Double value) {
return constant_pool_builder_.AddEntry(pc_offset(), value);
}

4
src/codegen/ppc/macro-assembler-ppc.cc
View File

@ -2341,8 +2341,8 @@ void TurboAssembler::LoadSmiLiteral(Register dst, Smi smi) {
mov(dst, Operand(smi));
}
void TurboAssembler::LoadDoubleLiteral(DoubleRegister result, Double value,
Register scratch) {
void TurboAssembler::LoadDoubleLiteral(DoubleRegister result,
base::Double value, Register scratch) {
if (FLAG_enable_embedded_constant_pool && is_constant_pool_available() &&
!(scratch == r0 && ConstantPoolAccessIsInOverflow())) {
ConstantPoolEntry::Access access = ConstantPoolAddEntry(value);

5
src/codegen/ppc/macro-assembler-ppc.h
View File

@ -9,10 +9,10 @@
#ifndef V8_CODEGEN_PPC_MACRO_ASSEMBLER_PPC_H_
#define V8_CODEGEN_PPC_MACRO_ASSEMBLER_PPC_H_
#include "src/base/numbers/double.h"
#include "src/codegen/bailout-reason.h"
#include "src/codegen/ppc/assembler-ppc.h"
#include "src/common/globals.h"
#include "src/numbers/double.h"
#include "src/objects/contexts.h"
namespace v8 {
@ -138,7 +138,8 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
mov(kRootRegister, Operand(isolate_root));
}
void LoadDoubleLiteral(DoubleRegister result, Double value, Register scratch);
void LoadDoubleLiteral(DoubleRegister result, base::Double value,
Register scratch);
void LoadSimd128(Simd128Register dst, const MemOperand& mem);
// load a literal signed int value <value> to GPR <dst>

8
src/common/globals.h
View File

@ -223,7 +223,7 @@ constexpr int kElidedFrameSlots = 0;
constexpr int kDoubleSizeLog2 = 3;
// The maximal length of the string representation for a double value
// (e.g. "-2.2250738585072020E-308"). It is composed as follows:
// - 17 decimal digits, see kBase10MaximalLength (dtoa.h)
// - 17 decimal digits, see base::kBase10MaximalLength (dtoa.h)
// - 1 sign
// - 1 decimal point
// - 1 E or e
@ -379,13 +379,7 @@ constexpr int kBinary32ExponentShift = 23;
// other bits set.
constexpr uint64_t kQuietNaNMask = static_cast<uint64_t>(0xfff) << 51;
// Latin1/UTF-16 constants
// Code-point values in Unicode 4.0 are 21 bits wide.
// Code units in UTF-16 are 16 bits wide.
using uc16 = uint16_t;
using uc32 = uint32_t;
constexpr int kOneByteSize = kCharSize;
constexpr int kUC16Size = sizeof(uc16);
// 128 bit SIMD value size.
constexpr int kSimd128Size = 16;

18
src/compiler/backend/arm/code-generator-arm.cc
View File

@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/numbers/double.h"
#include "src/codegen/arm/constants-arm.h"
#include "src/codegen/assembler-inl.h"
#include "src/codegen/macro-assembler.h"
@ -13,7 +14,6 @@
#include "src/compiler/node-matchers.h"
#include "src/compiler/osr.h"
#include "src/heap/memory-chunk.h"
#include "src/numbers/double.h"
#include "src/utils/boxed-float.h"
#if V8_ENABLE_WEBASSEMBLY
@ -2511,8 +2511,8 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
__ vshr(NeonS32, tmp, src, 31);
// Set i-th bit of each lane i. When AND with tmp, the lanes that
// are signed will have i-th bit set, unsigned will be 0.
__ vmov(mask.low(), Double(uint64_t{0x0000'0002'0000'0001}));
__ vmov(mask.high(), Double(uint64_t{0x0000'0008'0000'0004}));
__ vmov(mask.low(), base::Double(uint64_t{0x0000'0002'0000'0001}));
__ vmov(mask.high(), base::Double(uint64_t{0x0000'0008'0000'0004}));
__ vand(tmp, mask, tmp);
__ vpadd(Neon32, tmp.low(), tmp.low(), tmp.high());
__ vpadd(Neon32, tmp.low(), tmp.low(), kDoubleRegZero);
@ -2715,8 +2715,8 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
__ vshr(NeonS16, tmp, src, 15);
// Set i-th bit of each lane i. When AND with tmp, the lanes that
// are signed will have i-th bit set, unsigned will be 0.
__ vmov(mask.low(), Double(uint64_t{0x0008'0004'0002'0001}));
__ vmov(mask.high(), Double(uint64_t{0x0080'0040'0020'0010}));
__ vmov(mask.low(), base::Double(uint64_t{0x0008'0004'0002'0001}));
__ vmov(mask.high(), base::Double(uint64_t{0x0080'0040'0020'0010}));
__ vand(tmp, mask, tmp);
__ vpadd(Neon16, tmp.low(), tmp.low(), tmp.high());
__ vpadd(Neon16, tmp.low(), tmp.low(), tmp.low());
@ -2870,8 +2870,8 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
__ vshr(NeonS8, tmp, src, 7);
// Set i-th bit of each lane i. When AND with tmp, the lanes that
// are signed will have i-th bit set, unsigned will be 0.
__ vmov(mask.low(), Double(uint64_t{0x8040'2010'0804'0201}));
__ vmov(mask.high(), Double(uint64_t{0x8040'2010'0804'0201}));
__ vmov(mask.low(), base::Double(uint64_t{0x8040'2010'0804'0201}));
__ vmov(mask.high(), base::Double(uint64_t{0x8040'2010'0804'0201}));
__ vand(tmp, mask, tmp);
__ vext(mask, tmp, tmp, 8);
__ vzip(Neon8, mask, tmp);
@ -2885,8 +2885,8 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
QwNeonRegister dst = i.OutputSimd128Register();
uint64_t imm1 = make_uint64(i.InputUint32(1), i.InputUint32(0));
uint64_t imm2 = make_uint64(i.InputUint32(3), i.InputUint32(2));
__ vmov(dst.low(), Double(imm1));
__ vmov(dst.high(), Double(imm2));
__ vmov(dst.low(), base::Double(imm1));
__ vmov(dst.high(), base::Double(imm2));
break;
}
case kArmS128Zero: {

6
src/compiler/backend/instruction.h
View File

@ -11,6 +11,7 @@
#include <set>
#include "src/base/compiler-specific.h"
#include "src/base/numbers/double.h"
#include "src/codegen/external-reference.h"
#include "src/codegen/register-arch.h"
#include "src/codegen/source-position.h"
@ -20,7 +21,6 @@
#include "src/compiler/feedback-source.h"
#include "src/compiler/frame.h"
#include "src/compiler/opcodes.h"
#include "src/numbers/double.h"
#include "src/zone/zone-allocator.h"
namespace v8 {
@ -1147,9 +1147,9 @@ class V8_EXPORT_PRIVATE Constant final {
return bit_cast<uint32_t>(static_cast<int32_t>(value_));
}
Double ToFloat64() const {
base::Double ToFloat64() const {
DCHECK_EQ(kFloat64, type());
return Double(bit_cast<uint64_t>(value_));
return base::Double(bit_cast<uint64_t>(value_));
}
ExternalReference ToExternalReference() const {

14
src/compiler/backend/ppc/code-generator-ppc.cc
View File

@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/base/numbers/double.h"
#include "src/codegen/assembler-inl.h"
#include "src/codegen/callable.h"
#include "src/codegen/macro-assembler.h"
@ -12,7 +13,6 @@
#include "src/compiler/node-matchers.h"
#include "src/compiler/osr.h"
#include "src/heap/memory-chunk.h"
#include "src/numbers/double.h"
#if V8_ENABLE_WEBASSEMBLY
#include "src/wasm/wasm-code-manager.h"
@ -4435,7 +4435,7 @@ void CodeGenerator::AssembleMove(InstructionOperand* source,
DoubleRegister dst = destination->IsFPRegister()
? g.ToDoubleRegister(destination)
: kScratchDoubleReg;
Double value;
base::Double value;
#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
// casting double precision snan to single precision
// converts it to qnan on ia32/x64
@ -4445,17 +4445,17 @@ void CodeGenerator::AssembleMove(InstructionOperand* source,
uint64_t dval = static_cast<uint64_t>(val);
dval = ((dval & 0xC0000000) << 32) | ((dval & 0x40000000) << 31) |
((dval & 0x40000000) << 30) | ((dval & 0x7FFFFFFF) << 29);
value = Double(dval);
value = base::Double(dval);
} else {
value = Double(static_cast<double>(src.ToFloat32()));
value = base::Double(static_cast<double>(src.ToFloat32()));
}
} else {
value = Double(src.ToFloat64());
value = base::Double(src.ToFloat64());
}
#else
value = src.type() == Constant::kFloat32
? Double(static_cast<double>(src.ToFloat32()))
: Double(src.ToFloat64());
? base::Double(static_cast<double>(src.ToFloat32()))
: base::Double(src.ToFloat64());
#endif
__ LoadDoubleLiteral(dst, value, kScratchReg);
if (destination->IsDoubleStackSlot()) {

2
src/compiler/machine-operator-reducer.cc
View File

@ -544,7 +544,7 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
case IrOpcode::kFloat64Sub: {
Float64BinopMatcher m(node);
if (allow_signalling_nan_ && m.right().Is(0) &&
(Double(m.right().ResolvedValue()).Sign() > 0)) {
(base::Double(m.right().ResolvedValue()).Sign() > 0)) {
return Replace(m.left().node()); // x - 0 => x
}
if (m.right().IsNaN()) { // x - NaN => NaN

4
src/compiler/node-matchers.h
View File

@ -10,13 +10,13 @@
#include "src/base/bounds.h"
#include "src/base/compiler-specific.h"
#include "src/base/numbers/double.h"
#include "src/codegen/external-reference.h"
#include "src/common/globals.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/machine-operator.h"
#include "src/compiler/node.h"
#include "src/compiler/operator.h"
#include "src/numbers/double.h"
#include "src/objects/heap-object.h"
namespace v8 {
@ -216,7 +216,7 @@ struct FloatMatcher final : public ValueMatcher<T, kOpcode> {
if (!this->HasResolvedValue() || (this->ResolvedValue() == 0.0)) {
return false;
}
Double value = Double(this->ResolvedValue());
base::Double value = base::Double(this->ResolvedValue());
return !value.IsInfinite() && base::bits::IsPowerOfTwo(value.Significand());
}
};

1
src/diagnostics/objects-debug.cc
View File

@ -79,6 +79,7 @@
#include "torque-generated/class-verifiers.h"
#if V8_ENABLE_WEBASSEMBLY
#include "src/base/strings.h"
#include "src/debug/debug-wasm-objects-inl.h"
#include "src/wasm/wasm-objects-inl.h"
#endif // V8_ENABLE_WEBASSEMBLY

5
src/extensions/externalize-string-extension.cc
View File

@ -5,6 +5,7 @@
#include "src/extensions/externalize-string-extension.h"
#include "src/api/api-inl.h"
#include "src/base/strings.h"
#include "src/execution/isolate.h"
#include "src/handles/handles.h"
#include "src/objects/objects-inl.h"
@ -34,7 +35,7 @@ class SimpleStringResource : public Base {
using SimpleOneByteStringResource =
SimpleStringResource<char, v8::String::ExternalOneByteStringResource>;
using SimpleTwoByteStringResource =
SimpleStringResource<uc16, v8::String::ExternalStringResource>;
SimpleStringResource<base::uc16, v8::String::ExternalStringResource>;
const char* const ExternalizeStringExtension::kSource =
"native function externalizeString();"
@ -87,7 +88,7 @@ void ExternalizeStringExtension::Externalize(
result = Utils::ToLocal(string)->MakeExternal(resource);
if (!result) delete resource;
} else {
uc16* data = new uc16[string->length()];
base::uc16* data = new base::uc16[string->length()];
String::WriteToFlat(*string, data, 0, string->length());
SimpleTwoByteStringResource* resource = new SimpleTwoByteStringResource(
data, string->length());

6
src/heap/factory-base.cc
View File

@ -530,12 +530,12 @@ Handle<SeqOneByteString> FactoryBase<Impl>::NewOneByteInternalizedString(
template <typename Impl>
Handle<SeqTwoByteString> FactoryBase<Impl>::NewTwoByteInternalizedString(
const base::Vector<const uc16>& str, uint32_t raw_hash_field) {
const base::Vector<const base::uc16>& str, uint32_t raw_hash_field) {
Handle<SeqTwoByteString> result =
AllocateRawTwoByteInternalizedString(str.length(), raw_hash_field);
DisallowGarbageCollection no_gc;
MemCopy(result->GetChars(no_gc, SharedStringAccessGuardIfNeeded::NotNeeded()),
str.begin(), str.length() * kUC16Size);
str.begin(), str.length() * base::kUC16Size);
return result;
}
@ -643,7 +643,7 @@ MaybeHandle<String> FactoryBase<Impl>::NewConsString(
DisallowGarbageCollection no_gc;
SharedStringAccessGuardIfNeeded access_guard(isolate());
uc16* sink = result->GetChars(no_gc, access_guard);
base::uc16* sink = result->GetChars(no_gc, access_guard);
String::WriteToFlat(*left, sink, 0, left->length(), access_guard);
String::WriteToFlat(*right, sink + left->length(), 0, right->length(),
access_guard);

3
src/heap/factory-base.h
View File

@ -6,6 +6,7 @@
#define V8_HEAP_FACTORY_BASE_H_
#include "src/base/export-template.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
#include "src/objects/function-kind.h"
#include "src/objects/instance-type.h"
@ -182,7 +183,7 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) FactoryBase
Handle<SeqOneByteString> NewOneByteInternalizedString(
const base::Vector<const uint8_t>& str, uint32_t raw_hash_field);
Handle<SeqTwoByteString> NewTwoByteInternalizedString(
const base::Vector<const uc16>& str, uint32_t raw_hash_field);
const base::Vector<const base::uc16>& str, uint32_t raw_hash_field);
Handle<SeqOneByteString> AllocateRawOneByteInternalizedString(
int length, uint32_t raw_hash_field);

12
src/heap/factory.cc
View File

@ -689,7 +689,7 @@ Handle<String> Factory::InternalizeUtf8String(
std::unique_ptr<uint16_t[]> buffer(new uint16_t[decoder.utf16_length()]);
decoder.Decode(buffer.get(), utf8_data);
return InternalizeString(
base::Vector<const uc16>(buffer.get(), decoder.utf16_length()));
base::Vector<const base::uc16>(buffer.get(), decoder.utf16_length()));
}
template <typename SeqString>
@ -811,7 +811,7 @@ MaybeHandle<String> Factory::NewStringFromUtf8SubString(
return result;
}
MaybeHandle<String> Factory::NewStringFromTwoByte(const uc16* string,
MaybeHandle<String> Factory::NewStringFromTwoByte(const base::uc16* string,
int length,
AllocationType allocation) {
DCHECK_NE(allocation, AllocationType::kReadOnly);
@ -835,12 +835,12 @@ MaybeHandle<String> Factory::NewStringFromTwoByte(const uc16* string,
}
MaybeHandle<String> Factory::NewStringFromTwoByte(
const base::Vector<const uc16>& string, AllocationType allocation) {
const base::Vector<const base::uc16>& string, AllocationType allocation) {
return NewStringFromTwoByte(string.begin(), string.length(), allocation);
}
MaybeHandle<String> Factory::NewStringFromTwoByte(
const ZoneVector<uc16>* string, AllocationType allocation) {
const ZoneVector<base::uc16>* string, AllocationType allocation) {
return NewStringFromTwoByte(string->data(), static_cast<int>(string->size()),
allocation);
}
@ -979,7 +979,7 @@ Handle<String> Factory::NewSurrogatePairString(uint16_t lead, uint16_t trail) {
Handle<SeqTwoByteString> str =
isolate()->factory()->NewRawTwoByteString(2).ToHandleChecked();
DisallowGarbageCollection no_gc;
uc16* dest = str->GetChars(no_gc);
base::uc16* dest = str->GetChars(no_gc);
dest[0] = lead;
dest[1] = trail;
return str;
@ -1020,7 +1020,7 @@ Handle<String> Factory::NewProperSubString(Handle<String> str, int begin,
Handle<SeqTwoByteString> result =
NewRawTwoByteString(length).ToHandleChecked();
DisallowGarbageCollection no_gc;
uc16* dest = result->GetChars(no_gc);
base::uc16* dest = result->GetChars(no_gc);
String::WriteToFlat(*str, dest, begin, end);
return result;
}

9
src/heap/factory.h
View File

@ -7,6 +7,7 @@
// Clients of this interface shouldn't depend on lots of heap internals.
// Do not include anything from src/heap here!
#include "src/base/strings.h"
#include "src/base/vector.h"
#include "src/baseline/baseline.h"
#include "src/builtins/builtins.h"
@ -266,11 +267,11 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
AllocationType allocation = AllocationType::kYoung);
V8_WARN_UNUSED_RESULT MaybeHandle<String> NewStringFromTwoByte(
const base::Vector<const uc16>& str,
const base::Vector<const base::uc16>& str,
AllocationType allocation = AllocationType::kYoung);
V8_WARN_UNUSED_RESULT MaybeHandle<String> NewStringFromTwoByte(
const ZoneVector<uc16>* str,
const ZoneVector<base::uc16>* str,
AllocationType allocation = AllocationType::kYoung);
Handle<JSStringIterator> NewJSStringIterator(Handle<String> string);
@ -1007,9 +1008,9 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
uint32_t hash_field);
Handle<String> AllocateTwoByteInternalizedString(
const base::Vector<const uc16>& str, uint32_t hash_field);
const base::Vector<const base::uc16>& str, uint32_t hash_field);
MaybeHandle<String> NewStringFromTwoByte(const uc16* string, int length,
MaybeHandle<String> NewStringFromTwoByte(const base::uc16* string, int length,
AllocationType allocation);
// Attempt to find the number in a small cache. If we finds it, return

33
src/json/json-parser.cc
View File

@ -4,6 +4,7 @@
#include "src/json/json-parser.h"
#include "src/base/strings.h"
#include "src/common/message-template.h"
#include "src/debug/debug.h"
#include "src/numbers/conversions.h"
@ -281,7 +282,7 @@ void JsonParser<Char>::ReportUnexpectedToken(JsonToken token) {
}
template <typename Char>
void JsonParser<Char>::ReportUnexpectedCharacter(uc32 c) {
void JsonParser<Char>::ReportUnexpectedCharacter(base::uc32 c) {
JsonToken token = JsonToken::ILLEGAL;
if (c == kEndOfString) {
token = JsonToken::EOS;
@ -331,10 +332,10 @@ void JsonParser<Char>::SkipWhitespace() {
}
template <typename Char>
uc32 JsonParser<Char>::ScanUnicodeCharacter() {
uc32 value = 0;
base::uc32 JsonParser<Char>::ScanUnicodeCharacter() {
base::uc32 value = 0;
for (int i = 0; i < 4; i++) {
int digit = HexValue(NextCharacter());
int digit = base::HexValue(NextCharacter());
if (V8_UNLIKELY(digit < 0)) return kInvalidUnicodeCharacter;
value = value * 16 + digit;
}
@ -347,7 +348,7 @@ JsonString JsonParser<Char>::ScanJsonPropertyKey(JsonContinuation* cont) {
{
DisallowGarbageCollection no_gc;
const Char* start = cursor_;
uc32 first = CurrentCharacter();
base::uc32 first = CurrentCharacter();
if (first == '\\' && NextCharacter() == 'u') first = ScanUnicodeCharacter();
if (IsDecimalDigit(first)) {
if (first == '0') {
@ -891,7 +892,7 @@ Handle<Object> JsonParser<Char>::ParseJsonNumber() {
const Char* start = cursor_;
DisallowGarbageCollection no_gc;
uc32 c = *cursor_;
base::uc32 c = *cursor_;
if (c == '-') {
sign = -1;
c = NextCharacter();
@ -920,7 +921,7 @@ Handle<Object> JsonParser<Char>::ParseJsonNumber() {
ReportUnexpectedCharacter(CurrentCharacter());
return handle(Smi::FromInt(0), isolate_);
}
uc32 c = CurrentCharacter();
base::uc32 c = CurrentCharacter();
STATIC_ASSERT(Smi::IsValid(-999999999));
STATIC_ASSERT(Smi::IsValid(999999999));
const int kMaxSmiLength = 9;
@ -940,7 +941,7 @@ Handle<Object> JsonParser<Char>::ParseJsonNumber() {
}
if (CurrentCharacter() == '.') {
uc32 c = NextCharacter();
base::uc32 c = NextCharacter();
if (!IsDecimalDigit(c)) {
AllowGarbageCollection allow_before_exception;
ReportUnexpectedCharacter(c);
@ -950,7 +951,7 @@ Handle<Object> JsonParser<Char>::ParseJsonNumber() {
}
if (AsciiAlphaToLower(CurrentCharacter()) == 'e') {
uc32 c = NextCharacter();
base::uc32 c = NextCharacter();
if (c == '-' || c == '+') c = NextCharacter();
if (!IsDecimalDigit(c)) {
AllowGarbageCollection allow_before_exception;
@ -1080,12 +1081,12 @@ void JsonParser<Char>::DecodeString(SinkChar* sink, int start, int length) {
break;
case EscapeKind::kUnicode: {
uc32 value = 0;
base::uc32 value = 0;
for (int i = 0; i < 4; i++) {
value = value * 16 + HexValue(*++cursor);
value = value * 16 + base::HexValue(*++cursor);
}
if (value <=
static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
static_cast<base::uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
*sink++ = value;
} else {
*sink++ = unibrow::Utf16::LeadSurrogate(value);
@ -1107,7 +1108,7 @@ JsonString JsonParser<Char>::ScanJsonString(bool needs_internalization) {
int start = position();
int offset = start;
bool has_escape = false;
uc32 bits = 0;
base::uc32 bits = 0;
while (true) {
cursor_ = std::find_if(cursor_, end_, [&bits](Char c) {
@ -1136,7 +1137,7 @@ JsonString JsonParser<Char>::ScanJsonString(bool needs_internalization) {
if (*cursor_ == '\\') {
has_escape = true;
uc32 c = NextCharacter();
base::uc32 c = NextCharacter();
if (V8_UNLIKELY(!base::IsInRange(
c, 0, static_cast<int32_t>(unibrow::Latin1::kMaxChar)))) {
AllowGarbageCollection allow_before_exception;
@ -1155,7 +1156,7 @@ JsonString JsonParser<Char>::ScanJsonString(bool needs_internalization) {
break;
case EscapeKind::kUnicode: {
uc32 value = ScanUnicodeCharacter();
base::uc32 value = ScanUnicodeCharacter();
if (value == kInvalidUnicodeCharacter) {
AllowGarbageCollection allow_before_exception;
ReportUnexpectedCharacter(CurrentCharacter());
@ -1164,7 +1165,7 @@ JsonString JsonParser<Char>::ScanJsonString(bool needs_internalization) {
bits |= value;
// \uXXXX results in either 1 or 2 Utf16 characters, depending on
// whether the decoded value requires a surrogate pair.
offset += 5 - (value > static_cast<uc32>(
offset += 5 - (value > static_cast<base::uc32>(
unibrow::Utf16::kMaxNonSurrogateCharCode));
break;
}

14
src/json/json-parser.h
View File

@ -6,6 +6,7 @@
#define V8_JSON_JSON_PARSER_H_
#include "src/base/small-vector.h"
#include "src/base/strings.h"
#include "src/execution/isolate.h"
#include "src/heap/factory.h"
#include "src/objects/objects.h"
@ -152,8 +153,9 @@ class JsonParser final {
return result;
}
static constexpr uc32 kEndOfString = static_cast<uc32>(-1);
static constexpr uc32 kInvalidUnicodeCharacter = static_cast<uc32>(-1);
static constexpr base::uc32 kEndOfString = static_cast<base::uc32>(-1);
static constexpr base::uc32 kInvalidUnicodeCharacter =
static_cast<base::uc32>(-1);
private:
template <typename T>
@ -186,12 +188,12 @@ class JsonParser final {
void advance() { ++cursor_; }
uc32 CurrentCharacter() {
base::uc32 CurrentCharacter() {
if (V8_UNLIKELY(is_at_end())) return kEndOfString;
return *cursor_;
}
uc32 NextCharacter() {
base::uc32 NextCharacter() {
advance();
return CurrentCharacter();
}
@ -263,7 +265,7 @@ class JsonParser final {
// four-digit hex escapes (uXXXX). Any other use of backslashes is invalid.
JsonString ScanJsonString(bool needs_internalization);
JsonString ScanJsonPropertyKey(JsonContinuation* cont);
uc32 ScanUnicodeCharacter();
base::uc32 ScanUnicodeCharacter();
Handle<String> MakeString(const JsonString& string,
Handle<String> hint = Handle<String>());
@ -296,7 +298,7 @@ class JsonParser final {
const SmallVector<Handle<Object>>& element_stack);
// Mark that a parsing error has happened at the current character.
void ReportUnexpectedCharacter(uc32 c);
void ReportUnexpectedCharacter(base::uc32 c);
// Mark that a parsing error has happened at the current token.
void ReportUnexpectedToken(JsonToken token);

15
src/json/json-stringifier.cc
View File

@ -4,6 +4,7 @@
#include "src/json/json-stringifier.h"
#include "src/base/strings.h"
#include "src/common/message-template.h"
#include "src/numbers/conversions.h"
#include "src/objects/heap-number-inl.h"
@ -127,7 +128,7 @@ class JsonStringifier {
Handle<String> tojson_string_;
Handle<FixedArray> property_list_;
Handle<JSReceiver> replacer_function_;
uc16* gap_;
base::uc16* gap_;
int indent_;
using KeyObject = std::pair<Handle<Object>, Handle<Object>>;
@ -303,7 +304,7 @@ bool JsonStringifier::InitializeGap(Handle<Object> gap) {
Handle<String> gap_string = Handle<String>::cast(gap);
if (gap_string->length() > 0) {
int gap_length = std::min(gap_string->length(), 10);
gap_ = NewArray<uc16>(gap_length + 1);
gap_ = NewArray<base::uc16>(gap_length + 1);
String::WriteToFlat(*gap_string, gap_, 0, gap_length);
for (int i = 0; i < gap_length; i++) {
if (gap_[i] > String::kMaxOneByteCharCode) {
@ -317,7 +318,7 @@ bool JsonStringifier::InitializeGap(Handle<Object> gap) {
int num_value = DoubleToInt32(gap->Number());
if (num_value > 0) {
int gap_length = std::min(num_value, 10);
gap_ = NewArray<uc16>(gap_length + 1);
gap_ = NewArray<base::uc16>(gap_length + 1);
for (int i = 0; i < gap_length; i++) gap_[i] = ' ';
gap_[gap_length] = '\0';
}
@ -877,8 +878,8 @@ template <typename SrcChar, typename DestChar>
void JsonStringifier::SerializeStringUnchecked_(
base::Vector<const SrcChar> src,
IncrementalStringBuilder::NoExtend<DestChar>* dest) {
// Assert that uc16 character is not truncated down to 8 bit.
// The <uc16, char> version of this method must not be called.
// Assert that base::uc16 character is not truncated down to 8 bit.
// The <base::uc16, char> version of this method must not be called.
DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
for (int i = 0; i < src.length(); i++) {
SrcChar c = src[i];
@ -1036,9 +1037,9 @@ void JsonStringifier::SerializeString(Handle<String> object) {
}
} else {
if (String::IsOneByteRepresentationUnderneath(*object)) {
SerializeString_<uint8_t, uc16>(object);
SerializeString_<uint8_t, base::uc16>(object);
} else {
SerializeString_<uc16, uc16>(object);
SerializeString_<base::uc16, base::uc16>(object);
}
}
}

10
src/numbers/conversions-inl.h
View File

@ -15,10 +15,10 @@
// Extra POSIX/ANSI functions for Win32/MSVC.
#include "src/base/bits.h"
#include "src/base/numbers/double.h"
#include "src/base/platform/platform.h"
#include "src/base/platform/wrappers.h"
#include "src/numbers/conversions.h"
#include "src/numbers/double.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/objects-inl.h"
@ -94,11 +94,11 @@ int32_t DoubleToInt32(double x) {
// All doubles within these limits are trivially convertable to an int.
return static_cast<int32_t>(x);
}
Double d(x);
base::Double d(x);
int exponent = d.Exponent();
uint64_t bits;
if (exponent < 0) {
if (exponent <= -Double::kSignificandSize) return 0;
if (exponent <= -base::Double::kSignificandSize) return 0;
bits = d.Significand() >> -exponent;
} else {
if (exponent > 31) return 0;
@ -118,11 +118,11 @@ inline int64_t DoubleToWebIDLInt64(double x) {
// All doubles within these limits are trivially convertable to an int.
return static_cast<int64_t>(x);
}
Double d(x);
base::Double d(x);
int exponent = d.Exponent();
uint64_t bits;
if (exponent < 0) {
if (exponent <= -Double::kSignificandSize) return 0;
if (exponent <= -base::Double::kSignificandSize) return 0;
bits = d.Significand() >> -exponent;
} else {
if (exponent > 63) return 0;

63
src/numbers/conversions.cc
View File

@ -9,12 +9,12 @@
#include <cmath>
#include "src/base/numbers/dtoa.h"
#include "src/base/numbers/strtod.h"
#include "src/base/platform/wrappers.h"
#include "src/common/assert-scope.h"
#include "src/handles/handles.h"
#include "src/heap/factory.h"
#include "src/numbers/dtoa.h"
#include "src/numbers/strtod.h"
#include "src/objects/bigint.h"
#include "src/objects/objects-inl.h"
#include "src/objects/string-inl.h"
@ -143,7 +143,7 @@ inline double JunkStringValue() {
}
inline double SignedZero(bool negative) {
return negative ? uint64_to_double(Double::kSignMask) : 0.0;
return negative ? base::uint64_to_double(base::Double::kSignMask) : 0.0;
}
inline bool isDigit(int x, int radix) {
@ -340,7 +340,7 @@ class StringToIntHelper {
return subject_->GetFlatContent(no_gc).ToOneByteVector();
}
base::Vector<const uc16> GetTwoByteVector() {
base::Vector<const base::uc16> GetTwoByteVector() {
DisallowGarbageCollection no_gc;
return subject_->GetFlatContent(no_gc).ToUC16Vector();
}
@ -381,7 +381,7 @@ void StringToIntHelper<IsolateT>::ParseInt() {
base::Vector<const uint8_t> vector = GetOneByteVector();
DetectRadixInternal(vector.begin(), vector.length());
} else {
base::Vector<const uc16> vector = GetTwoByteVector();
base::Vector<const base::uc16> vector = GetTwoByteVector();
DetectRadixInternal(vector.begin(), vector.length());
}
}
@ -399,7 +399,7 @@ void StringToIntHelper<IsolateT>::ParseInt() {
break;
}
} else {
base::Vector<const uc16> vector = GetTwoByteVector();
base::Vector<const base::uc16> vector = GetTwoByteVector();
DCHECK_EQ(length_, vector.length());
if (ParseChunkInternal(vector.begin())) {
break;
@ -612,7 +612,7 @@ class NumberParseIntHelper : public StringToIntHelper<Isolate> {
result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
: HandleBaseTenCase(vector.begin());
} else {
base::Vector<const uc16> vector = GetTwoByteVector();
base::Vector<const base::uc16> vector = GetTwoByteVector();
DCHECK_EQ(length(), vector.length());
result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
: HandleBaseTenCase(vector.begin());
@ -957,9 +957,9 @@ double StringToDouble(base::Vector<const uint8_t> str, int flags,
empty_string_val);
}
double StringToDouble(base::Vector<const uc16> str, int flags,
double StringToDouble(base::Vector<const base::uc16> str, int flags,
double empty_string_val) {
const uc16* end = str.begin() + str.length();
const base::uc16* end = str.begin() + str.length();
return InternalStringToDouble(str.begin(), end, flags, empty_string_val);
}
@ -1099,13 +1099,14 @@ const char* DoubleToCString(double v, base::Vector<char> buffer) {
SimpleStringBuilder builder(buffer.begin(), buffer.length());
int decimal_point;
int sign;
const int kV8DtoaBufferCapacity = kBase10MaximalLength + 1;
const int kV8DtoaBufferCapacity = base::kBase10MaximalLength + 1;
char decimal_rep[kV8DtoaBufferCapacity];
int length;
DoubleToAscii(v, DTOA_SHORTEST, 0,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
&sign, &length, &decimal_point);
base::DoubleToAscii(
v, base::DTOA_SHORTEST, 0,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
&length, &decimal_point);
if (sign) builder.AddCharacter('-');
@ -1191,9 +1192,9 @@ char* DoubleToFixedCString(double value, int f) {
kMaxDigitsBeforePoint + kMaxFractionDigits + 1;
char decimal_rep[kDecimalRepCapacity];
int decimal_rep_length;
DoubleToAscii(value, DTOA_FIXED, f,
base::Vector<char>(decimal_rep, kDecimalRepCapacity), &sign,
&decimal_rep_length, &decimal_point);
base::DoubleToAscii(value, base::DTOA_FIXED, f,
base::Vector<char>(decimal_rep, kDecimalRepCapacity),
&sign, &decimal_rep_length, &decimal_point);
// Create a representation that is padded with zeros if needed.
int zero_prefix_length = 0;
@ -1281,19 +1282,19 @@ char* DoubleToExponentialCString(double value, int f) {
const int kV8DtoaBufferCapacity = kMaxFractionDigits + 1 + 1;
// Make sure that the buffer is big enough, even if we fall back to the
// shortest representation (which happens when f equals -1).
DCHECK_LE(kBase10MaximalLength, kMaxFractionDigits + 1);
DCHECK_LE(base::kBase10MaximalLength, kMaxFractionDigits + 1);
char decimal_rep[kV8DtoaBufferCapacity];
int decimal_rep_length;
if (f == -1) {
DoubleToAscii(value, DTOA_SHORTEST, 0,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
&decimal_rep_length, &decimal_point);
base::DoubleToAscii(value, base::DTOA_SHORTEST, 0,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
&sign, &decimal_rep_length, &decimal_point);
f = decimal_rep_length - 1;
} else {
DoubleToAscii(value, DTOA_PRECISION, f + 1,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
&decimal_rep_length, &decimal_point);
base::DoubleToAscii(value, base::DTOA_PRECISION, f + 1,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
&sign, &decimal_rep_length, &decimal_point);
}
DCHECK_GT(decimal_rep_length, 0);
DCHECK(decimal_rep_length <= f + 1);
@ -1324,9 +1325,9 @@ char* DoubleToPrecisionCString(double value, int p) {
char decimal_rep[kV8DtoaBufferCapacity];
int decimal_rep_length;
DoubleToAscii(value, DTOA_PRECISION, p,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
&decimal_rep_length, &decimal_point);
base::DoubleToAscii(value, base::DTOA_PRECISION, p,
base::Vector<char>(decimal_rep, kV8DtoaBufferCapacity),
&sign, &decimal_rep_length, &decimal_point);
DCHECK(decimal_rep_length <= p);
int exponent = decimal_point - 1;
@ -1398,8 +1399,8 @@ char* DoubleToRadixCString(double value, int radix) {
double integer = std::floor(value);
double fraction = value - integer;
// We only compute fractional digits up to the input double's precision.
double delta = 0.5 * (Double(value).NextDouble() - value);
delta = std::max(Double(0.0).NextDouble(), delta);
double delta = 0.5 * (base::Double(value).NextDouble() - value);
delta = std::max(base::Double(0.0).NextDouble(), delta);
DCHECK_GT(delta, 0.0);
if (fraction >= delta) {
// Insert decimal point.
@ -1440,7 +1441,7 @@ char* DoubleToRadixCString(double value, int radix) {
}
// Compute integer digits. Fill unrepresented digits with zero.
while (Double(integer / radix).Exponent() > 0) {
while (base::Double(integer / radix).Exponent() > 0) {
integer /= radix;
buffer[--integer_cursor] = '0';
}
@ -1487,10 +1488,10 @@ base::Optional<double> TryStringToDouble(LocalIsolate* isolate,
}
const int flags = ALLOW_HEX | ALLOW_OCTAL | ALLOW_BINARY;
auto buffer = std::make_unique<uc16[]>(max_length_for_conversion);
auto buffer = std::make_unique<base::uc16[]>(max_length_for_conversion);
SharedStringAccessGuardIfNeeded access_guard(isolate);
String::WriteToFlat(*object, buffer.get(), 0, length, access_guard);
base::Vector<const uc16> v(buffer.get(), length);
base::Vector<const base::uc16> v(buffer.get(), length);
return StringToDouble(v, flags);
}

3
src/numbers/conversions.h
View File

@ -8,6 +8,7 @@
#include "src/base/export-template.h"
#include "src/base/logging.h"
#include "src/base/optional.h"
#include "src/base/strings.h"
#include "src/base/vector.h"
#include "src/common/globals.h"
@ -89,7 +90,7 @@ enum ConversionFlags {
// Converts a string into a double value according to ECMA-262 9.3.1
double StringToDouble(base::Vector<const uint8_t> str, int flags,
double empty_string_val = 0);
double StringToDouble(base::Vector<const uc16> str, int flags,
double StringToDouble(base::Vector<const base::uc16> str, int flags,
double empty_string_val = 0);
// This version expects a zero-terminated character array.
double V8_EXPORT_PRIVATE StringToDouble(const char* str, int flags,

20
src/objects/bigint.cc
View File

@ -19,12 +19,12 @@
#include "src/objects/bigint.h"
#include "src/base/numbers/double.h"
#include "src/bigint/bigint.h"
#include "src/execution/isolate-inl.h"
#include "src/heap/factory.h"
#include "src/heap/heap-write-barrier-inl.h"
#include "src/numbers/conversions.h"
#include "src/numbers/double.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/instance-type-inl.h"
#include "src/objects/objects-inl.h"
@ -295,7 +295,8 @@ Handle<BigInt> MutableBigInt::NewFromDouble(Isolate* isolate, double value) {
bool sign = value < 0; // -0 was already handled above.
uint64_t double_bits = bit_cast<uint64_t>(value);
int raw_exponent =
static_cast<int>(double_bits >> Double::kPhysicalSignificandSize) & 0x7FF;
static_cast<int>(double_bits >> base::Double::kPhysicalSignificandSize) &
0x7FF;
DCHECK_NE(raw_exponent, 0x7FF);
DCHECK_GE(raw_exponent, 0x3FF);
int exponent = raw_exponent - 0x3FF;
@ -314,8 +315,8 @@ Handle<BigInt> MutableBigInt::NewFromDouble(Isolate* isolate, double value) {
// msd_topbit kDigitBits
//
uint64_t mantissa =
(double_bits & Double::kSignificandMask) | Double::kHiddenBit;
const int kMantissaTopBit = Double::kSignificandSize - 1; // 0-indexed.
(double_bits & base::Double::kSignificandMask) | base::Double::kHiddenBit;
const int kMantissaTopBit = base::Double::kSignificandSize - 1; // 0-indexed.
// 0-indexed position of most significant bit in the most significant digit.
int msd_topbit = exponent % kDigitBits;
// Number of unused bits in {mantissa}. We'll keep them shifted to the
@ -912,8 +913,9 @@ ComparisonResult BigInt::CompareToDouble(Handle<BigInt> x, double y) {
}
uint64_t double_bits = bit_cast<uint64_t>(y);
int raw_exponent =
static_cast<int>(double_bits >> Double::kPhysicalSignificandSize) & 0x7FF;
uint64_t mantissa = double_bits & Double::kSignificandMask;
static_cast<int>(double_bits >> base::Double::kPhysicalSignificandSize) &
0x7FF;
uint64_t mantissa = double_bits & base::Double::kSignificandMask;
// Non-finite doubles are handled above.
DCHECK_NE(raw_exponent, 0x7FF);
int exponent = raw_exponent - 0x3FF;
@ -944,7 +946,7 @@ ComparisonResult BigInt::CompareToDouble(Handle<BigInt> x, double y) {
// <--> <------>
// msd_topbit kDigitBits
//
mantissa |= Double::kHiddenBit;
mantissa |= base::Double::kHiddenBit;
const int kMantissaTopBit = 52; // 0-indexed.
// 0-indexed position of {x}'s most significant bit within the {msd}.
int msd_topbit = kDigitBits - 1 - msd_leading_zeros;
@ -1107,7 +1109,7 @@ double MutableBigInt::ToDouble(Handle<BigIntBase> x) {
mantissa++;
// Incrementing the mantissa can overflow the mantissa bits. In that case
// the new mantissa will be all zero (plus hidden bit).
if ((mantissa >> Double::kPhysicalSignificandSize) != 0) {
if ((mantissa >> base::Double::kPhysicalSignificandSize) != 0) {
mantissa = 0;
exponent++;
// Incrementing the exponent can overflow too.
@ -1118,7 +1120,7 @@ double MutableBigInt::ToDouble(Handle<BigIntBase> x) {
}
// Assemble the result.
uint64_t sign_bit = x->sign() ? (static_cast<uint64_t>(1) << 63) : 0;
exponent = (exponent + 0x3FF) << Double::kPhysicalSignificandSize;
exponent = (exponent + 0x3FF) << base::Double::kPhysicalSignificandSize;
uint64_t double_bits = sign_bit | exponent | mantissa;
return bit_cast<double>(double_bits);
}

11
src/objects/intl-objects.cc
View File

@ -14,6 +14,7 @@
#include <vector>
#include "src/api/api-inl.h"
#include "src/base/strings.h"
#include "src/execution/isolate.h"
#include "src/handles/global-handles.h"
#include "src/heap/factory.h"
@ -163,12 +164,12 @@ inline int FindFirstUpperOrNonAscii(String s, int length) {
}
const UChar* GetUCharBufferFromFlat(const String::FlatContent& flat,
std::unique_ptr<uc16[]>* dest,
std::unique_ptr<base::uc16[]>* dest,
int32_t length) {
DCHECK(flat.IsFlat());
if (flat.IsOneByte()) {
if (!*dest) {
dest->reset(NewArray<uc16>(length));
dest->reset(NewArray<base::uc16>(length));
CopyChars(dest->get(), flat.ToOneByteVector().begin(), length);
}
return reinterpret_cast<const UChar*>(dest->get());
@ -195,7 +196,7 @@ icu::UnicodeString Intl::ToICUUnicodeString(Isolate* isolate,
Handle<String> string) {
DCHECK(string->IsFlat());
DisallowGarbageCollection no_gc;
std::unique_ptr<uc16[]> sap;
std::unique_ptr<base::uc16[]> sap;
// Short one-byte strings can be expanded on the stack to avoid allocating a
// temporary buffer.
constexpr int kShortStringSize = 80;
@ -237,7 +238,7 @@ MaybeHandle<String> LocaleConvertCase(Isolate* isolate, Handle<String> s,
int32_t dest_length = src_length;
UErrorCode status;
Handle<SeqTwoByteString> result;
std::unique_ptr<uc16[]> sap;
std::unique_ptr<base::uc16[]> sap;
if (dest_length == 0) return ReadOnlyRoots(isolate).empty_string_handle();
@ -1960,7 +1961,7 @@ MaybeHandle<String> Intl::Normalize(Isolate* isolate, Handle<String> string,
int length = string->length();
string = String::Flatten(isolate, string);
icu::UnicodeString result;
std::unique_ptr<uc16[]> sap;
std::unique_ptr<base::uc16[]> sap;
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString input = ToICUUnicodeString(isolate, string);
// Getting a singleton. Should not free it.

5
src/objects/js-regexp.cc
View File

@ -4,6 +4,7 @@
#include "src/objects/js-regexp.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
#include "src/objects/js-array-inl.h"
#include "src/objects/js-regexp-inl.h"
@ -383,7 +384,7 @@ MaybeHandle<String> EscapeRegExpSource(Isolate* isolate,
bool needs_escapes = false;
int additional_escape_chars =
one_byte ? CountAdditionalEscapeChars<uint8_t>(source, &needs_escapes)
: CountAdditionalEscapeChars<uc16>(source, &needs_escapes);
: CountAdditionalEscapeChars<base::uc16>(source, &needs_escapes);
if (!needs_escapes) return source;
int length = source->length() + additional_escape_chars;
if (one_byte) {
@ -397,7 +398,7 @@ MaybeHandle<String> EscapeRegExpSource(Isolate* isolate,
ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
isolate->factory()->NewRawTwoByteString(length),
String);
return WriteEscapedRegExpSource<uc16>(source, result);
return WriteEscapedRegExpSource<base::uc16>(source, result);
}
}

4
src/objects/objects-inl.h
View File

@ -14,6 +14,7 @@
#include "src/base/bits.h"
#include "src/base/memory.h"
#include "src/base/numbers/double.h"
#include "src/builtins/builtins.h"
#include "src/common/external-pointer-inl.h"
#include "src/common/globals.h"
@ -22,7 +23,6 @@
#include "src/heap/heap-write-barrier-inl.h"
#include "src/heap/read-only-heap-inl.h"
#include "src/numbers/conversions-inl.h"
#include "src/numbers/double.h"
#include "src/objects/bigint.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/heap-object.h"
@ -1056,7 +1056,7 @@ Object Object::GetSimpleHash(Object object) {
if (num >= kMinInt && num <= kMaxInt && FastI2D(FastD2I(num)) == num) {
hash = ComputeUnseededHash(FastD2I(num));
} else {
hash = ComputeLongHash(double_to_uint64(num));
hash = ComputeLongHash(base::double_to_uint64(num));
}
return Smi::FromInt(hash & Smi::kMaxValue);
}

3
src/objects/stack-frame-info.cc
View File

@ -4,6 +4,7 @@
#include "src/objects/stack-frame-info.h"
#include "src/base/strings.h"
#include "src/objects/shared-function-info.h"
#include "src/objects/stack-frame-info-inl.h"
#include "src/strings/string-builder-inl.h"
@ -618,7 +619,7 @@ bool StringEndsWithMethodName(Isolate* isolate, Handle<String> subject,
return false;
}
const uc32 subject_char = subject_reader.Get(subject_index);
const base::uc32 subject_char = subject_reader.Get(subject_index);
if (i == pattern_reader.length()) {
if (subject_char != '.') return false;
} else if (subject_char != pattern_reader.Get(pattern_index)) {

25
src/objects/string-inl.h
View File

@ -300,11 +300,11 @@ bool String::IsOneByteRepresentationUnderneath(String string) {
}
}
uc32 FlatStringReader::Get(int index) const {
base::uc32 FlatStringReader::Get(int index) const {
if (is_one_byte_) {
return Get<uint8_t>(index);
} else {
return Get<uc16>(index);
return Get<base::uc16>(index);
}
}
@ -315,7 +315,7 @@ Char FlatStringReader::Get(int index) const {
if (sizeof(Char) == 1) {
return static_cast<Char>(static_cast<const uint8_t*>(start_)[index]);
} else {
return static_cast<Char>(static_cast<const uc16*>(start_)[index]);
return static_cast<Char>(static_cast<const base::uc16*>(start_)[index]);
}
}
@ -766,7 +766,7 @@ inline base::Vector<const uint8_t> String::GetCharVector(
}
template <>
inline base::Vector<const uc16> String::GetCharVector(
inline base::Vector<const base::uc16> String::GetCharVector(
const DisallowGarbageCollection& no_gc) {
String::FlatContent flat = GetFlatContent(no_gc);
DCHECK(flat.IsTwoByte());
@ -813,18 +813,19 @@ Address SeqTwoByteString::GetCharsAddress() const {
return field_address(kHeaderSize);
}
uc16* SeqTwoByteString::GetChars(const DisallowGarbageCollection& no_gc) const {
base::uc16* SeqTwoByteString::GetChars(
const DisallowGarbageCollection& no_gc) const {
USE(no_gc);
DCHECK(!SharedStringAccessGuardIfNeeded::IsNeeded(*this));
return reinterpret_cast<uc16*>(GetCharsAddress());
return reinterpret_cast<base::uc16*>(GetCharsAddress());
}
uc16* SeqTwoByteString::GetChars(
base::uc16* SeqTwoByteString::GetChars(
const DisallowGarbageCollection& no_gc,
const SharedStringAccessGuardIfNeeded& access_guard) const {
USE(no_gc);
USE(access_guard);
return reinterpret_cast<uc16*>(GetCharsAddress());
return reinterpret_cast<base::uc16*>(GetCharsAddress());
}
uint16_t SeqTwoByteString::Get(
@ -1193,13 +1194,13 @@ class SubStringRange::iterator final {
public:
using iterator_category = std::forward_iterator_tag;
using difference_type = int;
using value_type = uc16;
using pointer = uc16*;
using reference = uc16&;
using value_type = base::uc16;
using pointer = base::uc16*;
using reference = base::uc16&;
iterator(const iterator& other) = default;
uc16 operator*() { return content_.Get(offset_); }
base::uc16 operator*() { return content_.Get(offset_); }
bool operator==(const iterator& other) const {
return content_.UsesSameString(other.content_) && offset_ == other.offset_;
}

24
src/objects/string.cc
View File

@ -156,7 +156,7 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) {
if (FLAG_enable_slow_asserts) {
// Assert that the resource and the string are equivalent.
DCHECK(static_cast<size_t>(this->length()) == resource->length());
base::ScopedVector<uc16> smart_chars(this->length());
base::ScopedVector<base::uc16> smart_chars(this->length());
String::WriteToFlat(*this, smart_chars.begin(), 0, this->length());
DCHECK_EQ(0, memcmp(smart_chars.begin(), resource->data(),
resource->length() * sizeof(smart_chars[0])));
@ -572,7 +572,7 @@ String::FlatContent String::GetFlatContent(
return FlatContent(start + offset, length, no_gc);
} else {
DCHECK_EQ(shape.encoding_tag(), kTwoByteStringTag);
const uc16* start;
const base::uc16* start;
if (shape.representation_tag() == kSeqStringTag) {
start = SeqTwoByteString::cast(string).GetChars(no_gc);
} else {
@ -654,7 +654,7 @@ void String::WriteToFlat(String source, sinkchar* sink, int from, int to,
return;
}
case kTwoByteStringTag | kExternalStringTag: {
const uc16* data = ExternalTwoByteString::cast(source).GetChars();
const base::uc16* data = ExternalTwoByteString::cast(source).GetChars();
CopyChars(sink, data + from, to - from);
return;
}
@ -947,16 +947,16 @@ ComparisonResult String::Compare(Isolate* isolate, Handle<String> x,
base::Vector<const uint8_t> y_chars = y_content.ToOneByteVector();
r = CompareChars(x_chars.begin(), y_chars.begin(), prefix_length);
} else {
base::Vector<const uc16> y_chars = y_content.ToUC16Vector();
base::Vector<const base::uc16> y_chars = y_content.ToUC16Vector();
r = CompareChars(x_chars.begin(), y_chars.begin(), prefix_length);
}
} else {
base::Vector<const uc16> x_chars = x_content.ToUC16Vector();
base::Vector<const base::uc16> x_chars = x_content.ToUC16Vector();
if (y_content.IsOneByte()) {
base::Vector<const uint8_t> y_chars = y_content.ToOneByteVector();
r = CompareChars(x_chars.begin(), y_chars.begin(), prefix_length);
} else {
base::Vector<const uc16> y_chars = y_content.ToUC16Vector();
base::Vector<const base::uc16> y_chars = y_content.ToUC16Vector();
r = CompareChars(x_chars.begin(), y_chars.begin(), prefix_length);
}
}
@ -1043,9 +1043,9 @@ int String::IndexOf(Isolate* isolate, Handle<String> receiver,
return SearchString<const uint8_t>(isolate, receiver_content, pat_vector,
start_index);
}
base::Vector<const uc16> pat_vector = search_content.ToUC16Vector();
return SearchString<const uc16>(isolate, receiver_content, pat_vector,
start_index);
base::Vector<const base::uc16> pat_vector = search_content.ToUC16Vector();
return SearchString<const base::uc16>(isolate, receiver_content, pat_vector,
start_index);
}
MaybeHandle<String> String::GetSubstitution(Isolate* isolate, Match* match,
@ -1219,7 +1219,7 @@ int StringMatchBackwards(base::Vector<const schar> subject,
if (sizeof(schar) == 1 && sizeof(pchar) > 1) {
for (int i = 0; i < pattern_length; i++) {
uc16 c = pattern[i];
base::uc16 c = pattern[i];
if (c > String::kMaxOneByteCharCode) {
return -1;
}
@ -1304,7 +1304,7 @@ Object String::LastIndexOf(Isolate* isolate, Handle<Object> receiver,
pat_vector, start_index);
}
} else {
base::Vector<const uc16> pat_vector = search_content.ToUC16Vector();
base::Vector<const base::uc16> pat_vector = search_content.ToUC16Vector();
if (receiver_content.IsOneByte()) {
last_index = StringMatchBackwards(receiver_content.ToOneByteVector(),
pat_vector, start_index);
@ -1469,7 +1469,7 @@ void SeqOneByteString::clear_padding() {
}
void SeqTwoByteString::clear_padding() {
int data_size = SeqString::kHeaderSize + length() * kUC16Size;
int data_size = SeqString::kHeaderSize + length() * base::kUC16Size;
memset(reinterpret_cast<void*>(address() + data_size), 0,
SizeFor(length()) - data_size);
}

29
src/objects/string.h
View File

@ -9,6 +9,7 @@
#include "src/base/bits.h"
#include "src/base/export-template.h"
#include "src/base/strings.h"
#include "src/objects/instance-type.h"
#include "src/objects/name.h"
#include "src/objects/smi.h"
@ -124,12 +125,12 @@ class String : public TorqueGeneratedString<String, Name> {
}
// Return the two-byte content of the string. Only use if IsTwoByte()
// returns true.
base::Vector<const uc16> ToUC16Vector() const {
base::Vector<const base::uc16> ToUC16Vector() const {
DCHECK_EQ(TWO_BYTE, state_);
return base::Vector<const uc16>(twobyte_start, length_);
return base::Vector<const base::uc16>(twobyte_start, length_);
}
uc16 Get(int i) const {
base::uc16 Get(int i) const {
DCHECK(i < length_);
DCHECK(state_ != NON_FLAT);
if (state_ == ONE_BYTE) return onebyte_start[i];
@ -150,7 +151,7 @@ class String : public TorqueGeneratedString<String, Name> {
length_(length),
state_(ONE_BYTE),
no_gc_(no_gc) {}
FlatContent(const uc16* start, int length,
FlatContent(const base::uc16* start, int length,
const DisallowGarbageCollection& no_gc)
: twobyte_start(start),
length_(length),
@ -161,7 +162,7 @@ class String : public TorqueGeneratedString<String, Name> {
union {
const uint8_t* onebyte_start;
const uc16* twobyte_start;
const base::uc16* twobyte_start;
};
int length_;
State state_;
@ -250,7 +251,7 @@ class String : public TorqueGeneratedString<String, Name> {
AllocationType allocation = AllocationType::kYoung);
// Tries to return the content of a flat string as a structure holding either
// a flat vector of char or of uc16.
// a flat vector of char or of base::uc16.
// If the string isn't flat, and therefore doesn't have flat content, the
// returned structure will report so, and can't provide a vector of either
// kind.
@ -432,7 +433,7 @@ class String : public TorqueGeneratedString<String, Name> {
static const uint32_t kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar;
static const int kMaxUtf16CodeUnit = 0xffff;
static const uint32_t kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit;
static const uc32 kMaxCodePoint = 0x10ffff;
static const base::uc32 kMaxCodePoint = 0x10ffff;
// Maximal string length.
// The max length is different on 32 and 64 bit platforms. Max length for
@ -481,8 +482,8 @@ class String : public TorqueGeneratedString<String, Name> {
return NonAsciiStart(chars, length) >= length;
}
static inline int NonOneByteStart(const uc16* chars, int length) {
DCHECK(IsAligned(reinterpret_cast<Address>(chars), sizeof(uc16)));
static inline int NonOneByteStart(const base::uc16* chars, int length) {
DCHECK(IsAligned(reinterpret_cast<Address>(chars), sizeof(base::uc16)));
const uint16_t* start = chars;
const uint16_t* limit = chars + length;
@ -506,7 +507,7 @@ class String : public TorqueGeneratedString<String, Name> {
if (*reinterpret_cast<const uintptr_t*>(chars) & non_one_byte_mask) {
break;
}
chars += (sizeof(uintptr_t) / sizeof(uc16));
chars += (sizeof(uintptr_t) / sizeof(base::uc16));
}
}
@ -521,7 +522,7 @@ class String : public TorqueGeneratedString<String, Name> {
return static_cast<int>(chars - start);
}
static inline bool IsOneByte(const uc16* chars, int length) {
static inline bool IsOneByte(const base::uc16* chars, int length) {
return NonOneByteStart(chars, length) >= length;
}
@ -700,10 +701,10 @@ class SeqTwoByteString
// Get a pointer to the characters of the string. May only be called when a
// SharedStringAccessGuard is not needed (i.e. on the main thread or on
// read-only strings).
inline uc16* GetChars(const DisallowGarbageCollection& no_gc) const;
inline base::uc16* GetChars(const DisallowGarbageCollection& no_gc) const;
// Get a pointer to the characters of the string.
inline uc16* GetChars(
inline base::uc16* GetChars(
const DisallowGarbageCollection& no_gc,
const SharedStringAccessGuardIfNeeded& access_guard) const;
@ -958,7 +959,7 @@ class V8_EXPORT_PRIVATE FlatStringReader : public Relocatable {
public:
FlatStringReader(Isolate* isolate, Handle<String> str);
void PostGarbageCollection() override;
inline uc32 Get(int index) const;
inline base::uc32 Get(int index) const;
template <typename Char>
inline Char Get(int index) const;
int length() { return length_; }

19
src/objects/value-serializer.cc
View File

@ -315,10 +315,10 @@ void ValueSerializer::WriteOneByteString(base::Vector<const uint8_t> chars) {
WriteRawBytes(chars.begin(), chars.length() * sizeof(uint8_t));
}
void ValueSerializer::WriteTwoByteString(base::Vector<const uc16> chars) {
void ValueSerializer::WriteTwoByteString(base::Vector<const base::uc16> chars) {
// Warning: this uses host endianness.
WriteVarint<uint32_t>(chars.length() * sizeof(uc16));
WriteRawBytes(chars.begin(), chars.length() * sizeof(uc16));
WriteVarint<uint32_t>(chars.length() * sizeof(base::uc16));
WriteRawBytes(chars.begin(), chars.length() * sizeof(base::uc16));
}
void ValueSerializer::WriteBigIntContents(BigInt bigint) {
@ -497,8 +497,8 @@ void ValueSerializer::WriteString(Handle<String> string) {
WriteTag(SerializationTag::kOneByteString);
WriteOneByteString(chars);
} else if (flat.IsTwoByte()) {
base::Vector<const uc16> chars = flat.ToUC16Vector();
uint32_t byte_length = chars.length() * sizeof(uc16);
base::Vector<const base::uc16> chars = flat.ToUC16Vector();
uint32_t byte_length = chars.length() * sizeof(base::uc16);
// The existing reading code expects 16-byte strings to be aligned.
if ((buffer_size_ + 1 + BytesNeededForVarint(byte_length)) & 1)
WriteTag(SerializationTag::kPadding);
@ -1447,7 +1447,7 @@ MaybeHandle<String> ValueDeserializer::ReadTwoByteString() {
if (!ReadVarint<uint32_t>().To(&byte_length) ||
byte_length >
static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) ||
byte_length % sizeof(uc16) != 0 ||
byte_length % sizeof(base::uc16) != 0 ||
!ReadRawBytes(byte_length).To(&bytes)) {
return MaybeHandle<String>();
}
@ -1457,7 +1457,7 @@ MaybeHandle<String> ValueDeserializer::ReadTwoByteString() {
if (byte_length == 0) return isolate_->factory()->empty_string();
Handle<SeqTwoByteString> string;
if (!isolate_->factory()
->NewRawTwoByteString(byte_length / sizeof(uc16))
->NewRawTwoByteString(byte_length / sizeof(base::uc16))
.ToHandle(&string)) {
return MaybeHandle<String>();
}
@ -1496,8 +1496,9 @@ bool ValueDeserializer::ReadExpectedString(Handle<String> expected) {
return true;
}
} else if (tag == SerializationTag::kTwoByteString && flat.IsTwoByte()) {
base::Vector<const uc16> chars = flat.ToUC16Vector();
if (byte_length == static_cast<unsigned>(chars.length()) * sizeof(uc16) &&
base::Vector<const base::uc16> chars = flat.ToUC16Vector();
if (byte_length ==
static_cast<unsigned>(chars.length()) * sizeof(base::uc16) &&
memcmp(bytes.begin(), chars.begin(), byte_length) == 0) {
return true;
}

3
src/objects/value-serializer.h
View File

@ -11,6 +11,7 @@
#include "include/v8.h"
#include "src/base/compiler-specific.h"
#include "src/base/macros.h"
#include "src/base/strings.h"
#include "src/base/vector.h"
#include "src/common/message-template.h"
#include "src/handles/maybe-handles.h"
@ -106,7 +107,7 @@ class ValueSerializer {
template <typename T>
void WriteZigZag(T value);
void WriteOneByteString(base::Vector<const uint8_t> chars);
void WriteTwoByteString(base::Vector<const uc16> chars);
void WriteTwoByteString(base::Vector<const base::uc16> chars);
void WriteBigIntContents(BigInt bigint);
Maybe<uint8_t*> ReserveRawBytes(size_t bytes);

13
src/parsing/literal-buffer.cc
View File

@ -4,6 +4,7 @@
#include "src/parsing/literal-buffer.h"
#include "src/base/strings.h"
#include "src/execution/isolate.h"
#include "src/execution/local-isolate.h"
#include "src/heap/factory.h"
@ -43,7 +44,7 @@ void LiteralBuffer::ExpandBuffer() {
void LiteralBuffer::ConvertToTwoByte() {
DCHECK(is_one_byte());
base::Vector<byte> new_store;
int new_content_size = position_ * kUC16Size;
int new_content_size = position_ * base::kUC16Size;
if (new_content_size >= backing_store_.length()) {
// Ensure room for all currently read code units as UC16 as well
// as the code unit about to be stored.
@ -64,21 +65,21 @@ void LiteralBuffer::ConvertToTwoByte() {
is_one_byte_ = false;
}
void LiteralBuffer::AddTwoByteChar(uc32 code_unit) {
void LiteralBuffer::AddTwoByteChar(base::uc32 code_unit) {
DCHECK(!is_one_byte());
if (position_ >= backing_store_.length()) ExpandBuffer();
if (code_unit <=
static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
static_cast<base::uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
*reinterpret_cast<uint16_t*>(&backing_store_[position_]) = code_unit;
position_ += kUC16Size;
position_ += base::kUC16Size;
} else {
*reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
unibrow::Utf16::LeadSurrogate(code_unit);
position_ += kUC16Size;
position_ += base::kUC16Size;
if (position_ >= backing_store_.length()) ExpandBuffer();
*reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
unibrow::Utf16::TrailSurrogate(code_unit);
position_ += kUC16Size;
position_ += base::kUC16Size;
}
}

7
src/parsing/literal-buffer.h
View File

@ -5,6 +5,7 @@
#ifndef V8_PARSING_LITERAL_BUFFER_H_
#define V8_PARSING_LITERAL_BUFFER_H_
#include "src/base/strings.h"
#include "src/base/vector.h"
#include "src/strings/unicode-decoder.h"
@ -26,9 +27,9 @@ class LiteralBuffer final {
AddOneByteChar(static_cast<byte>(code_unit));
}
V8_INLINE void AddChar(uc32 code_unit) {
V8_INLINE void AddChar(base::uc32 code_unit) {
if (is_one_byte()) {
if (code_unit <= static_cast<uc32>(unibrow::Latin1::kMaxChar)) {
if (code_unit <= static_cast<base::uc32>(unibrow::Latin1::kMaxChar)) {
AddOneByteChar(static_cast<byte>(code_unit));
return;
}
@ -91,7 +92,7 @@ class LiteralBuffer final {
position_ += kOneByteSize;
}
void AddTwoByteChar(uc32 code_unit);
void AddTwoByteChar(base::uc32 code_unit);
int NewCapacity(int min_capacity);
void ExpandBuffer();
void ConvertToTwoByte();

19
src/parsing/scanner-character-streams.cc
View File

@ -8,6 +8,7 @@
#include <vector>
#include "include/v8.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
#include "src/handles/handles.h"
#include "src/logging/runtime-call-stats-scope.h"
@ -278,7 +279,7 @@ class BufferedCharacterStream : public Utf16CharacterStream {
: byte_stream_(other.byte_stream_) {}
static const size_t kBufferSize = 512;
uc16 buffer_[kBufferSize];
base::uc16 buffer_[kBufferSize];
ByteStream<uint8_t> byte_stream_;
};
@ -392,7 +393,7 @@ class BufferedUtf16CharacterStream : public Utf16CharacterStream {
// Fixed sized buffer that this class reads from.
// The base class' buffer_start_ should always point to buffer_.
uc16 buffer_[kBufferSize];
base::uc16 buffer_[kBufferSize];
};
BufferedUtf16CharacterStream::BufferedUtf16CharacterStream()
@ -418,7 +419,7 @@ bool BufferedUtf16CharacterStream::ReadBlock() {
namespace {
static const uc16 kWindows1252ToUC16[256] = {
static const base::uc16 kWindows1252ToUC16[256] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, // 00-07
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, // 08-0F
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, // 10-17
@ -504,7 +505,7 @@ class Windows1252CharacterStream final : public Utf16CharacterStream {
V8_NOEXCEPT : byte_stream_(other.byte_stream_) {}
static const size_t kBufferSize = 512;
uc16 buffer_[kBufferSize];
base::uc16 buffer_[kBufferSize];
ChunkedStream<uint8_t> byte_stream_;
};
@ -653,7 +654,7 @@ void Utf8ExternalStreamingStream::FillBufferFromCurrentChunk() {
unibrow::uchar t = unibrow::Utf8::ValueOfIncrementalFinish(&state);
if (t != unibrow::Utf8::kBufferEmpty) {
DCHECK_EQ(t, unibrow::Utf8::kBadChar);
*output_cursor = static_cast<uc16>(t);
*output_cursor = static_cast<base::uc16>(t);
buffer_end_++;
current_.pos.chars++;
current_.pos.incomplete_char = 0;
@ -672,13 +673,14 @@ void Utf8ExternalStreamingStream::FillBufferFromCurrentChunk() {
unibrow::uchar t =
unibrow::Utf8::ValueOfIncremental(&cursor, &state, &incomplete_char);
if (V8_LIKELY(t < kUtf8Bom)) {
*(output_cursor++) = static_cast<uc16>(t); // The most frequent case.
*(output_cursor++) =
static_cast<base::uc16>(t); // The most frequent case.
} else if (t == unibrow::Utf8::kIncomplete) {
continue;
} else if (t == kUtf8Bom) {
// BOM detected at beginning of the stream. Don't copy it.
} else if (t <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
*(output_cursor++) = static_cast<uc16>(t);
*(output_cursor++) = static_cast<base::uc16>(t);
} else {
*(output_cursor++) = unibrow::Utf16::LeadSurrogate(t);
*(output_cursor++) = unibrow::Utf16::TrailSurrogate(t);
@ -692,7 +694,8 @@ void Utf8ExternalStreamingStream::FillBufferFromCurrentChunk() {
unibrow::uchar t =
unibrow::Utf8::ValueOfIncremental(&cursor, &state, &incomplete_char);
if (V8_LIKELY(t <= unibrow::Utf16::kMaxNonSurrogateCharCode)) {
*(output_cursor++) = static_cast<uc16>(t); // The most frequent case.
*(output_cursor++) =
static_cast<base::uc16>(t); // The most frequent case.
} else if (t == unibrow::Utf8::kIncomplete) {
continue;
} else {

8
src/parsing/scanner-inl.h
View File

@ -251,7 +251,7 @@ static constexpr const uint8_t character_scan_flags[128] = {
#undef CALL_GET_SCAN_FLAGS
};
inline bool CharCanBeKeyword(uc32 c) {
inline bool CharCanBeKeyword(base::uc32 c) {
return static_cast<uint32_t>(c) < arraysize(character_scan_flags) &&
CanBeKeyword(character_scan_flags[c]);
}
@ -273,7 +273,7 @@ V8_INLINE Token::Value Scanner::ScanIdentifierOrKeywordInner() {
// Otherwise we'll fall into the slow path after scanning the identifier.
DCHECK(!IdentifierNeedsSlowPath(scan_flags));
AddLiteralChar(static_cast<char>(c0_));
AdvanceUntil([this, &scan_flags](uc32 c0) {
AdvanceUntil([this, &scan_flags](base::uc32 c0) {
if (V8_UNLIKELY(static_cast<uint32_t>(c0) > kMaxAscii)) {
// A non-ascii character means we need to drop through to the slow
// path.
@ -305,7 +305,7 @@ V8_INLINE Token::Value Scanner::ScanIdentifierOrKeywordInner() {
} else {
// Special case for escapes at the start of an identifier.
escaped = true;
uc32 c = ScanIdentifierUnicodeEscape();
base::uc32 c = ScanIdentifierUnicodeEscape();
DCHECK(!IsIdentifierStart(Invalid()));
if (c == '\\' || !IsIdentifierStart(c)) {
return Token::ILLEGAL;
@ -454,7 +454,7 @@ V8_INLINE Token::Value Scanner::ScanSingleToken() {
// / // /* /=
Advance();
if (c0_ == '/') {
uc32 c = Peek();
base::uc32 c = Peek();
if (c == '#' || c == '@') {
Advance();
Advance();

52
src/parsing/scanner.cc
View File

@ -12,6 +12,7 @@
#include "src/ast/ast-value-factory.h"
#include "src/base/platform/wrappers.h"
#include "src/base/strings.h"
#include "src/numbers/conversions-inl.h"
#include "src/objects/bigint.h"
#include "src/parsing/parse-info.h"
@ -109,19 +110,19 @@ void Scanner::Initialize() {
}
// static
bool Scanner::IsInvalid(uc32 c) {
bool Scanner::IsInvalid(base::uc32 c) {
DCHECK(c == Invalid() || base::IsInRange(c, 0u, String::kMaxCodePoint));
return c == Scanner::Invalid();
}
template <bool capture_raw, bool unicode>
uc32 Scanner::ScanHexNumber(int expected_length) {
base::uc32 Scanner::ScanHexNumber(int expected_length) {
DCHECK_LE(expected_length, 4); // prevent overflow
int begin = source_pos() - 2;
uc32 x = 0;
base::uc32 x = 0;
for (int i = 0; i < expected_length; i++) {
int d = HexValue(c0_);
int d = base::HexValue(c0_);
if (d < 0) {
ReportScannerError(Location(begin, begin + expected_length + 2),
unicode
@ -137,9 +138,10 @@ uc32 Scanner::ScanHexNumber(int expected_length) {
}
template <bool capture_raw>
uc32 Scanner::ScanUnlimitedLengthHexNumber(uc32 max_value, int beg_pos) {
uc32 x = 0;
int d = HexValue(c0_);
base::uc32 Scanner::ScanUnlimitedLengthHexNumber(base::uc32 max_value,
int beg_pos) {
base::uc32 x = 0;
int d = base::HexValue(c0_);
if (d < 0) return Invalid();
while (d >= 0) {
@ -150,7 +152,7 @@ uc32 Scanner::ScanUnlimitedLengthHexNumber(uc32 max_value, int beg_pos) {
return Invalid();
}
Advance<capture_raw>();
d = HexValue(c0_);
d = base::HexValue(c0_);
}
return x;
@ -209,7 +211,7 @@ Token::Value Scanner::SkipSingleLineComment() {
// separately by the lexical grammar and becomes part of the
// stream of input elements for the syntactic grammar (see
// ECMA-262, section 7.4).
AdvanceUntil([](uc32 c0_) { return unibrow::IsLineTerminator(c0_); });
AdvanceUntil([](base::uc32 c0_) { return unibrow::IsLineTerminator(c0_); });
return Token::WHITESPACE;
}
@ -276,7 +278,7 @@ Token::Value Scanner::SkipMultiLineComment() {
// Until we see the first newline, check for * and newline characters.
if (!next().after_line_terminator) {
do {
AdvanceUntil([](uc32 c0) {
AdvanceUntil([](base::uc32 c0) {
if (V8_UNLIKELY(static_cast<uint32_t>(c0) > kMaxAscii)) {
return unibrow::IsLineTerminator(c0);
}
@ -301,7 +303,7 @@ Token::Value Scanner::SkipMultiLineComment() {
// After we've seen newline, simply try to find '*/'.
while (c0_ != kEndOfInput) {
AdvanceUntil([](uc32 c0) { return c0 == '*'; });
AdvanceUntil([](base::uc32 c0) { return c0 == '*'; });
while (c0_ == '*') {
Advance();
@ -369,7 +371,7 @@ void Scanner::SeekForward(int pos) {
template <bool capture_raw>
bool Scanner::ScanEscape() {
uc32 c = c0_;
base::uc32 c = c0_;
Advance<capture_raw>();
// Skip escaped newlines.
@ -425,9 +427,9 @@ bool Scanner::ScanEscape() {
}
template <bool capture_raw>
uc32 Scanner::ScanOctalEscape(uc32 c, int length) {
base::uc32 Scanner::ScanOctalEscape(base::uc32 c, int length) {
DCHECK('0' <= c && c <= '7');
uc32 x = c - '0';
base::uc32 x = c - '0';
int i = 0;
for (; i < length; i++) {
int d = c0_ - '0';
@ -451,11 +453,11 @@ uc32 Scanner::ScanOctalEscape(uc32 c, int length) {
}
Token::Value Scanner::ScanString() {
uc32 quote = c0_;
base::uc32 quote = c0_;
next().literal_chars.Start();
while (true) {
AdvanceUntil([this](uc32 c0) {
AdvanceUntil([this](base::uc32 c0) {
if (V8_UNLIKELY(static_cast<uint32_t>(c0) > kMaxAscii)) {
if (V8_UNLIKELY(unibrow::IsStringLiteralLineTerminator(c0))) {
return true;
@ -531,7 +533,7 @@ Token::Value Scanner::ScanTemplateSpan() {
next().raw_literal_chars.Start();
const bool capture_raw = true;
while (true) {
uc32 c = c0_;
base::uc32 c = c0_;
if (c == '`') {
Advance(); // Consume '`'
result = Token::TEMPLATE_TAIL;
@ -547,7 +549,7 @@ Token::Value Scanner::ScanTemplateSpan() {
if (unibrow::IsLineTerminator(c0_)) {
// The TV of LineContinuation :: \ LineTerminatorSequence is the empty
// code unit sequence.
uc32 lastChar = c0_;
base::uc32 lastChar = c0_;
Advance();
if (lastChar == '\r') {
// Also skip \n.
@ -610,7 +612,7 @@ Handle<String> Scanner::SourceMappingUrl(IsolateT* isolate) const {
template Handle<String> Scanner::SourceMappingUrl(Isolate* isolate) const;
template Handle<String> Scanner::SourceMappingUrl(LocalIsolate* isolate) const;
bool Scanner::ScanDigitsWithNumericSeparators(bool (*predicate)(uc32 ch),
bool Scanner::ScanDigitsWithNumericSeparators(bool (*predicate)(base::uc32 ch),
bool is_check_first_digit) {
// we must have at least one digit after 'x'/'b'/'o'
if (is_check_first_digit && !predicate(c0_)) return false;
@ -670,7 +672,7 @@ bool Scanner::ScanDecimalAsSmiWithNumericSeparators(uint64_t* value) {
}
separator_seen = false;
*value = 10 * *value + (c0_ - '0');
uc32 first_char = c0_;
base::uc32 first_char = c0_;
Advance();
AddLiteralChar(first_char);
}
@ -691,7 +693,7 @@ bool Scanner::ScanDecimalAsSmi(uint64_t* value, bool allow_numeric_separator) {
while (IsDecimalDigit(c0_)) {
*value = 10 * *value + (c0_ - '0');
uc32 first_char = c0_;
base::uc32 first_char = c0_;
Advance();
AddLiteralChar(first_char);
}
@ -869,7 +871,7 @@ Token::Value Scanner::ScanNumber(bool seen_period) {
return is_bigint ? Token::BIGINT : Token::NUMBER;
}
uc32 Scanner::ScanIdentifierUnicodeEscape() {
base::uc32 Scanner::ScanIdentifierUnicodeEscape() {
Advance();
if (c0_ != 'u') return Invalid();
Advance();
@ -877,13 +879,13 @@ uc32 Scanner::ScanIdentifierUnicodeEscape() {
}
template <bool capture_raw>
uc32 Scanner::ScanUnicodeEscape() {
base::uc32 Scanner::ScanUnicodeEscape() {
// Accept both \uxxxx and \u{xxxxxx}. In the latter case, the number of
// hex digits between { } is arbitrary. \ and u have already been read.
if (c0_ == '{') {
int begin = source_pos() - 2;
Advance<capture_raw>();
uc32 cp =
base::uc32 cp =
ScanUnlimitedLengthHexNumber<capture_raw>(String::kMaxCodePoint, begin);
if (cp == kInvalidSequence || c0_ != '}') {
ReportScannerError(source_pos(),
@ -902,7 +904,7 @@ Token::Value Scanner::ScanIdentifierOrKeywordInnerSlow(bool escaped,
while (true) {
if (c0_ == '\\') {
escaped = true;
uc32 c = ScanIdentifierUnicodeEscape();
base::uc32 c = ScanIdentifierUnicodeEscape();
// Only allow legal identifier part characters.
// TODO(verwaest): Make this true.
// DCHECK(!IsIdentifierPart('\'));

56
src/parsing/scanner.h
View File

@ -12,6 +12,7 @@
#include "include/v8.h"
#include "src/base/logging.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
#include "src/common/message-template.h"
#include "src/parsing/literal-buffer.h"
@ -39,7 +40,7 @@ class Zone;
// or one part of a surrogate pair that make a single 21 bit code point.
class Utf16CharacterStream {
public:
static constexpr uc32 kEndOfInput = static_cast<uc32>(-1);
static constexpr base::uc32 kEndOfInput = static_cast<base::uc32>(-1);
virtual ~Utf16CharacterStream() = default;
@ -50,11 +51,11 @@ class Utf16CharacterStream {
V8_INLINE void reset_parser_error_flag() { has_parser_error_ = false; }
V8_INLINE bool has_parser_error() const { return has_parser_error_; }
inline uc32 Peek() {
inline base::uc32 Peek() {
if (V8_LIKELY(buffer_cursor_ < buffer_end_)) {
return static_cast<uc32>(*buffer_cursor_);
return static_cast<base::uc32>(*buffer_cursor_);
} else if (ReadBlockChecked()) {
return static_cast<uc32>(*buffer_cursor_);
return static_cast<base::uc32>(*buffer_cursor_);
} else {
return kEndOfInput;
}
@ -62,8 +63,8 @@ class Utf16CharacterStream {
// Returns and advances past the next UTF-16 code unit in the input
// stream. If there are no more code units it returns kEndOfInput.
inline uc32 Advance() {
uc32 result = Peek();
inline base::uc32 Advance() {
base::uc32 result = Peek();
buffer_cursor_++;
return result;
}
@ -72,11 +73,11 @@ class Utf16CharacterStream {
// that meets the checks requirement. If there are no more code units it
// returns kEndOfInput.
template <typename FunctionType>
V8_INLINE uc32 AdvanceUntil(FunctionType check) {
V8_INLINE base::uc32 AdvanceUntil(FunctionType check) {
while (true) {
auto next_cursor_pos =
std::find_if(buffer_cursor_, buffer_end_, [&check](uint16_t raw_c0_) {
uc32 c0_ = static_cast<uc32>(raw_c0_);
base::uc32 c0_ = static_cast<base::uc32>(raw_c0_);
return check(c0_);
});
@ -88,7 +89,7 @@ class Utf16CharacterStream {
}
} else {
buffer_cursor_ = next_cursor_pos + 1;
return static_cast<uc32>(*next_cursor_pos);
return static_cast<base::uc32>(*next_cursor_pos);
}
}
}
@ -267,11 +268,11 @@ class V8_EXPORT_PRIVATE Scanner {
};
// -1 is outside of the range of any real source code.
static constexpr uc32 kEndOfInput = Utf16CharacterStream::kEndOfInput;
static constexpr uc32 kInvalidSequence = static_cast<uc32>(-1);
static constexpr base::uc32 kEndOfInput = Utf16CharacterStream::kEndOfInput;
static constexpr base::uc32 kInvalidSequence = static_cast<base::uc32>(-1);
static constexpr uc32 Invalid() { return Scanner::kInvalidSequence; }
static bool IsInvalid(uc32 c);
static constexpr base::uc32 Invalid() { return Scanner::kInvalidSequence; }
static bool IsInvalid(base::uc32 c);
explicit Scanner(Utf16CharacterStream* source, UnoptimizedCompileFlags flags);
@ -471,7 +472,7 @@ class V8_EXPORT_PRIVATE Scanner {
// Scans octal escape sequence. Also accepts "\0" decimal escape sequence.
template <bool capture_raw>
uc32 ScanOctalEscape(uc32 c, int length);
base::uc32 ScanOctalEscape(base::uc32 c, int length);
// Call this after setting source_ to the input.
void Init() {
@ -502,11 +503,13 @@ class V8_EXPORT_PRIVATE Scanner {
// Seek to the next_ token at the given position.
void SeekNext(size_t position);
V8_INLINE void AddLiteralChar(uc32 c) { next().literal_chars.AddChar(c); }
V8_INLINE void AddLiteralChar(base::uc32 c) {
next().literal_chars.AddChar(c);
}
V8_INLINE void AddLiteralChar(char c) { next().literal_chars.AddChar(c); }
V8_INLINE void AddRawLiteralChar(uc32 c) {
V8_INLINE void AddRawLiteralChar(base::uc32 c) {
next().raw_literal_chars.AddChar(c);
}
@ -532,7 +535,7 @@ class V8_EXPORT_PRIVATE Scanner {
bool CombineSurrogatePair() {
DCHECK(!unibrow::Utf16::IsLeadSurrogate(kEndOfInput));
if (unibrow::Utf16::IsLeadSurrogate(c0_)) {
uc32 c1 = source_->Advance();
base::uc32 c1 = source_->Advance();
DCHECK(!unibrow::Utf16::IsTrailSurrogate(kEndOfInput));
if (unibrow::Utf16::IsTrailSurrogate(c1)) {
c0_ = unibrow::Utf16::CombineSurrogatePair(c0_, c1);
@ -543,21 +546,22 @@ class V8_EXPORT_PRIVATE Scanner {
return false;
}
void PushBack(uc32 ch) {
void PushBack(base::uc32 ch) {
DCHECK(IsInvalid(c0_) ||
base::IsInRange(c0_, 0u, unibrow::Utf16::kMaxNonSurrogateCharCode));
source_->Back();
c0_ = ch;
}
uc32 Peek() const { return source_->Peek(); }
base::uc32 Peek() const { return source_->Peek(); }
inline Token::Value Select(Token::Value tok) {
Advance();
return tok;
}
inline Token::Value Select(uc32 next, Token::Value then, Token::Value else_) {
inline Token::Value Select(base::uc32 next, Token::Value then,
Token::Value else_) {
Advance();
if (c0_ == next) {
Advance();
@ -622,12 +626,12 @@ class V8_EXPORT_PRIVATE Scanner {
}
template <bool capture_raw, bool unicode = false>
uc32 ScanHexNumber(int expected_length);
base::uc32 ScanHexNumber(int expected_length);
// Scan a number of any length but not bigger than max_value. For example, the
// number can be 000000001, so it's very long in characters but its value is
// small.
template <bool capture_raw>
uc32 ScanUnlimitedLengthHexNumber(uc32 max_value, int beg_pos);
base::uc32 ScanUnlimitedLengthHexNumber(base::uc32 max_value, int beg_pos);
// Scans a single JavaScript token.
V8_INLINE Token::Value ScanSingleToken();
@ -647,7 +651,7 @@ class V8_EXPORT_PRIVATE Scanner {
// Scans a possible HTML comment -- begins with '<!'.
Token::Value ScanHtmlComment();
bool ScanDigitsWithNumericSeparators(bool (*predicate)(uc32 ch),
bool ScanDigitsWithNumericSeparators(bool (*predicate)(base::uc32 ch),
bool is_check_first_digit);
bool ScanDecimalDigits(bool allow_numeric_separator);
// Optimized function to scan decimal number as Smi.
@ -676,10 +680,10 @@ class V8_EXPORT_PRIVATE Scanner {
// Decodes a Unicode escape-sequence which is part of an identifier.
// If the escape sequence cannot be decoded the result is kBadChar.
uc32 ScanIdentifierUnicodeEscape();
base::uc32 ScanIdentifierUnicodeEscape();
// Helper for the above functions.
template <bool capture_raw>
uc32 ScanUnicodeEscape();
base::uc32 ScanUnicodeEscape();
Token::Value ScanTemplateSpan();
@ -718,7 +722,7 @@ class V8_EXPORT_PRIVATE Scanner {
Utf16CharacterStream* const source_;
// One Unicode character look-ahead; c0_ < 0 at the end of the input.
uc32 c0_;
base::uc32 c0_;
TokenDesc token_storage_[3];

39
src/regexp/arm/regexp-macro-assembler-arm.cc
View File

@ -191,8 +191,8 @@ void RegExpMacroAssemblerARM::CheckCharacter(uint32_t c, Label* on_equal) {
BranchOrBacktrack(eq, on_equal);
}
void RegExpMacroAssemblerARM::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpMacroAssemblerARM::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
__ cmp(current_character(), Operand(limit));
BranchOrBacktrack(gt, on_greater);
}
@ -214,13 +214,12 @@ void RegExpMacroAssemblerARM::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(ne, on_not_at_start);
}
void RegExpMacroAssemblerARM::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerARM::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
__ cmp(current_character(), Operand(limit));
BranchOrBacktrack(lt, on_less);
}
void RegExpMacroAssemblerARM::CheckGreedyLoop(Label* on_equal) {
__ ldr(r0, MemOperand(backtrack_stackpointer(), 0));
__ cmp(current_input_offset(), r0);
@ -458,12 +457,8 @@ void RegExpMacroAssemblerARM::CheckNotCharacterAfterAnd(unsigned c,
BranchOrBacktrack(ne, on_not_equal);
}
void RegExpMacroAssemblerARM::CheckNotCharacterAfterMinusAnd(
uc16 c,
uc16 minus,
uc16 mask,
Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ sub(r0, current_character(), Operand(minus));
__ and_(r0, r0, Operand(mask));
@ -471,27 +466,22 @@ void RegExpMacroAssemblerARM::CheckNotCharacterAfterMinusAnd(
BranchOrBacktrack(ne, on_not_equal);
}
void RegExpMacroAssemblerARM::CheckCharacterInRange(
uc16 from,
uc16 to,
Label* on_in_range) {
void RegExpMacroAssemblerARM::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ sub(r0, current_character(), Operand(from));
__ cmp(r0, Operand(to - from));
BranchOrBacktrack(ls, on_in_range); // Unsigned lower-or-same condition.
}
void RegExpMacroAssemblerARM::CheckCharacterNotInRange(
uc16 from,
uc16 to,
Label* on_not_in_range) {
void RegExpMacroAssemblerARM::CheckCharacterNotInRange(base::uc16 from,
base::uc16 to,
Label* on_not_in_range) {
__ sub(r0, current_character(), Operand(from));
__ cmp(r0, Operand(to - from));
BranchOrBacktrack(hi, on_not_in_range); // Unsigned higher condition.
}
void RegExpMacroAssemblerARM::CheckBitInTable(
Handle<ByteArray> table,
Label* on_bit_set) {
@ -509,8 +499,7 @@ void RegExpMacroAssemblerARM::CheckBitInTable(
BranchOrBacktrack(ne, on_bit_set);
}
bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check
@ -625,7 +614,6 @@ bool RegExpMacroAssemblerARM::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerARM::Fail() {
__ mov(r0, Operand(FAILURE));
__ jmp(&exit_label_);
@ -828,8 +816,7 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
// Advance current position after a zero-length match.
Label advance;
__ bind(&advance);
__ add(current_input_offset(),
current_input_offset(),
__ add(current_input_offset(), current_input_offset(),
Operand((mode_ == UC16) ? 2 : 1));
if (global_unicode()) CheckNotInSurrogatePair(0, &advance);
}

19
src/regexp/arm/regexp-macro-assembler-arm.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_ARM_REGEXP_MACRO_ASSEMBLER_ARM_H_
#define V8_REGEXP_ARM_REGEXP_MACRO_ASSEMBLER_ARM_H_
#include "src/base/strings.h"
#include "src/codegen/arm/assembler-arm.h"
#include "src/codegen/macro-assembler.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -28,8 +29,8 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM
virtual void CheckCharacterAfterAnd(unsigned c,
unsigned mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -43,23 +44,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM
virtual void CheckNotCharacterAfterAnd(unsigned c,
unsigned mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
uc16 minus,
uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from,
uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from,
uc16 to,
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type,
Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);
virtual void GoTo(Label* label);

41
src/regexp/arm64/regexp-macro-assembler-arm64.cc
View File

@ -231,8 +231,7 @@ void RegExpMacroAssemblerARM64::CheckCharacter(uint32_t c, Label* on_equal) {
CompareAndBranchOrBacktrack(current_character(), c, eq, on_equal);
}
void RegExpMacroAssemblerARM64::CheckCharacterGT(uc16 limit,
void RegExpMacroAssemblerARM64::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
CompareAndBranchOrBacktrack(current_character(), limit, hi, on_greater);
}
@ -253,15 +252,14 @@ void RegExpMacroAssemblerARM64::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(ne, on_not_at_start);
}
void RegExpMacroAssemblerARM64::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerARM64::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
CompareAndBranchOrBacktrack(current_character(), limit, lo, on_less);
}
void RegExpMacroAssemblerARM64::CheckCharacters(base::Vector<const uc16> str,
int cp_offset,
Label* on_failure,
bool check_end_of_string) {
void RegExpMacroAssemblerARM64::CheckCharacters(
base::Vector<const base::uc16> str, int cp_offset, Label* on_failure,
bool check_end_of_string) {
// This method is only ever called from the cctests.
if (check_end_of_string) {
@ -557,39 +555,29 @@ void RegExpMacroAssemblerARM64::CheckNotCharacterAfterAnd(unsigned c,
CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
}
void RegExpMacroAssemblerARM64::CheckNotCharacterAfterMinusAnd(
uc16 c,
uc16 minus,
uc16 mask,
Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ Sub(w10, current_character(), minus);
__ And(w10, w10, mask);
CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
}
void RegExpMacroAssemblerARM64::CheckCharacterInRange(
uc16 from,
uc16 to,
Label* on_in_range) {
void RegExpMacroAssemblerARM64::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ Sub(w10, current_character(), from);
// Unsigned lower-or-same condition.
CompareAndBranchOrBacktrack(w10, to - from, ls, on_in_range);
}
void RegExpMacroAssemblerARM64::CheckCharacterNotInRange(
uc16 from,
uc16 to,
Label* on_not_in_range) {
base::uc16 from, base::uc16 to, Label* on_not_in_range) {
__ Sub(w10, current_character(), from);
// Unsigned higher condition.
CompareAndBranchOrBacktrack(w10, to - from, hi, on_not_in_range);
}
void RegExpMacroAssemblerARM64::CheckBitInTable(
Handle<ByteArray> table,
Label* on_bit_set) {
@ -604,8 +592,7 @@ void RegExpMacroAssemblerARM64::CheckBitInTable(
CompareAndBranchOrBacktrack(w11, 0, ne, on_bit_set);
}
bool RegExpMacroAssemblerARM64::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerARM64::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check
@ -708,7 +695,6 @@ bool RegExpMacroAssemblerARM64::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerARM64::Fail() {
__ Mov(w0, FAILURE);
__ B(&exit_label_);
@ -1016,8 +1002,7 @@ Handle<HeapObject> RegExpMacroAssemblerARM64::GetCode(Handle<String> source) {
// Advance current position after a zero-length match.
Label advance;
__ bind(&advance);
__ Add(current_input_offset(),
current_input_offset(),
__ Add(current_input_offset(), current_input_offset(),
Operand((mode_ == UC16) ? 2 : 1));
if (global_unicode()) CheckNotInSurrogatePair(0, &advance);
}

24
src/regexp/arm64/regexp-macro-assembler-arm64.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_ARM64_REGEXP_MACRO_ASSEMBLER_ARM64_H_
#define V8_REGEXP_ARM64_REGEXP_MACRO_ASSEMBLER_ARM64_H_
#include "src/base/strings.h"
#include "src/codegen/arm64/assembler-arm64.h"
#include "src/codegen/macro-assembler.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -29,10 +30,11 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM64
virtual void CheckCharacterAfterAnd(unsigned c,
unsigned mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacters(base::Vector<const uc16> str, int cp_offset,
Label* on_failure, bool check_end_of_string);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
virtual void CheckCharacters(base::Vector<const base::uc16> str,
int cp_offset, Label* on_failure,
bool check_end_of_string);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -46,23 +48,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerARM64
virtual void CheckNotCharacterAfterAnd(unsigned c,
unsigned mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
uc16 minus,
uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from,
uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from,
uc16 to,
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type,
Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void BindJumpTarget(Label* label = nullptr);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);

2
src/regexp/experimental/experimental-bytecode.cc
View File

@ -11,7 +11,7 @@ namespace internal {
namespace {
std::ostream& PrintAsciiOrHex(std::ostream& os, uc16 c) {
std::ostream& PrintAsciiOrHex(std::ostream& os, base::uc16 c) {
if (c < 128 && std::isprint(c)) {
os << static_cast<char>(c);
} else {

7
src/regexp/experimental/experimental-bytecode.h
View File

@ -7,6 +7,7 @@
#include <ios>
#include "src/base/strings.h"
#include "src/base/vector.h"
#include "src/regexp/regexp-ast.h"
@ -102,11 +103,11 @@ struct RegExpInstruction {
};
struct Uc16Range {
uc16 min; // Inclusive.
uc16 max; // Inclusive.
base::uc16 min; // Inclusive.
base::uc16 max; // Inclusive.
};
static RegExpInstruction ConsumeRange(uc16 min, uc16 max) {
static RegExpInstruction ConsumeRange(base::uc16 min, base::uc16 max) {
RegExpInstruction result;
result.opcode = CONSUME_RANGE;
result.payload.consume_range = Uc16Range{min, max};

21
src/regexp/experimental/experimental-compiler.cc
View File

@ -4,6 +4,7 @@
#include "src/regexp/experimental/experimental-compiler.h"
#include "src/base/strings.h"
#include "src/regexp/experimental/experimental.h"
#include "src/zone/zone-list-inl.h"
@ -14,7 +15,7 @@ namespace {
// TODO(mbid, v8:10765): Currently the experimental engine doesn't support
// UTF-16, but this shouldn't be too hard to implement.
constexpr uc32 kMaxSupportedCodepoint = 0xFFFFu;
constexpr base::uc32 kMaxSupportedCodepoint = 0xFFFFu;
class CanBeHandledVisitor final : private RegExpVisitor {
// Visitor to implement `ExperimentalRegExp::CanBeHandled`.
@ -229,7 +230,7 @@ class BytecodeAssembler {
code_.Add(RegExpInstruction::ClearRegister(register_index), zone_);
}
void ConsumeRange(uc16 from, uc16 to) {
void ConsumeRange(base::uc16 from, base::uc16 to) {
code_.Add(RegExpInstruction::ConsumeRange(from, to), zone_);
}
@ -402,16 +403,18 @@ class CompileVisitor : private RegExpVisitor {
CompileDisjunction(ranges->length(), [&](int i) {
// We don't support utf16 for now, so only ranges that can be specified
// by (complements of) ranges with uc16 bounds.
STATIC_ASSERT(kMaxSupportedCodepoint <= std::numeric_limits<uc16>::max());
// by (complements of) ranges with base::uc16 bounds.
STATIC_ASSERT(kMaxSupportedCodepoint <=
std::numeric_limits<base::uc16>::max());
uc32 from = (*ranges)[i].from();
base::uc32 from = (*ranges)[i].from();
DCHECK_LE(from, kMaxSupportedCodepoint);
uc16 from_uc16 = static_cast<uc16>(from);
base::uc16 from_uc16 = static_cast<base::uc16>(from);
uc32 to = (*ranges)[i].to();
base::uc32 to = (*ranges)[i].to();
DCHECK_IMPLIES(to > kMaxSupportedCodepoint, to == String::kMaxCodePoint);
uc16 to_uc16 = static_cast<uc16>(std::min(to, kMaxSupportedCodepoint));
base::uc16 to_uc16 =
static_cast<base::uc16>(std::min(to, kMaxSupportedCodepoint));
assembler_.ConsumeRange(from_uc16, to_uc16);
});
@ -419,7 +422,7 @@ class CompileVisitor : private RegExpVisitor {
}
void* VisitAtom(RegExpAtom* node, void*) override {
for (uc16 c : node->data()) {
for (base::uc16 c : node->data()) {
assembler_.ConsumeRange(c, c);
}
return nullptr;

17
src/regexp/experimental/experimental-interpreter.cc
View File

@ -5,6 +5,7 @@
#include "src/regexp/experimental/experimental-interpreter.h"
#include "src/base/optional.h"
#include "src/base/strings.h"
#include "src/common/assert-scope.h"
#include "src/objects/fixed-array-inl.h"
#include "src/objects/string-inl.h"
@ -76,7 +77,7 @@ base::Vector<const uint8_t> ToCharacterVector<uint8_t>(
}
template <>
base::Vector<const uc16> ToCharacterVector<uc16>(
base::Vector<const base::uc16> ToCharacterVector<base::uc16>(
String str, const DisallowGarbageCollection& no_gc) {
DCHECK(str.IsFlat());
String::FlatContent content = str.GetFlatContent(no_gc);
@ -87,8 +88,8 @@ base::Vector<const uc16> ToCharacterVector<uc16>(
template <class Character>
class NfaInterpreter {
// Executes a bytecode program in breadth-first mode, without backtracking.
// `Character` can be instantiated with `uint8_t` or `uc16` for one byte or
// two byte input strings.
// `Character` can be instantiated with `uint8_t` or `base::uc16` for one byte
// or two byte input strings.
//
// In contrast to the backtracking implementation, this has linear time
// complexity in the length of the input string. Breadth-first mode means
@ -343,7 +344,7 @@ class NfaInterpreter {
while (input_index_ != input_.length() &&
!(FoundMatch() && blocked_threads_.is_empty())) {
DCHECK(active_threads_.is_empty());
uc16 input_char = input_[input_index_];
base::uc16 input_char = input_[input_index_];
++input_index_;
static constexpr int kTicksBetweenInterruptHandling = 64;
@ -439,7 +440,7 @@ class NfaInterpreter {
// Unblock all blocked_threads_ by feeding them an `input_char`. Should only
// be called with `input_index_` pointing to the character *after*
// `input_char` so that `pc_last_input_index_` is updated correctly.
void FlushBlockedThreads(uc16 input_char) {
void FlushBlockedThreads(base::uc16 input_char) {
// The threads in blocked_threads_ are sorted from high to low priority,
// but active_threads_ needs to be sorted from low to high priority, so we
// need to activate blocked threads in reverse order.
@ -568,9 +569,9 @@ int ExperimentalRegExpInterpreter::FindMatches(
return interpreter.FindMatches(output_registers, output_register_count);
} else {
DCHECK(input.GetFlatContent(no_gc).IsTwoByte());
NfaInterpreter<uc16> interpreter(isolate, call_origin, bytecode,
register_count_per_match, input,
start_index, zone);
NfaInterpreter<base::uc16> interpreter(isolate, call_origin, bytecode,
register_count_per_match, input,
start_index, zone);
return interpreter.FindMatches(output_registers, output_register_count);
}
}

7
src/regexp/gen-regexp-special-case.cc
View File

@ -7,14 +7,15 @@
#include <iostream>
#include <sstream>
#include "src/base/strings.h"
#include "src/regexp/special-case.h"
namespace v8 {
namespace internal {
static const uc32 kSurrogateStart = 0xd800;
static const uc32 kSurrogateEnd = 0xdfff;
static const uc32 kNonBmpStart = 0x10000;
static const base::uc32 kSurrogateStart = 0xd800;
static const base::uc32 kSurrogateEnd = 0xdfff;
static const base::uc32 kNonBmpStart = 0x10000;
// The following code generates "src/regexp/special-case.cc".
void PrintSet(std::ofstream& out, const char* name,

37
src/regexp/ia32/regexp-macro-assembler-ia32.cc
View File

@ -176,8 +176,8 @@ void RegExpMacroAssemblerIA32::CheckCharacter(uint32_t c, Label* on_equal) {
BranchOrBacktrack(equal, on_equal);
}
void RegExpMacroAssemblerIA32::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpMacroAssemblerIA32::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
__ cmp(current_character(), limit);
BranchOrBacktrack(greater, on_greater);
}
@ -195,13 +195,12 @@ void RegExpMacroAssemblerIA32::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(not_equal, on_not_at_start);
}
void RegExpMacroAssemblerIA32::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerIA32::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
__ cmp(current_character(), limit);
BranchOrBacktrack(less, on_less);
}
void RegExpMacroAssemblerIA32::CheckGreedyLoop(Label* on_equal) {
Label fallthrough;
__ cmp(edi, Operand(backtrack_stackpointer(), 0));
@ -481,12 +480,8 @@ void RegExpMacroAssemblerIA32::CheckNotCharacterAfterAnd(uint32_t c,
BranchOrBacktrack(not_equal, on_not_equal);
}
void RegExpMacroAssemblerIA32::CheckNotCharacterAfterMinusAnd(
uc16 c,
uc16 minus,
uc16 mask,
Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ lea(eax, Operand(current_character(), -minus));
if (c == 0) {
@ -498,27 +493,21 @@ void RegExpMacroAssemblerIA32::CheckNotCharacterAfterMinusAnd(
BranchOrBacktrack(not_equal, on_not_equal);
}
void RegExpMacroAssemblerIA32::CheckCharacterInRange(
uc16 from,
uc16 to,
Label* on_in_range) {
void RegExpMacroAssemblerIA32::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ lea(eax, Operand(current_character(), -from));
__ cmp(eax, to - from);
BranchOrBacktrack(below_equal, on_in_range);
}
void RegExpMacroAssemblerIA32::CheckCharacterNotInRange(
uc16 from,
uc16 to,
Label* on_not_in_range) {
base::uc16 from, base::uc16 to, Label* on_not_in_range) {
__ lea(eax, Operand(current_character(), -from));
__ cmp(eax, to - from);
BranchOrBacktrack(above, on_not_in_range);
}
void RegExpMacroAssemblerIA32::CheckBitInTable(
Handle<ByteArray> table,
Label* on_bit_set) {
@ -534,8 +523,7 @@ void RegExpMacroAssemblerIA32::CheckBitInTable(
BranchOrBacktrack(not_equal, on_bit_set);
}
bool RegExpMacroAssemblerIA32::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerIA32::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check
@ -659,7 +647,6 @@ bool RegExpMacroAssemblerIA32::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerIA32::Fail() {
STATIC_ASSERT(FAILURE == 0); // Return value for failure is zero.
if (!global()) {
@ -1263,11 +1250,11 @@ void RegExpMacroAssemblerIA32::LoadCurrentCharacterUnchecked(int cp_offset,
DCHECK(mode_ == UC16);
if (characters == 2) {
__ mov(current_character(),
Operand(esi, edi, times_1, cp_offset * sizeof(uc16)));
Operand(esi, edi, times_1, cp_offset * sizeof(base::uc16)));
} else {
DCHECK_EQ(1, characters);
__ movzx_w(current_character(),
Operand(esi, edi, times_1, cp_offset * sizeof(uc16)));
Operand(esi, edi, times_1, cp_offset * sizeof(base::uc16)));
}
}
}

18
src/regexp/ia32/regexp-macro-assembler-ia32.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_
#define V8_REGEXP_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_
#include "src/base/strings.h"
#include "src/codegen/ia32/assembler-ia32.h"
#include "src/codegen/macro-assembler.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -28,8 +29,8 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerIA32
virtual void CheckCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -43,22 +44,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerIA32
virtual void CheckNotCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
uc16 minus,
uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from,
uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from,
uc16 to,
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);
virtual void GoTo(Label* label);

37
src/regexp/mips/regexp-macro-assembler-mips.cc
View File

@ -192,12 +192,11 @@ void RegExpMacroAssemblerMIPS::CheckCharacter(uint32_t c, Label* on_equal) {
BranchOrBacktrack(on_equal, eq, current_character(), Operand(c));
}
void RegExpMacroAssemblerMIPS::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpMacroAssemblerMIPS::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
BranchOrBacktrack(on_greater, gt, current_character(), Operand(limit));
}
void RegExpMacroAssemblerMIPS::CheckAtStart(int cp_offset, Label* on_at_start) {
__ lw(a1, MemOperand(frame_pointer(), kStringStartMinusOne));
__ Addu(a0, current_input_offset(),
@ -214,12 +213,11 @@ void RegExpMacroAssemblerMIPS::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(on_not_at_start, ne, a0, Operand(a1));
}
void RegExpMacroAssemblerMIPS::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerMIPS::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
BranchOrBacktrack(on_less, lt, current_character(), Operand(limit));
}
void RegExpMacroAssemblerMIPS::CheckGreedyLoop(Label* on_equal) {
Label backtrack_non_equal;
__ lw(a0, MemOperand(backtrack_stackpointer(), 0));
@ -462,39 +460,29 @@ void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterAnd(uint32_t c,
BranchOrBacktrack(on_not_equal, ne, a0, rhs);
}
void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterMinusAnd(
uc16 c,
uc16 minus,
uc16 mask,
Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ Subu(a0, current_character(), Operand(minus));
__ And(a0, a0, Operand(mask));
BranchOrBacktrack(on_not_equal, ne, a0, Operand(c));
}
void RegExpMacroAssemblerMIPS::CheckCharacterInRange(
uc16 from,
uc16 to,
Label* on_in_range) {
void RegExpMacroAssemblerMIPS::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ Subu(a0, current_character(), Operand(from));
// Unsigned lower-or-same condition.
BranchOrBacktrack(on_in_range, ls, a0, Operand(to - from));
}
void RegExpMacroAssemblerMIPS::CheckCharacterNotInRange(
uc16 from,
uc16 to,
Label* on_not_in_range) {
base::uc16 from, base::uc16 to, Label* on_not_in_range) {
__ Subu(a0, current_character(), Operand(from));
// Unsigned higher condition.
BranchOrBacktrack(on_not_in_range, hi, a0, Operand(to - from));
}
void RegExpMacroAssemblerMIPS::CheckBitInTable(
Handle<ByteArray> table,
Label* on_bit_set) {
@ -510,8 +498,7 @@ void RegExpMacroAssemblerMIPS::CheckBitInTable(
BranchOrBacktrack(on_bit_set, ne, a0, Operand(zero_reg));
}
bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check.
@ -615,7 +602,6 @@ bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerMIPS::Fail() {
__ li(v0, Operand(FAILURE));
__ jmp(&exit_label_);
@ -827,8 +813,7 @@ Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
// Advance current position after a zero-length match.
Label advance;
__ bind(&advance);
__ Addu(current_input_offset(),
current_input_offset(),
__ Addu(current_input_offset(), current_input_offset(),
Operand((mode_ == UC16) ? 2 : 1));
if (global_unicode()) CheckNotInSurrogatePair(0, &advance);
}

19
src/regexp/mips/regexp-macro-assembler-mips.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_MIPS_REGEXP_MACRO_ASSEMBLER_MIPS_H_
#define V8_REGEXP_MIPS_REGEXP_MACRO_ASSEMBLER_MIPS_H_
#include "src/base/strings.h"
#include "src/codegen/macro-assembler.h"
#include "src/codegen/mips/assembler-mips.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -28,8 +29,8 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
virtual void CheckCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -43,23 +44,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
virtual void CheckNotCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
uc16 minus,
uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from,
uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from,
uc16 to,
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type,
Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);
virtual void GoTo(Label* label);

39
src/regexp/mips64/regexp-macro-assembler-mips64.cc
View File

@ -228,12 +228,11 @@ void RegExpMacroAssemblerMIPS::CheckCharacter(uint32_t c, Label* on_equal) {
BranchOrBacktrack(on_equal, eq, current_character(), Operand(c));
}
void RegExpMacroAssemblerMIPS::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpMacroAssemblerMIPS::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
BranchOrBacktrack(on_greater, gt, current_character(), Operand(limit));
}
void RegExpMacroAssemblerMIPS::CheckAtStart(int cp_offset, Label* on_at_start) {
__ Ld(a1, MemOperand(frame_pointer(), kStringStartMinusOne));
__ Daddu(a0, current_input_offset(),
@ -250,12 +249,11 @@ void RegExpMacroAssemblerMIPS::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(on_not_at_start, ne, a0, Operand(a1));
}
void RegExpMacroAssemblerMIPS::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerMIPS::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
BranchOrBacktrack(on_less, lt, current_character(), Operand(limit));
}
void RegExpMacroAssemblerMIPS::CheckGreedyLoop(Label* on_equal) {
Label backtrack_non_equal;
__ Lw(a0, MemOperand(backtrack_stackpointer(), 0));
@ -492,39 +490,29 @@ void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterAnd(uint32_t c,
BranchOrBacktrack(on_not_equal, ne, a0, rhs);
}
void RegExpMacroAssemblerMIPS::CheckNotCharacterAfterMinusAnd(
uc16 c,
uc16 minus,
uc16 mask,
Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ Dsubu(a0, current_character(), Operand(minus));
__ And(a0, a0, Operand(mask));
BranchOrBacktrack(on_not_equal, ne, a0, Operand(c));
}
void RegExpMacroAssemblerMIPS::CheckCharacterInRange(
uc16 from,
uc16 to,
Label* on_in_range) {
void RegExpMacroAssemblerMIPS::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ Dsubu(a0, current_character(), Operand(from));
// Unsigned lower-or-same condition.
BranchOrBacktrack(on_in_range, ls, a0, Operand(to - from));
}
void RegExpMacroAssemblerMIPS::CheckCharacterNotInRange(
uc16 from,
uc16 to,
Label* on_not_in_range) {
base::uc16 from, base::uc16 to, Label* on_not_in_range) {
__ Dsubu(a0, current_character(), Operand(from));
// Unsigned higher condition.
BranchOrBacktrack(on_not_in_range, hi, a0, Operand(to - from));
}
void RegExpMacroAssemblerMIPS::CheckBitInTable(
Handle<ByteArray> table,
Label* on_bit_set) {
@ -540,8 +528,7 @@ void RegExpMacroAssemblerMIPS::CheckBitInTable(
BranchOrBacktrack(on_bit_set, ne, a0, Operand(zero_reg));
}
bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check.
@ -645,7 +632,6 @@ bool RegExpMacroAssemblerMIPS::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerMIPS::Fail() {
__ li(v0, Operand(FAILURE));
__ jmp(&exit_label_);
@ -863,9 +849,8 @@ Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
// Advance current position after a zero-length match.
Label advance;
__ bind(&advance);
__ Daddu(current_input_offset(),
current_input_offset(),
Operand((mode_ == UC16) ? 2 : 1));
__ Daddu(current_input_offset(), current_input_offset(),
Operand((mode_ == UC16) ? 2 : 1));
if (global_unicode()) CheckNotInSurrogatePair(0, &advance);
}

19
src/regexp/mips64/regexp-macro-assembler-mips64.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_MIPS64_REGEXP_MACRO_ASSEMBLER_MIPS64_H_
#define V8_REGEXP_MIPS64_REGEXP_MACRO_ASSEMBLER_MIPS64_H_
#include "src/base/strings.h"
#include "src/codegen/macro-assembler.h"
#include "src/codegen/mips64/assembler-mips64.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -28,8 +29,8 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
virtual void CheckCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -43,23 +44,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerMIPS
virtual void CheckNotCharacterAfterAnd(uint32_t c,
uint32_t mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
uc16 minus,
uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from,
uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from,
uc16 to,
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type,
Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);
virtual void GoTo(Label* label);

25
src/regexp/ppc/regexp-macro-assembler-ppc.cc
View File

@ -206,8 +206,8 @@ void RegExpMacroAssemblerPPC::CheckCharacter(uint32_t c, Label* on_equal) {
BranchOrBacktrack(eq, on_equal);
}
void RegExpMacroAssemblerPPC::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpMacroAssemblerPPC::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
__ Cmpli(current_character(), Operand(limit), r0);
BranchOrBacktrack(gt, on_greater);
}
@ -229,13 +229,12 @@ void RegExpMacroAssemblerPPC::CheckNotAtStart(int cp_offset,
BranchOrBacktrack(ne, on_not_at_start);
}
void RegExpMacroAssemblerPPC::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpMacroAssemblerPPC::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
__ Cmpli(current_character(), Operand(limit), r0);
BranchOrBacktrack(lt, on_less);
}
void RegExpMacroAssemblerPPC::CheckGreedyLoop(Label* on_equal) {
Label backtrack_non_equal;
__ LoadU64(r3, MemOperand(backtrack_stackpointer(), 0));
@ -488,9 +487,8 @@ void RegExpMacroAssemblerPPC::CheckNotCharacterAfterAnd(unsigned c,
BranchOrBacktrack(ne, on_not_equal, cr0);
}
void RegExpMacroAssemblerPPC::CheckNotCharacterAfterMinusAnd(
uc16 c, uc16 minus, uc16 mask, Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
DCHECK_GT(String::kMaxUtf16CodeUnit, minus);
__ subi(r3, current_character(), Operand(minus));
__ mov(r0, Operand(mask));
@ -499,8 +497,8 @@ void RegExpMacroAssemblerPPC::CheckNotCharacterAfterMinusAnd(
BranchOrBacktrack(ne, on_not_equal);
}
void RegExpMacroAssemblerPPC::CheckCharacterInRange(uc16 from, uc16 to,
void RegExpMacroAssemblerPPC::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
__ mov(r0, Operand(from));
__ sub(r3, current_character(), r0);
@ -508,8 +506,8 @@ void RegExpMacroAssemblerPPC::CheckCharacterInRange(uc16 from, uc16 to,
BranchOrBacktrack(le, on_in_range); // Unsigned lower-or-same condition.
}
void RegExpMacroAssemblerPPC::CheckCharacterNotInRange(uc16 from, uc16 to,
void RegExpMacroAssemblerPPC::CheckCharacterNotInRange(base::uc16 from,
base::uc16 to,
Label* on_not_in_range) {
__ mov(r0, Operand(from));
__ sub(r3, current_character(), r0);
@ -517,7 +515,6 @@ void RegExpMacroAssemblerPPC::CheckCharacterNotInRange(uc16 from, uc16 to,
BranchOrBacktrack(gt, on_not_in_range); // Unsigned higher condition.
}
void RegExpMacroAssemblerPPC::CheckBitInTable(Handle<ByteArray> table,
Label* on_bit_set) {
__ mov(r3, Operand(table));
@ -533,8 +530,7 @@ void RegExpMacroAssemblerPPC::CheckBitInTable(Handle<ByteArray> table,
BranchOrBacktrack(ne, on_bit_set);
}
bool RegExpMacroAssemblerPPC::CheckSpecialCharacterClass(uc16 type,
bool RegExpMacroAssemblerPPC::CheckSpecialCharacterClass(base::uc16 type,
Label* on_no_match) {
// Range checks (c in min..max) are generally implemented by an unsigned
// (c - min) <= (max - min) check
@ -651,7 +647,6 @@ bool RegExpMacroAssemblerPPC::CheckSpecialCharacterClass(uc16 type,
}
}
void RegExpMacroAssemblerPPC::Fail() {
__ li(r3, Operand(FAILURE));
__ b(&exit_label_);

15
src/regexp/ppc/regexp-macro-assembler-ppc.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
#define V8_REGEXP_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
#include "src/base/strings.h"
#include "src/codegen/macro-assembler.h"
#include "src/codegen/ppc/assembler-ppc.h"
#include "src/regexp/regexp-macro-assembler.h"
@ -27,8 +28,8 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerPPC
virtual void CheckCharacter(unsigned c, Label* on_equal);
virtual void CheckCharacterAfterAnd(unsigned c, unsigned mask,
Label* on_equal);
virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(uc16 limit, Label* on_less);
virtual void CheckCharacterGT(base::uc16 limit, Label* on_greater);
virtual void CheckCharacterLT(base::uc16 limit, Label* on_less);
// A "greedy loop" is a loop that is both greedy and with a simple
// body. It has a particularly simple implementation.
virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
@ -41,17 +42,19 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerPPC
virtual void CheckNotCharacter(unsigned c, Label* on_not_equal);
virtual void CheckNotCharacterAfterAnd(unsigned c, unsigned mask,
Label* on_not_equal);
virtual void CheckNotCharacterAfterMinusAnd(uc16 c, uc16 minus, uc16 mask,
virtual void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal);
virtual void CheckCharacterInRange(uc16 from, uc16 to, Label* on_in_range);
virtual void CheckCharacterNotInRange(uc16 from, uc16 to,
virtual void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range);
virtual void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range);
virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
// Checks whether the given offset from the current position is before
// the end of the string.
virtual void CheckPosition(int cp_offset, Label* on_outside_input);
virtual bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match);
virtual bool CheckSpecialCharacterClass(base::uc16 type, Label* on_no_match);
virtual void Fail();
virtual Handle<HeapObject> GetCode(Handle<String> source);
virtual void GoTo(Label* label);

8
src/regexp/property-sequences.cc
View File

@ -42,7 +42,7 @@ const generateData = (property) => {
buffer.push(' ' + codePoints.join(', ') + ', 0,');
}
const output =
`const uc32 UnicodePropertySequences::k${ id }[] = {\n` +
`const base::uc32 UnicodePropertySequences::k${ id }[] = {\n` +
`${ buffer.join('\n') }\n 0 // null-terminating the list\n};\n`;
return output;
};
@ -60,7 +60,7 @@ for (const property of properties) {
*/
// clang-format off
const uc32 UnicodePropertySequences::kEmojiFlagSequences[] = {
const base::uc32 UnicodePropertySequences::kEmojiFlagSequences[] = {
0x01F1E6, 0x01F1E8, 0,
0x01F1FF, 0x01F1FC, 0,
0x01F1E6, 0x01F1EA, 0,
@ -322,14 +322,14 @@ const uc32 UnicodePropertySequences::kEmojiFlagSequences[] = {
0 // null-terminating the list
};
const uc32 UnicodePropertySequences::kEmojiTagSequences[] = {
const base::uc32 UnicodePropertySequences::kEmojiTagSequences[] = {
0x01F3F4, 0x0E0067, 0x0E0062, 0x0E0065, 0x0E006E, 0x0E0067, 0x0E007F, 0,
0x01F3F4, 0x0E0067, 0x0E0062, 0x0E0073, 0x0E0063, 0x0E0074, 0x0E007F, 0,
0x01F3F4, 0x0E0067, 0x0E0062, 0x0E0077, 0x0E006C, 0x0E0073, 0x0E007F, 0,
0 // null-terminating the list
};
const uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
const base::uc32 UnicodePropertySequences::kEmojiZWJSequences[] = {
0x01F468, 0x00200D, 0x002764, 0x00FE0F, 0x00200D, 0x01F468, 0,
0x01F441, 0x00FE0F, 0x00200D, 0x01F5E8, 0x00FE0F, 0,
0x01F468, 0x00200D, 0x01F466, 0,

7
src/regexp/property-sequences.h
View File

@ -7,6 +7,7 @@
#ifdef V8_INTL_SUPPORT
#include "src/base/strings.h"
#include "src/common/globals.h"
namespace v8 {
@ -14,9 +15,9 @@ namespace internal {
class UnicodePropertySequences : public AllStatic {
public:
static const uc32 kEmojiFlagSequences[];
static const uc32 kEmojiTagSequences[];
static const uc32 kEmojiZWJSequences[];
static const base::uc32 kEmojiFlagSequences[];
static const base::uc32 kEmojiTagSequences[];
static const base::uc32 kEmojiZWJSequences[];
};
} // namespace internal

2
src/regexp/regexp-ast.cc
View File

@ -219,7 +219,7 @@ void* RegExpUnparser::VisitAssertion(RegExpAssertion* that, void* data) {
void* RegExpUnparser::VisitAtom(RegExpAtom* that, void* data) {
os_ << "'";
base::Vector<const uc16> chardata = that->data();
base::Vector<const base::uc16> chardata = that->data();
for (int i = 0; i < chardata.length(); i++) {
os_ << AsUC16(chardata[i]);
}

54
src/regexp/regexp-ast.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_REGEXP_AST_H_
#define V8_REGEXP_REGEXP_AST_H_
#include "src/base/strings.h"
#include "src/objects/js-regexp.h"
#include "src/objects/objects.h"
#include "src/objects/string.h"
@ -92,10 +93,10 @@ class CharacterRange {
char type, ZoneList<CharacterRange>* ranges,
bool add_unicode_case_equivalents, Zone* zone);
static base::Vector<const int> GetWordBounds();
static inline CharacterRange Singleton(uc32 value) {
static inline CharacterRange Singleton(base::uc32 value) {
return CharacterRange(value, value);
}
static inline CharacterRange Range(uc32 from, uc32 to) {
static inline CharacterRange Range(base::uc32 from, base::uc32 to) {
DCHECK(0 <= from && to <= String::kMaxCodePoint);
DCHECK(static_cast<uint32_t>(from) <= static_cast<uint32_t>(to));
return CharacterRange(from, to);
@ -110,13 +111,13 @@ class CharacterRange {
list->Add(range, zone);
return list;
}
bool Contains(uc32 i) { return from_ <= i && i <= to_; }
uc32 from() const { return from_; }
void set_from(uc32 value) { from_ = value; }
uc32 to() const { return to_; }
void set_to(uc32 value) { to_ = value; }
bool Contains(base::uc32 i) { return from_ <= i && i <= to_; }
base::uc32 from() const { return from_; }
void set_from(base::uc32 value) { from_ = value; }
base::uc32 to() const { return to_; }
void set_to(base::uc32 value) { to_ = value; }
bool is_valid() { return from_ <= to_; }
bool IsEverything(uc32 max) { return from_ == 0 && to_ >= max; }
bool IsEverything(base::uc32 max) { return from_ == 0 && to_ >= max; }
bool IsSingleton() { return (from_ == to_); }
V8_EXPORT_PRIVATE static void AddCaseEquivalents(
Isolate* isolate, Zone* zone, ZoneList<CharacterRange>* ranges,
@ -136,21 +137,21 @@ class CharacterRange {
static const int kPayloadMask = (1 << 24) - 1;
private:
CharacterRange(uc32 from, uc32 to) : from_(from), to_(to) {}
CharacterRange(base::uc32 from, base::uc32 to) : from_(from), to_(to) {}
uc32 from_;
uc32 to_;
base::uc32 from_;
base::uc32 to_;
};
class CharacterSet final {
public:
explicit CharacterSet(uc16 standard_set_type)
explicit CharacterSet(base::uc16 standard_set_type)
: ranges_(nullptr), standard_set_type_(standard_set_type) {}
explicit CharacterSet(ZoneList<CharacterRange>* ranges)
: ranges_(ranges), standard_set_type_(0) {}
ZoneList<CharacterRange>* ranges(Zone* zone);
uc16 standard_set_type() const { return standard_set_type_; }
void set_standard_set_type(uc16 special_set_type) {
base::uc16 standard_set_type() const { return standard_set_type_; }
void set_standard_set_type(base::uc16 special_set_type) {
standard_set_type_ = special_set_type;
}
bool is_standard() { return standard_set_type_ != 0; }
@ -160,7 +161,7 @@ class CharacterSet final {
ZoneList<CharacterRange>* ranges_;
// If non-zero, the value represents a standard set (e.g., all whitespace
// characters) without having to expand the ranges.
uc16 standard_set_type_;
base::uc16 standard_set_type_;
};
class TextElement final {
@ -322,7 +323,7 @@ class RegExpCharacterClass final : public RegExpTree {
character_class_flags_ ^= NEGATED;
}
}
RegExpCharacterClass(uc16 type, JSRegExp::Flags flags)
RegExpCharacterClass(base::uc16 type, JSRegExp::Flags flags)
: set_(type),
flags_(flags),
character_class_flags_(CharacterClassFlags()) {}
@ -352,7 +353,7 @@ class RegExpCharacterClass final : public RegExpTree {
// D : non-ASCII digit
// . : non-newline
// * : All characters, for advancing unanchored regexp
uc16 standard_type() const { return set_.standard_set_type(); }
base::uc16 standard_type() const { return set_.standard_set_type(); }
ZoneList<CharacterRange>* ranges(Zone* zone) { return set_.ranges(zone); }
bool is_negated() const { return (character_class_flags_ & NEGATED) != 0; }
JSRegExp::Flags flags() const { return flags_; }
@ -369,7 +370,8 @@ class RegExpCharacterClass final : public RegExpTree {
class RegExpAtom final : public RegExpTree {
public:
explicit RegExpAtom(base::Vector<const uc16> data, JSRegExp::Flags flags)
explicit RegExpAtom(base::Vector<const base::uc16> data,
JSRegExp::Flags flags)
: data_(data), flags_(flags) {}
void* Accept(RegExpVisitor* visitor, void* data) override;
RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
@ -379,13 +381,13 @@ class RegExpAtom final : public RegExpTree {
int min_match() override { return data_.length(); }
int max_match() override { return data_.length(); }
void AppendToText(RegExpText* text, Zone* zone) override;
base::Vector<const uc16> data() { return data_; }
base::Vector<const base::uc16> data() { return data_; }
int length() { return data_.length(); }
JSRegExp::Flags flags() const { return flags_; }
bool ignore_case() const { return (flags_ & JSRegExp::kIgnoreCase) != 0; }
private:
base::Vector<const uc16> data_;
base::Vector<const base::uc16> data_;
const JSRegExp::Flags flags_;
};
@ -486,8 +488,8 @@ class RegExpCapture final : public RegExpTree {
max_match_ = body->max_match();
}
int index() const { return index_; }
const ZoneVector<uc16>* name() const { return name_; }
void set_name(const ZoneVector<uc16>* name) { name_ = name; }
const ZoneVector<base::uc16>* name() const { return name_; }
void set_name(const ZoneVector<base::uc16>* name) { name_ = name; }
static int StartRegister(int index) { return index * 2; }
static int EndRegister(int index) { return index * 2 + 1; }
@ -496,7 +498,7 @@ class RegExpCapture final : public RegExpTree {
int index_;
int min_match_;
int max_match_;
const ZoneVector<uc16>* name_;
const ZoneVector<base::uc16>* name_;
};
class RegExpGroup final : public RegExpTree {
@ -593,12 +595,12 @@ class RegExpBackReference final : public RegExpTree {
int index() { return capture_->index(); }
RegExpCapture* capture() { return capture_; }
void set_capture(RegExpCapture* capture) { capture_ = capture; }
const ZoneVector<uc16>* name() const { return name_; }
void set_name(const ZoneVector<uc16>* name) { name_ = name; }
const ZoneVector<base::uc16>* name() const { return name_; }
void set_name(const ZoneVector<base::uc16>* name) { name_ = name; }
private:
RegExpCapture* capture_;
const ZoneVector<uc16>* name_;
const ZoneVector<base::uc16>* name_;
const JSRegExp::Flags flags_;
};

14
src/regexp/regexp-bytecode-generator.cc
View File

@ -220,12 +220,14 @@ void RegExpBytecodeGenerator::LoadCurrentCharacterImpl(int cp_offset,
if (check_bounds) EmitOrLink(on_failure);
}
void RegExpBytecodeGenerator::CheckCharacterLT(uc16 limit, Label* on_less) {
void RegExpBytecodeGenerator::CheckCharacterLT(base::uc16 limit,
Label* on_less) {
Emit(BC_CHECK_LT, limit);
EmitOrLink(on_less);
}
void RegExpBytecodeGenerator::CheckCharacterGT(uc16 limit, Label* on_greater) {
void RegExpBytecodeGenerator::CheckCharacterGT(base::uc16 limit,
Label* on_greater) {
Emit(BC_CHECK_GT, limit);
EmitOrLink(on_greater);
}
@ -288,14 +290,15 @@ void RegExpBytecodeGenerator::CheckNotCharacterAfterAnd(uint32_t c,
}
void RegExpBytecodeGenerator::CheckNotCharacterAfterMinusAnd(
uc16 c, uc16 minus, uc16 mask, Label* on_not_equal) {
base::uc16 c, base::uc16 minus, base::uc16 mask, Label* on_not_equal) {
Emit(BC_MINUS_AND_CHECK_NOT_CHAR, c);
Emit16(minus);
Emit16(mask);
EmitOrLink(on_not_equal);
}
void RegExpBytecodeGenerator::CheckCharacterInRange(uc16 from, uc16 to,
void RegExpBytecodeGenerator::CheckCharacterInRange(base::uc16 from,
base::uc16 to,
Label* on_in_range) {
Emit(BC_CHECK_CHAR_IN_RANGE, 0);
Emit16(from);
@ -303,7 +306,8 @@ void RegExpBytecodeGenerator::CheckCharacterInRange(uc16 from, uc16 to,
EmitOrLink(on_in_range);
}
void RegExpBytecodeGenerator::CheckCharacterNotInRange(uc16 from, uc16 to,
void RegExpBytecodeGenerator::CheckCharacterNotInRange(base::uc16 from,
base::uc16 to,
Label* on_not_in_range) {
Emit(BC_CHECK_CHAR_NOT_IN_RANGE, 0);
Emit16(from);

13
src/regexp/regexp-bytecode-generator.h
View File

@ -5,6 +5,7 @@
#ifndef V8_REGEXP_REGEXP_BYTECODE_GENERATOR_H_
#define V8_REGEXP_REGEXP_BYTECODE_GENERATOR_H_
#include "src/base/strings.h"
#include "src/regexp/regexp-macro-assembler.h"
namespace v8 {
@ -52,18 +53,20 @@ class V8_EXPORT_PRIVATE RegExpBytecodeGenerator : public RegExpMacroAssembler {
void CheckCharacter(unsigned c, Label* on_equal) override;
void CheckCharacterAfterAnd(unsigned c, unsigned mask,
Label* on_equal) override;
void CheckCharacterGT(uc16 limit, Label* on_greater) override;
void CheckCharacterLT(uc16 limit, Label* on_less) override;
void CheckCharacterGT(base::uc16 limit, Label* on_greater) override;
void CheckCharacterLT(base::uc16 limit, Label* on_less) override;
void CheckGreedyLoop(Label* on_tos_equals_current_position) override;
void CheckAtStart(int cp_offset, Label* on_at_start) override;
void CheckNotAtStart(int cp_offset, Label* on_not_at_start) override;
void CheckNotCharacter(unsigned c, Label* on_not_equal) override;
void CheckNotCharacterAfterAnd(unsigned c, unsigned mask,
Label* on_not_equal) override;
void CheckNotCharacterAfterMinusAnd(uc16 c, uc16 minus, uc16 mask,
void CheckNotCharacterAfterMinusAnd(base::uc16 c, base::uc16 minus,
base::uc16 mask,
Label* on_not_equal) override;
void CheckCharacterInRange(uc16 from, uc16 to, Label* on_in_range) override;
void CheckCharacterNotInRange(uc16 from, uc16 to,
void CheckCharacterInRange(base::uc16 from, base::uc16 to,
Label* on_in_range) override;
void CheckCharacterNotInRange(base::uc16 from, base::uc16 to,
Label* on_not_in_range) override;
void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set) override;
void CheckNotBackReference(int start_reg, bool read_backward,

19
src/regexp/regexp-bytecodes.h
View File

@ -7,6 +7,7 @@
#include "src/base/bounds.h"
#include "src/base/macros.h"
#include "src/base/strings.h"
#include "src/common/globals.h"
namespace v8 {
@ -87,12 +88,14 @@ STATIC_ASSERT(1 << BYTECODE_SHIFT > BYTECODE_MASK);
/* 0x10 - 0x1F: Character to match against (after mask aplied) */ \
/* 0x20 - 0x3F: Bitmask bitwise and combined with current character */ \
/* 0x40 - 0x5F: Address of bytecode when matched */ \
V(AND_CHECK_CHAR, 28, 12) /* bc8 pad8 uint16 uint32 addr32 */ \
V(AND_CHECK_NOT_4_CHARS, 29, 16) /* bc8 pad24 uint32 uint32 addr32 */ \
V(AND_CHECK_NOT_CHAR, 30, 12) /* bc8 pad8 uint16 uint32 addr32 */ \
V(MINUS_AND_CHECK_NOT_CHAR, 31, 12) /* bc8 pad8 uc16 uc16 uc16 addr32 */ \
V(CHECK_CHAR_IN_RANGE, 32, 12) /* bc8 pad24 uc16 uc16 addr32 */ \
V(CHECK_CHAR_NOT_IN_RANGE, 33, 12) /* bc8 pad24 uc16 uc16 addr32 */ \
V(AND_CHECK_CHAR, 28, 12) /* bc8 pad8 uint16 uint32 addr32 */ \
V(AND_CHECK_NOT_4_CHARS, 29, 16) /* bc8 pad24 uint32 uint32 addr32 */ \
V(AND_CHECK_NOT_CHAR, 30, 12) /* bc8 pad8 uint16 uint32 addr32 */ \
V(MINUS_AND_CHECK_NOT_CHAR, 31, \
12) /* bc8 pad8 base::uc16 base::uc16 base::uc16 addr32 */ \
V(CHECK_CHAR_IN_RANGE, 32, 12) /* bc8 pad24 base::uc16 base::uc16 addr32 */ \
V(CHECK_CHAR_NOT_IN_RANGE, 33, \
12) /* bc8 pad24 base::uc16 base::uc16 addr32 */ \
/* Checks if the current character matches any of the characters encoded */ \
/* in a bit table. Similar to/inspired by boyer moore string search */ \
/* Bit Layout: */ \
@ -101,8 +104,8 @@ STATIC_ASSERT(1 << BYTECODE_SHIFT > BYTECODE_MASK);
/* 0x20 - 0x3F: Address of bytecode when bit is set */ \
/* 0x40 - 0xBF: Bit table */ \
V(CHECK_BIT_IN_TABLE, 34, 24) /* bc8 pad24 addr32 bits128 */ \
V(CHECK_LT, 35, 8) /* bc8 pad8 uc16 addr32 */ \
V(CHECK_GT, 36, 8) /* bc8 pad8 uc16 addr32 */ \
V(CHECK_LT, 35, 8) /* bc8 pad8 base::uc16 addr32 */ \
V(CHECK_GT, 36, 8) /* bc8 pad8 base::uc16 addr32 */ \
V(CHECK_NOT_BACK_REF, 37, 8) /* bc8 reg_idx24 addr32 */ \
V(CHECK_NOT_BACK_REF_NO_CASE, 38, 8) /* bc8 reg_idx24 addr32 */ \
V(CHECK_NOT_BACK_REF_NO_CASE_UNICODE, 39, 8) \

73
src/regexp/regexp-compiler-tonode.cc
View File

@ -13,6 +13,7 @@
#include "src/zone/zone-list-inl.h"
#ifdef V8_INTL_SUPPORT
#include "src/base/strings.h"
#include "unicode/locid.h"
#include "unicode/uniset.h"
#include "unicode/utypes.h"
@ -56,11 +57,11 @@ static bool CompareInverseRanges(ZoneList<CharacterRange>* ranges,
return false;
}
for (int i = 0; i < length; i += 2) {
if (static_cast<uc32>(special_class[i]) != (range.to() + 1)) {
if (static_cast<base::uc32>(special_class[i]) != (range.to() + 1)) {
return false;
}
range = ranges->at((i >> 1) + 1);
if (static_cast<uc32>(special_class[i + 1]) != range.from()) {
if (static_cast<base::uc32>(special_class[i + 1]) != range.from()) {
return false;
}
}
@ -79,8 +80,8 @@ static bool CompareRanges(ZoneList<CharacterRange>* ranges,
}
for (int i = 0; i < length; i += 2) {
CharacterRange range = ranges->at(i >> 1);
if (range.from() != static_cast<uc32>(special_class[i]) ||
range.to() != static_cast<uc32>(special_class[i + 1] - 1)) {
if (range.from() != static_cast<base::uc32>(special_class[i]) ||
range.to() != static_cast<base::uc32>(special_class[i + 1] - 1)) {
return false;
}
}
@ -138,10 +139,10 @@ UnicodeRangeSplitter::UnicodeRangeSplitter(ZoneList<CharacterRange>* base) {
}
void UnicodeRangeSplitter::AddRange(CharacterRange range) {
static constexpr uc32 kBmp1Start = 0;
static constexpr uc32 kBmp1End = kLeadSurrogateStart - 1;
static constexpr uc32 kBmp2Start = kTrailSurrogateEnd + 1;
static constexpr uc32 kBmp2End = kNonBmpStart - 1;
static constexpr base::uc32 kBmp1Start = 0;
static constexpr base::uc32 kBmp1End = kLeadSurrogateStart - 1;
static constexpr base::uc32 kBmp2Start = kTrailSurrogateEnd + 1;
static constexpr base::uc32 kBmp2End = kNonBmpStart - 1;
// Ends are all inclusive.
STATIC_ASSERT(kBmp1Start == 0);
@ -155,12 +156,12 @@ void UnicodeRangeSplitter::AddRange(CharacterRange range) {
STATIC_ASSERT(kBmp2End + 1 == kNonBmpStart);
STATIC_ASSERT(kNonBmpStart < kNonBmpEnd);
static constexpr uc32 kStarts[] = {
static constexpr base::uc32 kStarts[] = {
kBmp1Start, kLeadSurrogateStart, kTrailSurrogateStart,
kBmp2Start, kNonBmpStart,
};
static constexpr uc32 kEnds[] = {
static constexpr base::uc32 kEnds[] = {
kBmp1End, kLeadSurrogateEnd, kTrailSurrogateEnd, kBmp2End, kNonBmpEnd,
};
@ -174,8 +175,8 @@ void UnicodeRangeSplitter::AddRange(CharacterRange range) {
for (int i = 0; i < kCount; i++) {
if (kStarts[i] > range.to()) break;
const uc32 from = std::max(kStarts[i], range.from());
const uc32 to = std::min(kEnds[i], range.to());
const base::uc32 from = std::max(kStarts[i], range.from());
const base::uc32 to = std::min(kEnds[i], range.to());
if (from > to) continue;
kTargets[i]->emplace_back(CharacterRange::Range(from, to));
}
@ -224,12 +225,12 @@ void AddNonBmpSurrogatePairs(RegExpCompiler* compiler, ChoiceNode* result,
// \ud800[\udc05-\udfff]|
// [\ud801-\ud803][\udc00-\udfff]|
// \ud804[\udc00-\udc05]
uc32 from = non_bmp->at(i).from();
uc32 to = non_bmp->at(i).to();
uc16 from_l = unibrow::Utf16::LeadSurrogate(from);
uc16 from_t = unibrow::Utf16::TrailSurrogate(from);
uc16 to_l = unibrow::Utf16::LeadSurrogate(to);
uc16 to_t = unibrow::Utf16::TrailSurrogate(to);
base::uc32 from = non_bmp->at(i).from();
base::uc32 to = non_bmp->at(i).to();
base::uc16 from_l = unibrow::Utf16::LeadSurrogate(from);
base::uc16 from_t = unibrow::Utf16::TrailSurrogate(from);
base::uc16 to_l = unibrow::Utf16::LeadSurrogate(to);
base::uc16 to_t = unibrow::Utf16::TrailSurrogate(to);
if (from_l == to_l) {
// The lead surrogate is the same.
result->AddAlternative(
@ -447,8 +448,8 @@ RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
int CompareFirstChar(RegExpTree* const* a, RegExpTree* const* b) {
RegExpAtom* atom1 = (*a)->AsAtom();
RegExpAtom* atom2 = (*b)->AsAtom();
uc16 character1 = atom1->data().at(0);
uc16 character2 = atom2->data().at(0);
base::uc16 character1 = atom1->data().at(0);
base::uc16 character2 = atom2->data().at(0);
if (character1 < character2) return -1;
if (character1 > character2) return 1;
return 0;
@ -1060,7 +1061,7 @@ static void AddClassNegated(const int* elmv, int elmc,
DCHECK_EQ(kRangeEndMarker, elmv[elmc]);
DCHECK_NE(0x0000, elmv[0]);
DCHECK_NE(String::kMaxCodePoint, elmv[elmc - 1]);
uc16 last = 0x0000;
base::uc16 last = 0x0000;
for (int i = 0; i < elmc; i += 2) {
DCHECK(last <= elmv[i] - 1);
DCHECK(elmv[i] < elmv[i + 1]);
@ -1148,9 +1149,9 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
icu::UnicodeSet others;
for (int i = 0; i < range_count; i++) {
CharacterRange range = ranges->at(i);
uc32 from = range.from();
base::uc32 from = range.from();
if (from > String::kMaxUtf16CodeUnit) continue;
uc32 to = std::min({range.to(), String::kMaxUtf16CodeUnitU});
base::uc32 to = std::min({range.to(), String::kMaxUtf16CodeUnitU});
// Nothing to be done for surrogates.
if (from >= kLeadSurrogateStart && to <= kTrailSurrogateEnd) continue;
if (is_one_byte && !RangeContainsLatin1Equivalents(range)) {
@ -1191,9 +1192,9 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
#else
for (int i = 0; i < range_count; i++) {
CharacterRange range = ranges->at(i);
uc32 bottom = range.from();
base::uc32 bottom = range.from();
if (bottom > String::kMaxUtf16CodeUnit) continue;
uc32 top = std::min({range.to(), String::kMaxUtf16CodeUnitU});
base::uc32 top = std::min({range.to(), String::kMaxUtf16CodeUnitU});
// Nothing to be done for surrogates.
if (bottom >= kLeadSurrogateStart && top <= kTrailSurrogateEnd) continue;
if (is_one_byte && !RangeContainsLatin1Equivalents(range)) {
@ -1205,7 +1206,7 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
// If this is a singleton we just expand the one character.
int length = isolate->jsregexp_uncanonicalize()->get(bottom, '\0', chars);
for (int i = 0; i < length; i++) {
uc32 chr = chars[i];
base::uc32 chr = chars[i];
if (chr != bottom) {
ranges->Add(CharacterRange::Singleton(chars[i]), zone);
}
@ -1228,11 +1229,11 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
// block we do this for all the blocks covered by the range (handling
// characters that is not in a block as a "singleton block").
unibrow::uchar equivalents[unibrow::Ecma262UnCanonicalize::kMaxWidth];
uc32 pos = bottom;
base::uc32 pos = bottom;
while (pos <= top) {
int length =
isolate->jsregexp_canonrange()->get(pos, '\0', equivalents);
uc32 block_end;
base::uc32 block_end;
if (length == 0) {
block_end = pos;
} else {
@ -1243,9 +1244,9 @@ void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
length = isolate->jsregexp_uncanonicalize()->get(block_end, '\0',
equivalents);
for (int i = 0; i < length; i++) {
uc32 c = equivalents[i];
uc32 range_from = c - (block_end - pos);
uc32 range_to = c - (block_end - end);
base::uc32 c = equivalents[i];
base::uc32 range_from = c - (block_end - pos);
base::uc32 range_to = c - (block_end - end);
if (!(bottom <= range_from && range_to <= top)) {
ranges->Add(CharacterRange::Range(range_from, range_to), zone);
}
@ -1261,7 +1262,7 @@ bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
DCHECK_NOT_NULL(ranges);
int n = ranges->length();
if (n <= 1) return true;
uc32 max = ranges->at(0).to();
base::uc32 max = ranges->at(0).to();
for (int i = 1; i < n; i++) {
CharacterRange next_range = ranges->at(i);
if (next_range.from() <= max + 1) return false;
@ -1301,8 +1302,8 @@ static int InsertRangeInCanonicalList(ZoneList<CharacterRange>* list, int count,
// list[0..count] for the result. Returns the number of resulting
// canonicalized ranges. Inserting a range may collapse existing ranges into
// fewer ranges, so the return value can be anything in the range 1..count+1.
uc32 from = insert.from();
uc32 to = insert.to();
base::uc32 from = insert.from();
base::uc32 to = insert.to();
int start_pos = 0;
int end_pos = count;
for (int i = count - 1; i >= 0; i--) {
@ -1362,7 +1363,7 @@ void CharacterRange::Canonicalize(ZoneList<CharacterRange>* character_ranges) {
// Check whether ranges are already canonical (increasing, non-overlapping,
// non-adjacent).
int n = character_ranges->length();
uc32 max = character_ranges->at(0).to();
base::uc32 max = character_ranges->at(0).to();
int i = 1;
while (i < n) {
CharacterRange current = character_ranges->at(i);
@ -1398,7 +1399,7 @@ void CharacterRange::Negate(ZoneList<CharacterRange>* ranges,
DCHECK(CharacterRange::IsCanonical(ranges));
DCHECK_EQ(0, negated_ranges->length());
int range_count = ranges->length();
uc32 from = 0;
base::uc32 from = 0;
int i = 0;
if (range_count > 0 && ranges->at(0).from() == 0) {
from = ranges->at(0).to() + 1;

100
src/regexp/regexp-compiler.cc
View File

@ -176,7 +176,7 @@ using namespace regexp_compiler_constants; // NOLINT(build/namespaces)
namespace {
constexpr uc32 MaxCodeUnit(const bool one_byte) {
constexpr base::uc32 MaxCodeUnit(const bool one_byte) {
STATIC_ASSERT(String::kMaxOneByteCharCodeU <=
std::numeric_limits<uint16_t>::max());
STATIC_ASSERT(String::kMaxUtf16CodeUnitU <=
@ -751,7 +751,7 @@ bool ContainsOnlyUtf16CodeUnits(unibrow::uchar* chars, int length) {
// Returns the number of characters in the equivalence class, omitting those
// that cannot occur in the source string because it is Latin1.
static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
static int GetCaseIndependentLetters(Isolate* isolate, base::uc16 character,
bool one_byte_subject,
unibrow::uchar* letters,
int letter_length) {
@ -815,7 +815,7 @@ static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
}
static inline bool EmitSimpleCharacter(Isolate* isolate,
RegExpCompiler* compiler, uc16 c,
RegExpCompiler* compiler, base::uc16 c,
Label* on_failure, int cp_offset,
bool check, bool preloaded) {
RegExpMacroAssembler* assembler = compiler->macro_assembler();
@ -831,8 +831,9 @@ static inline bool EmitSimpleCharacter(Isolate* isolate,
// Only emits non-letters (things that don't have case). Only used for case
// independent matches.
static inline bool EmitAtomNonLetter(Isolate* isolate, RegExpCompiler* compiler,
uc16 c, Label* on_failure, int cp_offset,
bool check, bool preloaded) {
base::uc16 c, Label* on_failure,
int cp_offset, bool check,
bool preloaded) {
RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
bool one_byte = compiler->one_byte();
unibrow::uchar chars[4];
@ -860,27 +861,27 @@ static inline bool EmitAtomNonLetter(Isolate* isolate, RegExpCompiler* compiler,
}
static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
bool one_byte, uc16 c1, uc16 c2,
Label* on_failure) {
bool one_byte, base::uc16 c1,
base::uc16 c2, Label* on_failure) {
const uint32_t char_mask = CharMask(one_byte);
uc16 exor = c1 ^ c2;
base::uc16 exor = c1 ^ c2;
// Check whether exor has only one bit set.
if (((exor - 1) & exor) == 0) {
// If c1 and c2 differ only by one bit.
// Ecma262UnCanonicalize always gives the highest number last.
DCHECK(c2 > c1);
uc16 mask = char_mask ^ exor;
base::uc16 mask = char_mask ^ exor;
macro_assembler->CheckNotCharacterAfterAnd(c1, mask, on_failure);
return true;
}
DCHECK(c2 > c1);
uc16 diff = c2 - c1;
base::uc16 diff = c2 - c1;
if (((diff - 1) & diff) == 0 && c1 >= diff) {
// If the characters differ by 2^n but don't differ by one bit then
// subtract the difference from the found character, then do the or
// trick. We avoid the theoretical case where negative numbers are
// involved in order to simplify code generation.
uc16 mask = char_mask ^ diff;
base::uc16 mask = char_mask ^ diff;
macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff, diff, mask,
on_failure);
return true;
@ -891,8 +892,8 @@ static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
// Only emits letters (things that have case). Only used for case independent
// matches.
static inline bool EmitAtomLetter(Isolate* isolate, RegExpCompiler* compiler,
uc16 c, Label* on_failure, int cp_offset,
bool check, bool preloaded) {
base::uc16 c, Label* on_failure,
int cp_offset, bool check, bool preloaded) {
RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
bool one_byte = compiler->one_byte();
unibrow::uchar chars[4];
@ -963,14 +964,14 @@ static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm, int first,
// even_label is for ranges[i] to ranges[i + 1] where i - start_index is even.
// odd_label is for ranges[i] to ranges[i + 1] where i - start_index is odd.
static void EmitUseLookupTable(RegExpMacroAssembler* masm,
ZoneList<uc32>* ranges, uint32_t start_index,
uint32_t end_index, uc32 min_char,
Label* fall_through, Label* even_label,
Label* odd_label) {
ZoneList<base::uc32>* ranges,
uint32_t start_index, uint32_t end_index,
base::uc32 min_char, Label* fall_through,
Label* even_label, Label* odd_label) {
static const uint32_t kSize = RegExpMacroAssembler::kTableSize;
static const uint32_t kMask = RegExpMacroAssembler::kTableMask;
uc32 base = (min_char & ~kMask);
base::uc32 base = (min_char & ~kMask);
USE(base);
// Assert that everything is on one kTableSize page.
@ -1017,10 +1018,10 @@ static void EmitUseLookupTable(RegExpMacroAssembler* masm,
if (on_bit_clear != fall_through) masm->GoTo(on_bit_clear);
}
static void CutOutRange(RegExpMacroAssembler* masm, ZoneList<uc32>* ranges,
uint32_t start_index, uint32_t end_index,
uint32_t cut_index, Label* even_label,
Label* odd_label) {
static void CutOutRange(RegExpMacroAssembler* masm,
ZoneList<base::uc32>* ranges, uint32_t start_index,
uint32_t end_index, uint32_t cut_index,
Label* even_label, Label* odd_label) {
bool odd = (((cut_index - start_index) & 1) == 1);
Label* in_range_label = odd ? odd_label : even_label;
Label dummy;
@ -1041,14 +1042,14 @@ static void CutOutRange(RegExpMacroAssembler* masm, ZoneList<uc32>* ranges,
// Unicode case. Split the search space into kSize spaces that are handled
// with recursion.
static void SplitSearchSpace(ZoneList<uc32>* ranges, uint32_t start_index,
static void SplitSearchSpace(ZoneList<base::uc32>* ranges, uint32_t start_index,
uint32_t end_index, uint32_t* new_start_index,
uint32_t* new_end_index, uc32* border) {
uint32_t* new_end_index, base::uc32* border) {
static const uint32_t kSize = RegExpMacroAssembler::kTableSize;
static const uint32_t kMask = RegExpMacroAssembler::kTableMask;
uc32 first = ranges->at(start_index);
uc32 last = ranges->at(end_index) - 1;
base::uc32 first = ranges->at(start_index);
base::uc32 last = ranges->at(end_index) - 1;
*new_start_index = start_index;
*border = (ranges->at(start_index) & ~kMask) + kSize;
@ -1107,15 +1108,16 @@ static void SplitSearchSpace(ZoneList<uc32>* ranges, uint32_t start_index,
// know that the character is in the range of min_char to max_char inclusive.
// Either label can be nullptr indicating backtracking. Either label can also
// be equal to the fall_through label.
static void GenerateBranches(RegExpMacroAssembler* masm, ZoneList<uc32>* ranges,
uint32_t start_index, uint32_t end_index,
uc32 min_char, uc32 max_char, Label* fall_through,
static void GenerateBranches(RegExpMacroAssembler* masm,
ZoneList<base::uc32>* ranges, uint32_t start_index,
uint32_t end_index, base::uc32 min_char,
base::uc32 max_char, Label* fall_through,
Label* even_label, Label* odd_label) {
DCHECK_LE(min_char, String::kMaxUtf16CodeUnit);
DCHECK_LE(max_char, String::kMaxUtf16CodeUnit);
uc32 first = ranges->at(start_index);
uc32 last = ranges->at(end_index) - 1;
base::uc32 first = ranges->at(start_index);
base::uc32 last = ranges->at(end_index) - 1;
DCHECK_LT(min_char, first);
@ -1175,7 +1177,7 @@ static void GenerateBranches(RegExpMacroAssembler* masm, ZoneList<uc32>* ranges,
uint32_t new_start_index = 0;
uint32_t new_end_index = 0;
uc32 border = 0;
base::uc32 border = 0;
SplitSearchSpace(ranges, start_index, end_index, &new_start_index,
&new_end_index, &border);
@ -1225,7 +1227,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
ZoneList<CharacterRange>* ranges = cc->ranges(zone);
CharacterRange::Canonicalize(ranges);
const uc32 max_char = MaxCodeUnit(one_byte);
const base::uc32 max_char = MaxCodeUnit(one_byte);
int range_count = ranges->length();
int last_valid_range = range_count - 1;
@ -1272,8 +1274,8 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
// entry at zero which goes to the failure label, but if there
// was already one there we fall through for success on that entry.
// Subsequent entries have alternating meaning (success/failure).
ZoneList<uc32>* range_boundaries =
zone->New<ZoneList<uc32>>(last_valid_range, zone);
ZoneList<base::uc32>* range_boundaries =
zone->New<ZoneList<base::uc32>>(last_valid_range, zone);
bool zeroth_entry_is_failure = !cc->is_negated();
@ -1579,11 +1581,11 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
for (int k = 0; k < elements()->length(); k++) {
TextElement elm = elements()->at(k);
if (elm.text_type() == TextElement::ATOM) {
base::Vector<const uc16> quarks = elm.atom()->data();
base::Vector<const base::uc16> quarks = elm.atom()->data();
for (int i = 0; i < characters && i < quarks.length(); i++) {
QuickCheckDetails::Position* pos =
details->positions(characters_filled_in);
uc16 c = quarks[i];
base::uc16 c = quarks[i];
if (elm.atom()->ignore_case()) {
unibrow::uchar chars[4];
int length = GetCaseIndependentLetters(
@ -1664,8 +1666,9 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
}
}
CharacterRange range = ranges->at(first_range);
const uc32 first_from = range.from();
const uc32 first_to = (range.to() > char_mask) ? char_mask : range.to();
const base::uc32 first_from = range.from();
const base::uc32 first_to =
(range.to() > char_mask) ? char_mask : range.to();
const uint32_t differing_bits = (first_from ^ first_to);
// A mask and compare is only perfect if the differing bits form a
// number like 00011111 with one single block of trailing 1s.
@ -1677,9 +1680,10 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
uint32_t bits = (first_from & common_bits);
for (int i = first_range + 1; i < ranges->length(); i++) {
CharacterRange range = ranges->at(i);
const uc32 from = range.from();
const base::uc32 from = range.from();
if (from > char_mask) continue;
const uc32 to = (range.to() > char_mask) ? char_mask : range.to();
const base::uc32 to =
(range.to() > char_mask) ? char_mask : range.to();
// Here we are combining more ranges into the mask and compare
// value. With each new range the mask becomes more sparse and
// so the chances of a false positive rise. A character class
@ -1851,15 +1855,15 @@ RegExpNode* TextNode::FilterOneByte(int depth) {
for (int i = 0; i < element_count; i++) {
TextElement elm = elements()->at(i);
if (elm.text_type() == TextElement::ATOM) {
base::Vector<const uc16> quarks = elm.atom()->data();
base::Vector<const base::uc16> quarks = elm.atom()->data();
for (int j = 0; j < quarks.length(); j++) {
uc16 c = quarks[j];
base::uc16 c = quarks[j];
if (elm.atom()->ignore_case()) {
c = unibrow::Latin1::TryConvertToLatin1(c);
}
if (c > unibrow::Latin1::kMaxChar) return set_replacement(nullptr);
// Replace quark in case we converted to Latin-1.
uc16* writable_quarks = const_cast<uc16*>(quarks.begin());
base::uc16* writable_quarks = const_cast<base::uc16*>(quarks.begin());
writable_quarks[j] = c;
}
} else {
@ -2314,11 +2318,11 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler, TextEmitPassType pass,
int cp_offset = trace->cp_offset() + elm.cp_offset() + backward_offset;
if (elm.text_type() == TextElement::ATOM) {
if (SkipPass(pass, elm.atom()->ignore_case())) continue;
base::Vector<const uc16> quarks = elm.atom()->data();
base::Vector<const base::uc16> quarks = elm.atom()->data();
for (int j = preloaded ? 0 : quarks.length() - 1; j >= 0; j--) {
if (first_element_checked && i == 0 && j == 0) continue;
if (DeterminedAlready(quick_check, elm.cp_offset() + j)) continue;
uc16 quark = quarks[j];
base::uc16 quark = quarks[j];
if (elm.atom()->ignore_case()) {
// Everywhere else we assume that a non-Latin-1 character cannot match
// a Latin-1 character. Avoid the cases where this is assumption is
@ -2523,7 +2527,7 @@ RegExpNode* TextNode::GetSuccessorOfOmnivorousTextNode(
return ranges->length() == 0 ? on_success() : nullptr;
}
if (ranges->length() != 1) return nullptr;
const uc32 max_char = MaxCodeUnit(compiler->one_byte());
const base::uc32 max_char = MaxCodeUnit(compiler->one_byte());
return ranges->at(0).IsEverything(max_char) ? on_success() : nullptr;
}
@ -3803,7 +3807,7 @@ void TextNode::FillInBMInfo(Isolate* isolate, int initial_offset, int budget,
if (initial_offset == 0) set_bm_info(not_at_start, bm);
return;
}
uc16 character = atom->data()[j];
base::uc16 character = atom->data()[j];
if (IgnoreCase(atom->flags())) {
unibrow::uchar chars[4];
int length = GetCaseIndependentLetters(

7
src/regexp/regexp-compiler.h
View File

@ -8,6 +8,7 @@
#include <bitset>
#include "src/base/small-vector.h"
#include "src/base/strings.h"
#include "src/regexp/regexp-nodes.h"
namespace v8 {
@ -21,7 +22,7 @@ namespace regexp_compiler_constants {
// The '2' variant is has inclusive from and exclusive to.
// This covers \s as defined in ECMA-262 5.1, 15.10.2.12,
// which include WhiteSpace (7.2) or LineTerminator (7.3) values.
constexpr uc32 kRangeEndMarker = 0x110000;
constexpr base::uc32 kRangeEndMarker = 0x110000;
constexpr int kSpaceRanges[] = {
'\t', '\r' + 1, ' ', ' ' + 1, 0x00A0, 0x00A1, 0x1680,
0x1681, 0x2000, 0x200B, 0x2028, 0x202A, 0x202F, 0x2030,
@ -96,8 +97,8 @@ class QuickCheckDetails {
void set_cannot_match() { cannot_match_ = true; }
struct Position {
Position() : mask(0), value(0), determines_perfectly(false) {}
uc32 mask;
uc32 value;
base::uc32 mask;
base::uc32 value;
bool determines_perfectly;
};
int characters() { return characters_; }

3
src/regexp/regexp-dotprinter.cc
View File

@ -4,6 +4,7 @@
#include "src/regexp/regexp-dotprinter.h"
#include "src/base/strings.h"
#include "src/regexp/regexp-compiler.h"
#include "src/utils/ostreams.h"
@ -128,7 +129,7 @@ void DotPrinterImpl::VisitText(TextNode* that) {
TextElement elm = that->elements()->at(i);
switch (elm.text_type()) {
case TextElement::ATOM: {
base::Vector<const uc16> data = elm.atom()->data();
base::Vector<const base::uc16> data = elm.atom()->data();
for (int i = 0; i < data.length(); i++) {
os_ << static_cast<char>(data[i]);
}

Some files were not shown because too many files have changed in this diff Show More