@nativescript/canvas 2.0.0-alpha.1 → 2.0.0-alpha.10

package/pods/Headers/runtime/FFICall.h

@@ -0,0 +1,105 @@
+#ifndef FFICall_h
+#define FFICall_h
+
+#include <malloc/malloc.h>
+#include <map>
+#include "robin_hood.h"
+#include "Metadata.h"
+#include "DataWrapper.h"
+#include "libffi.h"
+
+namespace tns {
+
+class BaseCall {
+public:
+    BaseCall(uint8_t* buffer, size_t returnOffset = 0)
+        : buffer_(buffer),
+          returnOffset_(returnOffset) {
+    }
+
+    ~BaseCall() {
+    }
+
+    void* ResultBuffer() {
+        return this->buffer_ + this->returnOffset_;
+    }
+
+    template <typename T>
+    T& GetResult() {
+        return *static_cast<T*>(this->ResultBuffer());
+    }
+protected:
+    uint8_t* buffer_;
+    size_t returnOffset_;
+};
+
+class ParametrizedCall {
+public:
+    ParametrizedCall(ffi_cif* cif)
+        : Cif(cif),
+          ReturnOffset(0),
+          StackSize(0) {
+        unsigned int argsCount = cif->nargs;
+        this->StackSize = 0;
+
+        if (argsCount > 0) {
+            this->StackSize = malloc_good_size(sizeof(void* [argsCount]));
+        }
+
+        this->ReturnOffset = this->StackSize;
+
+        this->StackSize += malloc_good_size(std::max(cif->rtype->size, sizeof(ffi_arg)));
+
+        this->ArgValueOffsets.reserve(argsCount);
+        for (size_t i = 0; i < argsCount; i++) {
+            this->ArgValueOffsets.push_back(this->StackSize);
+            ffi_type* argType = cif->arg_types[i];
+            this->StackSize += malloc_good_size(std::max(argType->size, sizeof(ffi_arg)));
+        }
+    }
+
+    static ParametrizedCall* Get(const TypeEncoding* typeEncoding, const int initialParameterIndex, const int argsCount);
+
+    ffi_cif* Cif;
+    size_t ReturnOffset;
+    size_t StackSize;
+    std::vector<size_t> ArgValueOffsets;
+private:
+    static robin_hood::unordered_map<const TypeEncoding*, ParametrizedCall*> callsCache_;
+};
+
+class FFICall: public BaseCall {
+public:
+    FFICall(ParametrizedCall* parametrizedCall): BaseCall(nullptr) {
+        this->returnOffset_ = parametrizedCall->ReturnOffset;
+        this->buffer_ = reinterpret_cast<uint8_t*>(malloc(parametrizedCall->StackSize));
+
+        this->argsArray_ = reinterpret_cast<void**>(this->buffer_);
+        for (size_t i = 0; i < parametrizedCall->Cif->nargs; i++) {
+            this->argsArray_[i] = this->buffer_ + parametrizedCall->ArgValueOffsets[i];
+        }
+    }
+
+    ~FFICall() {
+        free(this->buffer_);
+    }
+
+    static ffi_type* GetArgumentType(const TypeEncoding* typeEncoding, bool isStructMember = false);
+    static StructInfo GetStructInfo(const StructMeta* structMeta, std::string structName = "");
+    static StructInfo GetStructInfo(size_t fieldsCount, const TypeEncoding* fieldEncoding, const String* fieldNames, std::string structName = "");
+
+    void* ArgumentBuffer(unsigned index) {
+        return this->argsArray_[index];
+    }
+
+    void** ArgsArray() {
+        return this->argsArray_;
+    }
+private:
+    static robin_hood::unordered_map<std::string, StructInfo> structInfosCache_;
+    void** argsArray_;
+};
+
+}
+
+#endif /* FFICall_h */

package/pods/Headers/runtime/FastEnumerationAdapter.h

