@nativescript/canvas 2.0.0-alpha.3 → 2.0.0-alpha.31

package/src-native/ios/Headers/runtime/StringHasher.h

@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2005, 2006, 2008, 2010, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef WTF_StringHasher_h
+#define WTF_StringHasher_h
+
+typedef char LChar;
+typedef wchar_t UChar;
+#define ASSERT(expression) ;
+
+namespace WTF {
+    
+    // Paul Hsieh's SuperFastHash
+    // http://www.azillionmonkeys.com/qed/hash.html
+    
+    // LChar data is interpreted as Latin-1-encoded (zero extended to 16 bits).
+    
+    // NOTE: The hash computation here must stay in sync with the create_hash_table script in
+    // JavaScriptCore and the CodeGeneratorJS.pm script in WebCore.
+    
+    // Golden ratio. Arbitrary start value to avoid mapping all zeros to a hash value of zero.
+    static const unsigned stringHashingStartValue = 0x9E3779B9U;
+    
+    class StringHasher {
+    public:
+        static const unsigned flagCount = 8; // Save 8 bits for StringImpl to use as flags.
+        
+        StringHasher()
+        : m_hash(stringHashingStartValue)
+        , m_hasPendingCharacter(false)
+        , m_pendingCharacter(0)
+        {
+        }
+        
+        // The hasher hashes two characters at a time, and thus an "aligned" hasher is one
+        // where an even number of characters have been added. Callers that always add
+        // characters two at a time can use the "assuming aligned" functions.
+        void addCharactersAssumingAligned(UChar a, UChar b)
+        {
+            ASSERT(!m_hasPendingCharacter);
+            m_hash += a;
+            m_hash = (m_hash << 16) ^ ((b << 11) ^ m_hash);
+            m_hash += m_hash >> 11;
+        }
+        
+        void addCharacter(UChar character)
+        {
+            if (m_hasPendingCharacter) {
+                m_hasPendingCharacter = false;
+                addCharactersAssumingAligned(m_pendingCharacter, character);
+                return;
+            }
+            
+            m_pendingCharacter = character;
+            m_hasPendingCharacter = true;
+        }
+        
+        void addCharacters(UChar a, UChar b)
+        {
+            if (m_hasPendingCharacter) {
+#if !ASSERT_DISABLED
+                m_hasPendingCharacter = false;
+#endif
+                addCharactersAssumingAligned(m_pendingCharacter, a);
+                m_pendingCharacter = b;
+#if !ASSERT_DISABLED
+                m_hasPendingCharacter = true;
+#endif
+                return;
+            }
+            
+            addCharactersAssumingAligned(a, b);
+        }
+        
+        template <typename T, UChar Converter(T)>
+        void addCharactersAssumingAligned(const T* data, unsigned length)
+        {
+            ASSERT(!m_hasPendingCharacter);
+            
+            bool remainder = length & 1;
+            length >>= 1;
+            
+            while (length--) {
+                addCharactersAssumingAligned(Converter(data[0]), Converter(data[1]));
+                data += 2;
+            }
+            
+            if (remainder)
+                addCharacter(Converter(*data));
+        }
+        
+        template <typename T>
+        void addCharactersAssumingAligned(const T* data, unsigned length)
+        {
+            addCharactersAssumingAligned<T, defaultConverter>(data, length);
+        }
+        
+        template <typename T, UChar Converter(T)>
+        void addCharactersAssumingAligned(const T* data)
+        {
+            ASSERT(!m_hasPendingCharacter);
+            
+            while (T a = *data++) {
+                T b = *data++;
+                if (!b) {
+                    addCharacter(Converter(a));
+                    break;
+                }
+                addCharactersAssumingAligned(Converter(a), Converter(b));
+            }
+        }
+        
+        template <typename T>
+        void addCharactersAssumingAligned(const T* data)
+        {
+            addCharactersAssumingAligned<T, defaultConverter>(data);
+        }
+        
+        template <typename T, UChar Converter(T)>
+        void addCharacters(const T* data, unsigned length)
+        {
+            if (m_hasPendingCharacter && length) {
+                m_hasPendingCharacter = false;
+                addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
+                --length;
+            }
+            addCharactersAssumingAligned<T, Converter>(data, length);
+        }
+        
+        template <typename T>
+        void addCharacters(const T* data, unsigned length)
+        {
+            addCharacters<T, defaultConverter>(data, length);
+        }
+        
+        template <typename T, UChar Converter(T)>
+        void addCharacters(const T* data)
+        {
+            if (m_hasPendingCharacter && *data) {
+                m_hasPendingCharacter = false;
+                addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
+            }
+            addCharactersAssumingAligned<T, Converter>(data);
+        }
+        
+        template <typename T>
+        void addCharacters(const T* data)
+        {
+            addCharacters<T, defaultConverter>(data);
+        }
+        
+        unsigned hashWithTop8BitsMasked() const
+        {
+            unsigned result = avalancheBits();
+            
+            // Reserving space from the high bits for flags preserves most of the hash's
+            // value, since hash lookup typically masks out the high bits anyway.
+            result &= (1U << (sizeof(result) * 8 - flagCount)) - 1;
+            
+            // This avoids ever returning a hash code of 0, since that is used to
+            // signal "hash not computed yet". Setting the high bit maintains
+            // reasonable fidelity to a hash code of 0 because it is likely to yield
+            // exactly 0 when hash lookup masks out the high bits.
+            if (!result)
+                result = 0x80000000 >> flagCount;
+            
+            return result;
+        }
+        
+        unsigned hash() const
+        {
+            unsigned result = avalancheBits();
+            
+            // This avoids ever returning a hash code of 0, since that is used to
+            // signal "hash not computed yet". Setting the high bit maintains
+            // reasonable fidelity to a hash code of 0 because it is likely to yield
+            // exactly 0 when hash lookup masks out the high bits.
+            if (!result)
+                result = 0x80000000;
+            
+            return result;
+        }
+        
+        template <typename T, UChar Converter(T)>
+        static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
+        {
+            StringHasher hasher;
+            hasher.addCharactersAssumingAligned<T, Converter>(data, length);
+            return hasher.hashWithTop8BitsMasked();
+        }
+        
+        template <typename T, UChar Converter(T)>
+        static unsigned computeHashAndMaskTop8Bits(const T* data)
+        {
+            StringHasher hasher;
+            hasher.addCharactersAssumingAligned<T, Converter>(data);
+            return hasher.hashWithTop8BitsMasked();
+        }
+        
+        template <typename T>
+        static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
+        {
+            return computeHashAndMaskTop8Bits<T, defaultConverter>(data, length);
+        }
+        
+        template <typename T>
+        static unsigned computeHashAndMaskTop8Bits(const T* data)
+        {
+            return computeHashAndMaskTop8Bits<T, defaultConverter>(data);
+        }
+        
+        template <typename T, UChar Converter(T)>
+        static unsigned computeHash(const T* data, unsigned length)
+        {
+            StringHasher hasher;
+            hasher.addCharactersAssumingAligned<T, Converter>(data, length);
+            return hasher.hash();
+        }
+        
+        template <typename T, UChar Converter(T)>
+        static unsigned computeHash(const T* data)
+        {
+            StringHasher hasher;
+            hasher.addCharactersAssumingAligned<T, Converter>(data);
+            return hasher.hash();
+        }
+        
+        template <typename T>
+        static unsigned computeHash(const T* data, unsigned length)
+        {
+            return computeHash<T, defaultConverter>(data, length);
+        }
+        
+        template <typename T>
+        static unsigned computeHash(const T* data)
+        {
+            return computeHash<T, defaultConverter>(data);
+        }
+        
+        static unsigned hashMemory(const void* data, unsigned length)
+        {
+            // FIXME: Why does this function use the version of the hash that drops the top 8 bits?
+            // We want that for all string hashing so we can use those bits in StringImpl and hash
+            // strings consistently, but I don't see why we'd want that for general memory hashing.
+            ASSERT(!(length % 2));
+            return computeHashAndMaskTop8Bits<UChar>(static_cast<const UChar*>(data), length / sizeof(UChar));
+        }
+        
+        template <size_t length>
+        static unsigned hashMemory(const void* data)
+        {
+            static_assert(!(length % 2), "length must be a multiple of two!");
+            return hashMemory(data, length);
+        }
+        
+    private:
+        static UChar defaultConverter(UChar character)
+        {
+            return character;
+        }
+        
+        static UChar defaultConverter(LChar character)
+        {
+            return character;
+        }
+        
+        unsigned avalancheBits() const
+        {
+            unsigned result = m_hash;
+            
+            // Handle end case.
+            if (m_hasPendingCharacter) {
+                result += m_pendingCharacter;
+                result ^= result << 11;
+                result += result >> 17;
+            }
+            
+            // Force "avalanching" of final 31 bits.
+            result ^= result << 3;
+            result += result >> 5;
+            result ^= result << 2;
+            result += result >> 15;
+            result ^= result << 10;
+            
+            return result;
+        }
+        
+        unsigned m_hash;
+        bool m_hasPendingCharacter;
+        UChar m_pendingCharacter;
+    };
+    
+} // namespace WTF
+
+using WTF::StringHasher;
+
+#endif // WTF_StringHasher_h

