JNIEXPORT jobject JNICALL Java_org_appcelerator_kroll_runtime_v8_V8Runtime_nativeEvalString
	(JNIEnv *env, jobject self, jstring source, jstring filename)
{
	HandleScope scope(V8Runtime::v8_isolate);
	titanium::JNIScope jniScope(env);

	Local<Value> jsSource = TypeConverter::javaStringToJsString(V8Runtime::v8_isolate, env, source);
	if (jsSource.IsEmpty() || !jsSource->IsString()) {
		LOGE(TAG, "Error converting Javascript string, aborting evalString");
		return NULL;
	}

	Local<Value> jsFilename = TypeConverter::javaStringToJsString(V8Runtime::v8_isolate, env, filename);

	TryCatch tryCatch(V8Runtime::v8_isolate);
	Local<Script> script = Script::Compile(jsSource.As<String>(), jsFilename.As<String>());
	Local<Value> result = script->Run();

	if (tryCatch.HasCaught()) {
		V8Util::openJSErrorDialog(V8Runtime::v8_isolate, tryCatch);
		V8Util::reportException(V8Runtime::v8_isolate, tryCatch, true);
		return NULL;
	}

	return TypeConverter::jsValueToJavaObject(V8Runtime::v8_isolate, env, result);
}
Beispiel #2
0
void exec(Isolate *isolate){
    Isolate::Scope isolate_scope(isolate);

    // Create a stack-allocated handle scope.
    HandleScope handle_scope(isolate);

    // Create a new context.
    Local<Context> context = Context::New(isolate);

    // Enter the context for compiling and running the hello world script.
    Context::Scope context_scope(context);

    // Create a string containing the JavaScript source code.
    Local<String> source =
        String::NewFromUtf8(isolate, "'Hello' + ', World!'",
                            NewStringType::kNormal).ToLocalChecked();

    // Compile the source code.
    Local<Script> script = Script::Compile(context, source).ToLocalChecked();

    // Run the script to get the result.
    Local<Value> result = script->Run(context).ToLocalChecked();

    // Convert the result to an UTF8 string and print it.
    String::Utf8Value utf8(result);
    Print(" result --->", *utf8);
}
extern "C" void
init(Handle<Object> target)
{
    HandleScope scope;
    Local<FunctionTemplate> logFunction = FunctionTemplate::New(LogWrapper);
    target->Set(String::NewSymbol("_logString"), logFunction->GetFunction());
    Local<FunctionTemplate> logKeyValueFunction = FunctionTemplate::New(LogKeyValueWrapper);
    target->Set(String::NewSymbol("_logKeyValueString"), logKeyValueFunction->GetFunction());
    target->Set(String::NewSymbol("LOG_CRITICAL"), Integer::New(kPmLogLevel_Critical));
    target->Set(String::NewSymbol("LOG_ERR"), Integer::New(kPmLogLevel_Error));
    target->Set(String::NewSymbol("LOG_WARNING"), Integer::New(kPmLogLevel_Warning));
    target->Set(String::NewSymbol("LOG_INFO"), Integer::New(kPmLogLevel_Info));
    target->Set(String::NewSymbol("LOG_DEBUG"), Integer::New(kPmLogLevel_Debug));
    Local<String> scriptText = String::New((const char*)pmloglib_js, pmloglib_js_len);
    Local<Script> script = Script::New(scriptText, String::New("pmloglib.js"));
    if (!script.IsEmpty()) {
        Local<Value> v = script->Run();
        Local<Function> f = Local<Function>::Cast(v);
        Local<Context> current = Context::GetCurrent();
        Handle<Value> argv[1];
        argv[0] = target;
        f->Call(current->Global(), 1, &argv[0]);
    } else {
        cerr << "Script was empty." << endl;
    }
}
Beispiel #4
0
bool v8test_eval()
{
    BEGINTEST();

    HandleScope handle_scope;
    Persistent<Context> context = Context::New();
    Context::Scope context_scope(context);

    Local<Object> qmlglobal = Object::New();
    qmlglobal->Set(String::New("a"), Integer::New(1922));

    Local<Script> script = Script::Compile(String::New("eval(\"a\")"), NULL, NULL, 
                                           Handle<String>(), Script::QmlMode);
    
    TryCatch tc;
    Local<Value> result = script->Run(qmlglobal);

    VERIFY(!tc.HasCaught());
    VERIFY(result->Int32Value() == 1922);

cleanup:
    context.Dispose();

    ENDTEST();
}
ScriptValuePtr V8Engine::runScript(std::string script, std::string identifier)
{
    HandleScope handleScope;
    TryCatch tc;

    Local<String> source = String::New(script.c_str());

    // Build data

    ScriptOrigin origin(String::New(identifier.c_str()));

    // Compile the source code.

    Local<Script> code = Script::Compile(source, &origin);
    if (code.IsEmpty())
        handleException(tc);
  
    // Run the script to get the result.

    Local<Value> result = code->Run();
    if (result.IsEmpty())
        handleException(tc);

    return ScriptValuePtr( new V8Value(this, result) );
}
stdext::ustring JavaScriptContext::ExecuteReturnString(const stdext::ustring & source, const stdext::ustring & name, stdext::ustring & error)
{
	stdext::ustring resultString;
	error = wstringToUstring(L"");
	Locker locker(m_isolate); 
	Isolate::Scope isolate_scope(m_isolate);
	{
		Context::Scope contextScope(*m_ctx);
		HandleScope scope;
		Local<String> scriptSource = String::New(reinterpret_cast<const uint16_t *>(source.c_str()));
		Local<String> scriptName = String::New(reinterpret_cast<const uint16_t *>(name.c_str()));
		Local<Script> script = Script::New(scriptSource, scriptName);
		Local<Value> result;
		{
			TryCatch tryCatch;
			result = script->Run();
			if (!result.IsEmpty())
			{
				String::Value value(result);
				resultString.append(reinterpret_cast<const char16_t *>(*value));
			}

			if (tryCatch.HasCaught())
			{
				error.append(wstringToUstring(L"Error running script: "));
				error.append(name);
				error.append(wstringToUstring(L" - "));
				String::Value stackTrace(tryCatch.StackTrace());
				error.append(reinterpret_cast<const char16_t*>(*stackTrace));
			}
		}
	}

	return resultString;
}
Beispiel #7
0
 Local< v8::Value > newFunction( const char *code ) {
     stringstream codeSS;
     codeSS << "____MontoToV8_newFunction_temp = " << code;
     string codeStr = codeSS.str();
     Local< Script > compiled = Script::New( v8::String::New( codeStr.c_str() ) );
     Local< Value > ret = compiled->Run();
     return ret;
 }
