rhodes 6.2.0 → 7.1.17

data/platform/shared/rhoruby/impl/RhoRubyImpl.h

@@ -0,0 +1,81 @@
+#pragma once
+
+
+#include "../api/IRhoRuby.h"
+#include "../../ruby/include/ruby.h"
+#include "common/RhoMutexLock.h"
+#include "json/JSONIterator.h"
+
+#include <string>
+#include <map>
+#include <vector>
+
+namespace rho {
+namespace ruby {
+
+
+class RhoRubyImpl : public IRhoRuby {
+
+public:
+    virtual ~RhoRubyImpl();
+    RhoRubyImpl(bool _lateInit = false);
+
+    virtual void init() override;
+
+    // get local Ruby server URL
+    virtual IString* getRubyServerURL();
+    
+    // call command in ruby thread
+    virtual void executeInRubyThread(IRunnable* command);
+
+    // call ruby server url (get request) and receive responce (body if exist or NULL if error etc.)
+    virtual void executeGetRequestToRubyServer(const char* url, IRubyLocalServerRequestCallback* callback);
+
+    // execute ruby code in current thread. parameters can be simple object (string, integer etc. - in this case one parameters will be passed to method.)
+    // also parameters can be IArray - in this case list of parameters will be passed to method (parameters from array)
+    // this method recommended execute from ruby thread (from IRunnable command), but can be executed from other thread for very simple opertions without modifying ruby objects
+    virtual IObject* executeRubyObjectMethod(IObject* object, const char* method_name, IObject* parameters);
+
+    // this method recommended execute from ruby thread (from IRunnable command), but can be executed from other thread
+    virtual IObject* makeRubyClassObject(const char* full_class_name);
+
+    // can be execute from any thread - for construct parameters for execute ruby code
+    virtual IObject* makeBaseTypeObject(BASIC_TYPES type);
+
+
+    // register callback for execute from Ruby side via - it is needed for direct call native code foem ruby code
+    // Rho::Ruby.callNativeCallback(callback_id, param)
+    virtual void addRubyNativeCallback(const char* callback_id, IRubyNativeCallback* callback);
+    virtual void removeRubyNativeCallback(const char* callback_id);
+
+    // util methods (used for parse responce from server etc.)
+    virtual IObject* convertJSON_to_Objects(const char* json);
+    virtual IString* convertObject_to_JSON(IObject* obj);
+    
+    virtual void loadRubyFile(const char* ruby_file_path);
+    virtual void loadModel(const char* ruby_file_path);
+    virtual IObject* executeRubyMethod(const char* full_class_name, const char* method_name, IObject* parameters);
+    virtual IString* executeRubyMethodWithJSON(const char* full_class_name, const char* method_name, const char* parameters_in_json);
+    
+
+    IObject* convertVALUE_to_Object(VALUE value);
+    VALUE convertObject_to_VALUE(IObject* obj);
+    
+    VALUE rb_Rho_Ruby_callNativeCallback(int argc, VALUE *argv);
+    void rholib_local_server_callback();
+
+private:
+    IObject* convertJSON_to_Object(json::CJSONEntry* json_entry);
+    
+    //hashtable for native callback_id => callback pointer
+    std::map<std::string, IRubyNativeCallback*> mCallbacks;
+    
+    
+    std::vector<IRunnable*> mRubyCommands;
+    common::CMutex m_mxSyncMutex;
+    bool lateInit = false;
+
+};
+
+}
+}

data/platform/shared/rhoruby/impl/RhoRubySingletone.cpp

@@ -0,0 +1,20 @@
+
+#include "../api/RhoRubySingletone.h"
+#include "RhoRubyImpl.h"
+#include <stdlib.h>
+
+namespace rho {
+namespace ruby {
+
+IRhoRuby* RhoRubySingletone::mRhoRuby = NULL;
+
+IRhoRuby* RhoRubySingletone::getRhoRuby(bool lateInit) {
+    if (mRhoRuby == NULL) {
+        mRhoRuby = new RhoRubyImpl(lateInit);
+    }
+    return mRhoRuby;
+}
+
+
+}
+}

data/platform/shared/rhoruby/impl/RubyServerResponceImpl.cpp

