/* 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;
}
VALUE
rb_eval_string_wrap(const char *str, int *state)
{
int status;
rb_thread_t *th = GET_THREAD();
VALUE self = th->top_self;
VALUE wrapper = th->top_wrapper;
VALUE val;
th->top_wrapper = rb_module_new();
th->top_self = rb_obj_clone(rb_vm_top_self());
rb_extend_object(th->top_self, th->top_wrapper);
val = rb_eval_string_protect(str, &status);
th->top_self = self;
th->top_wrapper = wrapper;
if (state) {
*state = status;
}
else if (status) {
JUMP_TAG(status);
}
return val;
}
static VALUE
load_application(char *path, char *name)
{
VALUE app_class, class_name;
VALUE filename;
int state;
class_name = rb_str_new2(name);
rb_gc_register_address(&class_name);
app_class = rb_hash_aref(application_classes, class_name);
if (NIL_P(app_class)) {
filename = get_source_filename(name, path);
if (NIL_P(filename)) {
Warning("invalid module name: %s\n", name);
return Qnil;
}
rb_load_protect(filename, 0, &state);
if (state && error_handle(state))
return Qnil;
app_class = rb_eval_string_protect(name, &state);
rb_gc_register_address(&app_class);
if (state && error_handle(state))
return Qnil;
rb_hash_aset(application_classes, class_name, app_class);
}
return app_class;
}
int eval_buffer(char* script)
{
int state;
rb_eval_string_protect(script, &state);
return state;
}
void ex_ruby(exarg_T *eap)
{
int state;
char *script = NULL;
script = (char *)script_get(eap, eap->arg);
if (!eap->skip && ensure_ruby_initialized())
{
if (script == NULL)
rb_eval_string_protect((char *)eap->arg, &state);
else
rb_eval_string_protect(script, &state);
if (state)
error_print(state);
}
vim_free(script);
}
static int prompt(void *user)
{
int err;
rb_eval_string_protect("IRB.start();", &err);
if (err != 0)
return R_FALSE;
return R_TRUE;
}
static int init(void *user)
{
VALUE rb_RadareCmd;
ruby_init();
ruby_init_loadpath();
rb_eval_string_protect("require 'irb'", NULL);
core = user;
rb_RadareCmd = rb_define_class("RadareInternal", rb_cObject);
rb_define_method(rb_RadareCmd, "cmd", radare_ruby_cmd, 1);
rb_eval_string_protect("$r = RadareInternal.new()", NULL);
if (!slurp_ruby(RUBYAPI)) {
printf("[ruby] error loading ruby api\n");
//return R_FALSE;
}
return R_TRUE;
}
static int run(void *user, const char *code, int len)
{
int err, ret = R_TRUE;
rb_eval_string_protect(code, &err);
if (err != 0) {
printf("error %d handled\n", err);
ret = R_FALSE;
}
return ret;
}
static VALUE get(const wxString& name){
int error;
wxString rubyCode = _("Bowline.configuration.");
rubyCode.append(name);
VALUE result = rb_eval_string_protect(rubyCode.c_str(), &error);
if(error) {
RubyUtils::LogError();
throw "Config Error";
}
return result;
}
/*
=================
SV_Ruby
=================
*/
void SV_Ruby_f(void) {
int state;
if (Cmd_Argc() != 2) {
Com_Printf("usage: ruby \"code_to_execute\"\nPlease note the \"\", also use single-quotes for ruby strings\n");
return;
}
rb_eval_string_protect(Cmd_Argv(1), &state);
if (state != 0) {
Com_Printf("^1ruby: error: %i\nYour syntax may be invalid, or you are referencing a non-existing class/variable.\n", state);
}
}
VALUE zeitgeist::RbEvalStringWrap(const std::string& str, int& error)
{
VALUE v = rb_eval_string_protect(str.c_str(),&error);
if (error)
{
RbPrintError();
return Qnil;
}
return v;
}
static int mod_load_servlet(lua_State *l)
{
const char *path = luaL_checkstring(l, -1);
int ok = luaL_loadstring(l,
"local f = io.open(...)\n"
"local str = f:read([[*all]])\n"
"f:close()\n"
"str = str .. [[$servlet_run = lambda {|s| run(s) }]]\n"
"return str\n"
);
if (ok != LUA_OK)
{
return luaL_error(l, lua_tostring(l, -1));
}
lua_pushstring(l, path);
lua_call(l, 1, 1);
const char *servlet_rb = luaL_checkstring(l, -1);
// puts(servlet_rb);
int status;
VALUE result;
result = rb_eval_string_protect(servlet_rb, &status);
if (status != 0)
{
VALUE rbError = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
return luaL_error(l, "rb_load_protect: %s", StringValuePtr(rbError));
}
VALUE servlet = rb_gv_get("$servlet_run");
// printf("%lu\n", servlet);
lua_newtable(l);
lua_pushlightuserdata(l, (void*)servlet);
lua_pushcclosure(l, servlet_run, 1);
lua_setfield(l, -2, "run");
result = rb_eval_string_protect("$servlet_run = nil", &status);
return 1;
}
static VALUE
eval_enc_string_protect(const char *str, int *state)
{
#ifdef RUBY19_OR_LATER
int isnum;
long lval;
char_u *sval;
rb_encoding *enc;
VALUE v;
isnum = get_option_value((char_u *)"enc", &lval, &sval, 0);
if (isnum == 0)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
if (enc)
{
v = rb_sprintf("#-*- coding:%s -*-\n%s", rb_enc_name(enc), str);
return rb_eval_string_protect(StringValuePtr(v), state);
}
}
#endif
return rb_eval_string_protect(str, state);
}
SEXP
R_rb_eval_string(SEXP r_cmd, SEXP r_convert)
{
const char *cmd;
VALUE val;
int status = 0;
cmd = CHAR(STRING_ELT(r_cmd, 0));
val = rb_eval_string_protect(cmd, &status);
if(status) {
PROBLEM "error evaluating Ruby command: %s", cmd
ERROR;
}
return(convertRubyToR(val, r_convert));
}
int main(void) {
int res;
eruta_ruby_init();
rb_eval_string_protect("$: < '.'", &res);
rb_eval_string_protect("$: < '.' ; require 'local.rb'", &res);
rb_eval_string_protect("puts 'Hello 1 µµ!'", &res);
rb_eval_string_protect("exit(1)", &res);
rb_eval_string_protect("puts 'Hello 2!'", &res);
printf("Result: %d\n", res);
rb_eval_string_protect("frozcicks", &res);
printf("Result: %d\n", res);
rb_eval_string_protect("puts 'Hello 3!'", &res);
eruta_ruby_quit();
return 0;
}
char *Ruby::Eval(char *value)
{
//Evaluate Ruby expression (protected)
try
{
VALUE retval;
char *c_retval;
rb_eval_string("Thread.current[:nwnx_context] = true");
retval = rb_eval_string_protect(value, &nError);
rb_eval_string("Thread.current[:nwnx_context] = false");
if(nError)
{
Log(0, "Error %d while evaluating a Ruby expression: %s\n", nError, value);
return NULL;
}
if(retval!=Qnil)
{
retval = rb_funcall(retval, rb_intern("to_s"), 0);
c_retval = rb_string_value_ptr(&retval);
if(c_retval)
{
char *buf = (char *) malloc(strlen(c_retval)+1);
strcpy(buf, c_retval);
return buf;
}
}
return NULL;
}
catch(...)
{
Log(0, "Caught a C++ exception while evaluating a Ruby expression: %s\n", value);
return NULL;
}
/*else
return RSTRING(rb_cvar_get(cNWScript, rb_intern(RUBY_RETVAL)))->ptr;*/
}
/* load the interpreter and the script */
void startup_myruby(void)
{
int rc;
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
/* dumps the version info to stdout */
ruby_show_version();
/* set working dir for includes */
rb_eval_string_protect("$: << '.'", &rc); /* NOTRANSLATE */
#if USE_RUBYVERSION < 19
#else
rb_enc_find_index("encdb"); /* NOTRANSLATE */
#endif
myruby_loaded = 0;
//define that callback below
rb_define_global_function("iroffer_input", cie_inputline, 0); /* NOTRANSLATE */
rb_define_global_function("iroffer_privmsg", cie_privmsg, 2); /* NOTRANSLATE */
Init_IrofferEvent();
load_script(gdata.ruby_script);
}
void
debase_rb_eval(const char *string_to_eval)
{
rb_eval_string_protect(string_to_eval, NULL);
}
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 crb_eval_string(const char *rbstr) {
int error;
rb_eval_string_protect(rbstr, &error);
return error;
}
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;
}
