|
| 1 | +#include "env-inl.h" |
| 2 | +#include "node.h" |
| 3 | +#include "node_external_reference.h" |
| 4 | +#include "node_internals.h" |
| 5 | +#include "util-inl.h" |
| 6 | +#include "v8-fast-api-calls.h" |
| 7 | +#include "v8.h" |
| 8 | + |
| 9 | +#if defined(NODE_HAVE_I18N_SUPPORT) |
| 10 | +#include <unicode/utf8.h> |
| 11 | +#endif // NODE_HAVE_I18N_SUPPORT |
| 12 | + |
| 13 | +namespace node { |
| 14 | + |
| 15 | +using v8::ArrayBuffer; |
| 16 | +using v8::BackingStore; |
| 17 | +using v8::CFunction; |
| 18 | +using v8::Context; |
| 19 | +using v8::FastApiCallbackOptions; |
| 20 | +using v8::FastApiTypedArray; |
| 21 | +using v8::FastOneByteString; |
| 22 | +using v8::FunctionCallbackInfo; |
| 23 | +using v8::Isolate; |
| 24 | +using v8::Local; |
| 25 | +using v8::Object; |
| 26 | +using v8::String; |
| 27 | +using v8::Uint32Array; |
| 28 | +using v8::Uint8Array; |
| 29 | +using v8::Value; |
| 30 | + |
| 31 | +namespace encoding_methods { |
| 32 | + |
| 33 | +static void EncodeUtf8(const FunctionCallbackInfo<Value>& args) { |
| 34 | + Environment* env = Environment::GetCurrent(args); |
| 35 | + Isolate* isolate = env->isolate(); |
| 36 | + CHECK_GE(args.Length(), 1); |
| 37 | + CHECK(args[0]->IsString()); |
| 38 | + |
| 39 | + Local<String> str = args[0].As<String>(); |
| 40 | + size_t length = str->Utf8Length(isolate); |
| 41 | + |
| 42 | + Local<ArrayBuffer> ab; |
| 43 | + { |
| 44 | + NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data()); |
| 45 | + std::unique_ptr<BackingStore> bs = |
| 46 | + ArrayBuffer::NewBackingStore(isolate, length); |
| 47 | + |
| 48 | + CHECK(bs); |
| 49 | + |
| 50 | + str->WriteUtf8(isolate, |
| 51 | + static_cast<char*>(bs->Data()), |
| 52 | + -1, // We are certain that `data` is sufficiently large |
| 53 | + nullptr, |
| 54 | + String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8); |
| 55 | + |
| 56 | + ab = ArrayBuffer::New(isolate, std::move(bs)); |
| 57 | + } |
| 58 | + |
| 59 | + args.GetReturnValue().Set(Uint8Array::New(ab, 0, length)); |
| 60 | +} |
| 61 | + |
| 62 | +static void EncodeIntoUtf8(const FunctionCallbackInfo<Value>& args) { |
| 63 | + Environment* env = Environment::GetCurrent(args); |
| 64 | + Isolate* isolate = env->isolate(); |
| 65 | + CHECK_GE(args.Length(), 3); |
| 66 | + CHECK(args[0]->IsString()); |
| 67 | + CHECK(args[1]->IsUint8Array()); |
| 68 | + CHECK(args[2]->IsUint32Array()); |
| 69 | + |
| 70 | + Local<String> source = args[0].As<String>(); |
| 71 | + |
| 72 | + Local<Uint8Array> dest = args[1].As<Uint8Array>(); |
| 73 | + Local<ArrayBuffer> buf = dest->Buffer(); |
| 74 | + char* write_result = static_cast<char*>(buf->Data()) + dest->ByteOffset(); |
| 75 | + size_t dest_length = dest->ByteLength(); |
| 76 | + |
| 77 | + // results = [ read, written ] |
| 78 | + Local<Uint32Array> result_arr = args[2].As<Uint32Array>(); |
| 79 | + uint32_t* results = reinterpret_cast<uint32_t*>( |
| 80 | + static_cast<char*>(result_arr->Buffer()->Data()) + |
| 81 | + result_arr->ByteOffset()); |
| 82 | + |
| 83 | + int nchars; |
| 84 | + int written = source->WriteUtf8( |
| 85 | + isolate, |
| 86 | + write_result, |
| 87 | + dest_length, |
| 88 | + &nchars, |
| 89 | + String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8); |
| 90 | + results[0] = nchars; |
| 91 | + results[1] = written; |
| 92 | +} |
| 93 | + |
| 94 | +static void FastEncodeIntoUtf8( |
| 95 | + Local<Value> receiver, |
| 96 | + const FastOneByteString& source, |
| 97 | + const FastApiTypedArray<uint8_t>& destination, |
| 98 | + const FastApiTypedArray<uint32_t>& result, |
| 99 | + FastApiCallbackOptions& options) { // NOLINT(runtime/references) |
| 100 | +#if defined(NODE_HAVE_I18N_SUPPORT) |
| 101 | + uint8_t* destination_data; |
| 102 | + CHECK(destination.getStorageIfAligned(&destination_data)); |
| 103 | + |
| 104 | + uint32_t* results; |
| 105 | + CHECK(result.getStorageIfAligned(&results)); |
| 106 | + |
| 107 | + size_t destination_length = destination.length(); |
| 108 | + size_t source_length = source.length; |
| 109 | + size_t written = std::min(source_length, destination_length); |
| 110 | + |
| 111 | + U8_GET_UNSAFE(source.data, 0, *results); |
| 112 | + results[0] = source_length; |
| 113 | + results[1] = written; |
| 114 | +#else |
| 115 | + options.fallback = true; |
| 116 | +#endif // NODE_HAVE_I18N_SUPPORT |
| 117 | +} |
| 118 | + |
| 119 | +CFunction fast_encode_into_utf8_(CFunction::Make(FastEncodeIntoUtf8)); |
| 120 | + |
| 121 | +static void Initialize(Local<Object> target, |
| 122 | + Local<Value> unused, |
| 123 | + Local<Context> context, |
| 124 | + void* priv) { |
| 125 | + SetMethodNoSideEffect(context, target, "encodeUtf8", EncodeUtf8); |
| 126 | + SetFastMethod(context, |
| 127 | + target, |
| 128 | + "encodeIntoUtf8", |
| 129 | + EncodeIntoUtf8, |
| 130 | + &fast_encode_into_utf8_); |
| 131 | +} |
| 132 | + |
| 133 | +void RegisterExternalReferences(ExternalReferenceRegistry* registry) { |
| 134 | + registry->Register(EncodeUtf8); |
| 135 | + |
| 136 | + registry->Register(EncodeIntoUtf8); |
| 137 | + registry->Register(FastEncodeIntoUtf8); |
| 138 | + registry->Register(fast_encode_into_utf8_.GetTypeInfo()); |
| 139 | +} |
| 140 | + |
| 141 | +} // namespace encoding_methods |
| 142 | +} // namespace node |
| 143 | + |
| 144 | +NODE_BINDING_CONTEXT_AWARE_INTERNAL(encoding_methods, |
| 145 | + node::encoding_methods::Initialize) |
| 146 | +NODE_BINDING_EXTERNAL_REFERENCE( |
| 147 | + encoding_methods, node::encoding_methods::RegisterExternalReferences) |
0 commit comments