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;
}
static void destroy_rb(language_interpreter_t* li)
{
rb_internal_t*rb = (rb_internal_t*)li->internal;
if(--rb_reference_count == 0) {
ruby_finalize();
}
}
int initrb_start(int argc, char **argv, initrb_boot_fn_t boot) {
int ret = 0;
{
/* Initialize the stack */
RUBY_INIT_STACK;
/* Initialize the interpreter */
ruby_init();
/* Initialize the loadpath */
ruby_init_loadpath();
/* We're initrb */
ruby_script("initrb");
/* Set the argv */
ruby_set_argv(argc, argv);
/* Boot statics */
initrb_boot_statics();
/* Run */
ret = boot(argc, argv);
/* Finalize the interpreter */
ruby_finalize();
}
return ret;
}
static void run()
{
VALUE stack_start;
VALUE code;
void Init_stack _((VALUE*));
Init_stack(&stack_start);
code = compile(eruby_filename);
if (eruby_sync) {
print_headers(-1);
}
else {
replace_stdout();
}
code = eval(code, eruby_filename);
if (eruby_mode == MODE_FILTER &&
(RTEST(ruby_debug) || RTEST(ruby_verbose))) {
print_generated_code(stderr, code, 0);
}
rb_exec_end_proc();
if (!eruby_sync) {
flush_buffer();
}
ruby_finalize();
}
DWORD WINAPI rh_thread_proc(LPVOID lpParam)
{
DWORD dwWaitResult;
int must_exit = 0;
#ifdef DEBUG_THREADS
rh_log("RubyHoldem thread %d starting\n", GetCurrentThreadId());
#endif
ruby_init();
rh_safe_call("rh_load_init_script", (rh_function)rh_init_module, Qnil);
while (!must_exit)
{
#ifdef DEBUG_THREADS
rh_log("RubyHoldem thread %d waiting for event...\n", GetCurrentThreadId());
#endif
dwWaitResult = WaitForSingleObject(rh_event_job, INFINITE);
switch (dwWaitResult)
{
// Event object was signaled
case WAIT_OBJECT_0:
#ifdef DEBUG_THREADS
rh_log("Event occured in RubyHoldem thread %d\n", GetCurrentThreadId());
#endif
switch(rh_event_type)
{
case RH_EXIT:
#ifdef DEBUG_THREADS
rh_log("Event is RH_EXIT\n");
#endif
must_exit = 1;
break;
case RH_PROCESS_MESSAGE:
#ifdef DEBUG_THREADS
rh_log("Event is RH_PROCESS_MESSAGE\n");
#endif
rh_process_message();
break;
}
break;
// An error occurred
default:
rh_log("RubyHoldem thread: Wait error (%d)\n", GetLastError());
return 0;
}
rh_job_done();
}
ruby_finalize();
#ifdef DEBUG_THREADS
rh_log("RubyHoldem thread %d finished\n", GetCurrentThreadId());
#endif
return 1;
}
/* cleanup interpreter */
void shutdown_myruby(void)
{
ruby_cleanup(0);
#if USE_RUBYVERSION < 19
ruby_finalize();
#else
/* segfaults with ruby19 */
#endif
}
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;
}
static void destroy_rb(language_t* li)
{
if(li->internal) {
rb_internal_t*rb = (rb_internal_t*)li->internal;
if(--rb_reference_count == 0) {
ruby_finalize();
}
free(rb);
}
free(li);
}
__attribute__ ((noreturn)) static void SysExit (
int isThread,
int num
) {
if (isThread) {
rb_protect(SysExit2,Qnil,NULL);
} else {
rb_protect(SysExit3,num,NULL);
ruby_finalize();
}
exit(num);
}
int main ( int argc, char ** argv) {
ruby_set_debug_option(getenv("RUBY_DEBUG"));
ruby_sysinit(&argc, &argv);
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
setbuf(stdout, NULL); // disable buffering
rb_protect( test_iseq, 0, & error);// call our stuff rb_protect'ed
perror("ERROR");
return ruby_run_node(ruby_options(argc, argv));
ruby_finalize();
return 0;
}
int
weechat_plugin_end (struct t_weechat_plugin *plugin)
{
/* make C compiler happy */
(void) plugin;
/* unload all scripts */
weechat_ruby_unload_all ();
ruby_finalize();
return WEECHAT_RC_OK;
}
RUBY_GLOBAL_SETUP
int main(int argc, char *argv[])
{
int status;
{
RUBY_INIT_STACK;
ruby_init();
ruby_script(argv[0]);
rb_protect((VALUE (*)(VALUE))rb_require, (VALUE)"./embedded_ruby.rb", &status);
// ruby_cleanup(0);
ruby_finalize();
};
return status;
}
int main(int argc, char *argv[]) {
HINSTANCE hDllInst = LoadLibrary(L"msvcrt-ruby220.dll");
typedef int(*rb_init)();
typedef int(*rb_eval_string_protect)(const char*, int*);
typedef int(*rb_finalize)();
rb_init ruby_init = (rb_init)GetProcAddress(hDllInst, "ruby_init");
rb_eval_string_protect ruby_eval_string_protect = (rb_eval_string_protect)GetProcAddress(hDllInst, "rb_eval_string_protect");
rb_finalize ruby_finalize = (rb_finalize)GetProcAddress(hDllInst, "ruby_finalize");
ruby_init();
ruby_eval_string_protect(argv[1], NULL);
ruby_finalize();
FreeLibrary(hDllInst);
}
static VALUE
rescue_callback(VALUE arg)
{
VALUE error;
VALUE e = rb_errinfo();
VALUE bt = rb_funcall(e, rb_intern("backtrace"), 0);
VALUE msg = rb_funcall(e, rb_intern("message"), 0);
bt = rb_ary_entry(bt, 0);
error = rb_sprintf("%"PRIsVALUE": %"PRIsVALUE" (%s)\n", bt, msg, rb_obj_classname(e));
rb_write_error(StringValuePtr(error));
rb_backtrace();
ruby_finalize();
exit(-1);
return Qnil;
}
// keep on looking at the modification date of the file 'embed.rb' and eval it if it changes
int main () {
time_t test_mod_time = 0;
struct stat attrib;
int load_function_sym;
VALUE file_name;
VALUE loader;
int count = 0;
// register stop_running
signal( SIGINT, stop_running );
ruby_init();
ruby_init_loadpath();
ruby_script("rubyk");
rb_require("embed_loader.rb");
file_name = rb_str_new2("embed.rb");
loader = rb_class_new_instance(0,0,rb_const_get(rb_cObject, rb_intern("Loader")));
load_function_sym = rb_intern("secure_load");
running = 1;
while(running) {
sleep(0.1);
count = count + 1;
// get attributes
stat("embed.rb", &attrib);
if (test_mod_time != attrib.st_mtime) {
printf("Finally a change (%i)\n", count);
count = 0;
test_mod_time = attrib.st_mtime;
rb_funcall(loader, load_function_sym, 1, file_name);
}
}
printf("\nbye...\n");
ruby_finalize();
exit(0);
}
/**
* Load a Ruby file then run the function corresponding to the service by
* passing the conf, inputs and outputs parameters by refernce as Ruby Hash.
*
* @param main_conf the conf maps containing the main.cfg settings
* @param request the map containing the HTTP request
* @param s the service structure
* @param real_inputs the maps containing the inputs
* @param real_outputs the maps containing the outputs
* @return SERVICE_SUCCEEDED or SERVICE_FAILED if the service run, -1
* if the service failed to load or throw error at runtime.
*/
int zoo_ruby_support(maps** main_conf,map* request,service* s,maps **real_inputs,maps **real_outputs){
#if RUBY_API_VERSION_MAJOR >= 2 || RUBY_API_VERSION_MINOR == 9
ruby_sysinit(&argc,&argv);
RUBY_INIT_STACK;
#endif
ruby_init();
maps* m=*main_conf;
maps* inputs=*real_inputs;
maps* outputs=*real_outputs;
map* tmp0=getMapFromMaps(*main_conf,"lenv","cwd");
char *ntmp=tmp0->value;
map* tmp=NULL;
ruby_init_loadpath();
ruby_script("ZOO_EMBEDDED_ENV");
VALUE klass=rb_define_module("Zoo");
rb_define_const(klass,"SERVICE_SUCCEEDED",INT2FIX(3));
rb_define_const(klass,"SERVICE_FAILED",INT2FIX(4));
typedef VALUE (*HOOK)(...);
rb_define_module_function(klass,"Translate",reinterpret_cast<HOOK>(RubyTranslate),-1);
rb_define_module_function(klass,"UpdateStatus",reinterpret_cast<HOOK>(RubyUpdateStatus),-1);
int error = 0;
ID rFunc=Qnil;
tmp=getMap(s->content,"serviceProvider");
if(tmp!=NULL){
#if RUBY_VERSION_MINOR == 8
const char* script = ruby_sourcefile = rb_source_filename(tmp->value);
rb_protect(LoadWrap, reinterpret_cast<VALUE>(script), &error);
#else
rb_load_protect(rb_str_new2(tmp->value), 0, &error);
#endif
if(error) {
ruby_trace_error(m);
return -1;
}
#if RUBY_VERSION_MINOR == 8
ruby_exec();
#else
ruby_exec_node(NULL);
#endif
}
else{
map* err=createMap("text","Unable to parse serviceProvider please check your zcfg file.");
addToMap(err,"code","NoApplicableCode");
printExceptionReportResponse(m,err);
return -1;
}
int res=SERVICE_FAILED;
rFunc=rb_intern(s->name);
if(rFunc!=Qnil){
VALUE arg1=RubyHash_FromMaps(m);
VALUE arg2=RubyHash_FromMaps(inputs);
VALUE arg3=RubyHash_FromMaps(outputs);
VALUE rArgs[3]={arg1,arg2,arg3};
if (!rArgs)
return -1;
struct my_callback data;
data.obj=Qnil;
data.method_id=rFunc;
data.nargs=3;
data.args[0]=rArgs[0];
data.args[1]=rArgs[1];
data.args[2]=rArgs[2];
typedef VALUE (*HOOK)(VALUE);
VALUE tres=rb_protect(reinterpret_cast<HOOK>(FunCallWrap),(VALUE)(&data),&error);
if (TYPE(tres) == T_FIXNUM) {
res=FIX2INT(tres);
freeMaps(real_outputs);
free(*real_outputs);
freeMaps(main_conf);
free(*main_conf);
*main_conf=mapsFromRubyHash(arg1);
*real_outputs=mapsFromRubyHash(arg3);
#ifdef DEBUG
dumpMaps(*main_conf);
dumpMaps(*real_outputs);
#endif
}else{
ruby_trace_error(m);
res=-1;
}
}
else{
char tmpS[1024];
sprintf(tmpS, "Cannot find the %s function in the %s file.\n", s->name, tmp->value);
map* tmps=createMap("text",tmpS);
printExceptionReportResponse(m,tmps);
res=-1;
}
ruby_finalize();
return res;
}
static void eruby_exit(status)
{
ruby_finalize();
exit(status);
}
int main( int argc, char** argv )
{
int state = 0;
int rc = 0;
int opt_mv = 0;
crate_app ca;
/** startup items from ruby's original main.c */
#ifdef _WIN32
NtInitialize(&argc, &argv);
#endif
#if defined(__MACOS__) && defined(__MWERKS__)
argc = ccommand(&argv);
#endif
/* setup ruby */
ruby_init();
ruby_script( argv[0] );
ruby_init_loadpath();
/* strip out the crate specific arguments from argv using --crate- */
opt_mv = crate_init_from_options( &ca, argc, argv );
argc -= opt_mv;
argv += opt_mv;
/* printf("crate file : %s\n", ca.file_name); */
/* printf("crate class : %s\n", ca.class_name); */
/* printf("crate method: %s\n", ca.method_name); */
/* make ARGV available */
ruby_set_argv( argc, argv );
/* initialize all extensions */
Init_ext();
/* load up the amalgalite libs */
am_bootstrap_lift( cARB, Qnil );
/* remove the current LOAD_PATH */
rb_ary_clear( rb_gv_get( "$LOAD_PATH" ) );
/* invoke the class / method passing in ARGV and ENV */
rb_protect( crate_wrap_app, (VALUE)&ca, &state );
/* check the results */
if ( state ) {
/* exception was raised, check the $! var */
VALUE lasterr = rb_gv_get("$!");
/* system exit was called so just propogate that up to our exit */
if ( rb_obj_is_instance_of( lasterr, rb_eSystemExit ) ) {
rc = NUM2INT( rb_attr_get( lasterr, rb_intern("status") ) );
/*printf(" Caught SystemExit -> $? will be %d\n", rc ); */
} else {
/* some other exception was raised so dump that out */
VALUE klass = rb_class_path( CLASS_OF( lasterr ) );
VALUE message = rb_obj_as_string( lasterr );
VALUE backtrace = rb_funcall( lasterr, rb_intern("backtrace"), 0 );
fprintf( stderr, "%s: %s\n", RSTRING( klass )->ptr, RSTRING( message )->ptr );
rb_iterate( rb_each, backtrace, dump_backtrace, Qnil );
rc = state;
}
}
free( ca.file_name );
free( ca.class_name );
free( ca.method_name );
/* shut down ruby */
ruby_finalize();
/* exit the program */
exit( rc );
}
void CleanupInterpreter()
{
ruby_finalize();
}
void RubyInterpreter::finalizeRuby()
{
delete d;
d = 0;
ruby_finalize();
}
int eruta_ruby_quit() {
ruby_finalize();
}
static int fini(void *user)
{
ruby_finalize();
return R_TRUE;
}
