void EnumDescriptor_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "EnumDescriptor", rb_cObject);
rb_define_alloc_func(klass, EnumDescriptor_alloc);
rb_define_method(klass, "name", EnumDescriptor_name, 0);
rb_define_method(klass, "name=", EnumDescriptor_name_set, 1);
rb_define_method(klass, "add_value", EnumDescriptor_add_value, 2);
rb_define_method(klass, "lookup_name", EnumDescriptor_lookup_name, 1);
rb_define_method(klass, "lookup_value", EnumDescriptor_lookup_value, 1);
rb_define_method(klass, "each", EnumDescriptor_each, 0);
rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
rb_include_module(klass, rb_mEnumerable);
cEnumDescriptor = klass;
rb_gc_register_address(&cEnumDescriptor);
}
/* Init */
void
Init_webkit(void)
{
mWebKit = rb_define_module("WebKit");
rb_define_singleton_method(mWebKit, "set_web_database_path", WebKit_CLASS_set_web_database_path, 1);
rb_define_singleton_method(mWebKit, "remove_all_web_databases", WebKit_CLASS_remove_all_web_databases, 0);
rb_define_singleton_method(mWebKit, "set_default_web_database_quota", WebKit_CLASS_set_default_web_database_quota, 1);
cJavascriptError = rb_define_class_under(mWebKit, "JavascriptError", rb_eStandardError);
cWebSettings = G_DEF_CLASS(WEBKIT_TYPE_WEB_SETTINGS, "WebSettings", mWebKit);
rb_define_method(cWebSettings, "initialize", WebSettings_initialize, 0);
cWebFrame = G_DEF_CLASS(WEBKIT_TYPE_WEB_FRAME, "WebFrame", mWebKit);
rb_define_method(cWebFrame, "exec_js", WebFrame_exec_js, 1);
rb_define_method(cWebFrame, "setup_ruby", WebFrame_setup_ruby, 0);
rb_define_method(cWebFrame, "add_js_api", WebFrame_add_js_api, 1);
rb_define_method(cWebFrame, "load_string", WebFrame_load_string, 4);
cWebView = G_DEF_CLASS(WEBKIT_TYPE_WEB_VIEW, "WebView", mWebKit);
rb_define_method(cWebView, "initialize", WebView_initialize, 0);
rb_define_method(cWebView, "open", WebView_open, 1);
rb_define_method(cWebView, "execute_script", WebView_execute_script, 1);
rb_define_method(cWebView, "set_settings", WebView_set_settings, 1);
rb_define_method(cWebView, "load_string", WebView_load_string, 4);
rb_define_method(cWebView, "load_uri", WebView_load_uri, 1);
rb_define_method(cWebView, "main_frame", WebView_main_frame, 0);
rb_define_method(cWebView, "focused_frame", WebView_focused_frame, 0);
rb_define_method(cWebView, "progress", WebView_progress, 0);
rb_define_method(cWebView, "title", WebView_title, 0);
rb_define_method(cWebView, "uri", WebView_uri, 0);
rb_define_method(cWebView, "reload", WebView_reload, 0);
rb_define_method(cWebView, "reload_bypass_cache", WebView_reload_bypass_cache, 0);
rb_define_method(cWebView, "set_custom_encoding", WebView_set_custom_encoding, 1);
rb_define_method(cWebView, "stop_loading", WebView_stop_loading, 0);
cTargetInfo = G_DEF_CLASS(WEBKIT_TYPE_WEB_VIEW_TARGET_INFO, "TargetInfo", cWebView);
cViewMode = G_DEF_CLASS(WEBKIT_TYPE_WEB_VIEW_VIEW_MODE, "ViewMode", cWebView);
cDownloadStatus = G_DEF_CLASS(WEBKIT_TYPE_DOWNLOAD_STATUS, "DownloadStatus", mWebKit);
cDownloadError = G_DEF_CLASS(WEBKIT_TYPE_DOWNLOAD_ERROR, "DownloadError", mWebKit);
cNetworkError = G_DEF_CLASS(WEBKIT_TYPE_NETWORK_ERROR, "NetworkError", mWebKit);
cPolicyError = G_DEF_CLASS(WEBKIT_TYPE_POLICY_ERROR, "PolicyError", mWebKit);
cPluginError = G_DEF_CLASS(WEBKIT_TYPE_PLUGIN_ERROR, "PluginError", mWebKit);
cCacheModel = G_DEF_CLASS(WEBKIT_TYPE_CACHE_MODEL, "CacheModel", mWebKit);
cHitTestResultContext = G_DEF_CLASS(WEBKIT_TYPE_HIT_TEST_RESULT_CONTEXT, "HitTestResultContext", mWebKit);
cLoadStatus = G_DEF_CLASS(WEBKIT_TYPE_LOAD_STATUS, "LoadStatus", mWebKit);
cNavigationReason = G_DEF_CLASS(WEBKIT_TYPE_WEB_NAVIGATION_REASON, "NavigationReason", mWebKit);
cEditingBehavior = G_DEF_CLASS(WEBKIT_TYPE_EDITING_BEHAVIOR, "EditingBehavior", mWebKit);
cNavigationResponse = G_DEF_CLASS(WEBKIT_TYPE_NAVIGATION_RESPONSE, "NavigationResponse", mWebKit);
cSelectionAffinity = G_DEF_CLASS(WEBKIT_TYPE_SELECTION_AFFINITY, "SelectionAffinity", mWebKit);
cInsertAction = G_DEF_CLASS(WEBKIT_TYPE_INSERT_ACTION, "InsertAction", mWebKit);
rb_gc_register_address(&_gcpool_RubyFunc);
}
VALUE rb_fiber_schedule_to_req() {
int id = uwsgi.wsgi_req->async_id;
if (!uwsgi.wsgi_req->suspended) {
ufiber.fib[id] = rb_fiber_new(uwsgi_fiber_request, Qnil);
rb_gc_register_address(&ufiber.fib[id]);
uwsgi.wsgi_req->suspended = 1;
}
rb_fiber_resume(ufiber.fib[id], 0, NULL);
if (uwsgi.wsgi_req->suspended) {
uwsgi.wsgi_req->async_status = UWSGI_AGAIN;
}
return Qnil;
}
void connection_start(backend_t *backend, int fd, struct sockaddr_in remote_addr)
{
connection_t *c = (connection_t *) queue_pop(&backend->connections);
/* no free connection found, add more */
if (c == NULL) {
connections_push(backend);
c = (connection_t *) queue_pop(&backend->connections);
}
assert(c != NULL);
/* init connection */
c->finished = 0;
c->loop = backend->loop;
c->backend = backend;
c->content_length = 0;
c->fd = fd;
c->remote_addr = inet_ntoa(remote_addr.sin_addr);
c->thread.obj = Qnil;
c->thread.active = 0;
/* mark as used to Ruby GC */
c->env = rb_hash_new();
rb_gc_register_address(&c->env);
/* reset buffers */
buffer_reset(&c->read_buffer);
buffer_reset(&c->write_buffer);
/* reinit parser */
http_parser_init(&c->parser);
c->parser.data = c;
/* init libev stuff */
c->read_watcher.data = c;
c->write_watcher.data = c;
c->timeout_watcher.data = c;
ev_io_init(&c->read_watcher, connection_readable_cb, c->fd, EV_READ | EV_ERROR);
ev_io_init(&c->write_watcher, connection_writable_cb, c->fd, EV_WRITE | EV_ERROR);
ev_timer_init(&c->timeout_watcher, connection_timeout_cb, backend->timeout, backend->timeout);
/* start event watchers */
ev_timer_start(c->loop, &c->timeout_watcher);
ev_io_start(c->loop, &c->read_watcher);
}
static void
sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, SaxOptions options) {
ox_sax_buf_init(&dr->buf, io);
dr->buf.dr = dr;
stack_init(&dr->stack);
dr->handler = handler;
dr->value_obj = rb_data_object_alloc(ox_sax_value_class, dr, 0, 0);
rb_gc_register_address(&dr->value_obj);
dr->options = *options;
dr->hints = 0;
dr->err = 0;
has_init(&dr->has, handler);
#if HAS_ENCODING_SUPPORT
if ('\0' == *ox_default_options.encoding) {
VALUE encoding;
dr->encoding = 0;
if (rb_respond_to(io, ox_external_encoding_id) && Qnil != (encoding = rb_funcall(io, ox_external_encoding_id, 0))) {
int e = rb_enc_get_index(encoding);
if (0 <= e) {
dr->encoding = rb_enc_from_index(e);
}
}
} else {
dr->encoding = rb_enc_find(ox_default_options.encoding);
}
#elif HAS_PRIVATE_ENCODING
if ('\0' == *ox_default_options.encoding) {
VALUE encoding;
if (rb_respond_to(io, ox_external_encoding_id) && Qnil != (encoding = rb_funcall(io, ox_external_encoding_id, 0))) {
dr->encoding = encoding;
} else {
dr->encoding = Qnil;
}
} else {
dr->encoding = rb_str_new2(ox_default_options.encoding);
}
#else
dr->encoding = 0;
#endif
}
static void
accept_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
{
int client_fd;
client_t *client;
struct sockaddr_in client_addr;
if ((events & PICOEV_TIMEOUT) != 0) {
// time out
// next turn or other process
return;
}else if ((events & PICOEV_READ) != 0) {
socklen_t client_len = sizeof(client_addr);
#ifdef linux
client_fd = accept4(fd, (struct sockaddr *)&client_addr, &client_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
#else
client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
#endif
if (client_fd != -1) {
#ifdef DEBUG
printf("accept fd %d \n", client_fd);
#endif
setup_sock(client_fd);
client = new_client_t(client_fd, client_addr);
client->environ = Qnil;
rb_gc_register_address(&client->environ);
init_parser(client, server_name, server_port);
picoev_add(loop, client_fd, PICOEV_READ, READ_LONG_TIMEOUT_SECS, r_callback, (void *)client);
}else{
if (errno != EAGAIN && errno != EWOULDBLOCK) {
// TODO:
// raise exception from errno
/* rb_raise(); */
/* write_error_log(__FILE__, __LINE__); */
// die
loop_done = 0;
}
}
}
}
void FieldDescriptor_register(VALUE module) {
VALUE klass = rb_define_class_under(
module, "FieldDescriptor", rb_cObject);
rb_define_alloc_func(klass, FieldDescriptor_alloc);
rb_define_method(klass, "name", FieldDescriptor_name, 0);
rb_define_method(klass, "name=", FieldDescriptor_name_set, 1);
rb_define_method(klass, "type", FieldDescriptor_type, 0);
rb_define_method(klass, "type=", FieldDescriptor_type_set, 1);
rb_define_method(klass, "label", FieldDescriptor_label, 0);
rb_define_method(klass, "label=", FieldDescriptor_label_set, 1);
rb_define_method(klass, "number", FieldDescriptor_number, 0);
rb_define_method(klass, "number=", FieldDescriptor_number_set, 1);
rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
rb_define_method(klass, "submsg_name=", FieldDescriptor_submsg_name_set, 1);
rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
rb_define_method(klass, "get", FieldDescriptor_get, 1);
rb_define_method(klass, "set", FieldDescriptor_set, 2);
cFieldDescriptor = klass;
rb_gc_register_address(&cFieldDescriptor);
}
void MessagePack_Unpacker_module_init(VALUE mMessagePack)
{
msgpack_unpacker_static_init();
cMessagePack_Unpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject);
eUnpackError = rb_define_class_under(mMessagePack, "UnpackError", rb_eStandardError);
eMalformedFormatError = rb_define_class_under(mMessagePack, "MalformedFormatError", eUnpackError);
eStackError = rb_define_class_under(mMessagePack, "StackError", eUnpackError);
eTypeError = rb_define_class_under(mMessagePack, "TypeError", rb_eStandardError);
rb_define_alloc_func(cMessagePack_Unpacker, Unpacker_alloc);
rb_define_method(cMessagePack_Unpacker, "initialize", Unpacker_initialize, -1);
rb_define_method(cMessagePack_Unpacker, "buffer", Unpacker_buffer, 0);
rb_define_method(cMessagePack_Unpacker, "read", Unpacker_read, 0);
rb_define_alias(cMessagePack_Unpacker, "unpack", "read");
rb_define_method(cMessagePack_Unpacker, "skip", Unpacker_skip, 0);
rb_define_method(cMessagePack_Unpacker, "skip_nil", Unpacker_skip_nil, 0);
rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0);
rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
//rb_define_method(cMessagePack_Unpacker, "peek_next_type", Unpacker_peek_next_type, 0); // TODO
rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1);
rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);
rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
s_unpacker_value = Unpacker_alloc(cMessagePack_Unpacker);
rb_gc_register_address(&s_unpacker_value);
Data_Get_Struct(s_unpacker_value, msgpack_unpacker_t, s_unpacker);
/* prefer reference than copying */
msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0);
/* MessagePack.unpack(x) */
rb_define_module_function(mMessagePack, "load", MessagePack_load_module_method, -1);
rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack_module_method, -1);
}
static VALUE
trans_prompt(int argc, VALUE * argv, VALUE obj)
{
VALUE tidVal = rb_ivar_get(obj, rb_intern("tid"));
if (TYPE(tidVal) != T_FIXNUM && TYPE(tidVal) != T_BIGNUM) {
rb_raise(rb_eException, "internal error, incorrect 'tid' ivar");
} else if (argc != 2) {
rb_raise(rb_eArgError, "wrong number of arguments");
} else if (!rb_block_given_p()) {
rb_raise(rb_eArgError, "block required for prompt method");
} else if (TYPE(argv[0]) != T_STRING) {
rb_raise(rb_eException,
"transaction.prompt requires a string path argument");
}
unsigned int tid = NUM2UINT(tidVal);
std::string path(RSTRING_PTR(argv[0]));
bp::Object * data = rubyToBPObject(argv[1]);
const BPElement * e = (data == NULL) ? NULL : data->elemPtr();
s_lock.lock();
unsigned int x = g_bpCoreFunctions->prompt(tid, (BPPath) path.c_str(), e,
dummyCB, NULL);
// grab the passed in block and increment a reference to it
VALUE val = rb_block_proc();
s_outstandingPrompts[x] = val;
rb_gc_register_address(&s_outstandingPrompts[x]);
s_lock.unlock();
// now call the block!
if (data != NULL) delete data;
// return the prompt id!
return Qnil;
}
VALUE
strb_InitializeFont(VALUE rb_mStarRuby)
{
VALUE rb_cFont = rb_define_class_under(rb_mStarRuby, "Font", rb_cObject);
rb_define_singleton_method(rb_cFont, "exist?", Font_s_exist, 1);
rb_define_singleton_method(rb_cFont, "new", Font_s_new, -1);
rb_define_alloc_func(rb_cFont, Font_alloc);
rb_define_private_method(rb_cFont, "initialize", Font_initialize, 5);
rb_define_method(rb_cFont, "bold?", Font_bold, 0);
rb_define_method(rb_cFont, "get_size", Font_get_size, 1);
rb_define_method(rb_cFont, "italic?", Font_italic, 0);
rb_define_method(rb_cFont, "name", Font_name, 0);
rb_define_method(rb_cFont, "size", Font_size, 0);
symbol_bold = ID2SYM(rb_intern("bold"));
symbol_italic = ID2SYM(rb_intern("italic"));
symbol_ttc_index = ID2SYM(rb_intern("ttc_index"));
rbFontCache = rb_hash_new();
rb_gc_register_address(&rbFontCache);
return rb_cFont;
}
void Map_register(VALUE module) {
VALUE klass = rb_define_class_under(module, "Map", rb_cObject);
rb_define_alloc_func(klass, Map_alloc);
cMap = klass;
rb_gc_register_address(&cMap);
rb_define_method(klass, "initialize", Map_init, -1);
rb_define_method(klass, "each", Map_each, 0);
rb_define_method(klass, "keys", Map_keys, 0);
rb_define_method(klass, "values", Map_values, 0);
rb_define_method(klass, "[]", Map_index, 1);
rb_define_method(klass, "[]=", Map_index_set, 2);
rb_define_method(klass, "has_key?", Map_has_key, 1);
rb_define_method(klass, "delete", Map_delete, 1);
rb_define_method(klass, "clear", Map_clear, 0);
rb_define_method(klass, "length", Map_length, 0);
rb_define_method(klass, "dup", Map_dup, 0);
rb_define_method(klass, "==", Map_eq, 1);
rb_define_method(klass, "hash", Map_hash, 0);
rb_define_method(klass, "inspect", Map_inspect, 0);
rb_define_method(klass, "merge", Map_merge, 1);
rb_include_module(klass, rb_mEnumerable);
}
void Init_rhebok()
{
request_method_key = rb_obj_freeze(rb_str_new2("REQUEST_METHOD"));
rb_gc_register_address(&request_method_key);
request_uri_key = rb_obj_freeze(rb_str_new2("REQUEST_URI"));
rb_gc_register_address(&request_uri_key);
script_name_key = rb_obj_freeze(rb_str_new2("SCRIPT_NAME"));
rb_gc_register_address(&script_name_key);
server_protocol_key = rb_obj_freeze(rb_str_new2("SERVER_PROTOCOL"));
rb_gc_register_address(&server_protocol_key);
query_string_key = rb_obj_freeze(rb_str_new2("QUERY_STRING"));
rb_gc_register_address(&query_string_key);
remote_addr_key = rb_obj_freeze(rb_str_new2("REMOTE_ADDR"));
rb_gc_register_address(&remote_addr_key);
remote_port_key = rb_obj_freeze(rb_str_new2("REMOTE_PORT"));
rb_gc_register_address(&remote_port_key);
set_common_header("ACCEPT",sizeof("ACCEPT") - 1, 0);
set_common_header("ACCEPT-ENCODING",sizeof("ACCEPT-ENCODING") - 1, 0);
set_common_header("ACCEPT-LANGUAGE",sizeof("ACCEPT-LANGUAGE") - 1, 0);
set_common_header("CACHE-CONTROL",sizeof("CACHE-CONTROL") - 1, 0);
set_common_header("CONNECTION",sizeof("CONNECTION") - 1, 0);
set_common_header("CONTENT-LENGTH",sizeof("CONTENT-LENGTH") - 1, 1);
set_common_header("CONTENT-TYPE",sizeof("CONTENT-TYPE") - 1, 1);
set_common_header("COOKIE",sizeof("COOKIE") - 1, 0);
set_common_header("HOST",sizeof("HOST") - 1, 0);
set_common_header("IF-MODIFIED-SINCE",sizeof("IF-MODIFIED-SINCE") - 1, 0);
set_common_header("REFERER",sizeof("REFERER") - 1, 0);
set_common_header("USER-AGENT",sizeof("USER-AGENT") - 1, 0);
set_common_header("X-FORWARDED-FOR",sizeof("X-FORWARDED-FOR") - 1, 0);
cRhebok = rb_const_get(rb_cObject, rb_intern("Rhebok"));
rb_define_module_function(cRhebok, "accept_rack", rhe_accept, 4);
rb_define_module_function(cRhebok, "read_timeout", rhe_read_timeout, 5);
rb_define_module_function(cRhebok, "write_timeout", rhe_write_timeout, 5);
rb_define_module_function(cRhebok, "write_all", rhe_write_all, 4);
rb_define_module_function(cRhebok, "close_rack", rhe_close, 1);
rb_define_module_function(cRhebok, "write_response", rhe_write_response, 5);
}
void
init_pg_type_map_all_strings()
{
/*
* Document-class: PG::TypeMapAllStrings < PG::TypeMap
*
* This type map casts all values received from the database server to Strings
* and sends all values to the server after conversion to String by +#to_s+ .
* That means, it is hard coded to PG::TextEncoder::String for value encoding
* and to PG::TextDecoder::String for text format respectivly PG::BinaryDecoder::Bytea
* for binary format received from the server.
*
* It is suitable for type casting query bind parameters, result values and
* COPY IN/OUT data.
*
* This is the default type map for each PG::Connection .
*
*/
rb_cTypeMapAllStrings = rb_define_class_under( rb_mPG, "TypeMapAllStrings", rb_cTypeMap );
rb_define_alloc_func( rb_cTypeMapAllStrings, pg_tmas_s_allocate );
pg_typemap_all_strings = rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 );
rb_gc_register_address( &pg_typemap_all_strings );
}
static
void set_common_header(const char * key, int key_len, const int raw)
{
char tmp[MAX_HEADER_NAME_LEN + sizeof("HTTP_") - 1];
const char* name;
size_t name_len = 0;
const char * s;
char* d;
size_t n;
VALUE env_key;
if ( raw == 1) {
for (s = key, n = key_len, d = tmp;
n != 0;
s++, --n, d++) {
*d = *s == '-' ? '_' : TOU(*s);
name = tmp;
name_len = key_len;
}
} else {
strcpy(tmp, "HTTP_");
for (s = key, n = key_len, d = tmp + 5;
n != 0;
s++, --n, d++) {
*d = *s == '-' ? '_' : TOU(*s);
name = tmp;
name_len = key_len + 5;
}
}
env_key = rb_obj_freeze(rb_str_new(name,name_len));
common_headers[common_headers_num].name = key;
common_headers[common_headers_num].name_len = key_len;
common_headers[common_headers_num].key = env_key;
rb_gc_register_address(&common_headers[common_headers_num].key);
common_headers_num++;
}
int
weechat_ruby_load (const char *filename)
{
char modname[64];
VALUE curModule, ruby_retcode, err;
int ruby_error;
struct stat buf;
if (stat (filename, &buf) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
return 0;
}
if ((weechat_ruby_plugin->debug >= 1) || !ruby_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
RUBY_PLUGIN_NAME, filename);
}
ruby_current_script = NULL;
snprintf (modname, sizeof(modname), "%s%d", MOD_NAME_PREFIX, ruby_num);
ruby_num++;
curModule = rb_define_module(modname);
ruby_current_script_filename = filename;
ruby_retcode = rb_protect_funcall (curModule, rb_intern("load_eval_file"),
&ruby_error, 1, rb_str_new2(filename));
if (ruby_retcode == Qnil)
{
err = rb_inspect(rb_gv_get("$!"));
weechat_printf (NULL,
weechat_gettext ("%s%s: error: \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
STR2CSTR(err));
return 0;
}
if (NUM2INT(ruby_retcode) != 0)
{
VALUE ruby_eval_error;
switch (NUM2INT(ruby_retcode))
{
case 1:
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to read file "
"\"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
case 2:
weechat_printf (NULL,
weechat_gettext ("%s%s: error while loading "
"file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
case 3:
weechat_printf (NULL,
weechat_gettext ("%s%s: function "
"\"weechat_init\" is missing "
"in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
}
if (NUM2INT(ruby_retcode) == 1 || NUM2INT(ruby_retcode) == 2)
{
ruby_eval_error = rb_iv_get(curModule, "@load_eval_file_error");
if (ruby_eval_error)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
STR2CSTR(ruby_eval_error));
}
}
return 0;
}
ruby_retcode = rb_protect_funcall (curModule, rb_intern("weechat_init"),
&ruby_error, 0);
if (ruby_error)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to eval function "
"\"weechat_init\" in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
err = rb_inspect(rb_gv_get("$!"));
weechat_printf (NULL,
weechat_gettext ("%s%s: error: \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
STR2CSTR(err));
if (ruby_current_script != NULL)
{
script_remove (weechat_ruby_plugin,
&ruby_scripts, &last_ruby_script,
ruby_current_script);
}
return 0;
}
if (ruby_current_script == NULL)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
return 0;
}
ruby_current_script->interpreter = (VALUE *) curModule;
rb_gc_register_address (ruby_current_script->interpreter);
return 1;
}
void CRbFont::InitLibrary()
{
/**
* @classname
* Font
*
* @desc
* å—体的类。
*/
rb_cFont = rb_define_class_under(rb_mSin, "Font", rb_cObject);
VALUE __argv[3] = { INT2FIX(255), INT2FIX(255), INT2FIX(255) };
__default_name__ = rb_str_new2("simhei");
rb_str_freeze(__default_name__);
__default_size__ = INT2FIX(20);
__default_bold__ = Qfalse;
__default_italic__ = Qfalse;
__default_color__ = rb_class_new_instance(3, __argv, rb_cColor);
__default_shadow__ = Qtrue;
rb_gc_register_address(&__default_name__);
rb_gc_register_address(&__default_color__);
// special method
rb_define_alloc_func(rb_cFont, ObjAllocate<CRbFont>);
rb_define_method(rb_cFont, "initialize", (RbFunc)dm_initialize, -1);
// object attribute
rb_define_method(rb_cFont, "name", (RbFunc)dm_get_name, 0);
rb_define_method(rb_cFont, "name=", (RbFunc)dm_set_name, 1);
rb_define_method(rb_cFont, "size", (RbFunc)dm_get_size, 0);
rb_define_method(rb_cFont, "size=", (RbFunc)dm_set_size, 1);
rb_define_method(rb_cFont, "bold", (RbFunc)dm_get_bold, 0);
rb_define_method(rb_cFont, "bold=", (RbFunc)dm_set_bold, 1);
rb_define_method(rb_cFont, "italic", (RbFunc)dm_get_italic, 0);
rb_define_method(rb_cFont, "italic=", (RbFunc)dm_set_italic, 1);
rb_define_method(rb_cFont, "color", (RbFunc)dm_get_color, 0);
rb_define_method(rb_cFont, "color=", (RbFunc)dm_set_color, 1);
rb_define_method(rb_cFont, "shadow", (RbFunc)dm_get_shadow, 0);
rb_define_method(rb_cFont, "shadow=", (RbFunc)dm_set_shadow, 1);
// class attribute
rb_define_singleton_method(rb_cFont, "exist?", (RbFunc)dm_is_exist, 1);
rb_define_singleton_method(rb_cFont, "default_name", (RbFunc)dm_get_default_name, 0);
rb_define_singleton_method(rb_cFont, "default_name=", (RbFunc)dm_set_default_name, 1);
rb_define_singleton_method(rb_cFont, "default_size", (RbFunc)dm_get_default_size, 0);
rb_define_singleton_method(rb_cFont, "default_size=", (RbFunc)dm_set_default_size, 1);
rb_define_singleton_method(rb_cFont, "default_bold", (RbFunc)dm_get_default_bold, 0);
rb_define_singleton_method(rb_cFont, "default_bold=", (RbFunc)dm_set_default_bold, 1);
rb_define_singleton_method(rb_cFont, "default_italic", (RbFunc)dm_get_default_italic, 0);
rb_define_singleton_method(rb_cFont, "default_italic=", (RbFunc)dm_set_default_italic, 1);
rb_define_singleton_method(rb_cFont, "default_color", (RbFunc)dm_get_default_color, 0);
rb_define_singleton_method(rb_cFont, "default_color=", (RbFunc)dm_set_default_color, 1);
rb_define_singleton_method(rb_cFont, "default_shadow", (RbFunc)dm_get_default_shadow, 0);
rb_define_singleton_method(rb_cFont, "default_shadow=", (RbFunc)dm_set_default_shadow, 1);
// supplement
rb_define_method(rb_cFont, "to_s", (RbFunc)dm_to_string, 0);
rb_define_method(rb_cFont, "clone", (RbFunc)dm_clone, 0);
}
void Init_ludicrous_ext()
{
VALUE rb_mJIT;
VALUE rb_mLudicrous;
rb_require("jit");
rb_mJIT = rb_define_module("JIT");
rb_cFunction = rb_define_class_under(rb_mJIT, "Function", rb_cObject);
rb_define_method(rb_cFunction, "set_ruby_source", function_set_ruby_source, 1);
rb_define_method(rb_cFunction, "ruby_struct_member", function_ruby_struct_member, 3);
rb_define_method(rb_cFunction, "ruby_struct_member_offset", function_ruby_struct_member_offset, 2);
rb_define_method(rb_cFunction, "have_ruby_struct_member", function_have_ruby_struct_member, 2);
rb_define_method(rb_cFunction, "set_ruby_struct_member", function_set_ruby_struct_member, 4);
rb_cValue = rb_define_class_under(rb_mJIT, "Value", rb_cObject);
rb_mLudicrous = rb_define_module("Ludicrous");
rb_define_module_function(rb_mLudicrous, "function_pointer_of", function_pointer_of, 1);
name_to_function_pointer = rb_hash_new();
rb_gc_register_address(&name_to_function_pointer);
#define DEFINE_FUNCTION_POINTER(name) \
rb_hash_aset(name_to_function_pointer, ID2SYM(rb_intern(#name)), ULONG2NUM((unsigned long)name))
DEFINE_FUNCTION_POINTER(rb_funcall);
DEFINE_FUNCTION_POINTER(rb_funcall2);
DEFINE_FUNCTION_POINTER(rb_funcall3);
DEFINE_FUNCTION_POINTER(rb_call_super);
// DEFINE_FUNCTION_POINTER(rb_add_method);
DEFINE_FUNCTION_POINTER(rb_obj_is_kind_of);
DEFINE_FUNCTION_POINTER(rb_obj_as_string);
DEFINE_FUNCTION_POINTER(rb_str_dup);
DEFINE_FUNCTION_POINTER(rb_str_plus);
DEFINE_FUNCTION_POINTER(rb_str_concat);
DEFINE_FUNCTION_POINTER(rb_string_value_ptr);
DEFINE_FUNCTION_POINTER(rb_ary_new);
DEFINE_FUNCTION_POINTER(rb_ary_new2);
DEFINE_FUNCTION_POINTER(rb_ary_new3);
DEFINE_FUNCTION_POINTER(rb_ary_new4);
DEFINE_FUNCTION_POINTER(rb_ary_push);
DEFINE_FUNCTION_POINTER(rb_ary_pop);
DEFINE_FUNCTION_POINTER(rb_ary_store);
DEFINE_FUNCTION_POINTER(rb_ary_entry);
DEFINE_FUNCTION_POINTER(rb_ary_concat);
DEFINE_FUNCTION_POINTER(rb_ary_to_ary);
DEFINE_FUNCTION_POINTER(rb_ary_dup);
DEFINE_FUNCTION_POINTER(rb_hash_new);
DEFINE_FUNCTION_POINTER(rb_hash_aset);
DEFINE_FUNCTION_POINTER(rb_hash_aref);
DEFINE_FUNCTION_POINTER(rb_range_new);
DEFINE_FUNCTION_POINTER(rb_class_of);
DEFINE_FUNCTION_POINTER(rb_singleton_class);
DEFINE_FUNCTION_POINTER(rb_extend_object);
DEFINE_FUNCTION_POINTER(rb_include_module);
DEFINE_FUNCTION_POINTER(rb_ivar_set);
DEFINE_FUNCTION_POINTER(rb_ivar_get);
DEFINE_FUNCTION_POINTER(rb_ivar_defined);
DEFINE_FUNCTION_POINTER(rb_const_get);
DEFINE_FUNCTION_POINTER(rb_const_defined);
DEFINE_FUNCTION_POINTER(rb_const_defined_from);
DEFINE_FUNCTION_POINTER(rb_yield);
DEFINE_FUNCTION_POINTER(rb_yield_splat);
DEFINE_FUNCTION_POINTER(rb_block_given_p);
DEFINE_FUNCTION_POINTER(rb_block_proc);
DEFINE_FUNCTION_POINTER(rb_iterate);
DEFINE_FUNCTION_POINTER(rb_proc_new);
DEFINE_FUNCTION_POINTER(rb_iter_break);
DEFINE_FUNCTION_POINTER(rb_ensure);
DEFINE_FUNCTION_POINTER(rb_rescue);
DEFINE_FUNCTION_POINTER(rb_rescue2);
DEFINE_FUNCTION_POINTER(rb_protect);
DEFINE_FUNCTION_POINTER(rb_jump_tag);
DEFINE_FUNCTION_POINTER(rb_uint2inum);
DEFINE_FUNCTION_POINTER(rb_cvar_set);
DEFINE_FUNCTION_POINTER(rb_cvar_get);
DEFINE_FUNCTION_POINTER(rb_cvar_defined);
DEFINE_FUNCTION_POINTER(rb_gv_set);
DEFINE_FUNCTION_POINTER(rb_gv_get);
DEFINE_FUNCTION_POINTER(rb_gvar_defined);
DEFINE_FUNCTION_POINTER(rb_global_entry);
DEFINE_FUNCTION_POINTER(rb_id2name);
DEFINE_FUNCTION_POINTER(rb_reg_nth_match);
DEFINE_FUNCTION_POINTER(rb_reg_match);
DEFINE_FUNCTION_POINTER(rb_reg_match2);
DEFINE_FUNCTION_POINTER(rb_data_object_alloc);
DEFINE_FUNCTION_POINTER(rb_type);
DEFINE_FUNCTION_POINTER(rb_check_type);
DEFINE_FUNCTION_POINTER(ruby_xmalloc);
DEFINE_FUNCTION_POINTER(ruby_xcalloc);
DEFINE_FUNCTION_POINTER(ruby_xrealloc);
DEFINE_FUNCTION_POINTER(ruby_xfree);
DEFINE_FUNCTION_POINTER(rb_gc_mark);
DEFINE_FUNCTION_POINTER(rb_gc_mark_locations);
DEFINE_FUNCTION_POINTER(rb_method_boundp);
#ifdef RUBY_VM
DEFINE_FUNCTION_POINTER(yarv_spp);
#else
DEFINE_FUNCTION_POINTER(rb_svar);
#define ruby_frame ruby_frame_
DEFINE_FUNCTION_POINTER(ruby_frame);
#undef ruby_frame
#define ruby_scope ruby_scope_
DEFINE_FUNCTION_POINTER(ruby_scope);
#undef ruby_scope
DEFINE_FUNCTION_POINTER(ludicrous_splat_iterate_proc);
#endif
DEFINE_FUNCTION_POINTER(rb_errinfo);
DEFINE_FUNCTION_POINTER(block_pass_fcall);
DEFINE_FUNCTION_POINTER(block_pass_call);
DEFINE_FUNCTION_POINTER(rb_node_newnode);
/* From ruby-internal */
/* TODO: The require lines here do not seem to help for getting the
* following symbols loaded before they are used. It appears that
* using a function pointer causes the function to be resolved at load
* time rather than at time of use.
* - One quick workaround is to require the files before
* ludicrous.so is required.
* - Another possiblity (which would work also on machines where
* RTLD_GLOBAL is unavailable) would be to obtain the function
* pointers through a different means, e.g. by calling through
* ruby to ask the other module for its function pointers.
* - A last possiblity would be to create a local function here
* that calls the real function.
* The third option requires fewer changes than the second, but has
* negative performance implications.
*/
rb_require("internal/node");
#ifdef RUBY_VM
rb_require("internal/thread");
DEFINE_FUNCTION_POINTER(ruby_current_thread_jmp_buf);
DEFINE_FUNCTION_POINTER(ruby_current_thread_tag);
DEFINE_FUNCTION_POINTER(ruby_set_current_thread_tag);
DEFINE_FUNCTION_POINTER(setjmp);
DEFINE_FUNCTION_POINTER(_setjmp);
#endif
DEFINE_FUNCTION_POINTER(wrap_node);
DEFINE_FUNCTION_POINTER(unwrap_node);
DEFINE_FUNCTION_POINTER(eval_ruby_node);
DEFINE_FUNCTION_POINTER(raise);
struct_name_to_member_name_info = rb_hash_new();
rb_gc_register_address(&struct_name_to_member_name_info);
#define DEFINE_RUBY_STRUCT_MEMBER(name, member, type) \
add_member_info(#name, #member, offsetof(struct name, member), type);
// TODO: might not be right for 64-bit
DEFINE_RUBY_STRUCT_MEMBER(RBasic, flags, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(RBasic, klass, jit_type_uint);
#ifdef HAVE_ST_ROBJECT_IV_TBL
DEFINE_RUBY_STRUCT_MEMBER(RObject, iv_tbl, jit_type_void_ptr);
#endif
#ifdef HAVE_ST_RCLASS_IV_TBL
DEFINE_RUBY_STRUCT_MEMBER(RClass, iv_tbl, jit_type_void_ptr);
#endif
DEFINE_RUBY_STRUCT_MEMBER(RClass, m_tbl, jit_type_void_ptr);
#ifdef HAVE_ST_RCLASS_SUPER
DEFINE_RUBY_STRUCT_MEMBER(RClass, super, jit_type_uint);
#endif
#ifdef HAVE_ST_RFLOAT_VALUE
DEFINE_RUBY_STRUCT_MEMBER(RFloat, value, jit_type_uint);
#endif
#ifdef HAVE_ST_RSTRING_LEN
DEFINE_RUBY_STRUCT_MEMBER(RString, len, jit_type_uint);
#endif
#ifdef HAVE_ST_RSTRING_PTR
DEFINE_RUBY_STRUCT_MEMBER(RString, ptr, jit_type_void_ptr);
#endif
// TODO: capa, shared
#ifdef HAVE_ST_RARRAY_LEN
DEFINE_RUBY_STRUCT_MEMBER(RArray, len, jit_type_int);
#endif
#ifdef HAVE_ST_RARRAY_PTR
DEFINE_RUBY_STRUCT_MEMBER(RArray, ptr, jit_type_void_ptr);
#endif
#ifdef HAVE_ST_RARRAY_AS_HEAP_LEN
DEFINE_RUBY_STRUCT_MEMBER(RArray, as.heap.len, jit_type_int);
#endif
#ifdef HAVE_ST_RARRAY_AS_HEAP_PTR
DEFINE_RUBY_STRUCT_MEMBER(RArray, as.heap.ptr, jit_type_void_ptr);
#endif
#ifdef HAVE_ST_RARRAY_AS_ARY
DEFINE_RUBY_STRUCT_MEMBER(RArray, as.ary, jit_type_void_ptr);
#endif
// TODO: capa, shared
DEFINE_RUBY_STRUCT_MEMBER(RRegexp, ptr, jit_type_void_ptr);
#ifdef HAVE_ST_RREGEXP_LEN
DEFINE_RUBY_STRUCT_MEMBER(RRegexp, len, jit_type_uint);
#endif
#ifdef HAVE_ST_RREGEXP_STR
DEFINE_RUBY_STRUCT_MEMBER(RRegexp, str, jit_type_void_ptr);
#endif
#ifdef HAVE_ST_RHASH_TBL
DEFINE_RUBY_STRUCT_MEMBER(RHash, tbl, jit_type_void_ptr);
#endif
DEFINE_RUBY_STRUCT_MEMBER(RHash, iter_lev, jit_type_int);
DEFINE_RUBY_STRUCT_MEMBER(RHash, ifnone, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(RFile, fptr, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(RData, dmark, jit_type_void_ptr); // TODO: function ptr
DEFINE_RUBY_STRUCT_MEMBER(RData, dfree, jit_type_void_ptr); // TODO: function ptr
DEFINE_RUBY_STRUCT_MEMBER(RData, data, jit_type_void_ptr);
#ifdef HAVE_TYPE_STRUCT_FRAME
DEFINE_RUBY_STRUCT_MEMBER(FRAME, self, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, argc, jit_type_int);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, last_func, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, orig_func, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, last_class, jit_type_uint);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, prev, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, tmp, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, node, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, iter, jit_type_int);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, flags, jit_type_int);
DEFINE_RUBY_STRUCT_MEMBER(FRAME, uniq, jit_type_uint);
#endif
#ifdef HAVE_TYPE_STRUCT_SCOPE
DEFINE_RUBY_STRUCT_MEMBER(SCOPE, local_tbl, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(SCOPE, local_vars, jit_type_void_ptr);
DEFINE_RUBY_STRUCT_MEMBER(SCOPE, flags, jit_type_int);
#endif
#ifdef RUBY_VM
DEFINE_RUBY_STRUCT_MEMBER(rb_vm_tag, tag, jit_type_VALUE);
DEFINE_RUBY_STRUCT_MEMBER(rb_vm_tag, retval, jit_type_VALUE);
DEFINE_RUBY_STRUCT_MEMBER(rb_vm_tag, prev, jit_type_void_ptr);
rb_require("jit/struct");
{
VALUE rb_mJIT = rb_const_get(rb_cObject, rb_intern("JIT"));
VALUE rb_cJIT_Array = rb_const_get(rb_mJIT, rb_intern("Array"));
VALUE rb_cJIT_Type = rb_const_get(rb_mJIT, rb_intern("Type"));
VALUE jit_ubyte_type = rb_const_get(rb_cJIT_Type, rb_intern("UBYTE"));
VALUE rb_cJmp_Buf = rb_funcall(
rb_cJIT_Array,
rb_intern("new"),
2,
jit_ubyte_type,
INT2NUM(sizeof(jmp_buf)));
VALUE rb_cVMTag;
ID set_offset_of;
rb_const_set(rb_mLudicrous, rb_intern("JmpBuf"), rb_cJmp_Buf);
rb_cVMTag = rb_eval_string(
"module Ludicrous \n"
" VMTag = JIT::Struct.new( \n"
" [ :buf, JmpBuf], \n"
" [ :tag, JIT::Type::OBJECT], \n"
" [ :retval, JIT::Type::OBJECT], \n"
" [ :prev, JIT::Type::VOID_PTR] \n"
" ) \n"
" end \n"
" Ludicrous::VMTag \n"
);
set_offset_of = rb_intern("set_offset_of");
#define SET_OFFSET(klass, c_type, member) \
rb_funcall( \
klass, \
set_offset_of, \
2, \
ID2SYM(rb_intern(#member)), \
UINT2NUM(offsetof(struct rb_vm_tag, member)));
SET_OFFSET(rb_cVMTag, rb_vm_tag, buf);
SET_OFFSET(rb_cVMTag, rb_vm_tag, tag);
SET_OFFSET(rb_cVMTag, rb_vm_tag, retval);
SET_OFFSET(rb_cVMTag, rb_vm_tag, prev);
}
#endif
rb_define_const(rb_mLudicrous, "Qundef", UINT2NUM(Qundef));
rb_define_const(rb_mLudicrous, "Qnil", UINT2NUM(Qnil));
rb_define_const(rb_mLudicrous, "Qtrue", UINT2NUM(Qtrue));
rb_define_const(rb_mLudicrous, "Qfalse", UINT2NUM(Qfalse));
rb_define_const(rb_mLudicrous, "T_NONE", UINT2NUM(T_NONE));
rb_define_const(rb_mLudicrous, "T_NIL", UINT2NUM(T_NIL));
rb_define_const(rb_mLudicrous, "T_OBJECT", UINT2NUM(T_OBJECT));
rb_define_const(rb_mLudicrous, "T_CLASS", UINT2NUM(T_CLASS));
rb_define_const(rb_mLudicrous, "T_ICLASS", UINT2NUM(T_ICLASS));
rb_define_const(rb_mLudicrous, "T_MODULE", UINT2NUM(T_MODULE));
rb_define_const(rb_mLudicrous, "T_FLOAT", UINT2NUM(T_FLOAT));
rb_define_const(rb_mLudicrous, "T_STRING", UINT2NUM(T_STRING));
rb_define_const(rb_mLudicrous, "T_REGEXP", UINT2NUM(T_REGEXP));
rb_define_const(rb_mLudicrous, "T_ARRAY", UINT2NUM(T_ARRAY));
rb_define_const(rb_mLudicrous, "T_FIXNUM", UINT2NUM(T_FIXNUM));
rb_define_const(rb_mLudicrous, "T_HASH", UINT2NUM(T_HASH));
rb_define_const(rb_mLudicrous, "T_STRUCT", UINT2NUM(T_STRUCT));
rb_define_const(rb_mLudicrous, "T_BIGNUM", UINT2NUM(T_BIGNUM));
rb_define_const(rb_mLudicrous, "T_FILE", UINT2NUM(T_FILE));
rb_define_const(rb_mLudicrous, "T_TRUE", UINT2NUM(T_TRUE));
rb_define_const(rb_mLudicrous, "T_FALSE", UINT2NUM(T_FALSE));
rb_define_const(rb_mLudicrous, "T_DATA", UINT2NUM(T_DATA));
rb_define_const(rb_mLudicrous, "T_MATCH", UINT2NUM(T_MATCH));
rb_define_const(rb_mLudicrous, "T_SYMBOL", UINT2NUM(T_SYMBOL));
rb_define_const(rb_mLudicrous, "T_UNDEF", UINT2NUM(T_UNDEF));
rb_define_const(rb_mLudicrous, "T_MASK", UINT2NUM(T_MASK));
rb_define_const(rb_mLudicrous, "TAG_RETURN", UINT2NUM(0x1));
rb_define_const(rb_mLudicrous, "TAG_BREAK", UINT2NUM(0x2));
rb_define_const(rb_mLudicrous, "TAG_NEXT", UINT2NUM(0x3));
rb_define_const(rb_mLudicrous, "TAG_RETRY", UINT2NUM(0x4));
rb_define_const(rb_mLudicrous, "TAG_REDO", UINT2NUM(0x5));
rb_define_const(rb_mLudicrous, "TAG_RAISE", UINT2NUM(0x6));
rb_define_const(rb_mLudicrous, "TAG_THROW", UINT2NUM(0x7));
rb_define_const(rb_mLudicrous, "TAG_FATAL", UINT2NUM(0x8));
rb_define_const(rb_mLudicrous, "TAG_MASK", UINT2NUM(0xf));
rb_define_const(rb_mLudicrous, "YIELD_FUNC_AVALUE", UINT2NUM(1));
rb_define_const(rb_mLudicrous, "YIELD_FUNC_SVALUE", UINT2NUM(2));
#ifdef RUBY_VM
rb_define_const(rb_mLudicrous, "RUBY_VM_FROZEN_CORE", rb_mRubyVMFrozenCore);
#endif
#ifdef RARRAY_EMBED_FLAG
rb_define_const(rb_mLudicrous, "RARRAY_EMBED_FLAG", INT2NUM(RARRAY_EMBED_FLAG));
#endif
#ifdef RARRAY_EMBED_LEN_MASK
rb_define_const(rb_mLudicrous, "RARRAY_EMBED_LEN_MASK", INT2NUM(RARRAY_EMBED_LEN_MASK));
#endif
#ifdef RARRAY_EMBED_LEN_SHIFT
rb_define_const(rb_mLudicrous, "RARRAY_EMBED_LEN_SHIFT", INT2NUM(RARRAY_EMBED_LEN_SHIFT));
#endif
#ifdef NEED_MINIMAL_NODE
Init_ludicrous_minimal_node();
#endif
}
KRubyObject::KRubyObject(VALUE object) :
KObject("Ruby.KRubyObject"),
object(object)
{
rb_gc_register_address(&object);
}
int
weechat_ruby_load (const char *filename)
{
char modname[64];
VALUE ruby_retcode, err, argv[1];
int ruby_error;
struct stat buf;
if (stat (filename, &buf) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
return 0;
}
if ((weechat_ruby_plugin->debug >= 2) || !ruby_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
RUBY_PLUGIN_NAME, filename);
}
ruby_current_script = NULL;
ruby_registered_script = NULL;
snprintf (modname, sizeof(modname), "%s%d", MOD_NAME_PREFIX, ruby_num);
ruby_num++;
ruby_current_module = rb_define_module (modname);
ruby_current_script_filename = filename;
argv[0] = rb_str_new2 (filename);
ruby_retcode = rb_protect_funcall (ruby_current_module,
rb_intern ("load_eval_file"),
&ruby_error, 1, argv);
if (ruby_retcode == Qnil)
{
err = rb_gv_get("$!");
weechat_ruby_print_exception(err);
return 0;
}
if (NUM2INT(ruby_retcode) != 0)
{
switch (NUM2INT(ruby_retcode))
{
case 1:
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to read file "
"\"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
case 2:
weechat_printf (NULL,
weechat_gettext ("%s%s: error while loading "
"file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
case 3:
weechat_printf (NULL,
weechat_gettext ("%s%s: function "
"\"weechat_init\" is missing "
"in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
filename);
break;
}
if (NUM2INT(ruby_retcode) == 2)
{
weechat_ruby_print_exception (rb_iv_get (ruby_current_module,
"@load_eval_file_error"));
}
return 0;
}
(void) rb_protect_funcall (ruby_current_module, rb_intern ("weechat_init"),
&ruby_error, 0, NULL);
if (ruby_error)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to eval function "
"\"weechat_init\" in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
err = rb_gv_get("$!");
weechat_ruby_print_exception(err);
if (ruby_current_script != NULL)
{
plugin_script_remove (weechat_ruby_plugin,
&ruby_scripts, &last_ruby_script,
ruby_current_script);
}
return 0;
}
if (!ruby_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
return 0;
}
ruby_current_script = ruby_registered_script;
rb_gc_register_address (ruby_current_script->interpreter);
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_ruby_plugin,
ruby_scripts,
ruby_current_script,
&weechat_ruby_api_buffer_input_data_cb,
&weechat_ruby_api_buffer_close_cb);
(void) weechat_hook_signal_send ("ruby_script_loaded",
WEECHAT_HOOK_SIGNAL_STRING,
ruby_current_script->filename);
return 1;
}
void
Init_bossan_ext(void)
{
rb_gc_register_address(&version_key);
rb_gc_register_address(&version_val);
rb_gc_register_address(&scheme_key);
rb_gc_register_address(&scheme_val);
rb_gc_register_address(&errors_key);
rb_gc_register_address(&errors_val);
rb_gc_register_address(&multithread_key);
rb_gc_register_address(&multithread_val);
rb_gc_register_address(&multiprocess_key);
rb_gc_register_address(&multiprocess_val);
rb_gc_register_address(&run_once_key);
rb_gc_register_address(&run_once_val);
rb_gc_register_address(&script_key);
rb_gc_register_address(&script_val);
rb_gc_register_address(&server_name_key);
rb_gc_register_address(&server_name_val);
rb_gc_register_address(&server_port_key);
rb_gc_register_address(&server_port_val);
rb_gc_register_address(&server_protocol);
rb_gc_register_address(&path_info);
rb_gc_register_address(&request_uri);
rb_gc_register_address(&query_string);
rb_gc_register_address(&http_fragment);
rb_gc_register_address(&request_method);
rb_gc_register_address(&rb_remote_addr);
rb_gc_register_address(&rb_remote_port);
rb_gc_register_address(&rack_input);
rb_gc_register_address(&http_connection);
rb_gc_register_address(&http_user_agent);
rb_gc_register_address(&http_referer);
empty_string = rb_obj_freeze(rb_str_new2(""));
rb_gc_register_address(&empty_string);
rb_gc_register_address(&i_keys);
rb_gc_register_address(&i_call);
rb_gc_register_address(&i_new);
rb_gc_register_address(&i_key);
rb_gc_register_address(&i_each);
rb_gc_register_address(&i_close);
rb_gc_register_address(&rack_app); //rack app
i_new = rb_intern("new");
i_call = rb_intern("call");
i_keys = rb_intern("keys");
i_key = rb_intern("key?");
i_each = rb_intern("each");
i_close = rb_intern("close");
server = rb_define_module("Bossan");
rb_gc_register_address(&server);
rb_define_module_function(server, "run", bossan_run_loop, -1);
rb_define_module_function(server, "stop", bossan_stop, 0);
rb_define_module_function(server, "access_log", bossan_access_log, 1);
rb_define_module_function(server, "set_max_content_length", bossan_set_max_content_length, 1);
rb_define_module_function(server, "get_max_content_length", bossan_get_max_content_length, 0);
rb_require("stringio");
StringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
}
static char* proxenet_ruby_execute_function(VALUE module, ID rFunc, request_t* request)
{
char *buf, *data;
int buflen, i, state;
VALUE rRet;
char *uri;
struct proxenet_ruby_args args;
uri = request->http_infos.uri;
if (!uri)
return NULL;
/* build args */
args.rVM = module;
args.rFunc = rFunc;
args.rArgs[0] = INT2NUM(request->id);
args.rArgs[1] = rb_str_new(request->data, request->size);
args.rArgs[2] = rb_str_new2(uri);
for(i=0; i<3; i++) {
rb_gc_register_address(&args.rArgs[i]);
}
/* safe function call */
rRet = rb_protect(proxenet_safe_func_call, (VALUE)&args, &state);
if (state){
proxenet_ruby_print_last_exception();
data = NULL;
goto call_end;
}
if (!rRet) {
xlog_ruby(LOG_ERROR, "%s\n", "funcall2() failed");
data = NULL;
goto call_end;
}
rb_check_type(rRet, T_STRING);
/* copy result to exploitable buffer */
buf = RSTRING_PTR(rRet);
buflen = RSTRING_LEN(rRet);
data = proxenet_xmalloc(buflen + 1);
data = memcpy(data, buf, buflen);
request->data = data;
request->size = buflen;
call_end:
for(i=0; i<3; i++) {
rb_gc_unregister_address(&args.rArgs[i]);
}
return data;
}
void
rb_global_variable(VALUE *var)
{
rb_gc_register_address(var);
}
void
rb_register_mark_object(VALUE obj)
{
rb_gc_register_address(&obj);
}
/* call-seq: ox_default_options=(opts)
*
* Sets the default options for load and dump.
* @param [Hash] opts options to change
* @param [Fixnum] :indent number of spaces to indent each element in an XML document
* @param [Fixnum] :trace trace level where 0 is silent
* @param [String] :encoding character encoding for the XML file
* @param [true|false|nil] :with_dtd include DTD in the dump
* @param [true|false|nil] :with_instruct include instructions in the dump
* @param [true|false|nil] :with_xml include XML prolog in the dump
* @param [true|false|nil] :circular support circular references while dumping
* @param [true|false|nil] :xsd_date use XSD date format instead of decimal format
* @param [:object|:generic|:limited|nil] :mode load method to use for XML
* @param [:strict|:tolerant|:auto_define] :effort set the tolerance level for loading
* @param [true|false|nil] :symbolize_keys symbolize element attribute keys or leave as Strings
* @param [:skip_none|:skip_return|:skip_white] determines how to handle white space in text
* @param [nil|String] :invalid_replace replacement string for invalid XML characters on dump. nil indicates include anyway as hex. A string, limited to 10 characters will replace the invalid character with the replace.
* @param [nil|String|true|false] :strip_namespace "" or false result in no namespace stripping. A string of "*" or true will strip all namespaces. Any other non-empty string indicates that matching namespaces will be stripped.
* @return [nil]
*/
static VALUE
set_def_opts(VALUE self, VALUE opts) {
struct _YesNoOpt ynos[] = {
{ with_xml_sym, &ox_default_options.with_xml },
{ with_dtd_sym, &ox_default_options.with_dtd },
{ with_instruct_sym, &ox_default_options.with_instruct },
{ xsd_date_sym, &ox_default_options.xsd_date },
{ circular_sym, &ox_default_options.circular },
{ symbolize_keys_sym, &ox_default_options.sym_keys },
{ smart_sym, &ox_default_options.smart },
{ Qnil, 0 }
};
YesNoOpt o;
VALUE v;
Check_Type(opts, T_HASH);
v = rb_hash_aref(opts, ox_encoding_sym);
if (Qnil == v) {
*ox_default_options.encoding = '\0';
} else {
Check_Type(v, T_STRING);
strncpy(ox_default_options.encoding, StringValuePtr(v), sizeof(ox_default_options.encoding) - 1);
#if HAS_ENCODING_SUPPORT
ox_default_options.rb_enc = rb_enc_find(ox_default_options.encoding);
#elif HAS_PRIVATE_ENCODING
ox_default_options.rb_enc = rb_str_new2(ox_default_options.encoding);
rb_gc_register_address(&ox_default_options.rb_enc);
#endif
}
v = rb_hash_aref(opts, indent_sym);
if (Qnil != v) {
Check_Type(v, T_FIXNUM);
ox_default_options.indent = FIX2INT(v);
}
v = rb_hash_aref(opts, trace_sym);
if (Qnil != v) {
Check_Type(v, T_FIXNUM);
ox_default_options.trace = FIX2INT(v);
}
v = rb_hash_aref(opts, mode_sym);
if (Qnil == v) {
ox_default_options.mode = NoMode;
} else if (object_sym == v) {
ox_default_options.mode = ObjMode;
} else if (generic_sym == v) {
ox_default_options.mode = GenMode;
} else if (limited_sym == v) {
ox_default_options.mode = LimMode;
} else {
rb_raise(ox_parse_error_class, ":mode must be :object, :generic, :limited, or nil.\n");
}
v = rb_hash_aref(opts, effort_sym);
if (Qnil == v) {
ox_default_options.effort = NoEffort;
} else if (strict_sym == v) {
ox_default_options.effort = StrictEffort;
} else if (tolerant_sym == v) {
ox_default_options.effort = TolerantEffort;
} else if (auto_define_sym == v) {
ox_default_options.effort = AutoEffort;
} else {
rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, :auto_define, or nil.\n");
}
v = rb_hash_aref(opts, skip_sym);
if (Qnil == v) {
ox_default_options.skip = NoSkip;
} else if (skip_none_sym == v) {
ox_default_options.skip = NoSkip;
} else if (skip_return_sym == v) {
ox_default_options.skip = CrSkip;
} else if (skip_white_sym == v) {
ox_default_options.skip = SpcSkip;
} else {
rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, or nil.\n");
}
v = rb_hash_lookup(opts, convert_special_sym);
if (Qnil == v) {
// no change
} else if (Qtrue == v) {
ox_default_options.convert_special = 1;
} else if (Qfalse == v) {
ox_default_options.convert_special = 0;
} else {
rb_raise(ox_parse_error_class, ":convert_special must be true or false.\n");
}
v = rb_hash_aref(opts, invalid_replace_sym);
if (Qnil == v) {
ox_default_options.allow_invalid = Yes;
} else {
long slen;
Check_Type(v, T_STRING);
slen = RSTRING_LEN(v);
if (sizeof(ox_default_options.inv_repl) - 2 < slen) {
rb_raise(ox_parse_error_class, ":invalid_replace can be no longer than %ld characters.",
sizeof(ox_default_options.inv_repl) - 2);
}
strncpy(ox_default_options.inv_repl + 1, StringValuePtr(v), sizeof(ox_default_options.inv_repl) - 1);
ox_default_options.inv_repl[sizeof(ox_default_options.inv_repl) - 1] = '\0';
*ox_default_options.inv_repl = (char)slen;
ox_default_options.allow_invalid = No;
}
v = rb_hash_aref(opts, strip_namespace_sym);
if (Qfalse == v) {
*ox_default_options.strip_ns = '\0';
} else if (Qtrue == v) {
*ox_default_options.strip_ns = '*';
ox_default_options.strip_ns[1] = '\0';
} else if (Qnil != v) {
long slen;
Check_Type(v, T_STRING);
slen = RSTRING_LEN(v);
if (sizeof(ox_default_options.strip_ns) - 1 < slen) {
rb_raise(ox_parse_error_class, ":strip_namespace can be no longer than %ld characters.",
sizeof(ox_default_options.strip_ns) - 1);
}
strncpy(ox_default_options.strip_ns, StringValuePtr(v), sizeof(ox_default_options.strip_ns) - 1);
ox_default_options.strip_ns[sizeof(ox_default_options.strip_ns) - 1] = '\0';
}
for (o = ynos; 0 != o->attr; o++) {
v = rb_hash_lookup(opts, o->sym);
if (Qnil == v) {
*o->attr = NotSet;
} else if (Qtrue == v) {
*o->attr = Yes;
} else if (Qfalse == v) {
*o->attr = No;
} else {
rb_raise(ox_parse_error_class, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
}
}
return Qnil;
}
/* Init */
void
Init_webkit(void)
{
mWebKit = rb_define_module("WebKit");
rb_define_singleton_method(mWebKit, "set_web_database_path", WebKit_CLASS_set_web_database_path, 1);
rb_define_singleton_method(mWebKit, "remove_all_web_databases", WebKit_CLASS_remove_all_web_databases, 0);
rb_define_singleton_method(mWebKit, "set_default_web_database_quota", WebKit_CLASS_set_default_web_database_quota, 1);
cJsPtr = rb_define_class_under(mWebKit, "JsPtr", rb_cObject);
cJavascriptError = rb_define_class_under(mWebKit, "JavascriptError", rb_eStandardError);
cWebSettings = G_DEF_CLASS(WEBKIT_TYPE_WEB_SETTINGS, "WebSettings", mWebKit);
rb_define_method(cWebSettings, "initialize", WebSettings_initialize, 0);
cWebPolicyDecision = G_DEF_CLASS(WEBKIT_TYPE_WEB_POLICY_DECISION, "WebPolicyDecision", mWebKit);
rb_define_method(cWebPolicyDecision, "download", WebPolicyDecision_download, 0);
rb_define_method(cWebPolicyDecision, "use", WebPolicyDecision_use, 0);
rb_define_method(cWebPolicyDecision, "ignore", WebPolicyDecision_ignore, 0);
cWebFrame = G_DEF_CLASS(WEBKIT_TYPE_WEB_FRAME, "WebFrame", mWebKit);
rb_define_method(cWebFrame, "exec_js", WebFrame_exec_js, 1);
rb_define_method(cWebFrame, "add_ruby_class", WebFrame_add_ruby_class, 2);
rb_define_method(cWebFrame, "add_ruby_eval", WebFrame_add_ruby_eval, 0);
rb_define_method(cWebFrame, "add_js_api", WebFrame_add_js_api, 1);
rb_define_method(cWebFrame, "load_string", WebFrame_load_string, 4);
cWebView = G_DEF_CLASS(WEBKIT_TYPE_WEB_VIEW, "WebView", mWebKit);
rb_define_method(cWebView, "initialize", WebView_initialize, 0);
rb_define_method(cWebView, "open", WebView_open, 1);
rb_define_method(cWebView, "execute_script", WebView_execute_script, 1);
rb_define_method(cWebView, "set_settings", WebView_set_settings, 1);
rb_define_method(cWebView, "load_string", WebView_load_string, 4);
rb_define_method(cWebView, "load_uri", WebView_load_uri, 1);
rb_define_method(cWebView, "main_frame", WebView_main_frame, 0);
rb_define_method(cWebView, "focused_frame", WebView_focused_frame, 0);
rb_define_method(cWebView, "progress", WebView_progress, 0);
rb_define_method(cWebView, "title", WebView_title, 0);
rb_define_method(cWebView, "uri", WebView_uri, 0);
rb_define_method(cWebView, "reload", WebView_reload, 0);
rb_define_method(cWebView, "reload_bypass_cache", WebView_reload_bypass_cache, 0);
rb_define_method(cWebView, "set_custom_encoding", WebView_set_custom_encoding, 1);
rb_define_method(cWebView, "stop_loading", WebView_stop_loading, 0);
rb_define_method(cWebView, "has_selection?", WebView_has_selection_query, 0);
rb_define_method(cWebView, "inspector", WebView_inspector, 0);
cWebInspector = G_DEF_CLASS(WEBKIT_TYPE_WEB_INSPECTOR, "WebInspector", mWebKit);
rb_define_method(cWebInspector, "inspect_coordinates", WebInspector_inspect_coordinates, 2);
rb_define_method(cWebInspector, "uri", WebInspector_uri, 0);
rb_define_method(cWebInspector, "show", WebInspector_show, 0);
rb_define_method(cWebInspector, "close", WebInspector_close, 0);
rb_define_method(cWebInspector, "view", WebInspector_view, 0);
cWebResource = G_DEF_CLASS(WEBKIT_TYPE_WEB_RESOURCE, "WebResource", mWebKit);
rb_define_method(cWebResource, "encoding", WebResource_encoding, 0);
rb_define_method(cWebResource, "frame_name", WebResource_frame_name, 0);
rb_define_method(cWebResource, "mime_type", WebResource_mime_type, 0);
rb_define_method(cWebResource, "uri", WebResource_uri, 0);
rb_define_method(cWebResource, "data", WebResource_data, 0);
rb_define_method(cWebResource, "data=", WebResource_data_equals, 1);
cWebNetworkRequest = G_DEF_CLASS(WEBKIT_TYPE_NETWORK_REQUEST, "WebNetworkRequest", mWebKit);
rb_define_method(cWebNetworkRequest, "uri", WebNetworkRequest_uri, 0);
rb_define_method(cWebNetworkRequest, "uri=", WebNetworkRequest_uri_equals, 1);
rb_define_method(cWebNetworkRequest, "message", WebNetworkRequest_message, 0);
cWebNetworkResponse = G_DEF_CLASS(WEBKIT_TYPE_NETWORK_RESPONSE, "WebNetworkResponse", mWebKit);
rb_define_method(cWebNetworkResponse, "uri", WebNetworkResponse_uri, 0);
rb_define_method(cWebNetworkResponse, "uri=", WebNetworkResponse_uri_equals, 1);
rb_define_method(cWebNetworkResponse, "message", WebNetworkResponse_message, 0);
cDownload = G_DEF_CLASS(WEBKIT_TYPE_DOWNLOAD, "Download", mWebKit);
rb_define_method(cDownload, "initialize", Download_initialize, 1);
rb_define_method(cDownload, "start", Download_start, 0);
rb_define_method(cDownload, "cancel", Download_cancel, 0);
rb_define_method(cDownload, "progress", Download_progress, 0);
rb_define_method(cDownload, "current_size", Download_current_size, 0);
rb_define_method(cDownload, "total_size", Download_total_size, 0);
rb_define_method(cDownload, "uri", Download_uri, 0);
rb_define_method(cDownload, "suggested_filename", Download_suggested_filename, 0);
genumTargetInfo = G_DEF_CLASS(WEBKIT_TYPE_WEB_VIEW_TARGET_INFO, "TargetInfo", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_WEB_VIEW_TARGET_INFO, "WEBKIT_");
genumDownloadStatus = G_DEF_CLASS(WEBKIT_TYPE_DOWNLOAD_STATUS, "DownloadStatus", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_DOWNLOAD_STATUS, "WEBKIT_");
genumDownloadError = G_DEF_CLASS(WEBKIT_TYPE_DOWNLOAD_ERROR, "DownloadError", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_DOWNLOAD_ERROR, "WEBKIT_");
genumNetworkError = G_DEF_CLASS(WEBKIT_TYPE_NETWORK_ERROR, "NetworkError", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_NETWORK_ERROR, "WEBKIT_");
genumPolicyError = G_DEF_CLASS(WEBKIT_TYPE_POLICY_ERROR, "PolicyError", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_POLICY_ERROR, "WEBKIT_");
genumPluginError = G_DEF_CLASS(WEBKIT_TYPE_PLUGIN_ERROR, "PluginError", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_PLUGIN_ERROR, "WEBKIT_");
genumCacheModel = G_DEF_CLASS(WEBKIT_TYPE_CACHE_MODEL, "CacheModel", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_CACHE_MODEL, "WEBKIT_");
genumLoadStatus = G_DEF_CLASS(WEBKIT_TYPE_LOAD_STATUS, "LoadStatus", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_LOAD_STATUS, "WEBKIT_");
genumNavigationReason = G_DEF_CLASS(WEBKIT_TYPE_WEB_NAVIGATION_REASON, "NavigationReason", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_WEB_NAVIGATION_REASON, "WEBKIT_");
genumHitTestResultContext = G_DEF_CLASS(WEBKIT_TYPE_HIT_TEST_RESULT_CONTEXT, "HitTestResultContext", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_HIT_TEST_RESULT_CONTEXT, "WEBKIT_");
genumEditingBehavior = G_DEF_CLASS(WEBKIT_TYPE_EDITING_BEHAVIOR, "EditingBehavior", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_EDITING_BEHAVIOR, "WEBKIT_");
genumNavigationResponse = G_DEF_CLASS(WEBKIT_TYPE_NAVIGATION_RESPONSE, "NavigationResponse", mWebKit);
G_DEF_CONSTANTS(mWebKit, WEBKIT_TYPE_NAVIGATION_RESPONSE, "WEBKIT_");
rb_gc_register_address(&_gcpool_RubyFunc);
}
//
// Everything exposed to Ruby is exposed here.
//
void shoes_ruby_init() {
progname = rb_str_new2("(eval)");
rb_define_variable("$0", &progname);
rb_define_variable("$PROGRAM_NAME", &progname);
instance_eval_proc = rb_eval_string("lambda{|o,b| o.instance_eval(&b)}");
rb_gc_register_address(&instance_eval_proc);
ssNestSlot = rb_eval_string("{:height => 1.0}");
rb_gc_register_address(&ssNestSlot);
s_aref = rb_intern("[]=");
s_perc = rb_intern("%");
s_mult = rb_intern("*");
SYMBOL_DEFS(SYMBOL_INTERN);
symAltQuest = ID2SYM(rb_intern("alt_?"));
symAltSlash = ID2SYM(rb_intern("alt_/"));
symAltEqual = ID2SYM(rb_intern("alt_="));
symAltDot = ID2SYM(rb_intern("alt_."));
symAltSemiColon = ID2SYM(rb_intern("alt_;"));
//
// I want all elements to be addressed Shoes::Name, but also available in
// a separate mixin (cTypes), for inclusion in every Shoes.app block.
//
cTypes = rb_define_module("Shoes");
rb_mod_remove_const(rb_cObject, rb_str_new2("Shoes"));
cShoesWindow = rb_define_class_under(cTypes, "Window", rb_cObject);
cMouse = rb_define_class_under(cTypes, "Mouse", rb_cObject);
cCanvas = rb_define_class_under(cTypes, "Canvas", rb_cObject);
rb_define_alloc_func(cCanvas, shoes_canvas_alloc);
rb_define_method(cCanvas, "top", CASTHOOK(shoes_canvas_get_top), 0);
rb_define_method(cCanvas, "left", CASTHOOK(shoes_canvas_get_left), 0);
rb_define_method(cCanvas, "width", CASTHOOK(shoes_canvas_get_width), 0);
rb_define_method(cCanvas, "height", CASTHOOK(shoes_canvas_get_height), 0);
rb_define_method(cCanvas, "scroll_height", CASTHOOK(shoes_canvas_get_scroll_height), 0);
rb_define_method(cCanvas, "scroll_max", CASTHOOK(shoes_canvas_get_scroll_max), 0);
rb_define_method(cCanvas, "scroll_top", CASTHOOK(shoes_canvas_get_scroll_top), 0);
rb_define_method(cCanvas, "scroll_top=", CASTHOOK(shoes_canvas_set_scroll_top), 1);
rb_define_method(cCanvas, "displace", CASTHOOK(shoes_canvas_displace), 2);
rb_define_method(cCanvas, "move", CASTHOOK(shoes_canvas_move), 2);
rb_define_method(cCanvas, "style", CASTHOOK(shoes_canvas_style), -1);
rb_define_method(cCanvas, "parent", CASTHOOK(shoes_canvas_get_parent), 0);
rb_define_method(cCanvas, "contents", CASTHOOK(shoes_canvas_contents), 0);
rb_define_method(cCanvas, "children", CASTHOOK(shoes_canvas_children), 0);
rb_define_method(cCanvas, "draw", CASTHOOK(shoes_canvas_draw), 2);
rb_define_method(cCanvas, "hide", CASTHOOK(shoes_canvas_hide), 0);
rb_define_method(cCanvas, "show", CASTHOOK(shoes_canvas_show), 0);
rb_define_method(cCanvas, "toggle", CASTHOOK(shoes_canvas_toggle), 0);
rb_define_method(cCanvas, "remove", CASTHOOK(shoes_canvas_remove), 0);
rb_define_method(cCanvas, "refresh_slot", CASTHOOK(shoes_canvas_refresh_slot), 0);
rb_define_method(cCanvas, "refresh", CASTHOOK(shoes_canvas_refresh_slot), 0);
rb_define_method(cCanvas, "cursor", CASTHOOK(shoes_canvas_get_cursor), 0);
rb_define_method(cCanvas, "cursor=", CASTHOOK(shoes_canvas_set_cursor), 1);
cShoes = rb_define_class("Shoes", cCanvas);
rb_include_module(cShoes, cTypes);
rb_const_set(cShoes, rb_intern("Types"), cTypes);
shoes_version_init();
// other Shoes:: constants
rb_const_set(cTypes, rb_intern("RAD2PI"), rb_float_new(SHOES_RAD2PI));
rb_const_set(cTypes, rb_intern("TWO_PI"), rb_float_new(SHOES_PIM2));
rb_const_set(cTypes, rb_intern("HALF_PI"), rb_float_new(SHOES_HALFPI));
rb_const_set(cTypes, rb_intern("PI"), rb_float_new(SHOES_PI));
cApp = rb_define_class_under(cTypes, "App", rb_cObject);
rb_define_alloc_func(cApp, shoes_app_alloc);
rb_define_method(cApp, "fullscreen", CASTHOOK(shoes_app_get_fullscreen), 0);
rb_define_method(cApp, "fullscreen=", CASTHOOK(shoes_app_set_fullscreen), 1);
rb_define_method(cApp, "name", CASTHOOK(shoes_app_get_title), 0);
rb_define_method(cApp, "name=", CASTHOOK(shoes_app_set_title), 1);
rb_define_method(cApp, "location", CASTHOOK(shoes_app_location), 0);
rb_define_method(cApp, "started?", CASTHOOK(shoes_app_is_started), 0);
rb_define_method(cApp, "left", CASTHOOK(shoes_app_get_window_x_position), 0);
rb_define_method(cApp, "top", CASTHOOK(shoes_app_get_window_y_position), 0);
rb_define_method(cApp, "move", CASTHOOK(shoes_app_set_window_position), 2);
rb_define_method(cApp, "width", CASTHOOK(shoes_app_get_width), 0);
rb_define_method(cApp, "height", CASTHOOK(shoes_app_get_height), 0);
rb_define_method(cApp, "resize", CASTHOOK(shoes_app_resize_window), 2);
rb_define_method(cApp, "resizable", CASTHOOK(shoes_app_get_resizable), 0);
rb_define_method(cApp, "resizable=", CASTHOOK(shoes_app_set_resizable), 1);
rb_define_method(cApp, "slot", CASTHOOK(shoes_app_slot), 0);
rb_define_method(cApp, "set_window_icon_path", CASTHOOK(shoes_app_set_icon), 1); // New in 3.2.19
rb_define_method(cApp, "set_window_title", CASTHOOK(shoes_app_set_wtitle), 1); // New in 3.2.19
rb_define_method(cApp, "opacity", CASTHOOK(shoes_app_get_opacity), 0);
rb_define_method(cApp, "opacity=", CASTHOOK(shoes_app_set_opacity), 1);
rb_define_method(cApp, "decorated", CASTHOOK(shoes_app_get_decoration), 0);
rb_define_method(cApp, "decorated=", CASTHOOK(shoes_app_set_decoration), 1);
rb_define_alias(cApp, "decorated?", "decorated");
rb_define_method(cApp, "cache", CASTHOOK(shoes_app_get_cache), 0);
rb_define_method(cApp, "cache=", CASTHOOK(shoes_app_set_cache), 1);
rb_define_method(cApp, "cache_clear", CASTHOOK(shoes_app_clear_cache), 1);
rb_define_method(cApp, "event=", CASTHOOK(shoes_app_set_event_handler), 1);
rb_define_method(cApp, "replay_event", CASTHOOK(shoes_app_replay_event), 1);
rb_define_method(cApp, "monitor", CASTHOOK(shoes_app_monitor_get), 0);
rb_define_method(cApp, "monitor=", CASTHOOK(shoes_app_monitor_set), 1);
rb_define_method(cApp, "id", CASTHOOK(shoes_app_id), 0);
/* Settings holds global values, not per app values. Part of shoes_world_t */
cSettings = rb_define_class_under(cTypes, "Settings", rb_cObject);
rb_define_alloc_func(cSettings, shoes_settings_alloc);
rb_define_method(cSettings, "dbus", CASTHOOK(shoes_settings_dbus),0);
rb_define_method(cSettings, "app_name", CASTHOOK(shoes_settings_app_name),0);
rb_define_method(cSettings, "app_name=", CASTHOOK(shoes_settings_set_app_name),1);
rb_define_method(cSettings, "icon_path", CASTHOOK(shoes_settings_app_icon),0);
rb_define_method(cSettings, "icon_path=", CASTHOOK(shoes_settings_set_app_icon),1);
rb_define_method(cSettings, "theme", CASTHOOK(shoes_settings_get_theme),0);
rb_define_method(cSettings, "theme=", CASTHOOK(shoes_settings_set_theme),1);
rb_define_method(cSettings, "mdi", CASTHOOK(shoes_settings_mdi),0);
rb_define_method(cSettings, "use_menus", CASTHOOK(shoes_settings_menu),0);
rb_define_method(cSettings, "rdomain", CASTHOOK(shoes_settings_rdomain),0);
rb_define_method(cSettings, "rdomain=", CASTHOOK(shoes_settings_set_rdomain),1);
rb_define_method(cSettings, "monitor_count", CASTHOOK(shoes_settings_monitor_count),0);
rb_define_method(cSettings, "monitor_geometry", CASTHOOK(shoes_settings_monitor_geometry),1);
rb_define_method(cSettings, "monitor_default", CASTHOOK(shoes_settings_monitor_default), 0);
rb_define_method(cSettings, "extra1", CASTHOOK(shoes_setting_extra1), 0);
rb_define_method(cSettings, "extra2", CASTHOOK(shoes_setting_extra2), 0);
rb_define_method(cSettings, "wintmo", CASTHOOK(shoes_setting_get_wintmo), 0);
rb_define_method(cSettings, "wintmo=", CASTHOOK(shoes_setting_set_wintmo), 1);
rb_define_method(cSettings, "display_backend", CASTHOOK(shoes_setting_display_backend), 0);
cDialog = rb_define_class_under(cTypes, "Dialog", cApp);
eInvMode = rb_define_class_under(cTypes, "InvalidModeError", rb_eStandardError);
eNotImpl = rb_define_class_under(cTypes, "NotImplementedError", rb_eStandardError);
eImageError = rb_define_class_under(cTypes, "ImageError", rb_eStandardError);
C(HEX_SOURCE, "/^(?:0x|#)?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i");
C(HEX3_SOURCE, "/^(?:0x|#)?([0-9A-F])([0-9A-F])([0-9A-F])$/i");
C(RGB_SOURCE, "/^rgb\\((\\d+), *(\\d+), *(\\d+)\\)$/i");
C(RGBA_SOURCE, "/^rgb\\((\\d+), *(\\d+), *(\\d+), *(\\d+)\\)$/i");
C(GRAY_SOURCE, "/^gray\\((\\d+)\\)$/i");
C(GRAYA_SOURCE, "/^gray\\((\\d+), *(\\d+)\\)$/i");
C(LF, "/\\r?\\n/");
rb_eval_string(
"def Shoes.escape(string);"
"string.gsub(/&/n, '&').gsub(/\\\"/n, '"').gsub(/>/n, '>').gsub(/</n, '<');"
"end"
);
rb_define_singleton_method(cShoes, "APPS", CASTHOOK(shoes_apps_get), 0);
rb_define_singleton_method(cShoes, "app", CASTHOOK(shoes_app_main), -1);
rb_define_singleton_method(cShoes, "p", CASTHOOK(shoes_p), 1);
rb_define_singleton_method(cShoes, "log", CASTHOOK(shoes_log), 0);
rb_define_singleton_method(cShoes, "show_console", CASTHOOK(shoes_app_console), 0); // New in 3.2.23
rb_define_singleton_method(cShoes, "terminal", CASTHOOK(shoes_app_terminal), -1); // New in 3.3.2 replaces console
rb_define_singleton_method(cShoes, "quit", CASTHOOK(shoes_app_quit), 0); // Shoes 3.3.2
rb_define_singleton_method(cShoes, "settings", CASTHOOK(shoes_app_settings), 0); // Shoes 3.3.7
//rb_define_singleton_method(cShoes, "exit", CASTHOOK(shoes_app_quit), 0);
//
// Canvas methods
// See ruby.h for the complete list of Canvas method signatures.
// Macros are used to build App redirection methods, which should be
// speedier than method_missing.
//
CANVAS_DEFS(RUBY_M);
//
// Shoes Kernel methods
//
//rb_define_method(rb_mKernel, "quit", CASTHOOK(shoes_app_quit), 0);
//rb_define_method(rb_mKernel, "exit", CASTHOOK(shoes_app_quit), 0);
rb_define_method(rb_mKernel, "secret_exit_hook", CASTHOOK(shoes_exit_setup),0); //unused?
rb_define_method(rb_mKernel, "debug", CASTHOOK(shoes_canvas_debug), 1);
rb_define_method(rb_mKernel, "info", CASTHOOK(shoes_canvas_info), 1);
rb_define_method(rb_mKernel, "warn", CASTHOOK(shoes_canvas_warn), 1);
rb_define_method(rb_mKernel, "error", CASTHOOK(shoes_canvas_error), 1);
cFlow = rb_define_class_under(cTypes, "Flow", cShoes);
cStack = rb_define_class_under(cTypes, "Stack", cShoes);
cMask = rb_define_class_under(cTypes, "Mask", cShoes);
cWidget = rb_define_class_under(cTypes, "Widget", cShoes);
rb_define_method(cApp, "method_missing", CASTHOOK(shoes_app_method_missing), -1);
rb_define_method(rb_mKernel, "alert", CASTHOOK(shoes_dialog_alert), -1);
rb_define_method(rb_mKernel, "ask", CASTHOOK(shoes_dialog_ask), -1);
rb_define_method(rb_mKernel, "confirm", CASTHOOK(shoes_dialog_confirm), -1);
rb_define_method(rb_mKernel, "ask_color", CASTHOOK(shoes_dialog_color), 1);
rb_define_method(rb_mKernel, "ask_open_file", CASTHOOK(shoes_dialog_open), -1);
rb_define_method(rb_mKernel, "ask_save_file", CASTHOOK(shoes_dialog_save), -1);
rb_define_method(rb_mKernel, "ask_open_folder", CASTHOOK(shoes_dialog_open_folder), -1);
rb_define_method(rb_mKernel, "ask_save_folder", CASTHOOK(shoes_dialog_save_folder), -1);
rb_define_method(rb_mKernel, "font", CASTHOOK(shoes_font), 1);
SHOES_TYPES_INIT;
}
static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
{
VALUE xpath_handler = Qnil;
VALUE result;
VALUE *argv;
VALUE doc;
VALUE node_set = Qnil;
xmlNodeSetPtr xml_node_set = NULL;
xmlXPathObjectPtr obj;
int i;
nokogiriNodeSetTuple *node_set_tuple;
assert(ctx);
assert(ctx->context);
assert(ctx->context->userData);
assert(ctx->context->doc);
assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
xpath_handler = (VALUE)(ctx->context->userData);
argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
for (i = 0 ; i < nargs ; ++i) {
rb_gc_register_address(&argv[i]);
}
doc = DOC_RUBY_OBJECT(ctx->context->doc);
if (nargs > 0) {
i = nargs - 1;
do {
obj = valuePop(ctx);
switch(obj->type) {
case XPATH_STRING:
argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
break;
case XPATH_BOOLEAN:
argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
break;
case XPATH_NUMBER:
argv[i] = rb_float_new(obj->floatval);
break;
case XPATH_NODESET:
argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc);
break;
default:
argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
}
xmlXPathFreeNodeSetList(obj);
} while(i-- > 0);
}
result = rb_funcall2(
xpath_handler,
rb_intern((const char *)ctx->context->function),
nargs,
argv
);
for (i = 0 ; i < nargs ; ++i) {
rb_gc_unregister_address(&argv[i]);
}
free(argv);
switch(TYPE(result)) {
case T_FLOAT:
case T_BIGNUM:
case T_FIXNUM:
xmlXPathReturnNumber(ctx, NUM2DBL(result));
break;
case T_STRING:
xmlXPathReturnString(
ctx,
(xmlChar *)xmlXPathWrapCString(StringValuePtr(result))
);
break;
case T_TRUE:
xmlXPathReturnTrue(ctx);
break;
case T_FALSE:
xmlXPathReturnFalse(ctx);
break;
case T_NIL:
break;
case T_ARRAY:
{
VALUE args[2];
args[0] = doc;
args[1] = result;
node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
Data_Get_Struct(node_set, nokogiriNodeSetTuple, node_set_tuple);
xml_node_set = node_set_tuple->node_set;
xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
}
break;
case T_DATA:
if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
Data_Get_Struct(result, nokogiriNodeSetTuple, node_set_tuple);
xml_node_set = node_set_tuple->node_set;
/* Copy the node set, otherwise it will get GC'd. */
xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
break;
}
default:
rb_raise(rb_eRuntimeError, "Invalid return type");
}
}
KRubyObject::KRubyObject(VALUE object) :
object(object)
{
rb_gc_register_address(&object);
}
void rubysdl2_init_gl(void)
{
mGL = rb_define_module_under(mSDL2, "GL");
cGLContext = rb_define_class_under(mGL, "Context", rb_cObject);
rb_define_singleton_method(cGLContext, "create", GLContext_s_create, 1);
rb_define_singleton_method(cGLContext, "current", GLContext_s_current, 0);
rb_define_method(cGLContext, "destroy?", GLContext_destroy_p, 0);
rb_define_method(cGLContext, "destroy", GLContext_destroy, 0);
rb_define_method(cGLContext, "make_current", GLContext_make_current, 1);
rb_define_module_function(mGL, "extension_supported?", GL_s_extension_supported_p, 1);
rb_define_module_function(mGL, "swap_interval", GL_s_swap_interval, 0);
rb_define_module_function(mGL, "swap_interval=", GL_s_set_swap_interval, 1);
rb_define_module_function(mGL, "get_attribute", GL_s_get_attribute, 1);
rb_define_module_function(mGL, "set_attribute", GL_s_set_attribute, 2);
/* */
/* OpenGL attribute - minimal bits of red channel in color buffer, default is 3 */
rb_define_const(mGL, "RED_SIZE", INT2NUM(SDL_GL_RED_SIZE));
/* OpenGL attribute - minimal bits of green channel in color buffer, default is 3 */
rb_define_const(mGL, "GREEN_SIZE", INT2NUM(SDL_GL_GREEN_SIZE));
/* OpenGL attribute - minimal bits of blue channel in color buffer, default is 2 */
rb_define_const(mGL, "BLUE_SIZE", INT2NUM(SDL_GL_BLUE_SIZE));
/* OpenGL attribute - minimal bits of alpha channel in color buffer, default is 0 */
rb_define_const(mGL, "ALPHA_SIZE", INT2NUM(SDL_GL_ALPHA_SIZE));
/* OpenGL attribute - minimal bits of framebufer, default is 0 */
rb_define_const(mGL, "BUFFER_SIZE", INT2NUM(SDL_GL_BUFFER_SIZE));
/* OpenGL attribute - whether the single buffer (0) or double buffer (1), default
is double buffer */
rb_define_const(mGL, "DOUBLEBUFFER", INT2NUM(SDL_GL_DOUBLEBUFFER));
/* OpenGL attribute - bits of depth buffer, default is 16 */
rb_define_const(mGL, "DEPTH_SIZE", INT2NUM(SDL_GL_DEPTH_SIZE));
/* OpenGL attribute - bits of stencil buffer, default is 0 */
rb_define_const(mGL, "STENCIL_SIZE", INT2NUM(SDL_GL_STENCIL_SIZE));
/* OpenGL attribute - minimal bits of red channel in accumlation buffer,
default is 0 */
rb_define_const(mGL, "ACCUM_RED_SIZE", INT2NUM(SDL_GL_ACCUM_RED_SIZE));
/* OpenGL attribute - minimal bits of green channel in accumlation buffer,
default is 0 */
rb_define_const(mGL, "ACCUM_GREEN_SIZE", INT2NUM(SDL_GL_ACCUM_GREEN_SIZE));
/* OpenGL attribute - minimal bits of blue channel in accumlation buffer,
default is 0 */
rb_define_const(mGL, "ACCUM_BLUE_SIZE", INT2NUM(SDL_GL_ACCUM_BLUE_SIZE));
/* OpenGL attribute - minimal bits of alpha channel in accumlation buffer,
default is 0 */
rb_define_const(mGL, "ACCUM_ALPHA_SIZE", INT2NUM(SDL_GL_ACCUM_ALPHA_SIZE));
/* OpenGL attribute - whether output is stereo (1) or not (0), default is 0 */
rb_define_const(mGL, "STEREO", INT2NUM(SDL_GL_STEREO));
/* OpenGL attribuite - the number of buffers used for multisampe anti-aliasing,
default is 0 */
rb_define_const(mGL, "MULTISAMPLEBUFFERS", INT2NUM(SDL_GL_MULTISAMPLEBUFFERS));
/* OpenGL attribute - the number of samples used around the current pixel
use for multisample anti-aliasing, default is 0 */
rb_define_const(mGL, "MULTISAMPLESAMPLES", INT2NUM(SDL_GL_MULTISAMPLESAMPLES));
/* OpenGL attribute - 1 for requiring hardware acceleration, 0 for software rendering,
default is allowing either */
rb_define_const(mGL, "ACCELERATED_VISUAL", INT2NUM(SDL_GL_ACCELERATED_VISUAL));
/* OpenGL attribute - not used (deprecated) */
rb_define_const(mGL, "RETAINED_BACKING", INT2NUM(SDL_GL_RETAINED_BACKING));
/* OpenGL attribute - OpenGL context major version */
rb_define_const(mGL, "CONTEXT_MAJOR_VERSION", INT2NUM(SDL_GL_CONTEXT_MAJOR_VERSION));
/* OpenGL attribute - OpenGL context minor version */
rb_define_const(mGL, "CONTEXT_MINOR_VERSION", INT2NUM(SDL_GL_CONTEXT_MINOR_VERSION));
/*
* INT2NUM(SDL_GL_CONTEXT_FLAGS):
*
* OpenGL attribute - the bit combination of following constants, or 0.
* default is 0
*
* * {SDL2::GL::CONTEXT_DEBUG_FLAG}
* * {SDL2::GL::CONTEXT_FORWARD_COMPATIBLE_FLAG}
* * {SDL2::GL::CONTEXT_ROBUST_ACCESS_FLAG}
* * {SDL2::GL::CONTEXT_RESET_ISOLATION_FLAG}
*
* These flags are mapped to some OpenGL extensions. Please see
* the documentation of each constant for more details.
*
* https://wiki.libsdl.org/SDL_GLcontextFlag
*/
rb_define_const(mGL, "CONTEXT_FLAGS", INT2NUM(SDL_GL_CONTEXT_FLAGS));
/* INT2NUM(SDL_GL_CONTEXT_PROFILE_MASK):
*
* OpenGL attribute - type of GL context, one of the following constants,
* defaults depends on platform
*
* * {CONTEXT_PROFILE_CORE}
* * {CONTEXT_PROFILE_COMPATIBILITY}
* * {CONTEXT_PROFILE_ES}
*
* https://wiki.libsdl.org/SDL_GLprofile
*/
rb_define_const(mGL, "CONTEXT_PROFILE_MASK", INT2NUM(SDL_GL_CONTEXT_PROFILE_MASK));
/* OpenGL attribute - OpenGL context sharing, default is 0 */
rb_define_const(mGL, "SHARE_WITH_CURRENT_CONTEXT", INT2NUM(SDL_GL_SHARE_WITH_CURRENT_CONTEXT));
#if SDL_VERSION_ATLEAST(2,0,1)
/* OpenGL attribute - 1 for requesting sRGB capable visual, default to 0 */
rb_define_const(mGL, "FRAMEBUFFER_SRGB_CAPABLE", INT2NUM(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE));
#endif
/* OpenGL attribute - not used (deprecated) */
rb_define_const(mGL, "CONTEXT_EGL", INT2NUM(SDL_GL_CONTEXT_EGL));
/* */
/* This flag maps to GLX_CONTEXT_DEBUG_BIT_ARB in
* the GLX_ARB_create_context extension for X11
* and WGL_CONTEXT_DEBUG_BIT_ARB in the WGL_ARB_create_context
* extension for Windows.
*/
rb_define_const(mGL, "CONTEXT_DEBUG_FLAG", INT2NUM(SDL_GL_CONTEXT_DEBUG_FLAG));
/*
* This flag maps to GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB in the
* GLX_ARB_create_context extension for X11 and
* WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB in the WGL_ARB_create_context
* extension for Windows.
*/
rb_define_const(mGL, "CONTEXT_FORWARD_COMPATIBLE_FLAG", INT2NUM(SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG));
/*
* This flag maps to GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB in the
* GLX_ARB_create_context_robustness extension for X11 and
* WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB in the WGL_ARB_create_context_robustness
* extension for Windows.
*/
rb_define_const(mGL, "CONTEXT_ROBUST_ACCESS_FLAG", INT2NUM(SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG));
/*
* This flag maps to GLX_CONTEXT_RESET_ISOLATION_BIT_ARB in the
* GLX_ARB_robustness_isolation extension for X11 and
* WGL_CONTEXT_RESET_ISOLATION_BIT_ARB in the WGL_ARB_create_context_robustness
* extension for Windows.
*/
rb_define_const(mGL, "CONTEXT_RESET_ISOLATION_FLAG", INT2NUM(SDL_GL_CONTEXT_RESET_ISOLATION_FLAG));
/*
* OpenGL core profile - deprecated
* functions are disabled
*/
rb_define_const(mGL, "CONTEXT_PROFILE_CORE", INT2NUM(SDL_GL_CONTEXT_PROFILE_CORE));
/*
* OpenGL compatibility profile -
* deprecated functions are allowed
*/
rb_define_const(mGL, "CONTEXT_PROFILE_COMPATIBILITY", INT2NUM(SDL_GL_CONTEXT_PROFILE_COMPATIBILITY));
/*
* OpenGL ES profile - only a subset of the
* base OpenGL functionality is available
*/
rb_define_const(mGL, "CONTEXT_PROFILE_ES", INT2NUM(SDL_GL_CONTEXT_PROFILE_ES));
rb_gc_register_address(¤t_context);
}
Objects::Objects()
{
objects = rb_ary_new();
rb_gc_register_address(&objects);
}
