int eruta_ruby_init() { VALUE options = Qnil, sublet = Qnil; void Init_prelude(void); RUBY_INIT_STACK; ruby_init(); ruby_init_loadpath(); ruby_script("eruta"); #ifdef HAVE_RB_ENC_SET_DEFAULT_INTERNAL { VALUE encoding = Qnil; /* FIXME: Fix for ruby 1.9.2p429 borrowed from ruby? */ (void)rb_filesystem_encoding(); /* Set encoding */ encoding = rb_enc_from_encoding(rb_locale_encoding()); rb_enc_set_default_external(encoding); } #endif /* HAVE_RB_ENC_SET_DEFAULT_INTERNAL */ /* FIXME: Fake ruby_init_gems(Qtrue) */ rb_define_module("Gem"); Init_prelude(); /* Bypassing garbage collection. Why? */ /* shelter = rb_ary_new(); rb_gc_register_address(&shelter); */ }
int proxenet_ruby_initialize_vm(plugin_t* plugin) { interpreter_t *interpreter; interpreter = plugin->interpreter; /* checks */ if (interpreter->ready) return 0; #ifdef DEBUG xlog(LOG_DEBUG, "Initializing Ruby VM version %s\n", _RUBY_VERSION_); #endif /* init vm */ ruby_init(); interpreter->vm = (void*) rb_mKernel; ruby_script(PROGNAME); ruby_init_loadpath(); interpreter->ready = true; return 0; }
static void load_script(const char *name) { struct stat st; int rc; updatecontext(); if (!name) return; if (stat(name, &st) < 0) { myruby_loaded = -1; outerror(OUTERROR_TYPE_WARN_LOUD, "cannot access '%s', ignoring: %s", name, strerror(errno)); return; } ruby_script(name); myruby_time = st.st_mtime; rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc); if (rc != 0) { outerror(OUTERROR_TYPE_WARN_LOUD, "ruby_exec failed with %d: %s", rc, strerror(errno)); myruby_loaded = 1; return; } myruby_loaded = 1; oIrofferEvent = rb_class_new_instance(0, NULL, cIrofferEvent); rb_define_variable("objIrofferEvent", &oIrofferEvent); /* NOTRANSLATE */ }
/* call a ruby script as CGI via HTTP */ unsigned int http_ruby_script(const char *name, const char *output) { struct stat st; char *tempstr; int rc; updatecontext(); if (!name) return 1; if (stat(name, &st) < 0) { outerror(OUTERROR_TYPE_WARN_LOUD, "cannot access '%s', ignoring: %s", name, strerror(errno)); return 1; } ruby_script(name); tempstr = mymalloc(maxtextlength); snprintf(tempstr, maxtextlength, "$stdout = File.new(\"%s\", \"w+\")", output); /* NOTRANSLATE */ rb_eval_string_protect(tempstr, &rc); mydelete(tempstr); rb_load_protect(rb_str_new(name, strlen(name)), 0, &rc); if (rc != 0) { outerror(OUTERROR_TYPE_WARN_LOUD, "ruby_exec failed with %d: %s", rc, strerror(errno)); iroffer_ruby_errro(rc); } rb_eval_string_protect("$stdout.close", &rc); /* NOTRANSLATE */ if (rc != 0) return 1; return 0; }
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; }
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 VALUE load_provider(VALUE arg) { const char *classname = (const char *)arg; VALUE req; /* result of rb_require */ if (classname == NULL || *classname == 0) { _SBLIM_TRACE(1,("Ruby: load_provider(%s) no class given", classname)); return Qfalse; } char *filename = alloca(strlen(classname) * 2 + 1); decamelize(classname, filename); ruby_script(filename); _SBLIM_TRACE(1,("<%d> Ruby: loading (%s)", getpid(), filename)); req = rb_require(filename); /* Qtrue == just loaded, Qfalse = already loaded, else: fail */ if ((req != Qtrue) && (req != Qfalse)) { _SBLIM_TRACE(1,("<%d> require '%s' failed", getpid(), filename)); return Qnil; } /* Get Cmpi::Provider */ VALUE val = rb_const_get(rb_cObject, rb_intern(RB_MODULE_NAME)); if (NIL_P(val)) { _SBLIM_TRACE(1,("<%d> No such module '%s'", getpid(), RB_MODULE_NAME)); return val; } val = rb_const_get(val, rb_intern(classname)); if (NIL_P(val)) { _SBLIM_TRACE(1,("<%d> No such class '%s::%s'", getpid(), RB_MODULE_NAME, classname)); } return val; }
void InitializeInterpreter() { ruby_init(); VALUE load_path = rb_gv_get("$LOAD_PATH"); rb_ary_push(load_path, rb_str_new2(".")); Init_armagetronad(); ruby_script("Armagetron Advanced"); }
static inline void prep_ruby_env() { ruby_script("Lich"); #ifdef __MINGW32__ rb_ary_push(rb_gv_get("$\""), rb_str_new2("socket.dll")); reg32_setup(); #else rb_ary_push(rb_gv_get("$\""), rb_str_new2("socket.so")); #endif }
void xen_initialize(void) { #ifdef RUBY_INIT_STACK RUBY_INIT_STACK; #endif ruby_init(); ruby_init_loadpath(); ruby_script("xen"); /* necessary in ruby 1.9 (else segfault in rb_raise) */ Init_Hook(); }
/* Called by the epic hooks to activate tcl on-demand. */ void ruby_startstop (int value) { VALUE rubyval; /* If it is already in the state we want, do nothing. */ if (is_ruby_running == value) return; /* Do a shutdown */ if (value == 0) { is_ruby_running = 0; /* Do shutdown stuff */ return; } /* Do a startup */ ++is_ruby_running; ruby_init(); ruby_init_loadpath(); ruby_script(malloc_strdup(irc_version)); rubyclass = rb_define_class("EPIC", rb_cObject); rb_define_singleton_method(rubyclass, "echo", epic_echo, 1); rb_define_singleton_method(rubyclass, "say", epic_say, 1); rb_define_singleton_method(rubyclass, "cmd", epic_cmd, 1); rb_define_singleton_method(rubyclass, "eval", epic_eval, 1); rb_define_singleton_method(rubyclass, "expr", epic_expr, 1); rb_define_singleton_method(rubyclass, "call", epic_call, 1); rb_gc_register_address(&rubyclass); /* XXX Is it a hack to do it like this instead of in pure C? */ rubyval = rb_eval_string("EPICstderr = Object.new unless defined? EPICstderr\n" "def EPICstderr.write(string) \n" " str = string.chomp \n" " EPIC.echo(\"RUBY-ERROR: #{str}\") \n" "end \n" "$stderr = EPICstderr"); if (rubyval == Qnil) say("stderr assignment returned Qnil"); rubyval = rb_eval_string("EPICstdout = Object.new unless defined? EPICstdout\n" "def EPICstdout.write(string) \n" " str = string.chomp \n" " EPIC.echo(str) \n" "end \n" "$stdout = EPICstdout"); if (rubyval == Qnil) say("stderr assignment returned Qnil"); }
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); }
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; }
static void rb_w_define_klass() { /* * Initialize Ruby Interpreter */ int rb_argc = 0; char *rb_argv[] = {NULL}; ruby_init(); ruby_init_loadpath(); ruby_options(rb_argc, rb_argv); ruby_script("Wireplay"); /* * Initialize the Wireplay::Hook class for ruby hook repository */ rb_mWireplay = rb_define_module("Wireplay"); rb_const_set(rb_mWireplay, rb_intern("WIREPLAY_PROG_NAME"), rb_str_new2(WIREPLAY_PROG_NAME)); rb_const_set(rb_mWireplay, rb_intern("WIREPLAY_PROG_VER"), rb_str_new2(WIREPLAY_PROG_VER)); //rb_const_set(rb_mWireplay, rb_intern("WIREPLAY_AUTHOR"), rb_str_new2(WIREPLAY_AUTHOR)); rb_const_set(rb_mWireplay, rb_intern("WIREPLAY_COPYRIGHT"), rb_str_new2(WIREPLAY_COPYRIGHT)); rb_const_set(rb_mWireplay, rb_intern("REPLAY_SERVER_TO_CLIENT"), INT2FIX(REPLAY_SERVER_TO_CLIENT)); rb_const_set(rb_mWireplay, rb_intern("REPLAY_CLIENT_TO_SERVER"), INT2FIX(REPLAY_CLIENT_TO_SERVER)); rb_const_set(rb_mWireplay, rb_intern("ERROR_CONNECT_FAILED"), INT2FIX(ERROR_CONNECT_FAILED)); rb_const_set(rb_mWireplay, rb_intern("ERROR_SEND_FAILED"), INT2FIX(ERROR_SEND_FAILED)); rb_const_set(rb_mWireplay, rb_intern("ERROR_RECV_FAILED"), INT2FIX(ERROR_RECV_FAILED)); rb_const_set(rb_mWireplay, rb_intern("ERROR_TIMEOUT"), INT2FIX(ERROR_TIMEOUT)); rb_const_set(rb_mWireplay, rb_intern("ERROR_SOCKET_ERROR"), INT2FIX(ERROR_SOCKET_ERROR)); rb_const_set(rb_mWireplay, rb_intern("ROLE_CLIENT"), INT2FIX(ROLE_CLIENT)); rb_const_set(rb_mWireplay, rb_intern("ROLE_SERVER"), INT2FIX(ROLE_SERVER)); rb_define_global_function("cmsg", rb_w_cmsg, 1); /* TODO: define other msg.c functions */ rb_cHook = rb_define_class_under(rb_mWireplay, "Hooks", rb_cObject); rb_cvar_set(rb_cHook, rb_intern("_hooks"), rb_ary_new(), 0); rb_define_singleton_method(rb_cHook, "register", rb_cHook_register, 1); rb_define_singleton_method(rb_cHook, "hooks", rb_cHook_hooks, 0); rb_define_singleton_method(rb_mWireplay, "start_irb", rb_test_start_irb, 0); rb_define_singleton_method(rb_mWireplay, "load_library", rb_mWireplay_load_library, 1); //rb_test_start_irb(); return; }
static int ensure_ruby_initialized(void) { if (!ruby_initialized) { #ifdef DYNAMIC_RUBY if (ruby_enabled(TRUE)) { #endif #ifdef _WIN32 /* suggested by Ariya Mizutani */ int argc = 1; char *argv[] = {"gvim.exe"}; char **argvp = argv; NtInitialize(&argc, &argvp); #endif { #if defined(RUBY19_OR_LATER) || defined(RUBY_INIT_STACK) ruby_init_stack(ruby_stack_start); #endif ruby_init(); } #ifdef RUBY19_OR_LATER { int dummy_argc = 2; char *dummy_argv[] = {"vim-ruby", "-e0"}; ruby_options(dummy_argc, dummy_argv); } ruby_script("vim-ruby"); #else ruby_init_loadpath(); #endif ruby_io_init(); ruby_vim_init(); ruby_initialized = 1; #ifdef DYNAMIC_RUBY } else { EMSG(_("E266: Sorry, this command is disabled, the Ruby library could not be loaded.")); return 0; } #endif } return ruby_initialized; }
int policy_init( const Pool *p ) { ruby_init(); ruby_init_loadpath(); rb_set_safe_level(0); //FIXME /* give the ruby code a name */ ruby_script("satsolver_policy"); cPolicy = rb_define_class( "SatPolicy", rb_cObject ); /* load the policy implementation */ rb_require( "satsolver_policy" ); pool = p; return 0; }
void init_ruby(struct module *module) { unsigned char *path; /* Set up and initialize the interpreter. This function should be called * before any other Ruby-related functions. */ ruby_init(); ruby_script("ELinks-ruby"); ruby_init_loadpath(); /* ``Trap'' debug prints from scripts. */ rb_define_singleton_method(rb_stdout, "write", erb_module_message, 1); rb_define_global_function("p", erb_stdout_p, -1); /* Set up the ELinks module interface. */ init_erb_module(); if (elinks_home) { path = straconcat(elinks_home, RUBY_HOOKS_FILENAME, (unsigned char *) NULL); } else { path = stracpy(CONFDIR STRING_DIR_SEP RUBY_HOOKS_FILENAME); } if (!path) return; if (file_can_read(path)) { int error; /* Load ~/.elinks/hooks.rb into the interpreter. */ //rb_load_file(path); rb_load_protect(rb_str_new2(path), 0, &error); if (error) erb_report_error(NULL, error); } mem_free(path); }
void startup(const char* script_name) { if(running) { return; } int fake_argc = 0; char *fake_args[fake_argc]; char **fake_argv = fake_args; ruby_sysinit(&fake_argc, &fake_argv); // Initialize Ruby itself RUBY_INIT_STACK; ruby_init(); ruby_init_loadpath(); //Init_prelude(); //ruby_init_gems(); // To load prelude.rb static char* args[] = { "ruby", "/dev/null" }; ruby_process_options(2, args); // Load Ruby encodings, otherwise we'll get all kinds of "Unitialized // constanct Encoding::UTF-7", etc. everywhere. rb_enc_find_index("encdb"); VALUE gem; gem = rb_define_module("Gem"); rb_const_set(gem, rb_intern("Enable"), Qtrue); rb_require("rubygems"); ruby_script((char*)script_name); running = true; }
// 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); }
bool Ruby::Init(TCHAR* nwnxhome) { assert(GetPluginFileName()); /* Log file */ wxString logfile(nwnxhome); logfile.append(wxT("\\")); logfile.append(GetPluginFileName()); logfile.append(wxT(".txt")); logger = new wxLogNWNX(logfile, wxString(header.c_str())); ruby_init(); ruby_script("embedded"); ruby_init_loadpath(); RubyInt_DefineConstants(); //rb_eval_string("puts \"NWNX Ruby Initialized\"\n"); /* char *preload = (char*)((*nwnxConfig)[confKey]["preload"].c_str()); if (strlen(preload) > 0) { Log(0, "Preloading: %s\n", preload); rb_require(preload); }*/ cNWScript = RubyInt_InitNWScript(); rb_include_module(rb_cObject, cNWScript); if (HookFunctions()) { //bHooked=1; Log(0,"* Module loaded successfully.\n"); } //wxLogMessage(wxT("* Plugin initialized.")); return true; }
/** * 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; }
int weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]) { int ruby_error; char *weechat_ruby_code = { "$stdout = WeechatOutputs\n" "$stderr = WeechatOutputs\n" "\n" "class Module\n" " @load_eval_file_error = ''\n" "\n" " def load_eval_file (file)\n" " lines = ''\n" " begin\n" " f = File.open(file, 'r')\n" " lines = f.readlines.join\n" " rescue => e\n" " @load_eval_file_error = e\n" " return 1\n" " end\n" "\n" " begin\n" " module_eval(lines)\n" " rescue => e\n" " @load_eval_file_error = e\n" " return 2\n" " end\n" "\n" " has_init = false\n" "\n" " instance_methods.each do |meth|\n" " if meth == 'weechat_init'\n" " has_init = true\n" " end\n" " module_eval('module_function :' + meth)\n" " end\n" "\n" " unless has_init\n" " return 3\n" " end\n" "\n" " return 0\n" " end\n" "end\n" }; weechat_ruby_plugin = plugin; ruby_error = 0; /* init stdout/stderr buffer */ ruby_buffer_output[0] = '\0'; ruby_init (); ruby_init_loadpath (); ruby_script ("__weechat_plugin__"); ruby_mWeechat = rb_define_module("Weechat"); weechat_ruby_api_init (ruby_mWeechat); /* redirect stdin and stdout */ ruby_mWeechatOutputs = rb_define_module("WeechatOutputs"); rb_define_singleton_method(ruby_mWeechatOutputs, "write", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "puts", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "p", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "flush", weechat_ruby_output_flush, 0); rb_eval_string_protect(weechat_ruby_code, &ruby_error); if (ruby_error) { VALUE ruby_error_info = rb_inspect(ruby_errinfo); weechat_printf (NULL, weechat_gettext ("%s%s: unable to eval WeeChat ruby " "internal code"), weechat_prefix ("error"), RUBY_PLUGIN_NAME); weechat_printf (NULL, weechat_gettext ("%s%s: error: %s"), weechat_prefix ("error"), RUBY_PLUGIN_NAME, STR2CSTR(ruby_error_info)); return WEECHAT_RC_ERROR; } ruby_quiet = 1; script_init (weechat_ruby_plugin, argc, argv, &ruby_scripts, &weechat_ruby_command_cb, &weechat_ruby_completion_cb, &weechat_ruby_infolist_cb, &weechat_ruby_signal_debug_dump_cb, &weechat_ruby_signal_buffer_closed_cb, &weechat_ruby_signal_script_action_cb, &weechat_ruby_load_cb, &weechat_ruby_api_buffer_input_data_cb, &weechat_ruby_api_buffer_close_cb); ruby_quiet = 0; script_display_short_list (weechat_ruby_plugin, ruby_scripts); /* init ok */ return WEECHAT_RC_OK; }
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 ); }
PLRUBY_EXPORT OCIAnyData * extproc_ruby(OCIExtProcContext *with_context, short *ret_ind, int rettype, const char *obj, short obj_ind, const char *meth, short meth_ind, const char *argtype, int argtype_len, OCIString *v1, short v1_ind, OCIString *v2, short v2_ind, OCIString *v3, short v3_ind, OCIString *v4, short v4_ind, OCIString *v5, short v5_ind, OCIString *v6, short v6_ind, OCIString *v7, short v7_ind, OCIString *v8, short v8_ind, OCIString *v9, short v9_ind, OCIString *v10, short v10_ind, OCINumber *n1, short n1_ind, OCINumber *n2, short n2_ind, OCINumber *n3, short n3_ind, OCINumber *n4, short n4_ind, OCINumber *n5, short n5_ind, OCINumber *n6, short n6_ind, OCINumber *n7, short n7_ind, OCINumber *n8, short n8_ind, OCINumber *n9, short n9_ind, OCINumber *n10, short n10_ind, double d1, short d1_ind, double d2, short d2_ind, double d3, short d3_ind, double d4, short d4_ind, double d5, short d5_ind, double d6, short d6_ind, double d7, short d7_ind, double d8, short d8_ind, double d9, short d9_ind, double d10, short d10_ind) { plruby_context_t ctx; OCIAnyData *sdata = NULL; static int ruby_initialized = 0; OCIExtProcGetEnv(with_context, &ctx.envhp, &ctx.svchp, &ctx.errhp); ctx.obj = obj_ind ? NULL : obj; ctx.meth = meth_ind ? NULL : meth; ctx.rettype = rettype; ctx.argtype = argtype; ctx.args[0] = argtype_len >= 1 ? checkarg(argtype[0], v1, n1, &d1) : EMPTY; ctx.args[1] = argtype_len >= 2 ? checkarg(argtype[1], v2, n2, &d2) : EMPTY; ctx.args[2] = argtype_len >= 3 ? checkarg(argtype[2], v3, n3, &d3) : EMPTY; ctx.args[3] = argtype_len >= 4 ? checkarg(argtype[3], v4, n4, &d4) : EMPTY; ctx.args[4] = argtype_len >= 5 ? checkarg(argtype[4], v5, n5, &d5) : EMPTY; ctx.args[5] = argtype_len >= 6 ? checkarg(argtype[5], v6, n6, &d6) : EMPTY; ctx.args[6] = argtype_len >= 7 ? checkarg(argtype[6], v7, n7, &d7) : EMPTY; ctx.args[7] = argtype_len >= 8 ? checkarg(argtype[7], v8, n8, &d8) : EMPTY; ctx.args[8] = argtype_len >= 9 ? checkarg(argtype[8], v9, n9, &d9) : EMPTY; ctx.args[9] = argtype_len >= 10 ? checkarg(argtype[9], v10, n10, &d10) : EMPTY; if (!ruby_initialized) { ruby_init(); ruby_init_loadpath(); ruby_script("extproc_ruby"); ruby_initialized = 1; } { int state = 0; int plruby_initialized = 0; RUBY_INIT_STACK; if (!plruby_initialized) { rb_protect((VALUE(*)(VALUE))setup_plruby_oracle, (VALUE)&ctx, &state); if (state == 0) { plruby_initialized = 1; } } if (state == 0) { sdata = (OCIAnyData*)rb_protect((VALUE(*)(VALUE))call_ruby, (VALUE)&ctx, &state); } if (state) { int errnum = 20999; /* The last value of user-defined error number */ const char *errmsg = (const char *)rb_protect((VALUE(*)(VALUE))get_error_msg, (VALUE)&errnum, &state); if (state) { errmsg = "Failed to get an error in extproc_ruby"; } OCIExtProcRaiseExcpWithMsg(with_context, errnum, (OraText*)errmsg, 0); } } *ret_ind = (sdata != NULL) ? OCI_IND_NOTNULL : OCI_IND_NULL; return sdata; }
int weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]) { struct t_plugin_script_init init; int ruby_error; char *weechat_ruby_code = { "$stdout = WeechatOutputs\n" "$stderr = WeechatOutputs\n" "begin" " if RUBY_VERSION.split('.')[0] == '1' and RUBY_VERSION.split('.')[1] <= '8'\n" " require 'rubygems'\n" " else\n" " require 'enc/encdb.so'\n" " require 'enc/trans/transdb.so'\n" "\n" " require 'thread'\n" " class ::Mutex\n" " def synchronize(*args)\n" " yield\n" " end\n" " end\n" " require 'rubygems'\n" " end\n" "rescue LoadError\n" "end\n" "\n" "class Module\n" "\n" " def load_eval_file (file)\n" " lines = ''\n" " begin\n" " lines = File.read(file)\n" " rescue => e\n" " return 1\n" " end\n" "\n" " begin\n" " module_eval(lines)\n" " rescue Exception => e\n" " @load_eval_file_error = e\n" " return 2\n" " end\n" "\n" " has_init = false\n" "\n" " instance_methods.each do |meth|\n" " if meth.to_s == 'weechat_init'\n" " has_init = true\n" " end\n" " module_eval('module_function :' + meth.to_s)\n" " end\n" "\n" " unless has_init\n" " return 3\n" " end\n" "\n" " return 0\n" " end\n" "end\n" }; weechat_ruby_plugin = plugin; ruby_error = 0; /* init stdout/stderr buffer */ ruby_buffer_output[0] = '\0'; #if (defined(RUBY_API_VERSION_MAJOR) && defined(RUBY_API_VERSION_MINOR)) && (RUBY_API_VERSION_MAJOR >= 2 || (RUBY_API_VERSION_MAJOR == 1 && RUBY_API_VERSION_MINOR >= 9)) RUBY_INIT_STACK; #endif ruby_hide_errors = 1; ruby_init (); ruby_init_loadpath (); ruby_script ("__weechat_plugin__"); ruby_mWeechat = rb_define_module("Weechat"); weechat_ruby_api_init (ruby_mWeechat); /* redirect stdin and stdout */ ruby_mWeechatOutputs = rb_define_module("WeechatOutputs"); rb_define_singleton_method(ruby_mWeechatOutputs, "write", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "puts", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "p", weechat_ruby_output, 1); rb_define_singleton_method(ruby_mWeechatOutputs, "flush", weechat_ruby_output_flush, 0); ruby_hide_errors = 0; rb_eval_string_protect(weechat_ruby_code, &ruby_error); if (ruby_error) { weechat_printf (NULL, weechat_gettext ("%s%s: unable to eval WeeChat ruby " "internal code"), weechat_prefix ("error"), RUBY_PLUGIN_NAME); VALUE err = rb_gv_get("$!"); weechat_ruby_print_exception(err); return WEECHAT_RC_ERROR; } init.callback_command = &weechat_ruby_command_cb; init.callback_completion = &weechat_ruby_completion_cb; init.callback_hdata = &weechat_ruby_hdata_cb; init.callback_infolist = &weechat_ruby_infolist_cb; init.callback_signal_debug_dump = &weechat_ruby_signal_debug_dump_cb; init.callback_signal_debug_libs = &weechat_ruby_signal_debug_libs_cb; init.callback_signal_buffer_closed = &weechat_ruby_signal_buffer_closed_cb; init.callback_signal_script_action = &weechat_ruby_signal_script_action_cb; init.callback_load_file = &weechat_ruby_load_cb; ruby_quiet = 1; plugin_script_init (weechat_ruby_plugin, argc, argv, &init); ruby_quiet = 0; plugin_script_display_short_list (weechat_ruby_plugin, ruby_scripts); /* init OK */ return WEECHAT_RC_OK; }
static void proc_args(int argc, char **argv) { int option_index; ruby_script(argv[0]); switch (eruby_parse_options(argc, argv, &option_index)) { case 1: eruby_exit(0); case 2: eruby_exit(2); } if (eruby_mode == MODE_UNKNOWN) eruby_mode = guess_mode(); if (eruby_mode == MODE_CGI || eruby_mode == MODE_NPHCGI) { char *path; char *tmp_qs; char *query_string; int qs_has_equal; char *path_translated; if ((path = getenv("PATH_INFO")) != NULL && strcmp(path, "/logo.png") == 0) { give_img_logo(eruby_mode); eruby_exit(0); } if ((tmp_qs = getenv("QUERY_STRING")) == NULL) { query_string = ""; } else { query_string = eruby_xmalloc(strlen(tmp_qs) + 1); strcpy(query_string, tmp_qs); } qs_has_equal = (strchr(query_string, '=') != NULL); if ((path_translated = getenv("PATH_TRANSLATED")) == NULL) path_translated = ""; if (path_translated[0] && ((option_index == argc && (!query_string[0] || qs_has_equal)) || (option_index == argc - 1 && !qs_has_equal && strcmp(argv[option_index], query_string) == 0))) { eruby_filename = path_translated; } else if ((option_index == argc - 1 && (!query_string[0] || qs_has_equal)) || (option_index == argc - 2 && !qs_has_equal && strcmp(argv[option_index + 1], query_string) == 0)) { eruby_filename = argv[option_index]; } else { fprintf(stderr, "%s: missing required file to process\n", argv[0]); eruby_exit(1); } if (tmp_qs) free(query_string); } else { if (option_index == argc) { eruby_filename = "-"; } else { eruby_filename = argv[option_index++]; ruby_set_argv(argc - option_index, argv + option_index); } } }
rpmruby rpmrubyNew(char ** av, uint32_t flags) { static char * _av[] = { "rpmruby", NULL }; rpmruby ruby = (flags & 0x80000000) ? rpmrubyI() : rpmrubyGetPool(_rpmrubyPool); int xx; RUBYDBG((stderr, "--> %s(%p,0x%x) ruby %p\n", __FUNCTION__, av, flags, ruby)); /* If failure, or retrieving already initialized _rpmrubyI, just exit. */ if (ruby == NULL || ruby == _rpmrubyI) goto exit; if (av == NULL) av = _av; ruby->flags = flags; xx = argvAppend(&ruby->av, (ARGV_t)av); ruby->ac = argvCount(ruby->av); /* XXX FIXME: 0x40000000 => xruby.c wrapper without interpreter. */ if (ruby->flags & 0x40000000) { static size_t _rpmrubyStackSize = 4 * 1024 * 1024; /* XXX save as global interpreter. */ _rpmrubyI = ruby; ruby->nstack = _rpmrubyStackSize; ruby->stack = malloc(ruby->nstack); assert(ruby->stack != NULL); gettimeofday(&ruby->start, NULL); /* starting time for log entries */ if (_rpmruby_debug) ruby->zlog = rpmzLogNew(&ruby->start); /* initialize logging */ /* initialize the relay mechanism */ ruby->ruby_coroutine_lock = yarnNewLock(0); ruby->main_coroutine_lock = yarnNewLock(0); } else { #if defined(WITH_RUBYEMBED) VALUE variable_in_this_stack_frame; /* RUBY_INIT_STSCK */ #if defined(HAVE_RUBY_DEFINES_H) /* XXX ruby-1.9.2 */ ruby_sysinit(&ruby->ac, (char ***) &ruby->av); /* XXX ruby-1.9.2p0 ruby_bind_stack() patch needed */ { uint8_t * b = ruby->stack; uint8_t * e = b + ruby->nstack; ruby_bind_stack((VALUE *)b, (VALUE *) e); } #endif /* NOTYET */ ruby_init_stack(&variable_in_this_stack_frame); /* RUBY_INIT_STACK */ ruby_init(); ruby_init_loadpath(); ruby_script((char *)av[0]); if (av[1]) ruby_set_argv(argvCount((ARGV_t)av)-1, av+1); rb_gv_set("$result", rb_str_new2("")); #if !defined(HAVE_RUBY_DEFINES_H) /* XXX ruby-1.8.6 */ (void) rpmrubyRun(ruby, rpmrubyInitStringIO, NULL); #endif #endif /* WITH_RUBYEMBED */ } exit: return rpmrubyLink(ruby); }