@@ -0,0 +1,32 @@
+#include "RubyServerResponceImpl.h"
+#include "../api/RhoRubySingletone.h"
+#include "../api/IMutableString.h"
+#include <stdlib.h>
+#include "string.h"
+
+namespace rho {
+namespace ruby {
+
+RubyServerResponceImpl::RubyServerResponceImpl(const char* body) {
+    mBody = NULL;
+    if (body != NULL) {
+        int len = (int)strlen(body);
+        mBody = (char*)malloc(len+1);
+        strcpy(mBody, body);
+    }
+}
+
+RubyServerResponceImpl::~RubyServerResponceImpl(){
+    if (mBody != NULL) {
+        free(mBody);
+    }
+}
+
+IString* RubyServerResponceImpl::getResponceBody() {
+    IMutableString* str = (IMutableString*)RhoRubySingletone::getRhoRuby()->makeBaseTypeObject(BASIC_TYPES::MutableString);
+    str->setUTF8(mBody);
+    return str;
+}
+
+}
+}

data/platform/shared/rhoruby/impl/RubyServerResponceImpl.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "../api/IRhoRuby.h"
+
+namespace rho {
+namespace ruby {
+
+class RubyServerResponceImpl : public IRubyServerResponce 
+{
+public:
+    virtual ~RubyServerResponceImpl();
+    RubyServerResponceImpl(const char* body);
+    virtual IString* getResponceBody();
+    
+private:
+    char* mBody;
+};
+    
+
+        
+}
+}

data/platform/shared/ruby/android/ruby/config.h

@@ -7,6 +7,8 @@
 #warning ">>>>> Building for x86 <<<<<"
 #elif defined(__arm__)
 #warning ">>>>> Building for ARM <<<<<"
+#elif defined(__aarch64__)
+#warning ">>>>> Building for AARCH64 <<<<<"
 #else
 #error ">>>>> UNKNOWN ARCH! <<<<<"
 #endif
@@ -120,15 +122,29 @@
 #define HAVE_OFF_T 1
 #define SIZEOF_INT 4
 #define SIZEOF_SHORT 2
+#if defined(__aarch64__)
+#define SIZEOF_LONG 8
+#else
 #define SIZEOF_LONG 4
+#endif
 #define SIZEOF_LONG_LONG 8
 #define SIZEOF___INT64 0
+
+#if defined(__aarch64__)
+#define SIZEOF_OFF_T 8
+#define SIZEOF_VOIDP 8
+#define SIZEOF_TIME_T 8
+#define SIZEOF_CLOCK_T 8
+#else
 #define SIZEOF_OFF_T 4
 #define SIZEOF_VOIDP 4
-#define SIZEOF_FLOAT 4
-#define SIZEOF_DOUBLE 8
 #define SIZEOF_TIME_T 4
 #define SIZEOF_CLOCK_T 4
+#endif
+
+#define SIZEOF_FLOAT 4
+#define SIZEOF_DOUBLE 8
+
 #define PACKED_STRUCT(x) x __attribute__((packed))
 #define PACKED_STRUCT_UNALIGNED(x) x
 #define PRI_LL_PREFIX "ll"
@@ -209,8 +225,14 @@
 #define ENUM_OVER_INT 1
 #define HAVE_DECL_SYS_NERR 1
 #define HAVE_DECL_GETENV 1
+#if defined(__aarch64__)
+#define SIZEOF_SIZE_T 8
+#define SIZEOF_PTRDIFF_T 8
+#else
 #define SIZEOF_SIZE_T 4
 #define SIZEOF_PTRDIFF_T 4
+#endif
+
 #define PRI_SIZE_PREFIX "z"
 #define PRI_PTRDIFF_PREFIX "t"
 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
@@ -219,9 +241,17 @@
 #define HAVE_ST_BLOCKS 1
 #define HAVE_STRUCT_STAT_ST_RDEV 1
 #define HAVE_ST_RDEV 1
