Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/lib/V8/v8-buffer.cpp

1700 lines
55 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/// Parts of the code are based on:
///
/// Copyright Joyent, Inc. and other Node contributors.
///
/// Permission is hereby granted, free of charge, to any person obtaining a
/// copy of this software and associated documentation files (the
/// "Software"), to deal in the Software without restriction, including
/// without limitation the rights to use, copy, modify, merge, publish,
/// distribute, sublicense, and/or sell copies of the Software, and to permit
/// persons to whom the Software is furnished to do so, subject to the
/// following conditions:
///
/// The above copyright notice and this permission notice shall be included
/// in all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
/// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
/// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
/// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
/// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
/// USE OR OTHER DEALINGS IN THE SOFTWARE.
////////////////////////////////////////////////////////////////////////////////
#include "v8-buffer.h"
#include <v8-profiler.h>
#include "V8/v8-globals.h"
#include "V8/v8-utils.h"
////////////////////////////////////////////////////////////////////////////////
/// @brief safety overhead for buffer allocations
////////////////////////////////////////////////////////////////////////////////
#define SAFETY_OVERHEAD 16
static void InitSafetyOverhead(char* p, size_t length) {
if (p != nullptr) {
memset(p + length, 0, SAFETY_OVERHEAD);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief sliceArgs
////////////////////////////////////////////////////////////////////////////////
static inline bool sliceArgs(v8::Isolate* isolate, v8::Local<v8::Value> const& start_arg,
v8::Local<v8::Value> const& end_arg,
V8Buffer* parent, int32_t& start, int32_t& end) {
if (!start_arg->IsInt32() || !end_arg->IsInt32()) {
TRI_V8_SET_TYPE_ERROR("bad argument");
return false;
}
start = TRI_GET_INT32(start_arg);
end = TRI_GET_INT32(end_arg);
if (start < 0 || end < 0) {
TRI_V8_SET_TYPE_ERROR("bad argument");
return false;
}
if (!(start <= end)) {
TRI_V8_SET_ERROR("must have start <= end");
return false;
}
if ((size_t)end > parent->_length) {
TRI_V8_SET_ERROR("end cannot be longer than parent.length");
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief MIN
////////////////////////////////////////////////////////////////////////////////
#define MIN(a, b) ((a) < (b) ? (a) : (b))
////////////////////////////////////////////////////////////////////////////////
/// @brief unbase64
////////////////////////////////////////////////////////////////////////////////
// supports regular and URL-safe base64
static int const unbase64_table[] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1};
#define unbase64(x) unbase64_table[(uint8_t)(x)]
////////////////////////////////////////////////////////////////////////////////
/// @brief Base64DecodedSize
////////////////////////////////////////////////////////////////////////////////
static size_t Base64DecodedSize(char const* src, size_t size) {
char const* const end = src + size;
int const remainder = size % 4;
size = (size / 4) * 3;
if (remainder) {
// special case: 1-byte input cannot be decoded
if (size == 0 && remainder == 1) {
size = 0;
}
// non-padded input, add 1 or 2 extra bytes
else {
size += 1 + (remainder == 3);
}
}
// check for trailing padding (1 or 2 bytes)
if (size > 0) {
if (end[-1] == '=') size--;
if (end[-2] == '=') size--;
}
return size;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ByteLength
////////////////////////////////////////////////////////////////////////////////
static size_t ByteLengthString(v8::Isolate* isolate, v8::Handle<v8::String> string,
TRI_V8_encoding_t enc) {
v8::HandleScope scope(isolate);
if (enc == UTF8) {
return string->Utf8Length(isolate);
} else if (enc == BASE64) {
v8::String::Utf8Value v(isolate, string);
return Base64DecodedSize(*v, v.length());
} else if (enc == UCS2) {
return string->Length() * 2;
} else if (enc == HEX) {
return string->Length() / 2;
} else {
return string->Length();
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief encodes a buffer
////////////////////////////////////////////////////////////////////////////////
static void Encode(v8::FunctionCallbackInfo<v8::Value> const& args,
const void* buf, size_t len, TRI_V8_encoding_t enc) {
// cppcheck-suppress *
v8::Isolate* isolate = args.GetIsolate();
if (enc == BUFFER) {
TRI_V8_RETURN(TRI_V8_PAIR_STRING(isolate, static_cast<char const*>(buf), len));
}
if (!len) {
TRI_V8_RETURN_UNDEFINED();
}
if (enc == BINARY) {
const unsigned char* cbuf = static_cast<const unsigned char*>(buf);
uint16_t* twobytebuf = new uint16_t[len];
for (size_t i = 0; i < len; i++) {
// XXX is the following line platform independent?
twobytebuf[i] = cbuf[i];
}
v8::Local<v8::String> chunk = TRI_V8_STRING_UTF16(isolate, twobytebuf, (int)len);
delete[] twobytebuf; // TODO use ExternalTwoByteString?
TRI_V8_RETURN(chunk);
}
// utf8 or ascii enc
v8::Local<v8::String> chunk = TRI_V8_PAIR_STRING(isolate, (char const*)buf, (int)len);
TRI_V8_RETURN(chunk);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the array size
////////////////////////////////////////////////////////////////////////////////
#define ARRAY_SIZE(a) (sizeof((a)) / sizeof((a)[0]))
////////////////////////////////////////////////////////////////////////////////
/// @brief constructor template
////////////////////////////////////////////////////////////////////////////////
static void FromConstructorTemplate(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> t,
v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Local<v8::Value> argv[32];
size_t argc = args.Length();
if (argc > ARRAY_SIZE(argv)) {
argc = ARRAY_SIZE(argv);
}
for (size_t i = 0; i < argc; ++i) {
argv[i] = args[(int)i];
}
v8::MaybeLocal<v8::Object> ret =
t->GetFunction()->NewInstance(TRI_IGETC, (int)argc, argv);
TRI_V8_RETURN(ret.FromMaybe(v8::Local<v8::Object>()));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief non ascii test, slow version
////////////////////////////////////////////////////////////////////////////////
static bool ContainsNonAsciiSlow(char const* buf, size_t len) {
for (size_t i = 0; i < len; ++i) {
if (buf[i] & 0x80) {
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief non ascii test
////////////////////////////////////////////////////////////////////////////////
static bool ContainsNonAscii(char const* src, size_t len) {
if (len < 16) {
return ContainsNonAsciiSlow(src, len);
}
const unsigned bytes_per_word = ARANGODB_BITS / (8 * sizeof(char));
const unsigned align_mask = bytes_per_word - 1;
const unsigned unaligned = reinterpret_cast<uintptr_t>(src) & align_mask;
if (unaligned > 0) {
const unsigned n = bytes_per_word - unaligned;
if (ContainsNonAsciiSlow(src, n)) {
return true;
}
src += n;
len -= n;
}
#if ARANGODB_BITS == 64
typedef uint64_t word;
uint64_t const mask = 0x8080808080808080ll;
#else
typedef uint32_t word;
const uint32_t mask = 0x80808080l;
#endif
const word* srcw = reinterpret_cast<const word*>(src);
for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) {
if (srcw[i] & mask) return true;
}
const unsigned remainder = len & align_mask;
if (remainder > 0) {
size_t const offset = len - remainder;
if (ContainsNonAsciiSlow(src + offset, remainder)) {
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief strips high bit, slow version
////////////////////////////////////////////////////////////////////////////////
static void ForceAsciiSlow(char const* src, char* dst, size_t len) {
for (size_t i = 0; i < len; ++i) {
dst[i] = src[i] & 0x7f;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief strips high bit
////////////////////////////////////////////////////////////////////////////////
static void ForceAscii(char const* src, char* dst, size_t len) {
if (len < 16) {
ForceAsciiSlow(src, dst, len);
return;
}
const unsigned bytes_per_word = ARANGODB_BITS / (8 * sizeof(char));
const unsigned align_mask = bytes_per_word - 1;
const unsigned src_unalign = reinterpret_cast<uintptr_t>(src) & align_mask;
const unsigned dst_unalign = reinterpret_cast<uintptr_t>(dst) & align_mask;
if (src_unalign > 0) {
if (src_unalign == dst_unalign) {
const unsigned unalign = bytes_per_word - src_unalign;
ForceAsciiSlow(src, dst, unalign);
src += unalign;
dst += unalign;
len -= src_unalign;
} else {
ForceAsciiSlow(src, dst, len);
return;
}
}
#if ARANGODB_BITS == 64
typedef uint64_t word;
uint64_t const mask = ~0x8080808080808080ll;
#else
typedef uint32_t word;
const uint32_t mask = ~0x80808080l;
#endif
const word* srcw = reinterpret_cast<const word*>(src);
word* dstw = reinterpret_cast<word*>(dst);
for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) {
dstw[i] = srcw[i] & mask;
}
const unsigned remainder = len & align_mask;
if (remainder > 0) {
size_t const offset = len - remainder;
ForceAsciiSlow(src + offset, dst + offset, remainder);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief hex2bin
////////////////////////////////////////////////////////////////////////////////
static unsigned hex2bin(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
if (c >= 'A' && c <= 'F') {
return 10 + (c - 'A');
}
if (c >= 'a' && c <= 'f') {
return 10 + (c - 'a');
}
return static_cast<unsigned>(-1);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief DecodeWrite
///
/// Returns number of bytes written.
////////////////////////////////////////////////////////////////////////////////
static ssize_t DecodeWrite(v8::Isolate* isolate, char* buf, size_t buflen,
v8::Handle<v8::Value> val, TRI_V8_encoding_t encoding) {
v8::HandleScope scope(isolate);
// A lot of improvement can be made here. See:
// http://code.google.com/p/v8/issues/detail?id=270
// http://groups.google.com/group/v8-dev/browse_thread/thread/dba28a81d9215291/ece2b50a3b4022c
// http://groups.google.com/group/v8-users/browse_thread/thread/1f83b0ba1f0a611
if (val->IsArray()) {
return -1;
}
bool is_buffer = V8Buffer::hasInstance(isolate, val);
if (is_buffer && (encoding == BINARY || encoding == BUFFER)) {
// fast path, copy buffer data
char const* data = V8Buffer::data(isolate, val.As<v8::Object>());
size_t size = V8Buffer::length(isolate, val.As<v8::Object>());
size_t len = size < buflen ? size : buflen;
memcpy(buf, data, len);
return (ssize_t)len;
}
v8::Local<v8::String> str;
// slow path, convert to binary string
if (is_buffer) {
v8::Local<v8::Value> arg = TRI_V8_ASCII_STRING(isolate, "binary");
v8::Handle<v8::Object> object = val.As<v8::Object>();
v8::Local<v8::Function> callback =
object->Get(TRI_V8_ASCII_STRING(isolate, "toString")).As<v8::Function>();
str = TRI_GET_STRING(callback->Call(object, 1, &arg));
} else {
str = TRI_GET_STRING(val);
}
if (encoding == UTF8) {
str->WriteUtf8(isolate, buf, (int)buflen, NULL, v8::String::HINT_MANY_WRITES_EXPECTED);
return (ssize_t)buflen;
}
if (encoding == ASCII) {
str->WriteOneByte(isolate, reinterpret_cast<uint8_t*>(buf), 0, (int)buflen,
v8::String::HINT_MANY_WRITES_EXPECTED);
return (ssize_t)buflen;
}
// THIS IS AWFUL!!! FIXME
TRI_ASSERT(encoding == BINARY);
uint16_t* twobytebuf = new uint16_t[buflen];
str->Write(isolate, twobytebuf, 0, (int)buflen, v8::String::HINT_MANY_WRITES_EXPECTED);
for (size_t i = 0; i < buflen; i++) {
unsigned char* b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);
buf[i] = b[0];
}
delete[] twobytebuf;
return (ssize_t)buflen;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief tests if we are big endian
////////////////////////////////////////////////////////////////////////////////
static bool IsBigEndian() {
const union {
uint8_t u8[2];
uint16_t u16;
} u = {{0, 1}};
return u.u16 == 1 ? true : false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief reverses a buffer
////////////////////////////////////////////////////////////////////////////////
static void Swizzle(char* buf, size_t len) {
for (size_t i = 0; i < len / 2; ++i) {
char t = buf[i];
buf[i] = buf[len - i - 1];
buf[len - i - 1] = t;
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief parses an encoding
////////////////////////////////////////////////////////////////////////////////
static TRI_V8_encoding_t ParseEncoding(v8::Isolate* isolate, v8::Handle<v8::Value> encoding_v,
TRI_V8_encoding_t defenc) {
v8::HandleScope scope(isolate);
if (!encoding_v->IsString()) {
return defenc;
}
v8::String::Utf8Value encoding(isolate, encoding_v);
if (strcasecmp(*encoding, "utf8") == 0) {
return UTF8;
} else if (strcasecmp(*encoding, "utf-8") == 0) {
return UTF8;
} else if (strcasecmp(*encoding, "ascii") == 0) {
return ASCII;
} else if (strcasecmp(*encoding, "base64") == 0) {
return BASE64;
} else if (strcasecmp(*encoding, "ucs2") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "ucs-2") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "utf16le") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "utf-16le") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "binary") == 0) {
return BINARY;
} else if (strcasecmp(*encoding, "buffer") == 0) {
return BUFFER;
} else if (strcasecmp(*encoding, "hex") == 0) {
return HEX;
} else {
return defenc;
}
}
namespace {
////////////////////////////////////////////////////////////////////////////////
/// @brief object info
////////////////////////////////////////////////////////////////////////////////
class RetainedBufferInfo : public v8::RetainedObjectInfo {
public:
explicit RetainedBufferInfo(V8Buffer* buffer);
public:
virtual void Dispose() override;
virtual bool IsEquivalent(RetainedObjectInfo* other) override;
virtual intptr_t GetHash() override;
virtual char const* GetLabel() override;
virtual intptr_t GetSizeInBytes() override;
private:
static char const _label[];
private:
V8Buffer* _buffer;
};
////////////////////////////////////////////////////////////////////////////////
/// @brief name of the class
////////////////////////////////////////////////////////////////////////////////
char const RetainedBufferInfo::_label[] = "Buffer";
////////////////////////////////////////////////////////////////////////////////
/// @brief constructors
////////////////////////////////////////////////////////////////////////////////
RetainedBufferInfo::RetainedBufferInfo(V8Buffer* buffer) : _buffer(buffer) {}
////////////////////////////////////////////////////////////////////////////////
/// @brief create a new wrapper info
////////////////////////////////////////////////////////////////////////////////
v8::RetainedObjectInfo* WrapperInfo(uint16_t classId, v8::Handle<v8::Value> wrapper) {
#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
ISOLATE;
TRI_ASSERT(classId == TRI_V8_BUFFER_CID);
TRI_ASSERT(V8Buffer::hasInstance(isolate, wrapper));
#endif
V8Buffer* buffer = V8Buffer::unwrap(wrapper.As<v8::Object>());
return new RetainedBufferInfo(buffer);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief deletes the info
////////////////////////////////////////////////////////////////////////////////
void RetainedBufferInfo::Dispose() {
_buffer = NULL;
delete this;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief checks for equivalence
////////////////////////////////////////////////////////////////////////////////
bool RetainedBufferInfo::IsEquivalent(RetainedObjectInfo* other) {
return _label == other->GetLabel() &&
_buffer == static_cast<RetainedBufferInfo*>(other)->_buffer;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief computes the equivalence hash
////////////////////////////////////////////////////////////////////////////////
intptr_t RetainedBufferInfo::GetHash() {
return reinterpret_cast<intptr_t>(_buffer);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the label of the class
////////////////////////////////////////////////////////////////////////////////
char const* RetainedBufferInfo::GetLabel() { return _label; }
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the size in bytes
////////////////////////////////////////////////////////////////////////////////
intptr_t RetainedBufferInfo::GetSizeInBytes() {
return V8Buffer::length(_buffer->_isolate, _buffer);
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
/// @brief constructs a new buffer from arguments
////////////////////////////////////////////////////////////////////////////////
void V8Buffer::New(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
if (!args.IsConstructCall()) {
TRI_GET_GLOBAL(BufferTempl, v8::FunctionTemplate);
FromConstructorTemplate(isolate, BufferTempl, args);
return;
}
if (!args[0]->IsUint32()) {
TRI_V8_THROW_TYPE_ERROR("bad argument");
}
size_t length = TRI_GET_UINT32(args[0]);
if (length > kMaxLength) {
TRI_V8_THROW_RANGE_ERROR("length > kMaxLength");
}
new V8Buffer(isolate, args.This(), length);
TRI_V8_RETURN(args.This());
}
////////////////////////////////////////////////////////////////////////////////
/// @brief C++ API for constructing fast buffer
////////////////////////////////////////////////////////////////////////////////
v8::Handle<v8::Object> V8Buffer::New(v8::Isolate* isolate, v8::Handle<v8::String> string) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
// get Buffer from global scope.
v8::Local<v8::Object> global = TRI_IGETC->Global();
TRI_GET_GLOBAL_STRING(BufferConstant);
v8::Local<v8::Value> bv = global->Get(BufferConstant);
if (!bv->IsFunction()) {
return v8::Object::New(isolate);
}
v8::Local<v8::Function> b = v8::Local<v8::Function>::Cast(bv);
v8::Local<v8::Value> argv[1] = {v8::Local<v8::Value>::New(isolate, string)};
v8::Local<v8::Object> instance =
b->NewInstance(TRI_IGETC, 1, argv).FromMaybe(v8::Local<v8::Object>());
return instance;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief constructs a new buffer with length
////////////////////////////////////////////////////////////////////////////////
V8Buffer* V8Buffer::New(v8::Isolate* isolate, size_t length) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
v8::Local<v8::Value> arg = v8::Integer::NewFromUnsigned(isolate, (uint32_t)length);
TRI_GET_GLOBAL(BufferTempl, v8::FunctionTemplate);
v8::Local<v8::Object> b =
BufferTempl->GetFunction()->NewInstance(TRI_IGETC, 1, &arg).FromMaybe(v8::Local<v8::Object>());
if (b.IsEmpty()) {
return NULL;
}
return V8Buffer::unwrap(b);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief constructor, data is copied
////////////////////////////////////////////////////////////////////////////////
V8Buffer* V8Buffer::New(v8::Isolate* isolate, char const* data, size_t length) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
v8::Local<v8::Value> arg = v8::Integer::NewFromUnsigned(isolate, 0);
TRI_GET_GLOBAL(BufferTempl, v8::FunctionTemplate);
v8::Local<v8::Object> obj =
BufferTempl->GetFunction()->NewInstance(TRI_IGETC, 1, &arg).FromMaybe(v8::Local<v8::Object>());
V8Buffer* buffer = V8Buffer::unwrap(obj);
buffer->replace(isolate, const_cast<char*>(data), length, NULL, NULL);
return buffer;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief constructs a new buffer from buffer with free callback
////////////////////////////////////////////////////////////////////////////////
V8Buffer* V8Buffer::New(v8::Isolate* isolate, char* data, size_t length,
free_callback_fptr callback, void* hint) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
v8::Local<v8::Value> arg = v8::Integer::NewFromUnsigned(isolate, 0);
TRI_GET_GLOBAL(BufferTempl, v8::FunctionTemplate);
v8::Local<v8::Object> obj =
BufferTempl->GetFunction()->NewInstance(TRI_IGETC, 1, &arg).FromMaybe(v8::Local<v8::Object>());
V8Buffer* buffer = V8Buffer::unwrap(obj);
buffer->replace(isolate, data, length, callback, hint);
return buffer;
}
V8Buffer::~V8Buffer() { replace(_isolate, NULL, 0, NULL, NULL, true); }
////////////////////////////////////////////////////////////////////////////////
/// @brief private constructor
////////////////////////////////////////////////////////////////////////////////
V8Buffer::V8Buffer(v8::Isolate* isolate, v8::Handle<v8::Object> wrapper, size_t length)
: V8Wrapper<V8Buffer, TRI_V8_BUFFER_CID>(isolate, this, nullptr, wrapper), // TODO: warning C4355: 'this' :
// used in base member initializer
// list
_length(0),
_data(nullptr),
_callback(nullptr) {
replace(isolate, NULL, length, NULL, NULL);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief
////////////////////////////////////////////////////////////////////////////////
bool V8Buffer::hasInstance(v8::Isolate* isolate, v8::Handle<v8::Value> val) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (!val->IsObject()) {
return false;
}
v8::Local<v8::Object> obj =
val->ToObject(TRI_IGETC).FromMaybe(v8::Local<v8::Object>());
// Also check for SlowBuffers that are empty.
TRI_GET_GLOBAL(BufferTempl, v8::FunctionTemplate);
if (BufferTempl->HasInstance(obj)) {
return true;
}
if (TRI_HasProperty(context, isolate, obj, "__buffer__")) {
return true;
}
return strcmp(*v8::String::Utf8Value(isolate, obj->GetConstructorName()),
"Buffer") == 0;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief replaces the buffer
////////////////////////////////////////////////////////////////////////////////
void V8Buffer::replace(v8::Isolate* isolate, char* data, size_t length,
free_callback_fptr callback, void* hint, bool deleteIt) {
TRI_V8_CURRENT_GLOBALS_AND_SCOPE;
if (_callback != nullptr) {
_callback(_data, _callbackHint);
} else if (0 < _length) {
delete[] _data;
isolate->AdjustAmountOfExternalAllocatedMemory(
-static_cast<intptr_t>(sizeof(V8Buffer) + _length));
} else {
delete[] _data;
}
_length = length;
_callback = callback;
_callbackHint = hint;
if (_callback != nullptr) {
_data = data;
} else if (0 < _length) {
_data = new char[_length + SAFETY_OVERHEAD];
InitSafetyOverhead(_data, _length);
if (data != nullptr) {
memcpy(_data, data, _length);
}
isolate->AdjustAmountOfExternalAllocatedMemory(sizeof(V8Buffer) + _length + SAFETY_OVERHEAD);
} else {
_data = NULL;
}
if (!deleteIt) {
auto handle = v8::Local<v8::Object>::New(isolate, _handle);
TRI_GET_GLOBAL(LengthKey, v8::String);
auto len = v8::Integer::NewFromUnsigned(isolate, (uint32_t)_length);
handle->Set(LengthKey, len);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief binarySlice
////////////////////////////////////////////////////////////////////////////////
static void JS_BinarySlice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
char* data = parent->_data + start;
Encode(args, data, end - start, BINARY);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief asciiSlice
////////////////////////////////////////////////////////////////////////////////
static void JS_AsciiSlice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
char* data = parent->_data + start;
size_t len = end - start;
if (ContainsNonAscii(data, len)) {
char* out = new char[len + SAFETY_OVERHEAD];
InitSafetyOverhead(out, len);
ForceAscii(data, out, len);
v8::Local<v8::String> rc = TRI_V8_PAIR_STRING(isolate, out, (int)len);
delete[] out;
TRI_V8_RETURN(rc);
}
TRI_V8_RETURN(TRI_V8_PAIR_STRING(isolate, data, (int)len));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief utf8Slice
////////////////////////////////////////////////////////////////////////////////
static void JS_Utf8Slice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
char* data = parent->_data + start;
TRI_V8_RETURN(TRI_V8_PAIR_STRING(isolate, data, end - start));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ucs2Slice
////////////////////////////////////////////////////////////////////////////////
static void JS_Ucs2Slice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
uint16_t* data = (uint16_t*)(parent->_data + start);
TRI_V8_RETURN(TRI_V8_STRING_UTF16(isolate, data, (end - start) / 2));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief hexSlice
////////////////////////////////////////////////////////////////////////////////
static void JS_HexSlice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
char* src = parent->_data + start;
uint32_t dstlen = (end - start) * 2;
if (dstlen == 0) {
TRI_V8_RETURN(v8::String::Empty(isolate));
}
char* dst = new char[dstlen + SAFETY_OVERHEAD];
InitSafetyOverhead(dst, dstlen);
for (uint32_t i = 0, k = 0; k < dstlen; i += 1, k += 2) {
static char const hex[] = "0123456789abcdef";
uint8_t val = static_cast<uint8_t>(src[i]);
dst[k + 0] = hex[val >> 4];
dst[k + 1] = hex[val & 15];
}
v8::Local<v8::String> string = TRI_V8_PAIR_STRING(isolate, dst, dstlen);
delete[] dst;
TRI_V8_RETURN(string);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief base64Slice
////////////////////////////////////////////////////////////////////////////////
static void JS_Base64Slice(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[0], args[1], parent, start, end)) {
return;
}
unsigned slen = end - start;
char const* src = parent->_data + start;
unsigned dlen = (slen + 2 - ((slen + 2) % 3)) / 3 * 4;
char* dst = new char[dlen + SAFETY_OVERHEAD];
InitSafetyOverhead(dst, dlen);
unsigned a;
unsigned b;
unsigned i;
unsigned k;
unsigned n;
static char const table[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
i = 0;
k = 0;
n = slen / 3 * 3;
while (i < n) {
a = src[i + 0] & 0xff;
b = src[i + 1] & 0xff;
unsigned c = src[i + 2] & 0xff;
dst[k + 0] = table[a >> 2];
dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
dst[k + 3] = table[c & 0x3f];
i += 3;
k += 4;
}
if (n != slen) {
switch (slen - n) {
case 1:
a = src[i + 0] & 0xff;
dst[k + 0] = table[a >> 2];
dst[k + 1] = table[(a & 3) << 4];
dst[k + 2] = '=';
dst[k + 3] = '=';
break;
case 2:
a = src[i + 0] & 0xff;
b = src[i + 1] & 0xff;
dst[k + 0] = table[a >> 2];
dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
dst[k + 2] = table[(b & 0x0f) << 2];
dst[k + 3] = '=';
break;
}
}
v8::Local<v8::String> string = TRI_V8_PAIR_STRING(isolate, dst, dlen);
delete[] dst;
TRI_V8_RETURN(string);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief fill
////////////////////////////////////////////////////////////////////////////////
static void JS_Fill(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
int32_t start;
int32_t end;
if (!args[0]->IsInt32()) {
TRI_V8_THROW_EXCEPTION_USAGE("fill(<char>, <start>, <end>)");
}
int value = (char)TRI_GET_INT32(args[0]);
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!sliceArgs(isolate, args[1], args[2], parent, start, end)) {
return;
}
memset((void*)(parent->_data + start), value, end - start);
TRI_V8_RETURN_UNDEFINED();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief copy
////////////////////////////////////////////////////////////////////////////////
static void JS_Copy(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* source = V8Buffer::unwrap(args.This());
if (source == nullptr) {
TRI_V8_THROW_EXCEPTION_USAGE("expecting a buffer as this");
}
v8::Local<v8::Value> target = args[0];
char* target_data = V8Buffer::data(isolate, target);
if (target_data == nullptr || source == nullptr || source->_data == nullptr) {
TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "invalid pointer value");
}
size_t target_length = V8Buffer::length(isolate, target);
size_t target_start = TRI_GET_UINT32(args[1]);
size_t source_start = TRI_GET_UINT32(args[2]);
size_t source_end =
args[3]->IsUndefined() ? source->_length : TRI_GET_UINT32(args[3]);
if (source_end < source_start) {
TRI_V8_THROW_RANGE_ERROR("sourceEnd < sourceStart");
}
// Copy 0 bytes; we're done
if (source_end == source_start) {
TRI_V8_RETURN(v8::Integer::New(isolate, 0));
}
if (target_start >= target_length) {
TRI_V8_THROW_RANGE_ERROR("targetStart out of bounds");
}
if (source_start >= source->_length) {
TRI_V8_THROW_RANGE_ERROR("sourceStart out of bounds");
}
if (source_end > source->_length) {
TRI_V8_THROW_RANGE_ERROR("sourceEnd out of bounds");
}
size_t to_copy = MIN(MIN(source_end - source_start, target_length - target_start),
source->_length - source_start);
// need to use slightly slower memmove is the ranges might overlap
memmove((void*)(target_data + target_start),
(const void*)(source->_data + source_start), to_copy);
TRI_V8_RETURN(v8::Integer::New(isolate, (int32_t)to_copy));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief utf8Write
////////////////////////////////////////////////////////////////////////////////
static void JS_Utf8Write(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE(
"utf8Write(<string>, <offset>, [<maxLength>])");
}
v8::Local<v8::String> s = TRI_GET_STRING(args[0]);
size_t offset = TRI_GET_UINT32(args[1]);
int length = s->Length();
if (length == 0) {
TRI_V8_RETURN(v8::Integer::New(isolate, 0));
}
if (length > 0 && offset >= buffer->_length) {
TRI_V8_THROW_RANGE_ERROR("<offset> is out of bounds");
}
size_t max_length = args[2]->IsUndefined() ? buffer->_length - offset
: TRI_GET_UINT32(args[2]);
max_length = MIN(buffer->_length - offset, max_length);
char* p = buffer->_data + offset;
int char_written;
int written = s->WriteUtf8(isolate, p, (int)max_length, &char_written,
(v8::String::HINT_MANY_WRITES_EXPECTED |
v8::String::NO_NULL_TERMINATION));
TRI_V8_RETURN(v8::Integer::New(isolate, written));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief ucs2Write
////////////////////////////////////////////////////////////////////////////////
static void JS_Ucs2Write(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE("ucs2Write(string, offset, [maxLength])");
}
v8::Local<v8::String> s = TRI_GET_STRING(args[0]);
size_t offset = TRI_GET_UINT32(args[1]);
if (s->Length() > 0 && offset >= buffer->_length) {
TRI_V8_THROW_RANGE_ERROR("<offset> is out of bounds");
}
size_t max_length = args[2]->IsUndefined() ? buffer->_length - offset
: TRI_GET_UINT32(args[2]);
max_length = MIN(buffer->_length - offset, max_length) / 2;
uint16_t* p = (uint16_t*)(buffer->_data + offset);
int written =
s->Write(isolate, p, 0, (int)max_length,
(v8::String::HINT_MANY_WRITES_EXPECTED | v8::String::NO_NULL_TERMINATION));
TRI_V8_RETURN(v8::Integer::New(isolate, written * 2));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief hexWrite
////////////////////////////////////////////////////////////////////////////////
static void JS_HexWrite(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* parent = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE("hexWrite(string, offset, [maxLength])");
}
v8::Local<v8::String> s = args[0].As<v8::String>();
if (s->Length() % 2 != 0) {
TRI_V8_THROW_TYPE_ERROR("invalid hex string");
}
uint32_t start = TRI_GET_UINT32(args[1]);
uint32_t size = TRI_GET_UINT32(args[2]);
uint32_t end = start + size;
if (start >= parent->_length) {
TRI_V8_RETURN(v8::Integer::New(isolate, 0));
}
// overflow + bounds check.
if (end < start || end > parent->_length) {
// dead assignment: end = (uint32_t) parent->_length;
size = (uint32_t)(parent->_length - start);
}
if (size == 0) {
TRI_V8_RETURN(v8::Integer::New(isolate, 0));
}
char* dst = parent->_data + start;
v8::String::Utf8Value string(isolate, s);
char const* src = *string;
uint32_t max = string.length() / 2;
if (max > size) {
max = size;
}
for (uint32_t i = 0; i < max; ++i) {
unsigned a = hex2bin(src[i * 2 + 0]);
unsigned b = hex2bin(src[i * 2 + 1]);
if (!~a || !~b) {
TRI_V8_THROW_TYPE_ERROR("invalid hex string");
}
dst[i] = a * 16 + b;
}
TRI_V8_RETURN(v8::Integer::New(isolate, max));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief asciiWrite
////////////////////////////////////////////////////////////////////////////////
static void JS_AsciiWrite(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE(
"asciiWrite(<string>, <offset>, [<maxLength>])");
}
v8::Local<v8::String> s = TRI_GET_STRING(args[0]);
size_t length = s->Length();
size_t offset = TRI_GET_UINT32(args[1]);
if (length > 0 && offset >= buffer->_length) {
TRI_V8_THROW_TYPE_ERROR("<offset> is out of bounds");
}
size_t max_length = args[2]->IsUndefined() ? buffer->_length - offset
: TRI_GET_UINT32(args[2]);
max_length = MIN(length, MIN(buffer->_length - offset, max_length));
char* p = buffer->_data + offset;
int written =
s->WriteOneByte(isolate, reinterpret_cast<uint8_t*>(p), 0, (int)max_length,
(v8::String::HINT_MANY_WRITES_EXPECTED | v8::String::NO_NULL_TERMINATION));
TRI_V8_RETURN(v8::Integer::New(isolate, written));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief base64Write
////////////////////////////////////////////////////////////////////////////////
static void JS_Base64Write(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE(
"base64Write(<string>, <offset>, [<maxLength>])");
}
v8::String::Utf8Value s(isolate, args[0]);
size_t length = s.length();
size_t offset = TRI_GET_UINT32(args[1]);
size_t max_length = args[2]->IsUndefined() ? buffer->_length - offset
: TRI_GET_UINT32(args[2]);
max_length = MIN(length, MIN(buffer->_length - offset, max_length));
if (max_length && offset >= buffer->_length) {
TRI_V8_THROW_TYPE_ERROR("<offset> is out of bounds");
}
char* start = buffer->_data + offset;
char* dst = start;
char* const dstEnd = dst + max_length;
char const* src = *s;
char const* const srcEnd = src + s.length();
while (src < srcEnd && dst < dstEnd) {
int remaining = (int)(srcEnd - src);
while (unbase64(*src) < 0 && src < srcEnd) {
src++, remaining--;
}
if (remaining == 0 || *src == '=') break;
char a = unbase64(*src++);
while (unbase64(*src) < 0 && src < srcEnd) {
src++, remaining--;
}
if (remaining <= 1 || *src == '=') break;
char b = unbase64(*src++);
*dst++ = (a << 2) | ((b & 0x30) >> 4);
if (dst == dstEnd) break;
while (unbase64(*src) < 0 && src < srcEnd) {
src++, remaining--;
}
if (remaining <= 2 || *src == '=') break;
char c = unbase64(*src++);
*dst++ = ((b & 0x0F) << 4) | ((c & 0x3C) >> 2);
if (dst == dstEnd) break;
while (unbase64(*src) < 0 && src < srcEnd) {
src++, remaining--;
}
if (remaining <= 3 || *src == '=') break;
char d = unbase64(*src++);
*dst++ = ((c & 0x03) << 6) | (d & 0x3F);
}
TRI_V8_RETURN(v8::Integer::New(isolate, (int32_t)(dst - start)));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief binaryWrite
////////////////////////////////////////////////////////////////////////////////
static void JS_BinaryWrite(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE(
"binaryWrite(<string>, <offset>, [<maxLength>])");
}
v8::Local<v8::String> s = TRI_GET_STRING(args[0]);
size_t length = s->Length();
size_t offset = TRI_GET_UINT32(args[1]);
if (s->Length() > 0 && offset >= buffer->_length) {
TRI_V8_THROW_TYPE_ERROR("<offset> is out of bounds");
}
char* p = (char*)buffer->_data + offset;
size_t max_length = args[2]->IsUndefined() ? buffer->_length - offset
: TRI_GET_UINT32(args[2]);
max_length = MIN(length, MIN(buffer->_length - offset, max_length));
ssize_t written = DecodeWrite(isolate, p, max_length, s, BINARY);
TRI_V8_RETURN(v8::Integer::New(isolate, (int32_t)written));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief reads a float (generic version)
////////////////////////////////////////////////////////////////////////////////
template <typename T, bool ENDIANNESS>
static void ReadFloatGeneric(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
double offset_tmp = TRI_GET_DOUBLE(args[0]);
int64_t offset = static_cast<int64_t>(offset_tmp);
bool doTRI_ASSERT = !args[1]->BooleanValue(TRI_IGETC).FromMaybe(true);
V8Buffer* buffer = V8Buffer::unwrap(args.This());
if (doTRI_ASSERT) {
if (offset_tmp != offset || offset < 0) {
TRI_V8_THROW_TYPE_ERROR("<offset> is not uint");
}
size_t len = static_cast<size_t>(buffer->_length);
if (offset + sizeof(T) > len) {
TRI_V8_THROW_RANGE_ERROR("trying to read beyond buffer length");
}
}
char* data = static_cast<char*>(buffer->_data);
char* ptr = data + offset;
T val;
memcpy(&val, ptr, sizeof(T));
if (ENDIANNESS != IsBigEndian()) {
Swizzle(reinterpret_cast<char*>(&val), sizeof(T));
}
TRI_V8_RETURN(v8::Number::New(isolate, val));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief readFloatLE
////////////////////////////////////////////////////////////////////////////////
static void JS_ReadFloatLE(v8::FunctionCallbackInfo<v8::Value> const& args) {
ReadFloatGeneric<float, false>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief readFloatBE
////////////////////////////////////////////////////////////////////////////////
static void JS_ReadFloatBE(v8::FunctionCallbackInfo<v8::Value> const& args) {
ReadFloatGeneric<float, true>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief readDoubleLE
////////////////////////////////////////////////////////////////////////////////
static void JS_ReadDoubleLE(v8::FunctionCallbackInfo<v8::Value> const& args) {
return ReadFloatGeneric<double, false>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief readDoubleBE
////////////////////////////////////////////////////////////////////////////////
static void JS_ReadDoubleBE(v8::FunctionCallbackInfo<v8::Value> const& args) {
ReadFloatGeneric<double, true>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief writes a float (generic version)
////////////////////////////////////////////////////////////////////////////////
template <typename T, bool ENDIANNESS>
static void WriteFloatGeneric(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
bool doTRI_ASSERT = !args[2]->BooleanValue(TRI_IGETC).FromMaybe(true);
if (doTRI_ASSERT) {
if (!args[0]->IsNumber()) {
TRI_V8_THROW_TYPE_ERROR("<value> not a number");
}
if (!args[1]->IsUint32()) {
TRI_V8_THROW_TYPE_ERROR("<offset> is not uint");
}
}
V8Buffer* buffer = V8Buffer::unwrap(args.This());
T val = static_cast<T>(TRI_GET_DOUBLE(args[0]));
size_t offset = TRI_GET_UINT32(args[1]);
char* data = static_cast<char*>(buffer->_data);
char* ptr = data + offset;
if (doTRI_ASSERT) {
size_t len = static_cast<size_t>(buffer->_length);
if (offset + sizeof(T) > len || offset + sizeof(T) < offset) {
TRI_V8_THROW_RANGE_ERROR("trying to write beyond buffer length");
}
}
memcpy(ptr, &val, sizeof(T));
if (ENDIANNESS != IsBigEndian()) {
Swizzle(ptr, sizeof(T));
}
TRI_V8_RETURN_UNDEFINED();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief writeFloatLE
////////////////////////////////////////////////////////////////////////////////
static void JS_WriteFloatLE(v8::FunctionCallbackInfo<v8::Value> const& args) {
WriteFloatGeneric<float, false>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief writeFloatBE
////////////////////////////////////////////////////////////////////////////////
static void JS_WriteFloatBE(v8::FunctionCallbackInfo<v8::Value> const& args) {
WriteFloatGeneric<float, true>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief writeDoubleLE
////////////////////////////////////////////////////////////////////////////////
static void JS_WriteDoubleLE(v8::FunctionCallbackInfo<v8::Value> const& args) {
WriteFloatGeneric<double, false>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief writeDoubleBE
////////////////////////////////////////////////////////////////////////////////
static void JS_WriteDoubleBE(v8::FunctionCallbackInfo<v8::Value> const& args) {
WriteFloatGeneric<double, true>(args);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief byteLength
////////////////////////////////////////////////////////////////////////////////
static void JS_ByteLength(v8::FunctionCallbackInfo<v8::Value> const& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
if (!args[0]->IsString()) {
TRI_V8_THROW_EXCEPTION_USAGE("byteLength(<string>, <utf8>)");
}
v8::Local<v8::String> s = TRI_GET_STRING(args[0]);
TRI_V8_encoding_t e = ParseEncoding(isolate, args[1], UTF8);
TRI_V8_RETURN(v8::Integer::New(isolate, (int32_t)ByteLengthString(isolate, s, e)));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief selects an indexed attribute from the buffer
////////////////////////////////////////////////////////////////////////////////
static void MapGetIndexedBuffer(uint32_t idx,
const v8::PropertyCallbackInfo<v8::Value>& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::HandleScope scope(isolate);
v8::Handle<v8::Object> self = args.Holder();
if (self->InternalFieldCount() == 0) {
// seems object has become a FastBuffer already
if (TRI_HasProperty(context, isolate, self, "parent")) {
v8::Handle<v8::Value> parent =
self->Get(TRI_V8_ASCII_STRING(isolate, "parent"));
if (!parent->IsObject()) {
TRI_V8_RETURN(v8::Handle<v8::Value>());
}
self = TRI_GetObject(context, parent);
// intentionally falls through
}
}
V8Buffer* buffer = V8Buffer::unwrap(self);
if (buffer == nullptr || idx >= buffer->_length) {
TRI_V8_RETURN(v8::Handle<v8::Value>());
}
TRI_V8_RETURN(v8::Integer::NewFromUnsigned(isolate, ((uint8_t)buffer->_data[idx])));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief sets an indexed attribute in the buffer
////////////////////////////////////////////////////////////////////////////////
static void MapSetIndexedBuffer(uint32_t idx, v8::Local<v8::Value> value,
const v8::PropertyCallbackInfo<v8::Value>& args) {
v8::Isolate* isolate = args.GetIsolate();
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::HandleScope scope(isolate);
v8::Handle<v8::Object> self = args.Holder();
if (self->InternalFieldCount() == 0) {
// seems object has become a FastBuffer already
if (TRI_HasProperty(context, isolate, self, "parent")) {
v8::Handle<v8::Value> parent =
self->Get(TRI_V8_ASCII_STRING(isolate, "parent"));
if (!parent->IsObject()) {
TRI_V8_RETURN(v8::Handle<v8::Value>());
}
self = TRI_GetObject(context, parent);
// intentionally falls through
}
}
V8Buffer* buffer = V8Buffer::unwrap(self);
if (buffer == nullptr || idx >= buffer->_length) {
TRI_V8_RETURN(v8::Handle<v8::Value>());
}
auto val = static_cast<uint8_t>(TRI_GET_DOUBLE(value));
buffer->_data[idx] = (char)val;
TRI_V8_RETURN(v8::Integer::NewFromUnsigned(isolate, ((uint8_t)buffer->_data[idx])));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief initializes the buffer module
////////////////////////////////////////////////////////////////////////////////
void TRI_InitV8Buffer(v8::Isolate* isolate) {
v8::HandleScope scope(isolate);
// sanity checks
TRI_ASSERT(unbase64('/') == 63);
TRI_ASSERT(unbase64('+') == 62);
TRI_ASSERT(unbase64('T') == 19);
TRI_ASSERT(unbase64('Z') == 25);
TRI_ASSERT(unbase64('t') == 45);
TRI_ASSERT(unbase64('z') == 51);
TRI_ASSERT(unbase64(' ') == -2);
TRI_ASSERT(unbase64('\n') == -2);
TRI_ASSERT(unbase64('\r') == -2);
TRI_v8_global_t* v8g = TRI_GetV8Globals(isolate);
// .............................................................................
// generate the general SlowBuffer template
// .............................................................................
v8::Handle<v8::FunctionTemplate> ft;
v8::Handle<v8::ObjectTemplate> rt;
ft = v8::FunctionTemplate::New(isolate, V8Buffer::New);
ft->SetClassName(TRI_V8_ASCII_STRING(isolate, "SlowBuffer"));
rt = ft->InstanceTemplate();
rt->SetInternalFieldCount(1);
// accessor for indexed properties (e.g. buffer[1])
rt->SetIndexedPropertyHandler(MapGetIndexedBuffer, MapSetIndexedBuffer);
v8g->BufferTempl.Reset(isolate, ft);
// copy free
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "binarySlice"), JS_BinarySlice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "asciiSlice"), JS_AsciiSlice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "base64Slice"), JS_Base64Slice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "ucs2Slice"), JS_Ucs2Slice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "hexSlice"), JS_HexSlice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "utf8Slice"), JS_Utf8Slice);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "utf8Write"), JS_Utf8Write);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "asciiWrite"), JS_AsciiWrite);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "binaryWrite"), JS_BinaryWrite);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "base64Write"), JS_Base64Write);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "ucs2Write"), JS_Ucs2Write);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "hexWrite"), JS_HexWrite);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "readFloatLE"), JS_ReadFloatLE);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "readFloatBE"), JS_ReadFloatBE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "readDoubleLE"), JS_ReadDoubleLE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "readDoubleBE"), JS_ReadDoubleBE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "writeFloatLE"), JS_WriteFloatLE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "writeFloatBE"), JS_WriteFloatBE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "writeDoubleLE"), JS_WriteDoubleLE);
TRI_V8_AddProtoMethod(isolate, ft,
TRI_V8_ASCII_STRING(isolate, "writeDoubleBE"), JS_WriteDoubleBE);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "fill"), JS_Fill);
TRI_V8_AddProtoMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "copy"), JS_Copy);
TRI_V8_AddMethod(isolate, ft, TRI_V8_ASCII_STRING(isolate, "byteLength"), JS_ByteLength);
// create the exports
v8::Handle<v8::Object> exports = v8::Object::New(isolate);
TRI_V8_AddMethod(isolate, exports, TRI_V8_ASCII_STRING(isolate, "SlowBuffer"), ft);
TRI_AddGlobalVariableVocbase(
isolate, TRI_V8_ASCII_STRING(isolate, "EXPORTS_SLOW_BUFFER"), exports);
v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
heap_profiler->SetWrapperClassInfoProvider(TRI_V8_BUFFER_CID, WrapperInfo);
}
Reference in New Issue View Git Blame Copy Permalink