static VALUE cmethod_proj4_transform(VALUE method, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z) { VALUE result = Qnil; projPJ from_pj = RGEO_PROJ4_DATA_PTR(from)->pj; projPJ to_pj = RGEO_PROJ4_DATA_PTR(to)->pj; if (from_pj && to_pj) { double xval = rb_num2dbl(x); double yval = rb_num2dbl(y); double zval = 0.0; if (!NIL_P(z)) { zval = rb_num2dbl(z); } int err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval); if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) { result = rb_ary_new2(NIL_P(z) ? 2 : 3); rb_ary_push(result, rb_float_new(xval)); rb_ary_push(result, rb_float_new(yval)); if (!NIL_P(z)) { rb_ary_push(result, rb_float_new(zval)); } } } return result; }
static VALUE ossl_x509crl_get_revoked(VALUE self) { X509_CRL *crl; int i, num; X509_REVOKED *rev; VALUE ary, revoked; GetX509CRL(self, crl); num = sk_X509_REVOKED_num(X509_CRL_get_REVOKED(crl)); if (num < 0) { OSSL_Debug("num < 0???"); return rb_ary_new(); } ary = rb_ary_new2(num); for(i=0; i<num; i++) { /* NO DUP - don't free! */ rev = sk_X509_REVOKED_value(X509_CRL_get_REVOKED(crl), i); revoked = ossl_x509revoked_new(rev); rb_ary_push(ary, revoked); } return ary; }
VALUE rb_get_expanded_load_path(void) { VALUE load_path = rb_get_load_path(); VALUE ary; long i; for (i = 0; i < RARRAY_LEN(load_path); ++i) { VALUE str = rb_check_string_type(RARRAY_PTR(load_path)[i]); if (NIL_P(str) || !rb_is_absolute_path(RSTRING_PTR(str))) goto relative_path_found; } return load_path; relative_path_found: ary = rb_ary_new2(RARRAY_LEN(load_path)); for (i = 0; i < RARRAY_LEN(load_path); ++i) { VALUE path = rb_file_expand_path(RARRAY_PTR(load_path)[i], Qnil); rb_str_freeze(path); rb_ary_push(ary, path); } rb_obj_freeze(ary); return ary; }
static VALUE value_to_ruby(value_t*v) { switch(v->type) { case TYPE_VOID: return Qnil; break; case TYPE_FLOAT32: return rb_float_new(v->f32); break; case TYPE_INT32: return INT2FIX(v->i32); break; case TYPE_BOOLEAN: if(v->b) { return Qtrue; } else { return Qfalse; } break; case TYPE_STRING: { return rb_str_new2(v->str); } break; case TYPE_ARRAY: { volatile VALUE a = rb_ary_new2(v->length); int i; for(i=0;i<v->length;i++) { rb_ary_store(a, i, value_to_ruby(v->data[i])); } return a; } break; default: return Qnil; } }
VALUE rb_struct_define_without_accessor(const char *class_name, VALUE super, rb_alloc_func_t alloc, ...) { VALUE klass; va_list ar; VALUE members; long i; char *name; members = rb_ary_new2(0); va_start(ar, alloc); i = 0; while ((name = va_arg(ar, char*)) != NULL) { rb_ary_push(members, ID2SYM(rb_intern(name))); } va_end(ar); OBJ_FREEZE(members); if (class_name) { klass = rb_define_class(class_name, super); } else { klass = rb_class_new(super); rb_make_metaclass(klass, RBASIC(super)->klass); rb_class_inherited(super, klass); } rb_iv_set(klass, "__size__", LONG2NUM(RARRAY_LEN(members))); rb_iv_set(klass, "__members__", members); rb_objc_define_method(*(VALUE *)klass, "alloc", alloc != NULL ? alloc : struct_alloc, 0); return klass; }
static VALUE attrary2rval(GArray *attrs) { long i, len; VALUE rb_attrs, rb_class; len = attrs->len; rb_attrs = rb_ary_new2(len); rb_class = rb_const_get(rb_const_get(rb_cObject, rb_intern("Vte")), rb_intern("CharAttributes")); for (i = 0; i < len; i++) { VteCharAttributes *attr; attr = &g_array_index(attrs, VteCharAttributes, i); rb_ary_push(rb_attrs, rb_funcall(rb_class, id_new, 6, LONG2NUM(attr->row), LONG2NUM(attr->column), COLOR2RVAL(&(attr->fore)), COLOR2RVAL(&(attr->back)), CBOOL2RVAL(attr->underline), CBOOL2RVAL(attr->strikethrough))); } return rb_attrs; }
static VALUE fntype_initialize(int argc, VALUE* argv, VALUE self) { FunctionType *fnInfo; ffi_status status; VALUE rbReturnType = Qnil, rbParamTypes = Qnil, rbOptions = Qnil; VALUE rbEnums = Qnil, rbConvention = Qnil, rbBlocking = Qnil; #if defined(_WIN32) || defined(__WIN32__) VALUE rbConventionStr; #endif int i, nargs; nargs = rb_scan_args(argc, argv, "21", &rbReturnType, &rbParamTypes, &rbOptions); if (nargs >= 3 && rbOptions != Qnil) { rbConvention = rb_hash_aref(rbOptions, ID2SYM(rb_intern("convention"))); rbEnums = rb_hash_aref(rbOptions, ID2SYM(rb_intern("enums"))); rbBlocking = rb_hash_aref(rbOptions, ID2SYM(rb_intern("blocking"))); } Check_Type(rbParamTypes, T_ARRAY); Data_Get_Struct(self, FunctionType, fnInfo); fnInfo->parameterCount = RARRAY_LEN(rbParamTypes); fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes)); fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *)); fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes)); fnInfo->rbParameterTypes = rb_ary_new2(fnInfo->parameterCount); fnInfo->rbEnums = rbEnums; fnInfo->blocking = RTEST(rbBlocking); fnInfo->hasStruct = false; for (i = 0; i < fnInfo->parameterCount; ++i) { VALUE entry = rb_ary_entry(rbParamTypes, i); VALUE type = rbffi_Type_Lookup(entry); if (!RTEST(type)) { VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL); rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName)); } if (rb_obj_is_kind_of(type, rbffi_FunctionTypeClass)) { REALLOC_N(fnInfo->callbackParameters, VALUE, fnInfo->callbackCount + 1); fnInfo->callbackParameters[fnInfo->callbackCount++] = type; } if (rb_obj_is_kind_of(type, rbffi_StructByValueClass)) { fnInfo->hasStruct = true; } rb_ary_push(fnInfo->rbParameterTypes, type); Data_Get_Struct(type, Type, fnInfo->parameterTypes[i]); fnInfo->ffiParameterTypes[i] = fnInfo->parameterTypes[i]->ffiType; fnInfo->nativeParameterTypes[i] = fnInfo->parameterTypes[i]->nativeType; } fnInfo->rbReturnType = rbffi_Type_Lookup(rbReturnType); if (!RTEST(fnInfo->rbReturnType)) { VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL); rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName)); } if (rb_obj_is_kind_of(fnInfo->rbReturnType, rbffi_StructByValueClass)) { fnInfo->hasStruct = true; } Data_Get_Struct(fnInfo->rbReturnType, Type, fnInfo->returnType); fnInfo->ffiReturnType = fnInfo->returnType->ffiType; #if defined(_WIN32) || defined(__WIN32__) rbConventionStr = (rbConvention != Qnil) ? rb_funcall2(rbConvention, rb_intern("to_s"), 0, NULL) : Qnil; fnInfo->abi = (rbConventionStr != Qnil && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0) ? FFI_STDCALL : FFI_DEFAULT_ABI; #else fnInfo->abi = FFI_DEFAULT_ABI; #endif status = ffi_prep_cif(&fnInfo->ffi_cif, fnInfo->abi, fnInfo->parameterCount, fnInfo->ffiReturnType, fnInfo->ffiParameterTypes); switch (status) { case FFI_BAD_ABI: rb_raise(rb_eArgError, "Invalid ABI specified"); case FFI_BAD_TYPEDEF: rb_raise(rb_eArgError, "Invalid argument type specified"); case FFI_OK: break; default: rb_raise(rb_eArgError, "Unknown FFI error"); } fnInfo->invoke = rbffi_GetInvoker(fnInfo); return self; }
VALUE rb_curl_easy_error(CURLcode code) { VALUE exclz; const char *exmsg = NULL; VALUE results; switch (code) { case CURLE_OK: /* 0 */ exclz = eCurlErrOK; break; case CURLE_UNSUPPORTED_PROTOCOL: /* 1 */ exclz = eCurlErrUnsupportedProtocol; break; case CURLE_FAILED_INIT: /* 2 */ exclz = eCurlErrFailedInit; break; case CURLE_URL_MALFORMAT: /* 3 */ exclz = eCurlErrMalformedURL; break; #ifdef HAVE_CURLE_NOT_BUILT_IN case CURLE_NOT_BUILT_IN: /* 4 - [was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5] */ exclz = eCurlErrNotBuiltIn; break; #else case CURLE_URL_MALFORMAT_USER: /* 4 (NOT USED) */ exclz = eCurlErrMalformedURLUser; break; #endif case CURLE_COULDNT_RESOLVE_PROXY: /* 5 */ exclz = eCurlErrProxyResolution; break; case CURLE_COULDNT_RESOLVE_HOST: /* 6 */ exclz = eCurlErrHostResolution; break; case CURLE_COULDNT_CONNECT: /* 7 */ exclz = eCurlErrConnectFailed; break; case CURLE_FTP_WEIRD_SERVER_REPLY: /* 8 */ exclz = eCurlErrFTPWierdReply; break; case CURLE_FTP_ACCESS_DENIED: /* 9 denied due to lack of access. */ exclz = eCurlErrFTPAccessDenied; break; case CURLE_FTP_USER_PASSWORD_INCORRECT: /* 10 */ exclz = eCurlErrFTPBadPassword; break; case CURLE_FTP_WEIRD_PASS_REPLY: /* 11 */ exclz = eCurlErrFTPWierdPassReply; break; case CURLE_FTP_WEIRD_USER_REPLY: /* 12 */ exclz = eCurlErrFTPWierdUserReply; break; case CURLE_FTP_WEIRD_PASV_REPLY: /* 13 */ exclz = eCurlErrFTPWierdPasvReply; break; case CURLE_FTP_WEIRD_227_FORMAT: /* 14 */ exclz = eCurlErrFTPWierd227Format; break; case CURLE_FTP_CANT_GET_HOST: /* 15 */ exclz = eCurlErrFTPCantGetHost; break; case CURLE_FTP_CANT_RECONNECT: /* 16 */ exclz = eCurlErrFTPCantReconnect; break; case CURLE_FTP_COULDNT_SET_BINARY: /* 17 */ exclz = eCurlErrFTPCouldntSetBinary; break; case CURLE_PARTIAL_FILE: /* 18 */ exclz = eCurlErrPartialFile; break; case CURLE_FTP_COULDNT_RETR_FILE: /* 19 */ exclz = eCurlErrFTPCouldntRetrFile; break; case CURLE_FTP_WRITE_ERROR: /* 20 */ exclz = eCurlErrFTPWrite; break; case CURLE_FTP_QUOTE_ERROR: /* 21 */ exclz = eCurlErrFTPQuote; break; case CURLE_HTTP_RETURNED_ERROR: /* 22 */ exclz = eCurlErrHTTPFailed; break; case CURLE_WRITE_ERROR: /* 23 */ exclz = eCurlErrWriteError; break; case CURLE_MALFORMAT_USER: /* 24 - NOT USED */ exclz = eCurlErrMalformedUser; break; case CURLE_FTP_COULDNT_STOR_FILE: /* 25 - failed FTP upload */ exclz = eCurlErrFTPCouldntStorFile; break; case CURLE_READ_ERROR: /* 26 - could open/read from file */ exclz = eCurlErrReadError; break; case CURLE_OUT_OF_MEMORY: /* 27 */ exclz = eCurlErrOutOfMemory; break; case CURLE_OPERATION_TIMEOUTED: /* 28 - the timeout time was reached */ exclz = eCurlErrTimeout; break; case CURLE_FTP_COULDNT_SET_ASCII: /* 29 - TYPE A failed */ exclz = eCurlErrFTPCouldntSetASCII; break; case CURLE_FTP_PORT_FAILED: /* 30 - FTP PORT operation failed */ exclz = eCurlErrFTPPortFailed; break; case CURLE_FTP_COULDNT_USE_REST: /* 31 - the REST command failed */ exclz = eCurlErrFTPCouldntUseRest; break; case CURLE_FTP_COULDNT_GET_SIZE: /* 32 - the SIZE command failed */ exclz = eCurlErrFTPCouldntGetSize; break; case CURLE_HTTP_RANGE_ERROR: /* 33 - RANGE "command" didn't work */ exclz = eCurlErrHTTPRange; break; case CURLE_HTTP_POST_ERROR: /* 34 */ exclz = eCurlErrHTTPPost; break; case CURLE_SSL_CONNECT_ERROR: /* 35 - wrong when connecting with SSL */ exclz = eCurlErrSSLConnectError; break; case CURLE_BAD_DOWNLOAD_RESUME: /* 36 - couldn't resume download */ exclz = eCurlErrBadResume; break; case CURLE_FILE_COULDNT_READ_FILE: /* 37 */ exclz = eCurlErrFileCouldntRead; break; case CURLE_LDAP_CANNOT_BIND: /* 38 */ exclz = eCurlErrLDAPCouldntBind; break; case CURLE_LDAP_SEARCH_FAILED: /* 39 */ exclz = eCurlErrLDAPSearchFailed; break; case CURLE_LIBRARY_NOT_FOUND: /* 40 */ exclz = eCurlErrLibraryNotFound; break; case CURLE_FUNCTION_NOT_FOUND: /* 41 */ exclz = eCurlErrFunctionNotFound; break; case CURLE_ABORTED_BY_CALLBACK: /* 42 */ exclz = eCurlErrAbortedByCallback; break; case CURLE_BAD_FUNCTION_ARGUMENT: /* 43 */ exclz = eCurlErrBadFunctionArgument; break; case CURLE_BAD_CALLING_ORDER: /* 44 - NOT USED */ exclz = eCurlErrBadCallingOrder; break; case CURLE_INTERFACE_FAILED: /* 45 - CURLOPT_INTERFACE failed */ exclz = eCurlErrInterfaceFailed; break; case CURLE_BAD_PASSWORD_ENTERED: /* 46 - NOT USED */ exclz = eCurlErrBadPasswordEntered; break; case CURLE_TOO_MANY_REDIRECTS: /* 47 - catch endless re-direct loops */ exclz = eCurlErrTooManyRedirects; break; case CURLE_UNKNOWN_TELNET_OPTION: /* 48 - User specified an unknown option */ exclz = eCurlErrTelnetUnknownOption; break; case CURLE_TELNET_OPTION_SYNTAX: /* 49 - Malformed telnet option */ exclz = eCurlErrTelnetBadOptionSyntax; break; #ifdef HAVE_CURLE_OBSOLETE case CURLE_OBSOLETE: /* 50 - NOT USED */ exclz = eCurlErrObsolete; break; #endif case CURLE_SSL_PEER_CERTIFICATE: /* 51 - peer's certificate wasn't ok */ exclz = eCurlErrSSLPeerCertificate; break; case CURLE_GOT_NOTHING: /* 52 - when this is a specific error */ exclz = eCurlErrGotNothing; break; case CURLE_SSL_ENGINE_NOTFOUND: /* 53 - SSL crypto engine not found */ exclz = eCurlErrSSLEngineNotFound; break; case CURLE_SSL_ENGINE_SETFAILED: /* 54 - can not set SSL crypto engine as default */ exclz = eCurlErrSSLEngineSetFailed; break; case CURLE_SEND_ERROR: /* 55 - failed sending network data */ exclz = eCurlErrSendError; break; case CURLE_RECV_ERROR: /* 56 - failure in receiving network data */ exclz = eCurlErrRecvError; break; case CURLE_SHARE_IN_USE: /* 57 - share is in use */ exclz = eCurlErrShareInUse; break; case CURLE_SSL_CERTPROBLEM: /* 58 - problem with the local certificate */ exclz = eCurlErrSSLCertificate; break; case CURLE_SSL_CIPHER: /* 59 - couldn't use specified cipher */ exclz = eCurlErrSSLCipher; break; case CURLE_SSL_CACERT: /* 60 - problem with the CA cert (path?) */ exclz = eCurlErrSSLCACertificate; break; case CURLE_BAD_CONTENT_ENCODING: /* 61 - Unrecognized transfer encoding */ exclz = eCurlErrBadContentEncoding; break; case CURLE_LDAP_INVALID_URL: /* 62 - Invalid LDAP URL */ exclz = eCurlErrLDAPInvalidURL; break; case CURLE_FILESIZE_EXCEEDED: /* 63 - Maximum file size exceeded */ exclz = eCurlErrFileSizeExceeded; break; case CURLE_FTP_SSL_FAILED: /* 64 - Requested FTP SSL level failed */ exclz = eCurlErrFTPSSLFailed; break; #ifdef HAVE_CURLE_SEND_FAIL_REWIND case CURLE_SEND_FAIL_REWIND: /* 65 - Sending the data requires a rewind that failed */ exclz = eCurlErrSendFailedRewind; break; #endif #ifdef HAVE_CURLE_SSL_ENGINE_INITFAILED case CURLE_SSL_ENGINE_INITFAILED: /* 66 - failed to initialise ENGINE */ exclz = eCurlErrSSLEngineInitFailed; break; #endif #ifdef HAVE_CURLE_LOGIN_DENIED case CURLE_LOGIN_DENIED: /* 67 - user, password or similar was not accepted and we failed to login */ exclz = eCurlErrLoginDenied; break; #endif // recent additions, may not be present in all supported versions #ifdef HAVE_CURLE_TFTP_NOTFOUND case CURLE_TFTP_NOTFOUND: /* 68 - file not found on server */ exclz = eCurlErrTFTPNotFound; break; #endif #ifdef HAVE_CURLE_TFTP_PERM case CURLE_TFTP_PERM: /* 69 - permission problem on server */ exclz = eCurlErrTFTPPermission; break; #endif #ifdef HAVE_CURLE_TFTP_DISKFULL case CURLE_TFTP_DISKFULL: /* 70 - out of disk space on server */ exclz = eCurlErrTFTPDiskFull; break; #endif #ifdef HAVE_CURLE_TFTP_ILLEGAL case CURLE_TFTP_ILLEGAL: /* 71 - Illegal TFTP operation */ exclz = eCurlErrTFTPIllegalOperation; break; #endif #ifdef HAVE_CURLE_TFTP_UNKNOWNID case CURLE_TFTP_UNKNOWNID: /* 72 - Unknown transfer ID */ exclz = eCurlErrTFTPUnknownID; break; #endif #ifdef HAVE_CURLE_TFTP_EXISTS case CURLE_TFTP_EXISTS: /* 73 - File already exists */ exclz = eCurlErrTFTPFileExists; break; #endif #ifdef HAVE_CURLE_TFTP_NOSUCHUSER case CURLE_TFTP_NOSUCHUSER: /* 74 - No such user */ exclz = eCurlErrTFTPNotFound; break; #endif #ifdef HAVE_CURLE_CONV_FAILED case CURLE_CONV_FAILED: /* 75 - conversion failed */ exclz = eCurlErrConvFailed; break; #endif #ifdef HAVE_CURLE_CONV_REQD case CURLE_CONV_REQD: /* 76 - caller must register conversion callbacks using curl_easy_setopt options CURLOPT_CONV_FROM_NETWORK_FUNCTION, CURLOPT_CONV_TO_NETWORK_FUNCTION, and CURLOPT_CONV_FROM_UTF8_FUNCTION */ exclz = eCurlErrConvReqd; break; #endif #ifdef HAVE_CURLE_SSL_CACERT_BADFILE case CURLE_SSL_CACERT_BADFILE: /* 77 - could not load CACERT file, missing or wrong format */ exclz = eCurlErrSSLCacertBadfile; break; #endif #ifdef HAVE_CURLE_REMOTE_FILE_NOT_FOUND case CURLE_REMOTE_FILE_NOT_FOUND: /* 78 - remote file not found */ exclz = eCurlErrRemoteFileNotFound; break; #endif #ifdef HAVE_CURLE_SSH case CURLE_SSH: /* 79 - error from the SSH layer, somewhat generic so the error message will be of interest when this has happened */ exclz = eCurlErrSSH; break; #endif #ifdef HAVE_CURLE_SSL_SHUTDOWN_FAILED case CURLE_SSL_SHUTDOWN_FAILED: /* 80 - Failed to shut down the SSL connection */ exclz = eCurlErrSSLShutdownFailed; break; #endif #ifdef HAVE_CURLE_AGAIN case CURLE_AGAIN: /* 81 - socket is not ready for send/recv, wait till it's ready and try again (Added in 7.18.2) */ exclz = eCurlErrAgain; break; #endif #ifdef HAVE_CURLE_SSL_CRL_BADFILE case CURLE_SSL_CRL_BADFILE: /* 82 - could not load CRL file, missing or wrong format (Added in 7.19.0) */ exclz = eCurlErrSSLCRLBadfile; break; #endif #ifdef HAVE_CURLE_SSL_ISSUER_ERROR case CURLE_SSL_ISSUER_ERROR: /* 83 - Issuer check failed. (Added in 7.19.0) */ exclz = eCurlErrSSLIssuerError; break; #endif default: exclz = eCurlErrError; exmsg = "Unknown error result from libcurl"; } if (!exmsg) { exmsg = curl_easy_strerror(code); } results = rb_ary_new2(2); rb_ary_push(results, exclz); rb_ary_push(results, rb_str_new2(exmsg)); return results; }
static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh, int (*deriv)(const gsl_function *, double, double, double *, double *)) { gsl_function *f = NULL; double result, abserr, h; VALUE x, ary, aerr; gsl_vector *v = NULL, *vnew = NULL, *verr = NULL; gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL; size_t n, i, j; int status; Need_Float(hh); Data_Get_Struct(obj, gsl_function, f); h = NUM2DBL(hh); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: status = (*deriv)(f, NUM2DBL(xx), h, &result, &abserr); return rb_ary_new3(3, rb_float_new(result), rb_float_new(abserr), INT2FIX(status)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); (*deriv)(f, NUM2DBL(x), h, &result, &abserr); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(abserr)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { struct NARRAY *na; double *ptr1, *ptr2, *ptr3; VALUE ary2, ary3; GetNArray(xx, na); n = na->total; ptr1 = (double*) na->ptr; ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ary3 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary2, double*); ptr3 = NA_PTR_TYPE(ary3, double*); for (i = 0; i < n; i++) { (*deriv)(f, ptr1[i], h, &result, &abserr); ptr2[i] = result; ptr3[i] = abserr; } return rb_ary_new3(2, ary2, ary3); } #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++) { (*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, abserr); } 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++) { (*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, abserr); } } 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 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; 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; n = RARRAY_LEN(xx); 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)) { struct NARRAY *na; double *ptr1, *ptr2, *ptr3; 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 VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) { result_each_args args; VALUE defaults, opts, block, (*fetch_row_func)(VALUE, MYSQL_FIELD *fields, const result_each_args *args); ID db_timezone, app_timezone, dbTz, appTz; int symbolizeKeys, asArray, castBool, cacheRows, cast; GET_RESULT(self); if (wrapper->stmt_wrapper && wrapper->stmt_wrapper->closed) { rb_raise(cMysql2Error, "Statement handle already closed"); } defaults = rb_iv_get(self, "@query_options"); Check_Type(defaults, T_HASH); if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) { opts = rb_funcall(defaults, intern_merge, 1, opts); } else { opts = defaults; } symbolizeKeys = RTEST(rb_hash_aref(opts, sym_symbolize_keys)); asArray = rb_hash_aref(opts, sym_as) == sym_array; castBool = RTEST(rb_hash_aref(opts, sym_cast_booleans)); cacheRows = RTEST(rb_hash_aref(opts, sym_cache_rows)); cast = RTEST(rb_hash_aref(opts, sym_cast)); if (wrapper->is_streaming && cacheRows) { rb_warn(":cache_rows is ignored if :stream is true"); } if (wrapper->stmt_wrapper && !cacheRows && !wrapper->is_streaming) { rb_warn(":cache_rows is forced for prepared statements (if not streaming)"); } if (wrapper->stmt_wrapper && !cast) { rb_warn(":cast is forced for prepared statements"); } dbTz = rb_hash_aref(opts, sym_database_timezone); if (dbTz == sym_local) { db_timezone = intern_local; } else if (dbTz == sym_utc) { db_timezone = intern_utc; } else { if (!NIL_P(dbTz)) { rb_warn(":database_timezone option must be :utc or :local - defaulting to :local"); } db_timezone = intern_local; } appTz = rb_hash_aref(opts, sym_application_timezone); if (appTz == sym_local) { app_timezone = intern_local; } else if (appTz == sym_utc) { app_timezone = intern_utc; } else { app_timezone = Qnil; } if (wrapper->lastRowProcessed == 0 && !wrapper->is_streaming) { wrapper->numberOfRows = wrapper->stmt_wrapper ? mysql_stmt_num_rows(wrapper->stmt_wrapper->stmt) : mysql_num_rows(wrapper->result); if (wrapper->numberOfRows == 0) { rb_mysql_result_free_result(wrapper); wrapper->rows = rb_ary_new(); return wrapper->rows; } wrapper->rows = rb_ary_new2(wrapper->numberOfRows); } // Backward compat args.symbolizeKeys = symbolizeKeys; args.asArray = asArray; args.castBool = castBool; args.cacheRows = cacheRows; args.cast = cast; args.db_timezone = db_timezone; args.app_timezone = app_timezone; args.block_given = block; if (wrapper->stmt_wrapper) { fetch_row_func = rb_mysql_result_fetch_row_stmt; } else { fetch_row_func = rb_mysql_result_fetch_row; } return rb_mysql_result_each_(self, fetch_row_func, &args); }
static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, const result_each_args *args) { VALUE rowVal; unsigned int i = 0; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GET_RESULT(self); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif if (args->asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } if (wrapper->result_buffers == NULL) { rb_mysql_result_alloc_result_buffers(self, fields); } if (mysql_stmt_bind_result(wrapper->stmt_wrapper->stmt, wrapper->result_buffers)) { rb_raise_mysql2_stmt_error(wrapper->stmt_wrapper); } { switch((uintptr_t)rb_thread_call_without_gvl(nogvl_stmt_fetch, wrapper->stmt_wrapper->stmt, RUBY_UBF_IO, 0)) { case 0: /* success */ break; case 1: /* error */ rb_raise_mysql2_stmt_error(wrapper->stmt_wrapper); case MYSQL_NO_DATA: /* no more row */ return Qnil; case MYSQL_DATA_TRUNCATED: rb_raise(cMysql2Error, "IMPLBUG: caught MYSQL_DATA_TRUNCATED. should not come here as buffer_length is set to fields[i].max_length."); } } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys); VALUE val = Qnil; MYSQL_TIME *ts; if (wrapper->is_null[i]) { val = Qnil; } else { const MYSQL_BIND* const result_buffer = &wrapper->result_buffers[i]; switch(result_buffer->buffer_type) { case MYSQL_TYPE_TINY: // signed char if (args->castBool && fields[i].length == 1) { val = (*((unsigned char*)result_buffer->buffer) != 0) ? Qtrue : Qfalse; break; } if (result_buffer->is_unsigned) { val = UINT2NUM(*((unsigned char*)result_buffer->buffer)); } else { val = INT2NUM(*((signed char*)result_buffer->buffer)); } break; case MYSQL_TYPE_SHORT: // short int if (result_buffer->is_unsigned) { val = UINT2NUM(*((unsigned short int*)result_buffer->buffer)); } else { val = INT2NUM(*((short int*)result_buffer->buffer)); } break; case MYSQL_TYPE_INT24: // int case MYSQL_TYPE_LONG: // int case MYSQL_TYPE_YEAR: // int if (result_buffer->is_unsigned) { val = UINT2NUM(*((unsigned int*)result_buffer->buffer)); } else { val = INT2NUM(*((int*)result_buffer->buffer)); } break; case MYSQL_TYPE_LONGLONG: // long long int if (result_buffer->is_unsigned) { val = ULL2NUM(*((unsigned long long int*)result_buffer->buffer)); } else { val = LL2NUM(*((long long int*)result_buffer->buffer)); } break; case MYSQL_TYPE_FLOAT: // float val = rb_float_new((double)(*((float*)result_buffer->buffer))); break; case MYSQL_TYPE_DOUBLE: // double val = rb_float_new((double)(*((double*)result_buffer->buffer))); break; case MYSQL_TYPE_DATE: // MYSQL_TIME case MYSQL_TYPE_NEWDATE: // MYSQL_TIME ts = (MYSQL_TIME*)result_buffer->buffer; val = rb_funcall(cDate, intern_new, 3, INT2NUM(ts->year), INT2NUM(ts->month), INT2NUM(ts->day)); break; case MYSQL_TYPE_TIME: // MYSQL_TIME ts = (MYSQL_TIME*)result_buffer->buffer; val = rb_funcall(rb_cTime, args->db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), ULONG2NUM(ts->second_part)); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } break; case MYSQL_TYPE_DATETIME: // MYSQL_TIME case MYSQL_TYPE_TIMESTAMP: { // MYSQL_TIME uint64_t seconds; ts = (MYSQL_TIME*)result_buffer->buffer; seconds = (ts->year*31557600ULL) + (ts->month*2592000ULL) + (ts->day*86400ULL) + (ts->hour*3600ULL) + (ts->minute*60ULL) + ts->second; if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { // use DateTime instead VALUE offset = INT2NUM(0); if (args->db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, UINT2NUM(ts->year), UINT2NUM(ts->month), UINT2NUM(ts->day), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), offset); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { // utc val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { val = rb_funcall(rb_cTime, args->db_timezone, 7, UINT2NUM(ts->year), UINT2NUM(ts->month), UINT2NUM(ts->day), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), ULONG2NUM(ts->second_part)); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } } break; } case MYSQL_TYPE_DECIMAL: // char[] case MYSQL_TYPE_NEWDECIMAL: // char[] val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(result_buffer->buffer, *(result_buffer->length))); break; case MYSQL_TYPE_STRING: // char[] case MYSQL_TYPE_VAR_STRING: // char[] case MYSQL_TYPE_VARCHAR: // char[] case MYSQL_TYPE_TINY_BLOB: // char[] case MYSQL_TYPE_BLOB: // char[] case MYSQL_TYPE_MEDIUM_BLOB: // char[] case MYSQL_TYPE_LONG_BLOB: // char[] case MYSQL_TYPE_BIT: // char[] case MYSQL_TYPE_SET: // char[] case MYSQL_TYPE_ENUM: // char[] case MYSQL_TYPE_GEOMETRY: // char[] default: val = rb_str_new(result_buffer->buffer, *(result_buffer->length)); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (args->asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } return rowVal; }
static VALUE array_spec_rb_ary_new2(VALUE self, VALUE length) { return rb_ary_new2(NUM2LONG(length)); }
static VALUE variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE rbReturnType, VALUE options) { VariadicInvoker* invoker = NULL; VALUE retval = Qnil; VALUE convention = Qnil; VALUE fixed = Qnil; #if defined(X86_WIN32) VALUE rbConventionStr; #endif int i; Check_Type(options, T_HASH); convention = rb_hash_aref(options, ID2SYM(rb_intern("convention"))); Data_Get_Struct(self, VariadicInvoker, invoker); invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums"))); invoker->rbAddress = rbFunction; invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address; #if defined(X86_WIN32) rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL); invoker->abi = (RTEST(convention) && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0) ? FFI_STDCALL : FFI_DEFAULT_ABI; #else invoker->abi = FFI_DEFAULT_ABI; #endif invoker->rbReturnType = rbffi_Type_Lookup(rbReturnType); if (!RTEST(invoker->rbReturnType)) { VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL); rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName)); } Data_Get_Struct(rbReturnType, Type, invoker->returnType); invoker->paramCount = -1; fixed = rb_ary_new2(RARRAY_LEN(rbParameterTypes) - 1); for (i = 0; i < RARRAY_LEN(rbParameterTypes); ++i) { VALUE entry = rb_ary_entry(rbParameterTypes, i); VALUE rbType = rbffi_Type_Lookup(entry); Type* type; if (!RTEST(rbType)) { VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL); rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName)); } Data_Get_Struct(rbType, Type, type); if (type->nativeType != NATIVE_VARARGS) { rb_ary_push(fixed, entry); } } /* * @fixed and @type_map are used by the parameter mangling ruby code */ rb_iv_set(self, "@fixed", fixed); rb_iv_set(self, "@type_map", rb_hash_aref(options, ID2SYM(rb_intern("type_map")))); return retval; }
static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) { VALUE defaults, opts, block; ID db_timezone, app_timezone, dbTz, appTz; mysql2_result_wrapper * wrapper; unsigned long i; const char * errstr; int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1, streaming = 0; MYSQL_FIELD * fields = NULL; GetMysql2Result(self, wrapper); defaults = rb_iv_get(self, "@query_options"); Check_Type(defaults, T_HASH); if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) { opts = rb_funcall(defaults, intern_merge, 1, opts); } else { opts = defaults; } if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) { symbolizeKeys = 1; } if (rb_hash_aref(opts, sym_as) == sym_array) { asArray = 1; } if (rb_hash_aref(opts, sym_cast_booleans) == Qtrue) { castBool = 1; } if (rb_hash_aref(opts, sym_cache_rows) == Qfalse) { cacheRows = 0; } if (rb_hash_aref(opts, sym_cast) == Qfalse) { cast = 0; } if(rb_hash_aref(opts, sym_stream) == Qtrue) { streaming = 1; } if(streaming && cacheRows) { rb_warn("cacheRows is ignored if streaming is true"); } dbTz = rb_hash_aref(opts, sym_database_timezone); if (dbTz == sym_local) { db_timezone = intern_local; } else if (dbTz == sym_utc) { db_timezone = intern_utc; } else { if (!NIL_P(dbTz)) { rb_warn(":database_timezone option must be :utc or :local - defaulting to :local"); } db_timezone = intern_local; } appTz = rb_hash_aref(opts, sym_application_timezone); if (appTz == sym_local) { app_timezone = intern_local; } else if (appTz == sym_utc) { app_timezone = intern_utc; } else { app_timezone = Qnil; } if (wrapper->lastRowProcessed == 0) { if (streaming) { /* We can't get number of rows if we're streaming, */ /* until we've finished fetching all rows */ wrapper->numberOfRows = 0; wrapper->rows = rb_ary_new(); } else { wrapper->numberOfRows = mysql_num_rows(wrapper->result); if (wrapper->numberOfRows == 0) { wrapper->rows = rb_ary_new(); return wrapper->rows; } wrapper->rows = rb_ary_new2(wrapper->numberOfRows); } } if (streaming) { if (!wrapper->streamingComplete) { VALUE row; fields = mysql_fetch_fields(wrapper->result); do { row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields); if (block != Qnil && row != Qnil) { rb_yield(row); wrapper->lastRowProcessed++; } } while(row != Qnil); rb_mysql_result_free_result(wrapper); wrapper->numberOfRows = wrapper->lastRowProcessed; wrapper->streamingComplete = 1; // Check for errors, the connection might have gone out from under us // mysql_error returns an empty string if there is no error errstr = mysql_error(wrapper->client_wrapper->client); if (errstr[0]) { rb_raise(cMysql2Error, "%s", errstr); } } else { rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery)."); } } else { if (cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) { /* we've already read the entire dataset from the C result into our */ /* internal array. Lets hand that over to the user since it's ready to go */ for (i = 0; i < wrapper->numberOfRows; i++) { rb_yield(rb_ary_entry(wrapper->rows, i)); } } else { unsigned long rowsProcessed = 0; rowsProcessed = RARRAY_LEN(wrapper->rows); fields = mysql_fetch_fields(wrapper->result); for (i = 0; i < wrapper->numberOfRows; i++) { VALUE row; if (cacheRows && i < rowsProcessed) { row = rb_ary_entry(wrapper->rows, i); } else { row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields); if (cacheRows) { rb_ary_store(wrapper->rows, i, row); } wrapper->lastRowProcessed++; } if (row == Qnil) { /* we don't need the mysql C dataset around anymore, peace it */ rb_mysql_result_free_result(wrapper); return Qnil; } if (block != Qnil) { rb_yield(row); } } if (wrapper->lastRowProcessed == wrapper->numberOfRows) { /* we don't need the mysql C dataset around anymore, peace it */ rb_mysql_result_free_result(wrapper); } } } return wrapper->rows; }
static VALUE step(VALUE self) { sqlite3StmtRubyPtr ctx; sqlite3_stmt *stmt; int value, length; VALUE list; rb_encoding * internal_encoding; Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); if(ctx->done_p) return Qnil; { VALUE db = rb_iv_get(self, "@connection"); rb_funcall(db, rb_intern("encoding"), 0); internal_encoding = rb_default_internal_encoding(); } 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) ); rb_enc_associate_index(str, rb_utf8_encindex()); if(internal_encoding) str = rb_str_export_to_enc(str, internal_encoding); 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: sqlite3_reset(stmt); ctx->done_p = 0; CHECK(sqlite3_db_handle(ctx->st), value); } return list; }
static VALUE rb_keychain_find(int argc, VALUE *argv, VALUE self){ VALUE kind; VALUE attributes; VALUE first_or_all; rb_scan_args(argc, argv, "2:", &first_or_all, &kind, &attributes); Check_Type(first_or_all, T_SYMBOL); Check_Type(kind, T_STRING); CFMutableDictionaryRef query = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFDictionarySetValue(query, kSecReturnAttributes, kCFBooleanTrue); CFDictionarySetValue(query, kSecReturnRef, kCFBooleanTrue); if(rb_to_id(first_or_all) == rb_intern("all")){ CFDictionarySetValue(query, kSecMatchLimit, kSecMatchLimitAll); } rb_add_value_to_cf_dictionary(query, kSecClass, kind); if(!NIL_P(attributes)){ Check_Type(attributes, T_HASH); VALUE rb_keychains = rb_hash_aref(attributes, ID2SYM(rb_intern("keychains"))); if(!NIL_P(rb_keychains)){ Check_Type(rb_keychains, T_ARRAY); CFMutableArrayRef searchArray = CFArrayCreateMutable(NULL, RARRAY_LEN(rb_keychains), &kCFTypeArrayCallBacks); for(int index=0; index < RARRAY_LEN(rb_keychains); index++){ SecKeychainRef keychain = NULL; Data_Get_Struct(RARRAY_PTR(rb_keychains)[index], struct OpaqueSecKeychainRef, keychain); CFArrayAppendValue(searchArray, keychain); } CFDictionarySetValue(query, kSecMatchSearchList,searchArray); CFRelease(searchArray); } VALUE limit = rb_hash_aref(attributes, ID2SYM(rb_intern("limit"))); if(!NIL_P(limit)){ Check_Type(limit, T_FIXNUM); long c_limit = FIX2LONG(limit); CFNumberRef cf_limit = CFNumberCreate(NULL, kCFNumberLongType, &c_limit); CFDictionarySetValue(query, kSecMatchLimit, cf_limit); CFRelease(cf_limit); } VALUE conditions = rb_hash_aref(attributes, ID2SYM(rb_intern("conditions"))); if(!NIL_P(conditions)){ Check_Type(conditions, T_HASH); VALUE rQuery = Data_Wrap_Struct(rb_cPointerWrapper, NULL, NULL, query); rb_block_call(conditions, rb_intern("each"), 0, NULL, RUBY_METHOD_FUNC(add_conditions_to_query), rQuery); } } CFDictionaryRef result; OSStatus status = SecItemCopyMatching(query, (CFTypeRef*)&result); CFRelease(query); VALUE rb_item = rb_ary_new2(0); switch(status){ case errSecItemNotFound: break; default: CheckOSStatusOrRaise(status); if(CFArrayGetTypeID() == CFGetTypeID(result)){ CFArrayRef result_array = (CFArrayRef)result; for(CFIndex i = 0; i < CFArrayGetCount(result_array); i++){ rb_ary_push(rb_item,rb_keychain_item_from_sec_dictionary(CFArrayGetValueAtIndex(result_array,i))); } } else{ rb_ary_push(rb_item, rb_keychain_item_from_sec_dictionary(result)); } CFRelease(result); } if(rb_to_id(first_or_all) == rb_intern("first")){ return rb_ary_entry(rb_item,0); } else{ return rb_item; } }
static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) { VALUE result = Qnil; if (ttype == TTYPE_BOOL) { result = mt->read_bool(protocol); } else if (ttype == TTYPE_BYTE) { result = mt->read_byte(protocol); } else if (ttype == TTYPE_I16) { result = mt->read_i16(protocol); } else if (ttype == TTYPE_I32) { result = mt->read_i32(protocol); } else if (ttype == TTYPE_I64) { result = mt->read_i64(protocol); } else if (ttype == TTYPE_STRING) { result = mt->read_string(protocol); } else if (ttype == TTYPE_DOUBLE) { result = mt->read_double(protocol); } else if (ttype == TTYPE_STRUCT) { VALUE klass = rb_hash_aref(field_info, class_sym); result = rb_class_new_instance(0, NULL, klass); rb_thrift_struct_read(result, protocol); } else if (ttype == TTYPE_MAP) { int i; VALUE map_header = mt->read_map_begin(protocol); int key_ttype = FIX2INT(rb_ary_entry(map_header, 0)); int value_ttype = FIX2INT(rb_ary_entry(map_header, 1)); int num_entries = FIX2INT(rb_ary_entry(map_header, 2)); VALUE key_info = rb_hash_aref(field_info, key_sym); VALUE value_info = rb_hash_aref(field_info, value_sym); result = rb_hash_new(); for (i = 0; i < num_entries; ++i) { VALUE key, val; key = read_anything(protocol, key_ttype, key_info); val = read_anything(protocol, value_ttype, value_info); rb_hash_aset(result, key, val); } mt->read_map_end(protocol); } else if (ttype == TTYPE_LIST) { int i; VALUE list_header = mt->read_list_begin(protocol); int element_ttype = FIX2INT(rb_ary_entry(list_header, 0)); int num_elements = FIX2INT(rb_ary_entry(list_header, 1)); result = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym))); } mt->read_list_end(protocol); } else if (ttype == TTYPE_SET) { VALUE items; int i; VALUE set_header = mt->read_set_begin(protocol); int element_ttype = FIX2INT(rb_ary_entry(set_header, 0)); int num_elements = FIX2INT(rb_ary_entry(set_header, 1)); items = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym))); } mt->read_set_end(protocol); result = rb_class_new_instance(1, &items, rb_cSet); } else { rb_raise(rb_eNotImpError, "read_anything not implemented for type %d!", ttype); } return result; }
static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const result_each_args *args) { VALUE rowVal; MYSQL_ROW row; unsigned int i = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GET_RESULT(self); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_call_without_gvl(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } if (args->asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys); if (row[i]) { VALUE val = Qnil; enum enum_field_types type = fields[i].type; if (!args->cast) { if (type == MYSQL_TYPE_NULL) { val = Qnil; } else { val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif } } else { switch(type) { case MYSQL_TYPE_NULL: /* NULL-type field */ val = Qnil; break; case MYSQL_TYPE_BIT: /* BIT field (MySQL 5.0.3 and up) */ if (args->castBool && fields[i].length == 1) { val = *row[i] == 1 ? Qtrue : Qfalse; }else{ val = rb_str_new(row[i], fieldLengths[i]); } break; case MYSQL_TYPE_TINY: /* TINYINT field */ if (args->castBool && fields[i].length == 1) { val = *row[i] != '0' ? Qtrue : Qfalse; break; } case MYSQL_TYPE_SHORT: /* SMALLINT field */ case MYSQL_TYPE_LONG: /* INTEGER field */ case MYSQL_TYPE_INT24: /* MEDIUMINT field */ case MYSQL_TYPE_LONGLONG: /* BIGINT field */ case MYSQL_TYPE_YEAR: /* YEAR field */ val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: /* DECIMAL or NUMERIC field */ case MYSQL_TYPE_NEWDECIMAL: /* Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) */ if (fields[i].decimals == 0) { val = rb_cstr2inum(row[i], 10); } else if (strtod(row[i], NULL) == 0.000000){ val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero); }else{ val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); } break; case MYSQL_TYPE_FLOAT: /* FLOAT field */ case MYSQL_TYPE_DOUBLE: { /* DOUBLE or REAL field */ double column_to_double; column_to_double = strtod(row[i], NULL); if (column_to_double == 0.000000){ val = opt_float_zero; }else{ val = rb_float_new(column_to_double); } break; } case MYSQL_TYPE_TIME: { /* TIME field */ int tokens; unsigned int hour=0, min=0, sec=0, msec=0; char msec_char[7] = {'0','0','0','0','0','0','\0'}; tokens = sscanf(row[i], "%2u:%2u:%2u.%6s", &hour, &min, &sec, msec_char); if (tokens < 3) { val = Qnil; break; } msec = msec_char_to_uint(msec_char, sizeof(msec_char)); val = rb_funcall(rb_cTime, args->db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec)); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { /* utc */ val = rb_funcall(val, intern_utc, 0); } } break; } case MYSQL_TYPE_TIMESTAMP: /* TIMESTAMP field */ case MYSQL_TYPE_DATETIME: { /* DATETIME field */ int tokens; unsigned int year=0, month=0, day=0, hour=0, min=0, sec=0, msec=0; char msec_char[7] = {'0','0','0','0','0','0','\0'}; uint64_t seconds; tokens = sscanf(row[i], "%4u-%2u-%2u %2u:%2u:%2u.%6s", &year, &month, &day, &hour, &min, &sec, msec_char); if (tokens < 6) { /* msec might be empty */ val = Qnil; break; } seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec; if (seconds == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date in field '%.*s': %s", fields[i].name_length, fields[i].name, row[i]); val = Qnil; } else { if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { /* use DateTime for larger date range, does not support microseconds */ VALUE offset = INT2NUM(0); if (args->db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), offset); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { /* utc */ val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { msec = msec_char_to_uint(msec_char, sizeof(msec_char)); val = rb_funcall(rb_cTime, args->db_timezone, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec)); if (!NIL_P(args->app_timezone)) { if (args->app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { /* utc */ val = rb_funcall(val, intern_utc, 0); } } } } } break; } case MYSQL_TYPE_DATE: /* DATE field */ case MYSQL_TYPE_NEWDATE: { /* Newer const used > 5.0 */ int tokens; unsigned int year=0, month=0, day=0; tokens = sscanf(row[i], "%4u-%2u-%2u", &year, &month, &day); if (tokens < 3) { val = Qnil; break; } if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date in field '%.*s': %s", fields[i].name_length, fields[i].name, row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: /* CHAR or BINARY field */ case MYSQL_TYPE_SET: /* SET field */ case MYSQL_TYPE_ENUM: /* ENUM field */ case MYSQL_TYPE_GEOMETRY: /* Spatial fielda */ default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (args->asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } else { if (args->asArray) { rb_ary_push(rowVal, Qnil); } else { rb_hash_aset(rowVal, field, Qnil); } } } return rowVal; }
static VALUE rb_gsl_math_eval2(double (*func)(const double, const double), VALUE xx, VALUE yy) { VALUE x, y, ary; size_t i, j, size; gsl_vector *v = NULL, *v2 = NULL, *vnew = NULL; gsl_matrix *m = NULL, *m2 = NULL, *mnew = NULL; if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: Need_Float(yy); return rb_float_new((*func)(NUM2DBL(xx), NUM2DBL(yy))); break; case T_ARRAY: Check_Type(yy, T_ARRAY); size = RARRAY_LEN(xx); // if (size != RARRAY(yy)->len) rb_raise(rb_eRuntimeError, "array sizes are different."); if ((int) size != RARRAY_LEN(yy)) rb_raise(rb_eRuntimeError, "array sizes are different."); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); y = rb_ary_entry(yy, i); Need_Float(x); Need_Float(y); // rb_ary_store(ary, i, rb_float_new((*func)(RFLOAT(x)->value, RFLOAT(y)->value))); rb_ary_store(ary, i, rb_float_new((*func)(NUM2DBL(x), NUM2DBL(y)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { struct NARRAY *nax, *nay; double *ptr1, *ptr2, *ptr3; GetNArray(xx, nax); GetNArray(yy, nay); ptr1 = (double*) nax->ptr; ptr2 = (double*) nay->ptr; size = nax->total; ary = na_make_object(NA_DFLOAT, nax->rank, nax->shape, CLASS_OF(xx)); ptr3 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) ptr3[i] = (*func)(ptr1[i], ptr2[i]); return ary; } #endif if (VECTOR_P(xx)) { CHECK_VECTOR(yy); Data_Get_Struct(xx, gsl_vector, v); Data_Get_Struct(yy, gsl_vector, v2); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*func)(gsl_vector_get(v, i), gsl_vector_get(v2, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { CHECK_MATRIX(yy); Data_Get_Struct(xx, gsl_matrix, m); Data_Get_Struct(yy, gsl_matrix, m2); 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, (*func)(gsl_matrix_get(m, i, j), gsl_matrix_get(m2, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s " "(Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; }
VALUE ruby_libvirt_ary_new2_wrap(VALUE arg) { return rb_ary_new2(*((int *)arg)); }
static VALUE rb_gsl_pow_int(VALUE obj, VALUE xx, VALUE nn) { VALUE x, ary, argv[2]; size_t i, j, size; int n; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; 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_pow_int(NUM2DBL(xx), FIX2INT(nn))); break; case T_ARRAY: CHECK_FIXNUM(nn); n = FIX2INT(nn); size = RARRAY_LEN(xx); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); Need_Float(x); // rb_ary_store(ary, i, rb_float_new(gsl_pow_int(RFLOAT(x)->value, n))); rb_ary_store(ary, i, rb_float_new(gsl_pow_int(NUM2DBL(x), n))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { struct NARRAY *na; double *ptr1, *ptr2; CHECK_FIXNUM(nn); n = FIX2INT(nn); GetNArray(xx, na); ptr1 = (double*) na->ptr; size = 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 < size; i++) ptr2[i] = gsl_pow_int(ptr1[i], n); return ary; } #endif if (VECTOR_P(xx)) { CHECK_FIXNUM(nn); n = FIX2INT(nn); 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_pow_int(gsl_vector_get(v, i), n)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { CHECK_FIXNUM(nn); n = FIX2INT(nn); 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_pow_int(gsl_matrix_get(m, i, j), n)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else if (COMPLEX_P(xx) || VECTOR_COMPLEX_P(xx) || MATRIX_COMPLEX_P(xx)) { argv[0] = xx; argv[1] = nn; return rb_gsl_complex_pow_real(2, argv, obj); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; }
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; 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; n = RARRAY_LEN(xx); 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)) { struct NARRAY *na; double *ptr1, *ptr2; 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 */ }
static VALUE rb_gsl_interp_evaluate(VALUE obj, VALUE xxa, VALUE yya, VALUE xx, double (*eval)(const gsl_interp *, const double [], const double [], double, gsl_interp_accel *)) { rb_gsl_interp *rgi = NULL; double *ptrx = NULL, *ptry = NULL; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, x; double val; size_t n, i, j, size, stridex, stridey; #ifdef HAVE_NARRAY_H struct NARRAY *na = NULL; double *ptrz = NULL, *ptr = NULL; #endif Data_Get_Struct(obj, rb_gsl_interp, rgi); ptrx = get_vector_ptr(xxa, &stridex, &size); if (size != rgi->p->size ){ rb_raise(rb_eTypeError, "size mismatch (xa:%d != %d)", (int) size, (int) rgi->p->size); } ptry = get_vector_ptr(yya, &stridey, &size); if (size != rgi->p->size ){ rb_raise(rb_eTypeError, "size mismatch (ya:%d != %d)", (int) size, (int) rgi->p->size); } if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: Need_Float(xx); return rb_float_new((*eval)(rgi->p, ptrx, ptry, NUM2DBL(xx), rgi->a)); 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(x); val = (*eval)(rgi->p, ptrx, ptry, NUM2DBL(x), rgi->a); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptrz = (double*) na->ptr; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr = NA_PTR_TYPE(ary, double*); for (i = 0; i < na->total; i++) ptr[i] = (*eval)(rgi->p, ptrx, ptry, ptrz[i], rgi->a); 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++) { val = (*eval)(rgi->p, ptrx, ptry, gsl_vector_get(v, i), rgi->a); gsl_vector_set(vnew, i, val); } 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++) { val = (*eval)(rgi->p, ptrx, ptry, gsl_matrix_get(m, i, j), rgi->a); gsl_matrix_set(mnew, i, j, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; }
/* * Reads the specified list of items and returns their values and limits * state. * * @param item_array [Array<Array(String String String)>] An array * consisting of [target name, packet name, item name] * @param value_types [Symbol|Array<Symbol>] How to convert the items before * returning. A single symbol of {Packet::VALUE_TYPES} * can be passed which will convert all items the same way. Or * an array of symbols can be passed to control how each item is * converted. * @return [Array, Array, Array] The first array contains the item values, the * second their limits state, and the third the limits settings which includes * red, yellow, and green (if given) limits values. */ static VALUE values_and_limits_states(int argc, VALUE* argv, VALUE self) { volatile VALUE item_array = Qnil; volatile VALUE value_types = Qnil; volatile VALUE items = Qnil; volatile VALUE states = Qnil; volatile VALUE settings = Qnil; volatile VALUE entry = Qnil; volatile VALUE target_name = Qnil; volatile VALUE packet_name = Qnil; volatile VALUE item_name = Qnil; volatile VALUE value_type = Qnil; volatile VALUE result = Qnil; volatile VALUE return_value = Qnil; volatile VALUE limits = Qnil; volatile VALUE limits_set = Qnil; volatile VALUE limits_values = Qnil; volatile VALUE limits_settings = Qnil; long length = 0; long value_types_length = 0; int index = 0; switch (argc) { case 1: item_array = argv[0]; value_types = symbol_CONVERTED; break; case 2: item_array = argv[0]; value_types = argv[1]; break; default: /* Invalid number of arguments given */ rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc); break; }; items = rb_ary_new(); /* Verify items is a nested array */ entry = rb_ary_entry(item_array, index); if (TYPE(entry) != T_ARRAY) { rb_raise(rb_eArgError, "item_array must be a nested array consisting of [[tgt,pkt,item],[tgt,pkt,item],...]"); } states = rb_ary_new(); settings = rb_ary_new(); limits_set = rb_funcall(cSystem, id_method_limits_set, 0); length = RARRAY_LEN(item_array); if (TYPE(value_types) == T_ARRAY) { value_types_length = RARRAY_LEN(value_types); if (length != value_types_length) { rb_raise(rb_eArgError, "Passed %ld items but only %ld value types", length, value_types_length); } for (index = 0; index < length; index++) { entry = rb_ary_entry(item_array, index); target_name = rb_ary_entry(entry, 0); packet_name = rb_ary_entry(entry, 1); item_name = rb_ary_entry(entry, 2); value_type = rb_ary_entry(value_types, index); value_type = rb_funcall(value_type, id_method_intern, 0); result = packet_and_item(self, target_name, packet_name, item_name); rb_ary_push(items, rb_funcall(rb_ary_entry(result, 0), id_method_read, 2, item_name, value_type)); limits = rb_funcall(rb_ary_entry(result, 1), id_method_limits, 0); rb_ary_push(states, rb_funcall(limits, id_method_state, 0)); limits_values = rb_funcall(limits, id_method_values, 0); if (RTEST(limits_values)) { limits_settings = rb_hash_aref(limits_values, limits_set); } else { limits_settings = Qnil; } rb_ary_push(settings, limits_settings); } } else { value_type = rb_funcall(value_types, id_method_intern, 0); for (index = 0; index < length; index++) { entry = rb_ary_entry(item_array, index); target_name = rb_ary_entry(entry, 0); packet_name = rb_ary_entry(entry, 1); item_name = rb_ary_entry(entry, 2); result = packet_and_item(self, target_name, packet_name, item_name); rb_ary_push(items, rb_funcall(rb_ary_entry(result, 0), id_method_read, 2, item_name, value_type)); limits = rb_funcall(rb_ary_entry(result, 1), id_method_limits, 0); rb_ary_push(states, rb_funcall(limits, id_method_state, 0)); limits_values = rb_funcall(limits, id_method_values, 0); if (RTEST(limits_values)) { limits_settings = rb_hash_aref(limits_values, limits_set); } else { limits_settings = Qnil; } rb_ary_push(settings, limits_settings); } } return_value = rb_ary_new2(3); rb_ary_push(return_value, items); rb_ary_push(return_value, states); rb_ary_push(return_value, settings); return return_value; }
/* call-seq: track_get_audio_channel_map() -> array Returns an array n-channels in length Array contains Hashes in the form: {:assignment => :description} where :description is a symbol representing an audio channel description. eg. :Left, :Right, :Mono */ static VALUE track_get_audio_channel_map(VALUE obj) { AudioChannelLayout *layout = track_get_audio_channel_layout(obj); if (layout == NULL) return Qnil; VALUE channels = Qnil; UInt32 numChannels, x, highLayoutTag; VALUE channel; char message[256]; AudioChannelLayoutTag layoutTag = layout->mChannelLayoutTag; if (layoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) { // using the descriptions // not implemented numChannels = layout->mNumberChannelDescriptions; channels = rb_ary_new2(numChannels); // loop through all channels, adding assignment descriptions AudioChannelDescription desc; char *trackStr; for (x=0; x < numChannels; x++) { desc = layout->mChannelDescriptions[x]; trackStr = track_str_for_AudioChannelLabel(desc.mChannelLabel); if (trackStr != NULL) { ADD_CHANNEL(channels, channel, trackStr); } else { // unsupported audio channel labels ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); sprintf(message, "ChannelLabel unsupported by rmov: %d", (int)desc.mChannelLabel); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2(message)); } } } else { numChannels = AudioChannelLayoutTag_GetNumberOfChannels(layoutTag); channels = rb_ary_new2(numChannels); if (layoutTag == kAudioChannelLayoutTag_UseChannelBitmap) { // use the bitmap approach // not implemented //rb_raise(eQuickTime, "Not Implemented: kAudioChannelLayoutTag_UseChannelBitmap in track_get_audio_channel_map"); for (x=0; x < numChannels; x++) { ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2("UseChannelBitmap unsupported by rmov")); } } else { // using a standard LayoutTag switch (layoutTag) { case kAudioChannelLayoutTag_Mono: ADD_CHANNEL(channels, channel, "Mono"); break; case kAudioChannelLayoutTag_Stereo: ADD_CHANNEL(channels, channel, "Left"); ADD_CHANNEL(channels, channel, "Right"); break; case kAudioChannelLayoutTag_MatrixStereo: ADD_CHANNEL(channels, channel, "LeftTotal"); ADD_CHANNEL(channels, channel, "RightTotal"); break; case kAudioChannelLayoutTag_SMPTE_DTV: ADD_CHANNEL(channels, channel, "Left"); ADD_CHANNEL(channels, channel, "Right"); ADD_CHANNEL(channels, channel, "Center"); ADD_CHANNEL(channels, channel, "LFEScreen"); ADD_CHANNEL(channels, channel, "LeftSurround"); ADD_CHANNEL(channels, channel, "RightSurround"); ADD_CHANNEL(channels, channel, "LeftTotal"); ADD_CHANNEL(channels, channel, "RightTotal"); break; default: // unsupported channels highLayoutTag = (layoutTag & 0xff0000) >> 16; sprintf(message, "layoutTag unsupported by rmov: (%dL << 16) | %d", (int)highLayoutTag, (int)numChannels); for (x=0; x < numChannels; x++) { ADD_CHANNEL(channels, channel, "UnsupportedByRMov"); rb_hash_aset(channel, ID2SYM(rb_intern("message")), rb_str_new2(message)); } //rb_raise(eQuickTime, "Unsupported ChannelLayoutTag in track_get_audio_channel_map: %d", layoutTag); break; } } } free(layout); return channels; }
/* * call-seq: * OpenLDAP.split_url( str ) -> array * * Split an LDAP URL into an array of its parts: * - uri_scheme * - host * - port * - base * - attrs * - scope * - filter * - exts * - crit_exts */ static VALUE ropenldap_s_split_url( VALUE UNUSED(module), VALUE urlstring ) { const char *url = StringValueCStr( urlstring ); LDAPURLDesc *urldesc; VALUE rval = Qnil, obj = Qnil; if ( !ldap_is_ldap_url(url) ) rb_raise( rb_eArgError, "Not an LDAP URL." ); /* Parse the URL */ if ( ldap_url_parse(url, &urldesc) != 0 ) rb_raise( rb_eRuntimeError, "Error parsing %s as an LDAP URL!", url ); rval = rb_ary_new2( 9 ); /* Scheme */ if ( urldesc->lud_scheme ) { ropenldap_log( "debug", " parsed scheme: %s", urldesc->lud_scheme ); obj = rb_str_new2( urldesc->lud_scheme ); OBJ_INFECT( obj, urlstring ); rb_ary_store( rval, 0L, obj ); } /* LDAP host to contact */ if ( urldesc->lud_host ) { ropenldap_log( "debug", " parsed host: %s", urldesc->lud_host ); obj = rb_str_new2( urldesc->lud_host ); OBJ_INFECT( obj, urlstring ); rb_ary_store( rval, 1L, obj ); } /* Port */ rb_ary_store( rval, 2L, INT2FIX(urldesc->lud_port) ); /* Base DN */ if ( urldesc->lud_dn ) { ropenldap_log( "debug", " parsed DN: %s", urldesc->lud_dn ); obj = rb_str_new2( urldesc->lud_dn ); OBJ_INFECT( obj, urlstring ); rb_ary_store( rval, 3L, obj ); } /* Attributes */ rb_ary_store( rval, 4L, ropenldap_rb_string_array(urldesc->lud_attrs) ); /* Numeric scope (LDAP_SCOPE_*) */ rb_ary_store( rval, 5L, INT2FIX(urldesc->lud_scope) ); /* Filter */ if ( urldesc->lud_filter ) { ropenldap_log( "debug", " parsed filter: %s", urldesc->lud_filter ); obj = rb_str_new2( urldesc->lud_filter ); OBJ_INFECT( obj, urlstring ); rb_ary_store( rval, 6L, obj ); } /* lists of LDAP extensions */ rb_ary_store( rval, 7L, ropenldap_rb_string_array(urldesc->lud_exts) ); /* Critical extension/s flag */ rb_ary_store( rval, 8L, urldesc->lud_crit_exts ? Qtrue : Qfalse ); ldap_free_urldesc( urldesc ); return rval; }
static VALUE rb_matrix_form(VALUE self, VALUE n) { VALUE base_ary; VALUE res_ary; VALUE tmp_ary; long ary_len = 2; if(TYPE(n) != T_FIXNUM) { rb_raise(rb_eArgError, "Invalid argument for type Fixnum"); return Qnil; } if(RTEST(rb_funcall(n, id_lt, 1, ZERO))) { rb_raise(rb_eArgError, "n cannot be negative"); return Qnil; } else { base_ary = rb_ary_new2(ARY_LEN); res_ary = rb_ary_new2(ARY_LEN); tmp_ary = rb_ary_new2(ARY_LEN); /* base is {{1, 1}, {1, 0}} */ rb_ary_push(tmp_ary, ONE); rb_ary_push(tmp_ary, ONE); rb_ary_push(base_ary, tmp_ary); tmp_ary = rb_ary_new2(ARY_LEN); rb_ary_push(tmp_ary, ONE); rb_ary_push(tmp_ary, ZERO); rb_ary_push(base_ary, tmp_ary); /* res is {{1, 0}, {0, 1}} */ tmp_ary = rb_ary_new2(ARY_LEN); rb_ary_push(tmp_ary, ONE); rb_ary_push(tmp_ary, ZERO); rb_ary_push(res_ary, tmp_ary); tmp_ary = rb_ary_new2(ARY_LEN); rb_ary_push(tmp_ary, ZERO); rb_ary_push(tmp_ary, ONE); rb_ary_push(res_ary, tmp_ary); while(!rb_equal(n, ZERO)) { if(rb_equal(rb_funcall(n, id_mod, 1, TWO), ZERO)) { n = rb_funcall(n, id_div, 1, TWO); base_ary = rb_matrix_mul(base_ary, base_ary); } else { n = rb_funcall(n, id_minus, 1, ONE); res_ary = rb_matrix_mul(res_ary, base_ary); } } } return res_ary; }
/* * call-seq: initialize(fields, size, align) * @param [Array<StructLayout::Field>] fields * @param [Numeric] size * @param [Numeric] align * @return [self] * A new StructLayout instance. */ static VALUE struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align) { StructLayout* layout; ffi_type* ltype; int i; Data_Get_Struct(self, StructLayout, layout); layout->fieldCount = (int) RARRAY_LEN(fields); layout->rbFieldMap = rb_hash_new(); layout->rbFieldNames = rb_ary_new2(layout->fieldCount); layout->size = (int) FFI_ALIGN(NUM2INT(size), NUM2INT(align)); layout->align = NUM2INT(align); layout->fields = xcalloc(layout->fieldCount, sizeof(StructField *)); layout->ffiTypes = xcalloc(layout->fieldCount + 1, sizeof(ffi_type *)); layout->rbFields = rb_ary_new2(layout->fieldCount); layout->referenceFieldCount = 0; layout->base.ffiType->elements = layout->ffiTypes; layout->base.ffiType->size = layout->size; layout->base.ffiType->alignment = layout->align; ltype = layout->base.ffiType; for (i = 0; i < (int) layout->fieldCount; ++i) { VALUE rbField = rb_ary_entry(fields, i); VALUE rbName; StructField* field; ffi_type* ftype; if (!rb_obj_is_kind_of(rbField, rbffi_StructLayoutFieldClass)) { rb_raise(rb_eTypeError, "wrong type for field %d.", i); } rbName = rb_funcall2(rbField, rb_intern("name"), 0, NULL); Data_Get_Struct(rbField, StructField, field); layout->fields[i] = field; if (field->type == NULL || field->type->ffiType == NULL) { rb_raise(rb_eRuntimeError, "type of field %d not supported", i); } ftype = field->type->ffiType; if (ftype->size == 0 && i < ((int) layout->fieldCount - 1)) { rb_raise(rb_eTypeError, "type of field %d has zero size", i); } if (field->referenceRequired) { field->referenceIndex = layout->referenceFieldCount++; } layout->ffiTypes[i] = ftype->size > 0 ? ftype : NULL; st_insert(layout->fieldSymbolTable, rbName, rbField); rb_hash_aset(layout->rbFieldMap, rbName, rbField); rb_ary_push(layout->rbFields, rbField); rb_ary_push(layout->rbFieldNames, rbName); } if (ltype->size == 0) { rb_raise(rb_eRuntimeError, "Struct size is zero"); } return self; }
static VALUE read_anything(VALUE protocol, field_metadata* fmd, protocol_method_table *pmt) { VALUE result = Qnil; if (fmd->type == TTYPE_BOOL) { result = fastcall_call(pmt->read_bool, protocol, Qnil); } else if (fmd->type == TTYPE_BYTE) { result = fastcall_call(pmt->read_byte, protocol, Qnil); } else if (fmd->type == TTYPE_I16) { result = fastcall_call(pmt->read_i16, protocol, Qnil); } else if (fmd->type == TTYPE_I32) { result = fastcall_call(pmt->read_i32, protocol, Qnil); } else if (fmd->type == TTYPE_I64) { result = fastcall_call(pmt->read_i64, protocol, Qnil); } else if (fmd->type == TTYPE_STRING) { result = fastcall_call(pmt->read_string, protocol, Qnil); } else if (fmd->type == TTYPE_DOUBLE) { result = fastcall_call(pmt->read_double, protocol, Qnil); } else if (fmd->type == TTYPE_STRUCT) { result = rb_class_new_instance(0, NULL, fmd->klass_v); if (rb_obj_is_kind_of(result, thrift_union_class)) { union_read(result, protocol, pmt); } else { struct_read(result, protocol, pmt); } } else if (fmd->type == TTYPE_MAP) { int i; VALUE map_header = fastcall_call(pmt->read_map_begin, protocol, Qnil); int key_ttype = FIX2INT(rb_ary_entry(map_header, 0)); int value_ttype = FIX2INT(rb_ary_entry(map_header, 1)); int num_entries = FIX2INT(rb_ary_entry(map_header, 2)); // Check the declared key and value types against the expected ones and skip the map contents // if the types don't match. field_metadata* key_md = fmd->key; field_metadata* value_md = fmd->value; if (key_md && value_md) { int specified_key_type = key_md->type; int specified_value_type = value_md->type; if (num_entries == 0 || (specified_key_type == key_ttype && specified_value_type == value_ttype)) { result = rb_hash_new(); for (i = 0; i < num_entries; ++i) { VALUE key, val; key = read_anything(protocol, key_md, pmt); val = read_anything(protocol, value_md, pmt); rb_hash_aset(result, key, val); } } else { skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries); } } else { skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries); } fastcall_call(pmt->read_map_end, protocol, Qnil); } else if (fmd->type == TTYPE_LIST) { int i; VALUE list_header = fastcall_call(pmt->read_list_begin, protocol, Qnil); int element_ttype = FIX2INT(rb_ary_entry(list_header, 0)); int num_elements = FIX2INT(rb_ary_entry(list_header, 1)); // Check the declared element type against the expected one and skip the list contents // if the types don't match. field_metadata* element_md = fmd->element; if (element_md) { int specified_element_type = element_md->type; if (specified_element_type == element_ttype) { result = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(result, read_anything(protocol, element_md, pmt)); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } fastcall_call(pmt->read_list_end, protocol, Qnil); } else if (fmd->type == TTYPE_SET) { VALUE items; int i; VALUE set_header = fastcall_call(pmt->read_set_begin, protocol, Qnil); int element_ttype = FIX2INT(rb_ary_entry(set_header, 0)); int num_elements = FIX2INT(rb_ary_entry(set_header, 1)); // Check the declared element type against the expected one and skip the set contents // if the types don't match. field_metadata* element_md = fmd->element; if (element_md) { int specified_element_type = element_md->type; if (specified_element_type == element_ttype) { items = rb_ary_new2(num_elements); for (i = 0; i < num_elements; ++i) { rb_ary_push(items, read_anything(protocol, element_md, pmt)); } result = rb_class_new_instance(1, &items, rb_cSet); } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } } else { skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements); } fastcall_call(pmt->read_set_end, protocol, Qnil); } else { rb_raise(rb_eNotImpError, "read_anything not implemented for type %d!", fmd->type); } return result; }