package/src-native/ios/Headers/runtime/SymbolIterator.h

@@ -0,0 +1,18 @@
+#ifndef SymbolIterator_h
+#define SymbolIterator_h
+
+#include "Common.h"
+
+namespace tns {
+
+class SymbolIterator {
+public:
+    static void Set(v8::Local<v8::Context> context, v8::Local<v8::Value> object);
+private:
+    static v8::Local<v8::Object> CreateIteratorObject(v8::Local<v8::Context> context, v8::Local<v8::Value> object);
+    static void NextCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+};
+
+}
+
+#endif /* SymbolIterator_h */

package/src-native/ios/Headers/runtime/SymbolLoader.h

@@ -0,0 +1,27 @@
+#ifndef SymbolLoader_h
+#define SymbolLoader_h
+
+#include "robin_hood.h"
+#include "Metadata.h"
+
+namespace tns {
+
+class SymbolResolver;
+
+class SymbolLoader {
+public:
+    static SymbolLoader& instance();
+
+    void* loadFunctionSymbol(const ModuleMeta*, const char* symbolName);
+    void* loadDataSymbol(const ModuleMeta*, const char* symbolName);
+    bool ensureModule(const ModuleMeta*);
+
+private:
+    SymbolResolver* resolveModule(const ModuleMeta*);
+
+    robin_hood::unordered_map<const ModuleMeta*, std::unique_ptr<SymbolResolver>> _cache;
+};
+
+}
+
+#endif /* SymbolLoader_h */

