diff --git a/deps/chakrashim/chakrashim.gyp b/deps/chakrashim/chakrashim.gyp index b3740a6a64b..39216932ad8 100644 --- a/deps/chakrashim/chakrashim.gyp +++ b/deps/chakrashim/chakrashim.gyp @@ -48,8 +48,10 @@ 'msvs_disabled_warnings': [4091], }, 'sources': [ + 'include/libplatform/libplatform.h', 'include/v8.h', 'include/v8-debug.h', + 'include/v8-platform.h', 'include/v8-profiler.h', 'src/jsrtcachedpropertyidref.inc', 'src/jsrtcontextcachedobj.inc', @@ -67,6 +69,7 @@ 'src/jsrtutils.cc', 'src/jsrtutils.h', 'src/v8array.cc', + 'src/v8arraybuffer.cc', 'src/v8boolean.cc', 'src/v8booleanobject.cc', 'src/v8chakra.h', @@ -91,10 +94,12 @@ 'src/v8returnvalue.cc', 'src/v8script.cc', 'src/v8signature.cc', + 'src/v8stacktrace.cc', 'src/v8string.cc', 'src/v8stringobject.cc', 'src/v8template.cc', 'src/v8trycatch.cc', + 'src/v8typedarray.cc', 'src/v8uint32.cc', 'src/v8v8.cc', 'src/v8value.cc', diff --git a/deps/chakrashim/include/libplatform/libplatform.h b/deps/chakrashim/include/libplatform/libplatform.h new file mode 100644 index 00000000000..d413c27de9f --- /dev/null +++ b/deps/chakrashim/include/libplatform/libplatform.h @@ -0,0 +1,47 @@ +// Copyright 2014 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef V8_LIBPLATFORM_LIBPLATFORM_H_ +#define V8_LIBPLATFORM_LIBPLATFORM_H_ + +#include "include/v8-platform.h" + +namespace v8 { +namespace platform { + +v8::Platform* CreateDefaultPlatform(int thread_pool_size = 0) { + return nullptr; +} + +bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate) { + return false; +} + +} // namespace platform +} // namespace v8 + +#endif // V8_LIBPLATFORM_LIBPLATFORM_H_ diff --git a/deps/chakrashim/include/v8-debug.h b/deps/chakrashim/include/v8-debug.h index 70775344a74..fefe40cde1c 100644 --- a/deps/chakrashim/include/v8-debug.h +++ b/deps/chakrashim/include/v8-debug.h @@ -55,7 +55,7 @@ class EXPORT Debug { static void DisableAgent() {} static bool IsAgentEnabled(); static void ProcessDebugMessages() {} - static Local GetDebugContext() { return Context::GetCurrent(); } + static Local GetDebugContext(); static void SetMessageHandler(MessageHandler handler) {} static void SendCommand(Isolate* isolate, const uint16_t* command, int length, diff --git a/deps/chakrashim/include/v8-platform.h b/deps/chakrashim/include/v8-platform.h new file mode 100644 index 00000000000..6a807235548 --- /dev/null +++ b/deps/chakrashim/include/v8-platform.h @@ -0,0 +1,57 @@ +// Copyright 2013 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef V8_V8_PLATFORM_H_ +#define V8_V8_PLATFORM_H_ + +namespace v8 { + +class Isolate; + +class Task { + public: + virtual ~Task() {} + virtual void Run() = 0; +}; + +class Platform { + public: + enum ExpectedRuntime { + kShortRunningTask, + kLongRunningTask + }; + + virtual ~Platform() {} + virtual void CallOnBackgroundThread(Task* task, + ExpectedRuntime expected_runtime) = 0; + virtual void CallOnForegroundThread(Isolate* isolate, Task* task) = 0; + virtual double MonotonicallyIncreasingTime() = 0; +}; + +} // namespace v8 + +#endif // V8_V8_PLATFORM_H_ diff --git a/deps/chakrashim/include/v8.h b/deps/chakrashim/include/v8.h index 3bb04a1b36f..47e2f9c6dc0 100644 --- a/deps/chakrashim/include/v8.h +++ b/deps/chakrashim/include/v8.h @@ -56,8 +56,17 @@ // V8 does. #define EXPORT __declspec(dllexport) - -# define V8_DEPRECATED(message, declarator) declarator +#define V8_EXPORT EXPORT +#define V8_INLINE inline +#define V8_DEPRECATED(message, declarator) declarator +#define V8_WARN_UNUSED_RESULT +#define V8_UNLIKELY(condition) (condition) +#define V8_LIKELY(condition) (condition) + +#define TYPE_CHECK(T, S) \ + while (false) { \ + *(static_cast(0)) = static_cast(0); \ + } namespace v8 { @@ -76,19 +85,25 @@ class HeapProfiler; class Int32; class Integer; class Isolate; +class Name; class Number; class NumberObject; class Object; class ObjectTemplate; +class Platform; class ResourceConstraints; class RegExp; +class Promise; class Script; class Signature; +class StackFrame; class String; class StringObject; class Uint32; template class Handle; template class Local; +template class Maybe; +template class MaybeLocal; template class Persistent; template class FunctionCallbackInfo; template class PropertyCallbackInfo; @@ -146,6 +161,7 @@ typedef void (*AccessorSetterCallback)( Local property, Local value, const PropertyCallbackInfo& info); + typedef void (*NamedPropertyGetterCallback)( Local property, const PropertyCallbackInfo& info); typedef void (*NamedPropertySetterCallback)( @@ -158,6 +174,19 @@ typedef void (*NamedPropertyDeleterCallback)( Local property, const PropertyCallbackInfo& info); typedef void (*NamedPropertyEnumeratorCallback)( const PropertyCallbackInfo& info); + +typedef void (*GenericNamedPropertyGetterCallback)( + Local property, const PropertyCallbackInfo& info); +typedef void (*GenericNamedPropertySetterCallback)( + Local property, Local value, + const PropertyCallbackInfo& info); +typedef void (*GenericNamedPropertyQueryCallback)( + Local property, const PropertyCallbackInfo& info); +typedef void (*GenericNamedPropertyDeleterCallback)( + Local property, const PropertyCallbackInfo& info); +typedef void (*GenericNamedPropertyEnumeratorCallback)( + const PropertyCallbackInfo& info); + typedef void (*IndexedPropertyGetterCallback)( uint32_t index, const PropertyCallbackInfo& info); typedef void (*IndexedPropertySetterCallback)( @@ -168,6 +197,7 @@ typedef void (*IndexedPropertyDeleterCallback)( uint32_t index, const PropertyCallbackInfo& info); typedef void (*IndexedPropertyEnumeratorCallback)( const PropertyCallbackInfo& info); + typedef bool (*EntropySource)(unsigned char* buffer, size_t length); typedef void (*FatalErrorCallback)(const char *location, const char *message); typedef void (*JitCodeEventHandler)(const JitCodeEvent *event); @@ -220,8 +250,43 @@ class EXPORT Local : public Handle { static Local New(Handle that); static Local New(Isolate* isolate, Handle that); static Local New(Isolate* isolate, const Persistent& that); + private: + template friend class MaybeLocal; }; +template +class MaybeLocal { + public: + MaybeLocal() : val_(nullptr) {} + template + MaybeLocal(Local that) + : val_(reinterpret_cast(*that)) { + TYPE_CHECK(T, S); + } + + bool IsEmpty() const { return val_ == nullptr; } + + template + bool ToLocal(Local* out) const { + out->_ref = IsEmpty() ? nullptr : this->val_; + return !IsEmpty(); + } + + Local ToLocalChecked() { + if (val_ == nullptr) { + V8::ToLocalEmpty(); + } + return Local(val_); + } + + template + Local FromMaybe(Local default_value) const { + return IsEmpty() ? default_value : Local(val_); + } + + private: + T* val_; +}; template class WeakCallbackData { @@ -395,6 +460,8 @@ class EXPORT EscapableHandleScope : public HandleScope { Local Escape(Handle value) { return Close(value); } }; +typedef HandleScope SealHandleScope; + class EXPORT Data { public: }; @@ -469,10 +536,52 @@ class EXPORT Message { int GetLineNumber() const; int GetStartColumn() const; int GetEndColumn() const; + + static const int kNoLineNumberInfo = 0; + static const int kNoColumnInfo = 0; + static const int kNoScriptIdInfo = 0; }; typedef void (*MessageCallback)(Handle message, Handle error); +class EXPORT StackTrace { + public: + enum StackTraceOptions { + kLineNumber = 1, + kColumnOffset = 1 << 1 | kLineNumber, + kScriptName = 1 << 2, + kFunctionName = 1 << 3, + kIsEval = 1 << 4, + kIsConstructor = 1 << 5, + kScriptNameOrSourceURL = 1 << 6, + kScriptId = 1 << 7, + kExposeFramesAcrossSecurityOrigins = 1 << 8, + kOverview = kLineNumber | kColumnOffset | kScriptName | kFunctionName, + kDetailed = kOverview | kIsEval | kIsConstructor | kScriptNameOrSourceURL + }; + + Local GetFrame(uint32_t index) const; + int GetFrameCount() const; + Local AsArray(); + + static Local CurrentStackTrace( + Isolate* isolate, + int frame_limit, + StackTraceOptions options = kOverview); +}; + +class EXPORT StackFrame { + public: + int GetLineNumber() const; + int GetColumn() const; + int GetScriptId() const; + Local GetScriptName() const; + Local GetScriptNameOrSourceURL() const; + Local GetFunctionName() const; + bool IsEval() const; + bool IsConstructor() const; +}; + class EXPORT Value : public Data { public: bool IsUndefined() const; @@ -494,14 +603,16 @@ class EXPORT Value : public Data { bool IsNativeError() const; bool IsRegExp() const; bool IsExternal() const; + bool IsArrayBuffer() const; bool IsTypedArray() const; - Local ToBoolean() const; - Local ToNumber() const; - Local ToString() const; - Local ToObject() const; - Local ToInteger() const; - Local ToUint32() const; - Local ToInt32() const; + bool IsUint8Array() const; + Local ToBoolean(Isolate* isolate = nullptr) const; + Local ToNumber(Isolate* isolate = nullptr) const; + Local ToString(Isolate* isolate = nullptr) const; + Local ToObject(Isolate* isolate = nullptr) const; + Local ToInteger(Isolate* isolate = nullptr) const; + Local ToUint32(Isolate* isolate = nullptr) const; + Local ToInt32(Isolate* isolate = nullptr) const; bool BooleanValue() const; double NumberValue() const; int64_t IntegerValue() const; @@ -526,7 +637,15 @@ class EXPORT Boolean : public Primitive { static Handle New(Isolate* isolate, bool value); }; -class EXPORT String : public Primitive { +class EXPORT Name : public Primitive { + public: + int GetIdentityHash(); + static Name* Cast(v8::Value* obj); + private: + static void CheckCast(v8::Value* obj); +}; + +class EXPORT String : public Name { public: class EXPORT AsciiValue { public: @@ -543,9 +662,9 @@ class EXPORT String : public Primitive { size_t _length; }; - class EXPORT ExternalAsciiStringResource { + class EXPORT ExternalOneByteStringResource { public: - virtual ~ExternalAsciiStringResource() {} + virtual ~ExternalOneByteStringResource() {} virtual const char *data() const = 0; virtual size_t length() const = 0; }; @@ -600,7 +719,9 @@ class EXPORT String : public Primitive { int Length() const; int Utf8Length() const; - bool inline MayContainNonAscii() const { return true; } + bool IsOneByte() const { return false; } + bool ContainsOnlyOneByte() const { return false; } + int Write( uint16_t *buffer, int start = 0, @@ -634,12 +755,12 @@ class EXPORT String : public Primitive { static Local NewExternal( Isolate* isolate, ExternalStringResource* resource); static Local NewExternal( - Isolate* isolate, ExternalAsciiStringResource *resource); + Isolate* isolate, ExternalOneByteStringResource *resource); bool IsExternal() const { return false; } - bool IsExternalAscii() const { return false; } + bool IsExternalOneByte() const { return false; } ExternalStringResource* GetExternalStringResource() const { return NULL; } - const ExternalAsciiStringResource* GetExternalAsciiStringResource() const { + const ExternalOneByteStringResource* GetExternalOneByteStringResource() const{ return NULL; } @@ -696,6 +817,8 @@ class EXPORT Object : public Value { public: bool Set( Handle key, Handle value, PropertyAttribute attribs = None); + Maybe Set(Local context, + Local key, Local value); bool Set(uint32_t index, Handle value); bool ForceSet( Handle key, Handle value, PropertyAttribute attribs = None); @@ -703,6 +826,7 @@ class EXPORT Object : public Value { Local Get(uint32_t index); bool Has(Handle key); bool Delete(Handle key); + Maybe Delete(Local context, Local key); bool Delete(uint32_t index); bool SetAccessor( Handle name, @@ -713,6 +837,7 @@ class EXPORT Object : public Value { PropertyAttribute attribute = None); Local GetPrototype(); bool SetPrototype(Handle prototype); + Maybe SetPrototype(Local context, Local prototype); Local GetConstructor(); Local GetPropertyNames(); Local GetOwnPropertyNames(); @@ -733,7 +858,11 @@ class EXPORT Object : public Value { Local Clone(); Local CreationContext(); Local GetRealNamedProperty(Handle key); - + MaybeLocal GetRealNamedProperty(Local context, + Local key); + Maybe GetRealNamedPropertyAttributes( + Local context, Local key); + Isolate* GetIsolate(); static Local New(Isolate* isolate = nullptr); static Object *Cast(Value *obj); @@ -768,18 +897,6 @@ class EXPORT Array : public Object { static Array *Cast(Value *obj); }; - -class EXPORT ArrayBuffer : public Object { - public: - class EXPORT Allocator { - public: - virtual ~Allocator() {} - virtual void* Allocate(size_t length) = 0; - virtual void* AllocateUninitialized(size_t length) = 0; - virtual void Free(void* data, size_t length) = 0; - }; -}; - class EXPORT BooleanObject : public Object { public: static Local New(bool value); @@ -871,11 +988,11 @@ class FunctionCallbackInfo { return (i >= 0 && i < _length) ? Local(_args[i]) : Local(static_cast(*Undefined())); } + Local Callee() const { return _callee; } Local This() const { return _thisPointer; } Local Holder() const { return _holder; } - Local Callee() const { return _callee; } bool IsConstructCall() const { return _isConstructorCall; } - // V8_INLINE Local Data() const; + Local Data() const { return _data; } Isolate* GetIsolate() const { return Isolate::GetCurrent(); } ReturnValue GetReturnValue() const { return ReturnValue( @@ -888,15 +1005,17 @@ class FunctionCallbackInfo { Local _this, Local holder, bool isConstructorCall, + Local data, Local callee) : _args(args), _length(length), _thisPointer(_this), _holder(holder), _isConstructorCall(isConstructorCall), + _data(data), _callee(callee), _returnValue(static_cast(JS_INVALID_REFERENCE)), - _context(Context::GetCurrent()) { + _context(Context::GetCurrent()) { } private: @@ -904,6 +1023,7 @@ class FunctionCallbackInfo { Local _thisPointer; Local _holder; Local _callee; + Local _data; bool _isConstructorCall; Value** _args; Value* _returnValue; @@ -957,6 +1077,111 @@ class EXPORT Function : public Object { static Function *Cast(Value *obj); }; +class EXPORT Promise : public Object { + public: + class EXPORT Resolver : public Object { + public: + static Local New(Isolate* isolate); + Local GetPromise(); + void Resolve(Handle value); + void Reject(Handle value); + static Resolver* Cast(Value* obj); + private: + Resolver(); + static void CheckCast(Value* obj); + }; + + Local Chain(Handle handler); + Local Catch(Handle handler); + Local Then(Handle handler); + + bool HasHandler(); + static Promise* Cast(Value* obj); + private: + Promise(); +}; + + +enum class ArrayBufferCreationMode { kInternalized, kExternalized }; + +class EXPORT ArrayBuffer : public Object { + public: + class EXPORT Allocator { // NOLINT + public: + virtual ~Allocator() {} + virtual void* Allocate(size_t length) = 0; + virtual void* AllocateUninitialized(size_t length) = 0; + virtual void Free(void* data, size_t length) = 0; + }; + + class EXPORT Contents { // NOLINT + public: + Contents() : data_(NULL), byte_length_(0) {} + void* Data() const { return data_; } + size_t ByteLength() const { return byte_length_; } + + private: + void* data_; + size_t byte_length_; + friend class ArrayBuffer; + }; + + size_t ByteLength() const; + static Local New(Isolate* isolate, size_t byte_length); + static Local New( + Isolate* isolate, void* data, size_t byte_length, + ArrayBufferCreationMode mode = ArrayBufferCreationMode::kExternalized); + + bool IsExternal() const; + bool IsNeuterable() const; + void Neuter(); + Contents Externalize(); + Contents GetContents(); + + static ArrayBuffer* Cast(Value* obj); + private: + ArrayBuffer(); +}; + +class EXPORT ArrayBufferView : public Object { + public: + Local Buffer(); + size_t ByteOffset(); + size_t ByteLength(); + size_t CopyContents(void* dest, size_t byte_length); + bool HasBuffer() const; + + static ArrayBufferView* Cast(Value* obj); + private: + ArrayBufferView(); +}; + +class EXPORT TypedArray : public ArrayBufferView { + public: + size_t Length(); + static TypedArray* Cast(Value* obj); + private: + TypedArray(); +}; + +class EXPORT Uint8Array : public TypedArray { + public: + static Local New(Handle array_buffer, + size_t byte_offset, size_t length); + static Uint8Array* Cast(Value* obj); + private: + Uint8Array(); +}; + +class EXPORT Uint32Array : public TypedArray { + public: + static Local New(Handle array_buffer, + size_t byte_offset, size_t length); + static Uint32Array* Cast(Value* obj); + private: + Uint32Array(); +}; + enum AccessType { ACCESS_GET, ACCESS_SET, @@ -999,6 +1224,67 @@ class EXPORT FunctionTemplate : public Template { bool HasInstance(Handle object); }; +enum class PropertyHandlerFlags { + kNone = 0, + kAllCanRead = 1, + kNonMasking = 1 << 1, + kOnlyInterceptStrings = 1 << 2, +}; + +struct NamedPropertyHandlerConfiguration { + NamedPropertyHandlerConfiguration( + GenericNamedPropertyGetterCallback getter = 0, + GenericNamedPropertySetterCallback setter = 0, + GenericNamedPropertyQueryCallback query = 0, + GenericNamedPropertyDeleterCallback deleter = 0, + GenericNamedPropertyEnumeratorCallback enumerator = 0, + Handle data = Handle(), + PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) + : getter(getter), + setter(setter), + query(query), + deleter(deleter), + enumerator(enumerator), + data(data), + flags(flags) { + } + + GenericNamedPropertyGetterCallback getter; + GenericNamedPropertySetterCallback setter; + GenericNamedPropertyQueryCallback query; + GenericNamedPropertyDeleterCallback deleter; + GenericNamedPropertyEnumeratorCallback enumerator; + Handle data; + PropertyHandlerFlags flags; +}; + +struct IndexedPropertyHandlerConfiguration { + IndexedPropertyHandlerConfiguration( + IndexedPropertyGetterCallback getter = 0, + IndexedPropertySetterCallback setter = 0, + IndexedPropertyQueryCallback query = 0, + IndexedPropertyDeleterCallback deleter = 0, + IndexedPropertyEnumeratorCallback enumerator = 0, + Handle data = Handle(), + PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) + : getter(getter), + setter(setter), + query(query), + deleter(deleter), + enumerator(enumerator), + data(data), + flags(flags) { + } + + IndexedPropertyGetterCallback getter; + IndexedPropertySetterCallback setter; + IndexedPropertyQueryCallback query; + IndexedPropertyDeleterCallback deleter; + IndexedPropertyEnumeratorCallback enumerator; + Handle data; + PropertyHandlerFlags flags; +}; + class EXPORT ObjectTemplate : public Template { public: static Local New(Isolate* isolate); @@ -1025,6 +1311,7 @@ class EXPORT ObjectTemplate : public Template { NamedPropertyDeleterCallback deleter = 0, NamedPropertyEnumeratorCallback enumerator = 0, Handle data = Handle()); + void SetHandler(const NamedPropertyHandlerConfiguration& configuration); void SetIndexedPropertyHandler( IndexedPropertyGetterCallback getter, @@ -1100,6 +1387,37 @@ enum GCCallbackFlags { typedef void (*GCPrologueCallback)(GCType type, GCCallbackFlags flags); typedef void (*GCEpilogueCallback)(GCType type, GCCallbackFlags flags); +// --- Promise Reject Callback --- +enum PromiseRejectEvent { + kPromiseRejectWithNoHandler = 0, + kPromiseHandlerAddedAfterReject = 1 +}; + +class PromiseRejectMessage { + public: + PromiseRejectMessage(Handle promise, PromiseRejectEvent event, + Handle value, Handle stack_trace) + : promise_(promise), + event_(event), + value_(value), + stack_trace_(stack_trace) { + } + + Handle GetPromise() const { return promise_; } + PromiseRejectEvent GetEvent() const { return event_; } + Handle GetValue() const { return value_; } + + // DEPRECATED. Use v8::Exception::CreateMessage(GetValue())->GetStackTrace() + Handle GetStackTrace() const { return stack_trace_; } + + private: + Handle promise_; + PromiseRejectEvent event_; + Handle value_; + Handle stack_trace_; +}; + +typedef void (*PromiseRejectCallback)(PromiseRejectMessage message); class EXPORT HeapStatistics { private: @@ -1150,8 +1468,15 @@ class EXPORT Isolate { void* GetData(uint32_t slot); static uint32_t GetNumberOfDataSlots(); Local GetCurrentContext(); + void SetPromiseRejectCallback(PromiseRejectCallback callback); void RunMicrotasks(); void SetAutorunMicrotasks(bool autorun); + void SetFatalErrorHandler(FatalErrorCallback that); + void SetJitCodeEventHandler( + JitCodeEventOptions options, JitCodeEventHandler event_handler); + bool AddMessageListener( + MessageCallback that, Handle data = Handle()); + void RemoveMessageListeners(MessageCallback that); Local ThrowException(Local exception); HeapProfiler* GetHeapProfiler(); CpuProfiler* GetCpuProfiler(); @@ -1197,7 +1522,6 @@ class EXPORT JitCodeEvent { class EXPORT V8 { public: - static void SetFatalErrorHandler(FatalErrorCallback that); static void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator); static bool IsDead(); static void SetFlagsFromString(const char* str, int length); @@ -1206,17 +1530,66 @@ class EXPORT V8 { static const char *GetVersion(); static bool Initialize(); static void SetEntropySource(EntropySource source); - static void SetJitCodeEventHandler( - JitCodeEventOptions options, JitCodeEventHandler event_handler); static void TerminateExecution(Isolate* isolate); static bool IsExeuctionDisabled(Isolate* isolate = nullptr); static void CancelTerminateExecution(Isolate* isolate); static bool Dispose(); - static bool AddMessageListener( - MessageCallback that, Handle data = Handle()); - static void RemoveMessageListeners(MessageCallback that); + static void InitializePlatform(Platform* platform) {} + static void FromJustIsNothing(); + static void ToLocalEmpty(); }; +template +class Maybe { + public: + bool IsNothing() const { return !has_value; } + bool IsJust() const { return has_value; } + + // Will crash if the Maybe<> is nothing. + T FromJust() const { + if (!IsJust()) { + V8::FromJustIsNothing(); + } + return value; + } + + T FromMaybe(const T& default_value) const { + return has_value ? value : default_value; + } + + bool operator==(const Maybe& other) const { + return (IsJust() == other.IsJust()) && + (!IsJust() || FromJust() == other.FromJust()); + } + + bool operator!=(const Maybe& other) const { + return !operator==(other); + } + + private: + Maybe() : has_value(false) {} + explicit Maybe(const T& t) : has_value(true), value(t) {} + + bool has_value; + T value; + + template + friend Maybe Nothing(); + template + friend Maybe Just(const U& u); +}; + +template +inline Maybe Nothing() { + return Maybe(); +} + + +template +inline Maybe Just(const T& t) { + return Maybe(t); +} + class EXPORT TryCatch { private: void GetAndClearException(); diff --git a/deps/chakrashim/lib/chakra_shim.js b/deps/chakrashim/lib/chakra_shim.js index 0fb8834d822..91ace4cb371 100644 --- a/deps/chakrashim/lib/chakra_shim.js +++ b/deps/chakrashim/lib/chakra_shim.js @@ -59,106 +59,130 @@ this.fileName + ':' + this.lineNumber + ':' + this.columnNumber + ')'; }; - function patchErrorStack() { - function prepareStackTrace(error, stack) { - var stackString = (error.name ? error.name : 'Error') + - ': ' + error.message; - - for (var i = 0; i < stack.length; i++) { - stackString += '\n at ' + stack[i].toString(); - } + function prepareStackTrace(error, stack) { + var stackString = (error.name ? error.name : 'Error') + + ': ' + error.message; - return stackString; + for (var i = 0; i < stack.length; i++) { + stackString += '\n at ' + stack[i].toString(); } - function parseStack(stack, skipDepth) { - // remove the first line so this function won't be seen - var splittedStack = stack.split('\n'); - splittedStack.splice(0, 2); - var errstack = []; - - for (var i = skipDepth; i < splittedStack.length; i++) { - var parens = /\(/.exec(splittedStack[i]); - var funcName = splittedStack[i].substr(6, parens.index - 7); - if (funcName === 'Anonymous function') { - funcName = null; + return stackString; + } + + function parseStack(stack, skipDepth, startFunc) { + // remove the first line so this function won't be seen + var splittedStack = stack.split('\n'); + splittedStack.splice(0, 2); + var errstack = []; + + var startName = skipDepth < 0 ? startFunc.name : undefined; + skipDepth = Math.max(0, skipDepth); + + for (var i = skipDepth; i < splittedStack.length; i++) { + var parens = /\(/.exec(splittedStack[i]); + var funcName = splittedStack[i].substr(6, parens.index - 7); + + if (startName) { + if (funcName === startName) { + startName = undefined; } + continue; + } + if (funcName === 'Anonymous function') { + funcName = null; + } - var location = splittedStack[i].substr(parens.index + 1, - splittedStack[i].length - parens.index - 2); + var location = splittedStack[i].substr(parens.index + 1, + splittedStack[i].length - parens.index - 2); - var fileName = location; - var lineNumber = 0; - var columnNumber = 0; + var fileName = location; + var lineNumber = 0; + var columnNumber = 0; - var colonPattern = /:[0-9]+/g; - var firstColon = colonPattern.exec(location); - if (firstColon) { - fileName = location.substr(0, firstColon.index); + var colonPattern = /:[0-9]+/g; + var firstColon = colonPattern.exec(location); + if (firstColon) { + fileName = location.substr(0, firstColon.index); - var secondColon = colonPattern.exec(location); - if (secondColon) { - lineNumber = parseInt(location.substr(firstColon.index + 1, - secondColon.index - firstColon.index - 1), 10); - columnNumber = parseInt(location.substr(secondColon.index + 1, - location.length - secondColon.index), 10); - } + var secondColon = colonPattern.exec(location); + if (secondColon) { + lineNumber = parseInt(location.substr(firstColon.index + 1, + secondColon.index - firstColon.index - 1), 10); + columnNumber = parseInt(location.substr(secondColon.index + 1, + location.length - secondColon.index), 10); } - errstack.push( - new StackFrame(funcName, fileName, lineNumber, columnNumber)); } - return errstack; + errstack.push( + new StackFrame(funcName, fileName, lineNumber, columnNumber)); } + return errstack; + } - function findFuncDepth(func) { - try { - var curr = Error.captureStackTrace.caller; - var limit = Error.stackTraceLimit; - var skipDepth = 0; - while (curr) { - skipDepth++; - if (curr === func) { - return skipDepth; - } - if (skipDepth > limit) { - return 0; - } - curr = curr.caller; + function findFuncDepth(func) { + try { + var curr = captureStackTrace.caller; + var limit = Error.stackTraceLimit; + var skipDepth = 0; + while (curr) { + skipDepth++; + if (curr === func) { + return skipDepth; } - } catch (e) { - // Strict mode may throw on .caller + if (skipDepth > limit) { + return 0; + } + curr = curr.caller; } + } catch (e) { + // Strict mode may throw on .caller. Will try to match by function name. + return -1; + } - return 0; + return 0; + } + + function captureStackTrace(err, func) { + var currentStack; + try { throw new Error; } catch (e) { currentStack = e.stack; } + var isPrepared = false; + var skipDepth = func ? findFuncDepth(func) : 0; + + var currentStackTrace; + function ensureStackTrace() { + if (!currentStackTrace) { + currentStackTrace = parseStack(currentStack, skipDepth, func); + } + return currentStackTrace; } - Error.captureStackTrace = function(err, func) { - var currentStack; - try { throw new Error; } catch (e) { currentStack = e.stack; } - var isPrepared = false; - var skipDepth = func ? findFuncDepth(func) : 0; - Object_defineProperty(err, 'stack', { - get: function() { - if (isPrepared) { - return currentStack; - } - var errstack = parseStack(currentStack, skipDepth); - if (Error.prepareStackTrace) { - currentStack = Error.prepareStackTrace(err, errstack); - } else { - currentStack = prepareStackTrace(err, errstack); - } - isPrepared = true; + Object_defineProperty(err, 'stack', { + get: function () { + if (isPrepared) { return currentStack; - }, - set: function(value) { - currentStack = value; - isPrepared = true; - }, - configurable: true, - enumerable: false - }); - }; + } + var errstack = ensureStackTrace(); + if (Error.prepareStackTrace) { + currentStack = Error.prepareStackTrace(err, errstack); + } else { + currentStack = prepareStackTrace(err, errstack); + } + isPrepared = true; + return currentStack; + }, + set: function (value) { + currentStack = value; + isPrepared = true; + }, + configurable: true, + enumerable: false + }); + + return ensureStackTrace; + }; + + function patchErrorStack() { + Error.captureStackTrace = captureStackTrace; } function cloneObject(source, target) { @@ -371,6 +395,10 @@ return arr; })(); + + utils.getStackTrace = function () { + return captureStackTrace({}, utils.getStackTrace)(); + }; } // patch console diff --git a/deps/chakrashim/src/jsrtcachedpropertyidref.inc b/deps/chakrashim/src/jsrtcachedpropertyidref.inc index 377c1e44faa..d6feb47f912 100644 --- a/deps/chakrashim/src/jsrtcachedpropertyidref.inc +++ b/deps/chakrashim/src/jsrtcachedpropertyidref.inc @@ -50,6 +50,7 @@ DEF(createEnumerationIterator) DEF(createPropertyDescriptorsEnumerationIterator) DEF(getNamedOwnKeys) DEF(getIndexedOwnKeys) +DEF(getStackTrace) DEF(concat) DEF(createTargetFunction) DEF(forEachNonConfigurableProperty) @@ -58,5 +59,8 @@ DEF(slice) DEF(testFunctionType) DEF(throwAccessorErrorFunctions) DEF(toString) +DEF(buffer) +DEF(byteOffset) +DEF(byteLength) #undef DEF diff --git a/deps/chakrashim/src/jsrtcontextcachedobj.inc b/deps/chakrashim/src/jsrtcontextcachedobj.inc index 0a48474e979..edfe068ad11 100644 --- a/deps/chakrashim/src/jsrtcontextcachedobj.inc +++ b/deps/chakrashim/src/jsrtcontextcachedobj.inc @@ -36,6 +36,9 @@ DEFTYPE(Object) DEFTYPE(Proxy) DEFTYPE(RegExp) DEFTYPE(String) +DEFTYPE(Uint8Array) +DEFTYPE(Uint32Array) + // These prototype functions will be cached/shimmed DEFMETHOD(ArrayBuffer, toString) diff --git a/deps/chakrashim/src/jsrtcontextshim.cc b/deps/chakrashim/src/jsrtcontextshim.cc index e26ebf22752..b5a41829d77 100644 --- a/deps/chakrashim/src/jsrtcontextshim.cc +++ b/deps/chakrashim/src/jsrtcontextshim.cc @@ -73,6 +73,7 @@ ContextShim::ContextShim(IsolateShim * isolateShim, JS_INVALID_REFERENCE), getNamedOwnKeysFunction(JS_INVALID_REFERENCE), getIndexedOwnKeysFunction(JS_INVALID_REFERENCE), + getStackTraceFunction(JS_INVALID_REFERENCE), forEachNonConfigurablePropertyFunction(JS_INVALID_REFERENCE), testFunctionTypeFunction(JS_INVALID_REFERENCE), createTargetFunction(JS_INVALID_REFERENCE) { @@ -630,6 +631,10 @@ JsValueRef ContextShim::GetProxyConstructor() { return globalConstructor[GlobalType::Proxy]; } +JsValueRef ContextShim::GetGlobalType(GlobalType index) { + return globalConstructor[index]; +} + JsValueRef ContextShim::GetGetOwnPropertyDescriptorFunction() { return getOwnPropertyDescriptorFunction; } @@ -723,6 +728,11 @@ JsValueRef ContextShim::GetGetIndexedOwnKeysFunction() { &getIndexedOwnKeysFunction); } +JsValueRef ContextShim::GetGetStackTraceFunction() { + return GetCachedShimFunction(CachedPropertyIdRef::getStackTrace, + &getStackTraceFunction); +} + void ContextShim::EnsureThrowAccessorErrorFunctions() { if (throwAccessorErrorFunctions[0] == JS_INVALID_REFERENCE) { JsValueRef arr = JS_INVALID_REFERENCE; diff --git a/deps/chakrashim/src/jsrtcontextshim.h b/deps/chakrashim/src/jsrtcontextshim.h index 7bcbba2d688..7e4957ba911 100644 --- a/deps/chakrashim/src/jsrtcontextshim.h +++ b/deps/chakrashim/src/jsrtcontextshim.h @@ -73,6 +73,7 @@ class ContextShim { JsValueRef GetDateConstructor(); JsValueRef GetRegExpConstructor(); JsValueRef GetProxyConstructor(); + JsValueRef GetGlobalType(GlobalType index); JsValueRef GetGetOwnPropertyDescriptorFunction(); JsValueRef GetStringConcatFunction(); JsValueRef GetGlobalPrototypeFunction(GlobalPrototypeFunction index); @@ -90,6 +91,7 @@ class ContextShim { JsValueRef GetCreatePropertyDescriptorsEnumerationIteratorFunction(); JsValueRef GetGetNamedOwnKeysFunction(); JsValueRef GetGetIndexedOwnKeysFunction(); + JsValueRef GetGetStackTraceFunction(); void EnsureThrowAccessorErrorFunctions(); bool FindThrowAccessorErrorFunction(JsValueRef func, int* index); @@ -182,6 +184,7 @@ class ContextShim { JsValueRef createPropertyDescriptorsEnumerationIteratorFunction; JsValueRef getNamedOwnKeysFunction; JsValueRef getIndexedOwnKeysFunction; + JsValueRef getStackTraceFunction; static const int THROWACCESSORERRORFUNCTIONS = 4; JsValueRef throwAccessorErrorFunctions[THROWACCESSORERRORFUNCTIONS]; diff --git a/deps/chakrashim/src/jsrtutils.cc b/deps/chakrashim/src/jsrtutils.cc index 9c33844e818..6a44556597c 100644 --- a/deps/chakrashim/src/jsrtutils.cc +++ b/deps/chakrashim/src/jsrtutils.cc @@ -67,6 +67,23 @@ JsErrorCode GetProperty(_In_ JsValueRef ref, return error; } +JsErrorCode GetProperty(_In_ JsValueRef ref, + _In_ JsPropertyIdRef propId, + _Out_ int *intValue) { + JsValueRef value; + JsErrorCode error = JsGetProperty(ref, propId, &value); + if (error != JsNoError) { + return error; + } + + error = JsConvertValueToNumber(value, &value); + if (error != JsNoError) { + return error; + } + + return JsNumberToInt(value, intValue); +} + JsErrorCode SetProperty(_In_ JsValueRef ref, _In_ const wchar_t* propName, _In_ JsValueRef propValue) { @@ -166,6 +183,31 @@ JsErrorCode CallProperty( return CallProperty(ref, idRef, arguments, argumentCount, result); } +JsErrorCode CallGetter( + _In_ JsValueRef ref, + _In_ const wchar_t *propertyName, + _Out_ JsValueRef* result) { + return CallProperty(ref, propertyName, nullptr, 0, result); +} + +JsErrorCode CallGetter( + _In_ JsValueRef ref, + _In_ const wchar_t *propertyName, + _Out_ int* result) { + JsValueRef value; + JsErrorCode error = CallGetter(ref, propertyName, &value); + if (error != JsNoError) { + return error; + } + + error = JsConvertValueToNumber(value, &value); + if (error != JsNoError) { + return error; + } + + return JsNumberToInt(value, result); +} + JsErrorCode GetPropertyOfGlobal(_In_ const wchar_t *propertyName, _Out_ JsValueRef *ref) { JsErrorCode error = JsNoError; @@ -965,30 +1007,9 @@ JsErrorCode HasIndexedProperty(_In_ JsValueRef object, return error; } -JsErrorCode IsOfGlobalType( - _In_ JsValueRef objectRef, - _In_ const wchar_t *typeName, - _Out_ bool *result - ) { - // the JS equivlant to what we do is: this.constructor.prototype == - // object.prototype - JsErrorCode error; - JsValueRef valRef; - - error = GetPropertyOfGlobal(typeName, &valRef); - if (error != JsNoError) { - return error; - } - - error = InstanceOf(objectRef, valRef, result); - - return error; -} - -bool IsOfGlobalType(_In_ JsValueRef objectRef, - _In_ const wchar_t *typeName) { +bool IsOfGlobalType(_In_ JsValueRef ref, _In_ const wchar_t *typeName) { bool result; - return IsOfGlobalType(objectRef, typeName, &result) == JsNoError && result; + return InstanceOfGlobalType(ref, typeName, &result) == JsNoError && result; } JsErrorCode SetConstructorName(_In_ JsValueRef objectRef, diff --git a/deps/chakrashim/src/jsrtutils.h b/deps/chakrashim/src/jsrtutils.h index 55123f31df1..64d1ec5bdcd 100644 --- a/deps/chakrashim/src/jsrtutils.h +++ b/deps/chakrashim/src/jsrtutils.h @@ -65,6 +65,10 @@ JsErrorCode GetProperty(_In_ JsValueRef ref, _In_ const wchar_t *propertyName, _Out_ JsValueRef *result); +JsErrorCode GetProperty(_In_ JsValueRef ref, + _In_ JsPropertyIdRef propId, + _Out_ int *intValue); + JsErrorCode SetProperty(_In_ JsValueRef ref, _In_ JsValueRef propName, _In_ JsValueRef propValue); @@ -153,6 +157,15 @@ JsErrorCode CallProperty( _In_ unsigned short argumentCount, _Out_ JsValueRef *result); +JsErrorCode CallGetter( + _In_ JsValueRef ref, + _In_ const wchar_t *propertyName, + _Out_ JsValueRef* result); + +JsErrorCode CallGetter( + _In_ JsValueRef ref, + _In_ const wchar_t *propertyName, + _Out_ int* result); JsErrorCode GetPropertyOfGlobal(_In_ const wchar_t *propertyName, _Out_ JsValueRef *ref); @@ -304,10 +317,6 @@ JsErrorCode GetIndexedProperty(_In_ JsValueRef object, _In_ int index, _In_ JsValueRef *value); -JsErrorCode IsOfGlobalType(_In_ JsValueRef objectRef, - _In_ const wchar_t *typeName, - _Out_ bool *result); - bool IsOfGlobalType(_In_ JsValueRef objectRef, _In_ const wchar_t *typeName); @@ -336,7 +345,7 @@ class JsArguments { JsValueRef* _args; public: - JsArguments(int count) { + explicit JsArguments(int count) { _args = count <= STATIC_COUNT ? _local : new JsValueRef[count]; } diff --git a/deps/chakrashim/src/v8arraybuffer.cc b/deps/chakrashim/src/v8arraybuffer.cc new file mode 100644 index 00000000000..07aa5a9a0e8 --- /dev/null +++ b/deps/chakrashim/src/v8arraybuffer.cc @@ -0,0 +1,77 @@ +// Copyright Microsoft. All rights reserved. +// +// 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 "v8chakra.h" +#include "jsrtutils.h" + +namespace v8 { + +using jsrt::IsolateShim; +using jsrt::CachedPropertyIdRef; + +Local ArrayBuffer::New(Isolate* isolate, size_t byte_length) { + return New(isolate, nullptr, byte_length); +} + +Local ArrayBuffer::New(Isolate* isolate, + void* data, size_t byte_length, + ArrayBufferCreationMode mode) { + JsValueRef result; + if (JsCreateArrayBuffer(data, + static_cast(byte_length), + &result) != JsNoError) { + return Local(); + } + return static_cast(result); +} + +size_t ArrayBuffer::ByteLength() const { + int result; + if (jsrt::GetProperty(const_cast(this), + IsolateShim::GetCurrent()->GetCachedPropertyIdRef( + CachedPropertyIdRef::byteLength), + &result) != JsNoError) { + return 0; + } + return result; +} + +void ArrayBuffer::Neuter() { + // Chakra: not supported, ignore +} + +ArrayBuffer::Contents ArrayBuffer::GetContents() { + BYTE* buffer; + unsigned int bufferLength; + if (JsGetArrayBufferStorage(this, &buffer, &bufferLength) != JsNoError) { + return Contents(); + } + + Contents contents; + contents.data_ = buffer; + contents.byte_length_ = bufferLength; + return contents; +} + +ArrayBuffer* ArrayBuffer::Cast(Value* obj) { + return static_cast(obj); +} + +} // namespace v8 diff --git a/deps/chakrashim/src/v8chakra.h b/deps/chakrashim/src/v8chakra.h index b40ad866a55..09d3136d789 100644 --- a/deps/chakrashim/src/v8chakra.h +++ b/deps/chakrashim/src/v8chakra.h @@ -59,6 +59,7 @@ struct TemplateData { virtual void CreateProperties(); // Allow properties to be created lazily public: + virtual ~TemplateData() {} Object* EnsureProperties(); }; diff --git a/deps/chakrashim/src/v8debug.cc b/deps/chakrashim/src/v8debug.cc index ef85ba30f45..23aa08e96bf 100644 --- a/deps/chakrashim/src/v8debug.cc +++ b/deps/chakrashim/src/v8debug.cc @@ -25,6 +25,7 @@ namespace v8 { __declspec(thread) bool g_EnableDebug = false; +static JsContextRef g_debugContext = JS_INVALID_REFERENCE; bool Debug::EnableAgent(const char *name, int port, bool wait_for_connection) { HRESULT hr = S_OK; @@ -51,6 +52,17 @@ bool Debug::IsAgentEnabled() { return g_EnableDebug; } +Local Debug::GetDebugContext() { + if (g_debugContext == JS_INVALID_REFERENCE) { + Isolate* isolate = Isolate::GetCurrent(); + HandleScope scope(isolate); + g_debugContext = *Context::New(isolate); + JsAddRef(g_debugContext, nullptr); + } + + return static_cast(g_debugContext); +} + void Debug::Dispose() { if (g_EnableDebug) { CoUninitialize(); diff --git a/deps/chakrashim/src/v8functiontemplate.cc b/deps/chakrashim/src/v8functiontemplate.cc index 92e0f53a213..52c6961ed93 100644 --- a/deps/chakrashim/src/v8functiontemplate.cc +++ b/deps/chakrashim/src/v8functiontemplate.cc @@ -129,6 +129,7 @@ struct FunctionCallbackData { thisPointer, holder, isConstructCall, + callbackData->data, Local::New(static_cast(callee))); callbackData->callback(args); diff --git a/deps/chakrashim/src/v8isolate.cc b/deps/chakrashim/src/v8isolate.cc index bf82fe8f2f5..8ba48091b8b 100644 --- a/deps/chakrashim/src/v8isolate.cc +++ b/deps/chakrashim/src/v8isolate.cc @@ -77,6 +77,25 @@ Local Isolate::GetCurrentContext() { return Context::GetCurrent(); } +void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) { + // CHAKRA does not support this explicit callback +} + +bool Isolate::AddMessageListener(MessageCallback that, Handle data) { + // Ignore data parameter. Node doesn't use it. + return jsrt::IsolateShim::FromIsolate(this)->AddMessageListener(that); +} + +void Isolate::RemoveMessageListeners(MessageCallback that) { + jsrt::IsolateShim::FromIsolate(this)->RemoveMessageListeners(that); +} + +void Isolate::SetJitCodeEventHandler(JitCodeEventOptions options, + JitCodeEventHandler event_handler) { + // CHAKRA-TODO: This is for ETW events, we don't have equivalent but might not + // need it because we do our own ETW tracing. +} + void Isolate::RunMicrotasks() { } diff --git a/deps/chakrashim/src/v8object.cc b/deps/chakrashim/src/v8object.cc index 7d646111307..84c1a08f76b 100644 --- a/deps/chakrashim/src/v8object.cc +++ b/deps/chakrashim/src/v8object.cc @@ -63,6 +63,16 @@ struct InternalFieldDataStruct { int size; }; +Maybe Object::Set(Local context, + Local key, Local value) { + TryCatch try_catch; + bool result = Set(key, value); + if (try_catch.HasCaught()) { + return Nothing(); + } + return Just(true); +} + bool Object::Set( Handle key, Handle value, PropertyAttribute attribs) { return Set(key, value, attribs, /*force*/false); @@ -207,6 +217,15 @@ bool Object::Delete(Handle key) { return result; } +Maybe Object::Delete(Local context, Local key) { + TryCatch try_catch; + Delete(key); + if (try_catch.HasCaught()) { + return Nothing(); + } + return Just(true); +} + bool Object::Delete(uint32_t index) { if (DeleteIndexedProperty((JsValueRef)this, index) != JsNoError) { return false; @@ -449,6 +468,16 @@ bool Object::SetPrototype(Handle prototype) { return true; } +Maybe Object::SetPrototype(Local context, + Local prototype) { + TryCatch try_catch; + SetPrototype(prototype); + if (try_catch.HasCaught()) { + return Nothing(); + } + return Just(true); +} + Local Object::GetConstructor() { JsValueRef constructorRef; @@ -810,6 +839,27 @@ Local Object::GetRealNamedProperty(Handle key) { return this->Get(key); } +MaybeLocal Object::GetRealNamedProperty(Local context, + Local key) { + TryCatch try_catch; + Local result = GetRealNamedProperty(key); + if (try_catch.HasCaught()) { + return MaybeLocal(); + } + return result; +} + +Maybe Object::GetRealNamedPropertyAttributes( + Local context, Local key) { + // CHAKRA-TODO: This walks prototype chain skipping interceptors + return Just(PropertyAttribute::None); +} + +Isolate* Object::GetIsolate() { + // CHAKRA-TODO + return Isolate::GetCurrent(); +} + Local Object::New(Isolate* isolate) { JsValueRef newObjectRef; if (JsCreateObject(&newObjectRef) != JsNoError) { diff --git a/deps/chakrashim/src/v8objecttemplate.cc b/deps/chakrashim/src/v8objecttemplate.cc index 3401f835f5b..2793783c178 100644 --- a/deps/chakrashim/src/v8objecttemplate.cc +++ b/deps/chakrashim/src/v8objecttemplate.cc @@ -953,6 +953,17 @@ void ObjectTemplate::SetNamedPropertyHandler( objectTemplateData->namedPropertyInterceptorData = Persistent(data); } +void ObjectTemplate::SetHandler( + const NamedPropertyHandlerConfiguration& config) { + SetNamedPropertyHandler( + reinterpret_cast(config.getter), + reinterpret_cast(config.setter), + reinterpret_cast(config.query), + reinterpret_cast(config.deleter), + reinterpret_cast(config.enumerator), + config.data); +} + void ObjectTemplate::SetIndexedPropertyHandler( IndexedPropertyGetterCallback getter, IndexedPropertySetterCallback setter, diff --git a/deps/chakrashim/src/v8stacktrace.cc b/deps/chakrashim/src/v8stacktrace.cc new file mode 100644 index 00000000000..d9c7b263e05 --- /dev/null +++ b/deps/chakrashim/src/v8stacktrace.cc @@ -0,0 +1,110 @@ +// Copyright Microsoft. All rights reserved. +// +// 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 "v8chakra.h" +#include "jsrtutils.h" + +namespace v8 { + +using jsrt::IsolateShim; +using jsrt::ContextShim; + +Local StackTrace::CurrentStackTrace(Isolate* isolate, + int frame_limit, + StackTraceOptions options) { + IsolateShim* iso = IsolateShim::FromIsolate(isolate); + ContextShim* contextShim = iso->GetCurrentContextShim(); + + JsValueRef getStackTrace = contextShim->GetGetStackTraceFunction(); + JsValueRef stackTrace; + if (JsCallFunction(getStackTrace, nullptr, 0, &stackTrace) != JsNoError) { + return Local(); + } + + return static_cast(stackTrace); +} + +Local StackTrace::GetFrame(uint32_t index) const { + JsValueRef frame; + if (jsrt::GetIndexedProperty(const_cast(this), + static_cast(index), &frame) != JsNoError) { + return Local(); + } + + return static_cast(frame); +} + +int StackTrace::GetFrameCount() const { + unsigned int length; + if (jsrt::GetArrayLength(const_cast(this), + &length) != JsNoError) { + return 0; + } + + return static_cast(length); +} + +int StackFrame::GetLineNumber() const { + JsValueRef frame = const_cast(this); + int result; + if (jsrt::CallGetter(frame, L"getLineNumber", &result) != JsNoError) { + return 0; + } + return result; +} + +int StackFrame::GetColumn() const { + JsValueRef frame = const_cast(this); + int result; + if (jsrt::CallGetter(frame, L"getColumnNumber", &result) != JsNoError) { + return 0; + } + return result; +} + +int StackFrame::GetScriptId() const { + // CHAKRA-TODO + return 0; +} + +Local StackFrame::GetScriptName() const { + JsValueRef frame = const_cast(this); + JsValueRef result; + if (jsrt::CallGetter(frame, L"getFileName", &result) != JsNoError) { + return Local(); + } + return static_cast(result); +} + +Local StackFrame::GetFunctionName() const { + JsValueRef frame = const_cast(this); + JsValueRef result; + if (jsrt::CallGetter(frame, L"getFunctionName", &result) != JsNoError) { + return Local(); + } + return static_cast(result); +} + +bool StackFrame::IsEval() const { + // CHAKRA-TODO + return false; +} + +} // namespace v8 diff --git a/deps/chakrashim/src/v8string.cc b/deps/chakrashim/src/v8string.cc index 55afd7b0596..ac8e40dc37f 100644 --- a/deps/chakrashim/src/v8string.cc +++ b/deps/chakrashim/src/v8string.cc @@ -366,7 +366,7 @@ Local String::NewExternal( } Local String::NewExternal( - Isolate* isolate, ExternalAsciiStringResource *resource) { + Isolate* isolate, ExternalOneByteStringResource *resource) { if (resource->data() != nullptr) { auto newStr = New( jsrt::StringConvert::ToWChar, diff --git a/deps/chakrashim/src/v8typedarray.cc b/deps/chakrashim/src/v8typedarray.cc new file mode 100644 index 00000000000..555f191710d --- /dev/null +++ b/deps/chakrashim/src/v8typedarray.cc @@ -0,0 +1,113 @@ +// Copyright Microsoft. All rights reserved. +// +// 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 "v8chakra.h" +#include "jsrtutils.h" + +namespace v8 { + +using jsrt::IsolateShim; +using jsrt::ContextShim; +using jsrt::CachedPropertyIdRef; + +Local ArrayBufferView::Buffer() { + JsValueRef result; + if (JsGetProperty(this, + IsolateShim::GetCurrent()->GetCachedPropertyIdRef( + CachedPropertyIdRef::buffer), + &result) != JsNoError) { + return Local(); + } + return static_cast(result); +} + +size_t ArrayBufferView::ByteOffset() { + int result; + if (jsrt::GetProperty(this, + IsolateShim::GetCurrent()->GetCachedPropertyIdRef( + CachedPropertyIdRef::byteOffset), + &result) != JsNoError) { + return 0; + } + return result; +} + +size_t ArrayBufferView::ByteLength() { + int result; + if (jsrt::GetProperty(this, + IsolateShim::GetCurrent()->GetCachedPropertyIdRef( + CachedPropertyIdRef::byteLength), + &result) != JsNoError) { + return 0; + } + return result; +} + +static JsErrorCode NewTypedArray(ContextShim::GlobalType constructorIndex, + Handle array_buffer, + size_t byte_offset, size_t length, + JsValueRef* result) { + Isolate* iso = Isolate::GetCurrent(); + HandleScope handleScope(iso); + + ContextShim* contextShim = ContextShim::GetCurrent(); + JsValueRef constructor = contextShim->GetGlobalType(constructorIndex); + JsValueRef args[4] = { + contextShim->GetUndefined(), + *array_buffer, + *Uint32::NewFromUnsigned(iso, static_cast(byte_offset)), + *Uint32::NewFromUnsigned(iso, static_cast(length)), + }; + return JsConstructObject(constructor, args, _countof(args), result); +} + +template +Local NewTypedArray(ContextShim::GlobalType constructorIndex, + Handle array_buffer, + size_t byte_offset, size_t length) { + JsValueRef result; + if (NewTypedArray(constructorIndex, array_buffer, byte_offset, length, + &result) != JsNoError) { + return Local(); + } + return static_cast(result); +} + +Local Uint8Array::New(Handle array_buffer, + size_t byte_offset, size_t length) { + return NewTypedArray(ContextShim::GlobalType::Uint8Array, + array_buffer, byte_offset, length); +} + +Uint8Array* Uint8Array::Cast(Value* obj) { + return static_cast(obj); +} + +Local Uint32Array::New(Handle array_buffer, + size_t byte_offset, size_t length) { + return NewTypedArray(ContextShim::GlobalType::Uint32Array, + array_buffer, byte_offset, length); +} + +Uint32Array* Uint32Array::Cast(Value* obj) { + return static_cast(obj); +} + +} // namespace v8 diff --git a/deps/chakrashim/src/v8v8.cc b/deps/chakrashim/src/v8v8.cc index 8c2c9a63ca2..63705853a82 100644 --- a/deps/chakrashim/src/v8v8.cc +++ b/deps/chakrashim/src/v8v8.cc @@ -62,7 +62,7 @@ const char *V8::GetVersion() { return versionStr; } -void V8::SetFatalErrorHandler(FatalErrorCallback that) { +void Isolate::SetFatalErrorHandler(FatalErrorCallback that) { // CONSIDER: Ignoring for now, since we don't have an equivalent concept. } @@ -130,22 +130,6 @@ bool V8::Dispose() { return true; } -bool V8::AddMessageListener(MessageCallback that, Handle data) { - // Ignore data parameter. Node doesn't use it. - return jsrt::IsolateShim::GetCurrent()->AddMessageListener(that); -} - - -void V8::RemoveMessageListeners(MessageCallback that) { - jsrt::IsolateShim::GetCurrent()->RemoveMessageListeners(that); -} - -void V8::SetJitCodeEventHandler( - JitCodeEventOptions options, JitCodeEventHandler event_handler) { - // CHAKRA-TODO: This is for ETW events, we don't have equivalent but might not - // need it because we do our own ETW tracing. -} - void V8::TerminateExecution(Isolate* isolate) { jsrt::IsolateShim::FromIsolate(isolate)->DisableExecution(); } @@ -158,4 +142,12 @@ void V8::CancelTerminateExecution(Isolate* isolate) { jsrt::IsolateShim::FromIsolate(isolate)->EnableExecution(); } +void V8::FromJustIsNothing() { + jsrt::Fatal("v8::FromJust: %s", "Maybe value is Nothing."); +} + +void V8::ToLocalEmpty() { + jsrt::Fatal("v8::ToLocalChecked: %s", "Empty MaybeLocal."); +} + } // namespace v8 diff --git a/deps/chakrashim/src/v8value.cc b/deps/chakrashim/src/v8value.cc index f56869dc108..e7dee2bfca3 100644 --- a/deps/chakrashim/src/v8value.cc +++ b/deps/chakrashim/src/v8value.cc @@ -25,24 +25,24 @@ namespace v8 { -using jsrt::IsOfGlobalType; - -bool Value::IsUndefined() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { +static bool IsOfType(const Value* ref, JsValueType type) { + JsValueType valueType; + if (JsGetValueType(const_cast(ref), &valueType) != JsNoError) { return false; } + return valueType == type; +} - return (type == JsValueType::JsUndefined); +static bool IsOfType(const Value* ref, const wchar_t* type) { + return jsrt::IsOfGlobalType(const_cast(ref), type); } -bool Value::IsNull() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } +bool Value::IsUndefined() const { + return IsOfType(this, JsValueType::JsUndefined); +} - return (type == JsValueType::JsNull); +bool Value::IsNull() const { + return IsOfType(this, JsValueType::JsNull); } bool Value::IsTrue() const { @@ -64,29 +64,15 @@ bool Value::IsFalse() const { } bool Value::IsString() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } - return (type == JsValueType::JsString); + return IsOfType(this, JsValueType::JsString); } bool Value::IsFunction() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } - - return (type == JsValueType::JsFunction); + return IsOfType(this, JsValueType::JsFunction); } bool Value::IsArray() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } - - return (type == JsValueType::JsArray); + return IsOfType(this, JsValueType::JsArray); } bool Value::IsObject() const { @@ -95,38 +81,31 @@ bool Value::IsObject() const { return false; } - return (type == JsValueType::JsObject || type == JsValueType::JsFunction || - type == JsValueType::JsError); + return type >= JsValueType::JsObject && type != JsSymbol; } bool Value::IsExternal() const { return External::IsExternal(this); } +bool Value::IsArrayBuffer() const { + return IsOfType(this, JsValueType::JsArrayBuffer); +} + bool Value::IsTypedArray() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } - return (type == JsValueType::JsTypedArray); + return IsOfType(this, JsValueType::JsTypedArray); } -bool Value::IsBoolean() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } +bool Value::IsUint8Array() const { + return IsTypedArray() && IsOfType(this, L"Uint8Array"); +} - return (type == JsValueType::JsBoolean); +bool Value::IsBoolean() const { + return IsOfType(this, JsValueType::JsBoolean); } bool Value::IsNumber() const { - JsValueType type; - if (JsGetValueType((JsValueRef)this, &type) != JsNoError) { - return false; - } - - return (type == JsValueType::JsNumber); + return IsOfType(this, JsValueType::JsNumber); } bool Value::IsInt32() const { @@ -165,46 +144,36 @@ bool Value::IsUint32() const { } bool Value::IsDate() const { - bool result; - if (IsOfGlobalType((JsValueRef)this, L"Date", &result) != JsNoError) { - return false; - } - - return result; + return IsOfType(this, L"Date"); } bool Value::IsBooleanObject() const { - return IsOfGlobalType((JsValueRef)this, L"Boolean"); + return IsOfType(this, L"Boolean"); } bool Value::IsNumberObject() const { - return IsOfGlobalType((JsValueRef)this, L"Number"); + return IsOfType(this, L"Number"); } bool Value::IsStringObject() const { - return IsOfGlobalType((JsValueRef)this, L"String"); + return IsOfType(this, L"String"); } bool Value::IsNativeError() const { - return IsOfGlobalType((JsValueRef)this, L"Error") - || IsOfGlobalType((JsValueRef)this, L"EvalError") - || IsOfGlobalType((JsValueRef)this, L"RangeError") - || IsOfGlobalType((JsValueRef)this, L"ReferenceError") - || IsOfGlobalType((JsValueRef)this, L"SyntaxError") - || IsOfGlobalType((JsValueRef)this, L"TypeError") - || IsOfGlobalType((JsValueRef)this, L"URIError"); + return IsOfType(this, L"Error") + || IsOfType(this, L"EvalError") + || IsOfType(this, L"RangeError") + || IsOfType(this, L"ReferenceError") + || IsOfType(this, L"SyntaxError") + || IsOfType(this, L"TypeError") + || IsOfType(this, L"URIError"); } bool Value::IsRegExp() const { - bool result; - if (IsOfGlobalType((JsValueRef)this, L"RegExp", &result) != JsNoError) { - return false; - } - - return result; + return IsOfType(this, L"RegExp"); } -Local Value::ToBoolean() const { +Local Value::ToBoolean(Isolate* isolate) const { JsValueRef value; if (JsConvertValueToBoolean((JsValueRef)this, &value) != JsNoError) { return Local(); @@ -213,7 +182,7 @@ Local Value::ToBoolean() const { return Local::New(static_cast(value)); } -Local Value::ToNumber() const { +Local Value::ToNumber(Isolate* isolate) const { JsValueRef value; if (JsConvertValueToNumber((JsValueRef)this, &value) != JsNoError) { return Local(); @@ -222,7 +191,7 @@ Local Value::ToNumber() const { return Local::New(static_cast(value)); } -Local Value::ToString() const { +Local Value::ToString(Isolate* isolate) const { JsValueRef value; if (JsConvertValueToString((JsValueRef)this, &value) != JsNoError) { return Local(); @@ -231,7 +200,7 @@ Local Value::ToString() const { return Local::New(static_cast(value)); } -Local Value::ToObject() const { +Local Value::ToObject(Isolate* isolate) const { JsValueRef value; if (JsConvertValueToObject((JsValueRef)this, &value) != JsNoError) { return Local(); @@ -240,7 +209,7 @@ Local Value::ToObject() const { return Local::New(static_cast(value)); } -Local Value::ToInteger() const { +Local Value::ToInteger(Isolate* isolate) const { int64_t value = this->IntegerValue(); JsValueRef integerRef; @@ -253,13 +222,13 @@ Local Value::ToInteger() const { } -Local Value::ToUint32() const { +Local Value::ToUint32(Isolate* isolate) const { Local jsValue = Integer::NewFromUnsigned(Isolate::GetCurrent(), this->Uint32Value()); return Local(static_cast(*jsValue)); } -Local Value::ToInt32() const { +Local Value::ToInt32(Isolate* isolate) const { Local jsValue = Integer::New(Isolate::GetCurrent(), this->Int32Value()); return Local(static_cast(*jsValue)); diff --git a/deps/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/msvs.py b/deps/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/msvs.py index bc0097e7d3d..c0625889a21 100644 --- a/deps/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/msvs.py +++ b/deps/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/msvs.py @@ -2673,7 +2673,7 @@ def _GetMSBuildGlobalProperties(spec, guid, gyp_file_name): properties[0].append(['WindowsSDKDesktopARMSupport', 'true']) if msvs_windows_target_platform_version: properties[0].append(['WindowsTargetPlatformVersion', \ - msvs_windows_target_platform_version]) + str(msvs_windows_target_platform_version)]) return properties diff --git a/src/string_bytes.cc b/src/string_bytes.cc index a1806e3e3a0..fb53a467374 100644 --- a/src/string_bytes.cc +++ b/src/string_bytes.cc @@ -72,8 +72,12 @@ class ExternString: public ResourceType { ExternString* h_str = new ExternString(isolate, data, length); + // CHAKRA-TODO: Revert this change. Currently chakrashim + // String::NewExternal deletes h_str immediately. Avoid accessing h_str + // after passing it to String::NewExternal. + size_t byte_length = h_str->byte_length(); Local str = String::NewExternal(isolate, h_str); - isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length()); + isolate->AdjustAmountOfExternalAllocatedMemory(byte_length); return scope.Escape(str); } diff --git a/tools/gyp/pylib/gyp/generator/msvs.py b/tools/gyp/pylib/gyp/generator/msvs.py index 9ede3c67716..4ed040ce374 100644 --- a/tools/gyp/pylib/gyp/generator/msvs.py +++ b/tools/gyp/pylib/gyp/generator/msvs.py @@ -2673,7 +2673,7 @@ def _GetMSBuildGlobalProperties(spec, guid, gyp_file_name): properties[0].append(['WindowsSDKDesktopARMSupport', 'true']) if msvs_windows_target_platform_version: properties[0].append(['WindowsTargetPlatformVersion', \ - msvs_windows_target_platform_version]) + str(msvs_windows_target_platform_version)]) return properties