+
+#if defined(__aarch64__)
+#define SIZEOF_STRUCT_STAT_ST_SIZE SIZEOF_OFF_T
+#define SIZEOF_STRUCT_STAT_ST_BLOCKS SIZEOF_OFF_T
+#define SIZEOF_STRUCT_STAT_ST_INO SIZEOF_LONG
+#else
 #define SIZEOF_STRUCT_STAT_ST_SIZE SIZEOF_LONG_LONG
 #define SIZEOF_STRUCT_STAT_ST_BLOCKS SIZEOF_LONG_LONG
 #define SIZEOF_STRUCT_STAT_ST_INO SIZEOF_LONG_LONG
+#endif
+
 #define HAVE_STRUCT_STAT_ST_ATIMENSEC 1
 #define HAVE_STRUCT_STAT_ST_MTIMENSEC 1
 #define HAVE_STRUCT_STAT_ST_CTIMENSEC 1
@@ -247,11 +277,23 @@
 #define HAVE_UINT64_T 1
 #define SIZEOF_UINT64_T 8
 #define HAVE_INTPTR_T 1
+#if defined(__aarch64__)
+#define SIZEOF_INTPTR_T 8
+#else
 #define SIZEOF_INTPTR_T 4
+#endif
 #define HAVE_UINTPTR_T 1
+#if defined(__aarch64__)
+#define SIZEOF_UINTPTR_T 8
+#else
 #define SIZEOF_UINTPTR_T 4
+#endif
 #define HAVE_SSIZE_T 1
+#if defined(__aarch64__)
+#define SIZEOF_SSIZE_T 8
+#else
 #define SIZEOF_SSIZE_T 4
+#endif
 #define GETGROUPS_T gid_t
 #define RETSIGTYPE void
 #define HAVE_ALLOCA_H 1
@@ -399,7 +441,7 @@
 //RHO
 #if defined(__i386__) || defined(__x86_64__)
 #define STACK_GROW_DIRECTION -1
-#elif defined (__arm__)
+#elif defined(__arm__) || defined(__aarch64__)
 #define STACK_GROW_DIRECTION 0
 #else
 #error "Unknown arch!"
@@ -423,15 +465,25 @@
 #define HAVE_ELF_H 1
 #define DLEXT_MAXLEN 3
 #define DLEXT ".so"
+
+#if defined(__aarch64__)
+#define RUBY_SETJMP(env) sigsetjmp((env),0)
+#define RUBY_LONGJMP(env,val) siglongjmp((env),val)
+#define RUBY_JMP_BUF sigjmp_buf
+#else
 #define RUBY_SETJMP(env) __builtin_setjmp((env))
 #define RUBY_LONGJMP(env,val) __builtin_longjmp((env),val)
 #define RUBY_JMP_BUF jmp_buf
+#endif
+
 #define HAVE_PTHREAD_H 1
 //RHO
 #if defined(__i386__) || defined(__x86_64__)
 #define RUBY_PLATFORM "android-x86"
 #elif defined (__arm__)
 #define RUBY_PLATFORM "arm-linux-androideabi"
+#elif defined (__aarch64__)
+#define RUBY_PLATFORM "aarch64-linux"
 #else
 #error "Unknown arch!"
 #endif

data/platform/shared/ruby/error.c

@@ -66,7 +66,7 @@ static const char REPORTBUG_MSG[] =
 	" or extension libraries.\n" \
 	"Bug reports are welcome.\n" \
 	""
-	"For details: http://www.ruby-lang.org/bugreport.html\n\n" \
+	"For details: https://www.ruby-lang.org/bugreport.html\n\n" \
     ;
 
 static const char *

data/platform/shared/ruby/ext/rho/rhoruby.c

@@ -90,6 +90,9 @@ extern void Init_nonblock(void);
 extern void Init_date_core(void);
 
 
+extern void Init_RubyNative_extension(void);
+
+
 //RhoSupport extension
 extern void Init_RhoSupport(void);
 extern VALUE require_compiled(VALUE fname, VALUE* result);
@@ -121,6 +124,14 @@ extern int rho_conf_getBool(const char* szName);
 
 static int extensions_loaded = 0;
 
+#ifndef RHO_RUBY_COMPILER
+extern void* rho_mutex_create();
+extern void rho_mutex_lock(void*);
+extern void rho_mutex_release(void*);
+static void* s_ruby_gc_lock;
+#endif
+
+
 #if defined(WIN32)
 extern void rb_w32_sysinit(int *argc, char ***argv);
 #endif
