コード例 #1
0
void RubyInterpreter::initRuby()
{
    d = new RubyInterpreterPrivate();
    ruby_init();
    ruby_init_loadpath();
    rb_define_global_function("require", (VALUE (*)(...))RubyInterpreter::require, 1);
}
コード例 #2
0
ファイル: plugin-ruby.c プロジェクト: thorgul/proxenet
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;
}
コード例 #3
0
ファイル: initrb.c プロジェクト: numinit/initrb
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;
}
コード例 #4
0
ファイル: main.c プロジェクト: weimingtom/eriri_lua
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);
}
コード例 #5
0
ファイル: eruta.c プロジェクト: beoran/eruta
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);
  */
  
}
コード例 #6
0
ファイル: c_call_rb.c プロジェクト: windwiny/c_embedd_ruby
void crb_init() {
	int argc2 = 0;
	char **argv2 = NULL;

	ruby_sysinit(&argc2, &argv2);
	RUBY_INIT_STACK;
	ruby_init();
	ruby_init_loadpath();
}
コード例 #7
0
ファイル: rpmruby.c プロジェクト: hahnakane/junkcode
static void * rpmrubyThread(void * _ruby)
{
    rpmruby ruby = _ruby;
    rpmzLog zlog = ruby->zlog;
    int i;

    Trace((zlog, "-- %s: running", __FUNCTION__));

    _rpmruby_ruby_to_main(ruby, Qnil);

    for (i = 0; i < 2; i++)
        _rpmruby_ruby_to_main(ruby, Qnil);

    {
	VALUE variable_in_this_stack_frame;
	uint8_t * b = ruby->stack;
	uint8_t * e = b + ruby->nstack;

	/* Start up the ruby interpreter. */
	Trace((zlog, "-- %s: interpreter starting", __FUNCTION__));
	ruby_sysinit(&ruby->ac, (char ***) &ruby->av);

        ruby_bind_stack((VALUE *)b, (VALUE *)e);

	ruby_init_stack(&variable_in_this_stack_frame);
        ruby_init();
	ruby_init_loadpath();

        /* allow Ruby script to relay */
        rb_define_module_function(rb_mKernel, "relay_from_ruby_to_main",
                                  relay_from_ruby_to_main, 0);
	Trace((zlog, "-- %s: interpreter started", __FUNCTION__));

	/* Run file.rb arguments. */
	for (i = 1; i < ruby->ac; i++) {
	    if (*ruby->av[i] == '-')	/* XXX FIXME: skip options. */
		continue;
	    Trace((zlog, "-- %s: require '%s' begin", __FUNCTION__, ruby->av[i]));
	    rpmrubyRunThreadFile(ruby, ruby->av[i], NULL);
	    Trace((zlog, "-- %s: require '%s' end", __FUNCTION__, ruby->av[i]));
	}

	/* Terminate the ruby interpreter. */
	Trace((zlog, "-- %s: interpreter terminating", __FUNCTION__));
	ruby_finalize();
        ruby_cleanup(0);
	Trace((zlog, "-- %s: interpreter terminated", __FUNCTION__));
    }

    /* Report interpreter end to main. */
    ruby->more = 0;
    /* Permit main thread to run without blocking. */
    yarnRelease(ruby->main_coroutine_lock);

    Trace((zlog, "-- %s: ended", __FUNCTION__));
    return NULL;
}
コード例 #8
0
ファイル: rb_define.c プロジェクト: Passerby/fsnet
void
fs_rb_init(int argc,  char** argv){
    
    ruby_sysinit(&argc, &argv);
    RUBY_INIT_STACK
    ruby_init();
    ruby_init_loadpath();
    ruby_set_argv(argc, argv);
    Init_fsnet();
    
}
コード例 #9
0
ファイル: xen.c プロジェクト: OS2World/MM-SOUND-Snd
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();
}
コード例 #10
0
int main ( int argc, char ** argv) 	{
    ruby_set_debug_option(getenv("RUBY_DEBUG"));
	ruby_sysinit(&argc, &argv);
	RUBY_INIT_STACK;
	ruby_init();
	ruby_init_loadpath();
	setbuf(stdout, NULL); // disable buffering
	rb_protect( test_iseq, 0, & error);// call our stuff rb_protect'ed
	perror("ERROR");
	return ruby_run_node(ruby_options(argc, argv));
 	ruby_finalize();
 	return 0;
}
コード例 #11
0
ファイル: fancy_read.c プロジェクト: fourmond/tioga
int main()
{
  ruby_init();
  ruby_init_loadpath();
  Init_Dvector();
  VALUE cls = rb_eval_string("Dobjects::Dvector");
  VALUE res;
  
  res = rb_eval_string("Dobjects::Dvector.fast_fancy_read"
		       "(File.open('tmp.dat', 'r'), "
		       "Dobjects::Dvector::FANCY_READ_DEFAULTS)");
  return 0;
}
コード例 #12
0
ファイル: main.c プロジェクト: solccp/mpi-ruby
int main(int argc, char *argv[])
{
    void (*sigusr1)(int), (*sigusr2)(int);

    MPI_Init(&argc, &argv);

    /* ruby_run() calls exit() (why?), so we have to call finalize this way. */
    atexit((void (*)(void))MPI_Finalize);

    /* Allow errors to be returned as exceptions in ruby */
    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);

    /* This seems legitimate because comms can be passed by value to fns. */
    self = malloc(sizeof(MPI_Comm));
    if (self == NULL) {
        perror("Unable to allocate MPI::Comm::SELF");
        MPI_Finalize();
        exit(1);
    }
    *self = MPI_COMM_SELF;

    world = malloc(sizeof(MPI_Comm));
    if (self == NULL) {
        perror("Unable to allocate MPI::Comm::WORLD");
        MPI_Finalize();
        exit(1);
    }
    *world = MPI_COMM_WORLD;

    MPI_Barrier(*world);
    sigusr1 = signal(SIGUSR1, SIG_IGN);
    sigusr2 = signal(SIGUSR2, SIG_IGN);

    ruby_init();
    ruby_init_loadpath();
    ruby_options(argc, argv);

    signal(SIGUSR1, sigusr1);
    signal(SIGUSR2, sigusr2);
    MPI_Barrier(*world);

    Init_MPI();

    ruby_run();

    /* Unreachable */

    MPI_Finalize();

    return 0;
}
コード例 #13
0
ファイル: ruby_module.cpp プロジェクト: mital/kroll
	void RubyModule::Initialize()
	{
		RubyModule::instance_ = this;

		ruby_init();
		ruby_init_loadpath();

		// Add the application directoy to the Ruby include path so
		// that includes work in a intuitive way for application developers.
		ruby_incpush(host->GetApplication()->GetResourcesPath().c_str());

		this->InitializeBinding();
		host->AddModuleProvider(this);
	}
