// ----------------------------------------------------------------------------------
//
// 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;
}
