自学教程：C++ CHECK_EXCEPTION函数代码示例

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_tAndroidDecrypt(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 VALUEimage_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*/VALUEInfo_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 size_tAndroidEncrypt(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*/VALUEImageList_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 voidAndroidInit(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.*/VALUErm_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;}