int register_android_database_SQLiteDatabase(JNIEnv *env) { jclass clazz; clazz = env->FindClass("android/database/sqlite/SQLiteDatabase"); if (clazz == NULL) { LOGE("Can't find android/database/sqlite/SQLiteDatabase\n"); return -1; } offset_db_handle = env->GetFieldID(clazz, "mNativeHandle", "I"); if (offset_db_handle == NULL) { LOGE("Can't find SQLiteDatabase.mNativeHandle\n"); return -1; } return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteDatabase", sMethods, NELEM(sMethods)); }
jint Java_com_android_internal_util_WithFramework_registerNatives( JNIEnv* env, jclass clazz) { return register_jni_procs(gRegJNI, NELEM(gRegJNI), env); }
int register_com_android_internal_os_RuntimeInit(JNIEnv* env) { return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit", gMethods, NELEM(gMethods)); }
int registerMediaPlayerAudio(JNIEnv* env) { return jniRegisterNativeMethods(env, g_ProxyJavaClassAudio, g_MediaAudioPlayerMethods, NELEM(g_MediaAudioPlayerMethods)); }
void register_libcore_icu_Transliterator(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/Transliterator", gMethods, NELEM(gMethods)); }
int register_android_net_wifi_WifiManager(JNIEnv* env) { return AndroidRuntime::registerNativeMethods(env, WIFI_PKG_NAME, gWifiMethods, NELEM(gWifiMethods)); }
int register_android_server_LedService(JNIEnv *env) { return jniRegisterNativeMethods(env, "com/android/server/LedService", methods, NELEM(methods)); }
int register_android_server_LightsService(JNIEnv *env) { return jniRegisterNativeMethods(env, "com/android/server/lights/LightsService", method_table, NELEM(method_table)); }
void X(rdft_buffered_register)(planner *p) { size_t i; for (i = 0; i < NELEM(maxnbufs); ++i) REGISTER_SOLVER(p, mksolver(i)); }
void register_java_lang_invoke_MethodHandle(JNIEnv* env) { jniRegisterNativeMethods(env, "java/lang/invoke/MethodHandle", gMethods, NELEM(gMethods)); }
int register_android_animation_PropertyValuesHolder(JNIEnv* env) { return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); }
int register_android_server_AlarmManagerService(JNIEnv* env) { return jniRegisterNativeMethods(env, "com/android/server/AlarmManagerService", sMethods, NELEM(sMethods)); }
void register_libcore_icu_AlphabeticIndex(JNIEnv* env) { jniRegisterNativeMethods(env, "libcore/icu/AlphabeticIndex", gMethods, NELEM(gMethods)); jniRegisterNativeMethods(env, "libcore/icu/AlphabeticIndex$ImmutableIndex", gImmutableIndexMethods, NELEM(gImmutableIndexMethods)); }
int register_android_server_NetworkManagementSocketTagger(JNIEnv* env) { return jniRegisterNativeMethods(env, "com/android/server/NetworkManagementSocketTagger", gQTagUidMethods, NELEM(gQTagUidMethods)); }
int main(int argc, char **argv) { struct command *cmds; char objformat[32]; char *path, *chunk; char *cmd, *newcmd = NULL; const char *objformat_path; const char *ccver; const char *buver; const char *env_value = NULL; const char *base_path = NULL; int use_objformat = 0; if (getobjformat(objformat, sizeof objformat, &argc, argv) == -1) errx(1, "Invalid object format"); /* * Get the last path element of the program name being executed */ cmd = strrchr(argv[0], '/'); if (cmd != NULL) cmd++; else cmd = argv[0]; for (cmds = commands; cmds < &commands[NELEM(commands) - 1]; ++cmds) { if (strcmp(cmd, cmds->cmd) == 0) break; } if ((ccver = getenv("CCVER")) == NULL || ccver[0] == 0) ccver = CCVER_DEFAULT; if ((buver = getenv("BINUTILSVER")) == NULL) { buver = BINUTILSVER_DEFAULT; } if (cmds) { switch (cmds->type) { case COMPILER: base_path = "/usr/libexec"; use_objformat = 0; env_value = ccver; break; case BINUTILS: base_path = "/usr/libexec"; use_objformat = 1; env_value = buver; break; case OBJFORMAT: break; default: errx(1, "unknown command type"); break; } } /* * The objformat command itself doesn't need another exec */ if (cmds->type == OBJFORMAT) { if (argc != 1) { fprintf(stderr, "Usage: objformat\n"); exit(1); } printf("%s\n", objformat); exit(0); } /* * make buildworld glue and CCVER overrides. */ objformat_path = getenv("OBJFORMAT_PATH"); if (objformat_path == NULL) objformat_path = OBJFORMAT_PATH_DEFAULT; again: path = strdup(objformat_path); if (setenv("OBJFORMAT", objformat, 1) == -1) err(1, "setenv: cannot set OBJFORMAT=%s", objformat); /* * objformat_path could be sequence of colon-separated paths. */ while ((chunk = strsep(&path, ":")) != NULL) { if (newcmd != NULL) { free(newcmd); newcmd = NULL; } if (use_objformat) { asprintf(&newcmd, "%s%s/%s/%s/%s", chunk, base_path, env_value, objformat, cmd); } else { asprintf(&newcmd, "%s%s/%s/%s", chunk, base_path, env_value, cmd); } if (newcmd == NULL) err(1, "cannot allocate memory"); argv[0] = newcmd; execv(newcmd, argv); } /* * Fallback: if we're searching for a compiler, but didn't * find any, try again using the custom compiler driver. */ if (cmds && cmds->type == COMPILER && strcmp(env_value, "custom") != 0) { env_value = "custom"; goto again; } if (use_objformat) { err(1, "in path [%s]%s/%s/%s/%s", objformat_path, base_path, env_value, objformat, cmd); } else { err(1, "in path [%s]%s/%s/%s", objformat_path, base_path, env_value, cmd); } }
void register_java_util_regex_Pattern(JNIEnv* env) { jniRegisterNativeMethods(env, "java/util/regex/Pattern", gMethods, NELEM(gMethods)); }
{ "rquery", "Queries information in repository catalogues", exec_rquery, usage_rquery}, { "search", "Performs a search of package repository catalogues", exec_search, usage_search}, { "set", "Modifies information about packages in the local database", exec_set, usage_set}, { "ssh", "Package server (to be used via ssh)", exec_ssh, usage_ssh}, { "shell", "Opens a debug shell", exec_shell, usage_shell}, { "shlib", "Displays which packages link against a specific shared library", exec_shlib, usage_shlib}, { "stats", "Displays package database statistics", exec_stats, usage_stats}, { "unlock", "Unlocks a package, allowing modification or deletion", exec_unlock, usage_lock}, { "update", "Updates package repository catalogues", exec_update, usage_update}, { "updating", "Displays UPDATING information for a package", exec_updating, usage_updating}, { "upgrade", "Performs upgrades of packaged software distributions", exec_upgrade, usage_upgrade}, { "version", "Displays the versions of installed packages", exec_version, usage_version}, { "which", "Displays which package installed a specific file", exec_which, usage_which}, }; static const unsigned int cmd_len = NELEM(cmd); struct plugcmd { const char *name; const char *desc; int (*exec)(int argc, char **argv); struct plugcmd *next; struct plugcmd *prev; }; static struct plugcmd *plugins = NULL; typedef int (register_cmd)(int idx, const char **name, const char **desc, int (**exec)(int argc, char **argv)); typedef int (nb_cmd)(void); static void show_command_names(void)
ENTRY("2.20", 0x06fa, pentium_core2_duo_t7500, 6 ), }; #undef ENTRY struct est_cpu { const char *brand_prefix; const char *brand_suffix; size_t listc; const struct fqlist *list; }; static const struct est_cpu est_cpus[] = { { "Intel(R) Pentium(R) M processor ", "MHz", NELEM(pentium_m), pentium_m }, { "Intel(R) Pentium(R) M processor ", "GHz", NELEM(pentium_m_dothan), pentium_m_dothan }, { "Genuine Intel(R) CPU T2300 @ ", "GHz", NELEM(pentium_yonah), pentium_yonah }, { "Intel(R) Core(TM)2 Duo CPU T7500 @ ", "GHz", NELEM(pentium_merom),
int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env) { return AndroidRuntime::registerNativeMethods(env, "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods)); }
int register_libcore_icu_TimeZones(JNIEnv* env) { return jniRegisterNativeMethods(env, "libcore/icu/TimeZones", gMethods, NELEM(gMethods)); }
int register_person_info_func(JNIEnv *env) { nativeClassInit(env); return registerNativeMethods(env, JNIREG_CLASS, method_table, NELEM(method_table)); }
// Determine video dimensions from the sequence parameterset. void FindAVCDimensions( const sp<ABuffer> &seqParamSet, int32_t *width, int32_t *height, int32_t *sarWidth, int32_t *sarHeight) { ABitReader br(seqParamSet->data() + 1, seqParamSet->size() - 1); unsigned profile_idc = br.getBits(8); br.skipBits(16); parseUE(&br); // seq_parameter_set_id unsigned chroma_format_idc = 1; // 4:2:0 chroma format if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244 || profile_idc == 44 || profile_idc == 83 || profile_idc == 86) { chroma_format_idc = parseUE(&br); if (chroma_format_idc == 3) { br.skipBits(1); // residual_colour_transform_flag } parseUE(&br); // bit_depth_luma_minus8 parseUE(&br); // bit_depth_chroma_minus8 br.skipBits(1); // qpprime_y_zero_transform_bypass_flag if (br.getBits(1)) { // seq_scaling_matrix_present_flag for (size_t i = 0; i < 8; ++i) { if (br.getBits(1)) { // seq_scaling_list_present_flag[i] // WARNING: the code below has not ever been exercised... // need a real-world example. if (i < 6) { // ScalingList4x4[i],16,... skipScalingList(&br, 16); } else { // ScalingList8x8[i-6],64,... skipScalingList(&br, 64); } } } } } parseUE(&br); // log2_max_frame_num_minus4 unsigned pic_order_cnt_type = parseUE(&br); if (pic_order_cnt_type == 0) { parseUE(&br); // log2_max_pic_order_cnt_lsb_minus4 } else if (pic_order_cnt_type == 1) { // offset_for_non_ref_pic, offset_for_top_to_bottom_field and // offset_for_ref_frame are technically se(v), but since we are // just skipping over them the midpoint does not matter. br.getBits(1); // delta_pic_order_always_zero_flag parseUE(&br); // offset_for_non_ref_pic parseUE(&br); // offset_for_top_to_bottom_field unsigned num_ref_frames_in_pic_order_cnt_cycle = parseUE(&br); for (unsigned i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; ++i) { parseUE(&br); // offset_for_ref_frame } } parseUE(&br); // num_ref_frames br.getBits(1); // gaps_in_frame_num_value_allowed_flag unsigned pic_width_in_mbs_minus1 = parseUE(&br); unsigned pic_height_in_map_units_minus1 = parseUE(&br); unsigned frame_mbs_only_flag = br.getBits(1); *width = pic_width_in_mbs_minus1 * 16 + 16; *height = (2 - frame_mbs_only_flag) * (pic_height_in_map_units_minus1 * 16 + 16); if (!frame_mbs_only_flag) { br.getBits(1); // mb_adaptive_frame_field_flag } br.getBits(1); // direct_8x8_inference_flag if (br.getBits(1)) { // frame_cropping_flag unsigned frame_crop_left_offset = parseUE(&br); unsigned frame_crop_right_offset = parseUE(&br); unsigned frame_crop_top_offset = parseUE(&br); unsigned frame_crop_bottom_offset = parseUE(&br); unsigned cropUnitX, cropUnitY; if (chroma_format_idc == 0 /* monochrome */) { cropUnitX = 1; cropUnitY = 2 - frame_mbs_only_flag; } else { unsigned subWidthC = (chroma_format_idc == 3) ? 1 : 2; unsigned subHeightC = (chroma_format_idc == 1) ? 2 : 1; cropUnitX = subWidthC; cropUnitY = subHeightC * (2 - frame_mbs_only_flag); } ALOGV("frame_crop = (%u, %u, %u, %u), cropUnitX = %u, cropUnitY = %u", frame_crop_left_offset, frame_crop_right_offset, frame_crop_top_offset, frame_crop_bottom_offset, cropUnitX, cropUnitY); // *width -= (frame_crop_left_offset + frame_crop_right_offset) * cropUnitX; if(__builtin_add_overflow(frame_crop_left_offset, frame_crop_right_offset, &frame_crop_left_offset) || __builtin_mul_overflow(frame_crop_left_offset, cropUnitX, &frame_crop_left_offset) || __builtin_sub_overflow(*width, frame_crop_left_offset, width) || *width < 0) { *width = 0; } //*height -= (frame_crop_top_offset + frame_crop_bottom_offset) * cropUnitY; if(__builtin_add_overflow(frame_crop_top_offset, frame_crop_bottom_offset, &frame_crop_top_offset) || __builtin_mul_overflow(frame_crop_top_offset, cropUnitY, &frame_crop_top_offset) || __builtin_sub_overflow(*height, frame_crop_top_offset, height) || *height < 0) { *height = 0; } } if (sarWidth != NULL) { *sarWidth = 0; } if (sarHeight != NULL) { *sarHeight = 0; } if (br.getBits(1)) { // vui_parameters_present_flag unsigned sar_width = 0, sar_height = 0; if (br.getBits(1)) { // aspect_ratio_info_present_flag unsigned aspect_ratio_idc = br.getBits(8); if (aspect_ratio_idc == 255 /* extendedSAR */) { sar_width = br.getBits(16); sar_height = br.getBits(16); } else { static const struct { unsigned width, height; } kFixedSARs[] = { { 0, 0 }, // Invalid { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 }, { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 }, }; if (aspect_ratio_idc > 0 && aspect_ratio_idc < NELEM(kFixedSARs)) { sar_width = kFixedSARs[aspect_ratio_idc].width; sar_height = kFixedSARs[aspect_ratio_idc].height; } } } ALOGV("sample aspect ratio = %u : %u", sar_width, sar_height); if (sarWidth != NULL) { *sarWidth = sar_width; } if (sarHeight != NULL) { *sarHeight = sar_height; } } }
int register_mock_geolocation(JNIEnv* env) { jclass mockGeolocation = env->FindClass(javaMockGeolocationClass); LOG_ASSERT(mockGeolocation, "Unable to find class"); return jniRegisterNativeMethods(env, javaMockGeolocationClass, gMockGeolocationMethods, NELEM(gMockGeolocationMethods)); }
int register_android_server_BatteryStatsService(JNIEnv *env) { return jniRegisterNativeMethods(env, "com/android/server/am/BatteryStatsService", method_table, NELEM(method_table)); }
int register_java_io_File(JNIEnv* env) { return jniRegisterNativeMethods(env, "java/io/File", gMethods, NELEM(gMethods)); }
static usbd_status usb_block_allocmem(bus_dma_tag_t tag, size_t size, size_t align, usb_dma_block_t **dmap) { usb_dma_block_t *p; DPRINTFN(5, ("usb_block_allocmem: size=%lu align=%lu\n", (u_long)size, (u_long)align)); crit_enter(); /* First check the free list. */ for (p = LIST_FIRST(&usb_blk_freelist); p; p = LIST_NEXT(p, next)) { if (p->tag == tag && p->size >= size && p->align >= align) { LIST_REMOVE(p, next); usb_blk_nfree--; crit_exit(); *dmap = p; DPRINTFN(6,("usb_block_allocmem: free list size=%lu\n", (u_long)p->size)); logmemory(blkalloc2, p, NULL, size, align); return (USBD_NORMAL_COMPLETION); } } crit_exit(); DPRINTFN(6, ("usb_block_allocmem: no free\n")); p = kmalloc(sizeof *p, M_USB, M_INTWAIT); logmemory(blkalloc, p, NULL, size, align); if (bus_dma_tag_create(tag, align, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size, NELEM(p->segs), size, BUS_DMA_ALLOCNOW, &p->tag) == ENOMEM) { goto free; } p->size = size; p->align = align; if (bus_dmamem_alloc(p->tag, &p->kaddr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT, &p->map)) goto tagfree; if (bus_dmamap_load(p->tag, p->map, p->kaddr, p->size, usbmem_callback, p, 0)) goto memfree; /* XXX - override the tag, ok since we never free it */ p->tag = tag; *dmap = p; return (USBD_NORMAL_COMPLETION); /* * XXX - do we need to _unload? is the order of _free and _destroy * correct? */ memfree: bus_dmamem_free(p->tag, p->kaddr, p->map); tagfree: bus_dma_tag_destroy(p->tag); free: kfree(p, M_USB); return (USBD_NOMEM); }
jint Java_LoadClass_registerNatives(JNIEnv* env, jclass clazz) { return register_jni_procs(gRegJNI, NELEM(gRegJNI), env); }
.pr_usrreqs = &ngc_usrreqs }, { .pr_type = SOCK_DGRAM, .pr_domain = &ngdomain, .pr_protocol = NG_DATA, .pr_flags = PR_ATOMIC | PR_ADDR, .pr_usrreqs = &ngd_usrreqs } }; struct domain ngdomain = { .dom_family = AF_NETGRAPH, .dom_name = "netgraph", .dom_protosw = ngsw, .dom_protoswNPROTOSW = &ngsw[NELEM(ngsw)] }; /* * Handle loading and unloading for this node type. * This is to handle auxiliary linkages (e.g protocol domain addition). */ static int ngs_mod_event(module_t mod, int event, void *data) { int error = 0; switch (event) { case MOD_LOAD: /* Register protocol domain. */ net_add_domain(&ngdomain);
.pr_input = iptun_input, .pr_output = rip_output, .pr_ctlinput = iptun_ctlinput, .pr_ctloutput = 0, .pr_ctlport = cpu0_ctlport, .pr_usrreqs = &rip_usrreqs }, #endif #endif }; static int ipx_inithead(void **head, int off) { return rn_inithead(head, rn_cpumaskhead(mycpuid), off); } static struct domain ipxdomain = { AF_IPX, "network systems", 0, 0, 0, ipxsw, &ipxsw[NELEM(ipxsw)], SLIST_ENTRY_INITIALIZER, ipx_inithead, 16, sizeof(struct sockaddr_ipx)}; DOMAIN_SET(ipx); SYSCTL_NODE(_net, PF_IPX, ipx, CTLFLAG_RW, 0, "IPX/SPX"); SYSCTL_NODE(_net_ipx, IPXPROTO_RAW, ipx, CTLFLAG_RW, 0, "IPX"); SYSCTL_NODE(_net_ipx, IPXPROTO_SPX, spx, CTLFLAG_RW, 0, "SPX");
// This function only registers the native methods int register_android_sdl_SDLVideo(JNIEnv *env) { return SDLRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); }