package/src-native/ios/Headers/runtime/TNSDerivedClass.h

@@ -0,0 +1,8 @@
+#ifndef TNSDerivedClass_h
+#define TNSDerivedClass_h
+
+@protocol TNSDerivedClass
+
+@end
+
+#endif /* TNSDerivedClass_h */

package/src-native/ios/Headers/runtime/TSHelpers.h

@@ -0,0 +1,15 @@
+#ifndef TSHelpers_h
+#define TSHelpers_h
+
+#include "Common.h"
+
+namespace tns {
+
+class TSHelpers {
+public:
+    static void Init(v8::Local<v8::Context> context);
+};
+
+}
+
+#endif /* TSHelpers_h */

package/src-native/ios/Headers/runtime/Tasks.h

@@ -0,0 +1,19 @@
+#ifndef Tasks_h
+#define Tasks_h
+
+#include <vector>
+#include <functional>
+
+namespace tns {
+
+class Tasks {
+public:
+    static void Register(std::function<void()> task);
+    static void Drain();
+private:
+    static std::vector<std::function<void()>> tasks_;
+};
+
+}
+
+#endif /* Tasks_h */

package/src-native/ios/Headers/runtime/UnmanagedType.h

@@ -0,0 +1,21 @@
+#ifndef UnmanagedType_h
+#define UnmanagedType_h
+
+#include "Common.h"
+#include "DataWrapper.h"
+
+namespace tns {
+
+class UnmanagedType {
+public:
+    static v8::Local<v8::Value> Create(v8::Local<v8::Context> context, UnmanagedTypeWrapper* wrapper);
+private:
+    static void ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void TakeUnretainedValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void TakeRetainedValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static v8::Local<v8::Value> TakeValue(const v8::FunctionCallbackInfo<v8::Value>& info, bool retained);
+};
+
+}
+
+#endif /* UnmanagedType_h */

package/src-native/ios/Headers/runtime/WeakRef.h

@@ -0,0 +1,15 @@
+#ifndef WeakRef_h
+#define WeakRef_h
+
+#include "Common.h"
+
+namespace tns {
+
+class WeakRef {
+public:
+    static void Init(v8::Local<v8::Context> context);
+};
+
+}
+
+#endif /* WeakRef_h */

package/src-native/ios/Headers/runtime/Worker.h

@@ -0,0 +1,26 @@
+#ifndef Worker_h
+#define Worker_h
+
+#include "Common.h"
+
+namespace tns {
+
+class Worker {
+public:
+    static void Init(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate, bool isWorkerThread);
+    static std::vector<std::string> GlobalFunctions;
+private:
+    static void ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void PostMessageCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void TerminateCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void OnMessageCallback(v8::Isolate* isolate, v8::Local<v8::Value> receiver, std::string message);
+    static void PostMessageToMainCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static void CloseWorkerCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
+    static v8::Local<v8::String> Serialize(v8::Isolate* isolate, v8::Local<v8::Value> value, v8::Local<v8::Value>& error);
+    static void SetWorkerId(v8::Isolate* isolate, int workerId);
+    static int GetWorkerId(v8::Isolate* isolate, v8::Local<v8::Object> global);
+};
+
+}
+
+#endif /* Worker_h */