@@ -0,0 +1,13 @@
+#ifndef FastEnumerationAdapter_h
+#define FastEnumerationAdapter_h
+
+#import <Foundation/NSEnumerator.h>
+#include "Common.h"
+
+namespace tns {
+
+NSUInteger FastEnumerationAdapter(v8::Isolate* isolate, id self, NSFastEnumerationState* state, __unsafe_unretained id buffer[], NSUInteger length, v8::Persistent<v8::Function>* poIteratorFunc);
+
+}
+
+#endif /* FastEnumerationAdapter_h */

package/pods/Headers/runtime/FunctionReference.h

@@ -0,0 +1,18 @@
+#ifndef FunctionReference_h
+#define FunctionReference_h
+
+#include "Common.h"
+
+namespace tns {
+
+class FunctionReference {
+public:
+    static void Register(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+private:
+    static v8::Local<v8::Function> GetFunctionReferenceCtorFunc(v8::Local<v8::Context> context);
+    static void FunctionReferenceConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+};
+
+}
+
+#endif /* FunctionReference_h */

package/pods/Headers/runtime/Helpers.h

@@ -0,0 +1,84 @@
+#ifndef Helpers_h
+#define Helpers_h
+
+#include <functional>
+#include <string>
+#include "Common.h"
+#include "DataWrapper.h"
+
+#ifdef __OBJC__
+#include <Foundation/Foundation.h>
+#else
+#include <CoreFoundation/CoreFoundation.h>
+extern "C" void NSLog(CFStringRef format, ...);
+#endif
+
+namespace tns {
+
+v8::Local<v8::String> ToV8String(v8::Isolate* isolate, std::string value);
+std::string ToString(v8::Isolate* isolate, const v8::Local<v8::Value>& value);
+std::u16string ToUtf16String(v8::Isolate* isolate, const v8::Local<v8::Value>& value);
+double ToNumber(v8::Isolate* isolate, const v8::Local<v8::Value>& value);
+bool ToBool(const v8::Local<v8::Value>& value);
+std::vector<uint16_t> ToVector(const std::string& value);
+
+bool Exists(const char* fullPath);
+v8::Local<v8::String> ReadModule(v8::Isolate* isolate, const std::string &filePath);
+const char* ReadText(const std::string& filePath, long& length, bool& isNew);
+std::string ReadText(const std::string& file);
+uint8_t* ReadBinary(const std::string path, long& length, bool& isNew);
+bool WriteBinary(const std::string& path, const void* data, long length);
+
+void SetPrivateValue(const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName, const v8::Local<v8::Value>& value);
+v8::Local<v8::Value> GetPrivateValue(const v8::Local<v8::Object>& obj, const v8::Local<v8::String>& propName);
+
+void SetValue(v8::Isolate* isolate, const v8::Local<v8::Object>& obj, BaseDataWrapper* value);
+BaseDataWrapper* GetValue(v8::Isolate* isolate, const v8::Local<v8::Value>& val);
+void DeleteValue(v8::Isolate* isolate, const v8::Local<v8::Value>& val);
+std::vector<v8::Local<v8::Value>> ArgsToVector(const v8::FunctionCallbackInfo<v8::Value>& info);
+
+inline bool IsString(const v8::Local<v8::Value>& value) {
+    return !value.IsEmpty() && (value->IsString() || value->IsStringObject());
+}
+
+inline bool IsNumber(const v8::Local<v8::Value>& value) {
+    return !value.IsEmpty() && (value->IsNumber() || value->IsNumberObject());
+}
+
+inline bool IsBool(const v8::Local<v8::Value>& value) {
+    return !value.IsEmpty() && (value->IsBoolean() || value->IsBooleanObject());
+}
+
+
+bool IsArrayOrArrayLike(v8::Isolate* isolate, const v8::Local<v8::Value>& value);
+void* TryGetBufferFromArrayBuffer(const v8::Local<v8::Value>& value, bool& isArrayBuffer);
+
+void ExecuteOnMainThread(std::function<void ()> func, bool async = true);
+
+void LogError(v8::Isolate* isolate, v8::TryCatch& tc);
+void LogBacktrace(int skip = 1);
+#ifndef __OBJC__
+#define Log(fmt, ...) NSLog(CFSTR(fmt), ##__VA_ARGS__)
+#else
+#define Log(...) NSLog(__VA_ARGS__)
+#endif
+
+v8::Local<v8::String> JsonStringifyObject(v8::Local<v8::Context> context, v8::Local<v8::Value> value, bool handleCircularReferences = true);
+v8::Local<v8::Function> GetSmartJSONStringifyFunction(v8::Isolate* isolate);
+
+std::string ReplaceAll(const std::string source, std::string find, std::string replacement);
+
+const std::string BuildStacktraceFrameLocationPart(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame);
+const std::string BuildStacktraceFrameMessage(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame);
+const std::string GetStackTrace(v8::Isolate* isolate);
+const std::string GetCurrentScriptUrl(v8::Isolate* isolate);
+
+bool LiveSync(v8::Isolate* isolate);
+
+void Assert(bool condition, v8::Isolate* isolate = nullptr, std::string const &reason = std::string());
+
+void StopExecutionAndLogStackTrace(v8::Isolate* isolate);
+
+}
+
+#endif /* Helpers_h */

package/pods/Headers/runtime/InlineFunctions.h

@@ -0,0 +1,16 @@
+#ifndef InlineFunctions_h
+#define InlineFunctions_h
+
+#include "Common.h"
+
+namespace tns {
+
+class InlineFunctions {
+public:
+    static void Init(v8::Local<v8::Context> context);
+    static bool IsGlobalFunction(std::string name);
+};
+
+}
+
+#endif /* InlineFunctions_h */

package/pods/Headers/runtime/Interop.h

@@ -0,0 +1,202 @@
+#ifndef Interop_h
+#define Interop_h
+
+#include <CoreFoundation/CFBase.h>
+#include <objc/message.h>
+#include "libffi.h"
+#include "Common.h"
+#include "Metadata.h"
+#include "DataWrapper.h"
+#include "FFICall.h"
+
+namespace tns {
+
+typedef void (*FFIMethodCallback)(ffi_cif* cif, void* retValue, void** argValues, void* userData);
+
+struct MethodCall {
+    MethodCall(v8::Local<v8::Context> context,
+        bool isPrimitiveFunction,
+        void* functionPointer,
+        const TypeEncoding* typeEncoding,
+        V8Args& args,
+        id target,
+        Class clazz,
+        SEL selector,
+        bool callSuper,
+        MetaType metaType,
+        bool provideErrorOutParameter,
+        bool ownsReturnedObject,
+        bool returnsUnmanaged,
+        bool isInitializer)
+        : context_(context),
+          isPrimitiveFunction_(isPrimitiveFunction),
+          functionPointer_(functionPointer),
+          typeEncoding_(typeEncoding),
+          args_(args),
+          target_(target),
+          clazz_(clazz),
+          selector_(selector),
+          callSuper_(callSuper),
+          metaType_(metaType),
+          provideErrorOutParameter_(provideErrorOutParameter),
+          ownsReturnedObject_(ownsReturnedObject),
+          returnsUnmanaged_(returnsUnmanaged),
+          isInitializer_(isInitializer) {
+    }
+
+    v8::Local<v8::Context> context_;
+    bool isPrimitiveFunction_;
+    void* functionPointer_;
+    const TypeEncoding* typeEncoding_;
+    V8Args& args_;
+    id target_;
+    Class clazz_;
+    SEL selector_;
+    bool callSuper_;
+    MetaType metaType_;
+    bool provideErrorOutParameter_;
+    bool ownsReturnedObject_;
+    bool returnsUnmanaged_;
+    bool isInitializer_;
+};
+
+struct CMethodCall: MethodCall {
+    CMethodCall(
+        v8::Local<v8::Context> context,
+        void* functionPointer,
+        const TypeEncoding* typeEncoding,
+        V8Args& args,
+        bool ownsReturnedObject,
+        bool returnsUnmanaged)
+        : MethodCall(
+            context,
+            true,
+            functionPointer,
+            typeEncoding,
+            args,
+            nil,
+            nil,
+            nil,
+            false,
+            MetaType::Undefined,
+            false,
+            ownsReturnedObject,
+            returnsUnmanaged,
+            false) {
+    }
+};
+
+struct ObjCMethodCall: public MethodCall {
+    ObjCMethodCall(
+        v8::Local<v8::Context> context,
+        const MethodMeta* meta,
+        id target,
+        Class clazz,
+        V8Args& args,
+        bool callSuper)
+        : MethodCall(
+            context,
+            false,
+            callSuper ? (void*)objc_msgSendSuper : (void*)objc_msgSend,
+            meta->encodings()->first(),
+            args,
+            target,
+            clazz,
+            meta->selector(),
+            callSuper,
+            meta->type(),
+            meta->hasErrorOutParameter() && args.Length() < meta->encodings()->count - 1,
+            meta->ownsReturnedCocoaObject(),
+            false,
+            meta->isInitializer()) {
+        }
+};
+
+class Interop {
+public:
+    static void RegisterInteropTypes(v8::Local<v8::Context> context);
+    static IMP CreateMethod(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
+    static id CallInitializer(v8::Local<v8::Context> context, const MethodMeta* methodMeta, id target, Class clazz, V8Args& args);
+    static v8::Local<v8::Value> CallFunction(ObjCMethodCall& methodCall);
+    static v8::Local<v8::Value> CallFunction(CMethodCall& methodCall);
+    static v8::Local<v8::Value> GetResult(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, BaseCall* call, bool marshalToPrimitive, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct = nullptr, bool isStructMember = false, bool ownsReturnedObject = false, bool returnsUnmanaged = false, bool isInitializer = false);
+    static void SetStructPropertyValue(v8::Local<v8::Context> context, StructWrapper* wrapper, StructField field, v8::Local<v8::Value> value);
+    static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer, std::vector<StructField> fields, v8::Local<v8::Value> inititalizer);
+    static void WriteValue(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, void* dest, v8::Local<v8::Value> arg);
+    static id ToObject(v8::Local<v8::Context> context, v8::Local<v8::Value> arg);
+    static v8::Local<v8::Value> GetPrimitiveReturnType(v8::Local<v8::Context> context, BinaryTypeEncodingType type, BaseCall* call);
+private:
+    static void ExecuteWriteValueDebugValidationsIfInDebug(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, void* dest, v8::Local<v8::Value> arg);
+    static std::pair<IMP, ffi_closure*> CreateMethodInternal(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
+    static CFTypeRef CreateBlock(const uint8_t initialParamIndex, const uint8_t argsCount, const TypeEncoding* typeEncoding, FFIMethodCallback callback, void* userData);
+    template <typename T>
+    static void SetStructValue(v8::Local<v8::Value> value, void* destBuffer, ptrdiff_t position);
+    static void InitializeStruct(v8::Local<v8::Context> context, void* destBuffer, std::vector<StructField> fields, v8::Local<v8::Value> inititalizer, ptrdiff_t& position);
+    static void RegisterInteropType(v8::Local<v8::Context> context, v8::Local<v8::Object> types, std::string name, PrimitiveDataWrapper* wrapper);
+    static void RegisterBufferFromDataFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void RegisterHandleOfFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void RegisterAllocFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void RegisterFreeFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void RegisterAdoptFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void RegisterSizeOfFunction(v8::Local<v8::Context> context, v8::Local<v8::Object> interop);
+    static void SetFFIParams(v8::Local<v8::Context> context, const TypeEncoding* typeEncoding, FFICall* call, const int argsCount, const int initialParameterIndex, V8Args& args);
+    static bool isRefTypeEqual(const TypeEncoding* typeEncoding,const char* clazz);
+    static v8::Local<v8::Array> ToArray(v8::Local<v8::Object> object);
+    static v8::Local<v8::Value> StructToValue(v8::Local<v8::Context> context, void* result, StructInfo structInfo, std::shared_ptr<v8::Persistent<v8::Value>> parentStruct);
+    static const TypeEncoding* CreateEncoding(BinaryTypeEncodingType type);
+    static v8::Local<v8::Value> HandleOf(v8::Local<v8::Context> context, v8::Local<v8::Value> value);
+    static v8::Local<v8::Value> CallFunctionInternal(MethodCall& methodCall);
+    static bool IsNumbericType(BinaryTypeEncodingType type);
+    static v8::Local<v8::Object> GetInteropType(v8::Local<v8::Context> context, BinaryTypeEncodingType type);
+    static std::vector<std::string> GetAdditionalProtocols(const TypeEncoding* typeEncoding);
+    static SEL GetSwizzledMethodSelector(SEL selector);
+
+    template <typename T>
+    static inline void SetValue(void* dest, T value) {
+        if (std::is_same<T, SEL>::value) {
+            memcpy(dest, &value, sizeof(SEL*));
+        } else {
+            *static_cast<T*>(dest) = value;
+        }
+    }
+
+    template <typename T>
+    static void SetNumericValue(void* dest, double value) {
+        if (value < std::numeric_limits<T>::lowest()) {
+            Interop::SetValue(dest, std::numeric_limits<T>::lowest());
+        } else if (value > std::numeric_limits<T>::max()) {
+            Interop::SetValue(dest, std::numeric_limits<T>::max());
+        } else {
+            Interop::SetValue(dest, (T)value);
+        }
+    }
+
+    typedef struct JSBlock {
+        typedef struct {
+            uintptr_t reserved;
+            uintptr_t size;
+            void (*copy)(struct JSBlock*, const struct JSBlock*);
+            void (*dispose)(struct JSBlock*);
+        } JSBlockDescriptor;
+
+        enum {
+            BLOCK_NEEDS_FREE = (1 << 24), // runtime
+            BLOCK_HAS_COPY_DISPOSE = (1 << 25), // compiler
+        };
+
+        void* isa;
+        volatile int32_t flags; // contains ref count
+        int32_t reserved;
+        const void* invoke;
+        JSBlockDescriptor* descriptor;
+        void* userData;
+        ffi_closure* ffiClosure;
+        
+        static JSBlockDescriptor kJSBlockDescriptor;
+    } JSBlock;
+    
+};
+
+}
+
+#endif /* Interop_h */

package/pods/Headers/runtime/KnownUnknownClassPair.h

@@ -0,0 +1,35 @@
+#ifndef KnownUnknownClassPair_h
+#define KnownUnknownClassPair_h
+
+#include <objc/objc.h>
+
+namespace tns {
+
+struct KnownUnknownClassPair {
+    Class known;
+    Class unknown;
+
+    explicit KnownUnknownClassPair(Class known = nullptr, Class unknown = nullptr)
+        : known(known)
+        , unknown(unknown) {
+    }
+
+    Class realClass() const {
+        return unknown ? unknown : known;
+    }
+
+    bool operator<(const KnownUnknownClassPair& other) const {
+        return known < other.known || (known == other.known && unknown < other.unknown);
+    }
+
+    bool operator==(const KnownUnknownClassPair& other) const {
+        return known == other.known && unknown == other.unknown;
+    }
+
+    static const KnownUnknownClassPair& EmptyValue();
+    static const KnownUnknownClassPair& DeletedValue();
+};
+
+} // namespace tns
+
+#endif /* KnownUnknownClassPair_h */