@@ -180,6 +191,9 @@ void Init_transcoders() {
 
 void RhoRubyStart()
 {
+#ifndef RHO_RUBY_COMPILER
+    s_ruby_gc_lock = rho_mutex_create();
+#endif
     const char* szRoot = rho_native_rhopath();
 //RHO
 #if defined(_WIN32)
@@ -272,6 +286,11 @@ void RhoRubyStart()
 
 	Init_Extensions();
 #endif //OS_WP8
+        
+        
+    //MOHUS
+    //Init_RubyNative_extension();
+        
  
 	extensions_loaded = 1;
 
@@ -992,21 +1011,55 @@ void  rho_ruby_enable_gc(VALUE val)
         rb_gc_disable();
 }
 
+void rho_ruby_gc_lock() {
+    #ifndef RHO_RUBY_COMPILER
+    rho_mutex_lock( s_ruby_gc_lock );
+    #endif
+}
+
+void rho_ruby_gc_release() {
+    #ifndef RHO_RUBY_COMPILER
+    rho_mutex_release( s_ruby_gc_lock );
+    #endif
+}
+
 void rho_ruby_holdValue(VALUE val)
-{
+{    
+    rho_ruby_gc_lock();
+
     rb_gc_register_mark_object(val);
+
+    rho_ruby_gc_release();
 }
 
 void rho_ruby_releaseValue(VALUE val)
 {
-    VALUE ary = GET_THREAD()->vm->mark_object_ary;
-    int i = RARRAY_LEN(ary)-1;
-    for ( ; i >= 0; i-- ) {
-        if ( RARRAY_PTR(ary)[i]== val )
+    rho_ruby_gc_lock();
+
+    VALUE ary_ary = GET_VM()->mark_object_ary;
+
+    int bucket = RARRAY_LEN(ary_ary)-1;
+    int done = 0;
+    for ( ; bucket >= 0; bucket-- ) {
+        VALUE ary = rb_ary_at( ary_ary, INT2NUM(bucket) );
+
+         int i = RARRAY_LEN(ary)-1;
+         for ( ; i >= 0; i-- ) {
+             if ( RARRAY_PTR(ary)[i]== val )
+                 break;
+         }
+
+        if ( i >= 0 ) {
+            rb_ary_delete_at(ary,i);
+            done = 1;
+        }
+
+        if ( done != 0 ) {
             break;
+        }
     }
-    if ( i >= 0 )
-        rb_ary_delete_at(ary,i);
+
+    rho_ruby_gc_release();
 }
 
 extern VALUE rb_cMutex;

data/platform/shared/ruby/ext/rho/rhoruby.h

@@ -91,6 +91,9 @@ void rho_ruby_releaseValue(VALUE val);
 VALUE rho_ruby_disable_gc();
 void  rho_ruby_enable_gc(VALUE val);
 
+void rho_ruby_gc_lock();
+void rho_ruby_gc_release();
+
 VALUE callFramework(VALUE hashReq);
 VALUE callServeIndex(char* index_name, VALUE hashReq);
 

data/platform/shared/rubyext/NativeToolbarExt.h

@@ -28,6 +28,7 @@
 #define _NATIVETOOLBAREXT_H_
 
 #include "common/RhoStd.h"
+#include "api_generator/MethodResult.h"
 
 #if defined(OS_WP8) || defined(OS_UWP)
 #define TOOLBAR_TYPE		0

data/platform/uwp/rhoruntime/common/RhoClassFactory.h

@@ -29,6 +29,7 @@
 #include "common/IRhoClassFactory.h"
 #include "net/CURLNetRequest.h"
 #include "RhoThreadImpl.h"
+#include "common/ISecurityTokenGenerator.h"
 
 namespace rho {
 namespace common {
@@ -46,6 +47,11 @@ public:
     {
         return new CRhoThreadImpl;
     }
+    
+    const rho::common::ISecurityTokenGenerator* createSecurityTokenGenerator()
+    {
+        return nullptr;
+    }
 
     virtual net::ISSL* createSSLEngine();
     virtual IRhoCrypt* createRhoCrypt();