int
ruby_run_node(void *n)
{
int status;
if (!ruby_executable_node(n, &status)) {
ruby_cleanup(0);
return status;
}
rb_require_libraries();
rb_vm_run(RSTRING_PTR(rb_progname), (NODE *)n, NULL, false);
return ruby_cleanup(0);
}
void RubyModule::Stop()
{
host->script()->RemoveInterpreter(&interpreter);
RubyModule::instance_ = NULL;
ruby_cleanup(0);
}
int main(int argc, char *argv[])
{
int ret;
const char *script = argv[1];
if (script == NULL) {
script =
//"alphadraw.rb";
"alpha.rb";
//"aadraw.rb";
//"test_fib.rb";
}
ruby_debug = Qtrue;
ruby_verbose = Qtrue;
ruby_init();
ruby_init_loadpath();
ruby_script(script);
rb_load_file(script);
ret = ruby_cleanup(ruby_exec());
//exit(ret);
return(ret);
}
static void rpmrubyFini(void * _ruby)
/*@globals fileSystem @*/
/*@modifies *_ruby, fileSystem @*/
{
rpmruby ruby = _ruby;
/* XXX FIXME: 0x40000000 => xruby.c wrapper without interpreter. */
if (ruby->flags & 0x40000000) {
ruby->main_coroutine_lock = yarnFreeLock(ruby->main_coroutine_lock);
ruby->ruby_coroutine_lock = yarnFreeLock(ruby->ruby_coroutine_lock);
ruby->zlog = rpmzLogDump(ruby->zlog, NULL);
ruby->stack = _free(ruby->stack);
ruby->nstack = 0;
_rpmrubyI = NULL;
} else {
#if defined(WITH_RUBYEMBED)
ruby_finalize();
ruby_cleanup(0);
#endif
}
ruby->I = NULL;
ruby->flags = 0;
ruby->av = argvFree(ruby->av);
ruby->ac = 0;
}
void RhoRubyStop()
{
//TBD: clenup framework, etc.
ruby_cleanup(0);
rb_mKernel = 0;
}
static void mriBindingExecute()
{
/* Normally only a ruby executable would do a sysinit,
* but not doing it will lead to crashes due to closed
* stdio streams on some platforms (eg. Windows) */
int argc = 0;
char **argv = 0;
ruby_sysinit(&argc, &argv);
ruby_setup();
rb_enc_set_default_external(rb_enc_from_encoding(rb_utf8_encoding()));
Config &conf = shState->rtData().config;
if (!conf.rubyLoadpaths.empty())
{
/* Setup custom load paths */
VALUE lpaths = rb_gv_get(":");
for (size_t i = 0; i < conf.rubyLoadpaths.size(); ++i)
{
std::string &path = conf.rubyLoadpaths[i];
VALUE pathv = rb_str_new(path.c_str(), path.size());
rb_ary_push(lpaths, pathv);
}
}
RbData rbData;
shState->setBindingData(&rbData);
BacktraceData btData;
mriBindingInit();
STEAMSHIM_init();
_rb_define_module_function(rb_mKernel, "_steam_achievement_unlock",
_steamAchievementUnlock);
std::string &customScript = conf.customScript;
if (!customScript.empty())
runCustomScript(customScript);
else
runRMXPScripts(btData);
VALUE exc = rb_errinfo();
if (!NIL_P(exc) && !rb_obj_is_kind_of(exc, rb_eSystemExit))
showExc(exc, btData);
ruby_cleanup(0);
STEAMSHIM_deinit();
shState->rtData().rqTermAck.set();
}
static void * rpmrubyThread(void * _ruby)
{
rpmruby ruby = _ruby;
rpmzLog zlog = ruby->zlog;
int i;
Trace((zlog, "-- %s: running", __FUNCTION__));
_rpmruby_ruby_to_main(ruby, Qnil);
for (i = 0; i < 2; i++)
_rpmruby_ruby_to_main(ruby, Qnil);
{
VALUE variable_in_this_stack_frame;
uint8_t * b = ruby->stack;
uint8_t * e = b + ruby->nstack;
/* Start up the ruby interpreter. */
Trace((zlog, "-- %s: interpreter starting", __FUNCTION__));
ruby_sysinit(&ruby->ac, (char ***) &ruby->av);
ruby_bind_stack((VALUE *)b, (VALUE *)e);
ruby_init_stack(&variable_in_this_stack_frame);
ruby_init();
ruby_init_loadpath();
/* allow Ruby script to relay */
rb_define_module_function(rb_mKernel, "relay_from_ruby_to_main",
relay_from_ruby_to_main, 0);
Trace((zlog, "-- %s: interpreter started", __FUNCTION__));
/* Run file.rb arguments. */
for (i = 1; i < ruby->ac; i++) {
if (*ruby->av[i] == '-') /* XXX FIXME: skip options. */
continue;
Trace((zlog, "-- %s: require '%s' begin", __FUNCTION__, ruby->av[i]));
rpmrubyRunThreadFile(ruby, ruby->av[i], NULL);
Trace((zlog, "-- %s: require '%s' end", __FUNCTION__, ruby->av[i]));
}
/* Terminate the ruby interpreter. */
Trace((zlog, "-- %s: interpreter terminating", __FUNCTION__));
ruby_finalize();
ruby_cleanup(0);
Trace((zlog, "-- %s: interpreter terminated", __FUNCTION__));
}
/* Report interpreter end to main. */
ruby->more = 0;
/* Permit main thread to run without blocking. */
yarnRelease(ruby->main_coroutine_lock);
Trace((zlog, "-- %s: ended", __FUNCTION__));
return NULL;
}
int proxenet_ruby_destroy_vm(interpreter_t* interpreter)
{
ruby_cleanup(0);
interpreter->ready = false;
interpreter->vm = NULL;
return 0;
}
/* cleanup interpreter */
void shutdown_myruby(void)
{
ruby_cleanup(0);
#if USE_RUBYVERSION < 19
ruby_finalize();
#else
/* segfaults with ruby19 */
#endif
}
void RubyModule::Stop()
{
KObjectRef global = this->host->GetGlobalObject();
global->Set("Ruby", Value::Undefined);
Script::GetInstance()->RemoveScriptEvaluator(this->binding);
this->binding = NULL;
RubyModule::instance_ = NULL;
ruby_cleanup(0);
}
void shutdown(int exit_code)
{
free_all();
ruby_cleanup(0);
if(running == false)
{
return;
}
running = false;
}
int main(int argc, char **argv) {
ruby_sysinit(&argc, &argv); {
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
ruby_script("testing!!!!");
rb_gv_set("$brent", ID2SYM(rb_intern("c_defined_symbol")));
int state;
rb_protect(require_wrap, 0, &state);
}
return ruby_cleanup(0);
}
int main(int argc, char **argv) {
VALUE result;
ruby_sysinit(&argc, &argv);
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
rb_require("sum"); // or sum.rb
rb_eval_string("$summer = Summer.new");
rb_eval_string("$result = $summer.sum(10)");
result = rb_gv_get("result");
printf("Result = %d\n", NUM2INT(result));
return ruby_cleanup(0);
}
void hello_from_ruby()
{
/* construct the VM */
if (ruby_setup())
{
fprintf(stderr, "Failed to init Ruby VM\n");
}
rb_require("./test");
rb_funcall(rb_mKernel, rb_intern("some_ruby_method"), 0, NULL);
/* destruct the VM */
ruby_cleanup(0);
}
int
weechat_plugin_end (struct t_weechat_plugin *plugin)
{
/* unload all scripts */
ruby_quiet = 1;
plugin_script_end (plugin, &ruby_scripts, &weechat_ruby_unload_all);
ruby_quiet = 0;
ruby_cleanup (0);
/* free some data */
if (ruby_action_install_list)
free (ruby_action_install_list);
if (ruby_action_remove_list)
free (ruby_action_remove_list);
if (ruby_action_autoload_list)
free (ruby_action_autoload_list);
return WEECHAT_RC_OK;
}
int main()
{
// 1. init interpreter
ruby_init();
ruby_init_loadpath();
//ruby_script("embed.rb");
// 2. load global objects
Init_SysInfo();
// 3. run script
// int state = eval_buffer("puts \"kamin babo\"\nprint $hardware");
// int state = eval_file("/Users/yielding/test/rb/embed/embed.rb");
int state = eval_file("embed.rb");
if (state)
printf("error\n");
print_array(hardware_list);
// 4. finalize
// ruby_finalize();
ruby_cleanup(0);
}
static void mriBindingExecute()
{
ruby_setup();
rb_enc_set_default_external(rb_enc_from_encoding(rb_utf8_encoding()));
RbData rbData;
shState->setBindingData(&rbData);
mriBindingInit();
std::string &customScript = shState->rtData().config.customScript;
if (!customScript.empty())
runCustomScript(customScript);
else
runRMXPScripts();
VALUE exc = rb_errinfo();
if (!NIL_P(exc) && !rb_obj_is_kind_of(exc, rb_eSystemExit))
showExc(exc);
ruby_cleanup(0);
shState->rtData().rqTermAck = true;
}
void crb_cleanup() {
ruby_cleanup(0);
}
void RhoRubyStop()
{
//TBD: clenup framework, etc.
ruby_cleanup(0);
}
void
ruby_stop(int ex)
{
exit(ruby_cleanup(ex));
}
static void ruby_coroutine_body(
#ifdef DEMONSTRATE_PTHREAD
void* dummy_argument_that_is_not_used
#endif
)
{
#ifdef DEMONSTRATE_PTHREAD
printf("Coroutine: waiting for initial asynchronous relay from main\n");
relay_from_ruby_to_main(Qnil);
#endif
printf("Coroutine: begin\n");
int i;
for (i = 0; i < 2; i++)
{
printf("Coroutine: relay %d\n", i);
relay_from_ruby_to_main(Qnil);
}
printf("Coroutine: Ruby begin\n");
#ifdef HAVE_RUBY_SYSINIT
int argc = 0;
char** argv = {""};
ruby_sysinit(&argc, &argv);
#endif
{
#ifdef HAVE_RUBY_BIND_STACK
ruby_bind_stack(
/* lower memory address */
(VALUE*)(ruby_coroutine_stack),
/* upper memory address */
(VALUE*)(ruby_coroutine_stack + ruby_coroutine_stack_size)
);
#endif
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
/* allow Ruby script to relay */
rb_define_module_function(rb_mKernel, "relay_from_ruby_to_main",
relay_from_ruby_to_main, 0);
/* run the "hello world" Ruby script */
printf("Ruby: require 'hello' begin\n");
ruby_coroutine_body_require("./hello.rb");
printf("Ruby: require 'hello' end\n");
ruby_cleanup(0);
}
printf("Coroutine: Ruby end\n");
printf("Coroutine: end\n");
ruby_coroutine_finished = true;
relay_from_ruby_to_main(Qnil);
#ifdef DEMONSTRATE_PTHREAD
pthread_exit(NULL);
#endif
}
static int mod_cleanup(lua_State *l)
{
ruby_cleanup(0);
return 0;
}
