static VALUE Game_initialize(int argc, VALUE* argv, VALUE self) { if (!NIL_P(Game_s_current(rb_cGame))) { rb_raise(strb_GetStarRubyErrorClass(), "already run"); } volatile VALUE rbWidth, rbHeight, rbOptions; rb_scan_args(argc, argv, "21", &rbWidth, &rbHeight, &rbOptions); if (NIL_P(rbOptions)) { rbOptions = rb_hash_new(); } else { Check_Type(rbOptions, T_HASH); } Game* game; Data_Get_Struct(self, Game, game); if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER)) { rb_raise_sdl_error(); } const int width = NUM2INT(rbWidth); const int height = NUM2INT(rbHeight); volatile VALUE rbFps = rb_hash_aref(rbOptions, symbol_fps); Game_fps_eq(self, !NIL_P(rbFps) ? rbFps : INT2FIX(30)); volatile VALUE rbTitle = rb_hash_aref(rbOptions, symbol_title); Game_title_eq(self, !NIL_P(rbTitle) ? rbTitle : rb_str_new2("")); bool cursor = false; volatile VALUE val; Check_Type(rbOptions, T_HASH); if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_cursor))) { cursor = RTEST(val); } if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_fullscreen))) { game->isFullscreen = RTEST(val); } if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_window_scale))) { game->windowScale = NUM2INT(val); if (game->windowScale < 1) { rb_raise(rb_eArgError, "invalid window scale: %d", game->windowScale); } } if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_vsync))) { game->isVsync = RTEST(val); } SDL_ShowCursor(cursor ? SDL_ENABLE : SDL_DISABLE); volatile VALUE rbScreen = rb_class_new_instance(2, (VALUE[]){INT2NUM(width), INT2NUM(height)}, strb_GetTextureClass()); game->screen = rbScreen; InitializeScreen(game); rb_iv_set(rb_cGame, "current", self); return Qnil; }
static void rb_load_internal(VALUE fname, int wrap) { int state; rb_thread_t *th = GET_THREAD(); volatile VALUE wrapper = th->top_wrapper; volatile VALUE self = th->top_self; volatile int loaded = FALSE; volatile int mild_compile_error; #ifndef __GNUC__ rb_thread_t *volatile th0 = th; #endif th->errinfo = Qnil; /* ensure */ if (!wrap) { rb_secure(4); /* should alter global state */ th->top_wrapper = 0; } else { /* load in anonymous module as toplevel */ th->top_self = rb_obj_clone(rb_vm_top_self()); th->top_wrapper = rb_module_new(); rb_extend_object(th->top_self, th->top_wrapper); } mild_compile_error = th->mild_compile_error; PUSH_TAG(); state = EXEC_TAG(); if (state == 0) { NODE *node; VALUE iseq; th->mild_compile_error++; node = (NODE *)rb_load_file(RSTRING_PTR(fname)); loaded = TRUE; iseq = rb_iseq_new_top(node, rb_str_new2("<top (required)>"), fname, fname, Qfalse); th->mild_compile_error--; rb_iseq_eval(iseq); } POP_TAG(); #ifndef __GNUC__ th = th0; fname = RB_GC_GUARD(fname); #endif th->mild_compile_error = mild_compile_error; th->top_self = self; th->top_wrapper = wrapper; if (!loaded) { rb_exc_raise(GET_THREAD()->errinfo); } if (state) { rb_vm_jump_tag_but_local_jump(state, Qundef); } if (!NIL_P(GET_THREAD()->errinfo)) { /* exception during load */ rb_exc_raise(th->errinfo); } }
/* * call-seq: * dirname() -> String * * Returns the libusb device attribute dirname. At least in linux, this seems * to correspond to the device's directory in /proc/bus/usb * */ VALUE device_dirname(VALUE self) { struct usb_device *dev; Data_Get_Struct(self, struct usb_device, dev); return rb_str_new2(dev->bus->dirname); }
/* * call-seq: configure(opts) * * Configure this State instance with the Hash _opts_, and return * itself. */ static inline VALUE cState_configure(VALUE self, VALUE opts) { VALUE tmp; GET_STATE(self); tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash"); if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h"); if (NIL_P(tmp)) { rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash"); } opts = tmp; tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->indent = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space_before = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->array_nl = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->object_nl = tmp; } tmp = ID2SYM(i_check_circular); #if WITH_OBJC if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) { #else if (st_lookup(RHASH_TBL(opts), tmp, 0)) { #endif tmp = rb_hash_aref(opts, ID2SYM(i_check_circular)); state->check_circular = RTEST(tmp); } else { state->check_circular = 1; } tmp = ID2SYM(i_max_nesting); state->max_nesting = 19; #if WITH_OBJC if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) { #else if (st_lookup(RHASH_TBL(opts), tmp, 0)) { #endif VALUE max_nesting = rb_hash_aref(opts, tmp); if (RTEST(max_nesting)) { Check_Type(max_nesting, T_FIXNUM); state->max_nesting = FIX2LONG(max_nesting); } else { state->max_nesting = 0; } } tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan)); state->allow_nan = RTEST(tmp); return self; } /* * call-seq: to_h * * Returns the configuration instance variables as a hash, that can be * passed to the configure method. */ static VALUE cState_to_h(VALUE self) { VALUE result = rb_hash_new(); GET_STATE(self); rb_hash_aset(result, ID2SYM(i_indent), state->indent); rb_hash_aset(result, ID2SYM(i_space), state->space); rb_hash_aset(result, ID2SYM(i_space_before), state->space_before); rb_hash_aset(result, ID2SYM(i_object_nl), state->object_nl); rb_hash_aset(result, ID2SYM(i_array_nl), state->array_nl); rb_hash_aset(result, ID2SYM(i_check_circular), state->check_circular ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting)); return result; } /* * call-seq: new(opts = {}) * * Instantiates a new State object, configured by _opts_. * * _opts_ can have the following keys: * * * *indent*: a string used to indent levels (default: ''), * * *space*: a string that is put after, a : or , delimiter (default: ''), * * *space_before*: a string that is put before a : pair delimiter (default: ''), * * *object_nl*: a string that is put at the end of a JSON object (default: ''), * * *array_nl*: a string that is put at the end of a JSON array (default: ''), * * *check_circular*: true if checking for circular data structures * should be done, false (the default) otherwise. * * *allow_nan*: true if NaN, Infinity, and -Infinity should be * generated, otherwise an exception is thrown, if these values are * encountered. This options defaults to false. */ static VALUE cState_initialize(int argc, VALUE *argv, VALUE self) { VALUE opts; GET_STATE(self); rb_scan_args(argc, argv, "01", &opts); state->indent = rb_str_new2(""); state->space = rb_str_new2(""); state->space_before = rb_str_new2(""); state->array_nl = rb_str_new2(""); state->object_nl = rb_str_new2(""); if (NIL_P(opts)) { state->check_circular = 1; state->allow_nan = 0; state->max_nesting = 19; } else { cState_configure(self, opts); } state->seen = rb_hash_new(); state->memo = Qnil; state->depth = INT2FIX(0); return self; }
void Init_curb_core() { // TODO we need to call curl_global_cleanup at exit! curl_version_info_data *ver; VALUE curlver, curllongver, curlvernum; curl_global_init(CURL_GLOBAL_ALL); ver = curl_version_info(CURLVERSION_NOW); mCurl = rb_define_module("Curl"); curlver = rb_str_new2(ver->version); curllongver = rb_str_new2(curl_version()); curlvernum = LONG2NUM(LIBCURL_VERSION_NUM); rb_define_const(mCurl, "CURB_VERSION", rb_str_new2(CURB_VERSION)); rb_define_const(mCurl, "VERSION", curlver); rb_define_const(mCurl, "CURL_VERSION", curlver); rb_define_const(mCurl, "VERNUM", curlvernum); rb_define_const(mCurl, "CURL_VERNUM", curlvernum); rb_define_const(mCurl, "LONG_VERSION", curllongver); rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver); /* Passed to on_debug handler to indicate that the data is informational text. */ rb_define_const(mCurl, "CURLINFO_TEXT", INT2FIX(CURLINFO_TEXT)); /* Passed to on_debug handler to indicate that the data is header (or header-like) data received from the peer. */ rb_define_const(mCurl, "CURLINFO_HEADER_IN", INT2FIX(CURLINFO_HEADER_IN)); /* Passed to on_debug handler to indicate that the data is header (or header-like) data sent to the peer. */ rb_define_const(mCurl, "CURLINFO_HEADER_OUT", INT2FIX(CURLINFO_HEADER_OUT)); /* Passed to on_debug handler to indicate that the data is protocol data received from the peer. */ rb_define_const(mCurl, "CURLINFO_DATA_IN", INT2FIX(CURLINFO_DATA_IN)); /* Passed to on_debug handler to indicate that the data is protocol data sent to the peer. */ rb_define_const(mCurl, "CURLINFO_DATA_OUT", INT2FIX(CURLINFO_DATA_OUT)); #ifdef HAVE_CURLFTPMETHOD_MULTICWD rb_define_const(mCurl, "CURL_MULTICWD", INT2FIX(CURLFTPMETHOD_MULTICWD)); #endif #ifdef HAVE_CURLFTPMETHOD_NOCWD rb_define_const(mCurl, "CURL_NOCWD", INT2FIX(CURLFTPMETHOD_NOCWD)); #endif #ifdef HAVE_CURLFTPMETHOD_SINGLECWD rb_define_const(mCurl, "CURL_SINGLECWD", INT2FIX(CURLFTPMETHOD_SINGLECWD)); #endif /* When passed to Curl::Easy#proxy_type , indicates that the proxy is an HTTP proxy. (libcurl >= 7.10) */ #ifdef HAVE_CURLPROXY_HTTP rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(CURLPROXY_HTTP)); #else rb_define_const(mCurl, "CURLPROXY_HTTP", INT2FIX(-1)); #endif #ifdef CURL_VERSION_SSL rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(CURL_SSLVERSION_DEFAULT)); rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1", INT2FIX(CURL_SSLVERSION_TLSv1)); rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2", INT2FIX(CURL_SSLVERSION_SSLv2)); rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3", INT2FIX(CURL_SSLVERSION_SSLv3)); rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(CURB_FTPSSL_CONTROL)); rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(CURB_FTPSSL_NONE)); rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(CURB_FTPSSL_TRY)); rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(CURB_FTPSSL_ALL)); #else rb_define_const(mCurl, "CURL_SSLVERSION_DEFAULT", INT2FIX(-1)); rb_define_const(mCurl, "CURL_SSLVERSION_TLSv1", INT2FIX(-1)); rb_define_const(mCurl, "CURL_SSLVERSION_SSLv2", INT2FIX(-1)); rb_define_const(mCurl, "CURL_SSLVERSION_SSLv3", INT2FIX(-1)); rb_define_const(mCurl, "CURL_USESSL_CONTROL", INT2FIX(-1)); rb_define_const(mCurl, "CURL_USESSL_NONE", INT2FIX(-1)); rb_define_const(mCurl, "CURL_USESSL_TRY", INT2FIX(-1)); rb_define_const(mCurl, "CURL_USESSL_ALL", INT2FIX(-1)); #endif /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS4 proxy. (libcurl >= 7.15.2) */ #ifdef HAVE_CURLPROXY_SOCKS4 rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(CURLPROXY_SOCKS4)); #else rb_define_const(mCurl, "CURLPROXY_SOCKS4", INT2FIX(-2)); #endif /* When passed to Curl::Easy#proxy_type , indicates that the proxy is a SOCKS5 proxy. (libcurl >= 7.10) */ #ifdef HAVE_CURLPROXY_SOCKS5 rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(CURLPROXY_SOCKS5)); #else rb_define_const(mCurl, "CURLPROXY_SOCKS5", INT2FIX(-2)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Basic authentication. */ #ifdef HAVE_CURLAUTH_BASIC rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(CURLAUTH_BASIC)); #else rb_define_const(mCurl, "CURLAUTH_BASIC", INT2FIX(0)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use Digest authentication. */ #ifdef HAVE_CURLAUTH_DIGEST rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(CURLAUTH_DIGEST)); #else rb_define_const(mCurl, "CURLAUTH_DIGEST", INT2FIX(0)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use GSS Negotiate authentication. Requires a suitable GSS-API library. */ #ifdef HAVE_CURLAUTH_GSSNEGOTIATE rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(CURLAUTH_GSSNEGOTIATE)); #else rb_define_const(mCurl, "CURLAUTH_GSSNEGOTIATE", INT2FIX(0)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, directs libcurl to use HTTP NTLM authentication. Requires MS Windows or OpenSSL support. */ #ifdef HAVE_CURLAUTH_NTLM rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(CURLAUTH_NTLM)); #else rb_define_const(mCurl, "CURLAUTH_NTLM", INT2FIX(0)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method except basic. */ #ifdef HAVE_CURLAUTH_ANYSAFE rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(CURLAUTH_ANYSAFE)); #else rb_define_const(mCurl, "CURLAUTH_ANYSAFE", INT2FIX(0)); #endif /* When passed to Curl::Easy#http_auth_types or Curl::Easy#proxy_auth_types, allows libcurl to select any suitable authentication method. */ #ifdef HAVE_CURLAUTH_ANY rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(CURLAUTH_ANY)); #else rb_define_const(mCurl, "CURLAUTH_ANY", INT2FIX(0)); #endif CURB_DEFINE(CURLOPT_VERBOSE); CURB_DEFINE(CURLOPT_HEADER); CURB_DEFINE(CURLOPT_NOPROGRESS); CURB_DEFINE(CURLOPT_NOSIGNAL); CURB_DEFINE(CURLOPT_WRITEFUNCTION); CURB_DEFINE(CURLOPT_WRITEDATA); CURB_DEFINE(CURLOPT_READFUNCTION); CURB_DEFINE(CURLOPT_READDATA); CURB_DEFINE(CURLOPT_IOCTLFUNCTION); CURB_DEFINE(CURLOPT_IOCTLDATA); CURB_DEFINE(CURLOPT_SEEKFUNCTION); CURB_DEFINE(CURLOPT_SEEKDATA); CURB_DEFINE(CURLOPT_SOCKOPTFUNCTION); CURB_DEFINE(CURLOPT_SOCKOPTDATA); CURB_DEFINE(CURLOPT_OPENSOCKETFUNCTION); CURB_DEFINE(CURLOPT_OPENSOCKETDATA); CURB_DEFINE(CURLOPT_PROGRESSFUNCTION); CURB_DEFINE(CURLOPT_PROGRESSDATA); CURB_DEFINE(CURLOPT_HEADERFUNCTION); CURB_DEFINE(CURLOPT_WRITEHEADER); CURB_DEFINE(CURLOPT_DEBUGFUNCTION); CURB_DEFINE(CURLOPT_DEBUGDATA); CURB_DEFINE(CURLOPT_SSL_CTX_FUNCTION); CURB_DEFINE(CURLOPT_SSL_CTX_DATA); CURB_DEFINE(CURLOPT_CONV_TO_NETWORK_FUNCTION); CURB_DEFINE(CURLOPT_CONV_FROM_NETWORK_FUNCTION); CURB_DEFINE(CURLOPT_CONV_FROM_UTF8_FUNCTION); #if HAVE_CURLOPT_INTERLEAVEFUNCTION CURB_DEFINE(CURLOPT_INTERLEAVEFUNCTION); #endif #if HAVE_CURLOPT_INTERLEAVEDATA CURB_DEFINE(CURLOPT_INTERLEAVEDATA); #endif #if HAVE_CURLOPT_CHUNK_BGN_FUNCTION CURB_DEFINE(CURLOPT_CHUNK_BGN_FUNCTION); #endif #if HAVE_CURLOPT_CHUNK_END_FUNCTION CURB_DEFINE(CURLOPT_CHUNK_END_FUNCTION); #endif #if HAVE_CURLOPT_CHUNK_DATA CURB_DEFINE(CURLOPT_CHUNK_DATA); #endif #if HAVE_CURLOPT_FNMATCH_FUNCTION CURB_DEFINE(CURLOPT_FNMATCH_FUNCTION); #endif #if HAVE_CURLOPT_FNMATCH_DATA CURB_DEFINE(CURLOPT_FNMATCH_DATA); #endif #if HAVE_CURLOPT_ERRORBUFFER CURB_DEFINE(CURLOPT_ERRORBUFFER); #endif #if HAVE_CURLOPT_STDERR CURB_DEFINE(CURLOPT_STDERR); #endif #if HAVE_CURLOPT_FAILONERROR CURB_DEFINE(CURLOPT_FAILONERROR); #endif CURB_DEFINE(CURLOPT_URL); CURB_DEFINE(CURLOPT_PROTOCOLS); CURB_DEFINE(CURLOPT_REDIR_PROTOCOLS); CURB_DEFINE(CURLOPT_PROXY); CURB_DEFINE(CURLOPT_PROXYPORT); #if HAVE_CURLOPT_PROXYTYPE CURB_DEFINE(CURLOPT_PROXYTYPE); #endif #if HAVE_CURLOPT_NOPROXY CURB_DEFINE(CURLOPT_NOPROXY); #endif CURB_DEFINE(CURLOPT_HTTPPROXYTUNNEL); #if HAVE_CURLOPT_SOCKS5_GSSAPI_SERVICE CURB_DEFINE(CURLOPT_SOCKS5_GSSAPI_SERVICE); #endif #if HAVE_CURLOPT_SOCKS5_GSSAPI_NEC CURB_DEFINE(CURLOPT_SOCKS5_GSSAPI_NEC); #endif CURB_DEFINE(CURLOPT_INTERFACE); #if HAVE_CURLOPT_LOCALPORT CURB_DEFINE(CURLOPT_LOCALPORT); #endif CURB_DEFINE(CURLOPT_DNS_CACHE_TIMEOUT); CURB_DEFINE(CURLOPT_DNS_USE_GLOBAL_CACHE); CURB_DEFINE(CURLOPT_BUFFERSIZE); CURB_DEFINE(CURLOPT_PORT); CURB_DEFINE(CURLOPT_TCP_NODELAY); #if HAVE_CURLOPT_ADDRESS_SCOPE CURB_DEFINE(CURLOPT_ADDRESS_SCOPE); #endif CURB_DEFINE(CURLOPT_NETRC); CURB_DEFINE(CURL_NETRC_OPTIONAL); CURB_DEFINE(CURL_NETRC_IGNORED); CURB_DEFINE(CURL_NETRC_REQUIRED); #if HAVE_CURLOPT_NETRC_FILE CURB_DEFINE(CURLOPT_NETRC_FILE); #endif CURB_DEFINE(CURLOPT_USERPWD); CURB_DEFINE(CURLOPT_PROXYUSERPWD); #if HAVE_CURLOPT_USERNAME CURB_DEFINE(CURLOPT_USERNAME); #endif #if HAVE_CURLOPT_PASSWORD CURB_DEFINE(CURLOPT_PASSWORD); #endif #if HAVE_CURLOPT_PROXYUSERNAME CURB_DEFINE(CURLOPT_PASSWORD); #endif #if HAVE_CURLOPT_PROXYPASSWORD CURB_DEFINE(CURLOPT_PASSWORD); #endif #if HAVE_CURLOPT_HTTPAUTH CURB_DEFINE(CURLOPT_HTTPAUTH); #endif #if HAVE_CURLAUTH_DIGEST_IE CURB_DEFINE(CURLAUTH_DIGEST_IE); #endif #if HAVE_CURLAUTH_ONLY CURB_DEFINE(CURLAUTH_ONLY); #endif #if HAVE_CURLOPT_TLSAUTH_TYPE CURB_DEFINE(CURLOPT_TLSAUTH_TYPE); #endif #if HAVE_CURLOPT_TLSAUTH_SRP CURB_DEFINE(CURLOPT_TLSAUTH_SRP); #endif #if HAVE_CURLOPT_TLSAUTH_USERNAME CURB_DEFINE(CURLOPT_TLSAUTH_USERNAME); #endif #if HAVE_CURLOPT_TLSAUTH_PASSWORD CURB_DEFINE(CURLOPT_TLSAUTH_PASSWORD); #endif #if HAVE_CURLOPT_PROXYAUTH CURB_DEFINE(CURLOPT_PROXYAUTH); #endif #if HAVE_CURLOPT_AUTOREFERER CURB_DEFINE(CURLOPT_AUTOREFERER); #endif #if HAVE_CURLOPT_ENCODING CURB_DEFINE(CURLOPT_ENCODING); #endif #if HAVE_CURLOPT_FOLLOWLOCATION CURB_DEFINE(CURLOPT_FOLLOWLOCATION); #endif #if HAVE_CURLOPT_UNRESTRICTED_AUTH CURB_DEFINE(CURLOPT_UNRESTRICTED_AUTH); #endif #if HAVE_CURLOPT_MAXREDIRS CURB_DEFINE(CURLOPT_MAXREDIRS); #endif #if HAVE_CURLOPT_POSTREDIR CURB_DEFINE(CURLOPT_POSTREDIR); #endif #if HAVE_CURLOPT_PUT CURB_DEFINE(CURLOPT_PUT); #endif #if HAVE_CURLOPT_POST CURB_DEFINE(CURLOPT_POST); #endif CURB_DEFINE(CURLOPT_POSTFIELDS); CURB_DEFINE(CURLOPT_POSTFIELDSIZE); #if HAVE_CURLOPT_POSTFIELDSIZE_LARGE CURB_DEFINE(CURLOPT_POSTFIELDSIZE_LARGE); #endif #if HAVE_CURLOPT_COPYPOSTFIELDS CURB_DEFINE(CURLOPT_COPYPOSTFIELDS); #endif #if HAVE_CURLOPT_HTTPPOST CURB_DEFINE(CURLOPT_HTTPPOST); #endif CURB_DEFINE(CURLOPT_REFERER); CURB_DEFINE(CURLOPT_USERAGENT); CURB_DEFINE(CURLOPT_HTTPHEADER); #if HAVE_CURLOPT_HTTP200ALIASES CURB_DEFINE(CURLOPT_HTTP200ALIASES); #endif CURB_DEFINE(CURLOPT_COOKIE); CURB_DEFINE(CURLOPT_COOKIEFILE); CURB_DEFINE(CURLOPT_COOKIEJAR); #if HAVE_CURLOPT_COOKIESESSION CURB_DEFINE(CURLOPT_COOKIESESSION); #endif #if HAVE_CURLOPT_COOKIELIST CURB_DEFINE(CURLOPT_COOKIELIST); #endif #if HAVE_CURLOPT_HTTPGET CURB_DEFINE(CURLOPT_HTTPGET); #endif CURB_DEFINE(CURLOPT_HTTP_VERSION); CURB_DEFINE(CURL_HTTP_VERSION_NONE); CURB_DEFINE(CURL_HTTP_VERSION_1_0); CURB_DEFINE(CURL_HTTP_VERSION_1_1); #if HAVE_CURLOPT_IGNORE_CONTENT_LENGTH CURB_DEFINE(CURLOPT_IGNORE_CONTENT_LENGTH); #endif #if HAVE_CURLOPT_HTTP_CONTENT_DECODING CURB_DEFINE(CURLOPT_HTTP_CONTENT_DECODING); #endif #if HAVE_CURLOPT_HTTP_TRANSFER_DECODING CURB_DEFINE(CURLOPT_HTTP_TRANSFER_DECODING); #endif #if HAVE_CURLOPT_MAIL_FROM CURB_DEFINE(CURLOPT_MAIL_FROM); #endif #if HAVE_CURLOPT_MAIL_RCPT CURB_DEFINE(CURLOPT_MAIL_RCPT); #endif #if HAVE_CURLOPT_TFTP_BLKSIZE CURB_DEFINE(CURLOPT_TFTP_BLKSIZE); #endif #if HAVE_CURLOPT_FTPPORT CURB_DEFINE(CURLOPT_FTPPORT); #endif #if HAVE_CURLOPT_QUOTE CURB_DEFINE(CURLOPT_QUOTE); #endif #if HAVE_CURLOPT_POSTQUOTE CURB_DEFINE(CURLOPT_POSTQUOTE); #endif #if HAVE_CURLOPT_PREQUOTE CURB_DEFINE(CURLOPT_PREQUOTE); #endif #if HAVE_CURLOPT_DIRLISTONLY CURB_DEFINE(CURLOPT_DIRLISTONLY); #endif #if HAVE_CURLOPT_APPEND CURB_DEFINE(CURLOPT_APPEND); #endif #if HAVE_CURLOPT_FTP_USE_EPRT CURB_DEFINE(CURLOPT_FTP_USE_EPRT); #endif #if HAVE_CURLOPT_FTP_USE_EPSV CURB_DEFINE(CURLOPT_FTP_USE_EPSV); #endif #if HAVE_CURLOPT_FTP_USE_PRET CURB_DEFINE(CURLOPT_FTP_USE_PRET); #endif #if HAVE_CURLOPT_FTP_CREATE_MISSING_DIRS CURB_DEFINE(CURLOPT_FTP_CREATE_MISSING_DIRS); #endif #if HAVE_CURLOPT_FTP_RESPONSE_TIMEOUT CURB_DEFINE(CURLOPT_FTP_RESPONSE_TIMEOUT); #endif #if HAVE_CURLOPT_FTP_ALTERNATIVE_TO_USER CURB_DEFINE(CURLOPT_FTP_ALTERNATIVE_TO_USER); #endif #if HAVE_CURLOPT_FTP_SKIP_PASV_IP CURB_DEFINE(CURLOPT_FTP_SKIP_PASV_IP); #endif #if HAVE_CURLOPT_FTPSSLAUTH CURB_DEFINE(CURLOPT_FTPSSLAUTH); #endif #if HAVE_CURLFTPAUTH_DEFAULT CURB_DEFINE(CURLFTPAUTH_DEFAULT); #endif #if HAVE_CURLFTPAUTH_SSL CURB_DEFINE(CURLFTPAUTH_SSL); #endif #if HAVE_CURLFTPAUTH_TLS CURB_DEFINE(CURLFTPAUTH_TLS); #endif #if HAVE_CURLOPT_FTP_SSL_CCC CURB_DEFINE(CURLOPT_FTP_SSL_CCC); #endif #if HAVE_CURLFTPSSL_CCC_NONE CURB_DEFINE(CURLFTPSSL_CCC_NONE); #endif #if HAVE_CURLFTPSSL_CCC_PASSIVE CURB_DEFINE(CURLFTPSSL_CCC_PASSIVE); #endif #if HAVE_CURLFTPSSL_CCC_ACTIVE CURB_DEFINE(CURLFTPSSL_CCC_ACTIVE); #endif #if HAVE_CURLOPT_FTP_ACCOUNT CURB_DEFINE(CURLOPT_FTP_ACCOUNT); #endif #if HAVE_CURLOPT_FTP_FILEMETHOD CURB_DEFINE(CURLOPT_FTP_FILEMETHOD); #endif #if HAVE_CURLFTPMETHOD_MULTICWD CURB_DEFINE(CURLFTPMETHOD_MULTICWD); #endif #if HAVE_CURLFTPMETHOD_NOCWD CURB_DEFINE(CURLFTPMETHOD_NOCWD); #endif #if HAVE_CURLFTPMETHOD_SINGLECWD CURB_DEFINE(CURLFTPMETHOD_SINGLECWD); #endif #if HAVE_CURLOPT_RTSP_REQUEST CURB_DEFINE(CURLOPT_RTSP_REQUEST); #endif #if HAVE_CURL_RTSPREQ_OPTIONS CURB_DEFINE(CURL_RTSPREQ_OPTIONS); #endif #if HAVE_CURL_RTSPREQ_DESCRIBE CURB_DEFINE(CURL_RTSPREQ_DESCRIBE); #endif #if HAVE_CURL_RTSPREQ_ANNOUNCE CURB_DEFINE(CURL_RTSPREQ_ANNOUNCE); #endif #if HAVE_CURL_RTSPREQ_SETUP CURB_DEFINE(CURL_RTSPREQ_SETUP); #endif #if HAVE_CURL_RTSPREQ_PLAY CURB_DEFINE(CURL_RTSPREQ_PLAY); #endif #if HAVE_CURL_RTSPREQ_PAUSE CURB_DEFINE(CURL_RTSPREQ_PAUSE); #endif #if HAVE_CURL_RTSPREQ_TEARDOWN CURB_DEFINE(CURL_RTSPREQ_TEARDOWN); #endif #if HAVE_CURL_RTSPREQ_GET_PARAMETER CURB_DEFINE(CURL_RTSPREQ_GET_PARAMETER); #endif #if HAVE_CURL_RTSPREQ_SET_PARAMETER CURB_DEFINE(CURL_RTSPREQ_SET_PARAMETER); #endif #if HAVE_CURL_RTSPREQ_RECORD CURB_DEFINE(CURL_RTSPREQ_RECORD); #endif #if HAVE_CURL_RTSPREQ_RECEIVE CURB_DEFINE(CURL_RTSPREQ_RECEIVE); #endif #if HAVE_CURLOPT_RTSP_SESSION_ID CURB_DEFINE(CURLOPT_RTSP_SESSION_ID); #endif #if HAVE_CURLOPT_RTSP_STREAM_URI CURB_DEFINE(CURLOPT_RTSP_STREAM_URI); #endif #if HAVE_CURLOPT_RTSP_TRANSPORT CURB_DEFINE(CURLOPT_RTSP_TRANSPORT); #endif #if HAVE_CURLOPT_RTSP_HEADER CURB_DEFINE(CURLOPT_RTSP_HEADER); #endif #if HAVE_CURLOPT_RTSP_CLIENT_CSEQ CURB_DEFINE(CURLOPT_RTSP_CLIENT_CSEQ); #endif #if HAVE_CURLOPT_RTSP_SERVER_CSEQ CURB_DEFINE(CURLOPT_RTSP_SERVER_CSEQ); #endif CURB_DEFINE(CURLOPT_TRANSFERTEXT); #if HAVE_CURLOPT_PROXY_TRANSFER_MODE CURB_DEFINE(CURLOPT_PROXY_TRANSFER_MODE); #endif #if HAVE_CURLOPT_CRLF CURB_DEFINE(CURLOPT_CRLF); #endif #if HAVE_CURLOPT_RANGE CURB_DEFINE(CURLOPT_RANGE); #endif #if HAVE_CURLOPT_RESUME_FROM CURB_DEFINE(CURLOPT_RESUME_FROM); #endif #if HAVE_CURLOPT_RESUME_FROM_LARGE CURB_DEFINE(CURLOPT_RESUME_FROM_LARGE); #endif #if HAVE_CURLOPT_CUSTOMREQUEST CURB_DEFINE(CURLOPT_CUSTOMREQUEST); #endif #if HAVE_CURLOPT_FILETIME CURB_DEFINE(CURLOPT_FILETIME); #endif #if HAVE_CURLOPT_NOBODY CURB_DEFINE(CURLOPT_NOBODY); #endif #if HAVE_CURLOPT_INFILESIZE CURB_DEFINE(CURLOPT_INFILESIZE); #endif #if HAVE_CURLOPT_INFILESIZE_LARGE CURB_DEFINE(CURLOPT_INFILESIZE_LARGE); #endif #if HAVE_CURLOPT_UPLOAD CURB_DEFINE(CURLOPT_UPLOAD); #endif #if HAVE_CURLOPT_MAXFILESIZE CURB_DEFINE(CURLOPT_MAXFILESIZE); #endif #if HAVE_CURLOPT_MAXFILESIZE_LARGE CURB_DEFINE(CURLOPT_MAXFILESIZE_LARGE); #endif #if HAVE_CURLOPT_TIMECONDITION CURB_DEFINE(CURLOPT_TIMECONDITION); #endif #if HAVE_CURLOPT_TIMEVALUE CURB_DEFINE(CURLOPT_TIMEVALUE); #endif #if HAVE_CURLOPT_TIMEOUT CURB_DEFINE(CURLOPT_TIMEOUT); #endif #if HAVE_CURLOPT_TIMEOUT_MS CURB_DEFINE(CURLOPT_TIMEOUT_MS); #endif #if HAVE_CURLOPT_LOW_SPEED_LIMIT CURB_DEFINE(CURLOPT_LOW_SPEED_LIMIT); #endif #if HAVE_CURLOPT_LOW_SPEED_TIME CURB_DEFINE(CURLOPT_LOW_SPEED_TIME); #endif #if HAVE_CURLOPT_MAX_SEND_SPEED_LARGE CURB_DEFINE(CURLOPT_MAX_SEND_SPEED_LARGE); #endif #if HAVE_CURLOPT_MAX_RECV_SPEED_LARGE CURB_DEFINE(CURLOPT_MAX_RECV_SPEED_LARGE); #endif #if HAVE_CURLOPT_MAXCONNECTS CURB_DEFINE(CURLOPT_MAXCONNECTS); #endif #if HAVE_CURLOPT_CLOSEPOLICY CURB_DEFINE(CURLOPT_CLOSEPOLICY); #endif #if HAVE_CURLOPT_FRESH_CONNECT CURB_DEFINE(CURLOPT_FRESH_CONNECT); #endif #if HAVE_CURLOPT_FORBID_REUSE CURB_DEFINE(CURLOPT_FORBID_REUSE); #endif #if HAVE_CURLOPT_CONNECTTIMEOUT CURB_DEFINE(CURLOPT_CONNECTTIMEOUT); #endif #if HAVE_CURLOPT_CONNECTTIMEOUT_MS CURB_DEFINE(CURLOPT_CONNECTTIMEOUT_MS); #endif #if HAVE_CURLOPT_IPRESOLVE CURB_DEFINE(CURLOPT_IPRESOLVE); #endif #if HAVE_CURL_IPRESOLVE_WHATEVER CURB_DEFINE(CURL_IPRESOLVE_WHATEVER); #endif #if HAVE_CURL_IPRESOLVE_V4 CURB_DEFINE(CURL_IPRESOLVE_V4); #endif #if HAVE_CURL_IPRESOLVE_V6 CURB_DEFINE(CURL_IPRESOLVE_V6); #endif #if HAVE_CURLOPT_CONNECT_ONLY CURB_DEFINE(CURLOPT_CONNECT_ONLY); #endif #if HAVE_CURLOPT_USE_SSL CURB_DEFINE(CURLOPT_USE_SSL); #endif #if HAVE_CURLUSESSL_NONE CURB_DEFINE(CURLUSESSL_NONE); #endif #if HAVE_CURLUSESSL_TRY CURB_DEFINE(CURLUSESSL_TRY); #endif #if HAVE_CURLUSESSL_CONTROL CURB_DEFINE(CURLUSESSL_CONTROL); #endif #if HAVE_CURLUSESSL_ALL CURB_DEFINE(CURLUSESSL_ALL); #endif #if HAVE_CURLOPT_RESOLVE CURB_DEFINE(CURLOPT_RESOLVE); #endif #if HAVE_CURLOPT_SSLCERT CURB_DEFINE(CURLOPT_SSLCERT); #endif #if HAVE_CURLOPT_SSLCERTTYPE CURB_DEFINE(CURLOPT_SSLCERTTYPE); #endif #if HAVE_CURLOPT_SSLKEY CURB_DEFINE(CURLOPT_SSLKEY); #endif #if HAVE_CURLOPT_SSLKEYTYPE CURB_DEFINE(CURLOPT_SSLKEYTYPE); #endif #if HAVE_CURLOPT_KEYPASSWD CURB_DEFINE(CURLOPT_KEYPASSWD); #endif #if HAVE_CURLOPT_SSLENGINE CURB_DEFINE(CURLOPT_SSLENGINE); #endif #if HAVE_CURLOPT_SSLENGINE_DEFAULT CURB_DEFINE(CURLOPT_SSLENGINE_DEFAULT); #endif #if HAVE_CURLOPT_SSLVERSION CURB_DEFINE(CURLOPT_SSLVERSION); #endif #if HAVE_CURL_SSLVERSION_DEFAULT CURB_DEFINE(CURL_SSLVERSION_DEFAULT); #endif #if HAVE_CURL_SSLVERSION_TLSv1 CURB_DEFINE(CURL_SSLVERSION_TLSv1); #endif #if HAVE_CURL_SSLVERSION_SSLv2 CURB_DEFINE(CURL_SSLVERSION_SSLv2); #endif #if HAVE_CURL_SSLVERSION_SSLv3 CURB_DEFINE(CURL_SSLVERSION_SSLv3); #endif #if HAVE_CURLOPT_SSL_VERIFYPEER CURB_DEFINE(CURLOPT_SSL_VERIFYPEER); #endif #if HAVE_CURLOPT_CAINFO CURB_DEFINE(CURLOPT_CAINFO); #endif #if HAVE_CURLOPT_ISSUERCERT CURB_DEFINE(CURLOPT_ISSUERCERT); #endif #if HAVE_CURLOPT_CAPATH CURB_DEFINE(CURLOPT_CAPATH); #endif #if HAVE_CURLOPT_CRLFILE CURB_DEFINE(CURLOPT_CRLFILE); #endif #if HAVE_CURLOPT_SSL_VERIFYHOST CURB_DEFINE(CURLOPT_SSL_VERIFYHOST); #endif #if HAVE_CURLOPT_CERTINFO CURB_DEFINE(CURLOPT_CERTINFO); #endif #if HAVE_CURLOPT_RANDOM_FILE CURB_DEFINE(CURLOPT_RANDOM_FILE); #endif #if HAVE_CURLOPT_EGDSOCKET CURB_DEFINE(CURLOPT_EGDSOCKET); #endif #if HAVE_CURLOPT_SSL_CIPHER_LIST CURB_DEFINE(CURLOPT_SSL_CIPHER_LIST); #endif #if HAVE_CURLOPT_SSL_SESSIONID_CACHE CURB_DEFINE(CURLOPT_SSL_SESSIONID_CACHE); #endif #if HAVE_CURLOPT_KRBLEVEL CURB_DEFINE(CURLOPT_KRBLEVEL); #endif #if HAVE_CURLOPT_SSH_AUTH_TYPES CURB_DEFINE(CURLOPT_SSH_AUTH_TYPES); #endif #if HAVE_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 CURB_DEFINE(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5); #endif #if HAVE_CURLOPT_SSH_PUBLIC_KEYFILE CURB_DEFINE(CURLOPT_SSH_PUBLIC_KEYFILE); #endif #if HAVE_CURLOPT_SSH_PRIVATE_KEYFILE CURB_DEFINE(CURLOPT_SSH_PRIVATE_KEYFILE); #endif #if HAVE_CURLOPT_SSH_KNOWNHOSTS CURB_DEFINE(CURLOPT_SSH_KNOWNHOSTS); #endif #if HAVE_CURLOPT_SSH_KEYFUNCTION CURB_DEFINE(CURLOPT_SSH_KEYFUNCTION); #endif #if HAVE_CURLKHSTAT_FINE_ADD_TO_FILE CURB_DEFINE(CURLKHSTAT_FINE_ADD_TO_FILE); #endif #if HAVE_CURLKHSTAT_FINE CURB_DEFINE(CURLKHSTAT_FINE); #endif #if HAVE_CURLKHSTAT_REJECT CURB_DEFINE(CURLKHSTAT_REJECT); #endif #if HAVE_CURLKHSTAT_DEFER CURB_DEFINE(CURLKHSTAT_DEFER); #endif #if HAVE_CURLOPT_SSH_KEYDATA CURB_DEFINE(CURLOPT_SSH_KEYDATA); #endif #if HAVE_CURLOPT_PRIVATE CURB_DEFINE(CURLOPT_PRIVATE); #endif #if HAVE_CURLOPT_SHARE CURB_DEFINE(CURLOPT_SHARE); #endif #if HAVE_CURLOPT_NEW_FILE_PERMS CURB_DEFINE(CURLOPT_NEW_FILE_PERMS); #endif #if HAVE_CURLOPT_NEW_DIRECTORY_PERMS CURB_DEFINE(CURLOPT_NEW_DIRECTORY_PERMS); #endif #if HAVE_CURLOPT_TELNETOPTIONS CURB_DEFINE(CURLOPT_TELNETOPTIONS); #endif rb_define_const(mCurl, "HTTP_1_1", LONG2NUM(CURL_HTTP_VERSION_1_1)); rb_define_const(mCurl, "HTTP_1_0", LONG2NUM(CURL_HTTP_VERSION_1_0)); rb_define_const(mCurl, "HTTP_NONE", LONG2NUM(CURL_HTTP_VERSION_NONE)); rb_define_singleton_method(mCurl, "ipv6?", ruby_curl_ipv6_q, 0); rb_define_singleton_method(mCurl, "kerberos4?", ruby_curl_kerberos4_q, 0); rb_define_singleton_method(mCurl, "ssl?", ruby_curl_ssl_q, 0); rb_define_singleton_method(mCurl, "libz?", ruby_curl_libz_q, 0); rb_define_singleton_method(mCurl, "ntlm?", ruby_curl_ntlm_q, 0); rb_define_singleton_method(mCurl, "gssnegotiate?", ruby_curl_gssnegotiate_q, 0); rb_define_singleton_method(mCurl, "debug?", ruby_curl_debug_q, 0); rb_define_singleton_method(mCurl, "asyncdns?", ruby_curl_asyncdns_q, 0); rb_define_singleton_method(mCurl, "spnego?", ruby_curl_spnego_q, 0); rb_define_singleton_method(mCurl, "largefile?", ruby_curl_largefile_q, 0); rb_define_singleton_method(mCurl, "idn?", ruby_curl_idn_q, 0); rb_define_singleton_method(mCurl, "sspi?", ruby_curl_sspi_q, 0); rb_define_singleton_method(mCurl, "conv?", ruby_curl_conv_q, 0); init_curb_errors(); init_curb_easy(); init_curb_postfield(); init_curb_multi(); }
/* * call-seq: json_create(o) * * Raw Strings are JSON Objects (the raw bytes are stored in an array for the * key "raw"). The Ruby String can be created by this module method. */ static VALUE mString_Extend_json_create(VALUE self, VALUE o) { VALUE ary; Check_Type(o, T_HASH); ary = rb_hash_aref(o, rb_str_new2("raw")); return rb_funcall(ary, i_pack, 1, rb_str_new2("C*")); }
/* * call-seq: to_json(state = nil, depth = 0) * * Returns a JSON string for false: 'false'. */ static VALUE mFalseClass_to_json(int argc, VALUE *argv, VALUE self) { return rb_str_new2("false"); }
static VALUE dummy_dump(VALUE self) { return rb_str_new2(""); }
VALUE __rhoGetCurrentDir(void) { return rb_str_new2(rho_native_rhopath()); }
static VALUE get_value(const char* buffer, int* position, int type) { VALUE value; switch (type) { case -1: { value = rb_class_new_instance(0, NULL, MinKey); break; } case 1: { double d; memcpy(&d, buffer + *position, 8); value = rb_float_new(d); *position += 8; break; } case 2: case 13: { int value_length; value_length = *(int*)(buffer + *position) - 1; *position += 4; value = STR_NEW(buffer + *position, value_length); *position += value_length + 1; break; } case 3: { int size; memcpy(&size, buffer + *position, 4); if (strcmp(buffer + *position + 5, "$ref") == 0) { // DBRef int offset = *position + 10; VALUE argv[2]; int collection_length = *(int*)(buffer + offset) - 1; char id_type; offset += 4; argv[0] = STR_NEW(buffer + offset, collection_length); offset += collection_length + 1; id_type = buffer[offset]; offset += 5; argv[1] = get_value(buffer, &offset, (int)id_type); value = rb_class_new_instance(2, argv, DBRef); } else { value = elements_to_hash(buffer + *position + 4, size - 5); } *position += size; break; } case 4: { int size, end; memcpy(&size, buffer + *position, 4); end = *position + size - 1; *position += 4; value = rb_ary_new(); while (*position < end) { int type = (int)buffer[(*position)++]; int key_size = (int)strlen(buffer + *position); VALUE to_append; *position += key_size + 1; // just skip the key, they're in order. to_append = get_value(buffer, position, type); rb_ary_push(value, to_append); } (*position)++; break; } case 5: { int length, subtype; VALUE data, st; VALUE argv[2]; memcpy(&length, buffer + *position, 4); subtype = (unsigned char)buffer[*position + 4]; if (subtype == 2) { data = rb_str_new(buffer + *position + 9, length - 4); } else { data = rb_str_new(buffer + *position + 5, length); } st = INT2FIX(subtype); argv[0] = data; argv[1] = st; value = rb_class_new_instance(2, argv, Binary); *position += length + 5; break; } case 6: { value = Qnil; break; } case 7: { VALUE str = rb_str_new(buffer + *position, 12); VALUE oid = rb_funcall(str, unpack_method, 1, rb_str_new2("C*")); value = rb_class_new_instance(1, &oid, ObjectId); *position += 12; break; } case 8: { value = buffer[(*position)++] ? Qtrue : Qfalse; break; } case 9: { int64_t millis; memcpy(&millis, buffer + *position, 8); // Support 64-bit time values in 32 bit environments in Ruby > 1.9 // Note: rb_time_num_new is not available pre Ruby 1.9 #if RUBY_API_VERSION_CODE >= 10900 #define add(x,y) (rb_funcall((x), '+', 1, (y))) #define mul(x,y) (rb_funcall((x), '*', 1, (y))) #define quo(x,y) (rb_funcall((x), rb_intern("quo"), 1, (y))) VALUE d, timev; d = LL2NUM(1000LL); timev = add(LL2NUM(millis / 1000), quo(LL2NUM(millis % 1000), d)); value = rb_time_num_new(timev, Qnil); #else value = rb_time_new(millis / 1000, (millis % 1000) * 1000); #endif value = rb_funcall(value, utc_method, 0); *position += 8; break; } case 10: { value = Qnil; break; } case 11: { int pattern_length = (int)strlen(buffer + *position); VALUE pattern = STR_NEW(buffer + *position, pattern_length); int flags_length, flags = 0, i = 0; VALUE argv[3]; *position += pattern_length + 1; flags_length = (int)strlen(buffer + *position); for (i = 0; i < flags_length; i++) { char flag = buffer[*position + i]; if (flag == 'i') { flags |= IGNORECASE; } else if (flag == 'm') { flags |= MULTILINE; } else if (flag == 's') { flags |= MULTILINE; } else if (flag == 'x') { flags |= EXTENDED; } } argv[0] = pattern; argv[1] = INT2FIX(flags); value = rb_class_new_instance(2, argv, Regexp); *position += flags_length + 1; break; } case 12: { int collection_length; VALUE collection, str, oid, id, argv[2]; collection_length = *(int*)(buffer + *position) - 1; *position += 4; collection = STR_NEW(buffer + *position, collection_length); *position += collection_length + 1; str = rb_str_new(buffer + *position, 12); oid = rb_funcall(str, unpack_method, 1, rb_str_new2("C*")); id = rb_class_new_instance(1, &oid, ObjectId); *position += 12; argv[0] = collection; argv[1] = id; value = rb_class_new_instance(2, argv, DBRef); break; } case 14: { int value_length; memcpy(&value_length, buffer + *position, 4); value = ID2SYM(rb_intern(buffer + *position + 4)); *position += value_length + 4; break; } case 15: { int code_length, scope_size; VALUE code, scope, argv[2]; *position += 4; code_length = *(int*)(buffer + *position) - 1; *position += 4; code = STR_NEW(buffer + *position, code_length); *position += code_length + 1; memcpy(&scope_size, buffer + *position, 4); scope = elements_to_hash(buffer + *position + 4, scope_size - 5); *position += scope_size; argv[0] = code; argv[1] = scope; value = rb_class_new_instance(2, argv, Code); break; } case 16: { int i; memcpy(&i, buffer + *position, 4); value = LL2NUM(i); *position += 4; break; } case 17: { unsigned int sec, inc; VALUE argv[2]; memcpy(&inc, buffer + *position, 4); memcpy(&sec, buffer + *position + 4, 4); argv[0] = UINT2NUM(sec); argv[1] = UINT2NUM(inc); value = rb_class_new_instance(2, argv, Timestamp); *position += 8; break; } case 18: { long long ll; memcpy(&ll, buffer + *position, 8); value = LL2NUM(ll); *position += 8; break; } case 127: { value = rb_class_new_instance(0, NULL, MaxKey); break; } default: { rb_raise(rb_eTypeError, "no c decoder for this type yet (%d)", type); break; } } return value; }
void Init_Collection (VALUE mXmms) { #if RDOC_CAN_PARSE_DOCUMENTATION mXmms= rb_define_module("Xmms"); #endif cColl = rb_define_class_under (mXmms, "Collection", rb_cObject); rb_define_alloc_func (cColl, c_alloc); rb_define_singleton_method (cColl, "universe", c_coll_universe, 0); rb_define_singleton_method (cColl, "parse", c_coll_parse, 1); rb_define_method (cColl, "initialize", c_coll_init, 1); /* type methods */ rb_define_method (cColl, "type", c_coll_type_get, 0); /* idlist methods */ rb_define_method (cColl, "idlist", c_coll_idlist_get, 0); rb_define_method (cColl, "idlist=", c_coll_idlist_set, 1); /* operand methods */ rb_define_method (cColl, "operands", c_coll_operands, 0); /* attribute methods */ rb_define_method (cColl, "attributes", c_coll_attributes, 0); rb_define_const (cColl, "NS_ALL", rb_str_new2 (XMMS_COLLECTION_NS_ALL)); rb_define_const (cColl, "NS_COLLECTIONS", rb_str_new2 (XMMS_COLLECTION_NS_COLLECTIONS)); rb_define_const (cColl, "NS_PLAYLISTS", rb_str_new2 (XMMS_COLLECTION_NS_PLAYLISTS)); rb_define_const (cColl, "TYPE_REFERENCE", INT2FIX (XMMS_COLLECTION_TYPE_REFERENCE)); rb_define_const (cColl, "TYPE_UNIVERSE", INT2FIX (XMMS_COLLECTION_TYPE_UNIVERSE)); rb_define_const (cColl, "TYPE_UNION", INT2FIX (XMMS_COLLECTION_TYPE_UNION)); rb_define_const (cColl, "TYPE_INTERSECTION", INT2FIX (XMMS_COLLECTION_TYPE_INTERSECTION)); rb_define_const (cColl, "TYPE_COMPLEMENT", INT2FIX (XMMS_COLLECTION_TYPE_COMPLEMENT)); rb_define_const (cColl, "TYPE_HAS", INT2FIX (XMMS_COLLECTION_TYPE_HAS)); rb_define_const (cColl, "TYPE_MATCH", INT2FIX (XMMS_COLLECTION_TYPE_MATCH)); rb_define_const (cColl, "TYPE_TOKEN", INT2FIX (XMMS_COLLECTION_TYPE_TOKEN)); rb_define_const (cColl, "TYPE_EQUALS", INT2FIX (XMMS_COLLECTION_TYPE_EQUALS)); rb_define_const (cColl, "TYPE_NOTEQUAL", INT2FIX (XMMS_COLLECTION_TYPE_NOTEQUAL)); rb_define_const (cColl, "TYPE_SMALLER", INT2FIX (XMMS_COLLECTION_TYPE_SMALLER)); rb_define_const (cColl, "TYPE_SMALLEREQ", INT2FIX (XMMS_COLLECTION_TYPE_SMALLEREQ)); rb_define_const (cColl, "TYPE_GREATER", INT2FIX (XMMS_COLLECTION_TYPE_GREATER)); rb_define_const (cColl, "TYPE_GREATEREQ", INT2FIX (XMMS_COLLECTION_TYPE_GREATEREQ)); rb_define_const (cColl, "TYPE_ORDER", INT2FIX (XMMS_COLLECTION_TYPE_ORDER)); rb_define_const (cColl, "TYPE_LIMIT", INT2FIX (XMMS_COLLECTION_TYPE_LIMIT)); rb_define_const (cColl, "TYPE_MEDIASET", INT2FIX (XMMS_COLLECTION_TYPE_MEDIASET)); rb_define_const (cColl, "TYPE_IDLIST", INT2FIX (XMMS_COLLECTION_TYPE_IDLIST)); rb_define_const (cColl, "ADD", INT2FIX (XMMS_COLLECTION_CHANGED_ADD)); rb_define_const (cColl, "UPDATE", INT2FIX (XMMS_COLLECTION_CHANGED_UPDATE)); rb_define_const (cColl, "RENAME", INT2FIX (XMMS_COLLECTION_CHANGED_RENAME)); rb_define_const (cColl, "REMOVE", INT2FIX (XMMS_COLLECTION_CHANGED_REMOVE)); ePatternError = rb_define_class_under (cColl, "PatternError", rb_eStandardError); eCollectionError = rb_define_class_under (cColl, "CollectionError", rb_eStandardError); eClientError = rb_define_class_under (cColl, "ClientError", rb_eStandardError); eDisconnectedError = rb_define_class_under (cColl, "DisconnectedError", eClientError); cAttributes = rb_define_class_under (cColl, "Attributes", rb_cObject); rb_define_method (cAttributes, "initialize", c_attrs_init, 1); #ifdef HAVE_RB_PROTECT_INSPECT rb_define_method (cAttributes, "inspect", c_attrs_inspect, 0); #endif /* HAVE_RB_PROTECT_INSPECT */ rb_define_method (cAttributes, "[]", c_attrs_aref, 1); rb_define_method (cAttributes, "[]=", c_attrs_aset, 2); rb_define_method (cAttributes, "has_key?", c_attrs_has_key, 1); rb_define_method (cAttributes, "delete", c_attrs_delete, 1); rb_define_method (cAttributes, "each", c_attrs_each, 0); rb_define_method (cAttributes, "each_key", c_attrs_each_key, 0); rb_define_method (cAttributes, "each_value", c_attrs_each_value, 0); rb_define_alias (cAttributes, "include?", "has_key?"); rb_define_alias (cAttributes, "key?", "has_key?"); rb_define_alias (cAttributes, "member?", "has_key?"); rb_define_alias (cAttributes, "each_pair", "each"); rb_include_module (cAttributes, rb_mEnumerable); cOperands = rb_define_class_under (cColl, "Operands", rb_cObject); rb_define_method (cOperands, "initialize", c_operands_init, 1); rb_define_method (cOperands, "push", c_operands_push, 1); rb_define_method (cOperands, "delete", c_operands_delete, 1); rb_define_method (cOperands, "each", c_operands_each, 0); rb_define_alias (cOperands, "<<", "push"); rb_include_module (cOperands, rb_mEnumerable); }
static void write_doc(bson_buffer_t buffer, VALUE hash, VALUE check_keys, VALUE move_id) { bson_buffer_position start_position = bson_buffer_get_position(buffer); bson_buffer_position length_location = bson_buffer_save_space(buffer, 4); bson_buffer_position length; int allow_id; int (*write_function)(VALUE, VALUE, VALUE) = NULL; VALUE id_str = rb_str_new2("_id"); VALUE id_sym = ID2SYM(rb_intern("_id")); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } // write '_id' first if move_id is true. then don't allow an id to be written. if(move_id == Qtrue) { allow_id = 0; if (rb_funcall(hash, rb_intern("has_key?"), 1, id_str) == Qtrue) { VALUE id = rb_hash_aref(hash, id_str); write_element_with_id(id_str, id, pack_extra(buffer, check_keys)); } else if (rb_funcall(hash, rb_intern("has_key?"), 1, id_sym) == Qtrue) { VALUE id = rb_hash_aref(hash, id_sym); write_element_with_id(id_sym, id, pack_extra(buffer, check_keys)); } } else { allow_id = 1; // Ensure that hash doesn't contain both '_id' and :_id if ((rb_obj_classname(hash), "Hash") == 0) { if ((rb_funcall(hash, rb_intern("has_key?"), 1, id_str) == Qtrue) && (rb_funcall(hash, rb_intern("has_key?"), 1, id_sym) == Qtrue)) { VALUE oid_sym = rb_hash_delete(hash, id_sym); rb_funcall(hash, rb_intern("[]="), 2, id_str, oid_sym); } } } if(allow_id == 1) { write_function = write_element_with_id; } else { write_function = write_element_without_id; } // we have to check for an OrderedHash and handle that specially if (strcmp(rb_obj_classname(hash), "BSON::OrderedHash") == 0) { VALUE keys = rb_funcall(hash, rb_intern("keys"), 0); int i; for(i = 0; i < RARRAY_LEN(keys); i++) { VALUE key = rb_ary_entry(keys, i); VALUE value = rb_hash_aref(hash, key); write_function(key, value, pack_extra(buffer, check_keys)); } } else if (rb_obj_is_kind_of(hash, RB_HASH) == Qtrue) { rb_hash_foreach(hash, write_function, pack_extra(buffer, check_keys)); } else { bson_buffer_free(buffer); rb_raise(InvalidDocument, "BSON.serialize takes a Hash but got a %s", rb_obj_classname(hash)); } // write null byte and fill in length SAFE_WRITE(buffer, &zero, 1); length = bson_buffer_get_position(buffer) - start_position; // make sure that length doesn't exceed 4MB if (length > bson_buffer_get_max_size(buffer)) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Document too large: This BSON document is limited to %d bytes.", bson_buffer_get_max_size(buffer)); return; } SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&length, 4); }
static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) { bson_buffer_t buffer = (bson_buffer_t)NUM2LL(rb_ary_entry(extra, 0)); VALUE check_keys = rb_ary_entry(extra, 1); if (TYPE(key) == T_SYMBOL) { // TODO better way to do this... ? key = rb_str_new2(rb_id2name(SYM2ID(key))); } if (TYPE(key) != T_STRING) { bson_buffer_free(buffer); rb_raise(rb_eTypeError, "keys must be strings or symbols"); } if (allow_id == 0 && strcmp("_id", RSTRING_PTR(key)) == 0) { return ST_CONTINUE; } if (check_keys == Qtrue) { int i; if (RSTRING_LEN(key) > 0 && RSTRING_PTR(key)[0] == '$') { bson_buffer_free(buffer); rb_raise(InvalidKeyName, "key %s must not start with '$'", RSTRING_PTR(key)); } for (i = 0; i < RSTRING_LEN(key); i++) { if (RSTRING_PTR(key)[i] == '.') { bson_buffer_free(buffer); rb_raise(InvalidKeyName, "key %s must not contain '.'", RSTRING_PTR(key)); } } } switch(TYPE(value)) { case T_BIGNUM: { if (rb_funcall(value, gt_operator, 1, LL2NUM(9223372036854775807LL)) == Qtrue || rb_funcall(value, lt_operator, 1, LL2NUM(-9223372036854775808ULL)) == Qtrue) { bson_buffer_free(buffer); rb_raise(rb_eRangeError, "MongoDB can only handle 8-byte ints"); } } // NOTE: falls through to T_FIXNUM code case T_FIXNUM: { long long ll_value; ll_value = NUM2LL(value); if (ll_value > 2147483647LL || ll_value < -2147483648LL) { write_name_and_type(buffer, key, 0x12); SAFE_WRITE(buffer, (char*)&ll_value, 8); } else { int int_value; write_name_and_type(buffer, key, 0x10); int_value = (int)ll_value; SAFE_WRITE(buffer, (char*)&int_value, 4); } break; } case T_TRUE: { write_name_and_type(buffer, key, 0x08); SAFE_WRITE(buffer, &one, 1); break; } case T_FALSE: { write_name_and_type(buffer, key, 0x08); SAFE_WRITE(buffer, &zero, 1); break; } case T_FLOAT: { double d = NUM2DBL(value); write_name_and_type(buffer, key, 0x01); SAFE_WRITE(buffer, (char*)&d, 8); break; } case T_NIL: { write_name_and_type(buffer, key, 0x0A); break; } case T_HASH: { write_name_and_type(buffer, key, 0x03); write_doc(buffer, value, check_keys, Qfalse); break; } case T_ARRAY: { bson_buffer_position length_location, start_position, obj_length; int items, i; VALUE* values; write_name_and_type(buffer, key, 0x04); start_position = bson_buffer_get_position(buffer); // save space for length length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } items = RARRAY_LENINT(value); for(i = 0; i < items; i++) { char* name; VALUE key; INT2STRING(&name, i); key = rb_str_new2(name); write_element_with_id(key, rb_ary_entry(value, i), pack_extra(buffer, check_keys)); FREE_INTSTRING(name); } // write null byte and fill in length SAFE_WRITE(buffer, &zero, 1); obj_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4); break; } case T_STRING: { int length; write_name_and_type(buffer, key, 0x02); length = RSTRING_LENINT(value) + 1; SAFE_WRITE(buffer, (char*)&length, 4); write_utf8(buffer, value, 0); SAFE_WRITE(buffer, &zero, 1); break; } case T_SYMBOL: { const char* str_value = rb_id2name(SYM2ID(value)); int length = (int)strlen(str_value) + 1; write_name_and_type(buffer, key, 0x0E); SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, str_value, length); break; } case T_OBJECT: { // TODO there has to be a better way to do these checks... const char* cls = rb_obj_classname(value); if (strcmp(cls, "BSON::Binary") == 0 || strcmp(cls, "ByteBuffer") == 0) { const char subtype = strcmp(cls, "ByteBuffer") ? (const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2; VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0); int length = RSTRING_LENINT(string_data); write_name_and_type(buffer, key, 0x05); if (subtype == 2) { const int other_length = length + 4; SAFE_WRITE(buffer, (const char*)&other_length, 4); SAFE_WRITE(buffer, &subtype, 1); } SAFE_WRITE(buffer, (const char*)&length, 4); if (subtype != 2) { SAFE_WRITE(buffer, &subtype, 1); } SAFE_WRITE(buffer, RSTRING_PTR(string_data), length); break; } if (strcmp(cls, "BSON::ObjectId") == 0) { VALUE as_array = rb_funcall(value, rb_intern("to_a"), 0); int i; write_name_and_type(buffer, key, 0x07); for (i = 0; i < 12; i++) { char byte = (char)FIX2INT(rb_ary_entry(as_array, i)); SAFE_WRITE(buffer, &byte, 1); } break; } if (strcmp(cls, "BSON::DBRef") == 0) { bson_buffer_position length_location, start_position, obj_length; VALUE ns, oid; write_name_and_type(buffer, key, 0x03); start_position = bson_buffer_get_position(buffer); // save space for length length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } ns = rb_funcall(value, rb_intern("namespace"), 0); write_element_with_id(rb_str_new2("$ref"), ns, pack_extra(buffer, Qfalse)); oid = rb_funcall(value, rb_intern("object_id"), 0); write_element_with_id(rb_str_new2("$id"), oid, pack_extra(buffer, Qfalse)); // write null byte and fill in length SAFE_WRITE(buffer, &zero, 1); obj_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4); break; } if (strcmp(cls, "BSON::Code") == 0) { bson_buffer_position length_location, start_position, total_length; int length; VALUE code_str; write_name_and_type(buffer, key, 0x0F); start_position = bson_buffer_get_position(buffer); length_location = bson_buffer_save_space(buffer, 4); if (length_location == -1) { rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); } code_str = rb_funcall(value, rb_intern("code"), 0); length = RSTRING_LENINT(code_str) + 1; SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, RSTRING_PTR(code_str), length - 1); SAFE_WRITE(buffer, &zero, 1); write_doc(buffer, rb_funcall(value, rb_intern("scope"), 0), Qfalse, Qfalse); total_length = bson_buffer_get_position(buffer) - start_position; SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&total_length, 4); break; } if (strcmp(cls, "BSON::MaxKey") == 0) { write_name_and_type(buffer, key, 0x7f); break; } if (strcmp(cls, "BSON::MinKey") == 0) { write_name_and_type(buffer, key, 0xff); break; } if (strcmp(cls, "BSON::Timestamp") == 0) { unsigned int seconds; unsigned int increment; write_name_and_type(buffer, key, 0x11); seconds = NUM2UINT( rb_funcall(value, rb_intern("seconds"), 0)); increment = NUM2UINT( rb_funcall(value, rb_intern("increment"), 0)); SAFE_WRITE(buffer, (const char*)&increment, 4); SAFE_WRITE(buffer, (const char*)&seconds, 4); break; } if (strcmp(cls, "DateTime") == 0 || strcmp(cls, "Date") == 0 || strcmp(cls, "ActiveSupport::TimeWithZone") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "%s is not currently supported; use a UTC Time instance instead.", cls); break; } if(strcmp(cls, "Complex") == 0 || strcmp(cls, "Rational") == 0 || strcmp(cls, "BigDecimal") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls); break; } if (strcmp(cls, "ActiveSupport::Multibyte::Chars") == 0) { int length; VALUE str = StringValue(value); write_name_and_type(buffer, key, 0x02); length = RSTRING_LENINT(str) + 1; SAFE_WRITE(buffer, (char*)&length, 4); write_utf8(buffer, str, 0); SAFE_WRITE(buffer, &zero, 1); break; } bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls); break; } case T_DATA: { const char* cls = rb_obj_classname(value); if (strcmp(cls, "Time") == 0) { double t = NUM2DBL(rb_funcall(value, rb_intern("to_f"), 0)); long long time_since_epoch = (long long)round(t * 1000); write_name_and_type(buffer, key, 0x09); SAFE_WRITE(buffer, (const char*)&time_since_epoch, 8); break; } // Date classes are TYPE T_DATA in Ruby >= 1.9.3 if (strcmp(cls, "DateTime") == 0 || strcmp(cls, "Date") == 0 || strcmp(cls, "ActiveSupport::TimeWithZone") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "%s is not currently supported; use a UTC Time instance instead.", cls); break; } if(strcmp(cls, "BigDecimal") == 0) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize the Numeric type %s as BSON; only Bignum, Fixnum, and Float are supported.", cls); break; } bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s into BSON.", cls); break; } case T_REGEXP: { VALUE pattern = RREGEXP_SRC(value); long flags = RREGEXP_OPTIONS(value); VALUE has_extra; write_name_and_type(buffer, key, 0x0B); write_utf8(buffer, pattern, 1); SAFE_WRITE(buffer, &zero, 1); if (flags & IGNORECASE) { char ignorecase = 'i'; SAFE_WRITE(buffer, &ignorecase, 1); } if (flags & MULTILINE) { char multiline = 'm'; char dotall = 's'; SAFE_WRITE(buffer, &multiline, 1); SAFE_WRITE(buffer, &dotall, 1); } if (flags & EXTENDED) { char extended = 'x'; SAFE_WRITE(buffer, &extended, 1); } has_extra = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new2("extra_options_str")); if (TYPE(has_extra) == T_TRUE) { VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0); bson_buffer_position old_position = bson_buffer_get_position(buffer); SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LENINT(extra)); qsort(bson_buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char); } SAFE_WRITE(buffer, &zero, 1); break; } default: { const char* cls = rb_obj_classname(value); bson_buffer_free(buffer); rb_raise(InvalidDocument, "Cannot serialize an object of class %s (type %d) into BSON.", cls, TYPE(value)); break; } } return ST_CONTINUE; }
static void* add_cipher_name_to_ary(const OBJ_NAME *name, VALUE ary) { rb_ary_push(ary, rb_str_new2(name->name)); return NULL; }
static VALUE util_spec_rb_sourcefile(VALUE self) { return rb_str_new2(rb_sourcefile()); }
VALUE __rhoGetRuntimeDir(void) { return rb_str_new2(rho_native_reruntimepath()); }
inline static VALUE mArray_json_transfrom(VALUE self, VALUE Vstate, VALUE Vdepth) { long i, len = RARRAY_LEN(self); VALUE shift, result; long depth = NIL_P(Vdepth) ? 0 : FIX2LONG(Vdepth); VALUE delim = rb_str_new2(","); GET_STATE(Vstate); check_max_nesting(state, depth); if (state->check_circular) { VALUE self_id = rb_obj_id(self); rb_hash_aset(state->seen, self_id, Qtrue); result = rb_str_buf_new(len); if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl); shift = rb_str_times(state->indent, LONG2FIX(depth + 1)); rb_str_buf_cat2(result, "["); OBJ_INFECT(result, self); rb_str_buf_append(result, state->array_nl); for (i = 0; i < len; i++) { VALUE element = RARRAY_AT(self, i); if (RTEST(rb_hash_aref(state->seen, rb_obj_id(element)))) { rb_raise(eCircularDatastructure, "circular data structures not supported!"); } OBJ_INFECT(result, element); if (i > 0) rb_str_buf_append(result, delim); rb_str_buf_append(result, shift); element = rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1)); Check_Type(element, T_STRING); rb_str_buf_append(result, element); } if (RSTRING_LEN(state->array_nl)) { rb_str_buf_append(result, state->array_nl); rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth))); } rb_str_buf_cat2(result, "]"); rb_hash_delete(state->seen, self_id); } else { result = rb_str_buf_new(len); OBJ_INFECT(result, self); if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl); shift = rb_str_times(state->indent, LONG2FIX(depth + 1)); rb_str_buf_cat2(result, "["); rb_str_buf_append(result, state->array_nl); for (i = 0; i < len; i++) { VALUE element = RARRAY_AT(self, i); OBJ_INFECT(result, element); if (i > 0) rb_str_buf_append(result, delim); rb_str_buf_append(result, shift); element = rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1)); Check_Type(element, T_STRING); rb_str_buf_append(result, element); } rb_str_buf_append(result, state->array_nl); if (RSTRING_LEN(state->array_nl)) { rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth))); } rb_str_buf_cat2(result, "]"); } return result; }
static VALUE rb_RhoStdoutWrite(VALUE rhoLog, VALUE str) { return rb_RhoLogInfo(rhoLog,rb_str_new2("APP"),str); }
/* * call-seq: to_json(state = nil, depth = 0) * * Returns a JSON string for true: 'true'. */ static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self) { return rb_str_new2("true"); }
VALUE __rhoGetUserDir(void) { return rb_str_new2(rho_native_rhouserpath()); }
/* * call-seq: to_json(state = nil, depth = 0) * */ static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self) { return rb_str_new2("null"); }
VALUE __rhoGetDBDir(void) { return rb_str_new2(rho_native_rhodbpath()); }
static VALUE method_zerror(VALUE self, VALUE errc) { return rb_str_new2(zerror(FIX2INT(errc))); }
VALUE __rhoGetRhodesDir(void) { return rb_str_new2(rho_simconf_getRhodesPath()); }
VALUE rb_curl_easy_error(CURLcode code) { VALUE exclz; const char *exmsg = NULL; VALUE results; switch (code) { case CURLE_OK: /* 0 */ exclz = eCurlErrOK; break; case CURLE_UNSUPPORTED_PROTOCOL: /* 1 */ exclz = eCurlErrUnsupportedProtocol; break; case CURLE_FAILED_INIT: /* 2 */ exclz = eCurlErrFailedInit; break; case CURLE_URL_MALFORMAT: /* 3 */ exclz = eCurlErrMalformedURL; break; #ifdef HAVE_CURLE_NOT_BUILT_IN case CURLE_NOT_BUILT_IN: /* 4 - [was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5] */ exclz = eCurlErrNotBuiltIn; break; #else case CURLE_URL_MALFORMAT_USER: /* 4 (NOT USED) */ exclz = eCurlErrMalformedURLUser; break; #endif case CURLE_COULDNT_RESOLVE_PROXY: /* 5 */ exclz = eCurlErrProxyResolution; break; case CURLE_COULDNT_RESOLVE_HOST: /* 6 */ exclz = eCurlErrHostResolution; break; case CURLE_COULDNT_CONNECT: /* 7 */ exclz = eCurlErrConnectFailed; break; case CURLE_FTP_WEIRD_SERVER_REPLY: /* 8 */ exclz = eCurlErrFTPWeirdReply; break; case CURLE_FTP_ACCESS_DENIED: /* 9 denied due to lack of access. */ exclz = eCurlErrFTPAccessDenied; break; case CURLE_FTP_USER_PASSWORD_INCORRECT: /* 10 */ exclz = eCurlErrFTPBadPassword; break; case CURLE_FTP_WEIRD_PASS_REPLY: /* 11 */ exclz = eCurlErrFTPWeirdPassReply; break; case CURLE_FTP_WEIRD_USER_REPLY: /* 12 */ exclz = eCurlErrFTPWeirdUserReply; break; case CURLE_FTP_WEIRD_PASV_REPLY: /* 13 */ exclz = eCurlErrFTPWeirdPasvReply; break; case CURLE_FTP_WEIRD_227_FORMAT: /* 14 */ exclz = eCurlErrFTPWeird227Format; break; case CURLE_FTP_CANT_GET_HOST: /* 15 */ exclz = eCurlErrFTPCantGetHost; break; case CURLE_FTP_CANT_RECONNECT: /* 16 */ exclz = eCurlErrFTPCantReconnect; break; case CURLE_FTP_COULDNT_SET_BINARY: /* 17 */ exclz = eCurlErrFTPCouldntSetBinary; break; case CURLE_PARTIAL_FILE: /* 18 */ exclz = eCurlErrPartialFile; break; case CURLE_FTP_COULDNT_RETR_FILE: /* 19 */ exclz = eCurlErrFTPCouldntRetrFile; break; case CURLE_FTP_WRITE_ERROR: /* 20 */ exclz = eCurlErrFTPWrite; break; case CURLE_FTP_QUOTE_ERROR: /* 21 */ exclz = eCurlErrFTPQuote; break; case CURLE_HTTP_RETURNED_ERROR: /* 22 */ exclz = eCurlErrHTTPFailed; break; case CURLE_WRITE_ERROR: /* 23 */ exclz = eCurlErrWriteError; break; case CURLE_MALFORMAT_USER: /* 24 - NOT USED */ exclz = eCurlErrMalformedUser; break; case CURLE_FTP_COULDNT_STOR_FILE: /* 25 - failed FTP upload */ exclz = eCurlErrFTPCouldntStorFile; break; case CURLE_READ_ERROR: /* 26 - could open/read from file */ exclz = eCurlErrReadError; break; case CURLE_OUT_OF_MEMORY: /* 27 */ exclz = eCurlErrOutOfMemory; break; case CURLE_OPERATION_TIMEOUTED: /* 28 - the timeout time was reached */ exclz = eCurlErrTimeout; break; case CURLE_FTP_COULDNT_SET_ASCII: /* 29 - TYPE A failed */ exclz = eCurlErrFTPCouldntSetASCII; break; case CURLE_FTP_PORT_FAILED: /* 30 - FTP PORT operation failed */ exclz = eCurlErrFTPPortFailed; break; case CURLE_FTP_COULDNT_USE_REST: /* 31 - the REST command failed */ exclz = eCurlErrFTPCouldntUseRest; break; case CURLE_FTP_COULDNT_GET_SIZE: /* 32 - the SIZE command failed */ exclz = eCurlErrFTPCouldntGetSize; break; case CURLE_HTTP_RANGE_ERROR: /* 33 - RANGE "command" didn't work */ exclz = eCurlErrHTTPRange; break; case CURLE_HTTP_POST_ERROR: /* 34 */ exclz = eCurlErrHTTPPost; break; case CURLE_SSL_CONNECT_ERROR: /* 35 - wrong when connecting with SSL */ exclz = eCurlErrSSLConnectError; break; case CURLE_BAD_DOWNLOAD_RESUME: /* 36 - couldn't resume download */ exclz = eCurlErrBadResume; break; case CURLE_FILE_COULDNT_READ_FILE: /* 37 */ exclz = eCurlErrFileCouldntRead; break; case CURLE_LDAP_CANNOT_BIND: /* 38 */ exclz = eCurlErrLDAPCouldntBind; break; case CURLE_LDAP_SEARCH_FAILED: /* 39 */ exclz = eCurlErrLDAPSearchFailed; break; case CURLE_LIBRARY_NOT_FOUND: /* 40 */ exclz = eCurlErrLibraryNotFound; break; case CURLE_FUNCTION_NOT_FOUND: /* 41 */ exclz = eCurlErrFunctionNotFound; break; case CURLE_ABORTED_BY_CALLBACK: /* 42 */ exclz = eCurlErrAbortedByCallback; break; case CURLE_BAD_FUNCTION_ARGUMENT: /* 43 */ exclz = eCurlErrBadFunctionArgument; break; case CURLE_BAD_CALLING_ORDER: /* 44 - NOT USED */ exclz = eCurlErrBadCallingOrder; break; case CURLE_INTERFACE_FAILED: /* 45 - CURLOPT_INTERFACE failed */ exclz = eCurlErrInterfaceFailed; break; case CURLE_BAD_PASSWORD_ENTERED: /* 46 - NOT USED */ exclz = eCurlErrBadPasswordEntered; break; case CURLE_TOO_MANY_REDIRECTS: /* 47 - catch endless re-direct loops */ exclz = eCurlErrTooManyRedirects; break; case CURLE_UNKNOWN_TELNET_OPTION: /* 48 - User specified an unknown option */ exclz = eCurlErrTelnetUnknownOption; break; case CURLE_TELNET_OPTION_SYNTAX: /* 49 - Malformed telnet option */ exclz = eCurlErrTelnetBadOptionSyntax; break; #ifdef HAVE_CURLE_OBSOLETE case CURLE_OBSOLETE: /* 50 - NOT USED */ exclz = eCurlErrObsolete; break; #endif case CURLE_SSL_PEER_CERTIFICATE: /* 51 - peer's certificate wasn't ok */ exclz = eCurlErrSSLPeerCertificate; break; case CURLE_GOT_NOTHING: /* 52 - when this is a specific error */ exclz = eCurlErrGotNothing; break; case CURLE_SSL_ENGINE_NOTFOUND: /* 53 - SSL crypto engine not found */ exclz = eCurlErrSSLEngineNotFound; break; case CURLE_SSL_ENGINE_SETFAILED: /* 54 - can not set SSL crypto engine as default */ exclz = eCurlErrSSLEngineSetFailed; break; case CURLE_SEND_ERROR: /* 55 - failed sending network data */ exclz = eCurlErrSendError; break; case CURLE_RECV_ERROR: /* 56 - failure in receiving network data */ exclz = eCurlErrRecvError; break; case CURLE_SHARE_IN_USE: /* 57 - share is in use */ exclz = eCurlErrShareInUse; break; case CURLE_SSL_CERTPROBLEM: /* 58 - problem with the local certificate */ exclz = eCurlErrSSLCertificate; break; case CURLE_SSL_CIPHER: /* 59 - couldn't use specified cipher */ exclz = eCurlErrSSLCipher; break; case CURLE_SSL_CACERT: /* 60 - problem with the CA cert (path?) */ exclz = eCurlErrSSLCACertificate; break; case CURLE_BAD_CONTENT_ENCODING: /* 61 - Unrecognized transfer encoding */ exclz = eCurlErrBadContentEncoding; break; case CURLE_LDAP_INVALID_URL: /* 62 - Invalid LDAP URL */ exclz = eCurlErrLDAPInvalidURL; break; case CURLE_FILESIZE_EXCEEDED: /* 63 - Maximum file size exceeded */ exclz = eCurlErrFileSizeExceeded; break; case CURLE_FTP_SSL_FAILED: /* 64 - Requested FTP SSL level failed */ exclz = eCurlErrFTPSSLFailed; break; #ifdef HAVE_CURLE_SEND_FAIL_REWIND case CURLE_SEND_FAIL_REWIND: /* 65 - Sending the data requires a rewind that failed */ exclz = eCurlErrSendFailedRewind; break; #endif #ifdef HAVE_CURLE_SSL_ENGINE_INITFAILED case CURLE_SSL_ENGINE_INITFAILED: /* 66 - failed to initialise ENGINE */ exclz = eCurlErrSSLEngineInitFailed; break; #endif #ifdef HAVE_CURLE_LOGIN_DENIED case CURLE_LOGIN_DENIED: /* 67 - user, password or similar was not accepted and we failed to login */ exclz = eCurlErrLoginDenied; break; #endif // recent additions, may not be present in all supported versions #ifdef HAVE_CURLE_TFTP_NOTFOUND case CURLE_TFTP_NOTFOUND: /* 68 - file not found on server */ exclz = eCurlErrTFTPNotFound; break; #endif #ifdef HAVE_CURLE_TFTP_PERM case CURLE_TFTP_PERM: /* 69 - permission problem on server */ exclz = eCurlErrTFTPPermission; break; #endif #ifdef HAVE_CURLE_TFTP_DISKFULL case CURLE_TFTP_DISKFULL: /* 70 - out of disk space on server */ exclz = eCurlErrTFTPDiskFull; break; #endif #ifdef HAVE_CURLE_TFTP_ILLEGAL case CURLE_TFTP_ILLEGAL: /* 71 - Illegal TFTP operation */ exclz = eCurlErrTFTPIllegalOperation; break; #endif #ifdef HAVE_CURLE_TFTP_UNKNOWNID case CURLE_TFTP_UNKNOWNID: /* 72 - Unknown transfer ID */ exclz = eCurlErrTFTPUnknownID; break; #endif #ifdef HAVE_CURLE_TFTP_EXISTS case CURLE_TFTP_EXISTS: /* 73 - File already exists */ exclz = eCurlErrTFTPFileExists; break; #endif #ifdef HAVE_CURLE_TFTP_NOSUCHUSER case CURLE_TFTP_NOSUCHUSER: /* 74 - No such user */ exclz = eCurlErrTFTPNotFound; break; #endif #ifdef HAVE_CURLE_CONV_FAILED case CURLE_CONV_FAILED: /* 75 - conversion failed */ exclz = eCurlErrConvFailed; break; #endif #ifdef HAVE_CURLE_CONV_REQD case CURLE_CONV_REQD: /* 76 - caller must register conversion callbacks using curl_easy_setopt options CURLOPT_CONV_FROM_NETWORK_FUNCTION, CURLOPT_CONV_TO_NETWORK_FUNCTION, and CURLOPT_CONV_FROM_UTF8_FUNCTION */ exclz = eCurlErrConvReqd; break; #endif #ifdef HAVE_CURLE_SSL_CACERT_BADFILE case CURLE_SSL_CACERT_BADFILE: /* 77 - could not load CACERT file, missing or wrong format */ exclz = eCurlErrSSLCacertBadfile; break; #endif #ifdef HAVE_CURLE_REMOTE_FILE_NOT_FOUND case CURLE_REMOTE_FILE_NOT_FOUND: /* 78 - remote file not found */ exclz = eCurlErrRemoteFileNotFound; break; #endif #ifdef HAVE_CURLE_SSH case CURLE_SSH: /* 79 - error from the SSH layer, somewhat generic so the error message will be of interest when this has happened */ exclz = eCurlErrSSH; break; #endif #ifdef HAVE_CURLE_SSL_SHUTDOWN_FAILED case CURLE_SSL_SHUTDOWN_FAILED: /* 80 - Failed to shut down the SSL connection */ exclz = eCurlErrSSLShutdownFailed; break; #endif #ifdef HAVE_CURLE_AGAIN case CURLE_AGAIN: /* 81 - socket is not ready for send/recv, wait till it's ready and try again (Added in 7.18.2) */ exclz = eCurlErrAgain; break; #endif #ifdef HAVE_CURLE_SSL_CRL_BADFILE case CURLE_SSL_CRL_BADFILE: /* 82 - could not load CRL file, missing or wrong format (Added in 7.19.0) */ exclz = eCurlErrSSLCRLBadfile; break; #endif #ifdef HAVE_CURLE_SSL_ISSUER_ERROR case CURLE_SSL_ISSUER_ERROR: /* 83 - Issuer check failed. (Added in 7.19.0) */ exclz = eCurlErrSSLIssuerError; break; #endif default: exclz = eCurlErrError; exmsg = "Unknown error result from libcurl"; } if (!exmsg) { exmsg = curl_easy_strerror(code); } results = rb_ary_new2(2); rb_ary_push(results, exclz); rb_ary_push(results, rb_str_new2(exmsg)); return results; }
/* * call-seq: * Watchcat.new([options]) => watchcat_obj * Watchcat.new([options]) { |watchcat| block } => watchcat_obj * * Create a new Watchcat object. The parameter hash may have the following * symbols: * +timeout+:: * If watchcatd doesn't receive a heartbeat after this period (in seconds), * it will signal the process. (default: 60) * +signal+:: * Defines which signal will be sent to the process after the timeout * expires. Can be a string like 'HUP' or 'SIGHUP' or an integer like 9. * (default: 9) * +info+:: * Should be a string which is added to the log generated by watchcatd * when it signals a process. (default: nil) * +device+:: * The watchcat device. (default: +/var/run/watchcat.socket+). Use for * debugging purposes. * * If a block is given, the Watchcat object will be yielded and automatically * closed on block termination. */ static VALUE rb_wcat_open(int argc, VALUE *argv, VALUE self) { int sock, timeout, signal; char *signame; const char *info; VALUE opt, vtimeout, vsignal, vinfo, vdevice, vsiglist, mSignal; rb_scan_args(argc, argv, "01", &opt); if (NIL_P(opt)) { sock = cat_open(); if (sock == -1) rb_sys_fail("cat_open"); rb_iv_set(self, "@sock", INT2NUM(sock)); return(self); } /* Defaults. */ timeout = 60; signal = SIGKILL; info = NULL; vtimeout = rb_hash_aref(opt, SYMBOL("timeout")); if (!NIL_P(vtimeout)) { if (FIXNUM_P(vtimeout)) timeout = NUM2INT(vtimeout); else rb_raise(rb_eArgError, "timeout must be an integer"); } vsignal = rb_hash_aref(opt, SYMBOL("signal")); if (!NIL_P(vsignal)) { switch (TYPE(vsignal)) { case T_FIXNUM: signal = NUM2INT(vsignal); break; case T_STRING: signame = StringValuePtr(vsignal); if (strncmp("SIG", signame, 3) == 0) { signame += 3; vsignal = rb_str_new2(signame); } mSignal = rb_const_get(rb_cObject, rb_intern("Signal")); vsiglist = rb_funcall(mSignal, rb_intern("list"), 0); vsignal = rb_hash_aref(vsiglist, vsignal); if (NIL_P(vsignal)) rb_raise(rb_eArgError, "invalid signal name"); else signal = NUM2INT(vsignal); break; default: rb_raise(rb_eArgError, "signal must be an integer or a string"); } } vinfo = rb_hash_aref(opt, SYMBOL("info")); if (!NIL_P(vinfo)) info = StringValuePtr(vinfo); vdevice = rb_hash_aref(opt, SYMBOL("device")); if (!NIL_P(vdevice)) cat_set_device(StringValuePtr(vdevice)); sock = cat_open1(timeout, signal, info); if (sock == -1) rb_sys_fail("cat_open"); rb_iv_set(self, "@sock", INT2NUM(sock)); if (rb_block_given_p()) rb_ensure(rb_yield, self, (void *)cat_close, sock); return(self); }
static int search_required(VALUE fname, volatile VALUE *path, int safe_level) { VALUE tmp; char *ext, *ftptr; int type, ft = 0; const char *loading; *path = 0; ext = strrchr(ftptr = RSTRING_PTR(fname), '.'); if (ext && !strchr(ext, '/')) { if (IS_RBEXT(ext)) { if (rb_feature_p(ftptr, ext, TRUE, FALSE, &loading)) { if (loading) *path = rb_str_new2(loading); return 'r'; } if ((tmp = rb_find_file_safe(fname, safe_level)) != 0) { ext = strrchr(ftptr = RSTRING_PTR(tmp), '.'); if (!rb_feature_p(ftptr, ext, TRUE, TRUE, &loading) || loading) *path = tmp; return 'r'; } return 0; } else if (IS_SOEXT(ext)) { if (rb_feature_p(ftptr, ext, FALSE, FALSE, &loading)) { if (loading) *path = rb_str_new2(loading); return 's'; } tmp = rb_str_new(RSTRING_PTR(fname), ext - RSTRING_PTR(fname)); #ifdef DLEXT2 OBJ_FREEZE(tmp); if (rb_find_file_ext_safe(&tmp, loadable_ext + 1, safe_level)) { ext = strrchr(ftptr = RSTRING_PTR(tmp), '.'); if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading) *path = tmp; return 's'; } #else rb_str_cat2(tmp, DLEXT); OBJ_FREEZE(tmp); if ((tmp = rb_find_file_safe(tmp, safe_level)) != 0) { ext = strrchr(ftptr = RSTRING_PTR(tmp), '.'); if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading) *path = tmp; return 's'; } #endif } else if (IS_DLEXT(ext)) { if (rb_feature_p(ftptr, ext, FALSE, FALSE, &loading)) { if (loading) *path = rb_str_new2(loading); return 's'; } if ((tmp = rb_find_file_safe(fname, safe_level)) != 0) { ext = strrchr(ftptr = RSTRING_PTR(tmp), '.'); if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading) *path = tmp; return 's'; } } } else if ((ft = rb_feature_p(ftptr, 0, FALSE, FALSE, &loading)) == 'r') { if (loading) *path = rb_str_new2(loading); return 'r'; } tmp = fname; type = rb_find_file_ext_safe(&tmp, loadable_ext, safe_level); switch (type) { case 0: if (ft) break; ftptr = RSTRING_PTR(tmp); return rb_feature_p(ftptr, 0, FALSE, TRUE, 0); default: if (ft) break; case 1: ext = strrchr(ftptr = RSTRING_PTR(tmp), '.'); if (rb_feature_p(ftptr, ext, !--type, TRUE, &loading) && !loading) break; *path = tmp; } return type ? 's' : 'r'; }
static VALUE trap(struct trap_arg *arg) { sighandler_t func, oldfunc; VALUE command, oldcmd; int sig = -1; const char *s; func = sighandler; if (NIL_P(arg->cmd)) { func = SIG_IGN; } else { command = rb_check_string_type(arg->cmd); if (!NIL_P(command)) { SafeStringValue(command); /* taint check */ switch (RSTRING_LEN(command)) { case 0: func = SIG_IGN; break; case 7: if (strncmp(RSTRING_PTR(command), "SIG_IGN", 7) == 0) { func = SIG_IGN; } else if (strncmp(RSTRING_PTR(command), "SIG_DFL", 7) == 0) { func = SIG_DFL; } else if (strncmp(RSTRING_PTR(command), "DEFAULT", 7) == 0) { func = SIG_DFL; } break; case 6: if (strncmp(RSTRING_PTR(command), "IGNORE", 6) == 0) { func = SIG_IGN; } break; case 4: if (strncmp(RSTRING_PTR(command), "EXIT", 4) == 0) { arg->cmd = Qundef; } break; } } } if (func == SIG_IGN || func == SIG_DFL) { command = 0; } else { command = arg->cmd; } switch (TYPE(arg->sig)) { case T_FIXNUM: sig = FIX2INT(arg->sig); break; case T_SYMBOL: s = rb_id2name(SYM2ID(arg->sig)); if (!s) rb_raise(rb_eArgError, "bad signal"); goto str_signal; case T_STRING: s = RSTRING_PTR(arg->sig); str_signal: if (strncmp("SIG", s, 3) == 0) s += 3; sig = signm2signo(s); if (sig == 0 && strcmp(s, "EXIT") != 0) rb_raise(rb_eArgError, "unsupported signal SIG%s", s); } if (sig < 0 || sig >= NSIG) { rb_raise(rb_eArgError, "invalid signal number (%d)", sig); } #if defined(HAVE_SETITIMER) if (sig == SIGVTALRM) { rb_raise(rb_eArgError, "SIGVTALRM reserved for Thread; can't set handler"); } #endif if (func == SIG_DFL) { switch (sig) { case SIGINT: #ifdef SIGHUP case SIGHUP: #endif #ifdef SIGQUIT case SIGQUIT: #endif #ifdef SIGALRM case SIGALRM: #endif #ifdef SIGUSR1 case SIGUSR1: #endif #ifdef SIGUSR2 case SIGUSR2: #endif func = sighandler; break; #ifdef SIGBUS case SIGBUS: func = sigbus; break; #endif #ifdef SIGSEGV case SIGSEGV: func = sigsegv; break; #endif #ifdef SIGPIPE case SIGPIPE: func = sigpipe; break; #endif } } oldfunc = ruby_signal(sig, func); oldcmd = trap_list[sig].cmd; if (!oldcmd) { if (oldfunc == SIG_IGN) oldcmd = rb_str_new2("IGNORE"); else if (oldfunc == sighandler) oldcmd = rb_str_new2("DEFAULT"); else oldcmd = Qnil; } trap_list[sig].cmd = command; trap_list[sig].safe = rb_safe_level(); /* enable at least specified signal. */ #ifndef _WIN32 #ifdef HAVE_SIGPROCMASK sigdelset(&arg->mask, sig); #else arg->mask &= ~sigmask(sig); #endif #endif return oldcmd; }
static void process_sflag(int *sflag) { if (*sflag > 0) { long n; VALUE *args; VALUE argv = rb_argv; n = RARRAY_LEN(argv); args = RARRAY_PTR(argv); while (n > 0) { VALUE v = *args++; char *s = StringValuePtr(v); char *p; int hyphen = FALSE; if (s[0] != '-') break; n--; if (s[1] == '-' && s[2] == '\0') break; v = Qtrue; /* check if valid name before replacing - with _ */ for (p = s + 1; *p; p++) { if (*p == '=') { *p++ = '\0'; v = rb_str_new2(p); break; } if (*p == '-') { hyphen = TRUE; } else if (*p != '_' && !ISALNUM(*p)) { VALUE name_error[2]; name_error[0] = rb_str_new2("invalid name for global variable - "); if (!(p = strchr(p, '='))) { rb_str_cat2(name_error[0], s); } else { rb_str_cat(name_error[0], s, p - s); } name_error[1] = args[-1]; rb_exc_raise(rb_class_new_instance(2, name_error, rb_eNameError)); } } s[0] = '$'; if (hyphen) { for (p = s + 1; *p; ++p) { if (*p == '-') *p = '_'; } } rb_gv_set(s, v); } n = RARRAY_LEN(argv) - n; while (n--) { rb_ary_shift(argv); } *sflag = -1; } }
static void write_io(VALUE io) { rb_funcall(io, rb_intern("write"), 1, rb_str_new2("e")); }