void V8Engine::init()
{
    Logging::log(Logging::DEBUG, "V8Engine::init:\r\n");
    INDENT_LOG(Logging::DEBUG);

    HandleScope handleScope;

    // Create a template for the global object.
    Logging::log(Logging::DEBUG, "Creating global\r\n");

//    _global = ObjectTemplate::New();

    Logging::log(Logging::DEBUG, "Creating context\r\n");

    context = Context::New(); //NULL, _global);

    context->Enter();

    // Create our internal wrappers

    Logging::log(Logging::DEBUG, "Creating wrapper for global\r\n");

    globalValue = ScriptValuePtr(new V8Value(this, context->Global()));

#if 0
    // Setup debugger, if required - XXX Doesn't work

//    Debug::SetDebugEventListener(debuggerListener);
//    runFile("src/thirdparty/v8/src/debug-delay.js"); // FIXME: remove hardcoded src/..
    runFile("src/javascript/intensity/V8Debugger.js"); // FIXME: remove hardcoded src/javascript
             
    v8::Handle<v8::Value> result =
        ((V8Value*)(getGlobal()->getProperty("__debuggerListener").get()))->value;
    assert(result->IsObject());
    Local<Object> debuggerListener = result->ToObject();
    assert(debuggerListener->IsFunction());

    Debug::SetDebugEventListener(debuggerListener);

    runScript("Debug.setBrzzzzzzzzzeakOnException()");

    Local<String> source = String::New(
        "temp = function () { Debug.setBreakOnException(); return 5098; } "
    );
    Local<Script> code = Script::Compile(source);
    Local<Value> result2 = code->Run();
    printV8Value(result2, true);
    assert(result2->IsObject());
    Local<Object> obj = result2->ToObject();
    assert(obj->IsFunction());
    Local<Function> func = Function::Cast(*obj);
    Handle<Value> output = Debug::Call(func);
    printV8Value(output, true);
assert(0);
#endif

    Logging::log(Logging::DEBUG, "V8Engine::init complete.\r\n");
}
Beispiel #9
0
void Module::Init(Isolate *isolate)
{
	JEnv env;

	MODULE_CLASS = env.FindClass("com/tns/Module");
	assert(MODULE_CLASS != nullptr);

	RESOLVE_PATH_METHOD_ID = env.GetStaticMethodID(MODULE_CLASS, "resolvePath", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
	assert(RESOLVE_PATH_METHOD_ID != nullptr);

	string requireFactoryScript =
	"(function () { "
	"	function require_factory(requireInternal, dirName) { "
	"		return function require(modulePath) { "
	"			if(global.__requireOverride) { "
	"				var result = global.__requireOverride(modulePath, dirName); "
	"				if(result) { "
	"					return result; "
	"				} "
	"			} "
	"			return requireInternal(modulePath, dirName); "
	"		} "
	"	} "
	"	return require_factory; "
	"})()";

	auto source = ConvertToV8String(requireFactoryScript);
	auto context = isolate->GetCurrentContext();

	Local<Script> script;
	auto maybeScript = Script::Compile(context, source).ToLocal(&script);

	assert(!script.IsEmpty());

	Local<Value> result;
	auto maybeResult = script->Run(context).ToLocal(&result);

	assert(!result.IsEmpty() && result->IsFunction());

	auto requireFactoryFunction = result.As<Function>();

	auto cache = GetCache(isolate);

	cache->RequireFactoryFunction = new Persistent<Function>(isolate, requireFactoryFunction);

	auto requireFuncTemplate = FunctionTemplate::New(isolate, RequireCallback);
	auto requireFunc = requireFuncTemplate->GetFunction();
	cache->RequireFunction = new Persistent<Function>(isolate, requireFunc);

	auto global = isolate->GetCurrentContext()->Global();
	auto globalRequire = GetRequireFunction(isolate, Constants::APP_ROOT_FOLDER_PATH);
	global->Set(ConvertToV8String("require"), globalRequire);
}
jobject NativePlatform::RunScript(JNIEnv *_env, jobject obj, jstring scriptFile)
{
	JEnv env(_env);
	jobject res = nullptr;

	auto isolate = g_isolate;
	Isolate::Scope isolate_scope(isolate);
	HandleScope handleScope(isolate);
	auto context = isolate->GetCurrentContext();

	auto filename = ArgConverter::jstringToString(scriptFile);
	auto src = File::ReadText(filename);
	auto source = ConvertToV8String(src);

	TryCatch tc;

	Local<Script> script;
	ScriptOrigin origin(ConvertToV8String(filename));
	auto maybeScript = Script::Compile(context, source, &origin).ToLocal(&script);

	if(tc.HasCaught()) {
		throw NativeScriptException(tc, "Script " + filename + " contains compilation errors!");
	}

	if (!script.IsEmpty())
	{
		Local<Value> result;
		auto maybeResult = script->Run(context).ToLocal(&result);

		if(tc.HasCaught()) {
			throw NativeScriptException(tc, "Error running script " + filename);
		}
		if (!result.IsEmpty())
		{
			res = ConvertJsValueToJavaObject(env, result, static_cast<int>(Type::Null));
		}
		else
		{
			DEBUG_WRITE(">>runScript maybeResult is empty");
		}
	}
	else
	{
		DEBUG_WRITE(">>runScript maybeScript is empty");
	}

	return res;
}
bool JSWrapper::execute( const char *scr, JSWrapperData *data, const char *fileName )
{
    HandleScope handle_scope( m_isolate );

    Local<String> source = String::NewFromUtf8( m_isolate, scr, NewStringType::kNormal ).ToLocalChecked();

    ScriptOrigin origin( v8::String::NewFromUtf8( m_isolate, fileName ? fileName : "Unknown" ) );
    MaybeLocal<Script> maybeScript = Script::Compile( m_context, source, &origin );

    bool success=false;

    if ( !maybeScript.IsEmpty() )
    {
        Local<Script> script = maybeScript.ToLocalChecked();        
        MaybeLocal<Value> maybeResult = script->Run(m_context);

        if ( !maybeResult.IsEmpty() )
        {
            Local<Value> result = maybeResult.ToLocalChecked();

            if ( data )
            {
                if ( result->IsNumber() )
                    data->setNumber( result->ToNumber()->Value() );
                else
                if ( result->IsString() )
                {
                    String::Utf8Value utf8( result );
                    data->setString( *utf8 );
                } else
                if ( result->IsBoolean() )
                    data->setBoolean( result->ToBoolean()->Value() );
                else                
                if ( result->IsObject() )
                    data->setObject( new JSWrapperObject( m_isolate, result->ToObject() ) );
                else
                if ( result->IsNull() )
                    data->setNull();
                else data->setUndefined();
            }

            success=true;
        } 
    }

    return success;
}
Beispiel #12
0
	Local<Value> ExecuteString(Handle<String> source, Handle<Value> filename) {
		HandleScope scope;
		TryCatch tryCatch;
		
		Local<Script> script = Script::Compile(source, filename);
		if (script.IsEmpty()) {
			ReportException(&tryCatch);
			exit(1);
		}
		
		Local<Value> result = script->Run();
		if (result.IsEmpty()) {
			ReportException(&tryCatch);
			exit(1);
		}
		
		return scope.Close(result);
	} // ExecuteString
Beispiel #13
0
	//C++版本的loadJSCode
	Handle<Value> LoadJsCode(LPCWSTR cjs,LPCWSTR fn){
		if(cjs==0) return Undefined();
		if(fn==0) fn = NULL_STR;
		HandleScope store;
		Handle<String> js = String::New((uint16_t*)cjs);
		Handle<Value> name = String::New((uint16_t*)fn);
		TryCatch err;

		Local<Script> script = Script::Compile(js,name);
		while(!script.IsEmpty()){
			Local<Value> result = script->Run(); 
			if(err.HasCaught()) break;//这两种判断方式可能是等价的。
			//if(result.IsEmpty()) break;
			return store.Close(result);
		}
		ReportError(err);
		return Undefined();
	}
Beispiel #14
0
	//*,{
	//	"type":"function",
	//	"name":"run(js,[name])",
	//	"text":"加载一段js代码字串, 并且返回执行结果. 这个函数类似于 PHP 的 require 函数, 但是参数不是文件名, 而是 js 代码字串。",
	//	"param":[
	//		{
	//			"type":"string",
	//			"name":"js",
	//			"text":"Javascript 脚本字串。"
	//		},
	//		{
	//			"type":"string",
	//			"name":"[name]",
	//			"text":"这个名称用于调试时候显示的文件名。"
	//		}
	//	],
	//	"return":{
	//		"type":"any",
	//		"text":"返回脚本执行结果。"
	//	},
	//	"example":[
	//		"run('new Function(a,b){return a+b;}','test');",
	//		"//运行结果返回一个函数。"
	//	]
	//}//*
	Handle<Value> loadJsCode(const Arguments& args){
		HandleScope store;
		TryCatch err;

		Handle<String> js;
		Handle<Value> name;
		if(args.Length()>0)
			js = args[0]->ToString();
		if(args.Length()>1)
			name = args[1];
		Local<Script> script = Script::Compile(args[0]->ToString(),name);
		while(!script.IsEmpty()){
			Local<Value> result = script->Run(); 
			if(result.IsEmpty()) break;
			return store.Close(result);
		}
		ReportError(err);
		return Undefined();
	}
void debuggerListener(DebugEvent event,
                       Handle<Object> exec_state,
                       Handle<Object> event_data,
                       Handle<Value> data)
{
    printf("************************ V8 debugger ***********************\r\n");

    HandleScope handleScope;

    Local<String> source = String::New(
        "temp = function (exec_state) { "
        "   log(WARNING, 'halp now'); "
        "   return serializeJSON(exec_state); "
        "} "
    );
    Local<Script> code = Script::Compile(source);
    Local<Value> result = code->Run();
//    printV8Value(result, true);
    assert(result->IsObject());
    Local<Object> obj = result->ToObject();
    assert(obj->IsFunction());
    Local<Function> func = Function::Cast(*obj);
    Handle<Value> output = Debug::Call(func, exec_state);
    printV8Value(output, true);


    printV8Value(exec_state, true);
    printV8Value(event_data, true);
    printV8Value(data, true);

/*

    Local<Object> _func = obj->Get(String::New(funcName.c_str()))->ToObject();
    assert(_func->IsFunction());

    Local<Function> func = Function::Cast(*_func);
*/


    assert(0);
}
Beispiel #16
0
Handle<Value> V8Util::executeString(Handle<String> source, Handle<Value> filename)
{
	HandleScope scope;
	TryCatch tryCatch;

	Local<Script> script = Script::Compile(source, filename);
	if (script.IsEmpty()) {
		LOGF(TAG, "Script source is empty");
		reportException(tryCatch, true);
		return Undefined();
	}

	Local<Value> result = script->Run();
	if (result.IsEmpty()) {
		LOGF(TAG, "Script result is empty");
		reportException(tryCatch, true);
		return Undefined();
	}

	return scope.Close(result);
}
Beispiel #17
0
		Handle<Value> evalScript(const Arguments& args) {
			if (args.Length() < 2) {
				return ThrowException(Exception::TypeError(String::New("evalScript takes 2 arguments.")));
			}

			TryCatch tc;
			Local<Script> compiled = Script::Compile(args[0]->ToString(), args[1]->ToString());
			
			if (compiled.IsEmpty()) {
				return tc.ReThrow();
			}
			
			Handle<Value> value = compiled->Run();
			
			if (value.IsEmpty()) {
				return tc.ReThrow();
			}
			
			return value;
		
		}
Beispiel #18
0
		Handle<Value> evalInContext(const Arguments& args) {
			if (args.Length() < 3) {
				return ThrowException(Exception::TypeError(String::New("evalInContext takes 3 arguments.")));
			}
			
			if (!args[1]->IsObject()) {
				return ThrowException(Exception::TypeError(String::New("evalInContext expects an object as second argument.")));
			}
			
			HandleScope scope;
			
			Persistent<Context> context = Context::New();
			Context::Scope context_scope(context);

			Local<Object> global = context->Global();

			Local<Object> jscontext = args[1]->ToObject()->Clone();
			Local<Array> names = jscontext->GetOwnPropertyNames();
			for (int i = 0; i < names->Length(); i++) {
				global->Set(names->Get(i), jscontext->Get(names->Get(i)));
			}

			TryCatch tc;
			
			Local<Script> compiled = Script::Compile(args[0]->ToString(), args[2]->ToString());
			
			if (compiled.IsEmpty()) {
				return tc.ReThrow();
			}
			
			Handle<Value> value = compiled->Run();
			
			if (value.IsEmpty()) {
				return tc.ReThrow();
			}

			
			return scope.Close(value);
		}
Beispiel #19
0
static void
gum_script_do_load (GumScriptTask * task,
                    gpointer source_object,
                    gpointer task_data,
                    GCancellable * cancellable)
{
  GumScript * self = GUM_SCRIPT (source_object);
  GumScriptPrivate * priv = self->priv;

  {
    Locker locker (priv->isolate);
    Isolate::Scope isolate_scope (priv->isolate);
    HandleScope handle_scope (priv->isolate);

    if (priv->code == NULL)
    {
      gboolean created;

      created = gum_script_create_context (self, NULL);
      g_assert (created);
    }

    if (!priv->loaded)
    {
      priv->loaded = TRUE;

      ScriptScope scope (self);

      gum_script_bundle_run (gum_script_get_platform ()->GetUserRuntime ());

      Local<Script> code (Local<Script>::New (priv->isolate, *priv->code));
      code->Run ();
    }
  }

  gum_script_task_return_pointer (task, NULL, NULL);
}
Beispiel #20
0
void* worker_routine(void *vdbc) {

    struct dbcontext * dbc = (struct dbcontext *) vdbc;
    
    //allocate array for objects that will be automatically removed after 
    th_alloc_array(1000);
    
    //  Socket to talk to dispatcher
    void *receiver = zmq_socket (dbc->context, ZMQ_REP);
    zmq_connect (receiver, "inproc://workers");

    //Initialize our Isoloate
    Isolate *isolate = Isolate::New();
    if(!isolate)
    {
        cout << "Failed to initialize Isolate, we can't work";
        return 0;
    }
    
    Locker lock(isolate);
    Isolate::Scope isolateScope(isolate);
    HandleScope scope;
    
    Local<ObjectTemplate> globals = ObjectTemplate::New();
    
#define SETGLOB(name) globals->Set(String::New(""#name), FunctionTemplate::New(name));

    globals->Set(String::New("addnum"), FunctionTemplate::New(addnum));
    SETGLOB(print)
    
    globals->Set(String::New("put"), FunctionTemplate::New(put));
    globals->Set(String::New("get"), FunctionTemplate::New(get));
    globals->Set(String::New("del"), FunctionTemplate::New(del));
    
    //iterator
    globals->Set(String::New("it_del"), FunctionTemplate::New(it_del));
    globals->Set(String::New("it_new"), FunctionTemplate::New(it_new));
    globals->Set(String::New("it_first"), FunctionTemplate::New(it_first));
    globals->Set(String::New("it_last"), FunctionTemplate::New(it_last));
    globals->Set(String::New("it_seek"), FunctionTemplate::New(it_seek));
    globals->Set(String::New("it_next"), FunctionTemplate::New(it_next));
    globals->Set(String::New("it_prev"), FunctionTemplate::New(it_prev));
    globals->Set(String::New("it_valid"), FunctionTemplate::New(it_valid));
    globals->Set(String::New("it_key"), FunctionTemplate::New(it_key));
    globals->Set(String::New("it_val"), FunctionTemplate::New(it_val));

    //BITSET
    SETGLOB(bs_new)
    SETGLOB(bs_reset)
    SETGLOB(bs_set)
    SETGLOB(bs_logicalor)
    SETGLOB(bs_logicalnot)
    SETGLOB(bs_inplace_logicalnot)
    SETGLOB(bs_logicaland)
    SETGLOB(bs_sparselogicaland)
    SETGLOB(bs_tostring)
    SETGLOB(bs_makeSameSize)
    SETGLOB(bs_eq)
    SETGLOB(putbs)
    SETGLOB(getbs)
    SETGLOB(bs_it_new)
    SETGLOB(bs_it_end)
    SETGLOB(bs_it_isend)
    SETGLOB(bs_it_next)
    SETGLOB(bs_it_val)
    SETGLOB(bs_it_end)
    SETGLOB(bs_it_eq)
    
    
    Handle<Context> context = Context::New(NULL, globals);
    context->Enter();
    
    //Running init script with library functions
 
    if (dbc->init_code != NULL) {
        TryCatch try_catch;
        
        Local<String> source = String::New(dbc->init_code);
        Local<Script> script = Script::Compile(source);
        
        if(script.IsEmpty())
        {
            ReportException(&try_catch);
        } else {        
            // Run the function once and catch the error to generate machine code
            Local<Value> result = script->Run();
        }
        
    }
        
    while (1) {
        
        zmq_msg_t req;
        int rc = zmq_msg_init (&req);
        assert (rc == 0);
        rc = zmq_recv (receiver, &req, 0);
        assert (rc == 0);
        
        zmq_msg_t reply;
        //rc = zmq_msg_init_size (&reply, 200);
        //assert (rc == 0);

//test mq speed only
#if 0
        
        rc = zmq_msg_init_size (&reply, 200);
        assert (rc == 0);
        rc = zmq_msg_copy (&reply, &req);
        assert (rc == 0);
        rc = zmq_send (receiver, &reply, 0); 
        assert (rc == 0);
        
        //s_sleep(1);
        
        zmq_msg_close (&req);
        zmq_msg_close (&reply);
        continue;
#endif

        //std::cout << "thread: " << pthread_self() << " Received script: " << (char*) zmq_msg_data(&req) << std::endl;

        //leveldb::Status s;
 
 #if 1
        Context::Scope contextScope(context);
        
        // Compile a function which will keep using the stack until v8 cuts it off
        
        //Local<Script> script = Local<Script>::New(Script::Compile(String::New( (char*) zmq_msg_data(&req) )));
        
        TryCatch try_catch;
        
        Local<String> source = String::New((char*) zmq_msg_data(&req));
        Local<Script> script = Script::Compile(source);
        
        if(script.IsEmpty())
        {
            ReportException(&try_catch);
            
            String::Utf8Value error(try_catch.Exception());
            v8::Handle<v8::Message> message = try_catch.Message();
            int line_num = 0;
            int col_num = 0;
            
            if (message.IsEmpty()) {
                
            }else {
                line_num = message->GetLineNumber();
                col_num = message->GetStartColumn();
            }
            
            int mess_size = error.length()+100;
            rc = zmq_msg_init_size (&reply, mess_size);
            assert (rc == 0);

            //cerr << "compile error line: " << " message: " << *error << endl;
            snprintf ((char*) zmq_msg_data (&reply), mess_size, "2; {res: 'COMPILE ERROR', line: %d, col: %d, message: '%s'}", line_num, col_num, *error);
        }
        else {        

            // Run the function once and catch the error to generate machine code
            Local<Value> result = script->Run();
                    
            if (try_catch.HasCaught()) {
                //TODO: escape string
                String::Utf8Value message(try_catch.Exception());
                int mess_size = message.length()+100;
                rc = zmq_msg_init_size (&reply, mess_size);
                assert (rc == 0);

                std::cout <<"exception->" <<*message <<"\n";
                snprintf ((char*) zmq_msg_data (&reply), mess_size, "1; {res: 'ERROR', message: '%s'}", *message);
            }
            else {
                //TODO: escape string
                String::Utf8Value message(result->ToString());
                int mess_size = message.length()+2;
                rc = zmq_msg_init_size (&reply, mess_size);
                assert (rc == 0);

                snprintf ((char*) zmq_msg_data (&reply), mess_size, " %s", *message);
            }
        }        

#endif
                
        
        /* Send the message to the socket */
        rc = zmq_send (receiver, &reply, 0); 
        assert (rc == 0);
        
        //s_sleep(1);
        
        zmq_msg_close (&req);
        zmq_msg_close (&reply);
        
        free_objects();
    }
    
    context->Exit();    
    //printf("Iter: %d , Result: %ld ; from thread: %ld \n", i, res, tid);
        
    //context.Dispose();
    
    //script.Dispose();
    
    Unlocker unlock(isolate);
    
    //isolate->Exit();
    //isolate->Dispose();

    zmq_close (receiver);
    return NULL;
}
Beispiel #21
0
 v8::Local<v8::Value> JSDeviceTest::runScript(const std::string &script) {
     Local<String> source = String::NewFromUtf8(isolate, script.c_str());
     Local<Script> jsScript = Script::Compile(source);
     return jsScript->Run();
 }
Beispiel #22
0
inline bool runscript(const char *source) {
    Local<Script> script = Script::Compile(String::New(source));
    Local<Value> result = script->Run();
    return result->BooleanValue();
}
Beispiel #23
0
bool V8Engine::runScript(const char* js, std::string& result)
{
   bool rval = true;

   // lock V8 while script is running
   Locker locker;

   // Create a stack-allocated handle scope.
   HandleScope handle_scope;

   // Enter the engine context for compiling and running the script.
   Context::Scope context_scope(mContext);

   // We're just about to compile the script; set up an error handler to
   // catch any exceptions the script might throw.
   TryCatch tryCatch;

   // Create a string containing the JavaScript source code.
   Local< ::v8::String> source = ::v8::String::New(js);

   // Script containing the compiled source.
   Local< ::v8::Script> script;

   // Result of the script after it has been run.
   Local<Value> resultval;

   if(rval)
   {
      // Compile the source code.
      script = ::v8::Script::Compile(source);
      if(script.IsEmpty())
      {
         String::Utf8Value error(tryCatch.Exception());
         // The script failed to compile
         ExceptionRef e = new rt::Exception(
            "Script failed to compile.",
            EXCEPTION_PREFIX ".CompileError");
         e->getDetails()["error"] = *error;
         rt::Exception::set(e);
         rval = false;
      }
   }


   if(rval)
   {
      // Run the script to get the result.
      resultval = script->Run();
      if(resultval.IsEmpty())
      {
         String::Utf8Value error(tryCatch.Exception());
         // The script failed to run
         ExceptionRef e = new rt::Exception(
            "Script failed to run.",
            EXCEPTION_PREFIX ".RunError");
         e->getDetails()["error"] = *error;
         rt::Exception::set(e);
         rval = false;
      }
   }

   if(rval)
   {
      ::v8::String::AsciiValue ascii(resultval);
      result = *ascii;
   }

   return rval;
}
Beispiel #24
0
int main(int argc, char* argv[]) {
	SDL_Init(SDL_INIT_EVERYTHING);

	V8::Initialize();
	isolate = Isolate::GetCurrent();
	HandleScope handle_scope(isolate);
	
	Persistent<Context> context = Context::New();
    Context::Scope context_scope(context);

	Local<Object> global = context->Global();
	
	Local<Object> sphere = Object::New();
	
	global->Set(String::New("sphere"), sphere);
	
	API::fs::Init(sphere);
	API::engine::Init(sphere);
	API::graphics::Init(sphere);
	API::events::Init(sphere);
	
	Local<Object> engine = sphere->Get(String::New("engine"))->ToObject();
	
	engine->Set(String::New("argc"), Integer::New(argc));
	Local<Array> js_argv = Array::New(argc);
	
	for (int i = 0; i < argc; i++) {
		js_argv->Set(Number::New(i), String::New(argv[i]));
	}

	engine->Set(String::New("argv"), js_argv);
	
	const char* gameScript = Files::readTextFile("system/sphere.js");
	
	if (gameScript == NULL) {
		debug("Error loading bootstrap script.\n");
		exit(1);
	}
	
	TryCatch trycatch;
	Local<Script> compiled = Script::Compile(String::New(gameScript), String::New("system/sphere.js"));
	
	if (compiled.IsEmpty()) {
		Handle<Value> exception = trycatch.Exception();
		String::Utf8Value exception_str(exception);
		printf("Exception: %s\n", *exception_str);
		exit(1);
	}
	
	Handle<Value> value = compiled->Run();
	
	if (value.IsEmpty()) {
		Handle<Object> exception = trycatch.Exception()->ToObject();
		Handle<String> str;
		if (exception->Has(String::New("stack"))) {
			str = exception->Get(String::New("stack"))->ToString();
		}
		else {
			str = exception->ToString();
		}
		String::Utf8Value exception_str(str);
		printf("Exception: %s\n", *exception_str);
		exit(1);
	}
	
	return 0;
}
//事件循环
//TAGG核心代码程序
static void eventLoop (typeThread* thread) {
  thread->isolate->Enter(); //进入 isolate
  thread->context= Context::New(); //创建一个sandbox沙箱用来执行js代码,他的上下文将有他自己控制
  thread->context->Enter(); //进入这个上下文
  
  {
    HandleScope scope1;
    
    //返回这个分离的沙箱内的全局对象
    //Local< Object >   Global ()
    Local<Object> global= thread->context->Global();

	global->Set(String::NewSymbol("_Global"), global);
    
	//将puts方法设置到全局中去,代替console.log
	Handle<Object> console_obj = Object::New();
	console_obj->Set(String::New("log"), FunctionTemplate::New(Puts)->GetFunction());
	

    global->Set(String::New("console"), console_obj);
	global->Set(String::New("require"), FunctionTemplate::New(require_file)->GetFunction(), ReadOnly);
  
	
	//定义一个thread对象到全局变量中
    Local<Object> threadObject= Object::New();
    global->Set(String::NewSymbol("thread"), threadObject);
    
    //设置这个全局对象thread的id和emit属性
    threadObject->Set(String::NewSymbol("id"), Number::New(thread->id));
    threadObject->Set(String::NewSymbol("emit"), FunctionTemplate::New(threadEmit)->GetFunction());
    threadObject->Set(String::NewSymbol("end"), FunctionTemplate::New(threadEnd)->GetFunction());
    threadObject->Set(String::New("_TAGG_RES"), Undefined()); //返回的全局变量字符串
    
	//将global对象放入全局global中,每次都会初始化
	Handle<Object> user_global = Object::New();
	global->Set(String::NewSymbol("global"), user_global);
	global->Set(String::NewSymbol("Global"), user_global);
	
	
	//让threadObject继承event接口
    Local<Object> dispatchEvents= Script::Compile(String::New(kEvents_js))->Run()->ToObject()->CallAsFunction(threadObject, 0, NULL)->ToObject();
	
	//获得下个事件循环的函数
    Local<Object> dispatchNextTicks= Script::Compile(String::New(kThread_nextTick_js))->Run()->ToObject();
	


    //获得thread_nextTick.js中定义的 next回调函数的数组
    Local<Array> _ntq= (v8::Array*) *threadObject->Get(String::NewSymbol("_ntq"));
   

    double nextTickQueueLength= 0; //事件循环次数
    long int ctr= 0;
    
    //SetFatalErrorHandler(FatalErrorCB);
    
    while (!thread->sigkill) { //当线程的信号不为kill时,则循环执行下面代码
      typeJob* job;
      typeQueueItem* qitem;
      
      {//while循环代码块


        HandleScope scope2;
        //v8的TryCatch类,
        //一个外部的异常控制类
        TryCatch onError;    
        String::Utf8Value* str;//临时保存js源代码的指针
        Local<String> source; //保存js源代码字符串
        Local<Script> script; //保存js源代码
        Local<Value> resultado; //保存js源代码执行的return 结果值
        
        
        while ((qitem= queue_pull(&thread->inQueue))) { //当队列中有项目时,循环执行如下代码
          
          job= (typeJob*) qitem->asPtr; //队列中的任务
          
          if ((++ctr) > 2e3) { //如果ctr 大于 2*10的3次方
            ctr= 0;
            V8::IdleNotification(); //强制V8进行GC while(!V8::IdleNotification()) {};
          }
          
          if (job->jobType == kJobTypeEval) { //如果执行的任务
            //Ejecutar un texto
            
            if (job->typeEval.useStringObject) { //如果是eval方法传入的参数进来的
              str= job->typeEval.scriptText_StringObject;
              source= String::New(**str, (*str).length()); 
              delete str; //删除str指针
            }
            else { //如果是load js 文件进来的
              source= String::New(job->typeEval.scriptText_CharPtr);//创建js源代码string,
              free(job->typeEval.scriptText_CharPtr); //释放
            }
            
            script= Script::New(source); //将源代码字符串,转存为js代码
            
            //这里进行判断,如果上下问里的js代码执行抛出了异常,则本次循环将不执行js代码了
            
			//将global对象放入全局global中,每次都会初始化
			Handle<Object> user_global = Object::New();
			global->Set(String::NewSymbol("global"), user_global);
			global->Set(String::NewSymbol("Global"), user_global);
            
			if (!onError.HasCaught()){  //如果没有错误


				//Local<Object> obj = job->buffer->Clone();
				//resultado = String::NewSymbol("id");
				//将char* 的job->buf_ptr又转换为Buffer指针
				//node::Buffer *buf = node::Buffer::New(job->buf_ptr, job->buf_len); 					
				//Local<Object> buf_obj = External::Wrap(buf)->ToObject();				
				threadObject->Set(String::New("_TAGG_RES"), Undefined()); //返回的全局变量字符串

				Local<Object> buf_obj = Object::New();
				

				if(job->buf_ptr){
					buf_obj->SetHiddenValue(String::New("buffer"), String::New(job->buf_ptr, job->buf_len));
					buf_obj->SetHiddenValue(String::New("isBuffer"),Number::New(1));
				}
				else{
					buf_obj->SetHiddenValue(String::New("isBuffer"),Number::New(0));
				}

				buf_obj->Set(String::NewSymbol("toString"), FunctionTemplate::New(Buffer_toString)->GetFunction());
				
				threadObject->Set(String::NewSymbol("buffer"),  buf_obj);				
				
				global->Set(String::NewSymbol("__dirname"), String::New(**job->__dirname));
				global->SetPointerInInternalField(0, job->__dirname);
				  

				script->Run(); //执行js代码,返回值为 resultado
			    resultado = threadObject->Get(String::New("_TAGG_RES"));
				

		   }//如果没有错误

            if (_ntq->Length() && !onError.HasCaught()) { //当有错误时,不执行异步
            
                  if ((++ctr) > 2e3) {
                      ctr= 0;
                      V8::IdleNotification();//强制GC
                  }

                  resultado = dispatchNextTicks->CallAsFunction(global, 0, NULL); //调用线程内的 nexttick
			
            }

            if (job->typeEval.tiene_callBack) { //如果执行任务具有回调函数
              //如果有错误,则 job->typeEval.error 是1,否则为0;
              job->typeEval.error= onError.HasCaught() ? 1 : 0; 
			  if(job->typeEval.error){
					 _ntq= Array::New();
			  }
              //如果有异常,则返回值 resultado 为异常内容,否则为函数返回内容
              job->typeEval.resultado= new String::Utf8Value(job->typeEval.error ? onError.Exception() : threadObject->Get(String::New("_TAGG_RES")));
              //执行完毕,将qtiem项丢入线程的出列队列
              queue_push(qitem, &thread->outQueue);
              // wake up callback
              //丢入异步队列

              uv_async_send(&thread->async_watcher);

            }
            else { //如果没有回调函数,则把改item丢入闲置任务队列
              queue_push(qitem, freeJobsQueue);
            }

            if (onError.HasCaught()){
				nextTickQueueLength= 1;
				onError.Reset(); //如果此次执行有错误,则清空
			}
			else{
				 nextTickQueueLength= resultado->NumberValue();
			}

     }//如果执行的任务


          else if (job->jobType == kJobTypeEvent) { //如果是事件的任务
            //Emitir evento.
            
            Local<Value> args[2]; //定义一个数组长度为2,保存 Local<Value> 类型的值
            str= job->typeEvent.eventName; //获得事件名字
            args[0]= String::New(**str, (*str).length()); //数组第一个保存event事件的名字,保存为local<string>类型
            delete str;
            
            Local<Array> array= Array::New(job->typeEvent.length);
            args[1]= array; //设置参数长度
            
            int i= 0;
            while (i < job->typeEvent.length) { //将参数保存入Local<Array>
              str= job->typeEvent.argumentos[i];
              array->Set(i, String::New(**str, (*str).length()));
              delete str;
              i++;
            }
            
            free(job->typeEvent.argumentos); //释放任务的 typeEvent 内存
            queue_push(qitem, freeJobsQueue); //将本项丢入闲置任务队列
            dispatchEvents->CallAsFunction(global, 2, args); //执行回调函数,并且加入参数
          



          }//如果是事件的任务


        }//while2 结束

	    
		/* 
		if (_ntq->Length()) { //执行异步
				  
				   if ((++ctr) > 2e3) {
                      ctr= 0;
                      V8::IdleNotification();//强制GC
                  }

                  resultado = dispatchNextTicks->CallAsFunction(global, 0, NULL); //调用线程内的 nexttick
                  if (onError.HasCaught()) { //如果有错误
                      nextTickQueueLength= 1; //nexttick队列长度为1
                      onError.Reset();
                  }
                  else {
                      nextTickQueueLength= resultado->NumberValue();
                  }
            }
		*/



      if (thread->inQueue.length) continue;
      if (thread->sigkill) break; //如果收到线程杀死信号,条春循环
      
      pthread_mutex_lock(&thread->IDLE_mutex); //锁住线程
      if (!thread->inQueue.length) { //如果线程的入队列长度为0
        thread->IDLE= 1; //则把线程设置为闲置
        pthread_cond_wait(&thread->IDLE_cv, &thread->IDLE_mutex); //休眠线程
        thread->IDLE= 0;
      }
      pthread_mutex_unlock(&thread->IDLE_mutex); //解锁线程




    }//while 结束



  }
  
  thread->context.Dispose(); //摧毁上下文
}

}
Beispiel #26
0
INT32_MAIN_INT32_ARGC_TCHAR_ARGV()
{
	GEngineLoop.PreInit(ArgC, ArgV);
	UE_LOG(LogUnrealNode, Display, TEXT("Hello World"));

	// Initialize V8.
	V8::InitializeICU();
	//V8::InitializeExternalStartupData(ArgV[0]);
	Platform* platform = platform::CreateDefaultPlatform();
	V8::InitializePlatform(platform);
	V8::Initialize();

	// Create a new Isolate and make it the current one.
	ArrayBufferAllocator allocator;
	Isolate::CreateParams create_params;
	create_params.array_buffer_allocator = &allocator;
	Isolate* isolate = Isolate::New(create_params);
	{
		Isolate::Scope isolate_scope(isolate);

		// Create a stack-allocated handle scope.
		HandleScope handle_scope(isolate);

		// Create a new context.
		Local<Context> context = Context::New(isolate);

		// Enter the context for compiling and running the hello world script.
		Context::Scope context_scope(context);

		// Create a string containing the JavaScript source code.
		Local<String> source =
			String::NewFromUtf8(isolate, "'Hello World' + ' from JavaScript'",
				NewStringType::kNormal).ToLocalChecked();

		// Compile the source code.
		Local<Script> script = Script::Compile(context, source).ToLocalChecked();

		// Run the script to get the result.
		Local<Value> result = script->Run(context).ToLocalChecked();

		// Convert the result to an UTF8 string and print it.
		String::Utf8Value utf8(result);
		printf("%s\n", *utf8);

	}

	// Dispose the isolate and tear down V8.
	isolate->Dispose();
	V8::Dispose();
	V8::ShutdownPlatform();
	delete platform;



	//uv_idle_t idler;

	//uv_idle_init(uv_default_loop(), &idler);
	//uv_idle_start(&idler, wait_for_a_while);

	//printf("Idling...\n");
	//uv_run(uv_default_loop(), UV_RUN_DEFAULT);

	//uv_loop_close(uv_default_loop());


	return 0;


}