#include "node.h"

#include "node_buffer.h"

#include "node_errors.h"

#include "env-inl.h"

#include "string_bytes.h"

#include "string_search.h"

#include "util-inl.h"

#include "v8-profiler.h"

#include "v8.h"

#include <string.h>

#include <limits.h>

#define BUFFER_ID 0xB0E4

#define MIN(a, b) ((a) < (b) ? (a) : (b))

#define THROW_AND_RETURN_UNLESS_BUFFER(env, obj) \

THROW_AND_RETURN_IF_NOT_BUFFER(env, obj, "argument")

#define THROW_AND_RETURN_IF_OOB(r) \

do { \

if (!(r)) return node::THROW_ERR_INDEX_OUT_OF_RANGE(env); \

} while (0)

#define SLICE_START_END(start_arg, end_arg, end_max) \

size_t start; \

size_t end; \

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(start_arg, 0, &start)); \

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(end_arg, end_max, &end)); \

if (end < start) end = start; \

THROW_AND_RETURN_IF_OOB(end <= end_max); \

size_t length = end - start;

namespace node {

bool zero_fill_all_buffers = false;

namespace {

inline void* BufferMalloc(size_t length) {

return zero_fill_all_buffers ? node::UncheckedCalloc(length) :

node::UncheckedMalloc(length);

}

} // namespace

namespace Buffer {

using v8::ArrayBuffer;

using v8::ArrayBufferCreationMode;

using v8::ArrayBufferView;

using v8::Context;

using v8::EscapableHandleScope;

using v8::FunctionCallbackInfo;

using v8::Integer;

using v8::Isolate;

using v8::Local;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Object;

using v8::String;

using v8::Uint32Array;

using v8::Uint8Array;

using v8::Value;

using v8::WeakCallbackInfo;

namespace {

class CallbackInfo {

};

void CallbackInfo::Free(char* data, void*) {

::free(data);

}

CallbackInfo* CallbackInfo::New(Isolate* isolate,

Local<ArrayBuffer> object,

FreeCallback callback,

char* data,

void* hint) {

return new CallbackInfo(isolate, object, callback, data, hint);

}

CallbackInfo::CallbackInfo(Isolate* isolate,

}

void CallbackInfo::WeakCallback(

}

void CallbackInfo::WeakCallback(Isolate* isolate) {

}

inline MUST_USE_RESULT bool ParseArrayIndex(Local<Value> arg,

}

} // anonymous namespace

bool HasInstance(Local<Value> val) {

return val->IsArrayBufferView();

}

bool HasInstance(Local<Object> obj) {

return obj->IsArrayBufferView();

}

char* Data(Local<Value> val) {

CHECK(val->IsArrayBufferView());

Local<ArrayBufferView> ui = val.As<ArrayBufferView>();

ArrayBuffer::Contents ab_c = ui->Buffer()->GetContents();

return static_cast<char*>(ab_c.Data()) + ui->ByteOffset();

}

char* Data(Local<Object> obj) {

CHECK(obj->IsArrayBufferView());

Local<ArrayBufferView> ui = obj.As<ArrayBufferView>();

ArrayBuffer::Contents ab_c = ui->Buffer()->GetContents();

return static_cast<char*>(ab_c.Data()) + ui->ByteOffset();

}

size_t Length(Local<Value> val) {

}

size_t Length(Local<Object> obj) {

}

MaybeLocal<Object> New(Isolate* isolate,

}

MaybeLocal<Object> New(Isolate* isolate, size_t length) {

}

MaybeLocal<Object> New(Environment* env, size_t length) {

}

MaybeLocal<Object> Copy(Isolate* isolate, const char* data, size_t length) {

}

MaybeLocal<Object> Copy(Environment* env, const char* data, size_t length) {

}

MaybeLocal<Object> New(Isolate* isolate,

}

MaybeLocal<Object> New(Environment* env,

}

MaybeLocal<Object> New(Isolate* isolate, char* data, size_t length) {

}

MaybeLocal<Object> New(Environment* env, char* data, size_t length) {

}

namespace {

void CreateFromString(const FunctionCallbackInfo<Value>& args) {

}

template <encoding encoding>

void StringSlice(const FunctionCallbackInfo<Value>& args) {

}

template <>

void StringSlice<UCS2>(const FunctionCallbackInfo<Value>& args) {

Isolate* isolate = args.GetIsolate();

Environment* env = Environment::GetCurrent(isolate);

THROW_AND_RETURN_UNLESS_BUFFER(env, args.This());

SPREAD_BUFFER_ARG(args.This(), ts_obj);

if (ts_obj_length == 0)

return args.GetReturnValue().SetEmptyString();

SLICE_START_END(args[0], args[1], ts_obj_length)

length /= 2;

const char* data = ts_obj_data + start;

const uint16_t* buf;

bool release = false;

// Node's "ucs2" encoding expects LE character data inside a Buffer, so we

// need to reorder on BE platforms. See http://nodejs.org/api/buffer.html

// regarding Node's "ucs2" encoding specification.

const bool aligned = (reinterpret_cast<uintptr_t>(data) % sizeof(*buf) == 0);

if (IsLittleEndian() && !aligned) {

// Make a copy to avoid unaligned accesses in v8::String::NewFromTwoByte().

// This applies ONLY to little endian platforms, as misalignment will be

// handled by a byte-swapping operation in StringBytes::Encode on

// big endian platforms.

uint16_t* copy = new uint16_t[length];

for (size_t i = 0, k = 0; i < length; i += 1, k += 2) {

// Assumes that the input is little endian.

const uint8_t lo = static_cast<uint8_t>(data[k + 0]);

const uint8_t hi = static_cast<uint8_t>(data[k + 1]);

copy[i] = lo | hi << 8;

}

buf = copy;

release = true;

} else {

buf = reinterpret_cast<const uint16_t*>(data);

}

Local<Value> error;

MaybeLocal<Value> ret =

StringBytes::Encode(isolate,

buf,

length,

&error);

if (release)

delete[] buf;

if (ret.IsEmpty()) {

CHECK(!error.IsEmpty());

isolate->ThrowException(error);

return;

}

args.GetReturnValue().Set(ret.ToLocalChecked());

}

void Copy(const FunctionCallbackInfo<Value> &args) {

}

void Fill(const FunctionCallbackInfo<Value>& args) {

}

template <encoding encoding>

void StringWrite(const FunctionCallbackInfo<Value>& args) {

}

void ByteLengthUtf8(const FunctionCallbackInfo<Value> &args) {

}

static int normalizeCompareVal(int val, size_t a_length, size_t b_length) {

}

void CompareOffset(const FunctionCallbackInfo<Value> &args) {

}

void Compare(const FunctionCallbackInfo<Value> &args) {

}

int64_t IndexOfOffset(size_t length,

}

void IndexOfString(const FunctionCallbackInfo<Value>& args) {

}

void IndexOfBuffer(const FunctionCallbackInfo<Value>& args) {

}

void IndexOfNumber(const FunctionCallbackInfo<Value>& args) {