int main(int argc, char **argv)
{
#ifndef __MINGW32__
FILE *fileconf;
#endif
char *tmp;
char lichdir[256] = { '\0' };
char datadir[512] = { '\0' };
int nerr;
sig_setup();
#ifndef __MINGW32__
snprintf(lichdir, 256, "%s%s", getenv("HOME"), "/.lich.cfg");
fileconf = fopen(lichdir, "rb");
if (!fileconf) {
perror("fopen");
fprintf(stderr, "Your `$HOME/.lich.cfg' file cannot be opened: please create the file and put the full directory name Lich should use for settings/config files in it.\n\nFor example, to do that, you could type: echo \"$HOME/lich\" > $HOME/.lich.cfg\n");
exit(EXIT_FAILURE);
}
fgets(lichdir, 256, fileconf);
fclose(fileconf);
lichdir[strnlen(lichdir, 256) - 1] = '/';
chdir(lichdir);
#else
NtInitialize(&argc, &argv);
strncpy(lichdir, argv[0], 255);
tmp = &lichdir[strlen(lichdir)];
while (tmp && (*tmp != '\\') && (*tmp != '/')) {
tmp--;
}
*tmp = '\0';
chdir(lichdir);
#endif
init_ruby_interpreter(argc, argv);
init_libs();
prep_ruby_env();
getcwd(lichdir, 255);
lichdir[strlen(lichdir) + 1] = '\0';
lichdir[strlen(lichdir)] = RSTRING(rb_const_get(rb_cFile, rb_intern("SEPARATOR")))->ptr[0];
strcpy(datadir, lichdir);
strcat(datadir, "data");
datadir[strlen(datadir)] = lichdir[strlen(lichdir) - 1];
rb_gv_set("$data_dir", rb_str_new(datadir, strlen(datadir)));
rb_gv_set("$lich_dir", rb_str_new(lichdir, strlen(lichdir)));
ruby_safe_level = 0;
if (nerr = ruby_exec()) {
tmp = RSTRING(rb_funcall(rb_gv_get("$!"), rb_intern("to_s"), 0))->ptr;
if (!strncasecmp(tmp, "exit", 4)) ruby_stop(0);
fprintf(stderr, "%s\n", tmp);
fprintf(stderr, "%s\n", RSTRING(rb_funcall(rb_funcall(rb_gv_get("$!"), rb_intern("backtrace"), 0), rb_intern("join"), 1, rb_str_new2("\n")))->ptr);
ruby_stop(nerr);
}
ruby_stop(0);
}
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
}
VALUE makeProtectedCall(const std::string &t_functionName, std::vector<VALUE> &t_params)
{
// we go through all of this because we cannot rb_protect a call to
// rb_funcall. At least not in any way I can find.
std::stringstream params;
for (size_t i = 0; i < t_params.size(); ++i)
{
std::stringstream ss;
ss << "$embedded_ruby_param_" << i;
rb_define_variable(ss.str().c_str(), &t_params[i]);
params << ss.str();
if (i < t_params.size() - 1)
{
params << ", ";
}
}
std::string funcall = "$embedded_ruby_return = " + t_functionName + "(" + params.str() + ")";
evalString(funcall);
VALUE retval = rb_gv_get("$embedded_ruby_return");
return retval;
}
static VALUE
rg_print(int argc, VALUE *argv, VALUE out)
{
int i;
VALUE line;
VALUE output_field_separator;
/* if no argument given, print `$_' */
if (argc == 0) {
argc = 1;
line = rb_lastline_get();
argv = &line;
}
output_field_separator = rb_gv_get("$,");
for (i=0; i<argc; i++) {
if (!NIL_P(output_field_separator) && i>0) {
rg_write(out, output_field_separator);
}
switch (TYPE(argv[i])) {
case T_NIL:
rg_write(out, rb_str_new2("nil"));
break;
default:
rg_write(out, argv[i]);
break;
}
}
if (!NIL_P(output_field_separator)) {
rg_write(out, output_field_separator);
}
return Qnil;
}
rpmRC rpmrubyRunFile(rpmruby ruby, const char * fn, const char ** resultp)
{
rpmRC rc = RPMRC_FAIL;
RUBYDBG((stderr, "--> %s(%p,%s,%p)\n", __FUNCTION__, ruby, fn, resultp));
if (ruby == NULL) ruby = rpmrubyI();
if (fn == NULL)
goto exit;
#if defined(WITH_RUBYEMBED)
#if !defined(HAVE_RUBY_DEFINES_H) /* XXX ruby-1.8.6 */
rb_load_file(fn);
ruby->state = ruby_exec();
#else
ruby->state = ruby_exec_node(rb_load_file(fn));
#endif
if (resultp != NULL)
*resultp = RSTRING_PTR(rb_gv_get("$result"));
rc = RPMRC_OK;
#endif /* WITH_RUBYEMBED */
exit:
RUBYDBG((stderr, "<-- %s(%p,%s,%p) rc %d\n", __FUNCTION__, ruby, fn, resultp, rc));
return rc;
}
RUBYMQ_EXTERN void Init_rubymsgque() {
// Register system
#ifdef HAVE_FORK
// MqInitSysAPI(NS(fork),NULL);
#endif
// Initialize components
NS(MqS_Init)();
NS(MqSException_Init)();
NS(MqBufferS_Init)();
// get the script name
VALUE a0 = rb_gv_get("$0");
// init libmsgque global data
if (MqInitBuf == NULL && !NIL_P(a0)) {
struct MqBufferLS * initB = MqInitCreate();
MqBufferLAppendC(initB, VAL2CST(rb_argv0));
MqBufferLAppendC(initB, VAL2CST(a0));
}
// set global data
id_receiver = rb_intern("receiver");
id_clone = rb_intern("clone");
id_unbind = rb_intern("unbind");
id_bind = rb_intern("bind");
}
static VALUE ruby_coroutine_body_require(const char* file)
{
int error;
VALUE result = rb_protect((VALUE (*)(VALUE))rb_require,
(VALUE)file, &error);
if (error)
{
printf("rb_require('%s') failed with status=%d\n",
file, error);
VALUE exception = rb_gv_get("$!");
if (RTEST(exception))
{
printf("... because an exception was raised:\n");
fflush(stdout);
VALUE inspect = rb_inspect(exception);
rb_io_puts(1, &inspect, rb_stderr);
VALUE backtrace = rb_funcall(
exception, rb_intern("backtrace"), 0);
rb_io_puts(1, &backtrace, rb_stderr);
}
}
return result;
}
static rpmRC rpmrubyRunThreadFile(rpmruby ruby, const char * fn,
const char **resultp)
{
int error;
VALUE result;
rpmRC rc = RPMRC_FAIL; /* assume failure */
result = rb_protect((VALUE (*)(VALUE))rb_require, (VALUE)fn, &error);
if (error) {
fprintf(stderr, "rb_require('%s') failed with status=%d\n",
fn, error);
VALUE exception = rb_gv_get("$!");
if (RTEST(exception)) {
fprintf(stderr, "... because an exception was raised:\n");
VALUE inspect = rb_inspect(exception);
rb_io_puts(1, &inspect, rb_stderr);
VALUE backtrace = rb_funcall(
exception, rb_intern("backtrace"), 0);
rb_io_puts(1, &backtrace, rb_stderr);
}
} else {
/* XXX FIXME: check result */
rc = RPMRC_OK;
}
return rc;
}
std::string GetExceptionInfo()
{
VALUE exception = rb_gv_get("$!");
if (NIL_P(exception))
return std::string("No exception");
VALUE klass = rb_funcall(rb_funcall(exception,
rb_intern("class"),
0),
rb_intern("to_s"),
0);
VALUE to_s = rb_funcall(exception, rb_intern("to_s"), 0);
VALUE backtrace = rb_funcall(rb_funcall(exception,
rb_intern("backtrace"),
0),
rb_intern("join"),
1,
rb_str_new2("\n"));
std::string info;
info += StringValuePtr(klass);
info += ": ";
info += StringValuePtr(to_s);
info += '\n';
info += StringValuePtr(backtrace);
return info;
}
VALUE ss_rstring_assign_global_foobar(VALUE self) {
VALUE var = rb_gv_get("$global_rstring_test");
RSTRING(var)->len = 6;
RSTRING(var)->ptr = ALLOC_N(char, 7);
memcpy(RSTRING(var)->ptr, "foobar", 7);
return Qnil;
}
static void iroffer_ruby_errro(int error)
{
VALUE lasterr;
VALUE inclass;
VALUE message;
VALUE ary;
long c;
if (error == 0)
return;
lasterr = rb_gv_get("$!"); /* NOTRANSLATE */
inclass = rb_class_path(CLASS_OF(lasterr));
message = rb_obj_as_string(lasterr);
outerror(OUTERROR_TYPE_WARN_LOUD,
"error ruby_script: class=%s, message=%s",
RSTRING_PTR(inclass), RSTRING_PTR(message));
if (!NIL_P(rb_errinfo())) {
ary = rb_funcall(rb_errinfo(), rb_intern("backtrace"), 0);
for (c=0; c<RARRAY_LEN(ary); ++c) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"backtrace from %s",
RSTRING_PTR(RARRAY_PTR(ary)[c]));
}
}
}
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 void LogError(){
VALUE lasterr = rb_gv_get("$!");
VALUE message = rb_obj_as_string(lasterr);
VALUE array = rb_funcall(lasterr, rb_intern("backtrace"), 0);
VALUE backtrace = rb_funcall(array, rb_intern("join"), 1, rb_str_new2("\n\t"));
std::cout << "\t" << RSTRING_PTR(message) << std::endl;
std::cout << RSTRING_PTR(backtrace) << std::endl;
}
static void coverage_event_coverage_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass) {
char *sourcefile;
unsigned int sourceline;
static unsigned int in_hook = 0;
if(in_hook) {
return;
}
in_hook++;
#if COVERAGE_DEBUG_EVENTS
do {
int status;
VALUE old_exception;
old_exception = rb_gv_get("$!");
rb_protect(rb_inspect, klass, &status);
if(!status) {
printf("EVENT: %d %s %s %s %d\n", event,
klass ? RSTRING(rb_inspect(klass))->ptr : "",
mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
: "unknown",
node ? node->nd_file : "", node ? nd_line(node) : 0);
}
else {
printf("EVENT: %d %s %s %d\n", event,
mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
: "unknown",
node ? node->nd_file : "", node ? nd_line(node) : 0);
}
rb_gv_set("$!", old_exception);
} while (0);
#endif
if(event & RUBY_EVENT_C_CALL) {
coverage_mark_caller();
}
if(event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS)) {
in_hook--;
return;
}
if(node == NULL) {
in_hook--;
return;
}
sourcefile = node->nd_file;
sourceline = nd_line(node) - 1;
coverage_increase_counter_cached(sourcefile, sourceline);
if(event & RUBY_EVENT_CALL)
coverage_mark_caller();
in_hook--;
}
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();
}
SEXP
R_rb_gv_get(SEXP r_name, SEXP r_convert)
{
const char *name;
VALUE val;
name = CHAR(STRING_ELT(r_name, 0));
val = rb_gv_get(name);
return(convertRubyToR(val, r_convert));
}
static CMPIString *
get_exc_trace(const CMPIBroker* broker)
{
VALUE exception = rb_gv_get("$!"); /* get last exception */
VALUE reason = rb_funcall(exception, rb_intern("to_s"), 0 );
VALUE trace = rb_gv_get("$@"); /* get last exception trace */
VALUE backtrace;
char* tmp;
CMPIString *result;
if (NIL_P(exception)) {
return NULL;
}
backtrace = rb_funcall(trace, rb_intern("join"), 1, rb_str_new("\n\t", 2));
tmp = fmtstr("%s\n\t%s", StringValuePtr(reason), StringValuePtr(backtrace));
result = broker->eft->newString(broker, tmp, NULL);
free(tmp);
return result;
}
void
Init_wizardparser()
{
lich_cScript = rb_eval_string("Script");
rb_define_singleton_method(lich_cScript, "wizard_label_check", wizard_label_check, 1);
rb_define_method(lich_cScript, "wizard_parse_file", wizard_parse_file, 1);
id_lines = rb_intern("@lines");
id_labels = rb_intern("@labels");
rb_global_variable(&id_lines);
rb_global_variable(&id_labels);
#ifdef __MINGW32__
rb_ary_push(rb_gv_get("$\""), rb_str_new2("wizardparser.dll"));
#else
rb_ary_push(rb_gv_get("$\""), rb_str_new2("wizardparser.so"));
#endif
}
static void rb_report_error()
{
VALUE lasterr = rb_gv_get("$!");
VALUE message = rb_obj_as_string(lasterr);
char*msg = RSTRING(message)->ptr;
if(msg && *msg) {
printf("Ruby Error:\n");
printf("%s\n", msg);
}
}
void ruby_toplevel_init(void)
{
VALUE argv0;
argv0 = rb_gv_get("$0");
toplevel = s_toplevel_new();
g_rc_parse(toplevel, StringValueCStr(argv0), "grubyrc", NULL);
i_vars_libgeda_set(toplevel);
}
void Init_scanner ()
{
cScanner = rb_define_class("Scanner", rb_cObject);
rb_define_method(cScanner, "initialize", t_init, 0);
rb_define_method(cScanner, "next_token", t_next_token, 0);
rb_define_method(cScanner, "lineno", t_lineno, 0);
id_push = rb_intern("push");
id_clear = rb_intern("clear");
id_to_s = rb_intern("to_s");
obj_false = rb_gv_get("false");
}
static VALUE initrb_interpreter_begin(VALUE file) {
/** `file' may be a symlink or a relative path, expand it and dereference all symlinks **/
VALUE real_name = rb_funcall(rb_cFile, rb_intern("realpath"), 1, file);
VALUE dir = rb_file_dirname(real_name);
/** Add the file's directory to the library search path **/
rb_ary_unshift(rb_gv_get(":"), dir);
/** Run the interpreter */
return initrb_interpreter_boot(real_name);
}
static void reg32_setup()
{
char *tmp;
if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\DataBasePath")) {
rb_gv_set("$hosts_dir", rb_str_new2(tmp));
free(tmp);
}
else if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\DataBasePath")) {
rb_gv_set("$hosts_dir", rb_str_new2(tmp));
free(tmp);
}
if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "Software\\Simutronics\\SGE32\\Directory")) {
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("SGE Directory"), rb_str_new2(tmp));
free(tmp);
}
if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "Software\\Simutronics\\Launcher\\Directory")) {
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("Launcher Directory"), rb_str_new2(tmp));
free(tmp);
}
if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "Software\\Simutronics\\WIZ32\\Directory")) {
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("Wizard Directory"), rb_str_new2(tmp));
free(tmp);
}
if (tmp = reg_get_value(HKEY_LOCAL_MACHINE, "Software\\Classes\\Simutronics.Autolaunch\\Shell\\Open\\command\\")) {
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("Launcher Shell Command"), rb_str_new2(tmp));
free(tmp);
}
if (tmp = getenv("windir")) {
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("Windows Directory"), rb_str_new2(tmp));
rb_hash_aset(rb_gv_get("$LICHCONFIG"), rb_str_new2("windir"), rb_str_new2(tmp));
}
}
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;
}
// ----------------------------------------------------------------------------
void RubyClassHandler::ShowRubyError(int error)
// ----------------------------------------------------------------------------
{
// Fetch the status error for rb_protected calls
// Other non-protected calls may throw an exception to the
// console/log and terminate the script. eg, wrong parameter count.
#if not defined(LOGGING)
return;
#endif
if(error == 0)
return;
wxString clog = wxEmptyString;
wxString endl = _T("\n");
VALUE lasterr = rb_gv_get("$!");
// class
VALUE klass = rb_class_path(CLASS_OF(lasterr));
clog << "class = " << RSTRING(klass)->ptr << endl;
// message
VALUE message = rb_obj_as_string(lasterr);
clog << "message = " << RSTRING(message)->ptr << endl;
// backtrace
if(!NIL_P(ruby_errinfo)) {
//-std::ostringstream o;
wxString o = "";
VALUE ary = rb_funcall(
ruby_errinfo, rb_intern("backtrace"), 0);
int c;
for (c=0; c<RARRAY(ary)->len; c++) {
o << "\tfrom " <<
clog << "\tfrom " <<
RSTRING(RARRAY(ary)->ptr[c])->ptr <<
"\n";
}
//-clog << "backtrace = " << o.str() << endl;
clog << "backtrace = " << o << endl;
}
//-throw runtime_error("ruby_error");
#if defined(LOGGING)
LOGIT( _T("Ruby Error:[%s]"), clog.c_str());
#endif
ID method = rb_intern("puts");
if (MethodExists(rb_mKernel, _T("puts")))
rb_funcall(rb_mKernel, method, 1, rb_str_new2(clog.c_str() ));
}
VALUE RubyEvaluator::GetContext(KObjectRef global)
{
std::string theid = this->GetContextId(global);
VALUE ctx = rb_gv_get(theid.c_str());
if (ctx == Qnil)
{
VALUE ctx_class = rb_define_class("KrollRubyContext", rb_cObject);
rb_define_method(ctx_class, "method_missing", VALUEFUNC(m_missing), -1);
ctx = rb_obj_alloc(ctx_class);
rb_gv_set(theid.c_str(), ctx);
}
return ctx;
}
void RubyEvaluator::Evaluate(const ValueList& args, KValueRef result)
{
args.VerifyException("evaluate", "s s s o");
//const char *mimeType = args.GetString(0).c_str();
std::string name = args.GetString(1);
std::string code = args.GetString(2);
global_object = args.GetObject(3);
VALUE ctx = this->GetContext(global_object);
VALUE rargs = rb_ary_new();
rb_ary_push(rargs, ctx);
rb_ary_push(rargs, rb_str_new2(code.c_str()));
int error;
VALUE returnValue = rb_protect(reval_do_call, rargs, &error);
RubyEvaluator::ContextToGlobal(ctx, global_object);
if (error != 0)
{
std::string error("An error occured while parsing Ruby (");
error += name;
error += "): ";
// Display a stringified version of the exception.
VALUE exception = rb_gv_get("$!");
KValueRef v = RubyUtils::ToKrollValue(exception);
SharedString ss = v->DisplayString();
error.append(ss->c_str());
// Try to make a nice backtrace for the user.
VALUE backtrace = rb_funcall(exception,
rb_intern("backtrace"), 0);
VALUE rBacktraceString = rb_funcall(backtrace,
rb_intern("join"), 1, rb_str_new2("\n"));
if (TYPE(rBacktraceString) == T_STRING)
{
error.append("\n");
error.append(StringValuePtr(rBacktraceString));
}
Logger *logger = Logger::Get("Ruby");
logger->Error(error);
result->SetUndefined();
return;
}
result->SetValue(RubyUtils::ToKrollValue(returnValue));
}
void uwsgi_ruby_exception(void) {
VALUE lasterr = rb_gv_get("$!");
VALUE message = rb_obj_as_string(lasterr);
uwsgi_log("%s\n", RSTRING_PTR(message));
if(!NIL_P(rb_errinfo())) {
VALUE ary = rb_funcall(rb_errinfo(), rb_intern("backtrace"), 0);
int i;
for (i=0; i<RARRAY_LEN(ary); i++) {
uwsgi_log("%s\n", RSTRING_PTR(RARRAY_PTR(ary)[i]));
}
}
}
static VALUE
rg_s_init(int argc, VALUE *argv, VALUE self)
{
gint i, gargc;
VALUE argary;
char** gargv;
VALUE progname;
if (_initialized)
return self;
else
_initialized = TRUE;
rb_scan_args(argc, argv, "01", &argary);
if (NIL_P(argary)){
argary = rb_const_get(rb_cObject, rb_intern("ARGV"));
gargc = RARRAY_LEN(argary);
} else {
Check_Type(argary, T_ARRAY);
gargc = RARRAY_LEN(argary);
}
gargv = ALLOCA_N(char *, gargc + 1);
progname = rb_gv_get("$0");
gargv[0] = (char *)RVAL2CSTR(progname);
for (i = 0; i < gargc; i++)
if (TYPE(RARRAY_PTR(argary)[i]) == T_STRING)
gargv[i+1] = (char *)RVAL2CSTR(RARRAY_PTR(argary)[i]);
else
gargv[i+1] = (char *)"";
gargc++;
{
gboolean is_initialized;
is_initialized = gtk_init_check(&gargc, &gargv);
if (! is_initialized) {
const char *display_name_arg = gdk_get_display_arg_name();
display_name_arg = display_name_arg ? display_name_arg : g_getenv("DISPLAY");
rb_raise(rbgtk_eGtkInitError, "Cannot open display: %s",
display_name_arg ? display_name_arg : " ");
}
setlocale(LC_NUMERIC, "C");
}
return self;
}
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);
}
