Skip to content

Commit ed29de3

Browse files
targosnodejs-github-bot
targos
authored and
nodejs-github-bot
committed
src: use new versions of V8 String APIs
Refs: v8/v8@a0c8b80 Refs: v8/v8@47a2457
1 parent c0fc477 commit ed29de3

File tree

9 files changed

+66
-76
lines changed

9 files changed

+66
-76
lines changed

‎benchmark/napi/function_args/binding.cc‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,9 +21,10 @@ void CallWithString(const FunctionCallbackInfo<Value>& args) {
2121
assert(args.Length() == 1 && args[0]->IsString());
2222
if (args.Length() == 1 && args[0]->IsString()) {
2323
Local<String> str = args[0].As<String>();
24-
const int32_t length = str->Utf8Length(args.GetIsolate()) + 1;
24+
const size_t length = str->Utf8LengthV2(args.GetIsolate()) + 1;
2525
char* buf = new char[length];
26-
str->WriteUtf8(args.GetIsolate(), buf, length);
26+
str->WriteUtf8V2(
27+
args.GetIsolate(), buf, length, String::WriteFlags::kNullTerminate);
2728
delete[] buf;
2829
}
2930
}

‎src/crypto/crypto_util.cc‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -416,12 +416,12 @@ ByteSource ByteSource::FromStringOrBuffer(Environment* env,
416416
ByteSource ByteSource::FromString(Environment* env, Local<String> str,
417417
bool ntc) {
418418
CHECK(str->IsString());
419-
size_t size = str->Utf8Length(env->isolate());
419+
size_t size = str->Utf8LengthV2(env->isolate());
420420
size_t alloc_size = ntc ? size + 1 : size;
421421
ByteSource::Builder out(alloc_size);
422-
int opts = String::NO_OPTIONS;
423-
if (!ntc) opts |= String::NO_NULL_TERMINATION;
424-
str->WriteUtf8(env->isolate(), out.data<char>(), alloc_size, nullptr, opts);
422+
int opts = String::WriteFlags::kNone;
423+
if (ntc) opts |= String::WriteFlags::kNullTerminate;
424+
str->WriteUtf8V2(env->isolate(), out.data<char>(), alloc_size, opts);
425425
return std::move(out).release();
426426
}
427427

‎src/encoding_binding.cc‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,7 @@ void BindingData::EncodeInto(const FunctionCallbackInfo<Value>& args) {
101101
size_t dest_length = dest->ByteLength();
102102

103103
int nchars;
104+
// TODO: Use `WriteUtf8V2`, which has no `nchars_ref` parameter.
104105
int written = source->WriteUtf8(
105106
isolate,
106107
write_result,
@@ -121,7 +122,7 @@ void BindingData::EncodeUtf8String(const FunctionCallbackInfo<Value>& args) {
121122
CHECK(args[0]->IsString());
122123

123124
Local<String> str = args[0].As<String>();
124-
size_t length = str->Utf8Length(isolate);
125+
size_t length = str->Utf8LengthV2(isolate);
125126

126127
Local<ArrayBuffer> ab;
127128
{
@@ -130,11 +131,11 @@ void BindingData::EncodeUtf8String(const FunctionCallbackInfo<Value>& args) {
130131

131132
CHECK(bs);
132133

133-
str->WriteUtf8(isolate,
134-
static_cast<char*>(bs->Data()),
135-
-1, // We are certain that `data` is sufficiently large
136-
nullptr,
137-
String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8);
134+
str->WriteUtf8V2(
135+
isolate,
136+
static_cast<char*>(bs->Data()),
137+
length, // We are certain that `data` is sufficiently large
138+
String::WriteFlags::kReplaceInvalidUtf8);
138139

139140
ab = ArrayBuffer::New(isolate, std::move(bs));
140141
}

‎src/js_native_api_v8.cc‎

Lines changed: 13 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -2446,16 +2446,13 @@ napi_status NAPI_CDECL napi_get_value_string_latin1(
24462446
CHECK_ARG(env, result);
24472447
*result = val.As<v8::String>()->Length();
24482448
} else if (bufsize != 0) {
2449-
int copied =
2450-
val.As<v8::String>()->WriteOneByte(env->isolate,
2451-
reinterpret_cast<uint8_t*>(buf),
2452-
0,
2453-
bufsize - 1,
2454-
v8::String::NO_NULL_TERMINATION);
2449+
size_t length = bufsize - 1;
2450+
val.As<v8::String>()->WriteOneByteV2(
2451+
env->isolate, 0, length, reinterpret_cast<uint8_t*>(buf));
24552452

2456-
buf[copied] = '\0';
2453+
buf[length] = '\0';
24572454
if (result != nullptr) {
2458-
*result = copied;
2455+
*result = length;
24592456
}
24602457
} else if (result != nullptr) {
24612458
*result = 0;
@@ -2482,14 +2479,13 @@ napi_status NAPI_CDECL napi_get_value_string_utf8(
24822479

24832480
if (!buf) {
24842481
CHECK_ARG(env, result);
2485-
*result = val.As<v8::String>()->Utf8Length(env->isolate);
2482+
*result = val.As<v8::String>()->Utf8LengthV2(env->isolate);
24862483
} else if (bufsize != 0) {
2487-
int copied = val.As<v8::String>()->WriteUtf8(
2484+
size_t copied = val.As<v8::String>()->WriteUtf8V2(
24882485
env->isolate,
24892486
buf,
24902487
bufsize - 1,
2491-
nullptr,
2492-
v8::String::REPLACE_INVALID_UTF8 | v8::String::NO_NULL_TERMINATION);
2488+
v8::String::WriteFlags::kReplaceInvalidUtf8);
24932489

24942490
buf[copied] = '\0';
24952491
if (result != nullptr) {
@@ -2526,15 +2522,13 @@ napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env,
25262522
// V8 assumes UTF-16 length is the same as the number of characters.
25272523
*result = val.As<v8::String>()->Length();
25282524
} else if (bufsize != 0) {
2529-
int copied = val.As<v8::String>()->Write(env->isolate,
2530-
reinterpret_cast<uint16_t*>(buf),
2531-
0,
2532-
bufsize - 1,
2533-
v8::String::NO_NULL_TERMINATION);
2525+
size_t length = bufsize - 1;
2526+
val.As<v8::String>()->WriteV2(
2527+
env->isolate, 0, length, reinterpret_cast<uint16_t*>(buf));
25342528

2535-
buf[copied] = '\0';
2529+
buf[length] = '\0';
25362530
if (result != nullptr) {
2537-
*result = copied;
2531+
*result = length;
25382532
}
25392533
} else if (result != nullptr) {
25402534
*result = 0;

‎src/node_buffer.cc‎

Lines changed: 7 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -646,7 +646,7 @@ void Fill(const FunctionCallbackInfo<Value>& args) {
646646
// Can't use StringBytes::Write() in all cases. For example if attempting
647647
// to write a two byte character into a one byte Buffer.
648648
if (enc == UTF8) {
649-
str_length = str_obj->Utf8Length(env->isolate());
649+
str_length = str_obj->Utf8LengthV2(env->isolate());
650650
node::Utf8Value str(env->isolate(), args[1]);
651651
memcpy(ts_obj_data + start, *str, std::min(str_length, fill_length));
652652

@@ -732,7 +732,8 @@ void SlowByteLengthUtf8(const FunctionCallbackInfo<Value>& args) {
732732
CHECK(args[0]->IsString());
733733

734734
// Fast case: avoid StringBytes on UTF8 string. Jump to v8.
735-
args.GetReturnValue().Set(args[0].As<String>()->Utf8Length(env->isolate()));
735+
size_t length = args[0].As<String>()->Utf8LengthV2(env->isolate());
736+
args.GetReturnValue().Set(static_cast<uint64_t>(length));
736737
}
737738

738739
uint32_t FastByteLengthUtf8(Local<Value> receiver,
@@ -999,8 +1000,7 @@ void IndexOfString(const FunctionCallbackInfo<Value>& args) {
9991000
if (needle_data == nullptr) {
10001001
return args.GetReturnValue().Set(-1);
10011002
}
1002-
needle->WriteOneByte(
1003-
isolate, needle_data, 0, needle_length, String::NO_NULL_TERMINATION);
1003+
needle->WriteOneByteV2(isolate, 0, needle_length, needle_data);
10041004

10051005
result = nbytes::SearchString(reinterpret_cast<const uint8_t*>(haystack),
10061006
haystack_length,
@@ -1250,11 +1250,7 @@ static void Btoa(const FunctionCallbackInfo<Value>& args) {
12501250
simdutf::binary_to_base64(ext->data(), ext->length(), buffer.out());
12511251
} else if (input->IsOneByte()) {
12521252
MaybeStackBuffer<uint8_t> stack_buf(input->Length());
1253-
input->WriteOneByte(env->isolate(),
1254-
stack_buf.out(),
1255-
0,
1256-
input->Length(),
1257-
String::NO_NULL_TERMINATION);
1253+
input->WriteOneByteV2(env->isolate(), 0, input->Length(), stack_buf.out());
12581254

12591255
size_t expected_length =
12601256
simdutf::base64_length_from_binary(input->Length());
@@ -1313,11 +1309,8 @@ static void Atob(const FunctionCallbackInfo<Value>& args) {
13131309
ext->data(), ext->length(), buffer.out(), simdutf::base64_default);
13141310
} else if (input->IsOneByte()) {
13151311
MaybeStackBuffer<uint8_t> stack_buf(input->Length());
1316-
input->WriteOneByte(args.GetIsolate(),
1317-
stack_buf.out(),
1318-
0,
1319-
input->Length(),
1320-
String::NO_NULL_TERMINATION);
1312+
input->WriteOneByteV2(
1313+
args.GetIsolate(), 0, input->Length(), stack_buf.out());
13211314
const char* data = reinterpret_cast<const char*>(*stack_buf);
13221315
size_t expected_length =
13231316
simdutf::maximal_binary_length_from_base64(data, input->Length());

‎src/node_http2.cc‎

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -472,13 +472,10 @@ Origins::Origins(
472472

473473
CHECK_LE(origin_contents + origin_string_len,
474474
static_cast<char*>(bs_->Data()) + bs_->ByteLength());
475-
CHECK_EQ(origin_string->WriteOneByte(
476-
env->isolate(),
477-
reinterpret_cast<uint8_t*>(origin_contents),
478-
0,
479-
origin_string_len,
480-
String::NO_NULL_TERMINATION),
481-
origin_string_len);
475+
origin_string->WriteOneByteV2(env->isolate(),
476+
0,
477+
origin_string_len,
478+
reinterpret_cast<uint8_t*>(origin_contents));
482479

483480
size_t n = 0;
484481
char* p;
@@ -3125,8 +3122,13 @@ void Http2Session::AltSvc(const FunctionCallbackInfo<Value>& args) {
31253122

31263123
MaybeStackBuffer<uint8_t> origin(origin_len);
31273124
MaybeStackBuffer<uint8_t> value(value_len);
3128-
origin_str->WriteOneByte(env->isolate(), *origin);
3129-
value_str->WriteOneByte(env->isolate(), *value);
3125+
origin_str->WriteOneByteV2(env->isolate(),
3126+
0,
3127+
origin_len,
3128+
*origin,
3129+
String::WriteFlags::kNullTerminate);
3130+
value_str->WriteOneByteV2(
3131+
env->isolate(), 0, value_len, *value, String::WriteFlags::kNullTerminate);
31303132

31313133
session->AltSvc(id, *origin, origin_len, *value, value_len);
31323134
}

‎src/node_http_common-inl.h‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -37,13 +37,11 @@ NgHeaders<T>::NgHeaders(Environment* env, v8::Local<v8::Array> headers) {
3737
nv_t* const nva = reinterpret_cast<nv_t*>(start);
3838

3939
CHECK_LE(header_contents + header_string_len, *buf_ + buf_.length());
40-
CHECK_EQ(header_string.As<v8::String>()->WriteOneByte(
40+
header_string.As<v8::String>()->WriteOneByteV2(
4141
env->isolate(),
42-
reinterpret_cast<uint8_t*>(header_contents),
4342
0,
4443
header_string_len,
45-
v8::String::NO_NULL_TERMINATION),
46-
header_string_len);
44+
reinterpret_cast<uint8_t*>(header_contents));
4745

4846
size_t n = 0;
4947
char* p;

‎src/string_bytes.cc‎

Lines changed: 14 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -200,8 +200,11 @@ MaybeLocal<Value> ExternTwoByteString::NewSimpleFromCopy(Isolate* isolate,
200200

201201
} // anonymous namespace
202202

203-
size_t StringBytes::WriteUCS2(
204-
Isolate* isolate, char* buf, size_t buflen, Local<String> str, int flags) {
203+
size_t StringBytes::WriteUCS2(Isolate* isolate,
204+
char* buf,
205+
size_t buflen,
206+
Local<String> str,
207+
int flags = String::WriteFlags::kNone) {
205208
uint16_t* const dst = reinterpret_cast<uint16_t*>(buf);
206209

207210
size_t max_chars = buflen / sizeof(*dst);
@@ -212,7 +215,8 @@ size_t StringBytes::WriteUCS2(
212215
uint16_t* const aligned_dst = nbytes::AlignUp(dst, sizeof(*dst));
213216
size_t nchars;
214217
if (aligned_dst == dst) {
215-
nchars = str->Write(isolate, dst, 0, max_chars, flags);
218+
nchars = max_chars;
219+
str->WriteV2(isolate, 0, nchars, dst, flags);
216220
return nchars * sizeof(*dst);
217221
}
218222

@@ -223,15 +227,15 @@ size_t StringBytes::WriteUCS2(
223227
if (max_chars == 0) {
224228
return 0;
225229
}
226-
nchars = str->Write(isolate, aligned_dst, 0, max_chars - 1, flags);
227-
CHECK_EQ(nchars, max_chars - 1);
230+
nchars = max_chars - 1;
231+
str->WriteV2(isolate, 0, nchars, aligned_dst, flags);
228232

229233
// Shift everything to unaligned-left
230234
memmove(dst, aligned_dst, nchars * sizeof(*dst));
231235

232236
// One more char to be written
233237
uint16_t last;
234-
CHECK_EQ(str->Write(isolate, &last, nchars, 1, flags), 1);
238+
str->WriteV2(isolate, nchars, 1, &last, flags);
235239
memcpy(buf + nchars * sizeof(*dst), &last, sizeof(last));
236240
nchars++;
237241

@@ -250,9 +254,7 @@ size_t StringBytes::Write(Isolate* isolate,
250254
Local<String> str = val.As<String>();
251255
String::ValueView input_view(isolate, str);
252256

253-
int flags = String::HINT_MANY_WRITES_EXPECTED |
254-
String::NO_NULL_TERMINATION |
255-
String::REPLACE_INVALID_UTF8;
257+
int flags = String::WriteFlags::kReplaceInvalidUtf8;
256258

257259
switch (encoding) {
258260
case ASCII:
@@ -262,13 +264,14 @@ size_t StringBytes::Write(Isolate* isolate,
262264
memcpy(buf, input_view.data8(), nbytes);
263265
} else {
264266
uint8_t* const dst = reinterpret_cast<uint8_t*>(buf);
265-
nbytes = str->WriteOneByte(isolate, dst, 0, buflen, flags);
267+
str->WriteOneByteV2(isolate, 0, buflen, dst, flags);
268+
nbytes = buflen;
266269
}
267270
break;
268271

269272
case BUFFER:
270273
case UTF8:
271-
nbytes = str->WriteUtf8(isolate, buf, buflen, nullptr, flags);
274+
nbytes = str->WriteUtf8V2(isolate, buf, buflen, flags);
272275
break;
273276

274277
case UCS2: {

‎src/util.cc‎

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -127,10 +127,9 @@ static void MakeUtf8String(Isolate* isolate,
127127

128128
// TODO(@anonrig): Use simdutf to speed up non-one-byte strings once it's
129129
// implemented
130-
const int flags =
131-
String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8;
132-
const int length =
133-
string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
130+
const int flags = String::WriteFlags::kReplaceInvalidUtf8;
131+
const size_t length =
132+
string->WriteUtf8V2(isolate, target->out(), storage, flags);
134133
target->SetLengthAndZeroTerminate(length);
135134
}
136135

@@ -154,9 +153,8 @@ TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {
154153
const size_t storage = string->Length() + 1;
155154
AllocateSufficientStorage(storage);
156155

157-
const int flags = String::NO_NULL_TERMINATION;
158-
const int length = string->Write(isolate, out(), 0, storage, flags);
159-
SetLengthAndZeroTerminate(length);
156+
string->WriteV2(isolate, 0, storage - 1, out());
157+
SetLengthAndZeroTerminate(storage);
160158
}
161159

162160
BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {

0 commit comments

Comments
 (0)