jint JNI_OnLoad(JavaVM *vm, void *reserved) { LOGV(TAG, "Loading library"); jvm = vm; JNIEnv *env; if ((*vm)->GetEnv(vm, (void **) &env, JNI_VERSION_1_6)) { return JNI_ERR; /* JNI version not supported */ } jFXActivityClass = (*env)->NewGlobalRef(env, (*env)->FindClass(env, "javafxports/android/FXActivity")); CHECK_EXCEPTION(env); jFXActivity_notifyGlassStartup = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_glassHasStarted", "()V"); CHECK_EXCEPTION(env); jFXActivity_notifyGlassShutdown = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_glassShutdown", "()V"); CHECK_EXCEPTION(env); jFXActivity_notifyShowIME = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_showIME", "()V"); CHECK_EXCEPTION(env); jFXActivity_notifyHideIME = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_hideIME", "()V"); CHECK_EXCEPTION(env); return JNI_VERSION_1_6; }
void init_ids(JNIEnv *env) { jNativeWebViewClass = (*env)->NewGlobalRef(env, (*env)->FindClass(env, "com/sun/webkit/NativeWebView")); CHECK_EXCEPTION(env); jNativeWebView_fire_load_event = (*env)->GetStaticMethodID(env, jNativeWebViewClass, "fire_load_event", "(IIILjava/lang/String;Ljava/lang/String;II)V"); CHECK_EXCEPTION(env); }
static void read_physical_drive_sector_to_file(uint8_t drive_number, uint64_t sector_number, _In_z_ const wchar_t* output_file_name) { std::vector<uint8_t> sector = read_physical_drive_sector(drive_number, sector_number); std::ofstream output_file(output_file_name, std::ios::binary | std::ios::trunc); CHECK_EXCEPTION(output_file.good(), u8"Error opening: " + PortableRuntime::utf8_from_utf16(output_file_name)); output_file.write(reinterpret_cast<const char*>(sector.data()), sector.size()); CHECK_EXCEPTION(!output_file.fail(), u8"Error writing output file."); }
static int parse_arguments_and_execute() { enum { Argument_logical_sector = 0, Argument_file_name, Argument_help, }; const std::vector<Parsing::Argument_descriptor> argument_map = { { Argument_logical_sector, u8"logical-sector", u8's', true, u8"The logical block address (LBA) of the sector to read." }, { Argument_file_name, u8"file-name", u8'f', true, u8"The name of the file to hold the output. This file will be overwritten." }, { Argument_help, u8"help", u8'?', false, nullptr }, }; #ifndef NDEBUG Parsing::validate_argument_map(argument_map); #endif const auto arguments = WindowsCommon::args_from_command_line(); const auto options = Parsing::options_from_allowed_args(arguments, argument_map); int error_level = 0; if(options.count(Argument_help) == 0) { CHECK_EXCEPTION(options.count(Argument_logical_sector) > 0, u8"Missing a required argument: --" + std::string(argument_map[Argument_logical_sector].long_name)); CHECK_EXCEPTION(options.count(Argument_file_name) > 0, u8"Missing a required argument: --" + std::string(argument_map[Argument_file_name].long_name)); // There is no _atoui64 function (and perhaps a private implementation is a good idea), but // reading an int64_t into a uint64_t will have no negative (ha!) consequences, as any sector // number is considered a valid sector to read. const uint64_t sector_number = _atoi64(options.at(Argument_logical_sector).c_str()); GetSector::read_physical_drive_sector_to_file(0, sector_number, PortableRuntime::utf16_from_utf8(options.at(Argument_file_name)).c_str()); } else { constexpr auto arg_program_name = 0; // Hold a reference to program_name_long for the duration of the output functions. const auto program_name_long = PortableRuntime::utf16_from_utf8(arguments[arg_program_name]); const auto program_name = PathFindFileNameW(program_name_long.c_str()); std::fwprintf(stderr, L"Usage: %s [options]\nOptions:\n", program_name); std::fwprintf(stderr, PortableRuntime::utf16_from_utf8(Parsing::Options_help_text(argument_map)).c_str()); std::fwprintf(stderr, L"\nTo read the Master Boot Record:\n %s -%c 1 -%c mbr.bin\n", program_name, argument_map[Argument_logical_sector].short_name, argument_map[Argument_file_name].short_name); error_level = 1; } return error_level; }
void fire_load_event(int id, int frameID, int state, char *url, char *content_type, int progress, int error_code) { JNIEnv *env; (*jvm)->AttachCurrentThread(jvm, &env, 0); jstring jurl = (*env)->NewStringUTF(env, url); jstring jcontentType = (*env)->NewStringUTF(env, content_type); CHECK_EXCEPTION(env); (*env)->CallStaticVoidMethod(env, jNativeWebViewClass, jNativeWebView_fire_load_event, id, frameID, state, jurl, jcontentType, progress, error_code); CHECK_EXCEPTION(env); }
static size_t AndroidDecrypt(vlc_keystore *p_keystore, void *p_ctx, const uint8_t *p_src, size_t i_src_len, uint8_t **pp_dst) { (void) p_ctx; JNIEnv *p_env = GET_ENV(); if (p_env == NULL) return 0; jobject jivArray = NULL, jiv = NULL, jcipher = NULL; jcipher = CALL_STATICOBJ(Cipher, Cipher.getInstance, fields.VLC_CIPHER); if (CHECK_EXCEPTION()) return 0; /* Get the IV located at the beginning of the secret */ size_t i_dst_len = 0; uint32_t i_iv_len; if (i_src_len < sizeof(uint32_t)) goto end; memcpy(&i_iv_len, p_src, sizeof(uint32_t)); if (i_iv_len == 0 || i_src_len < (sizeof(uint32_t) + i_iv_len)) goto end; jivArray = (*p_env)->NewByteArray(p_env, i_iv_len); if (CHECK_EXCEPTION()) goto end; (*p_env)->SetByteArrayRegion(p_env, jivArray, 0, i_iv_len, (jbyte *)(p_src + sizeof(uint32_t)) ); jiv = NEW_OBJECT(IvParameterSpec, jivArray); if (CHECK_EXCEPTION()) goto end; /* Use the IV to initialize the decrypt Cipher */ CALL_VOID(jcipher, Cipher.init, fields.Cipher.DECRYPT_MODE, s_jkey, jiv); if (CHECK_EXCEPTION()) goto end; i_dst_len = Process(p_keystore, p_env, jcipher, p_src + sizeof(uint32_t) + i_iv_len, i_src_len - sizeof(uint32_t) - i_iv_len, NULL, 0, pp_dst); end: DEL_LREF(jcipher); if (jivArray != NULL) DEL_LREF(jivArray); if (jiv != NULL) DEL_LREF(jiv); return i_dst_len; }
static int array2_test(IC_Env *env) { long dl[2][3] = {{11, 2, 7}, {22, 8 ,13}}; m_dd dlo; m_dd_slice* dlr; fprintf(stdout, "\n======== m_i_array2 test ======\n\n"); dlr = m_i_array2_test(NULL, dl, dlo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_dd(dl,dlo) && cmp_dd(dl,dlr)); if (!cmp_dd(dl,dlo)) { fprintf(stdout, " out parameter error, sent:\n"); print_dd(dl); fprintf(stdout, " got:\n"); print_dd(dlo); fprintf(stdout, "\n"); } if (!cmp_dd(dl,dlr)) { fprintf(stdout, " result error, sent:\n"); print_dd(dl); fprintf(stdout, " got:\n"); print_dd(dlr); fprintf(stdout, "\n"); } free(*dlr); return -1; }
static int string2_test(IC_Env *env) { char* sa[3] = {"hello", "foo", "bar"}; m_sseq ssi = {3, 3, sa}; m_sseq *sso, *ssr; fprintf(stdout, "\n======== m_i_string2 test ======\n\n"); ssr = m_i_string2_test(NULL, &ssi, &sso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_sseq(&ssi, sso) && cmp_sseq(&ssi, sso)); if (!cmp_sseq(&ssi, sso)) { fprintf(stdout, " out parameter error, sent:\n"); print_sseq(&ssi); fprintf(stdout, "got:\n"); print_sseq(sso); } if (!cmp_sseq(&ssi, ssr)) { fprintf(stdout, " result error, sent:\n"); print_sseq(&ssi); fprintf(stdout, "got:\n"); print_sseq(ssr); } CORBA_free(sso); CORBA_free(ssr); return -1; }
static int void_test(IC_Env *env) { fprintf(stdout, "\n======== m_i_void test ======\n\n"); m_i_void_test(NULL,env); CHECK_EXCEPTION(env); RETURN_IF_OK(1); }
static int term_struct_test(IC_Env *env) { m_et eti = { erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"), 121212 }; m_et eto, etr; fprintf(stdout, "\n======== m_i_term_struct test ======\n\n"); etr = m_i_term_struct_test(NULL, &eti, &eto, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_et(&eti, &eto) && cmp_et(&eti, &etr)); if (!cmp_et(&eti, &eto)) { fprintf(stdout, " out parameter error, sent:\n"); print_et(&eti); fprintf(stdout, "got:\n"); print_et(&eto); } if (!cmp_et(&eti, &etr)) { fprintf(stdout, " result error, sent:\n"); print_et(&eti); fprintf(stdout, "got:\n"); print_et(&etr); } free_et(&eti); free_et(&eto); free_et(&etr); return -1; }
static int term_sequence_test(IC_Env *env) { ETERM* et_array[4] = { erl_format("[{apa, 1, 23}, \"string\", {1.23, 45}]"), erl_format("[{banan, 1, 23}, \"string\", {1.23, 45}]"), erl_format("[{apelsin, 1, 23}, \"string\", {1.23, 45}]"), erl_format("[{mango, 1, 23}, \"string\", {1.23, 45}]")}; m_etseq etsi = {4, 4, et_array}, *etso, *etsr; fprintf(stdout, "\n======== m_i_term_sequence test ======\n\n"); etsr = m_i_term_sequence_test(NULL, &etsi, &etso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_etseq(&etsi, etso) && cmp_etseq(&etsi, etsr)); if (!cmp_etseq(&etsi, etso)) { fprintf(stdout, " out parameter error, sent:\n"); print_etseq(&etsi); fprintf(stdout, "got:\n"); print_etseq(etso); } if (!cmp_etseq(&etsi, etsr)) { fprintf(stdout, " result error, sent:\n"); print_etseq(&etsi); fprintf(stdout, "got:\n"); print_etseq(etsr); } free_etseq_buf(&etsi); free_etseq_buf(etso); free_etseq_buf(etsr); CORBA_free(etso); CORBA_free(etsr); return -1; }
static int inline_sequence_test(IC_Env *env) { int i; long al[500]; m_s isi = {4711, {500, 10, al}}, *iso, *isr; for (i = 0; i < 500; i++) al[i]=i; fprintf(stdout, "\n======== m_i_inline_sequence test ======\n\n"); isr = m_i_inline_sequence_test(NULL, &isi, &iso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_s(&isi, iso) && cmp_s(&isi, isr)); if (!cmp_s(&isi, iso)) { fprintf(stdout, " out parameter error, sent:\n"); print_s(&isi); fprintf(stdout, "got:\n"); print_s(iso); } if (!cmp_s(&isi, isr)) { fprintf(stdout, " result error, sent:\n"); print_s(&isi); fprintf(stdout, "got:\n"); print_s(isr); } CORBA_free(iso); CORBA_free(isr); return -1; }
static int seq5_test(IC_Env *env) { m_arr3 arr3a[3] = { {4711, 18931947, 3}, {4711, 18931947, 3}, {4711, 18931947, 3}}; m_sarr3 arr3sa[3] = {{3, 3, arr3a}, {3, 3, arr3a}, {3, 3, arr3a}}; m_ssarr3 arr3ssi = {3, 3, arr3sa}; m_ssarr3 *arr3sso; m_ssarr3 *arr3ssr; fprintf(stdout, "\n======== m_i_seq5 test ======\n\n"); arr3ssr = m_i_seq5_test(NULL, &arr3ssi, &arr3sso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_ssarr3(&arr3ssi, arr3sso) && cmp_ssarr3(&arr3ssi, arr3ssr)); if (!cmp_ssarr3(&arr3ssi, arr3sso)) { fprintf(stdout, " out parameter error, sent:\n"); print_ssarr3(&arr3ssi); fprintf(stdout, " got:\n"); print_ssarr3(arr3sso); fprintf(stdout, "\n"); } if (!cmp_ssarr3(&arr3ssi, arr3ssr)) { fprintf(stdout, " result error, sent:\n"); print_ssarr3(&arr3ssi); fprintf(stdout, " got:\n"); print_ssarr3(arr3ssr); fprintf(stdout, "\n"); } CORBA_free(arr3sso); CORBA_free(arr3ssr); return -1; }
static int seq3_test(IC_Env *env) { m_lseq lsi, *lso, *lsr; long al[500]; int i=0; for (i = 0; i < 500; i++) al[i]=i; lsi._length = 500; lsi._buffer = al; fprintf(stdout, "\n======== m_i_seq3 test ======\n\n"); lsr = m_i_seq3_test(NULL, &lsi, &lso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_lseq(&lsi, lso) && cmp_lseq(&lsi, lsr)); if (!cmp_lseq(&lsi, lso)) { fprintf(stdout, " out parameter error, sent:\n"); print_lseq(&lsi); fprintf(stdout, " got:\n"); print_lseq(lso); fprintf(stdout, "\n"); } if (!cmp_lseq(&lsi, lsr)) { fprintf(stdout, " result error, sent:\n"); print_lseq(&lsi); fprintf(stdout, " got:\n"); print_lseq(lsr); fprintf(stdout, "\n"); } CORBA_free(lso); CORBA_free(lsr); return -1; }
static int array1_test(IC_Env *env) { int i; long al[500]; m_arr1 alo; m_arr1_slice* alr; for (i = 0; i < 500; i++) al[i]=i; fprintf(stdout, "\n======== m_i_array1 test ======\n\n"); alr = m_i_array1_test(NULL, al, alo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_arr1(al, alo) && cmp_arr1(al, alr)); if (!cmp_arr1(al, alo)) { fprintf(stdout, " out parameter error, sent:\n"); print_arr1(al); fprintf(stdout, " got:\n"); print_arr1(alo); fprintf(stdout, "\n"); } if (!cmp_arr1(al,alr)) { fprintf(stdout, " result error, sent:\n"); print_arr1(al); fprintf(stdout, " got:\n"); print_arr1(alr); fprintf(stdout, "\n"); } free(alo); free(alr); return -1; }
/** * Convert an image to a blob and the blob to a String. * * No Ruby usage (internal function) * * Notes: * - Returns Qnil if there is no image * * @param image the Image to convert * @return Ruby string representation of image * @see str_to_image */ static VALUE image_to_str(Image *image) { VALUE dimg = Qnil; unsigned char *blob; size_t length; Info *info; ExceptionInfo *exception; if (image) { info = CloneImageInfo(NULL); exception = AcquireExceptionInfo(); blob = ImageToBlob(info, image, &length, exception); DestroyImageInfo(info); CHECK_EXCEPTION(); DestroyExceptionInfo(exception); dimg = rb_str_new((char *)blob, (long)length); magick_free((void*)blob); } RB_GC_GUARD(dimg); return dimg; }
/* Method: Info#format= Purpose: Set the image encoding format */ VALUE Info_format_eq(VALUE self, VALUE magick) { Info *info; const MagickInfo *m; char *mgk; ExceptionInfo exception; Data_Get_Struct(self, Info, info); GetExceptionInfo(&exception); mgk = StringValuePtr(magick); m = GetMagickInfo(mgk, &exception); CHECK_EXCEPTION() (void) DestroyExceptionInfo(&exception); if (!m) { rb_raise(rb_eArgError, "unknown format: %s", mgk); } strncpy(info->magick, m->name, MaxTextExtent-1); return self; }
static int seq1_test(IC_Env *env) { m_bseq bs, *bso, *bsr; m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}}; bs._length = 3; bs._buffer = ba; fprintf(stdout, "\n======== m_i_seq1 test ======\n\n"); bsr = m_i_seq1_test(NULL, &bs, &bso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_bseq(&bs, bso) && cmp_bseq(&bs, bsr)); if (!cmp_bseq(&bs, bso)) { fprintf(stdout, " out parameter error, sent:\n"); print_bseq(&bs); fprintf(stdout, " got:\n"); print_bseq(bso); fprintf(stdout, "\n"); } if (!cmp_bseq(&bs, bsr)) { fprintf(stdout, " result error, sent:\n"); print_bseq(&bs); fprintf(stdout, " got:\n"); print_bseq(bsr); fprintf(stdout, "\n"); } CORBA_free(bso); CORBA_free(bsr); return -1; }
static int term_test(IC_Env *env) { ETERM *ti, *to, *tr; ti = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"); fprintf(stdout, "\n======== m_i_term test ======\n\n"); tr = m_i_term_test(NULL, ti, &to, env); CHECK_EXCEPTION(env); RETURN_IF_OK(erl_match(ti, to) && erl_match(ti, tr)); if (!erl_match(ti, to)) { fprintf(stdout, " out parameter error, sent:\n"); print_term(ti); fprintf(stdout, "got:\n"); print_term(to); } if (!erl_match(ti, tr)) { fprintf(stdout, " result error, sent:\n"); print_term(ti); fprintf(stdout, "got:\n"); print_term(tr); } erl_free_term(ti); erl_free_term(to); erl_free_term(tr); return -1; }
static int seq4_test(IC_Env *env) { char *stra0[3] = {"a", "long", "time"}; char *stra1[3] = {"ago", "there", "was"}; char *stra2[3] = {"a", "buggy", "compiler"}; m_sstr3 str3s[3] = {{3, 3, stra0}, {3, 3, stra1}, {3, 3, stra2}}; m_ssstr3 str3ssi = {3, 3, str3s}; m_ssstr3 *str3sso, *str3ssr; fprintf(stdout, "\n======== m_i_seq4 test ======\n\n"); str3ssr = m_i_seq4_test(NULL, &str3ssi, &str3sso, env); CHECK_EXCEPTION(env); RETURN_IF_OK(cmp_ssstr3(&str3ssi, str3sso) && cmp_ssstr3(&str3ssi, str3ssr)); if (!cmp_ssstr3(&str3ssi, str3sso)){ fprintf(stdout, " out parameter error, sent:\n"); print_ssstr3(&str3ssi); fprintf(stdout, " got:\n"); print_ssstr3(str3sso); fprintf(stdout, "\n"); } if (!cmp_ssstr3(&str3ssi, str3ssr)) { fprintf(stdout, " result error, sent:\n"); print_ssstr3(&str3ssi); fprintf(stdout, " got:\n"); print_ssstr3(str3ssr); fprintf(stdout, "\n"); } CORBA_free(str3sso); CORBA_free(str3ssr); return -1; }
static int typedef_test(IC_Env *env) { m_banan mbi, mbo; /* erlang_port */ m_apa mai; /* ETERM* */ m_apa mao = NULL; long tl; strcpy(mbi.node,"node"); mbi.id = 15; mbi.creation = 1; fprintf(stdout, "\n======== m_i_typedef test ======\n\n"); mai = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"); tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(erl_match(mai, mao) && cmp_port(&mbi, &mbo) && tl == 4711); if (!erl_match(mai, mao)) { fprintf(stdout, " out parameter error (term), sent:\n"); print_term(mai); fprintf(stdout, "got:\n"); print_term(mao); } if (!cmp_port(&mbi, &mbo)) { fprintf(stdout, " out parameter error (port), sent:\n"); print_port(&mbi); fprintf(stdout, "got:\n"); print_port(&mbo); } if (tl != 4711) { fprintf(stdout, " result error, sent: 4711, got %ld\n", tl); } erl_free_term(mai); erl_free_term(mao); return -1; }
static int char_test(IC_Env *env) { char c = 'g', co, cr; /* char test */ fprintf(stdout, "\n======== m_i_char test ======\n\n"); cr = m_i_char_test(NULL, c, &co, env); CHECK_EXCEPTION(env); RETURN_IF_OK(c == co && c == cr); if
static size_t AndroidEncrypt(vlc_keystore *p_keystore, void *p_ctx, const uint8_t *p_src, size_t i_src_len, uint8_t **pp_dst) { (void) p_ctx; JNIEnv *p_env = GET_ENV(); if (p_env == NULL) return 0; jobject jcipher = NULL; jcipher = CALL_STATICOBJ(Cipher, Cipher.getInstance, fields.VLC_CIPHER); if (CHECK_EXCEPTION()) return 0; size_t i_dst_len = 0; CALL_VOID(jcipher, Cipher.init, fields.Cipher.ENCRYPT_MODE, s_jkey, NULL); if (CHECK_EXCEPTION()) goto end; /* Get the IV (Initialization Vector) initialized by Android that will be * used to decrypt this secret. This IV will be stored with the encrypted * secret */ jarray jivArray = (jarray) CALL_OBJ(jcipher, Cipher.getIV); if (jivArray == NULL) goto end; jsize i_iv_len = (*p_env)->GetArrayLength(p_env, jivArray); if (i_iv_len == 0) goto end; jbyte *p_iv_bytes = (*p_env)->GetByteArrayElements(p_env, jivArray, 0); i_dst_len = Process(p_keystore, p_env, jcipher, p_src, i_src_len, (const uint8_t *)p_iv_bytes, i_iv_len, pp_dst); (*p_env)->ReleaseByteArrayElements(p_env, jivArray, p_iv_bytes, 0); DEL_LREF(jivArray); end: DEL_LREF(jcipher); return i_dst_len; }
/* Method: ImageList#to_blob Purpose: returns the imagelist as a blob (a String) Notes: runs an info parm block if present - the user can specify the image format and depth */ VALUE ImageList_to_blob(VALUE self) { Image *images; Info *info; volatile VALUE info_obj; volatile VALUE blob_str; void *blob = NULL; size_t length = 0; ExceptionInfo exception; info_obj = rm_info_new(); Data_Get_Struct(info_obj, Info, info); // Convert the images array to an images sequence. images = images_from_imagelist(self); GetExceptionInfo(&exception); (void) SetImageInfo(info, MagickTrue, &exception); rm_check_exception(&exception, images, RetainOnError); if (*info->magick != '\0') { Image *img; for (img = images; img; img = GetNextImageInList(img)) { strncpy(img->magick, info->magick, sizeof(info->magick)-1); } } // Unconditionally request multi-images support. The worst that // can happen is that there's only one image or the format // doesn't support multi-image files. info->adjoin = MagickTrue; blob = ImagesToBlob(info, images, &length, &exception); if (exception.severity != UndefinedException) { magick_free((void*)blob); } rm_split(images); CHECK_EXCEPTION() (void) DestroyExceptionInfo(&exception); if (length == 0 || !blob) { return Qnil; } blob_str = rb_str_new(blob, (long)length); magick_free((void*)blob); return blob_str; }
/* * Init JNI fields, fetch the key stored by Android or generate a new one */ static void AndroidInit(vlc_keystore *p_keystore) { JNIEnv *p_env = GET_ENV(); if (p_env == NULL) return; if (InitJni(p_keystore, p_env) != VLC_SUCCESS) return; jobject jkeystore = NULL, jentry = NULL, jkey = NULL; jstring jstringAlias = NULL, jstringProvider = NULL; jstringAlias = NEW_STR("LibVLCAndroid"); if (CHECK_EXCEPTION()) goto end; jstringProvider = NEW_STR("AndroidKeyStore"); if (CHECK_EXCEPTION()) goto end; jkeystore = CALL_STATICOBJ(KeyStore, KeyStore.getInstance, jstringProvider); if (CHECK_EXCEPTION()) goto end; CALL_VOID(jkeystore, KeyStore.load, NULL); if (CHECK_EXCEPTION()) goto end; jentry = CALL_OBJ(jkeystore, KeyStore.getEntry, jstringAlias, NULL); if (CHECK_EXCEPTION()) goto end; if (jentry != NULL) { jkey = CALL_OBJ(jentry, KeyStore.SecretKeyEntry.getSecretKey); if (CHECK_EXCEPTION()) goto end; } else { jkey = GenerateKey(p_keystore, p_env, jstringAlias, jstringProvider); if (jkey == NULL) goto end; } s_jkey = NEW_GREF(jkey); end: if (jstringAlias != NULL) DEL_LREF(jstringAlias); if (jstringProvider != NULL) DEL_LREF(jstringProvider); if (jkeystore != NULL) DEL_LREF(jkeystore); if (jentry != NULL) DEL_LREF(jentry); if (jkey != NULL) DEL_LREF(jkey); }
static int double_test(IC_Env *env) { double d = 12.1212, db, dr; fprintf(stdout, "\n======== m_i_double test ======\n\n"); dr = m_i_double_test(NULL, d, &db, env); CHECK_EXCEPTION(env); RETURN_IF_OK(d == db && d == dr); if (d != db) fprintf(stdout, " out parameter error, sent: %f, got: %f\n", d, db); if (d != dr) fprintf(stdout, " result error, sent: %f, got: %f\n", d, dr); return -1; }
/* Extern: rm_pixelpacket_to_color_name Purpose: Map the color intensity to a named color Returns: the named color as a String Notes: See below for the equivalent function that accepts an Info structure instead of an Image. */ VALUE rm_pixelpacket_to_color_name(Image *image, PixelPacket *color) { char name[MaxTextExtent]; ExceptionInfo exception; GetExceptionInfo(&exception); (void) QueryColorname(image, color, X11Compliance, name, &exception); CHECK_EXCEPTION() (void) DestroyExceptionInfo(&exception); return rb_str_new2(name); }
static int enum_test(IC_Env *env) { m_fruit ei = m_banana, eo, er; fprintf(stdout, "\n======== m_i_enum test ======\n\n"); er = m_i_enum_test(NULL, ei, &eo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(ei == eo && ei == er); if (ei != eo) fprintf(stdout, " out parameter error, sent: %d, got: %d\n", ei, eo); if (ei != er) fprintf(stdout, " result error, sent: %d, got: %d\n", ei, er); return -1; }
static int octet_test(IC_Env *env) { char o ='r', oo, or; fprintf(stdout, "\n======== m_i_octet test ======\n\n"); or = m_i_octet_test(NULL, o, &oo, env); CHECK_EXCEPTION(env); RETURN_IF_OK(o == oo && o == or); if (o != oo) fprintf(stdout, " out parameter error, sent: %c, got: %c\n", o, oo); if (o != or) fprintf(stdout, " result error, sent: %c, got: %c\n", o, or); return -1; }
static int bool_test(IC_Env *env) { unsigned char i = 0, io, ir; fprintf(stdout, "\n======== m_i_bool test ======\n\n"); ir = m_i_bool_test(NULL, i, &io, env); CHECK_EXCEPTION(env); RETURN_IF_OK(i == io && i == ir); if (i != io) fprintf(stdout, " out parameter error, sent: %d, got: %d\n", i, io); if (i != ir) fprintf(stdout, " result error, sent: %d, got: %d\n", i, ir); return -1; }