string-builder.cc | Explore in Territory

// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/base/strings.h"
#include "src/execution/isolate-inl.h"
#include "src/objects/fixed-array-inl.h"
#include "src/objects/js-array-inl.h"
#include "src/strings/string-builder-inl.h"

namespace v8 {
namespace internal {

template <typename sinkchar>
void StringBuilderConcatHelper(Tagged<String> special, sinkchar* sink,
                               Tagged<FixedArray> fixed_array,
                               int array_length) { … }

template void StringBuilderConcatHelper<uint8_t>(Tagged<String> special,
                                                 uint8_t* sink,
                                                 Tagged<FixedArray> fixed_array,
                                                 int array_length);

template void StringBuilderConcatHelper<base::uc16>(
    Tagged<String> special, base::uc16* sink, Tagged<FixedArray> fixed_array,
    int array_length);

int StringBuilderConcatLength(int special_length,
                              Tagged<FixedArray> fixed_array, int array_length,
                              bool* one_byte) { … }

FixedArrayBuilder::FixedArrayBuilder(Isolate* isolate, int initial_capacity)
    : … { … }

FixedArrayBuilder::FixedArrayBuilder(DirectHandle<FixedArray> backing_store)
    : … { … }

FixedArrayBuilder::FixedArrayBuilder(Isolate* isolate)
    : … { … }

// static
FixedArrayBuilder FixedArrayBuilder::Lazy(Isolate* isolate) { … }

bool FixedArrayBuilder::HasCapacity(int elements) { … }

void FixedArrayBuilder::EnsureCapacity(Isolate* isolate, int elements) { … }

void FixedArrayBuilder::Add(Tagged<Object> value) { … }

void FixedArrayBuilder::Add(Tagged<Smi> value) { … }

int FixedArrayBuilder::capacity() { … }

ReplacementStringBuilder::ReplacementStringBuilder(Heap* heap,
                                                   DirectHandle<String> subject,
                                                   int estimated_part_count)
    : … { … }

void ReplacementStringBuilder::EnsureCapacity(int elements) { … }

void ReplacementStringBuilder::AddString(DirectHandle<String> string) { … }

MaybeDirectHandle<String> ReplacementStringBuilder::ToString() { … }

void ReplacementStringBuilder::AddElement(DirectHandle<Object> element) { … }

IncrementalStringBuilder::IncrementalStringBuilder(Isolate* isolate)
    : … { … }

int IncrementalStringBuilder::Length() const { … }

bool IncrementalStringBuilder::HasValidCurrentIndex() const { … }

void IncrementalStringBuilder::Accumulate(DirectHandle<String> new_part) { … }

void IncrementalStringBuilder::Extend() { … }

MaybeDirectHandle<String> IncrementalStringBuilder::Finish() { … }

// Short strings can be copied directly to {current_part_}.
// Requires the IncrementalStringBuilder to either have two byte encoding or
// the incoming string to have one byte representation "underneath" (The
// one byte check requires the string to be flat).
bool IncrementalStringBuilder::CanAppendByCopy(DirectHandle<String> string) { … }

void IncrementalStringBuilder::AppendStringByCopy(DirectHandle<String> string) { … }

void IncrementalStringBuilder::AppendString(DirectHandle<String> string) { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/strings/string-builder.cc
