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);
}
