// ---------------------------------------------------------------------------------- // // getting record for specifed key // read all bins of record or given in specific_bins argument // // def get(key, specific_bins = nil, options = {}) // // params: // keys - Array of AerospikeC::Key objects // specific bins - Array of strings representing bin names // options - hash of options: // with_header: returns also generation and expire_in field (default: false) // policy: AerospikeC::Policy for read // // ------ // RETURN: // 1. hash representing record // 2. nil when AEROSPIKE_ERR_RECORD_NOT_FOUND // static VALUE get(int argc, VALUE * argv, VALUE self) { rb_aero_TIMED(tm); as_error err; as_status status; aerospike * as = rb_aero_CLIENT; as_record * rec = NULL; VALUE bins; VALUE key; VALUE specific_bins; VALUE options; rb_scan_args(argc, argv, "12", &key, &specific_bins, &options); // default values for optional arguments if ( NIL_P(specific_bins) ) specific_bins = Qnil; if ( NIL_P(options) ) { options = rb_hash_new(); rb_hash_aset(options, with_header_sym, Qfalse); } as_key * k = rb_aero_KEY; as_policy_read * policy = get_policy(options); // read specific bins if ( specific_bins != Qnil && rb_ary_len_int(specific_bins) > 0 ) { if ( TYPE(specific_bins) != T_ARRAY ) { rb_raise(rb_aero_OptionError, "[AerospikeC::Client][get] specific_bins must be an Array"); } char ** inputArray = rb_array2inputArray(specific_bins); // convert ruby array to char ** if ( ( status = aerospike_key_select(as, &err, policy, k, inputArray, &rec) ) != AEROSPIKE_OK) { as_record_destroy(rec); inputArray_destroy(inputArray); if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) { rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 2, rb_str_new2("[Client][get] AEROSPIKE_ERR_RECORD_NOT_FOUND"), rb_aero_KEY_INFO); return Qnil; } raise_as_error(err); } bins = record2hash(rec); bins = check_with_header(bins, options, rec); as_record_destroy(rec); inputArray_destroy(inputArray); // check_for_llist_workaround(self, key, bins); rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 2, rb_str_new2("[Client][get] success"), rb_aero_KEY_INFO); return bins; } // read all bins if ( ( status = aerospike_key_get(as, &err, policy, k, &rec) ) != AEROSPIKE_OK) { as_record_destroy(rec); if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) { rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 2, rb_str_new2("[Client][get] AEROSPIKE_ERR_RECORD_NOT_FOUND"), rb_aero_KEY_INFO); return Qnil; } raise_as_error(err); } bins = record2hash(rec); bins = check_with_header(bins, options, rec); as_record_destroy(rec); // check_for_llist_workaround(self, key, bins); rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 2, rb_str_new2("[Client][get] success"), rb_aero_KEY_INFO); return bins; }
/** * This looks like a complicated scheme but there is a reason for * doing it this way. In MRI, rb_cObject, etc. are all global data. * We need to avoid global data to better support embedding and * other features like MVM. @see capi_get_constant(). */ std::string& capi_get_constant_name(int type) { static CApiConstantNameMap map; if(map.empty()) { map.resize(cCApiMaxConstant + 1); map[cCApiArray] = "Array"; map[cCApiBignum] = "Bignum"; map[cCApiClass] = "Class"; map[cCApiComparable] = "Comparable"; map[cCApiData] = "Data"; map[cCApiEnumerable] = "Enumerable"; map[cCApiFalse] = "FalseClass"; map[cCApiFile] = "File"; map[cCApiFixnum] = "Fixnum"; map[cCApiFloat] = "Float"; map[cCApiHash] = "Hash"; map[cCApiInteger] = "Integer"; map[cCApiIO] = "IO"; map[cCApiKernel] = "Kernel"; map[cCApiMatch] = "MatchData"; map[cCApiModule] = "Module"; map[cCApiNil] = "NilClass"; map[cCApiNumeric] = "Numeric"; map[cCApiObject] = "Object"; map[cCApiRange] = "Range"; map[cCApiRegexp] = "Regexp"; map[cCApiRubinius] = "Rubinius"; map[cCApiString] = "String"; map[cCApiStruct] = "Struct"; map[cCApiSymbol] = "Symbol"; map[cCApiThread] = "Thread"; map[cCApiTime] = "Time"; map[cCApiTrue] = "TrueClass"; map[cCApiProc] = "Proc"; map[cCApiGC] = "GC"; map[cCApiCAPI] = "Rubinius::CAPI"; map[cCApiMethod] = "Method"; map[cCApiArgumentError] = "ArgumentError"; map[cCApiEOFError] = "EOFError"; map[cCApiErrno] = "Errno"; map[cCApiException] = "Exception"; map[cCApiFatal] = "FatalError"; map[cCApiFloatDomainError] = "FloatDomainError"; map[cCApiIndexError] = "IndexError"; map[cCApiInterrupt] = "Interrupt"; map[cCApiIOError] = "IOError"; map[cCApiLoadError] = "LoadError"; map[cCApiLocalJumpError] = "LocalJumpError"; map[cCApiNameError] = "NameError"; map[cCApiNoMemoryError] = "NoMemoryError"; map[cCApiNoMethodError] = "NoMethodError"; map[cCApiNotImplementedError] = "NotImplementedError"; map[cCApiRangeError] = "RangeError"; map[cCApiRegexpError] = "RegexpError"; map[cCApiRuntimeError] = "RuntimeError"; map[cCApiScriptError] = "ScriptError"; map[cCApiSecurityError] = "SecurityError"; map[cCApiSignalException] = "SignalException"; map[cCApiStandardError] = "StandardError"; map[cCApiSyntaxError] = "SyntaxError"; map[cCApiSystemCallError] = "SystemCallError"; map[cCApiSystemExit] = "SystemExit"; map[cCApiSystemStackError] = "SystemStackError"; map[cCApiTypeError] = "TypeError"; map[cCApiThreadError] = "ThreadError"; map[cCApiZeroDivisionError] = "ZeroDivisionError"; } if(type < 0 || type >= cCApiMaxConstant) { NativeMethodEnvironment* env = NativeMethodEnvironment::get(); rb_raise(env->get_handle(env->state()->globals().exception.get()), "C-API: invalid constant index"); } return map[type]; }
static void append_action( openflow_actions *actions, VALUE action ) { if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::Enqueue" ) ) == Qtrue ) { uint32_t queue_id = ( uint32_t ) NUM2UINT( rb_funcall( action, rb_intern( "queue_id" ), 0 ) ); uint16_t port_number = ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "port_number" ), 0 ) ); append_action_enqueue( actions, port_number, queue_id ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SendOutPort" ) ) == Qtrue ) { uint16_t port_number = ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "port_number" ), 0 ) ); uint16_t max_len = ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "max_len" ), 0 ) ); append_action_output( actions, port_number, max_len ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetEthDstAddr" ) ) == Qtrue ) { uint8_t dl_dst[ OFP_ETH_ALEN ]; uint8_t *ptr = ( uint8_t * ) dl_addr_to_a( rb_funcall( action, rb_intern( "mac_address" ), 0 ), dl_dst ); append_action_set_dl_dst( actions, ptr ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetEthSrcAddr" ) ) == Qtrue ) { uint8_t dl_src[ OFP_ETH_ALEN ]; uint8_t *ptr = ( uint8_t * ) dl_addr_to_a( rb_funcall( action, rb_intern( "mac_address" ), 0 ), dl_src ); append_action_set_dl_src( actions, ptr ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetIpDstAddr" ) ) == Qtrue ) { append_action_set_nw_dst( actions, nw_addr_to_i( rb_funcall( action, rb_intern( "ip_address" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetIpSrcAddr" ) ) == Qtrue ) { append_action_set_nw_src( actions, nw_addr_to_i( rb_funcall( action, rb_intern( "ip_address" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetIpTos" ) ) == Qtrue ) { append_action_set_nw_tos( actions, ( uint8_t ) NUM2UINT( rb_funcall( action, rb_intern( "type_of_service" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetTransportDstPort" ) ) == Qtrue ) { append_action_set_tp_dst( actions, ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "port_number" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetTransportSrcPort" ) ) == Qtrue ) { append_action_set_tp_src( actions, ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "port_number" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetVlanPriority" ) ) == Qtrue ) { append_action_set_vlan_pcp( actions, ( uint8_t ) NUM2UINT( rb_funcall( action, rb_intern( "vlan_priority" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::SetVlanVid" ) ) == Qtrue ) { append_action_set_vlan_vid( actions, ( uint16_t ) NUM2UINT( rb_funcall( action, rb_intern( "vlan_id" ), 0 ) ) ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::StripVlanHeader" ) ) == Qtrue ) { append_action_strip_vlan( actions ); } else if ( rb_funcall( action, rb_intern( "is_a?" ), 1, rb_path2class( "Trema::VendorAction" ) ) == Qtrue ) { VALUE vendor_id = rb_funcall( action, rb_intern( "vendor_id" ), 0 ); VALUE rbody = rb_funcall( action, rb_intern( "body" ), 0 ); if ( rbody != Qnil ) { Check_Type( rbody, T_ARRAY ); uint16_t length = ( uint16_t ) RARRAY_LEN( rbody ); buffer *body = alloc_buffer_with_length( length ); void *p = append_back_buffer( body, length ); for ( int i = 0; i < length; i++ ) { ( ( uint8_t * ) p )[ i ] = ( uint8_t ) FIX2INT( RARRAY_PTR( rbody )[ i ] ); } append_action_vendor( actions, ( uint32_t ) NUM2UINT( vendor_id ), body ); free_buffer( body ); } else { append_action_vendor( actions, ( uint32_t ) NUM2UINT( vendor_id ), NULL ); } } else { rb_raise( rb_eTypeError, "actions argument must be an Array of Action objects" ); } }
/* * call-seq: * parser.parse(yaml) * * Parse the YAML document contained in +yaml+. Events will be called on * the handler set on the parser instance. * * See Psych::Parser and Psych::Parser#handler */ static VALUE parse(VALUE self, VALUE yaml) { yaml_parser_t * parser; yaml_event_t event; int done = 0; #ifdef HAVE_RUBY_ENCODING_H int encoding = rb_utf8_encindex(); rb_encoding * internal_enc = rb_default_internal_encoding(); #endif VALUE handler = rb_iv_get(self, "@handler"); Data_Get_Struct(self, yaml_parser_t, parser); if(rb_respond_to(yaml, id_read)) { yaml_parser_set_input(parser, io_reader, (void *)yaml); } else { StringValue(yaml); yaml_parser_set_input_string( parser, (const unsigned char *)RSTRING_PTR(yaml), (size_t)RSTRING_LEN(yaml) ); } while(!done) { if(!yaml_parser_parse(parser, &event)) { size_t line = parser->mark.line; size_t column = parser->mark.column; rb_raise(ePsychSyntaxError, "couldn't parse YAML at line %d column %d", (int)line, (int)column); } switch(event.type) { case YAML_STREAM_START_EVENT: rb_funcall(handler, id_start_stream, 1, INT2NUM((long)event.data.stream_start.encoding) ); break; case YAML_DOCUMENT_START_EVENT: { /* Get a list of tag directives (if any) */ VALUE tag_directives = rb_ary_new(); /* Grab the document version */ VALUE version = event.data.document_start.version_directive ? rb_ary_new3( (long)2, INT2NUM((long)event.data.document_start.version_directive->major), INT2NUM((long)event.data.document_start.version_directive->minor) ) : rb_ary_new(); if(event.data.document_start.tag_directives.start) { yaml_tag_directive_t *start = event.data.document_start.tag_directives.start; yaml_tag_directive_t *end = event.data.document_start.tag_directives.end; for(; start != end; start++) { VALUE handle = Qnil; VALUE prefix = Qnil; if(start->handle) { handle = rb_str_new2((const char *)start->handle); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(handle, encoding, internal_enc); #endif } if(start->prefix) { prefix = rb_str_new2((const char *)start->prefix); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(prefix, encoding, internal_enc); #endif } rb_ary_push(tag_directives, rb_ary_new3((long)2, handle, prefix)); } } rb_funcall(handler, id_start_document, 3, version, tag_directives, event.data.document_start.implicit == 1 ? Qtrue : Qfalse ); } break; case YAML_DOCUMENT_END_EVENT: rb_funcall(handler, id_end_document, 1, event.data.document_end.implicit == 1 ? Qtrue : Qfalse ); break; case YAML_ALIAS_EVENT: { VALUE alias = Qnil; if(event.data.alias.anchor) { alias = rb_str_new2((const char *)event.data.alias.anchor); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(alias, encoding, internal_enc); #endif } rb_funcall(handler, id_alias, 1, alias); } break; case YAML_SCALAR_EVENT: { VALUE anchor = Qnil; VALUE tag = Qnil; VALUE plain_implicit, quoted_implicit, style; VALUE val = rb_str_new( (const char *)event.data.scalar.value, (long)event.data.scalar.length ); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(val, encoding, internal_enc); #endif if(event.data.scalar.anchor) { anchor = rb_str_new2((const char *)event.data.scalar.anchor); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(anchor, encoding, internal_enc); #endif } if(event.data.scalar.tag) { tag = rb_str_new2((const char *)event.data.scalar.tag); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(tag, encoding, internal_enc); #endif } plain_implicit = event.data.scalar.plain_implicit == 0 ? Qfalse : Qtrue; quoted_implicit = event.data.scalar.quoted_implicit == 0 ? Qfalse : Qtrue; style = INT2NUM((long)event.data.scalar.style); rb_funcall(handler, id_scalar, 6, val, anchor, tag, plain_implicit, quoted_implicit, style); } break; case YAML_SEQUENCE_START_EVENT: { VALUE anchor = Qnil; VALUE tag = Qnil; VALUE implicit, style; if(event.data.sequence_start.anchor) { anchor = rb_str_new2((const char *)event.data.sequence_start.anchor); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(anchor, encoding, internal_enc); #endif } tag = Qnil; if(event.data.sequence_start.tag) { tag = rb_str_new2((const char *)event.data.sequence_start.tag); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(tag, encoding, internal_enc); #endif } implicit = event.data.sequence_start.implicit == 0 ? Qfalse : Qtrue; style = INT2NUM((long)event.data.sequence_start.style); rb_funcall(handler, id_start_sequence, 4, anchor, tag, implicit, style); } break; case YAML_SEQUENCE_END_EVENT: rb_funcall(handler, id_end_sequence, 0); break; case YAML_MAPPING_START_EVENT: { VALUE anchor = Qnil; VALUE tag = Qnil; VALUE implicit, style; if(event.data.mapping_start.anchor) { anchor = rb_str_new2((const char *)event.data.mapping_start.anchor); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(anchor, encoding, internal_enc); #endif } if(event.data.mapping_start.tag) { tag = rb_str_new2((const char *)event.data.mapping_start.tag); #ifdef HAVE_RUBY_ENCODING_H PSYCH_TRANSCODE(tag, encoding, internal_enc); #endif } implicit = event.data.mapping_start.implicit == 0 ? Qfalse : Qtrue; style = INT2NUM((long)event.data.mapping_start.style); rb_funcall(handler, id_start_mapping, 4, anchor, tag, implicit, style); } break; case YAML_MAPPING_END_EVENT: rb_funcall(handler, id_end_mapping, 0); break; case YAML_NO_EVENT: rb_funcall(handler, id_empty, 0); break; case YAML_STREAM_END_EVENT: rb_funcall(handler, id_end_stream, 0); done = 1; break; } } return self; }
/* call-seq: stmt.bind_param(key, value) * * Binds value to the named (or positional) placeholder. If +param+ is a * Fixnum, it is treated as an index for a positional placeholder. * Otherwise it is used as the name of the placeholder to bind to. * * See also #bind_params. */ static VALUE bind_param(VALUE self, VALUE key, VALUE value) { sqlite3StmtRubyPtr ctx; int status; int index; Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); switch(TYPE(key)) { case T_SYMBOL: key = rb_funcall(key, rb_intern("to_s"), 0); case T_STRING: if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key); index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key)); break; default: index = (int)NUM2INT(key); } if(index == 0) rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter"); switch(TYPE(value)) { case T_STRING: if(CLASS_OF(value) == cSqlite3Blob #ifdef HAVE_RUBY_ENCODING_H || rb_enc_get_index(value) == rb_ascii8bit_encindex() #endif ) { status = sqlite3_bind_blob( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } else { #ifdef HAVE_RUBY_ENCODING_H if(!UTF8_P(value)) { VALUE db = rb_iv_get(self, "@connection"); VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0); rb_encoding * enc = rb_to_encoding(encoding); value = rb_str_export_to_enc(value, enc); } #endif status = sqlite3_bind_text( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } break; case T_BIGNUM: #if SIZEOF_LONG < 8 if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) { status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value)); break; } #endif case T_FLOAT: status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value)); break; case T_FIXNUM: status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value)); break; case T_NIL: status = sqlite3_bind_null(ctx->st, index); break; default: rb_raise(rb_eRuntimeError, "can't prepare %s", rb_class2name(CLASS_OF(value))); break; } CHECK(sqlite3_db_handle(ctx->st), status); return self; }
static inline VALUE call_cfunc(VALUE (*func)(), VALUE recv, int len, int argc, const VALUE *argv) { /* printf("len: %d, argc: %d\n", len, argc); */ if (len >= 0 && argc != len) { rb_raise(rb_eArgError, "wrong number of arguments(%d for %d)", argc, len); } switch (len) { case -2: return (*func) (recv, rb_ary_new4(argc, argv)); break; case -1: return (*func) (argc, argv, recv); break; case 0: return (*func) (recv); break; case 1: return (*func) (recv, argv[0]); break; case 2: return (*func) (recv, argv[0], argv[1]); break; case 3: return (*func) (recv, argv[0], argv[1], argv[2]); break; case 4: return (*func) (recv, argv[0], argv[1], argv[2], argv[3]); break; case 5: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4]); break; case 6: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); break; case 7: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); break; case 8: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]); break; case 9: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]); break; case 10: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]); break; case 11: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]); break; case 12: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]); break; case 13: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]); break; case 14: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]); break; case 15: return (*func) (recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]); break; default: rb_raise(rb_eArgError, "too many arguments(%d)", len); return Qundef; /* not reached */ } }
VALUE xmlsec_is_valid_by_x509_file(VALUE self, xmlDocPtr doc, VALUE x509_file ) { xmlSecKeysMngrPtr mngr; VALUE v; xmlNodePtr node = NULL; xmlSecDSigCtxPtr dsigCtx = NULL; long i; mngr = xmlSecKeysMngrCreate(); if(mngr == NULL) { if(doc != NULL) xmlFreeDoc(doc); rb_raise(rb_eRuntimeError, "Error: failed to create keys manager.\n"); return Qnil; } if(xmlSecCryptoAppDefaultKeysMngrInit(mngr) < 0) { if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); rb_raise(rb_eRuntimeError, "Error: failed to initialize keys manager.\n"); return Qnil; } if (TYPE(x509_file) == T_STRING){ /* load trusted cert */ if(xmlSecCryptoAppKeysMngrCertLoad(mngr, StringValuePtr(x509_file), xmlSecKeyDataFormatPem, xmlSecKeyDataTypeTrusted) < 0) { if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); rb_raise(rb_eRuntimeError, "Error: failed to load pem certificate from \"%s\"\n", StringValuePtr(x509_file)); return Qnil; } } if (TYPE(x509_file) == T_ARRAY) { for (i =0; i < RARRAY_LEN(x509_file); i++) { v = rb_ary_entry(x509_file, i); StringValue(v); if(xmlSecCryptoAppKeysMngrCertLoad(mngr, RSTRING_PTR(v), xmlSecKeyDataFormatPem, xmlSecKeyDataTypeTrusted) < 0) { if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); rb_raise(rb_eRuntimeError, "Error: failed to load pem certificate from \"%s\"\n", RSTRING_PTR(v)); return Qnil; } } //rb_ary_entry } /* find start node */ node = xmlSecFindNode(xmlDocGetRootElement(doc), xmlSecNodeSignature, xmlSecDSigNs); if(node == NULL) { if(doc != NULL) xmlFreeDoc(doc); rb_raise(rb_eRuntimeError, "Error: start node not found\n"); return Qnil; } /* create signature context*/ dsigCtx = xmlSecDSigCtxCreate(mngr); if(dsigCtx == NULL) { if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); rb_raise(rb_eRuntimeError, "Error: failed to create signature context\n"); return Qnil; } /* limit the Reference URI attributes to empty or NULL */ dsigCtx->enabledReferenceUris = xmlSecTransformUriTypeEmpty; /* Verify signature */ if(xmlSecDSigCtxVerify(dsigCtx, node) < 0) { if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx); if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); rb_raise(rb_eRuntimeError, "Error: signature verify \"%s\"\n"); return Qnil; } /* verification result*/ if(dsigCtx->status == xmlSecDSigStatusSucceeded) { if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx); if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); return Qtrue; } else { if(dsigCtx != NULL) xmlSecDSigCtxDestroy(dsigCtx); if(doc != NULL) xmlFreeDoc(doc); if(mngr != NULL) xmlSecKeysMngrDestroy(mngr); return Qfalse; } }
/* Init func that fails by raising an exception. */ VALUE grpc_rb_cannot_init(VALUE self) { rb_raise(rb_eTypeError, "initialization of %s only allowed from the gRPC native layer", rb_obj_classname(self)); return Qnil; }
static VALUE rb_gsl_linalg_complex_LU_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_vector_complex *b = NULL, *x = NULL; int flagm = 0, flagx = 0, itmp, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2 || argc > 4) rb_raise(rb_eArgError, "Usage: solve(m, b), solve(m, b, x), solve(lu, p, b), solve(lu, p, b, x)"); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 1; break; default: if (argc < 1 || argc > 3) rb_raise(rb_eArgError, "Usage: LU_solve(b), LU_solve(p, b), LU_solve(b, x), solve(p, b, x)"); Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 0; } if (flagm == 1) { if (itmp != argc-1) rb_raise(rb_eArgError, "Usage: m.LU_solve(b)"); Data_Get_Struct(argv[itmp], gsl_vector_complex, b); x = gsl_vector_complex_alloc(b->size); p = gsl_permutation_alloc(b->size); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); itmp++; Data_Get_Struct(argv[itmp], gsl_vector_complex, b); itmp++; if (itmp == argc-1) { Data_Get_Struct(argv[itmp], gsl_vector_complex, x); flagx = 1; } else { x = gsl_vector_complex_alloc(m->size1); } } gsl_linalg_complex_LU_solve(mtmp, p, b, x); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } if (flagx == 0) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, x); else return argv[argc-1]; }
/** * grpc_rb_time_timeval creates a timeval from a ruby time object. * * This func is copied from ruby source, MRI/source/time.c, which is published * under the same license as the ruby.h, on which the entire extensions is * based. */ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) { gpr_timespec t; gpr_timespec *time_const; const char *tstr = interval ? "time interval" : "time"; const char *want = " want <secs from epoch>|<Time>|<GRPC::TimeConst.*>"; t.clock_type = GPR_CLOCK_REALTIME; switch (TYPE(time)) { case T_DATA: if (CLASS_OF(time) == grpc_rb_cTimeVal) { TypedData_Get_Struct(time, gpr_timespec, &grpc_rb_timespec_data_type, time_const); t = *time_const; } else if (CLASS_OF(time) == rb_cTime) { t.tv_sec = NUM2INT(rb_funcall(time, id_tv_sec, 0)); t.tv_nsec = NUM2INT(rb_funcall(time, id_tv_nsec, 0)); } else { rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr, rb_obj_classname(time), want); } break; case T_FIXNUM: t.tv_sec = FIX2LONG(time); if (interval && t.tv_sec < 0) rb_raise(rb_eArgError, "%s must be positive", tstr); t.tv_nsec = 0; break; case T_FLOAT: if (interval && RFLOAT_VALUE(time) < 0.0) rb_raise(rb_eArgError, "%s must be positive", tstr); else { double f, d; d = modf(RFLOAT_VALUE(time), &f); if (d < 0) { d += 1; f -= 1; } t.tv_sec = (int64_t)f; if (f != t.tv_sec) { rb_raise(rb_eRangeError, "%f out of Time range", RFLOAT_VALUE(time)); } t.tv_nsec = (int)(d * 1e9 + 0.5); } break; case T_BIGNUM: t.tv_sec = NUM2LONG(time); if (interval && t.tv_sec < 0) rb_raise(rb_eArgError, "%s must be positive", tstr); t.tv_nsec = 0; break; default: rb_raise(rb_eTypeError, "bad input: (%s)->c_timeval, got <%s>,%s", tstr, rb_obj_classname(time), want); break; } return t; }
/* Alloc func that blocks allocation of a given object by raising an * exception. */ VALUE grpc_rb_cannot_alloc(VALUE cls) { rb_raise(rb_eTypeError, "allocation of %s only allowed from the gRPC native layer", rb_class2name(cls)); return Qnil; }
/* Converts string to a JSON string in FBuffer buffer, where all but the ASCII * and control characters are JSON escaped. */ static void convert_UTF8_to_JSON_ASCII(FBuffer *buffer, VALUE string) { const UTF8 *source = (UTF8 *) RSTRING_PTR(string); const UTF8 *sourceEnd = source + RSTRING_LEN(string); char buf[6] = { '\\', 'u' }; while (source < sourceEnd) { UTF32 ch = 0; unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; if (source + extraBytesToRead >= sourceEnd) { rb_raise(rb_path2class("JSON::GeneratorError"), "partial character in source, but hit end"); } if (!isLegalUTF8(source, extraBytesToRead+1)) { rb_raise(rb_path2class("JSON::GeneratorError"), "source sequence is illegal/malformed utf-8"); } /* * The cases all fall through. See "Note A" below. */ switch (extraBytesToRead) { case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ case 3: ch += *source++; ch <<= 6; case 2: ch += *source++; ch <<= 6; case 1: ch += *source++; ch <<= 6; case 0: ch += *source++; } ch -= offsetsFromUTF8[extraBytesToRead]; if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */ /* UTF-16 surrogate values are illegal in UTF-32 */ if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { #if UNI_STRICT_CONVERSION source -= (extraBytesToRead+1); /* return to the illegal value itself */ rb_raise(rb_path2class("JSON::GeneratorError"), "source sequence is illegal/malformed utf-8"); #else unicode_escape_to_buffer(buffer, buf, UNI_REPLACEMENT_CHAR); #endif } else { /* normal case */ if (ch >= 0x20 && ch <= 0x7f) { switch (ch) { case '\\': fbuffer_append(buffer, "\\\\", 2); break; case '"': fbuffer_append(buffer, "\\\"", 2); break; default: fbuffer_append_char(buffer, (char)ch); break; } } else { switch (ch) { case '\n': fbuffer_append(buffer, "\\n", 2); break; case '\r': fbuffer_append(buffer, "\\r", 2); break; case '\t': fbuffer_append(buffer, "\\t", 2); break; case '\f': fbuffer_append(buffer, "\\f", 2); break; case '\b': fbuffer_append(buffer, "\\b", 2); break; default: unicode_escape_to_buffer(buffer, buf, (UTF16) ch); break; } } } } else if (ch > UNI_MAX_UTF16) { #if UNI_STRICT_CONVERSION source -= (extraBytesToRead+1); /* return to the start */ rb_raise(rb_path2class("JSON::GeneratorError"), "source sequence is illegal/malformed utf8"); #else unicode_escape_to_buffer(buffer, buf, UNI_REPLACEMENT_CHAR); #endif } else { /* target is a character in range 0xFFFF - 0x10FFFF. */ ch -= halfBase; unicode_escape_to_buffer(buffer, buf, (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START)); unicode_escape_to_buffer(buffer, buf, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START)); } } }
/** * arguments: * - Plm_array(x) : lmax = w->lmax, A new vector is created * - Plm_array(x, result) : lmax = w->lmax, the given vector is used * - Plm_array(lmax, x) : A new vector is created * - Plm_array(lmax, x, result) : Same as C Plm_array() * - Plm_array(x, result, deriv) : lmax = w->lmax, calcurate Plm_deriv_array(lmax, x, result, deriv) * - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array */ static VALUE rb_alf_Plm_array(int argc, VALUE *argv, VALUE obj) { alf_workspace *w = NULL; gsl_vector *res = NULL, *deriv = NULL; int lmax; double x; VALUE ret; Data_Get_Struct(obj, alf_workspace, w); switch (argc) { case 1: x = NUM2DBL(argv[0]); lmax = w->lmax; res = gsl_vector_alloc(alf_array_size(lmax)); ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); break; case 2: // Plm_array(x, result) or Plm_array(lmax, x) if (VECTOR_P(argv[1])) { x = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, res); lmax = w->lmax; if (res->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } ret = argv[1]; } else { lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); res = gsl_vector_alloc(alf_array_size(lmax)); ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); } break; case 3: // Plm_array(lmax, x, result) or Plm_array(x, result, deriv) if (VECTOR_P(argv[1])) { CHECK_VECTOR(argv[2]); lmax = w->lmax; x = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, res); Data_Get_Struct(argv[2], gsl_vector, deriv); ret = argv[1]; } else { lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, res); if (res->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } ret = argv[2]; } break; case 4: CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3]) lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, res); Data_Get_Struct(argv[3], gsl_vector, deriv); ret = argv[2]; break; default: rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-3)\n", argc); } if (argc == 4 && deriv != NULL) alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w); else alf_Plm_array(lmax, x, res->data, w); return ret; }
// ---------------------------------------------------------------------------------- // // getting batch of records in one call // batch size is limited on aerospike server (default: 5000) // // def batch_get(keys, specific_bins = nil, options = {}) // // params: // keys - Array of AerospikeC::Key objects // specific bins - Array of strings representing bin names // options - hash of options: // with_header: returns also generation and expire_in field (default: false) // // ------ // RETURN: Array of hashes where each hash represents record bins // // @TODO options policy // static VALUE batch_get(int argc, VALUE * argv, VALUE self) { rb_aero_TIMED(tm); as_error err; as_status status; aerospike * as = rb_aero_CLIENT; char ** bin_names; long n_bin_names; VALUE keys; VALUE specific_bins; VALUE options; rb_scan_args(argc, argv, "12", &keys, &specific_bins, &options); // default values for optional arguments if ( NIL_P(specific_bins) ) { specific_bins = Qnil; } else { if ( TYPE(specific_bins) != T_ARRAY ) rb_raise(rb_aero_OptionError, "[AerospikeC::Client][batch_get] specific_bins must be an Array"); bin_names = rb_array2bin_names(specific_bins); n_bin_names = rb_ary_len_long(specific_bins); } if ( NIL_P(options) ) { options = rb_hash_new(); rb_hash_aset(options, with_header_sym, Qfalse); } long keys_len = rb_ary_len_long(keys); VALUE records_bins = rb_ary_new(); as_batch_read_records records; as_batch_read_inita(&records, keys_len); // map array into as_batch_read_record * record for (int i = 0; i < keys_len; ++i) { VALUE element = rb_ary_entry(keys, i); VALUE tmp; tmp = rb_funcall(element, rb_intern("namespace"), 0); char * c_namespace = StringValueCStr( tmp ); tmp = rb_funcall(element, rb_intern("set"), 0); char * c_set = StringValueCStr( tmp ); as_batch_read_record * record = as_batch_read_reserve(&records); tmp = rb_funcall(element, rb_intern("key"), 0); if ( TYPE(tmp) != T_FIXNUM ) { char * c_key = StringValueCStr( tmp ); as_key_init(&record->key, c_namespace, c_set, c_key); } else { as_key_init_int64(&record->key, c_namespace, c_set, FIX2LONG(tmp)); } if ( specific_bins == Qnil ) { record->read_all_bins = true; } else { record->bin_names = bin_names; record->n_bin_names = n_bin_names; } } // read here! if ( ( status = aerospike_batch_read(as, &err, NULL, &records) ) != AEROSPIKE_OK ) { if ( status == AEROSPIKE_ERR_RECORD_NOT_FOUND ) { rb_aero_logger(AS_LOG_LEVEL_WARN, &tm, 1, rb_str_new2("[Client][batch_get] AEROSPIKE_ERR_RECORD_NOT_FOUND")); return Qnil; } as_batch_read_destroy(&records); raise_as_error(err); } as_vector list = records.list; // map records into array of hashes for (long i = 0; i < list.size; ++i) { as_batch_read_record * record = as_vector_get(&list, i); as_record rec = record->record; VALUE bins = record2hash(&rec); bins = check_with_header(bins, options, &rec); rb_ary_push(records_bins, bins); } as_batch_read_destroy(&records); if ( specific_bins != Qnil ) bin_names_destroy(bin_names, n_bin_names); rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 1, rb_str_new2("[Client][batch_get] success")); return records_bins; }
VALUE require_compiled(VALUE fname, VALUE* result, int bLoad) { VALUE path; char* szName1 = 0; char* la = 0; VALUE retval = Qtrue; if (TYPE(fname) != T_STRING) rb_raise(rb_eLoadError, "can not load non-string"); szName1 = RSTRING_PTR(fname); if ( String_endsWith(szName1,".rb") ) { rb_str_chop_bang(fname); rb_str_chop_bang(fname); rb_str_chop_bang(fname); } //rb_funcall(fname, rb_intern("sub!"), 2, rb_str_new2(".rb"), rb_str_new2("") ); szName1 = RSTRING_PTR(fname); if ( strcmp("strscan",szName1)==0 || strcmp("enumerator",szName1)==0 || strcmp("stringio",szName1)==0 || strcmp("socket",szName1)==0 ) return Qtrue; RHO_LOCK(require_lock); if ( !bLoad && isAlreadyLoaded(fname) == Qtrue ) goto RCompExit; path = find_file(fname); if ( path != 0 ) { VALUE seq; RAWLOG_INFO1("require_compiled: %s", szName1); //optimize require //rb_ary_push(GET_VM()->loaded_features, path); rb_ary_push(GET_VM()->loaded_features, fname); #ifdef RHODES_EMULATOR if ( strstr( RSTRING_PTR(path), ".rb") == 0 ) rb_str_cat(path,".rb",3); GET_VM()->src_encoding_index = rb_utf8_encindex(); rb_load(path, 0); if( rho_simconf_getBool("reload_app_changes") ) { if ( strncmp( RSTRING_PTR(path), rho_native_rhopath(), strlen(rho_native_rhopath()) ) == 0 ) rb_ary_delete(GET_VM()->loaded_features, fname); } #else //rb_gc_disable(); seq = loadISeqFromFile(path); //*result = rb_funcall(seq, rb_intern("eval"), 0 ); *result = rb_iseq_eval(seq); //rb_gc_enable(); #endif goto RCompExit; } RAWLOG_ERROR1("require_compiled: error: can not find %s", RSTRING_PTR(fname)); retval = Qnil; RCompExit: RHO_UNLOCK(require_lock); return retval; }
static VALUE rh_init(VALUE self) { SYBRESULT *sybres; int i, rc; VALUE aRow, allRows; char *mystring; int mystrlen; Data_Get_Struct(self, SYBRESULT, sybres); if(tds_submit_query(sybres->tds,sybres->sqlstring) != TDS_SUCCEED) { rb_raise(rb_eRuntimeError, "SQL-query failed (1)"); } else { /* Based on FreeTDS's src/tds/unittest/t0005.c */ allRows = rb_ary_new(); while ((rc=tds_process_result_tokens(sybres->tds))==TDS_SUCCEED) { while ((rc=tds_process_row_tokens(sybres->tds))==TDS_SUCCEED) { aRow = rb_ary_new(); for (i=0; i<sybres->tds->res_info->num_cols; i++) { /* We're calling calloc for every column in every row to get the memory for the string-conversion. There are probably faster ways... */ if(sybres->tds->res_info->columns[i]->column_textvalue) { mystrlen=(sybres->tds->res_info->columns[i]->column_textsize)+1; } else { mystrlen = 256; } mystring = calloc(1, mystrlen); if(mystring == NULL) { rb_raise(rb_eRuntimeError, "Couldn't malloc - out of memory? (1)"); } value_as_string(mystring, mystrlen, sybres->tds, i); rb_ary_push(aRow, rb_str_new2(mystring)); free(mystring); } rb_ary_push(allRows, aRow); } if (rc == TDS_FAIL) { rb_raise(rb_eRuntimeError, "tds_process_row_tokens() returned TDS_FAIL\n"); } else if (rc != TDS_NO_MORE_ROWS) { rb_raise(rb_eRuntimeError, "tds_process_row_tokens() unexpected return\n"); } } if (rc == TDS_FAIL) { rb_raise(rb_eRuntimeError, "tds_process_result_tokens() returned TDS_FAIL for SELECT\n"); return 1; } else if (rc != TDS_NO_MORE_RESULTS) { rb_raise(rb_eRuntimeError, "tds_process_result_tokens() unexpected return\n"); } } rb_iv_set(self, "@allRows", allRows); return self; } // rh_init
static inline int caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag, int argc, rb_iseq_t *blockiseq, rb_block_t **block) { rb_block_t *blockptr = 0; if (block) { if (flag & VM_CALL_ARGS_BLOCKARG_BIT) { rb_proc_t *po; VALUE proc; proc = *(--cfp->sp); if (proc != Qnil) { if (!rb_obj_is_proc(proc)) { VALUE b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc"); if (NIL_P(b) || !rb_obj_is_proc(b)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc)", rb_obj_classname(proc)); } proc = b; } GetProcPtr(proc, po); blockptr = &po->block; RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)->proc = proc; *block = blockptr; } } else if (blockiseq) { blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp); blockptr->iseq = blockiseq; blockptr->proc = 0; *block = blockptr; } } /* expand top of stack? */ if (flag & VM_CALL_ARGS_SPLAT_BIT) { VALUE ary = *(cfp->sp - 1); VALUE *ptr; int i; VALUE tmp = rb_check_convert_type(ary, T_ARRAY, "Array", "to_a"); if (NIL_P(tmp)) { /* do nothing */ } else { long len = RARRAY_LEN(tmp); ptr = RARRAY_PTR(tmp); cfp->sp -= 1; CHECK_STACK_OVERFLOW(cfp, len); for (i = 0; i < len; i++) { *cfp->sp++ = ptr[i]; } argc += i-1; } } return argc; }
static VALUE rb_gsl_cheb_eval_n_err(VALUE obj, VALUE nn, VALUE xx) { gsl_cheb_series *p = NULL; double result, err; VALUE x, ary, aerr; size_t n, order, i, j; gsl_vector *v, *vnew, *verr; gsl_matrix *m, *mnew, *merr; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2, *ptr3; #endif CHECK_FIXNUM(nn); order = FIX2INT(nn); Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: gsl_cheb_eval_n_err(p, order, NUM2DBL(xx), &result, &err); return rb_ary_new3(2, rb_float_new(result), rb_float_new(err)); break; case T_ARRAY: n = RARRAY(xx)->len; ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); gsl_cheb_eval_n_err(p, order, NUM2DBL(x), &result, &err); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(err)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); aerr = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); ptr3 = NA_PTR_TYPE(aerr,double*); for (i = 0; i < n; i++) { gsl_cheb_eval_n_err(p, order, ptr1[i], &result, &err); ptr2[i] = result; ptr3[i] = err; } return rb_ary_new3(2, ary, aerr); } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); verr = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_cheb_eval_n_err(p, order, gsl_vector_get(v, i), &result, &err); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, err); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr)); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); merr = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_cheb_eval_n_err(p, order, gsl_matrix_get(m, i, j), &result, &err); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, err); } } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr)); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ }
static inline VALUE vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp, int num, const rb_block_t *blockptr, VALUE flag, ID id, const rb_method_entry_t *me, VALUE recv) { VALUE val; start_method_dispatch: if (me != 0) { if ((me->flag == 0)) { normal_method_dispatch: switch (me->def->type) { case VM_METHOD_TYPE_ISEQ:{ vm_setup_method(th, cfp, recv, num, blockptr, flag, me); return Qundef; } case VM_METHOD_TYPE_NOTIMPLEMENTED: case VM_METHOD_TYPE_CFUNC:{ val = vm_call_cfunc(th, cfp, num, recv, blockptr, me); break; } case VM_METHOD_TYPE_ATTRSET:{ if (num != 1) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", num); } val = rb_ivar_set(recv, me->def->body.attr.id, *(cfp->sp - 1)); cfp->sp -= 2; break; } case VM_METHOD_TYPE_IVAR:{ if (num != 0) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", num); } val = rb_attr_get(recv, me->def->body.attr.id); cfp->sp -= 1; break; } case VM_METHOD_TYPE_MISSING:{ VALUE *argv = ALLOCA_N(VALUE, num+1); argv[0] = ID2SYM(me->def->original_id); MEMCPY(argv+1, cfp->sp - num, VALUE, num); cfp->sp += - num - 1; th->passed_block = blockptr; val = rb_funcall2(recv, rb_intern("method_missing"), num+1, argv); break; } case VM_METHOD_TYPE_BMETHOD:{ VALUE *argv = ALLOCA_N(VALUE, num); MEMCPY(argv, cfp->sp - num, VALUE, num); cfp->sp += - num - 1; val = vm_call_bmethod(th, recv, num, argv, blockptr, me); break; } case VM_METHOD_TYPE_ZSUPER:{ VALUE klass = RCLASS_SUPER(me->klass); me = rb_method_entry(klass, id); if (me != 0) { goto normal_method_dispatch; } else { goto start_method_dispatch; } } case VM_METHOD_TYPE_OPTIMIZED:{ switch (me->def->body.optimize_type) { case OPTIMIZED_METHOD_TYPE_SEND: { rb_control_frame_t *reg_cfp = cfp; rb_num_t i = num - 1; VALUE sym; if (num == 0) { rb_raise(rb_eArgError, "no method name given"); } sym = TOPN(i); id = SYMBOL_P(sym) ? SYM2ID(sym) : rb_to_id(sym); /* shift arguments */ if (i > 0) { MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i); } me = rb_method_entry(CLASS_OF(recv), id); num -= 1; DEC_SP(1); flag |= VM_CALL_FCALL_BIT | VM_CALL_OPT_SEND_BIT; goto start_method_dispatch; } case OPTIMIZED_METHOD_TYPE_CALL: { rb_proc_t *proc; int argc = num; VALUE *argv = ALLOCA_N(VALUE, num); GetProcPtr(recv, proc); MEMCPY(argv, cfp->sp - num, VALUE, num); cfp->sp -= num + 1; val = rb_vm_invoke_proc(th, proc, proc->block.self, argc, argv, blockptr); break; } default: rb_bug("eval_invoke_method: unsupported optimized method type (%d)", me->def->body.optimize_type); } break; } default:{ rb_bug("eval_invoke_method: unsupported method type (%d)", me->def->type); break; } } } else { int noex_safe; if (!(flag & VM_CALL_FCALL_BIT) && (me->flag & NOEX_MASK) & NOEX_PRIVATE) { int stat = NOEX_PRIVATE; if (flag & VM_CALL_VCALL_BIT) { stat |= NOEX_VCALL; } val = vm_method_missing(th, id, recv, num, blockptr, stat); } else if (!(flag & VM_CALL_OPT_SEND_BIT) && (me->flag & NOEX_MASK) & NOEX_PROTECTED) { VALUE defined_class = me->klass; if (RB_TYPE_P(defined_class, T_ICLASS)) { defined_class = RBASIC(defined_class)->klass; } if (!rb_obj_is_kind_of(cfp->self, defined_class)) { val = vm_method_missing(th, id, recv, num, blockptr, NOEX_PROTECTED); } else { goto normal_method_dispatch; } } else if ((noex_safe = NOEX_SAFE(me->flag)) > th->safe_level && (noex_safe > 2)) { rb_raise(rb_eSecurityError, "calling insecure method: %s", rb_id2name(id)); } else { goto normal_method_dispatch; } } } else { /* method missing */ int stat = 0; if (flag & VM_CALL_VCALL_BIT) { stat |= NOEX_VCALL; } if (flag & VM_CALL_SUPER_BIT) { stat |= NOEX_SUPER; } if (id == idMethodMissing) { VALUE *argv = ALLOCA_N(VALUE, num); vm_method_missing_args(th, argv, num - 1, 0, stat); rb_raise_method_missing(th, num, argv, recv, stat); } else { val = vm_method_missing(th, id, recv, num, blockptr, stat); } } RUBY_VM_CHECK_INTS(); return val; }
static VALUE rb_gsl_cheb_eval(VALUE obj, VALUE xx) { gsl_cheb_series *p = NULL; VALUE x, ary; size_t i, j, n; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(gsl_cheb_eval(p, NUM2DBL(xx))); break; case T_ARRAY: n = RARRAY(xx)->len; ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); rb_ary_store(ary, i, rb_float_new(gsl_cheb_eval(p, NUM2DBL(x)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); for (i = 0; i < n; i++) ptr2[i] = gsl_cheb_eval(p, ptr1[i]); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, gsl_cheb_eval(p, gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, gsl_cheb_eval(p, gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ }
int rb_scan_args(int argc, const VALUE *argv, const char *fmt, ...) { int i; const char *p = fmt; VALUE *var; va_list vargs; int f_var = 0, f_hash = 0, f_block = 0; int n_lead = 0, n_opt = 0, n_trail = 0, n_mand; int argi = 0; VALUE hash = Qnil; if (ISDIGIT(*p)) { n_lead = *p - '0'; p++; if (ISDIGIT(*p)) { n_opt = *p - '0'; p++; if (ISDIGIT(*p)) { n_trail = *p - '0'; p++; goto block_arg; } } } if (*p == '*') { f_var = 1; p++; if (ISDIGIT(*p)) { n_trail = *p - '0'; p++; } } block_arg: if (*p == ':') { f_hash = 1; p++; } if (*p == '&') { f_block = 1; p++; } if (*p != '\0') { rb_fatal("bad scan arg format: %s", fmt); } n_mand = n_lead + n_trail; if (argc < n_mand) goto argc_error; va_start(vargs, fmt); /* capture an option hash - phase 1: pop */ if (f_hash && n_mand < argc) { VALUE last = argv[argc - 1]; if (NIL_P(last)) { /* nil is taken as an empty option hash only if it is not ambiguous; i.e. '*' is not specified and arguments are given more than sufficient */ if (!f_var && n_mand + n_opt < argc) argc--; } else { hash = rb_check_convert_type(last, T_HASH, "Hash", "to_hash"); if (!NIL_P(hash)) argc--; } } /* capture leading mandatory arguments */ for (i = n_lead; i-- > 0; ) { var = va_arg(vargs, VALUE *); if (var) *var = argv[argi]; argi++; } /* capture optional arguments */ for (i = n_opt; i-- > 0; ) { var = va_arg(vargs, VALUE *); if (argi < argc - n_trail) { if (var) *var = argv[argi]; argi++; } else { if (var) *var = Qnil; } } /* capture variable length arguments */ if (f_var) { int n_var = argc - argi - n_trail; var = va_arg(vargs, VALUE *); if (0 < n_var) { if (var) *var = rb_ary_new4(n_var, &argv[argi]); argi += n_var; } else { if (var) *var = rb_ary_new(); } } /* capture trailing mandatory arguments */ for (i = n_trail; i-- > 0; ) { var = va_arg(vargs, VALUE *); if (var) *var = argv[argi]; argi++; } /* capture an option hash - phase 2: assignment */ if (f_hash) { var = va_arg(vargs, VALUE *); if (var) *var = hash; } /* capture iterator block */ if (f_block) { var = va_arg(vargs, VALUE *); if (rb_block_given_p()) { *var = rb_block_proc(); } else { *var = Qnil; } } va_end(vargs); if (argi < argc) goto argc_error; return argc; argc_error: if (0 < n_opt) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d..%d%s)", argc, n_mand, n_mand + n_opt, f_var ? "+" : ""); else rb_raise(rb_eArgError, "wrong number of arguments (%d for %d%s)", argc, n_mand, f_var ? "+" : ""); }
VALUE cIGraph_unavailable_method(int argc, VALUE *argv, VALUE self){ rb_raise(rb_eNoMethodError,"Method not available on OSX"); }
static VALUE step(VALUE self) { sqlite3StmtRubyPtr ctx; sqlite3_stmt *stmt; int value, length; VALUE list; #ifdef HAVE_RUBY_ENCODING_H rb_encoding * internal_encoding; int enc_index; #endif Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); if(ctx->done_p) return Qnil; #ifdef HAVE_RUBY_ENCODING_H { VALUE db = rb_iv_get(self, "@connection"); VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0); enc_index = NIL_P(encoding) ? rb_utf8_encindex() : rb_to_encoding_index(encoding); internal_encoding = rb_default_internal_encoding(); } #endif stmt = ctx->st; value = sqlite3_step(stmt); length = sqlite3_column_count(stmt); list = rb_ary_new2((long)length); switch(value) { case SQLITE_ROW: { int i; for(i = 0; i < length; i++) { switch(sqlite3_column_type(stmt, i)) { case SQLITE_INTEGER: rb_ary_push(list, LL2NUM(sqlite3_column_int64(stmt, i))); break; case SQLITE_FLOAT: rb_ary_push(list, rb_float_new(sqlite3_column_double(stmt, i))); break; case SQLITE_TEXT: { VALUE str = rb_tainted_str_new( (const char *)sqlite3_column_text(stmt, i), (long)sqlite3_column_bytes(stmt, i) ); #ifdef HAVE_RUBY_ENCODING_H rb_enc_associate_index(str, enc_index); if(internal_encoding) str = rb_str_export_to_enc(str, internal_encoding); #endif rb_ary_push(list, str); } break; case SQLITE_BLOB: { VALUE str = rb_tainted_str_new( (const char *)sqlite3_column_blob(stmt, i), (long)sqlite3_column_bytes(stmt, i) ); rb_ary_push(list, str); } break; case SQLITE_NULL: rb_ary_push(list, Qnil); break; default: rb_raise(rb_eRuntimeError, "bad type"); } } } break; case SQLITE_DONE: ctx->done_p = 1; return Qnil; break; default: CHECK(sqlite3_db_handle(ctx->st), value); } return list; }
static int proc_options(int argc, char **argv, struct cmdline_options *opt, int envopt) { int n, argc0 = argc; const char *s; if (argc == 0) return 0; for (argc--, argv++; argc > 0; argc--, argv++) { const char *const arg = argv[0]; if (arg[0] != '-' || !arg[1]) break; s = arg + 1; reswitch: switch (*s) { case 'a': if (envopt) goto noenvopt; opt->do_split = Qtrue; s++; goto reswitch; case 'p': if (envopt) goto noenvopt; opt->do_print = Qtrue; /* through */ case 'n': if (envopt) goto noenvopt; opt->do_loop = Qtrue; s++; goto reswitch; case 'd': ruby_debug = Qtrue; ruby_verbose = Qtrue; s++; goto reswitch; case 'y': if (envopt) goto noenvopt; opt->yydebug = 1; s++; goto reswitch; case 'v': if (opt->verbose) { s++; goto reswitch; } ruby_show_version(); opt->verbose = 1; case 'w': ruby_verbose = Qtrue; s++; goto reswitch; case 'W': { int numlen; int v = 2; /* -W as -W2 */ if (*++s) { v = scan_oct(s, 1, &numlen); if (numlen == 0) v = 1; s += numlen; } switch (v) { case 0: ruby_verbose = Qnil; break; case 1: ruby_verbose = Qfalse; break; default: ruby_verbose = Qtrue; break; } } goto reswitch; case 'c': if (envopt) goto noenvopt; opt->do_check = Qtrue; s++; goto reswitch; case 's': if (envopt) goto noenvopt; forbid_setid("-s"); opt->sflag = 1; s++; goto reswitch; case 'h': if (envopt) goto noenvopt; usage(origarg.argv[0]); rb_exit(EXIT_SUCCESS); break; case 'l': if (envopt) goto noenvopt; opt->do_line = Qtrue; rb_output_rs = rb_rs; s++; goto reswitch; case 'S': if (envopt) goto noenvopt; forbid_setid("-S"); opt->do_search = Qtrue; s++; goto reswitch; case 'e': if (envopt) goto noenvopt; forbid_setid("-e"); if (!*++s) { s = argv[1]; argc--, argv++; } if (!s) { rb_raise(rb_eRuntimeError, "no code specified for -e"); } if (!opt->e_script) { opt->e_script = rb_str_new(0, 0); if (opt->script == 0) opt->script = "-e"; } rb_str_cat2(opt->e_script, s); rb_str_cat2(opt->e_script, "\n"); break; case 'r': forbid_setid("-r"); if (*++s) { add_modules(opt, s); } else if (argv[1]) { add_modules(opt, argv[1]); argc--, argv++; } break; case 'i': if (envopt) goto noenvopt; forbid_setid("-i"); ruby_set_inplace_mode(s + 1); break; case 'x': if (envopt) goto noenvopt; opt->xflag = Qtrue; s++; if (*s && chdir(s) < 0) { rb_fatal("Can't chdir to %s", s); } break; case 'C': case 'X': if (envopt) goto noenvopt; s++; if (!*s) { s = argv[1]; argc--, argv++; } if (!s || !*s) { rb_fatal("Can't chdir"); } if (chdir(s) < 0) { rb_fatal("Can't chdir to %s", s); } break; case 'F': if (envopt) goto noenvopt; if (*++s) { rb_fs = rb_reg_new(s, strlen(s), 0); } break; case 'E': if (!*++s && (!--argc || !(s = *++argv))) { rb_raise(rb_eRuntimeError, "missing argument for -E"); } goto encoding; case 'U': set_internal_encoding_once(opt, "UTF-8", 0); ++s; goto reswitch; case 'K': if (*++s) { const char *enc_name = 0; switch (*s) { case 'E': case 'e': enc_name = "EUC-JP"; break; case 'S': case 's': enc_name = "Windows-31J"; break; case 'U': case 'u': enc_name = "UTF-8"; break; case 'N': case 'n': case 'A': case 'a': enc_name = "ASCII-8BIT"; break; } if (enc_name) { opt->src.enc.name = rb_str_new2(enc_name); if (!opt->ext.enc.name) opt->ext.enc.name = opt->src.enc.name; } s++; } goto reswitch; case 'T': { int numlen; int v = 1; if (*++s) { v = scan_oct(s, 2, &numlen); if (numlen == 0) v = 1; s += numlen; } if (v > opt->safe_level) opt->safe_level = v; } goto reswitch; case 'I': forbid_setid("-I"); if (*++s) ruby_incpush_expand(s); else if (argv[1]) { ruby_incpush_expand(argv[1]); argc--, argv++; } break; case '0': if (envopt) goto noenvopt; { int numlen; int v; char c; v = scan_oct(s, 4, &numlen); s += numlen; if (v > 0377) rb_rs = Qnil; else if (v == 0 && numlen >= 2) { rb_rs = rb_str_new2("\n\n"); } else { c = v & 0xff; rb_rs = rb_str_new(&c, 1); } } goto reswitch; case '-': if (!s[1] || (s[1] == '\r' && !s[2])) { argc--, argv++; goto switch_end; } s++; # define is_option_end(c, allow_hyphen) \ (!(c) || (allow_hyphen && (c) == '-') || (c) == '=') # define check_envopt(name, allow_envopt) \ ((allow_envopt || !envopt) ? (void)0 : \ rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --" name)) # define need_argument(name, s) \ ((*s++ ? !*s : (!--argc || !(s = *++argv))) ? \ rb_raise(rb_eRuntimeError, "missing argument for --" name) \ : (void)0) # define is_option_with_arg(name, allow_hyphen, allow_envopt) \ (strncmp(name, s, n = sizeof(name) - 1) == 0 && is_option_end(s[n], allow_hyphen) ? \ (check_envopt(name, allow_envopt), s += n, need_argument(name, s), 1) : 0) if (strcmp("copyright", s) == 0) { if (envopt) goto noenvopt_long; opt->copyright = 1; } else if (strcmp("debug", s) == 0) { ruby_debug = Qtrue; ruby_verbose = Qtrue; } else if (is_option_with_arg("enable", Qtrue, Qtrue)) { ruby_each_words(s, enable_option, &opt->disable); } else if (is_option_with_arg("disable", Qtrue, Qtrue)) { ruby_each_words(s, disable_option, &opt->disable); } else if (is_option_with_arg("encoding", Qfalse, Qtrue)) { char *p; encoding: do { # define set_encoding_part(type) \ if (!(p = strchr(s, ':'))) { \ set_##type##_encoding_once(opt, s, 0); \ break; \ } \ else if (p > s) { \ set_##type##_encoding_once(opt, s, p-s); \ } set_encoding_part(external); if (!*(s = ++p)) break; set_encoding_part(internal); if (!*(s = ++p)) break; rb_raise(rb_eRuntimeError, "extra argument for %s: %s", (arg[1] == '-' ? "--encoding" : "-E"), s); # undef set_encoding_part } while (0); } else if (is_option_with_arg("internal-encoding", Qfalse, Qtrue)) { set_internal_encoding_once(opt, s, 0); } else if (is_option_with_arg("external-encoding", Qfalse, Qtrue)) { set_external_encoding_once(opt, s, 0); } else if (strcmp("version", s) == 0) { if (envopt) goto noenvopt_long; opt->version = 1; } else if (strcmp("verbose", s) == 0) { opt->verbose = 1; ruby_verbose = Qtrue; } else if (strcmp("yydebug", s) == 0) { if (envopt) goto noenvopt_long; opt->yydebug = 1; } else if (is_option_with_arg("dump", Qfalse, Qfalse)) { ruby_each_words(s, dump_option, &opt->dump); } else if (strcmp("help", s) == 0) { if (envopt) goto noenvopt_long; usage(origarg.argv[0]); rb_exit(EXIT_SUCCESS); } else { rb_raise(rb_eRuntimeError, "invalid option --%s (-h will show valid options)", s); } break; case '\r': if (!s[1]) break; default: { if (ISPRINT(*s)) { rb_raise(rb_eRuntimeError, "invalid option -%c (-h will show valid options)", (int)(unsigned char)*s); } else { rb_raise(rb_eRuntimeError, "invalid option -\\x%02X (-h will show valid options)", (int)(unsigned char)*s); } } goto switch_end; noenvopt: /* "EIdvwWrKU" only */ rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: -%c", *s); break; noenvopt_long: rb_raise(rb_eRuntimeError, "invalid switch in RUBYOPT: --%s", s); break; case 0: break; # undef is_option_end # undef check_envopt # undef need_argument # undef is_option_with_arg } } switch_end: return argc0 - argc; }
void capi_raise_runtime_error(const char* reason) { rb_raise(rb_eRuntimeError, reason); }
VALUE sfcc_cimdata_to_value(CIMCData *data, VALUE client) { VALUE rbval; CIMCStatus status; if ((data->state != CIMC_goodValue) && (data->state != CIMC_keyValue)) { if (data->state & CIMC_nullValue) return Qnil; if (data->state & CIMC_notFound) rb_raise(rb_eRuntimeError, "Value not found"); if (data->state & CIMC_badValue) rb_raise(rb_eArgError, "Bad value"); } if (data->type & CIMC_ARRAY) { int k = 0; int n = 0; VALUE rbarray = rb_ary_new(); if (!data->value.array) return rb_ary_new(); n = data->value.array->ft->getSize(data->value.array, &status); if (!status.rc) { for (k = 0; k < n; ++k) { CIMCData element = data->value.array->ft->getElementAt(data->value.array, k, NULL); rb_ary_push(rbarray, sfcc_cimdata_to_value(&element, client)); } return rbarray; } sfcc_rb_raise_if_error(status, "Can't retrieve array size"); return Qnil; } else if (data->type & CIMC_ENC) { switch (data->type) { case CIMC_instance: return data->value.inst ? Sfcc_wrap_cim_instance(data->value.inst->ft->clone(data->value.inst, NULL), client) : Qnil; case CIMC_ref: return data->value.ref ? Sfcc_wrap_cim_object_path(data->value.ref->ft->clone(data->value.ref, NULL), client) : Qnil; case CIMC_args: return data->value.args ? sfcc_cimargs_to_hash(data->value.args, client) : Qnil; case CIMC_class: return data->value.cls ? Sfcc_wrap_cim_class(data->value.cls->ft->clone(data->value.cls, NULL)) : Qnil; case CIMC_filter: return Qnil; case CIMC_enumeration: return data->value.Enum ? Sfcc_wrap_cim_enumeration(data->value.Enum->ft->clone(data->value.Enum, NULL), client) : Qnil; case CIMC_string: if (data->value.string) { const char *strval = data->value.string->ft->getCharPtr(data->value.string, NULL); /* getCharPtr() might return NULL and rb_str_new2 doesn't like that */ if (strval) return rb_str_new2(strval); } return Qnil; case CIMC_chars: return data->value.chars ? rb_str_new2(data->value.chars) : Qnil; case CIMC_charsptr: return data->value.chars ? rb_str_new((char*)data->value.dataPtr.ptr, data->value.dataPtr.length) : Qnil; case CIMC_dateTime: if (data->value.dateTime) { CIMCUint64 bintime; bintime = data->value.dateTime->ft->getBinaryFormat(data->value.dateTime, NULL); rbval = rb_time_new((time_t) (bintime / 1000000L), (time_t) (bintime % 1000000)); } else { rbval = Qnil; } return rbval; default: rb_raise(rb_eTypeError, "Unhandled type 0x%04x", data->type); } } else if (data->type & CIMC_SIMPLE) { switch (data->type) { case CIMC_boolean: return data->value.boolean ? Qtrue : Qfalse; case CIMC_char16: return UINT2NUM(data->value.char16); } } else if (data->type & CIMC_INTEGER) { switch (data->type) { case CIMC_uint8: return UINT2NUM(data->value.uint8); case CIMC_sint8: return INT2NUM(data->value.sint8); case CIMC_uint16: return UINT2NUM(data->value.uint16); case CIMC_sint16: return INT2NUM(data->value.sint16); case CIMC_uint32: return UINT2NUM(data->value.uint32); case CIMC_sint32: return INT2NUM(data->value.sint32); case CIMC_uint64: return UINT2NUM(data->value.uint64); case CIMC_sint64: return INT2NUM(data->value.sint64); } } else if (data->type & CIMC_REAL) { switch (data->type) { case CIMC_real32: return rb_float_new(data->value.real32); case CIMC_real64: return rb_float_new(data->value.real64); } } else if (data->type & CIMC_null ) { return Qnil; } rb_raise(rb_eTypeError, "unsupported data type %d", data->type); return Qnil; }
/* * @overload send_packet_out(datapath_id, options={}) * Sends a packet_out message to have a packet processed by the datapath. * * @example * send_packet_out( * datapath_id, * :packet_in => message, * :actions => Trema::SendOutPort.new(port_no) * ) * * * @param [Number] datapath_id * the datapath to which a message is sent. * * @param [Hash] options * the options to create a message with. * * * @option options [PacketIn] :packet_in (nil) * The {PacketIn} object received by packet_in handler. If this * option is not nil, :buffer_id, :data, and :in_port option is * set automatically according to the value of :packet_in. * * @option options [Number] :in_port (OFPP_NONE) * The port from which the frame is to be sent. OFPP_NONE if * none. OFPP_TABLE to perform the actions defined in the flow * table. * * @option options [Number] :buffer_id (0xffffffff) * The buffer ID assigned by the datapath. If 0xffffffff, the * frame is not buffered, and the entire frame must be passed in * :data. * * @option options [String, nil] :data (nil) * The entire Ethernet frame. Should be of length 0 if buffer_id * is 0xffffffff, and should be of length >0 otherwise. * * @option options [Action, Array<Action>, nil] :actions (nil) * The sequence of actions specifying the actions to perform on * the frame. * * @option options [Boolean] :zero_padding (false) * If true, fill up to minimum ethernet frame size. */ static VALUE controller_send_packet_out( int argc, VALUE *argv, VALUE self ) { VALUE datapath_id = Qnil; VALUE options = Qnil; rb_scan_args( argc, argv, "11", &datapath_id, &options ); // Defaults. uint32_t buffer_id = UINT32_MAX; uint16_t in_port = OFPP_NONE; openflow_actions *actions = create_actions(); const buffer *data = NULL; buffer *allocated_data = NULL; VALUE opt_zero_padding = Qnil; if ( options != Qnil ) { VALUE opt_message = rb_hash_aref( options, ID2SYM( rb_intern( "packet_in" ) ) ); if ( opt_message != Qnil ) { packet_in *message; Data_Get_Struct( opt_message, packet_in, message ); if ( NUM2ULL( datapath_id ) == message->datapath_id ) { buffer_id = message->buffer_id; in_port = message->in_port; } data = ( buffer_id == UINT32_MAX ? message->data : NULL ); } VALUE opt_buffer_id = rb_hash_aref( options, ID2SYM( rb_intern( "buffer_id" ) ) ); if ( opt_buffer_id != Qnil ) { buffer_id = ( uint32_t ) NUM2ULONG( opt_buffer_id ); } VALUE opt_in_port = rb_hash_aref( options, ID2SYM( rb_intern( "in_port" ) ) ); if ( opt_in_port != Qnil ) { in_port = ( uint16_t ) NUM2UINT( opt_in_port ); } VALUE opt_action = rb_hash_aref( options, ID2SYM( rb_intern( "actions" ) ) ); if ( opt_action != Qnil ) { form_actions( opt_action, actions ); } VALUE opt_data = rb_hash_aref( options, ID2SYM( rb_intern( "data" ) ) ); if ( opt_data != Qnil ) { Check_Type( opt_data, T_STRING ); uint16_t length = ( uint16_t ) RSTRING_LEN( opt_data ); allocated_data = alloc_buffer_with_length( length ); memcpy( append_back_buffer( allocated_data, length ), RSTRING_PTR( opt_data ), length ); data = allocated_data; } opt_zero_padding = rb_hash_aref( options, ID2SYM( rb_intern( "zero_padding" ) ) ); if ( opt_zero_padding != Qnil ) { if ( TYPE( opt_zero_padding ) != T_TRUE && TYPE( opt_zero_padding ) != T_FALSE ) { rb_raise( rb_eTypeError, ":zero_padding must be true or false" ); } } } if ( data != NULL && data->length + ETH_FCS_LENGTH < ETH_MINIMUM_LENGTH && opt_zero_padding != Qnil && TYPE( opt_zero_padding ) == T_TRUE ) { if ( allocated_data == NULL ) { allocated_data = duplicate_buffer( data ); data = allocated_data; } fill_ether_padding( allocated_data ); } buffer *packet_out = create_packet_out( get_transaction_id(), buffer_id, in_port, actions, data ); send_openflow_message( NUM2ULL( datapath_id ), packet_out ); if ( allocated_data != NULL ) { free_buffer( allocated_data ); } free_buffer( packet_out ); delete_actions( actions ); return self; }
CIMCData sfcc_value_to_cimdata(VALUE value) { CIMCData data; memset(&data, 0, sizeof(CIMCData)); data.state = CIMC_goodValue; data.type = CIMC_null; switch (TYPE(value)) { case T_NIL: data.type = CIMC_null; data.state = CIMC_nullValue; break; case T_STRING: data.type = CIMC_string; data.value.string = cimcEnv->ft->newString(cimcEnv, to_charptr(value), NULL); break; case T_TRUE: data.type = CIMC_boolean; data.value.boolean = 1; break; case T_FALSE: data.type = CIMC_boolean; data.value.boolean = 0; break; case T_FIXNUM: data.type = CIMC_sint64; data.value.Long = NUM2INT(value); break; case T_FLOAT: data.type = CIMC_real64; data.value.real64 = NUM2DBL(value); break; case T_BIGNUM: data.type = CIMC_sint64; data.value.Long = NUM2LL(value); break; /* not yet supported case T_HASH: break; case T_SYMBOL: */ case T_ARRAY: { data.value.array = sfcc_rubyarray_to_cimcarray(value, &data.type); if (!data.value.array) { data.state = CIMC_badValue; } break; } case T_DATA: default: if (CLASS_OF(value) == cSfccCimString) { Data_Get_Struct(value, CIMCString, data.value.string); if (data.value.string == NULL) { /* packed a NULL pointer ? */ data.type = CIMC_null; data.state = CIMC_nullValue; } else { data.type = CIMC_string; } } else if (CLASS_OF(value) == cSfccCimData) { CIMCData *tmp; Data_Get_Struct(value, CIMCData, tmp); data = *tmp; } else if(CLASS_OF(value) == cSfccCimInstance) { rb_sfcc_instance *obj; Data_Get_Struct(value, rb_sfcc_instance, obj); data.value.inst = obj->inst; if (data.value.inst == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_instance; } } else if(CLASS_OF(value) == cSfccCimObjectPath) { rb_sfcc_object_path *obj; Data_Get_Struct(value, rb_sfcc_object_path, obj); data.value.ref = obj->op; if (data.value.ref == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_ref; } } else if(CLASS_OF(value) == cSfccCimEnumeration) { rb_sfcc_enumeration *obj; Data_Get_Struct(value, rb_sfcc_enumeration, obj); data.value.Enum = obj->enm; if (data.value.Enum == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_enumeration; } } else if (CLASS_OF(value) == cSfccCimClass) { Data_Get_Struct(value, CIMCClass, data.value.cls); if (data.value.cls == NULL) { data.type = CIMC_null; data.state = CIMC_nullValue; }else { data.type = CIMC_class; } } else { VALUE cname; const char *class_name; data.state = CIMC_badValue; data.type = CIMC_null; cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0); class_name = to_charptr(cname); rb_raise(rb_eTypeError, "unsupported data type: %s", class_name); return data; } } return data; }
void updateSettings(PortDescriptor *port) { if (port->status != 0) rb_raise(rb_eException, "Can not set due to comport is not open, status: %d\n", port->status); if (port->toBeUpdated & T_BaudRate) port->commConfig.dcb.BaudRate = port->settings.BaudRate; if (port->toBeUpdated & T_Parity) { port->commConfig.dcb.Parity = (BYTE) port->settings.Parity; port->commConfig.dcb.fParity = (port->settings.Parity == PAR_NONE) ? 0 : 1; } if (port->toBeUpdated & T_DataBits) { port->commConfig.dcb.ByteSize = (BYTE) port->settings.DataBits; } if (port->toBeUpdated & T_StopBits) { switch (port->settings.StopBits) { case STOP_1: port->commConfig.dcb.StopBits = ONESTOPBIT; break; case STOP_2: port->commConfig.dcb.StopBits = TWOSTOPBITS; break; } } if (port->toBeUpdated & T_Flow) { switch (port->settings.FlowControl) { case FLOW_OFF: port->commConfig.dcb.fOutxCtsFlow = 0; port->commConfig.dcb.fRtsControl = RTS_CONTROL_DISABLE; port->commConfig.dcb.fInX = 0; port->commConfig.dcb.fOutX = 0; break; case FLOW_XONXOFF: port->commConfig.dcb.fOutxCtsFlow = 0; port->commConfig.dcb.fRtsControl = RTS_CONTROL_DISABLE; port->commConfig.dcb.fInX = 1; port->commConfig.dcb.fOutX = 1; break; case FLOW_HARDWARE: port->commConfig.dcb.fOutxCtsFlow = 1; port->commConfig.dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; port->commConfig.dcb.fInX = 0; port->commConfig.dcb.fOutX = 0; break; } } if (port->toBeUpdated & T_TimeOut) { int millisec = port->settings.Timeout_Millisec; if (millisec == -1) { port->commTimeouts.ReadIntervalTimeout = MAXDWORD; port->commTimeouts.ReadTotalTimeoutConstant = 0; } else { port->commTimeouts.ReadIntervalTimeout = MAXDWORD; port->commTimeouts.ReadTotalTimeoutConstant = millisec; } port->commTimeouts.ReadTotalTimeoutMultiplier = 0; port->commTimeouts.WriteTotalTimeoutMultiplier = millisec; port->commTimeouts.WriteTotalTimeoutConstant = 0; } if (port->toBeUpdated & T_SettingsDone) SetCommConfig(port->fd, &port->commConfig, sizeof(COMMCONFIG)); if ((port->toBeUpdated & T_TimeOut)) SetCommTimeouts(port->fd, &port->commTimeouts); port->toBeUpdated = 0; }
int na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx) { int i, j; int count_new=0; int count_rest=0; ssize_t x, s, m, pos, *idx; narray_t *na; narray_view_t *nv; stridx_t sdx; VALUE a; GetNArray(self,na); if (na->size == 0) { rb_raise(nary_eShapeError, "cannot get element of empty array"); } idx = ALLOCA_N(ssize_t, argc); for (i=j=0; i<argc; i++) { a = argv[i]; switch(TYPE(a)) { case T_FIXNUM: idx[j++] = FIX2LONG(a); break; case T_BIGNUM: case T_FLOAT: idx[j++] = NUM2SSIZET(a); break; case T_FALSE: case T_SYMBOL: if (a==sym_rest || a==sym_tilde || a==Qfalse) { argv[i] = Qfalse; count_rest++; break; } else if (a==sym_new || a==sym_minus) { argv[i] = sym_new; count_new++; } } } if (j != argc) { return check_index_count(argc, na->ndim, count_new, count_rest); } switch(na->type) { case NARRAY_VIEW_T: GetNArrayView(self,nv); pos = nv->offset; if (j == na->ndim) { for (i=j-1; i>=0; i--) { x = na_range_check(idx[i], na->shape[i], i); sdx = nv->stridx[i]; if (SDX_IS_INDEX(sdx)) { pos += SDX_GET_INDEX(sdx)[x]; } else { pos += SDX_GET_STRIDE(sdx)*x; } } *pos_idx = pos; return 0; } if (j == 1) { x = na_range_check(idx[0], na->size, 0); for (i=na->ndim-1; i>=0; i--) { s = na->shape[i]; m = x % s; x = x / s; sdx = nv->stridx[i]; if (SDX_IS_INDEX(sdx)) { pos += SDX_GET_INDEX(sdx)[m]; } else { pos += SDX_GET_STRIDE(sdx)*m; } } *pos_idx = pos; return 0; } break; default: if (!stride) { stride = nary_element_stride(self); } if (j == 1) { x = na_range_check(idx[0], na->size, 0); *pos_idx = stride * x; return 0; } if (j == na->ndim) { pos = 0; for (i=j-1; i>=0; i--) { x = na_range_check(idx[i], na->shape[i], i); pos += stride * x; stride *= na->shape[i]; } *pos_idx = pos; return 0; } } rb_raise(rb_eIndexError,"# of index(=%i) should be " "equal to ndim(=%i) or 1", argc,na->ndim); return -1; }