コード例 #14
0
ファイル: eruby_main.c プロジェクト: shugo/eruby
static void init()
{
    ruby_init();
#if RUBY_VERSION_CODE >= 160
    ruby_init_loadpath();
#else
#if RUBY_VERSION_CODE >= 145
    rb_ary_push(rb_load_path, rb_str_new2("."));
#endif
#endif
    if (eruby_mode == MODE_CGI || eruby_mode == MODE_NPHCGI)
	rb_set_safe_level(1);
    eruby_init();
}
コード例 #15
0
ファイル: ruby.c プロジェクト: Cloudxtreme/epic5
/* 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");
}
コード例 #16
0
ファイル: main.cpp プロジェクト: datalurkur/Mountainhome
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);
}
コード例 #17
0
	void RubyModule::Initialize()
	{
		RubyModule::instance_ = this;

		ruby_init();
		ruby_init_loadpath();

		// Add the application directoy to the Ruby include path so
		// that includes work in a intuitive way for application developers.
		ruby_incpush(UTF8ToSystem(host->GetApplication()->GetResourcesPath()).c_str());

        host->script()->AddInterpreter(&interpreter, supportedScriptTypes);

		host->AddModuleProvider(this);
	}
コード例 #18
0
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);
}
コード例 #19
0
ファイル: whook_rb.c プロジェクト: abhisek/wireplay
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;
}
コード例 #20
0
ファイル: ruby.c プロジェクト: raj347/modserver
static int mod_init(lua_State *l)
{
  int ret = ruby_setup();
  if (ret != 0)
  {
    return luaL_error(l, "ruby_setup: %d", ret);
  }
  ruby_init_loadpath();
  
  rb_define_global_function("rwrite", api_rwrite, 2);
  
  // VALUE api = rb_define_module("Api");
  // rb_define_module_function(api, "rwrite", api_rwrite, 0);
  // rb_define_const(mRUBBER, "TestConst", INT2NUM(38));
  
  return 0;
}
コード例 #21
0
ファイル: Ruby.c プロジェクト: authorNari/panda
static	void
init(
	MessageHandler	*handler)
{
	VALUE load_path;


	InitMONFUNC(RubyConv,
		JSON_PackValue,
		JSON_UnPackValue,
		JSON_SizeValue);

	ruby_init();
	ruby_init_loadpath();

	load_path = rb_eval_string("$LOAD_PATH");

	if (handler->loadpath == NULL) {
		handler->loadpath = getenv("APS_RUBY_PATH");
	}
	if (handler->loadpath == NULL) {
		handler->loadpath = getenv("RUBYLIB");
	}
	if (handler->loadpath == NULL) {
		handler->loadpath = MONTSUQI_LOAD_PATH;
	}
	rb_ary_push(load_path, rb_str_new2(handler->loadpath));

	application_classes = rb_hash_new();
	rb_gc_register_address(&application_classes);
	rb_global_variable(&application_classes);

	node_info = rb_hash_new();
	rb_gc_register_address(&node_info);
	rb_global_variable(&node_info);

	rb_define_global_function("monfunc", monfunc, 2);
	rb_define_global_const("MCP_OK"        ,INT2NUM(MCP_OK));
	rb_define_global_const("MCP_EOF"       ,INT2NUM(MCP_EOF));
	rb_define_global_const("MCP_NONFATAL"  ,INT2NUM(MCP_NONFATAL));
	rb_define_global_const("MCP_BAD_ARG"   ,INT2NUM(MCP_BAD_ARG));
	rb_define_global_const("MCP_BAD_FUNC"  ,INT2NUM(MCP_BAD_FUNC));
	rb_define_global_const("MCP_BAD_OTHER" ,INT2NUM(MCP_BAD_OTHER));
	rb_define_global_const("MCP_BAD_CONN"  ,INT2NUM(MCP_BAD_CONN));
}
コード例 #22
0
ファイル: if_ruby.c プロジェクト: LemonBoy/vim
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;
}
コード例 #23
0
ファイル: ruby.c プロジェクト: 0xroot/radare2
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;
}
コード例 #24
0
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;
}
コード例 #25
0
ファイル: core.c プロジェクト: UNIVERSAL-IT-SYSTEMS/elinks-1
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);
}
コード例 #26
0
ファイル: embed.c プロジェクト: BackupTheBerlios/rubyk
// 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);
}
コード例 #27
0
ファイル: ruby.cpp プロジェクト: bdheeman/mod_ruby
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;
}
コード例 #28
0
ファイル: embed.c プロジェクト: MagnusTiberius/code
int main()
{
  // 1. init interpreter
  ruby_init();
  ruby_init_loadpath();
  //ruby_script("embed.rb");

  // 2. load global objects
  Init_SysInfo();

  // 3. run script
  // int state = eval_buffer("puts \"kamin babo\"\nprint $hardware");
  // int state = eval_file("/Users/yielding/test/rb/embed/embed.rb");
  int state = eval_file("embed.rb");
  if (state) 
    printf("error\n");

  print_array(hardware_list);

  // 4. finalize
  // ruby_finalize();
  ruby_cleanup(0);
}
コード例 #29
0
ファイル: embed.c プロジェクト: asengupta/cef-ruby
int main(int argc, char *argv[])
{
  int i;
  for(i=0; i <= argc - 1; ++i)
  {
    printf("%s", argv[i]);
  }
	ruby_sysinit(&argc, &argv);
	{
  	RUBY_INIT_STACK;
  	ruby_init();
  	ruby_init_loadpath();
    VALUE array = rb_ary_new2(argc);
    for(i=0; i <= argc - 1; ++i)
    {
      rb_ary_push(array, rb_str_new2(argv[i]));
    }

    rb_funcall(Qnil, rb_intern("require"), 1, rb_str_new2("./libcef-test.rb"));
    rb_funcall(Qnil, rb_intern("run"), 1, array);
	}
	return 0;
}
コード例 #30
0
ファイル: target_ruby.c プロジェクト: jsafrane/cmpi-bindings
static int
RbGlobalInitialize(const CMPIBroker* broker, CMPIStatus* st)
{
  char *loadpath;
  VALUE searchpath;

  _SBLIM_TRACE(1,("<%d> Ruby: RbGlobalInitialize, stack @ %p", getpid(), &searchpath));
  ruby_init();
  ruby_init_loadpath();

  extern void SWIG_init();
  SWIG_init();

  searchpath = rb_gv_get("$:");
  /* Append /usr/share/cmpi to $: */
  rb_ary_push(searchpath, rb_str_new2("/usr/share/cmpi"));

  /* Check RUBY_PROVIDERS_DIR_ENV if its a dir, append to $: */
  loadpath = getenv(RUBY_PROVIDERS_DIR_ENV);
  if (loadpath) {
    struct stat buf;
    if (stat(loadpath, &buf)) {
      _SBLIM_TRACE(1,("<%d> Can't stat $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
      return -1;
    }
    if ((buf.st_mode & S_IFDIR) == 0) {
      _SBLIM_TRACE(1,("<%d> Not a directory: $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
      return -1;
    }
    _SBLIM_TRACE(1,("<%d> Loading providers from: $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
    rb_ary_push(searchpath, rb_str_new2(loadpath));
  }
  else {
    _SBLIM_TRACE(0, ("<%d> Hmm, %s not set ?!", getpid(), RUBY_PROVIDERS_DIR_ENV)); 
  }
  return 0;
}