static void event_callback (struct em_event* e) { const unsigned long a1 = e->a1; int a2 = e->a2; const char *a3 = e->a3; const unsigned long a4 = e->a4; if (a2 == EM_CONNECTION_READ) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "received %d bytes of data for unknown signature: %lu", a4, a1); rb_funcall (q, Intern_receive_data, 1, rb_str_new (a3, a4)); } else if (a2 == EM_CONNECTION_NOTIFY_READABLE) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "unknown connection: %lu", a1); rb_funcall (q, Intern_notify_readable, 0); } else if (a2 == EM_CONNECTION_NOTIFY_WRITABLE) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "unknown connection: %lu", a1); rb_funcall (q, Intern_notify_writable, 0); } else if (a2 == EM_LOOPBREAK_SIGNAL) { rb_funcall (EmModule, Intern_run_deferred_callbacks, 0); } else if (a2 == EM_TIMER_FIRED) { VALUE t = rb_ivar_get (EmModule, Intern_at_timers); VALUE q = rb_funcall (t, Intern_delete, 1, ULONG2NUM (a4)); if (q == Qnil) { rb_raise (EM_eUnknownTimerFired, "no such timer: %lu", a4); } else if (q == Qfalse) { /* Timer Canceled */ } else { rb_funcall (q, Intern_call, 0); } } #ifdef WITH_SSL else if (a2 == EM_SSL_HANDSHAKE_COMPLETED) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "unknown connection: %lu", a1); rb_funcall (q, Intern_ssl_handshake_completed, 0); } else if (a2 == EM_SSL_VERIFY) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "unknown connection: %lu", a1); VALUE r = rb_funcall (q, Intern_ssl_verify_peer, 1, rb_str_new(a3, a4)); if (RTEST(r)) evma_accept_ssl_peer (a1); } #endif else if (a2 == EM_PROXY_TARGET_UNBOUND) { VALUE t = rb_ivar_get (EmModule, Intern_at_conns); VALUE q = rb_hash_aref (t, ULONG2NUM (a1)); if (q == Qnil) rb_raise (EM_eConnectionNotBound, "unknown connection: %lu", a1); rb_funcall (q, Intern_proxy_target_unbound, 0); } else rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(a1), INT2FIX(a2), a3 ? rb_str_new(a3,a4) : ULONG2NUM(a4)); }
void make_graphcommand(char *command, VALUE hash) { VALUE val; if (TYPE(hash) == T_STRING) { sprintf(command, "graph -T X -g 3 %s", STR2CSTR(hash)); return; } strcpy(command, "graph"); if (TYPE(hash) != T_HASH) rb_raise(rb_eTypeError, "wrong argument type %s (Hash expected)", rb_class2name(CLASS_OF(hash))); if ((val = rb_hash_aref(hash, rb_str_new2("T"))) != Qnil) sprintf(command, "%s -T %s", command, STR2CSTR(val)); else sprintf(command, "%s -T X", command); val = rb_hash_aref(hash, rb_str_new2("C")); if (val == Qtrue) sprintf(command, "%s -C", command); if ((val = rb_hash_aref(hash, rb_str_new2("g"))) != Qnil) sprintf(command, "%s -g %d", command, (int) FIX2INT(val)); else sprintf(command, "%s -g 3", command); if ((val = rb_hash_aref(hash, rb_str_new2("B"))) == Qtrue) sprintf(command, "%s -B", command); if ((val = rb_hash_aref(hash, rb_str_new2("E"))) != Qnil) sprintf(command, "%s -E %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("f"))) != Qnil) sprintf(command, "%s -f %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("F"))) != Qnil) sprintf(command, "%s -F %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("h"))) != Qnil) sprintf(command, "%s -h %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("k"))) != Qnil) sprintf(command, "%s -k %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("K"))) != Qnil) sprintf(command, "%s -K %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("l"))) != Qnil) { if (str_tail_grep(STR2CSTR(val), "xy") || str_tail_grep(STR2CSTR(val), "x/y")) sprintf(command, "%s -l x -l y", command); else sprintf(command, "%s -l %s", command, STR2CSTR(val)); } if ((val = rb_hash_aref(hash, rb_str_new2("L"))) != Qnil) sprintf(command, "%s -L \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("N"))) != Qnil) sprintf(command, "%s -N %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("r"))) != Qnil) sprintf(command, "%s -r %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("R"))) != Qnil) sprintf(command, "%s -R %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("s"))) == Qtrue) sprintf(command, "%s -s", command); if ((val = rb_hash_aref(hash, rb_str_new2("t"))) == Qtrue) sprintf(command, "%s -t", command); if ((val = rb_hash_aref(hash, rb_str_new2("u"))) != Qnil) sprintf(command, "%s -u %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("w"))) != Qnil) sprintf(command, "%s -w %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("x"))) != Qnil) sprintf(command, "%s -x %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("X"))) != Qnil) sprintf(command, "%s -X \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("y"))) != Qnil) sprintf(command, "%s -y %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("Y"))) != Qnil) sprintf(command, "%s -Y \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("bg-color"))) != Qnil) sprintf(command, "%s --bg-color %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("bitmap-size"))) != Qnil) sprintf(command, "%s --bitmap-size %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("frame-color"))) != Qnil) sprintf(command, "%s --frame-color %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("frame-line-width"))) != Qnil) sprintf(command, "%s --frame-line-width %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("max-line-length"))) != Qnil) sprintf(command, "%s --max-line-length %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("page-size"))) != Qnil) sprintf(command, "%s --page-size %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("pen-colors"))) != Qnil) sprintf(command, "%s --pen-colors %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("rotation"))) != Qnil) sprintf(command, "%s --rotation %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("title-font-name"))) != Qnil) sprintf(command, "%s --title-font-name %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("title-font-size"))) != Qnil) sprintf(command, "%s --title-font-size %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("toggle-rotate-y-label"))) == Qtrue) sprintf(command, "%s --toggle-rotate-y-label", command); if ((val = rb_hash_aref(hash, rb_str_new2("m"))) != Qnil) sprintf(command, "%s -m %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("S"))) != Qnil) sprintf(command, "%s -S %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("W"))) != Qnil) sprintf(command, "%s -W %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("q"))) != Qnil) sprintf(command, "%s -q %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("symbol-font-name"))) != Qnil) sprintf(command, "%s --symbol-font-name %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("reposition"))) != Qnil) sprintf(command, "%s --reposition %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("blankout"))) != Qnil) sprintf(command, "%s --blankout %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("O"))) == Qtrue) sprintf(command, "%s -O", command); }
static VALUE param_hash_aref(VALUE self, VALUE key) { if (TYPE(key) == T_SYMBOL) { key = rb_sym_to_s(key); } return rb_hash_aref(self, key); }
/** * call-seq: * Amalgalite::Requires::Bootstrap.lift( 'dbfile' => "lib.db", 'table_name' => "bootload", 'rowid_column' => "id", 'filename_column' => "filename", 'content_column' => "contents" ) * * *WARNING* *WARNING* *WARNING* *WARNING* *WARNING* *WARNING* *WARNING* * * This is a boostrap mechanism to eval all the code in a particular column in a * specially formatted table in an sqlite database. It should only be used for * a specific purpose, mainly loading the Amalgalite ruby code directly from an * sqlite table. * * Amalgalite::Requires adds in the ability to _require_ code that is in an * sqlite database. Since Amalgalite::Requires is itself ruby code, if * Amalgalite::Requires was in an sqlite database, it could not _require_ * itself. Therefore this method is made available. It is a pure C extension * method that directly calls the sqlite3 C functions directly and uses the ruby * C api to eval the data in the table. * * This method attaches to an sqlite3 database (filename) and then does: * * SELECT filename_column_name, content_column_name * FROM table_name * ORDER BY rowid_column_name * * For each row returned it does an _eval_ on the code in the * *content_column_name* and then updates _$LOADED_FEATURES_ directly with the value from * *filename_column_name*. * * The database to be opened by _lift_ *must* be an sqlite3 UTF-8 database. * */ VALUE am_bootstrap_lift( VALUE self, VALUE args ) { sqlite3* db = NULL; sqlite3_stmt* stmt = NULL; int rc; int last_row_good; char raise_msg[BUFSIZ]; VALUE am_db_c = rb_const_get( cARB, rb_intern("DEFAULT_DB") ); VALUE am_tbl_c = rb_const_get( cARB, rb_intern("DEFAULT_BOOTSTRAP_TABLE") ); VALUE am_pk_c = rb_const_get( cARB, rb_intern("DEFAULT_ROWID_COLUMN") ); VALUE am_fname_c = rb_const_get( cARB, rb_intern("DEFAULT_FILENAME_COLUMN") ); VALUE am_content_c = rb_const_get( cARB, rb_intern("DEFAULT_CONTENTS_COLUMN") ); char* dbfile = NULL; char* tbl_name = NULL; char* pk_col = NULL; char* fname_col = NULL; char* content_col = NULL; char sql[BUFSIZ]; const char* sql_tail = NULL; int sql_bytes = 0; const unsigned char* result_text = NULL; int result_length = 0; VALUE require_name = Qnil; /* ruby string of the file name for use in eval */ VALUE eval_this_code = Qnil; /* ruby string of the code to eval from the db */ VALUE toplevel_binding = rb_const_get( rb_cObject, rb_intern("TOPLEVEL_BINDING") ) ; VALUE tmp = Qnil; ID eval_id = rb_intern("eval"); if ( Qnil == args ) { args = rb_hash_new(); } else { args = rb_ary_shift( args ); } Check_Type( args, T_HASH ); /* get the arguments */ dbfile = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "dbfile" ) ) ) ) ? StringValuePtr( am_db_c ) : StringValuePtr( tmp ); tbl_name = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "table_name" ) ) ) ) ? StringValuePtr( am_tbl_c ) : StringValuePtr( tmp ); pk_col = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "rowid_column" ) ) ) ) ? StringValuePtr( am_pk_c ) : StringValuePtr( tmp ); fname_col = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "filename_column" ) ) ) ) ? StringValuePtr( am_fname_c ) : StringValuePtr( tmp ); content_col = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "contents_column" ) ) ) ) ? StringValuePtr( am_content_c ) : StringValuePtr( tmp ); /* open the database */ rc = sqlite3_open_v2( dbfile , &db, SQLITE_OPEN_READONLY, NULL); if ( SQLITE_OK != rc ) { memset( raise_msg, 0, BUFSIZ ); snprintf(raise_msg, BUFSIZ, "Failure to open database %s for bootload: [SQLITE_ERROR %d] : %s", dbfile, rc, sqlite3_errmsg( db ) ); am_bootstrap_cleanup_and_raise( raise_msg, db, stmt ); } /* prepare the db query */ memset( sql, 0, BUFSIZ ); sql_bytes = snprintf( sql, BUFSIZ, "SELECT %s, %s FROM %s ORDER BY %s", fname_col, content_col, tbl_name, pk_col ); rc = sqlite3_prepare_v2( db, sql, sql_bytes, &stmt, &sql_tail ) ; if ( SQLITE_OK != rc) { memset( raise_msg, 0, BUFSIZ ); snprintf( raise_msg, BUFSIZ, "Failure to prepare bootload select statement table = '%s', rowid col = '%s', filename col ='%s', contents col = '%s' : [SQLITE_ERROR %d] %s\n", tbl_name, pk_col, fname_col, content_col, rc, sqlite3_errmsg( db )); am_bootstrap_cleanup_and_raise( raise_msg, db, stmt ); } /* loop over the resulting rows, eval'ing and loading $LOADED_FEATURES */ last_row_good = -1; while ( SQLITE_ROW == ( rc = sqlite3_step( stmt ) ) ) { /* file name */ result_text = sqlite3_column_text( stmt, 0 ); result_length = sqlite3_column_bytes( stmt, 0 ); require_name = rb_str_new( (const char*)result_text, result_length ); /* ruby code */ result_text = sqlite3_column_text( stmt, 1 ); result_length = sqlite3_column_bytes( stmt, 1 ); eval_this_code = rb_str_new( (const char*)result_text, result_length ); /* Kernel.eval( code, TOPLEVEL_BINDING, filename, 1 ) */ rb_funcall(rb_mKernel, eval_id, 4, eval_this_code, toplevel_binding, require_name, INT2FIX(1) ); /* TODO: for ruby 1.9 -- put in ? sqlite3://path/to/database?tablename=tbl_name#require_name */ /* update $LOADED_FEATURES */ rb_ary_push( rb_gv_get( "$LOADED_FEATURES" ), require_name ); } /* if there was some sqlite error in the processing of the rows */ if ( SQLITE_DONE != rc ) { memset( raise_msg, 0, BUFSIZ ); snprintf( raise_msg, BUFSIZ, "Failure in bootloading, last successfully loaded rowid was %d : [SQLITE_ERROR %d] %s\n", last_row_good, rc, sqlite3_errmsg( db ) ); am_bootstrap_cleanup_and_raise( raise_msg, db, stmt ); } /* finalize the statement */ rc = sqlite3_finalize( stmt ); if ( SQLITE_OK != rc ) { memset( raise_msg, 0, BUFSIZ ); snprintf( raise_msg, BUFSIZ, "Failure to finalize bootload statement : [SQLITE_ERROR %d] %s\n", rc, sqlite3_errmsg( db ) ); am_bootstrap_cleanup_and_raise( raise_msg, db, stmt ); } stmt = NULL; /* close the database */ rc = sqlite3_close( db ); if ( SQLITE_OK != rc ) { memset( raise_msg, 0, BUFSIZ ); snprintf( raise_msg, BUFSIZ, "Failure to close database : [SQLITE_ERROR %d] : %s\n", rc, sqlite3_errmsg( db )), am_bootstrap_cleanup_and_raise( raise_msg, db,stmt ); } return Qnil; }
void do_postgres_full_connect(VALUE self, PGconn *db) { VALUE r_host; char *host = NULL; if ((r_host = rb_iv_get(self, "@host")) != Qnil) { host = StringValuePtr(r_host); } VALUE r_user; char *user = NULL; if ((r_user = rb_iv_get(self, "@user")) != Qnil) { user = StringValuePtr(r_user); } VALUE r_password; char *password = NULL; if ((r_password = rb_iv_get(self, "@password")) != Qnil) { password = StringValuePtr(r_password); } VALUE r_port; const char *port = "5432"; if ((r_port = rb_iv_get(self, "@port")) != Qnil) { port = StringValuePtr(r_port); } VALUE r_path; char *path = NULL; char *database = NULL; if ((r_path = rb_iv_get(self, "@path")) != Qnil) { path = StringValuePtr(r_path); database = strtok(path, "/"); } if (!database || !*database) { database = NULL; } VALUE r_query = rb_iv_get(self, "@query"); const char *search_path = data_objects_get_uri_option(r_query, "search_path"); db = PQsetdbLogin( host, port, NULL, NULL, database, user, password ); if (PQstatus(db) == CONNECTION_BAD) { rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db)); } PGresult *result; if (search_path) { char *search_path_query; if (!(search_path_query = calloc(256, sizeof(char)))) { rb_memerror(); } snprintf(search_path_query, 256, "set search_path to %s;", search_path); r_query = rb_str_new2(search_path_query); result = do_postgres_cCommand_execute(Qnil, self, db, r_query); if (PQresultStatus(result) != PGRES_COMMAND_OK) { free(search_path_query); do_postgres_raise_error(self, result, r_query); } free(search_path_query); } const char *backslash_off = "SET backslash_quote = off"; const char *standard_strings_on = "SET standard_conforming_strings = on"; const char *warning_messages = "SET client_min_messages = warning"; const char *date_format = "SET datestyle = ISO"; VALUE r_options; r_options = rb_str_new2(backslash_off); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(standard_strings_on); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(warning_messages); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(date_format); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } VALUE encoding = rb_iv_get(self, "@encoding"); #ifdef HAVE_PQSETCLIENTENCODING VALUE pg_encoding = rb_hash_aref(data_objects_const_get(mDO_PostgresEncoding, "MAP"), encoding); if (pg_encoding != Qnil) { if (PQsetClientEncoding(db, rb_str_ptr_readonly(pg_encoding))) { rb_raise(eDO_ConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding)); } else { #ifdef HAVE_RUBY_ENCODING_H rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding)))); #endif rb_iv_set(self, "@pg_encoding", pg_encoding); } } else { rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL\n", rb_str_ptr_readonly(encoding)); rb_iv_set(self, "@encoding", rb_str_new2("UTF-8")); #ifdef HAVE_RUBY_ENCODING_H rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8"))); #endif rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8")); } #endif rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db)); }
VALUE rho_ruby_hash_aref(VALUE hash, const char* key) { return rb_hash_aref( hash, rb_str_new2(key)); }
/* * call-seq: configure(opts) * * Configure this State instance with the Hash _opts_, and return * itself. */ static VALUE cState_configure(VALUE self, VALUE opts) { VALUE tmp; GET_STATE(self); tmp = rb_check_convert_type(opts, T_HASH, "Hash", "to_hash"); if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h"); opts = tmp; tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->indent = fstrndup(RSTRING_PTR(tmp), len + 1); state->indent_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->space = fstrndup(RSTRING_PTR(tmp), len + 1); state->space_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->space_before = fstrndup(RSTRING_PTR(tmp), len + 1); state->space_before_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->array_nl = fstrndup(RSTRING_PTR(tmp), len + 1); state->array_nl_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->object_nl = fstrndup(RSTRING_PTR(tmp), len + 1); state->object_nl_len = len; } tmp = ID2SYM(i_max_nesting); state->max_nesting = 100; if (option_given_p(opts, tmp)) { 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 = ID2SYM(i_depth); state->depth = 0; if (option_given_p(opts, tmp)) { VALUE depth = rb_hash_aref(opts, tmp); if (RTEST(depth)) { Check_Type(depth, T_FIXNUM); state->depth = FIX2LONG(depth); } else { state->depth = 0; } } tmp = ID2SYM(i_buffer_initial_length); if (option_given_p(opts, tmp)) { VALUE buffer_initial_length = rb_hash_aref(opts, tmp); if (RTEST(buffer_initial_length)) { long initial_length; Check_Type(buffer_initial_length, T_FIXNUM); initial_length = FIX2LONG(buffer_initial_length); if (initial_length > 0) state->buffer_initial_length = initial_length; } } tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan)); state->allow_nan = RTEST(tmp); tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only)); state->ascii_only = RTEST(tmp); tmp = rb_hash_aref(opts, ID2SYM(i_quirks_mode)); state->quirks_mode = RTEST(tmp); return self; }
/* call-seq: draw(hash = nil) { ... } Three keys are checked in the given hash : ":buffer" which is the buffer on which manipulation are done (by default, the actual buffer is taken), ":painter", which tell us to yield a +Joyau::Painter+ instead of a +Joyau::Buffer+ when true (false by default), and ":auto_update" which tell us whether we should update the buffer (true by default). It is mandatory to give a block to this function. Examples: Joyau.draw(:buffer => a_buffer, :painter => true) Joyau.draw(:auto_update => false) Joyau.draw(:painter => true) Joyau.draw(:buffer => a_buffer) */ VALUE Joyau_draw(int argc, VALUE *argv, VALUE self) { static bool can_draw = false; VALUE hash, block; rb_scan_args(argc, argv, "01&", &hash, &block); OSL_IMAGE *oldBuffer = oslGetDrawBuffer(); Buffer *buffer = NULL; VALUE rbPainter = Qnil; bool painter = false; bool auto_update = true; bool ruby_buf = false; bool could_draw = can_draw; if (!NIL_P(hash)) { if (TYPE(hash) != T_HASH) rb_raise(rb_eTypeError, "Hash expected for Joyau::draw."); VALUE rbBuffer = rb_hash_aref(hash, ID2SYM(rb_intern("buffer"))); if (rb_obj_is_kind_of(rbBuffer, getClass("Buffer")) == Qfalse) { if (rbBuffer != Qnil) rb_raise(rb_eTypeError, ":buffer should be a Buffer (or nil)."); } else { buffer = getPtr<Buffer>(rbBuffer); ruby_buf = true; } if (!buffer) buffer = new Buffer(oldBuffer); if (rb_hash_aref(hash, ID2SYM(rb_intern("painter"))) == Qtrue) { painter = true; Painter painter(buffer); rbPainter = createObject(getClass("Painter"), painter); } if (rb_hash_aref(hash, ID2SYM(rb_intern("auto_update"))) == Qfalse) auto_update = false; } else { if (!buffer) buffer = new Buffer(oldBuffer); } if (buffer->isScreen() && !can_draw) { can_draw = true; Graphics_startDraw(Qnil); } if (!NIL_P(block)) { buffer->setActual(); if (painter) rb_yield(rbPainter); else { VALUE rbBuffer = createObject(getClass("Buffer"), *buffer, true); rb_yield(rbBuffer); } if (buffer->isScreen() && !could_draw) { can_draw = false; Graphics_endDraw(Qnil); } if (auto_update && buffer->isScreen()) Graphics_sync(Qnil); } else rb_raise(rb_eArgError, "Block expected."); if (!ruby_buf) // We do not delete the buffer if it comes from Ruby. delete buffer; oslSetDrawBuffer(oldBuffer); return Qnil; }
/* * call-seq: * commit.amend(data = {}) -> oid * * Amend a commit object, with the given +data+ * arguments, passed as a +Hash+: * * - +:message+: a string with the full text for the commit's message * - +:committer+ (optional): a hash with the signature for the committer, * defaults to the signature from the configuration * - +:author+ (optional): a hash with the signature for the author, * defaults to the signature from the configuration * - +:tree+: the tree for this amended commit, represented as a <tt>Rugged::Tree</tt> * instance or an OID +String+. * - +:update_ref+ (optional): a +String+ with the name of a reference in the * repository which should be updated to point to this amended commit (e.g. "HEAD") * * When the amended commit is successfully written to disk, its +oid+ will be * returned as a hex +String+. * * author = {:email=>"*****@*****.**", :time=>Time.now, :name=>"Vicent Mart\303\255"} * * commit.amend( * :author => author, * :message => "Updated Hello world\n\n", * :committer => author, * :tree => some_tree) #=> "f148106ca58764adc93ad4e2d6b1d168422b9796" */ static VALUE rb_git_commit_amend(VALUE self, VALUE rb_data) { VALUE rb_message, rb_tree, rb_ref, owner; int error = 0; git_commit *commit_to_amend; char *message = NULL; git_tree *tree = NULL; git_signature *author = NULL, *committer = NULL; git_oid commit_oid; git_repository *repo; const char *update_ref = NULL; Check_Type(rb_data, T_HASH); Data_Get_Struct(self, git_commit, commit_to_amend); owner = rugged_owner(self); Data_Get_Struct(owner, git_repository, repo); rb_ref = rb_hash_aref(rb_data, CSTR2SYM("update_ref")); if (!NIL_P(rb_ref)) { Check_Type(rb_ref, T_STRING); update_ref = StringValueCStr(rb_ref); } rb_message = rb_hash_aref(rb_data, CSTR2SYM("message")); if (!NIL_P(rb_message)) { Check_Type(rb_message, T_STRING); message = StringValueCStr(rb_message); } rb_tree = rb_hash_aref(rb_data, CSTR2SYM("tree")); if (!NIL_P(rb_tree)) tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE); if (!NIL_P(rb_hash_aref(rb_data, CSTR2SYM("committer")))) { committer = rugged_signature_get( rb_hash_aref(rb_data, CSTR2SYM("committer")), repo ); } if (!NIL_P(rb_hash_aref(rb_data, CSTR2SYM("author")))) { author = rugged_signature_get( rb_hash_aref(rb_data, CSTR2SYM("author")), repo ); } error = git_commit_amend( &commit_oid, commit_to_amend, update_ref, author, committer, NULL, message, tree); git_signature_free(author); git_signature_free(committer); git_object_free((git_object *)tree); rugged_exception_check(error); return rugged_create_oid(&commit_oid); }
/* An rb_rescue()-compatible Ruby pseudo-method that handles the actual parsing */ VALUE rcsv_raw_parse(VALUE ensure_container) { /* Unpacking multiple variables from a single Ruby VALUE */ VALUE options = rb_ary_entry(ensure_container, 0); VALUE csvio = rb_ary_entry(ensure_container, 1); struct rcsv_metadata * meta = (struct rcsv_metadata *)NUM2LONG(rb_ary_entry(ensure_container, 2)); struct csv_parser * cp = (struct csv_parser *)NUM2LONG(rb_ary_entry(ensure_container, 3)); /* Helper temporary variables */ VALUE option, csvstr, buffer_size; /* libcsv-related temporary variables */ char * csv_string; size_t csv_string_len; int error; /* Generic iterator */ size_t i = 0; /* IO buffer size can be controller via an option */ buffer_size = rb_hash_aref(options, ID2SYM(rb_intern("buffer_size"))); /* By default, parse as Array of Arrays */ option = rb_hash_aref(options, ID2SYM(rb_intern("row_as_hash"))); if (option && (option != Qnil)) { meta->row_as_hash = true; } /* :col_sep sets the column separator, default is comma (,) */ option = rb_hash_aref(options, ID2SYM(rb_intern("col_sep"))); if (option != Qnil) { csv_set_delim(cp, (unsigned char)*StringValuePtr(option)); } /* :quote_char sets the character used for quoting data; default is double-quote (") */ option = rb_hash_aref(options, ID2SYM(rb_intern("quote_char"))); if (option != Qnil) { csv_set_quote(cp, (unsigned char)*StringValuePtr(option)); } /* Specify how many rows to skip from the beginning of CSV */ option = rb_hash_aref(options, ID2SYM(rb_intern("offset_rows"))); if (option != Qnil) { meta->offset_rows = (size_t)NUM2INT(option); } /* Specify the character encoding of the input data */ option = rb_hash_aref(options, ID2SYM(rb_intern("output_encoding"))); if (option && (option != Qnil)) { meta->encoding_index = RB_ENC_FIND_INDEX(StringValueCStr(option)); } /* :only_rows is a list of values where row is only parsed if its fields match those in the passed array. [nil, nil, ["ABC", nil, 1]] skips all rows where 3rd column isn't equal to "ABC", nil or 1 */ option = rb_hash_aref(options, ID2SYM(rb_intern("only_rows"))); if (option != Qnil) { meta->num_only_rows = (size_t)RARRAY_LEN(option); meta->only_rows = (VALUE *)malloc(meta->num_only_rows * sizeof(VALUE)); for (i = 0; i < meta->num_only_rows; i++) { VALUE only_row = rb_ary_entry(option, i); meta->only_rows[i] = validate_filter_row("only_rows", only_row); } } /* :except_rows is a list of values where row is only parsed if its fields don't match those in the passed array. [nil, nil, ["ABC", nil, 1]] skips all rows where 3rd column is equal to "ABC", nil or 1 */ option = rb_hash_aref(options, ID2SYM(rb_intern("except_rows"))); if (option != Qnil) { meta->num_except_rows = (size_t)RARRAY_LEN(option); meta->except_rows = (VALUE *)malloc(meta->num_except_rows * sizeof(VALUE)); for (i = 0; i < meta->num_except_rows; i++) { VALUE except_row = rb_ary_entry(option, i); meta->except_rows[i] = validate_filter_row("except_rows", except_row); } } /* :row_defaults is an array of default values that are assigned to fields containing empty strings according to matching field positions */ option = rb_hash_aref(options, ID2SYM(rb_intern("row_defaults"))); if (option != Qnil) { meta->num_row_defaults = RARRAY_LEN(option); meta->row_defaults = (VALUE*)malloc(meta->num_row_defaults * sizeof(VALUE*)); for (i = 0; i < meta->num_row_defaults; i++) { VALUE row_default = rb_ary_entry(option, i); meta->row_defaults[i] = row_default; } } /* :row_conversions specifies Ruby types that CSV field values should be converted into. Each char of row_conversions string represents Ruby type for CSV field with matching position. */ option = rb_hash_aref(options, ID2SYM(rb_intern("row_conversions"))); if (option != Qnil) { meta->num_row_conversions = RSTRING_LEN(option); meta->row_conversions = StringValuePtr(option); } /* Column names should be declared explicitly when parsing fields as Hashes */ if (meta->row_as_hash) { /* Only matters for hash results */ option = rb_hash_aref(options, ID2SYM(rb_intern("column_names"))); if (option == Qnil) { rb_raise(rcsv_parse_error, ":row_as_hash requires :column_names to be set."); } else { meta->last_entry = rb_hash_new(); meta->num_columns = (size_t)RARRAY_LEN(option); meta->column_names = (VALUE*)malloc(meta->num_columns * sizeof(VALUE*)); for (i = 0; i < meta->num_columns; i++) { meta->column_names[i] = rb_ary_entry(option, i); } } } else { meta->last_entry = rb_ary_new(); } while(true) { csvstr = rb_funcall(csvio, rb_intern("read"), 1, buffer_size); if ((csvstr == Qnil) || (RSTRING_LEN(csvstr) == 0)) { break; } csv_string = StringValuePtr(csvstr); csv_string_len = strlen(csv_string); /* Actual parsing and error handling */ if (csv_string_len != csv_parse(cp, csv_string, csv_string_len, &end_of_field_callback, &end_of_line_callback, meta)) { error = csv_error(cp); switch(error) { case CSV_EPARSE: rb_raise(rcsv_parse_error, "Error when parsing malformed data"); break; case CSV_ENOMEM: rb_raise(rcsv_parse_error, "No memory"); break; case CSV_ETOOBIG: rb_raise(rcsv_parse_error, "Field data is too large"); break; case CSV_EINVALID: rb_raise(rcsv_parse_error, "%s", (const char *)csv_strerror(error)); break; default: rb_raise(rcsv_parse_error, "Failed due to unknown reason"); } } } /* Flushing libcsv's buffer */ csv_fini(cp, &end_of_field_callback, &end_of_line_callback, meta); return Qnil; }
/* The main method that handles parsing */ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) { struct rcsv_metadata meta; VALUE csvio, options, option; VALUE ensure_container = rb_ary_new(); /* [] */ struct csv_parser cp; unsigned char csv_options = CSV_STRICT_FINI | CSV_APPEND_NULL; /* Setting up some sane defaults */ meta.row_as_hash = false; meta.empty_field_is_nil = false; meta.skip_current_row = false; meta.encoding_index = -1; meta.num_columns = 0; meta.current_col = 0; meta.current_row = 0; meta.offset_rows = 0; meta.num_only_rows = 0; meta.num_except_rows = 0; meta.num_row_defaults = 0; meta.num_row_conversions = 0; meta.only_rows = NULL; meta.except_rows = NULL; meta.row_defaults = NULL; meta.row_conversions = NULL; meta.column_names = NULL; meta.result = (VALUE[]){rb_ary_new()}; /* [] */ /* csvio is required, options is optional (pun intended) */ rb_scan_args(argc, argv, "11", &csvio, &options); /* options ||= {} */ if (NIL_P(options)) { options = rb_hash_new(); } /* First of all, we parse libcsv-related params so that it fails early if something is wrong with them */ /* By default, parsing is strict */ option = rb_hash_aref(options, ID2SYM(rb_intern("nostrict"))); if (!option || (option == Qnil)) { csv_options |= CSV_STRICT; } /* By default, empty strings are treated as Nils and quoted empty strings are treated as empty Ruby strings */ option = rb_hash_aref(options, ID2SYM(rb_intern("parse_empty_fields_as"))); if ((option == Qnil) || (option == ID2SYM(rb_intern("nil_or_string")))) { csv_options |= CSV_EMPTY_IS_NULL; } else if (option == ID2SYM(rb_intern("nil"))) { meta.empty_field_is_nil = true; } else if (option == ID2SYM(rb_intern("string"))) { meta.empty_field_is_nil = false; } else { rb_raise(rcsv_parse_error, "The only valid options for :parse_empty_fields_as are :nil, :string and :nil_or_string, but %s was supplied.", RSTRING_PTR(rb_inspect(option))); } /* rb_ensure() only expects callback functions to accept and return VALUEs */ /* This ugly hack converts C pointers into Ruby Fixnums in order to pass them in Array */ rb_ary_push(ensure_container, options); /* [options] */ rb_ary_push(ensure_container, csvio); /* [options, csvio] */ rb_ary_push(ensure_container, LONG2NUM((long)&meta)); /* [options, csvio, &meta] */ rb_ary_push(ensure_container, LONG2NUM((long)&cp)); /* [options, csvio, &meta, &cp] */ /* Try to initialize libcsv */ if (csv_init(&cp, csv_options) == -1) { rb_raise(rcsv_parse_error, "Couldn't initialize libcsv"); } /* From now on, cp handles allocated data and should be free'd on exit or exception */ rb_ensure(rcsv_raw_parse, ensure_container, rcsv_free_memory, ensure_container); /* Remove the last row if it's empty. That happens if CSV file ends with a newline. */ if (RARRAY_LEN(*(meta.result)) && /* meta.result.size != 0 */ RARRAY_LEN(rb_ary_entry(*(meta.result), -1)) == 0) { rb_ary_pop(*(meta.result)); } if (rb_block_given_p()) { return Qnil; /* STREAMING */ } else { return *(meta.result); /* Return accumulated result */ } }
static VALUE rb_tinytds_connect(VALUE self, VALUE opts) { /* Parsing options hash to local vars. */ VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset, azure; user = rb_hash_aref(opts, sym_username); pass = rb_hash_aref(opts, sym_password); dataserver = rb_hash_aref(opts, sym_dataserver); database = rb_hash_aref(opts, sym_database); app = rb_hash_aref(opts, sym_appname); version = rb_hash_aref(opts, sym_tds_version); ltimeout = rb_hash_aref(opts, sym_login_timeout); timeout = rb_hash_aref(opts, sym_timeout); charset = rb_hash_aref(opts, sym_encoding); azure = rb_hash_aref(opts, sym_azure); /* Dealing with options. */ if (dbinit() == FAIL) { rb_raise(cTinyTdsError, "failed dbinit() function"); return self; } dberrhandle(tinytds_err_handler); dbmsghandle(tinytds_msg_handler); GET_CLIENT_WRAPPER(self); cwrap->login = dblogin(); if (!NIL_P(version)) dbsetlversion(cwrap->login, NUM2INT(version)); if (!NIL_P(user)) dbsetluser(cwrap->login, StringValuePtr(user)); if (!NIL_P(pass)) dbsetlpwd(cwrap->login, StringValuePtr(pass)); if (!NIL_P(app)) dbsetlapp(cwrap->login, StringValuePtr(app)); if (!NIL_P(ltimeout)) dbsetlogintime(NUM2INT(ltimeout)); if (!NIL_P(timeout)) dbsettime(NUM2INT(timeout)); if (!NIL_P(charset)) DBSETLCHARSET(cwrap->login, StringValuePtr(charset)); if (!NIL_P(database) && (azure == Qtrue)) { #ifdef DBSETLDBNAME DBSETLDBNAME(cwrap->login, StringValuePtr(database)); cwrap->userdata->continue_on_timeout = 0; // Send INT_CANCEL on timeout with Azure #else rb_warn("TinyTds: Azure connections not supported in this version of FreeTDS.\n"); #endif } cwrap->client = dbopen(cwrap->login, StringValuePtr(dataserver)); if (cwrap->client) { cwrap->closed = 0; cwrap->charset = charset; if (!NIL_P(version)) dbsetversion(NUM2INT(version)); dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata); cwrap->userdata->closed = 0; if (!NIL_P(database) && (azure != Qtrue)) { dbuse(cwrap->client, StringValuePtr(database)); } VALUE transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset); cwrap->encoding = rb_enc_find(StringValuePtr(transposed_encoding)); if (dbtds(cwrap->client) <= 7) { cwrap->identity_insert_sql = "SELECT CAST(@@IDENTITY AS bigint) AS Ident"; } else { cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"; } } return self; }
VALUE Traverser_Clone2_traverse_item(VALUE self ) { VALUE vals[0]; VALUE it ,__result=Qnil,_autovar=Qnil,_autovar_2=Qnil,_autovar_3=Qnil,_ar=Qnil,_it=Qnil,_autovar_4=Qnil; VALUE bind2=bind_new2(2); cstruct *ptr; Data_Get_Struct(self,cstruct,ptr); switch(FIX2LONG(rb_hash_aref(switchhash_Traverser_Clone2_1,rb_obj_class(ame_curobj2(ptr))))) { case 0/*AmethystAST*/: ; int oldpos1=ptr->pos; int cut1=0; alt1_1: if(!ptr->branches)ptr->discard=ptr->pos; ptr->branches+=3; it=rb_funcall(self,sy_visit,0); if (it==failobj) { it=failobj; goto revert1; } __result=it;; ; goto accept2; revert1: ; goto alt1_2; accept2: ; ; ptr->branches-=3; goto accept1; alt1_2: ptr->pos=oldpos1; ptr->branches-=1; it=ptr->ary[ptr->pos]; ; ptr->pos++; _autovar=it;; cstruct oldpass1=*ptr; ptr->pos=ptr->len=0; ptr->ary=NULL; ame_setsrc2(self,_autovar); it=Traverser_Clone2_traverse(self ); if (it==failobj) { it=failobj; goto pass1; } _autovar_2=it;; goto success1; pass1: *ptr=oldpass1; if (1) { it=failobj; goto revert2; } success1: *ptr=oldpass1; it=_autovar_2; __result=it;; ; goto accept3; revert2: ; goto alt1_3; accept3: ; ; ptr->branches-=2; goto accept1; alt1_3: ptr->pos=oldpos1; ptr->branches-=1; it=AmethystCore_anything(self ); if (it==failobj) { it=failobj; goto revert3; } __result=it;; ; goto accept4; revert3: ; goto alt1_4; accept4: ; ; ptr->branches-=1; goto accept1; alt1_4: ptr->pos=oldpos1; ptr->branches-=1; if (1) { it=failobj; goto fail; }; accept1: ; break; case 1/*Array*/: ; int oldpos2=ptr->pos; int cut2=0; alt2_1: if(!ptr->branches)ptr->discard=ptr->pos; ptr->branches+=2; it=rb_funcall(self,sy_visit,0); if (it==failobj) { it=failobj; goto revert4; } __result=it;; ; goto accept6; revert4: ; goto alt2_2; accept6: ; ; ptr->branches-=2; goto accept5; alt2_2: ptr->pos=oldpos2; ptr->branches-=1; it=ptr->ary[ptr->pos]; ; ptr->pos++; _autovar_3=it;; cstruct oldpass2=*ptr; ptr->pos=ptr->len=0; ptr->ary=NULL; ame_setsrc2(self,_autovar_3); it=rb_ary_new3(0); _ar=it;; int stop1=0; while(!stop1) { int oldpos3=ptr->pos; int cut3=0; alt3_1: if(!ptr->branches)ptr->discard=ptr->pos; ptr->branches+=2; it=Traverser_Clone2_traverse_item(self ); if (it==failobj) { it=failobj; goto revert6; } _it=it;; bind_aset(bind2,1,_ar); bind_aset(bind2,2,_it); it=rb_funcall(self,sy_Traverser_Clone2_bind_lb_1_rb__lt__7b20,1,bind2); _ar=bind_aget(bind2,1);; _it=bind_aget(bind2,2);; ; goto accept9; revert6: ; goto alt3_2; accept9: ; ; ptr->branches-=2; goto accept8; alt3_2: ptr->pos=oldpos3; ptr->branches-=1; stop1=1; ; goto accept10; revert7: ; goto alt3_3; accept10: ; ; ptr->branches-=1; goto accept8; alt3_3: ptr->pos=oldpos3; ptr->branches-=1; if (1) { it=failobj; goto pass2; }; accept8: ; } it=_ar; _autovar_4=it;; goto success2; pass2: *ptr=oldpass2; if (1) { it=failobj; goto revert5; } success2: *ptr=oldpass2; it=_autovar_4; __result=it;; ; goto accept7; revert5: ; goto alt2_3; accept7: ; ; ptr->branches-=1; goto accept5; alt2_3: ptr->pos=oldpos2; ptr->branches-=1; if (1) { it=failobj; goto fail; }; accept5: ; break; case 2/*Object*/: ; int oldpos4=ptr->pos; int cut4=0; alt4_1: if(!ptr->branches)ptr->discard=ptr->pos; ptr->branches+=2; it=rb_funcall(self,sy_visit,0); if (it==failobj) { it=failobj; goto revert8; } __result=it;; ; goto accept12; revert8: ; goto alt4_2; accept12: ; ; ptr->branches-=2; goto accept11; alt4_2: ptr->pos=oldpos4; ptr->branches-=1; it=AmethystCore_anything(self ); if (it==failobj) { it=failobj; goto revert9; } __result=it;; ; goto accept13; revert9: ; goto alt4_3; accept13: ; ; ptr->branches-=1; goto accept11; alt4_3: ptr->pos=oldpos4; ptr->branches-=1; if (1) { it=failobj; goto fail; }; accept11: ; break; } fail: return it; }
static VALUE rb_redcarpet_html_init(int argc, VALUE *argv, VALUE self) { struct rb_redcarpet_rndr *rndr; unsigned int render_flags = 0; VALUE hash, link_attr = Qnil; Data_Get_Struct(self, struct rb_redcarpet_rndr, rndr); if (rb_scan_args(argc, argv, "01", &hash) == 1) { Check_Type(hash, T_HASH); /* escape_html */ if (rb_hash_aref(hash, CSTR2SYM("escape_html")) == Qtrue) render_flags |= HTML_ESCAPE; /* filter_html */ if (rb_hash_aref(hash, CSTR2SYM("filter_html")) == Qtrue) render_flags |= HTML_SKIP_HTML; /* no_image */ if (rb_hash_aref(hash, CSTR2SYM("no_images")) == Qtrue) render_flags |= HTML_SKIP_IMAGES; /* no_links */ if (rb_hash_aref(hash, CSTR2SYM("no_links")) == Qtrue) render_flags |= HTML_SKIP_LINKS; /* prettify */ if (rb_hash_aref(hash, CSTR2SYM("prettify")) == Qtrue) render_flags |= HTML_PRETTIFY; /* filter_style */ if (rb_hash_aref(hash, CSTR2SYM("no_styles")) == Qtrue) render_flags |= HTML_SKIP_STYLE; /* safelink */ if (rb_hash_aref(hash, CSTR2SYM("safe_links_only")) == Qtrue) render_flags |= HTML_SAFELINK; if (rb_hash_aref(hash, CSTR2SYM("with_toc_data")) == Qtrue) render_flags |= HTML_TOC; if (rb_hash_aref(hash, CSTR2SYM("hard_wrap")) == Qtrue) render_flags |= HTML_HARD_WRAP; if (rb_hash_aref(hash, CSTR2SYM("xhtml")) == Qtrue) render_flags |= HTML_USE_XHTML; link_attr = rb_hash_aref(hash, CSTR2SYM("link_attributes")); } sdhtml_renderer(&rndr->callbacks, (struct html_renderopt *)&rndr->options.html, render_flags); rb_redcarpet__overload(self, rb_cRenderHTML); if (!NIL_P(link_attr)) { rndr->options.link_attributes = link_attr; rndr->options.html.link_attributes = &rndr_link_attributes; } return Qnil; }
void wsf_util_pack_attachments ( axutil_env_t *env, axiom_node_t *node, VALUE attach_ht, int enable_mtom, char *default_cnt_type) { axiom_element_t *node_element = NULL; axiom_element_t *child_element = NULL; axiom_child_element_iterator_t *child_element_ite = NULL; axiom_node_t *child_node = NULL; int attachment_done = 0; axis2_char_t *element_localname = NULL; axiom_namespace_t *element_namespace = NULL; axis2_char_t *namespace_uri = NULL; if (!node) return; if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { node_element = axiom_node_get_data_element(node, env); if (node_element) { child_element_ite = axiom_element_get_child_elements(node_element, env, node); if (child_element_ite) { child_node = axiom_child_element_iterator_next(child_element_ite, env); attachment_done = 0; while (child_node && !attachment_done) { child_element = axiom_node_get_data_element(child_node, env); element_localname = axiom_element_get_localname(child_element, env); if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0)) { element_namespace = axiom_element_get_namespace(child_element, env, child_node); if (element_namespace) { namespace_uri = axiom_namespace_get_uri(element_namespace, env); if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0)) { axis2_char_t *cnt_type = NULL; axis2_char_t *content_type = NULL; axis2_char_t *href = NULL; axis2_char_t* pos = NULL; cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE); content_type = !cnt_type ? default_cnt_type : cnt_type; href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF); if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:"))) { axis2_char_t* cid = NULL; VALUE content_tmp; void* content = NULL; unsigned int content_length = 0; cid = href + 4; content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid)); content_length = RSTRING(content_tmp)->len; content = malloc(sizeof (char) * content_length); memcpy (content, (const void*)STR2CSTR(content_tmp), content_length); if (content) { void *data_buffer = NULL; axiom_data_handler_t *data_handler = NULL; axiom_node_t *text_node = NULL; axiom_text_t *text = NULL; data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length); if (data_buffer) { memcpy (data_buffer, content, content_length); data_handler = axiom_data_handler_create (env, NULL, content_type); if (data_handler) { axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length); text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node); if (enable_mtom == AXIS2_FALSE) axiom_text_set_optimize (text, env, AXIS2_FALSE); axiom_node_detach (child_node, env); } } attachment_done = 1; } } } } } child_node = axiom_child_element_iterator_next(child_element_ite, env); } } } } // Process child nodes child_node = axiom_node_get_first_child(node, env); while (child_node) { wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type); child_node = axiom_node_get_next_sibling(child_node, env); } }
/* * call-seq: * Commit.create(repository, data = {}) -> oid * * Write a new +Commit+ object to +repository+, with the given +data+ * arguments, passed as a +Hash+: * * - +:message+: a string with the full text for the commit's message * - +:committer+ (optional): a hash with the signature for the committer, * defaults to the signature from the configuration * - +:author+ (optional): a hash with the signature for the author, * defaults to the signature from the configuration * - +:parents+: an +Array+ with zero or more parents for this commit, * represented as <tt>Rugged::Commit</tt> instances, or OID +String+. * - +:tree+: the tree for this commit, represented as a <tt>Rugged::Tree</tt> * instance or an OID +String+. * - +:update_ref+ (optional): a +String+ with the name of a reference in the * repository which should be updated to point to this commit (e.g. "HEAD") * * When the commit is successfully written to disk, its +oid+ will be * returned as a hex +String+. * * author = {:email=>"*****@*****.**", :time=>Time.now, :name=>"Vicent Mart\303\255"} * * Rugged::Commit.create(r, * :author => author, * :message => "Hello world\n\n", * :committer => author, * :parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"], * :tree => some_tree) #=> "f148106ca58764adc93ad4e2d6b1d168422b9796" */ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data) { VALUE rb_message, rb_tree, rb_parents, rb_ref; VALUE rb_err_obj = Qnil; int parent_count, i, error = 0; const git_commit **parents = NULL; git_commit **free_list = NULL; git_tree *tree; git_signature *author, *committer; git_oid commit_oid; git_repository *repo; const char *update_ref = NULL; Check_Type(rb_data, T_HASH); rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); rb_ref = rb_hash_aref(rb_data, CSTR2SYM("update_ref")); if (!NIL_P(rb_ref)) { Check_Type(rb_ref, T_STRING); update_ref = StringValueCStr(rb_ref); } rb_message = rb_hash_aref(rb_data, CSTR2SYM("message")); Check_Type(rb_message, T_STRING); committer = rugged_signature_get( rb_hash_aref(rb_data, CSTR2SYM("committer")), repo ); author = rugged_signature_get( rb_hash_aref(rb_data, CSTR2SYM("author")), repo ); rb_parents = rb_hash_aref(rb_data, CSTR2SYM("parents")); Check_Type(rb_parents, T_ARRAY); rb_tree = rb_hash_aref(rb_data, CSTR2SYM("tree")); tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE); parents = alloca(RARRAY_LEN(rb_parents) * sizeof(void *)); free_list = alloca(RARRAY_LEN(rb_parents) * sizeof(void *)); parent_count = 0; for (i = 0; i < (int)RARRAY_LEN(rb_parents); ++i) { VALUE p = rb_ary_entry(rb_parents, i); git_commit *parent = NULL; git_commit *free_ptr = NULL; if (NIL_P(p)) continue; if (TYPE(p) == T_STRING) { git_oid oid; error = git_oid_fromstr(&oid, StringValueCStr(p)); if (error < GIT_OK) goto cleanup; error = git_commit_lookup(&parent, repo, &oid); if (error < GIT_OK) goto cleanup; free_ptr = parent; } else if (rb_obj_is_kind_of(p, rb_cRuggedCommit)) { Data_Get_Struct(p, git_commit, parent); } else { rb_err_obj = rb_exc_new2(rb_eTypeError, "Invalid type for parent object"); goto cleanup; } parents[parent_count] = parent; free_list[parent_count] = free_ptr; parent_count++; } error = git_commit_create( &commit_oid, repo, update_ref, author, committer, NULL, StringValueCStr(rb_message), tree, parent_count, parents); cleanup: git_signature_free(author); git_signature_free(committer); git_object_free((git_object *)tree); for (i = 0; i < parent_count; ++i) git_object_free((git_object *)free_list[i]); if (!NIL_P(rb_err_obj)) rb_exc_raise(rb_err_obj); rugged_exception_check(error); return rugged_create_oid(&commit_oid); }
static VALUE port_init( VALUE self, VALUE attributes ) { VALUE number = rb_hash_aref( attributes, ID2SYM( rb_intern( "number" ) ) ); rb_iv_set( self, "@number", number ); return self; }
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 max_size; 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) { int i; VALUE keys = rb_funcall(hash, rb_intern("keys"), 0); 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 the max size (determined by server, defaults to 4mb) max_size = bson_buffer_get_max_size(buffer); if (length > max_size) { bson_buffer_free(buffer); rb_raise(InvalidDocument, "Document too large: This BSON document is limited to %d bytes.", max_size); } SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&length, 4); }
/* * call-seq: * QueryParser.new(options = {}) -> QueryParser * * Create a new QueryParser. The QueryParser is used to convert string * queries into Query objects. The options are; * * === Options * * :default_field:: Default: "*" (all fields). The default field to * search when no field is specified in the search * string. It can also be an array of fields. * :analyzer:: Default: StandardAnalyzer. Analyzer used by the * query parser to parse query terms * :wild_card_downcase:: Default: true. Specifies whether wild-card queries * should be downcased or not since they are not * passed through the parser * :fields:: Default: []. Lets the query parser know what * fields are available for searching, particularly * when the "*" is specified as the search field * :tokenized_fields:: Default: :fields. Lets the query parser know which * fields are tokenized so it knows which fields to * run the analyzer over. * :validate_fields:: Default: false. Set to true if you want an * exception to be raised if there is an attempt to * search a non-existent field * :or_default:: Default: true. Use "OR" as the default boolean * operator * :default_slop:: Default: 0. Default slop to use in PhraseQuery * :handle_parser_errors:: Default: true. QueryParser will quietly handle all * parsing errors internally. If you'd like to handle * them yourself, set this parameter to false. * :clean_string:: Default: true. QueryParser will do a quick * once-over the query string make sure that quotes * and brackets match up and special characters are * escaped * :max_clauses:: Default: 512. the maximum number of clauses * allowed in boolean queries and the maximum number * of terms allowed in multi, prefix, wild-card or * fuzzy queries when those queries are generated by * rewriting other queries */ static VALUE frt_qp_init(int argc, VALUE *argv, VALUE self) { VALUE roptions; VALUE rval; Analyzer *analyzer = NULL; bool has_options = false; HashSet *all_fields = NULL; HashSet *tkz_fields = NULL; HashSet *def_fields = NULL; QParser *qp; if (rb_scan_args(argc, argv, "01", &roptions) > 0) { if (TYPE(roptions) == T_HASH) { has_options = true; if (Qnil != (rval = rb_hash_aref(roptions, sym_default_field))) { def_fields = frt_get_fields(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_analyzer))) { analyzer = frt_get_cwrapped_analyzer(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_all_fields))) { all_fields = frt_get_fields(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_fields))) { all_fields = frt_get_fields(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_tkz_fields))) { tkz_fields = frt_get_fields(rval); } } else { def_fields = frt_get_fields(roptions); } } if (all_fields == NULL) { all_fields = hs_new_str(&free); } if (!analyzer) { analyzer = mb_standard_analyzer_new(true); } qp = qp_new(all_fields, def_fields, tkz_fields, analyzer); qp->allow_any_fields = true; qp->clean_str = true; /* handle options */ if (argc > 0) { if (Qnil != (rval = rb_hash_aref(roptions, sym_handle_parse_errors))) { qp->handle_parse_errors = RTEST(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_validate_fields))) { qp->allow_any_fields = !RTEST(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_wild_card_downcase))) { qp->wild_lower = RTEST(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_or_default))) { qp->or_default = RTEST(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_default_slop))) { qp->def_slop = FIX2INT(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_clean_string))) { qp->clean_str = RTEST(rval); } if (Qnil != (rval = rb_hash_aref(roptions, sym_max_clauses))) { qp->max_clauses = FIX2INT(rval); } } Frt_Wrap_Struct(self, frt_qp_mark, frt_qp_free, qp); object_add(qp, self); return self; }
/* grpc_run_batch_stack_fill_ops fills the run_batch_stack ops array from * ops_hash */ static void grpc_run_batch_stack_fill_ops(run_batch_stack* st, VALUE ops_hash) { VALUE this_op = Qnil; VALUE this_value = Qnil; VALUE ops_ary = rb_ary_new(); size_t i = 0; /* Create a ruby array with just the operation keys */ rb_hash_foreach(ops_hash, grpc_rb_call_check_op_keys_hash_cb, ops_ary); /* Fill the ops array */ for (i = 0; i < (size_t)RARRAY_LEN(ops_ary); i++) { this_op = rb_ary_entry(ops_ary, i); this_value = rb_hash_aref(ops_hash, this_op); switch(NUM2INT(this_op)) { case GRPC_OP_SEND_INITIAL_METADATA: /* N.B. later there is no need to explicitly delete the metadata keys * and values, they are references to data in ruby objects. */ grpc_rb_md_ary_convert(this_value, &st->send_metadata); st->ops[st->op_num].data.send_initial_metadata.count = st->send_metadata.count; st->ops[st->op_num].data.send_initial_metadata.metadata = st->send_metadata.metadata; break; case GRPC_OP_SEND_MESSAGE: st->ops[st->op_num].data.send_message = grpc_rb_s_to_byte_buffer(RSTRING_PTR(this_value), RSTRING_LEN(this_value)); break; case GRPC_OP_SEND_CLOSE_FROM_CLIENT: break; case GRPC_OP_SEND_STATUS_FROM_SERVER: /* N.B. later there is no need to explicitly delete the metadata keys * and values, they are references to data in ruby objects. */ grpc_rb_op_update_status_from_server(&st->ops[st->op_num], &st->send_trailing_metadata, this_value); break; case GRPC_OP_RECV_INITIAL_METADATA: st->ops[st->op_num].data.recv_initial_metadata = &st->recv_metadata; break; case GRPC_OP_RECV_MESSAGE: st->ops[st->op_num].data.recv_message = &st->recv_message; break; case GRPC_OP_RECV_STATUS_ON_CLIENT: st->ops[st->op_num].data.recv_status_on_client.trailing_metadata = &st->recv_trailing_metadata; st->ops[st->op_num].data.recv_status_on_client.status = &st->recv_status; st->ops[st->op_num].data.recv_status_on_client.status_details = &st->recv_status_details; st->ops[st->op_num].data.recv_status_on_client.status_details_capacity = &st->recv_status_details_capacity; break; case GRPC_OP_RECV_CLOSE_ON_SERVER: st->ops[st->op_num].data.recv_close_on_server.cancelled = &st->recv_cancelled; break; default: grpc_run_batch_stack_cleanup(st); rb_raise(rb_eTypeError, "invalid operation : bad value %d", NUM2INT(this_op)); }; st->ops[st->op_num].op = (grpc_op_type)NUM2INT(this_op); st->op_num++; } }
void yajl_encode_part(void * wrapper, VALUE obj, VALUE io) { VALUE str, outBuff, otherObj; yajl_encoder_wrapper * w = wrapper; yajl_gen_status status; int idx = 0; const unsigned char * buffer; const char * cptr; unsigned int len; if (io != Qnil || w->on_progress_callback != Qnil) { status = yajl_gen_get_buf(w->encoder, &buffer, &len); if (len >= WRITE_BUFSIZE) { outBuff = rb_str_new((const char *)buffer, len); if (io != Qnil) { rb_io_write(io, outBuff); } else if (w->on_progress_callback != Qnil) { rb_funcall(w->on_progress_callback, intern_call, 1, outBuff); } yajl_gen_clear(w->encoder); } } switch (TYPE(obj)) { case T_HASH: status = yajl_gen_map_open(w->encoder); /* TODO: itterate through keys in the hash */ VALUE keys = rb_funcall(obj, intern_keys, 0); VALUE entry, keyStr; for(idx=0; idx<RARRAY_LEN(keys); idx++) { entry = rb_ary_entry(keys, idx); keyStr = rb_funcall(entry, intern_to_s, 0); /* key must be a string */ /* the key */ yajl_encode_part(w, keyStr, io); /* the value */ yajl_encode_part(w, rb_hash_aref(obj, entry), io); } status = yajl_gen_map_close(w->encoder); break; case T_ARRAY: status = yajl_gen_array_open(w->encoder); for(idx=0; idx<RARRAY_LEN(obj); idx++) { otherObj = rb_ary_entry(obj, idx); yajl_encode_part(w, otherObj, io); } status = yajl_gen_array_close(w->encoder); break; case T_NIL: status = yajl_gen_null(w->encoder); break; case T_TRUE: status = yajl_gen_bool(w->encoder, 1); break; case T_FALSE: status = yajl_gen_bool(w->encoder, 0); break; case T_FIXNUM: case T_FLOAT: case T_BIGNUM: str = rb_funcall(obj, intern_to_s, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); if (strcmp(cptr, "NaN") == 0 || strcmp(cptr, "Infinity") == 0 || strcmp(cptr, "-Infinity") == 0) { rb_raise(cEncodeError, "'%s' is an invalid number", cptr); } status = yajl_gen_number(w->encoder, cptr, len); break; case T_STRING: cptr = RSTRING_PTR(obj); len = RSTRING_LEN(obj); status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len); break; default: if (rb_respond_to(obj, intern_as_json)) { obj = rb_funcall(obj, intern_as_json, 0); yajl_encode_part(w, obj, io); } else if (rb_respond_to(obj, intern_to_json)) { str = rb_funcall(obj, intern_to_json, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_number(w->encoder, cptr, len); } else { str = rb_funcall(obj, intern_to_s, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len); } break; } }
static VALUE stackprof_start(int argc, VALUE *argv, VALUE self) { struct sigaction sa; struct itimerval timer; VALUE opts = Qnil, mode = Qnil, interval = Qnil, out = Qfalse; int raw = 0, aggregate = 1; if (_stackprof.running) return Qfalse; rb_scan_args(argc, argv, "0:", &opts); if (RTEST(opts)) { mode = rb_hash_aref(opts, sym_mode); interval = rb_hash_aref(opts, sym_interval); out = rb_hash_aref(opts, sym_out); if (RTEST(rb_hash_aref(opts, sym_raw))) raw = 1; if (rb_hash_lookup2(opts, sym_aggregate, Qundef) == Qfalse) aggregate = 0; } if (!RTEST(mode)) mode = sym_wall; if (!_stackprof.frames) { _stackprof.frames = st_init_numtable(); _stackprof.overall_signals = 0; _stackprof.overall_samples = 0; _stackprof.during_gc = 0; } if (mode == sym_object) { if (!RTEST(interval)) interval = INT2FIX(1); objtracer = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, stackprof_newobj_handler, 0); rb_tracepoint_enable(objtracer); } else if (mode == sym_wall || mode == sym_cpu) { if (!RTEST(interval)) interval = INT2FIX(1000); sa.sa_sigaction = stackprof_signal_handler; sa.sa_flags = SA_RESTART | SA_SIGINFO; sigemptyset(&sa.sa_mask); sigaction(mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL); timer.it_interval.tv_sec = 0; timer.it_interval.tv_usec = NUM2LONG(interval); timer.it_value = timer.it_interval; setitimer(mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0); } else if (mode == sym_custom) { /* sampled manually */ interval = Qnil; } else { rb_raise(rb_eArgError, "unknown profiler mode"); } _stackprof.running = 1; _stackprof.raw = raw; _stackprof.aggregate = aggregate; _stackprof.mode = mode; _stackprof.interval = interval; _stackprof.out = out; return Qtrue; }
static inline void event_callback (struct em_event* e) { const unsigned long signature = e->signature; int event = e->event; const char *data_str = e->data_str; const unsigned long data_num = e->data_num; switch (event) { case EM_CONNECTION_READ: { VALUE conn = rb_hash_aref (EmConnsHash, ULONG2NUM (signature)); if (conn == Qnil) rb_raise (EM_eConnectionNotBound, "received %lu bytes of data for unknown signature: %lu", data_num, signature); rb_funcall (conn, Intern_receive_data, 1, rb_str_new (data_str, data_num)); return; } case EM_CONNECTION_ACCEPTED: case EM_CONNECTION_UNBOUND: { rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), data_str ? rb_str_new(data_str,data_num) : ULONG2NUM(data_num)); return; } case EM_CONNECTION_COMPLETED: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_connection_completed, 0); return; } case EM_CONNECTION_NOTIFY_READABLE: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_notify_readable, 0); return; } case EM_CONNECTION_NOTIFY_WRITABLE: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_notify_readable, 0); return; } case EM_LOOPBREAK_SIGNAL: { rb_funcall (EmModule, Intern_run_deferred_callbacks, 0); return; } case EM_TIMER_FIRED: { VALUE timer = rb_funcall (EmTimersHash, Intern_delete, 1, ULONG2NUM (data_num)); if (timer == Qnil) { rb_raise (EM_eUnknownTimerFired, "no such timer: %lu", data_num); } else if (timer == Qfalse) { /* Timer Canceled */ } else { rb_funcall (timer, Intern_call, 0); } return; } #ifdef WITH_SSL case EM_SSL_HANDSHAKE_COMPLETED: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_ssl_handshake_completed, 0); return; } case EM_SSL_VERIFY: { VALUE conn = ensure_conn(signature); VALUE should_accept = rb_funcall (conn, Intern_ssl_verify_peer, 1, rb_str_new(data_str, data_num)); if (RTEST(should_accept)) evma_accept_ssl_peer (signature); return; } #endif case EM_PROXY_TARGET_UNBOUND: { VALUE conn = ensure_conn(signature); rb_funcall (conn, Intern_proxy_target_unbound, 0); return; } } }
static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) { struct nogvl_send_query_args args; fd_set fdset; int fd, retval; int async = 0; VALUE opts, defaults, read_timeout; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *conn_enc; #endif struct timeval tv; struct timeval* tvp; long int sec; VALUE result; GET_CLIENT(self); REQUIRE_OPEN_DB(wrapper); args.mysql = wrapper->client; // see if this connection is still waiting on a result from a previous query if (wrapper->active == 0) { // mark this connection active wrapper->active = 1; } else { rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result"); } defaults = rb_iv_get(self, "@query_options"); if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) { opts = rb_funcall(defaults, intern_merge, 1, opts); rb_iv_set(self, "@query_options", opts); if (rb_hash_aref(opts, sym_async) == Qtrue) { async = 1; } } else { opts = defaults; } Check_Type(args.sql, T_STRING); #ifdef HAVE_RUBY_ENCODING_H conn_enc = rb_to_encoding(wrapper->encoding); // ensure the string is in the encoding the connection is expecting args.sql = rb_str_export_to_enc(args.sql, conn_enc); #endif if (rb_thread_blocking_region(nogvl_send_query, &args, RUBY_UBF_IO, 0) == Qfalse) { // an error occurred, we're not active anymore MARK_CONN_INACTIVE(self); return rb_raise_mysql2_error(wrapper); } read_timeout = rb_iv_get(self, "@read_timeout"); tvp = NULL; if (!NIL_P(read_timeout)) { Check_Type(read_timeout, T_FIXNUM); tvp = &tv; sec = FIX2INT(read_timeout); // TODO: support partial seconds? // also, this check is here for sanity, we also check up in Ruby if (sec >= 0) { tvp->tv_sec = sec; } else { rb_raise(cMysql2Error, "read_timeout must be a positive integer, you passed %ld", sec); } tvp->tv_usec = 0; } if (!async) { // the below code is largely from do_mysql // http://github.com/datamapper/do fd = wrapper->client->net.fd; for(;;) { int fd_set_fd = fd; #if defined(_WIN32) && !defined(HAVE_RB_THREAD_BLOCKING_REGION) WSAPROTOCOL_INFO wsa_pi; // dupicate the SOCKET from libmysql int r = WSADuplicateSocket(fd, GetCurrentProcessId(), &wsa_pi); SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0); // create the CRT fd so ruby can get back to the SOCKET fd_set_fd = _open_osfhandle(s, O_RDWR|O_BINARY); #endif FD_ZERO(&fdset); FD_SET(fd_set_fd, &fdset); retval = rb_thread_select(fd_set_fd + 1, &fdset, NULL, NULL, tvp); #if defined(_WIN32) && !defined(HAVE_RB_THREAD_BLOCKING_REGION) // cleanup the CRT fd _close(fd_set_fd); // cleanup the duplicated SOCKET closesocket(s); #endif if (retval == 0) { rb_raise(cMysql2Error, "Timeout waiting for a response from the last query. (waited %d seconds)", FIX2INT(read_timeout)); } if (retval < 0) { rb_sys_fail(0); } if (retval > 0) { break; } } result = rb_mysql_client_async_result(self); return result; } else { return Qnil; } }
static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) { /* Local Vars */ VALUE qopts, opts, block; ID timezone; int symbolize_keys = 0, as_array = 0, cache_rows = 0, first = 0, empty_sets = 0; tinytds_client_userdata *userdata; GET_RESULT_WRAPPER(self); userdata = (tinytds_client_userdata *)dbgetuserdata(rwrap->client); /* Merge Options Hash To Query Options. Populate Opts & Block Var. */ qopts = rb_iv_get(self, "@query_options"); if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) qopts = rb_funcall(qopts, intern_merge, 1, opts); rb_iv_set(self, "@query_options", qopts); /* Locals From Options */ if (rb_hash_aref(qopts, sym_first) == Qtrue) first = 1; if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue) symbolize_keys = 1; if (rb_hash_aref(qopts, sym_as) == sym_array) as_array = 1; if (rb_hash_aref(qopts, sym_cache_rows) == Qtrue) cache_rows = 1; if (rb_hash_aref(qopts, sym_timezone) == sym_local) { timezone = intern_local; } else if (rb_hash_aref(qopts, sym_timezone) == sym_utc) { timezone = intern_utc; } else { rb_warn(":timezone option must be :utc or :local - defaulting to :local"); timezone = intern_local; } if (rb_hash_aref(qopts, sym_empty_sets) == Qtrue) empty_sets = 1; /* Make The Results Or Yield Existing */ if (NIL_P(rwrap->results)) { RETCODE dbsqlok_rc, dbresults_rc; rwrap->results = rb_ary_new(); dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client); dbresults_rc = rb_tinytds_result_dbresults_retcode(self); while ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED)) { int has_rows = (DBROWS(rwrap->client) == SUCCEED) ? 1 : 0; if (has_rows || empty_sets || (rwrap->number_of_results == 0)) rb_tinytds_result_fields(self); if ((has_rows || empty_sets) && rwrap->number_of_fields > 0) { /* Create rows for this result set. */ unsigned long rowi = 0; VALUE result = rb_ary_new(); while (nogvl_dbnextrow(rwrap->client) != NO_MORE_ROWS) { VALUE row = rb_tinytds_result_fetch_row(self, timezone, symbolize_keys, as_array); if (cache_rows) rb_ary_store(result, rowi, row); if (!NIL_P(block)) rb_yield(row); if (first) { dbcanquery(rwrap->client); userdata->dbcancel_sent = 1; } rowi++; } rwrap->number_of_rows = rowi; /* Store the result. */ if (cache_rows) { if (rwrap->number_of_results == 0) { rwrap->results = result; } else if (rwrap->number_of_results == 1) { VALUE multi_resultsets = rb_ary_new(); rb_ary_store(multi_resultsets, 0, rwrap->results); rb_ary_store(multi_resultsets, 1, result); rwrap->results = multi_resultsets; } else { rb_ary_store(rwrap->results, rwrap->number_of_results, result); } } // If we find results increment the counter that helpers use and setup the next loop. rwrap->number_of_results = rwrap->number_of_results + 1; dbresults_rc = rb_tinytds_result_dbresults_retcode(self); rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil); } else { // If we do not find results, side step the rb_tinytds_result_dbresults_retcode helper and // manually populate its memoized array while nullifing any memoized fields too before loop. dbresults_rc = nogvl_dbresults(rwrap->client); rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, INT2FIX(dbresults_rc)); rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil); } } if (dbresults_rc == FAIL) rb_warn("TinyTDS: Something in the dbresults() while loop set the return code to FAIL.\n"); userdata->dbsql_sent = 0; } else if (!NIL_P(block)) { unsigned long i; for (i = 0; i < rwrap->number_of_rows; i++) { rb_yield(rb_ary_entry(rwrap->results, i)); } } return rwrap->results; }
static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) { #ifndef _WIN32 struct async_query_args async_args; #endif struct nogvl_send_query_args args; int async = 0; VALUE opts, defaults; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *conn_enc; #endif GET_CLIENT(self); REQUIRE_OPEN_DB(wrapper); args.mysql = wrapper->client; defaults = rb_iv_get(self, "@query_options"); if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) { opts = rb_funcall(defaults, intern_merge, 1, opts); rb_iv_set(self, "@query_options", opts); if (rb_hash_aref(opts, sym_async) == Qtrue) { async = 1; } } else { opts = defaults; } Check_Type(args.sql, T_STRING); #ifdef HAVE_RUBY_ENCODING_H conn_enc = rb_to_encoding(wrapper->encoding); // ensure the string is in the encoding the connection is expecting args.sql = rb_str_export_to_enc(args.sql, conn_enc); #endif args.sql_ptr = StringValuePtr(args.sql); args.sql_len = RSTRING_LEN(args.sql); // see if this connection is still waiting on a result from a previous query if (wrapper->active == 0) { // mark this connection active wrapper->active = 1; } else { rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result"); } args.wrapper = wrapper; #ifndef _WIN32 rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0); if (!async) { async_args.fd = wrapper->client->net.fd; async_args.self = self; rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0); return rb_mysql_client_async_result(self); } else { return Qnil; } #else do_send_query(&args); // this will just block until the result is ready return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self); #endif }
// prereq: len > 0 static void _nested_aset(VALUE output, volatile VALUE keys, VALUE value) { volatile VALUE klass = rb_obj_class(output); VALUE* arr = RARRAY_PTR(keys); long len = RARRAY_LEN(keys); // first key seg if (!RSTRING_LEN(arr[0])) { rb_raise(rb_eRuntimeError, "array key at:0 conflicts with hash"); } bool is_hash_key = true; # define NEW_CHILD(child) \ volatile VALUE child = (next_is_hash_key ? rb_class_new_instance(0, NULL, klass) : rb_ary_new()); # define ASSERT_HASH \ if (TYPE(output) != T_HASH) {\ rb_raise(rb_eTypeError, "hash key at:%ld conflicts with array", i + 1);\ } # define ASSERT_ARRAY \ if (TYPE(output) != T_ARRAY) {\ rb_raise(rb_eTypeError, "array key at:%ld conflicts with hash", i + 1);\ } # define CHECK_NEXT \ if (next_is_hash_key) {\ ASSERT_HASH;\ } else {\ ASSERT_ARRAY;\ } // special treatment to array keys according to last 2 segments: // *[][foo] append new hash if already exists // // normal cases: // *[] just push // *[foo] find last elem first // *[]* find last elem first // middle key segs for (long i = 0; i < len - 1; i++) { bool next_is_hash_key = RSTRING_LEN(arr[i + 1]); if (is_hash_key) { if (nyara_rb_hash_has_key(output, arr[i])) { output = rb_hash_aref(output, arr[i]); CHECK_NEXT; } else { NEW_CHILD(child); rb_hash_aset(output, arr[i], child); output = child; } } else { // array key, try to use the last elem long output_len = RARRAY_LEN(output); if (output_len) { bool append = false; if (i == len - 2 && next_is_hash_key) { volatile VALUE next_hash = RARRAY_PTR(output)[output_len - 1]; if (nyara_rb_hash_has_key(next_hash, arr[i + 1])) { append = true; } } if (append) { volatile VALUE child = rb_class_new_instance(0, NULL, klass); rb_ary_push(output, child); output = child; } else { output = RARRAY_PTR(output)[output_len - 1]; CHECK_NEXT; } } else { NEW_CHILD(child); rb_ary_push(output, child); output = child; } } is_hash_key = next_is_hash_key; } # undef CHECK_NEXT # undef ASSERT_ARRAY # undef ASSERT_HASH # undef NEW_CHILD // terminate seg if (is_hash_key) { rb_hash_aset(output, arr[len - 1], value); } else { rb_ary_push(output, value); } }
/* CHANGED */ void wsf_util_create_op_and_add_to_svc ( wsf_svc_info_t * svc_info, char *action, axutil_env_t * env, char *op_name, VALUE ht_mep) { axis2_svc_t *svc = NULL; axis2_op_t *op = NULL; axutil_qname_t *op_qname = NULL; op_qname = axutil_qname_create (env, op_name, NULL, NULL); svc = svc_info->svc; if (NULL != svc && NULL != op_name) { op = axis2_svc_get_op_with_name (svc_info->svc, env, op_name); if (!op) { axis2_conf_t *conf = NULL; axis2_conf_ctx_t *conf_ctx = NULL; axis2_phases_info_t *info = NULL; op_qname = axutil_qname_create (env, op_name, NULL, NULL); op = axis2_op_create_with_qname (env, op_qname); axis2_op_set_msg_recv (op, env, svc_info->msg_recv); conf_ctx = wsf_worker_get_conf_ctx (svc_info->ruby_worker, env); conf = axis2_conf_ctx_get_conf (conf_ctx, env); info = axis2_conf_get_phases_info (conf, env); axis2_phases_info_set_op_phases (info, env, op); axis2_svc_add_op (svc_info->svc, env, op); if (ht_mep) { char operation[300]; VALUE mep_value; char *mep; AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_service] ht mep not null, %s", op_name); snprintf (operation, sizeof(operation), "%s", op_name); if(TYPE(ht_mep) == T_HASH) { mep_value = rb_hash_aref(ht_mep, ID2SYM(rb_intern(operation))); } if(mep_value != Qnil) { mep = RSTRING(mep_value)->ptr; if (mep) { AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_service] op mep %s", mep); if (strcmp (mep, "IN_ONLY") == 0) { axis2_op_set_msg_exchange_pattern (op, env, AXIS2_MEP_URI_IN_ONLY); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_service] AXIS2_MEP_URI_IN_ONLY"); } else if (strcmp (mep, "IN_OUT") == 0) { axis2_op_set_msg_exchange_pattern (op, env, AXIS2_MEP_URI_IN_OUT); AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf_service] AXIS2_MEP_URI_IN_OUT"); } } } else { AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI, "[wsf service] message exchange pattern for %s not found", op_name); } } if (action) { axis2_svc_add_mapping (svc_info->svc, env, action, op); } } } if(op_qname) { axutil_qname_free(op_qname, env); } return; }
static VALUE header_hash_aref(VALUE self, VALUE key) { return rb_hash_aref(self, header_hash_tidy_key(key)); }
/* * Initialize new CouchRequest * * @since 1.2.0 * * @return [Bucket::CouchRequest] */ VALUE cb_http_request_init(int argc, VALUE *argv, VALUE self) { struct cb_http_request_st *request = DATA_PTR(self); VALUE bucket, path, opts, on_body, pp, arg; rb_scan_args(argc, argv, "22", &bucket, &pp, &opts, &on_body); if (NIL_P(on_body) && rb_block_given_p()) { on_body = rb_block_proc(); } if (CLASS_OF(bucket) != cb_cBucket) { rb_raise(rb_eTypeError, "wrong argument type (expected Couchbase::Bucket)"); } memset(&request->cmd, 0, sizeof(lcb_http_cmd_t)); request->type = LCB_HTTP_TYPE_VIEW; request->on_body_callback = on_body; request->bucket = DATA_PTR(bucket); request->bucket_obj = bucket; request->extended = Qfalse; path = StringValue(pp); /* convert path to string */ request->cmd.v.v0.path = strdup(RSTRING_PTR(path)); request->cmd.v.v0.npath = RSTRING_LEN(path); request->cmd.v.v0.method = LCB_HTTP_METHOD_GET; request->cmd.v.v0.content_type = strdup("application/json"); if (opts != Qnil) { Check_Type(opts, T_HASH); request->extended = RTEST(rb_hash_aref(opts, cb_sym_extended)); request->cmd.v.v0.chunked = RTEST(rb_hash_aref(opts, cb_sym_chunked)); if ((arg = rb_hash_aref(opts, cb_sym_type)) != Qnil) { if (arg == cb_sym_view) { request->type = LCB_HTTP_TYPE_VIEW; } else if (arg == cb_sym_management) { request->type = LCB_HTTP_TYPE_MANAGEMENT; } else { rb_raise(rb_eArgError, "unsupported request type"); } } if ((arg = rb_hash_aref(opts, cb_sym_method)) != Qnil) { if (arg == cb_sym_get) { request->cmd.v.v0.method = LCB_HTTP_METHOD_GET; } else if (arg == cb_sym_post) { request->cmd.v.v0.method = LCB_HTTP_METHOD_POST; } else if (arg == cb_sym_put) { request->cmd.v.v0.method = LCB_HTTP_METHOD_PUT; } else if (arg == cb_sym_delete) { request->cmd.v.v0.method = LCB_HTTP_METHOD_DELETE; } else { rb_raise(rb_eArgError, "unsupported HTTP method"); } } if ((arg = rb_hash_aref(opts, cb_sym_body)) != Qnil) { Check_Type(arg, T_STRING); request->cmd.v.v0.body = strdup(RSTRING_PTR(arg)); request->cmd.v.v0.nbody = RSTRING_LEN(arg); } if ((arg = rb_hash_aref(opts, cb_sym_content_type)) != Qnil) { Check_Type(arg, T_STRING); free((char *)request->cmd.v.v0.content_type); request->cmd.v.v0.content_type = strdup(RSTRING_PTR(arg)); } } return self; }