/* * Class: sun_awt_shell_Win32ShellFolder2 * Method: initSpecial * Signature: (JI)V */ JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolder2_initSpecial (JNIEnv* env, jobject folder, jlong desktopIShellFolder, jint folderType) { // Get desktop IShellFolder interface IShellFolder* pDesktop = (IShellFolder*)desktopIShellFolder; if (pDesktop == NULL) { JNU_ThrowInternalError(env, "Desktop shell folder missing"); return; } // Get special folder relative PIDL LPITEMIDLIST relPIDL; HRESULT res = fn_SHGetSpecialFolderLocation(NULL, folderType, &relPIDL); if (res != S_OK) { JNU_ThrowIOException(env, "Could not get shell folder ID list"); return; } // Set field ID for relative PIDL env->CallVoidMethod(folder, MID_relativePIDL, (jlong)relPIDL); // Get special folder IShellFolder interface IShellFolder* pFolder; res = pDesktop->BindToObject(relPIDL, NULL, IID_IShellFolder, (void**)&pFolder); if (res != S_OK) { JNU_ThrowInternalError(env, "Could not bind shell folder to interface"); return; } // Set field ID for pIShellFolder env->CallVoidMethod(folder, MID_pIShellFolder, (jlong)pFolder); }
static void get_thread_state_info(JNIEnv *env, jint state, jobjectArray stateValues, jobjectArray stateNames) { char errmsg[128]; jintArray values; jobjectArray names; values = (*GetThreadStateValues_fp)(env, state); if (values == NULL) { sprintf(errmsg, "Mismatched VM version: Thread state (%d) " "not supported", state); JNU_ThrowInternalError(env, errmsg); return; } /* state is also used as the index in the array */ (*env)->SetObjectArrayElement(env, stateValues, state, values); names = (*GetThreadStateNames_fp)(env, state, values); if (names == NULL) { sprintf(errmsg, "Mismatched VM version: Thread state (%d) " "not supported", state); JNU_ThrowInternalError(env, errmsg); return; } (*env)->SetObjectArrayElement(env, stateNames, state, names); }
int putGV(JNIEnv* env, jint gmask, jint baseIndex, jobject gvdata, const LayoutEngine* engine, int glyphCount) { int count = env->GetIntField(gvdata, gvdCountFID); jarray glyphArray = (jarray)env->GetObjectField(gvdata, gvdGlyphsFID); if (IS_NULL(glyphArray)) { JNU_ThrowInternalError(env, "glypharray null"); return 0; } jint capacity = env->GetArrayLength(glyphArray); if (count + glyphCount > capacity) { JNU_ThrowArrayIndexOutOfBoundsException(env, ""); return 0; } jarray posArray = (jarray)env->GetObjectField(gvdata, gvdPositionsFID); if (IS_NULL(glyphArray)) { JNU_ThrowInternalError(env, "positions array null"); return 0; } jarray inxArray = (jarray)env->GetObjectField(gvdata, gvdIndicesFID); if (IS_NULL(inxArray)) { JNU_ThrowInternalError(env, "indices array null"); return 0; } int countDelta = 0; // le_uint32 is the same size as jint... forever, we hope le_uint32* glyphs = (le_uint32*)env->GetPrimitiveArrayCritical(glyphArray, NULL); if (glyphs) { jfloat* positions = (jfloat*)env->GetPrimitiveArrayCritical(posArray, NULL); if (positions) { jint* indices = (jint*)env->GetPrimitiveArrayCritical(inxArray, NULL); if (indices) { LEErrorCode status = (LEErrorCode)0; engine->getGlyphs(glyphs + count, gmask, status); engine->getGlyphPositions(positions + (count * 2), status); engine->getCharIndices((le_int32*)(indices + count), baseIndex, status); countDelta = glyphCount; // !!! need engine->getFlags to signal positions, indices data /* "0" arg used instead of JNI_COMMIT as we want the carray * to be freed by any VM that actually passes us a copy. */ env->ReleasePrimitiveArrayCritical(inxArray, indices, 0); } env->ReleasePrimitiveArrayCritical(posArray, positions, 0); } env->ReleasePrimitiveArrayCritical(glyphArray, glyphs, 0); } if (countDelta) { count += countDelta; env->SetIntField(gvdata, gvdCountFID, count); } return 1; }
JNIEXPORT jlong JNICALL Java_java_util_zip_Inflater_init(JNIEnv *env, jclass cls, jboolean nowrap) { z_stream *strm = calloc(1, sizeof(z_stream)); if (strm == NULL) { JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; } else { const char *msg; int ret = inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS); switch (ret) { case Z_OK: return ptr_to_jlong(strm); case Z_MEM_ERROR: free(strm); JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; default: msg = ((strm->msg != NULL) ? strm->msg : (ret == Z_VERSION_ERROR) ? "zlib returned Z_VERSION_ERROR: " "compile time and runtime zlib implementations differ" : (ret == Z_STREAM_ERROR) ? "inflateInit2 returned Z_STREAM_ERROR" : "unknown error initializing zlib library"); free(strm); JNU_ThrowInternalError(env, msg); return jlong_zero; } } }
static pathData * MakeSpanData(JNIEnv *env, jobject sr) { pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID); if (pd != NULL) { JNU_ThrowInternalError(env, "private data already initialized"); return NULL; } pd = calloc(1, sizeof(pathData)); if (pd == NULL) { JNU_ThrowOutOfMemoryError(env, "private data"); } else { /* Initialize Ductus object header */ pd->consumer = &dcShapeSpanIteratorClass; /* Initialize ShapeSpanIterator fields */ pd->first = 1; (*env)->SetLongField(env, sr, pSpanDataID, ptr_to_jlong(pd)); } return pd; }
JNIEXPORT void JNICALL Java_sun_net_spi_SdpProvider_convert(JNIEnv *env, jclass cls, jint fd) { #ifdef PROTO_SDP int domain = ipv6_available() ? AF_INET6 : AF_INET; int s = socket(domain, SOCK_STREAM, PROTO_SDP); if (s < 0) { JNU_ThrowIOExceptionWithLastError(env, "socket"); } else { int arg, len, res; struct linger linger; /* copy socket options that are relevant to SDP */ len = sizeof(arg); if (getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&arg, &len) == 0) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&arg, len); len = sizeof(arg); if (getsockopt(fd, SOL_SOCKET, SO_OOBINLINE, (char*)&arg, &len) == 0) setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char*)&arg, len); len = sizeof(linger); if (getsockopt(fd, SOL_SOCKET, SO_LINGER, (void*)&linger, &len) == 0) setsockopt(s, SOL_SOCKET, SO_LINGER, (char*)&linger, len); RESTARTABLE(dup2(s, fd), res); if (res < 0) JNU_ThrowIOExceptionWithLastError(env, "dup2"); RESTARTABLE(close(s), res); } #else JNU_ThrowInternalError(env, "should not reach here"); #endif }
void initScreens(JNIEnv *env) { awt_numScreens = ::CountMonitors(); monHds = (MHND *)safe_Malloc(awt_numScreens * sizeof(MHND)); AwtWin32GraphicsDevice **tempDevArray; if (awt_numScreens != ::CollectMonitors(monHds, awt_numScreens)) { JNU_ThrowInternalError(env, "Failed to get all monitor handles."); } if (devices) { devices->RemoveReference(); // Lock access to devices array until we've created the new // array. Prevents things like accessing out-of-date color // models and partially-created devices array. } MTSafeArray *tmpDevices = new MTSafeArray(awt_numScreens); // Add reference for the overall array - don't want to delete it just // because there are no surfaceData objects referencing it tmpDevices->AddReference(); // Create all devices first, then initialize them. This allows // correct configuration of devices after contruction of the // primary device (which may not be device 0). tempDevArray = (AwtWin32GraphicsDevice**) safe_Malloc(awt_numScreens * sizeof(AwtWin32GraphicsDevice)); for (int i = 0; i < awt_numScreens; ++i) { tempDevArray[i] = new AwtWin32GraphicsDevice(i, tmpDevices); } for (i = 0; i < awt_numScreens; ++i) { tempDevArray[i]->Initialize(); tmpDevices->AddElement(tempDevArray[i], i); } free(tempDevArray); devices = tmpDevices; InitDirectX(); }
/** * This is the implementation of the general GetRasInfoFunc defined in * SurfaceData.h. */ void OGLSD_GetRasInfo(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo) { JNU_ThrowInternalError(env, "OGLSD_GetRasInfo not implemented!"); }
/** * This is the implementation of the general surface UnlockFunc defined in * SurfaceData.h. */ void D3DSD_Unlock(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo) { JNU_ThrowInternalError(env, "D3DSD_Unlock not implemented!"); }
JNIEXPORT jlong JNICALL Java_java_util_zip_Deflater_init(JNIEnv *env, jclass cls, jint level, jint strategy, jboolean nowrap) { z_stream *strm = calloc(1, sizeof(z_stream)); if (strm == 0) { JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; } else { char *msg; switch (deflateInit2(strm, level, Z_DEFLATED, nowrap ? -MAX_WBITS : MAX_WBITS, DEF_MEM_LEVEL, strategy)) { case Z_OK: return ptr_to_jlong(strm); case Z_MEM_ERROR: free(strm); JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; case Z_STREAM_ERROR: free(strm); JNU_ThrowIllegalArgumentException(env, 0); return jlong_zero; default: msg = strm->msg; free(strm); JNU_ThrowInternalError(env, msg); return jlong_zero; } } }
/* * Class: sun_awt_shell_Win32ShellFolder2 * Method: parseDisplayName0 * Signature: (JLjava/lang/String;)J */ JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder2_parseDisplayName0 (JNIEnv* env, jclass cls, jlong jpIShellFolder, jstring jname) { // Get desktop IShellFolder interface IShellFolder* pIShellFolder = (IShellFolder*)jpIShellFolder; if (pIShellFolder == NULL) { JNU_ThrowInternalError(env, "Desktop shell folder missing"); return 0; } // Get relative PIDL for name LPITEMIDLIST pIDL; int nLength = env->GetStringLength(jname); const jchar* strPath = env->GetStringChars(jname, NULL); JNU_CHECK_EXCEPTION_RETURN(env, 0); jchar* wszPath = new jchar[nLength + 1]; wcsncpy(reinterpret_cast<LPWSTR>(wszPath), reinterpret_cast<LPCWSTR>(strPath), nLength); wszPath[nLength] = 0; HRESULT res = pIShellFolder->ParseDisplayName(NULL, NULL, reinterpret_cast<LPWSTR>(wszPath), NULL, &pIDL, NULL); if (res != S_OK) { JNU_ThrowIOException(env, "Could not parse name"); pIDL = 0; } delete[] wszPath; env->ReleaseStringChars(jname, strPath); return (jlong)pIDL; }
JNIEXPORT jint JNICALL Java_sun_nio_ch_InheritedChannel_open0(JNIEnv *env, jclass cla, jstring path, jint oflag) { const char* str; int oflag_actual; /* convert to OS specific value */ switch (oflag) { case sun_nio_ch_InheritedChannel_O_RDWR : oflag_actual = O_RDWR; break; case sun_nio_ch_InheritedChannel_O_RDONLY : oflag_actual = O_RDONLY; break; case sun_nio_ch_InheritedChannel_O_WRONLY : oflag_actual = O_WRONLY; break; default : JNU_ThrowInternalError(env, "Unrecognized file mode"); return -1; } str = JNU_GetStringPlatformChars(env, path, NULL); if (str == NULL) { return (jint)-1; } else { int fd = open(str, oflag_actual); if (fd < 0) { JNU_ThrowIOExceptionWithLastError(env, str); } JNU_ReleaseStringPlatformChars(env, path, str); return (jint)fd; } }
JNIEXPORT jlong JNICALL Java_java_util_zip_Inflater_init(JNIEnv *env, jclass cls, jboolean nowrap) { z_stream *strm = calloc(1, sizeof(z_stream)); if (strm == 0) { JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; } else { char *msg; switch (inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS)) { case Z_OK: return ptr_to_jlong(strm); case Z_MEM_ERROR: free(strm); JNU_ThrowOutOfMemoryError(env, 0); return jlong_zero; default: msg = strm->msg; free(strm); JNU_ThrowInternalError(env, msg); return jlong_zero; } } }
JNIEXPORT jobject JNICALL Java_sun_management_MemoryManagerImpl_getMemoryPools0 (JNIEnv *env, jobject mgr) { jobject pools = jmm_interface->GetMemoryPools(env, mgr); if (pools == NULL) { JNU_ThrowInternalError(env, "Memory Manager not found"); } return pools; }
/** * This is the implementation of the general surface LockFunc defined in * SurfaceData.h. */ jint D3DSD_Lock(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo, jint lockflags) { JNU_ThrowInternalError(env, "D3DSD_Lock not implemented!"); return SD_FAILURE; }
JNIEXPORT void JNICALL Java_sun_misc_VM_getThreadStateValues(JNIEnv *env, jclass cls, jobjectArray values, jobjectArray names) { char errmsg[128]; // check if the number of Thread.State enum constants // matches the number of states defined in jvm.h jsize len1 = (*env)->GetArrayLength(env, values); jsize len2 = (*env)->GetArrayLength(env, names); if (len1 != JAVA_THREAD_STATE_COUNT || len2 != JAVA_THREAD_STATE_COUNT) { sprintf(errmsg, "Mismatched VM version: JAVA_THREAD_STATE_COUNT = %d " " but JDK expects %d / %d", JAVA_THREAD_STATE_COUNT, len1, len2); JNU_ThrowInternalError(env, errmsg); return; } if (GetThreadStateValues_fp == NULL) { GetThreadStateValues_fp = (GET_THREAD_STATE_VALUES_FN) JDK_FindJvmEntry("JVM_GetThreadStateValues"); if (GetThreadStateValues_fp == NULL) { JNU_ThrowInternalError(env, "Mismatched VM version: JVM_GetThreadStateValues not found"); return; } GetThreadStateNames_fp = (GET_THREAD_STATE_NAMES_FN) JDK_FindJvmEntry("JVM_GetThreadStateNames"); if (GetThreadStateNames_fp == NULL) { JNU_ThrowInternalError(env, "Mismatched VM version: JVM_GetThreadStateNames not found"); return ; } } get_thread_state_info(env, JAVA_THREAD_STATE_NEW, values, names); get_thread_state_info(env, JAVA_THREAD_STATE_RUNNABLE, values, names); get_thread_state_info(env, JAVA_THREAD_STATE_BLOCKED, values, names); get_thread_state_info(env, JAVA_THREAD_STATE_WAITING, values, names); get_thread_state_info(env, JAVA_THREAD_STATE_TIMED_WAITING, values, names); get_thread_state_info(env, JAVA_THREAD_STATE_TERMINATED, values, names); }
/* * Class: sun_awt_shell_Win32ShellFolderManager2 * Method: initializeCom * Signature: ()V */ JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolderManager2_initializeCom (JNIEnv* env, jclass cls) { HRESULT hr = ::CoInitialize(NULL); if (FAILED(hr)) { char c[64]; sprintf(c, "Could not initialize COM: HRESULT=0x%08X", hr); JNU_ThrowInternalError(env, c); } }
/* * Class: sun_awt_X11RemoteOffScreenImage * Method: initIDs * Signature: ()V */ JNIEXPORT void JNICALL Java_sun_awt_motif_X11RemoteOffScreenImage_initIDs(JNIEnv *env, jclass bisd) { static char *bimgName = "java/awt/image/BufferedImage"; jclass bimg = (*env)->FindClass(env, bimgName); if (JNU_IsNull(env, bimg)) { JNU_ThrowClassNotFoundException(env, bimgName); return; } sDataID = (*env)->GetFieldID(env, bimg, "sData", "Lsun/java2d/SurfaceData;"); if (sDataID == 0) { JNU_ThrowInternalError(env, "Could not get field IDs"); } rasterID = (*env)->GetFieldID(env, bimg, "raster", "Ljava/awt/image/WritableRaster;"); if (rasterID == 0) { JNU_ThrowInternalError(env, "Could not get field IDs"); } }
JNIEXPORT jobject JNICALL Java_sun_misc_VMSupport_initAgentProperties(JNIEnv *env, jclass cls, jobject props) { char errmsg[128]; if (InitAgentProperties_fp == NULL) { if (!JDK_InitJvmHandle()) { JNU_ThrowInternalError(env, "Handle for JVM not found for symbol lookup"); } InitAgentProperties_fp = (INIT_AGENT_PROPERTIES_FN) JDK_FindJvmEntry("JVM_InitAgentProperties"); if (InitAgentProperties_fp == NULL) { JNU_ThrowInternalError(env, "Mismatched VM version: JVM_InitAgentProperties not found"); return NULL; } } return (*InitAgentProperties_fp)(env, props); }
static int initFieldIDs(JNIEnv *env, jobject process, jobject fd) { jclass tmpC; if (field_exitcode != 0) return 0; tmpC = (*env)->GetObjectClass(env, process);; field_exitcode = (*env)->GetFieldID(env, tmpC, "exitcode", "I"); if (field_exitcode == 0) { JNU_ThrowInternalError(env, "Can't find field UNIXProcess.exitcode"); return -1; } tmpC = (*env)->GetObjectClass(env, fd); field_fd = (*env)->GetFieldID(env, tmpC, "fd", "I"); if (field_fd == 0) { JNU_ThrowInternalError(env, "Can't find field FileDescriptor.fd"); field_exitcode = 0; return -1; } return 0; }
JNIEXPORT NativePrimitive * JNICALL GetNativePrim(JNIEnv *env, jobject gp) { NativePrimitive *pPrim; pPrim = (NativePrimitive *) JNU_GetLongFieldAsPtr(env, gp, pNativePrimID); if (pPrim == NULL) { JNU_ThrowInternalError(env, "Non-native Primitive invoked natively"); } return pPrim; }
/* * Class: sun_awt_shell_Win32ShellFolder * Method: initFile * Signature: (JLjava/lang/String;Z)J */ JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder_initFile (JNIEnv* env, jobject folder, jlong desktopIShellFolder, jstring absolutePath, jboolean initAttributes) { // Get desktop IShellFolder interface IShellFolder* pDesktop = (IShellFolder*)desktopIShellFolder; if (pDesktop == NULL) { JNU_ThrowInternalError(env, "Desktop shell folder missing"); return 0; } // Get PIDL for file from desktop LPITEMIDLIST pIDL; int nLength = env->GetStringLength(absolutePath); jchar* wszPath = new jchar[nLength + 1]; const jchar* strPath = env->GetStringChars(absolutePath, NULL); wcsncpy(wszPath, strPath, nLength); wszPath[nLength] = 0; HRESULT res = pDesktop->ParseDisplayName(NULL, NULL, const_cast<jchar*>(wszPath), NULL, &pIDL, NULL); if (res != S_OK) { JNU_ThrowIOException(env, "Could not parse file path"); delete[] wszPath; env->ReleaseStringChars(absolutePath, strPath); return 0; } delete[] wszPath; env->ReleaseStringChars(absolutePath, strPath); // Get display name, folder type, and possibly attributes SHFILEINFO fileInfo; UINT flags; if (initAttributes) { flags = SHGFI_ATTRIBUTES | SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_PIDL; } else { flags = SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_PIDL; } if (fn_SHGetFileInfo((char *)pIDL, 0L, &fileInfo, sizeof(fileInfo), flags) != 0) { if (initAttributes) { env->SetLongField(folder, FID_attributes, (jlong)fileInfo.dwAttributes); } env->SetObjectField(folder, FID_displayName, JNU_NewStringPlatform(env, fileInfo.szDisplayName)); env->SetObjectField(folder, FID_folderType, JNU_NewStringPlatform(env, fileInfo.szTypeName)); } return (jlong)pIDL; }
JNIEXPORT void JNICALL SurfaceData_SetOps(JNIEnv *env, jobject sData, SurfaceDataOps *ops) { if (JNU_GetLongFieldAsPtr(env, sData, pDataID) == NULL) { JNU_SetLongFieldFromPtr(env, sData, pDataID, ops); /* Register the data for disposal */ Disposer_AddRecord(env, sData, SurfaceData_DisposeOps, ptr_to_jlong(ops)); } else { JNU_ThrowInternalError(env, "Attempting to set SurfaceData ops twice"); } }
/* * Class: sun_awt_shell_Win32ShellFolder2 * Method: initDesktop * Signature: ()V */ JNIEXPORT void JNICALL Java_sun_awt_shell_Win32ShellFolder2_initDesktop (JNIEnv* env, jobject desktop) { // Get desktop IShellFolder HRESULT res = fn_SHGetDesktopFolder(&pDesktop); if (res != S_OK) { JNU_ThrowInternalError(env, "Could not get desktop shell folder"); return; } // Set field ID for pIShellFolder env->CallVoidMethod(desktop, MID_pIShellFolder, (jlong)pDesktop); // Get desktop relative PIDL LPITEMIDLIST relPIDL; res = fn_SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &relPIDL); if (res != S_OK) { JNU_ThrowInternalError(env, "Could not get desktop shell folder ID list"); return; } // Set field ID for relative PIDL env->CallVoidMethod(desktop, MID_relativePIDL, (jlong)relPIDL); }
/* * Class: sun_tools_attach_WindowsVirtualMachine * Method: init * Signature: ()V */ JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_init (JNIEnv *env, jclass cls) { HINSTANCE h = LoadLibrary("kernel32"); if (h != NULL) { _LoadLibrary = (LoadLibraryFunc) GetProcAddress(h, "LoadLibraryA"); _GetProcAddress = (GetProcAddressFunc)GetProcAddress(h, "GetProcAddress"); _IsWow64Process = (IsWow64ProcessFunc)GetProcAddress(h, "IsWow64Process"); } if (_LoadLibrary == NULL || _GetProcAddress == NULL) { JNU_ThrowInternalError(env, "Unable to get address of LoadLibraryA or GetProcAddress"); } }
static pathData * GetSpanData(JNIEnv *env, jobject sr, int minState, int maxState) { pathData *pd = (pathData *) JNU_GetLongFieldAsPtr(env, sr, pSpanDataID); if (pd == NULL) { JNU_ThrowNullPointerException(env, "private data"); } else if (pd->state < minState || pd->state > maxState) { JNU_ThrowInternalError(env, "bad path delivery sequence"); pd = NULL; } return pd; }
/* * Returns pointer discretionary access-control list (ACL) from the security * descriptor of the specified file. */ static ACL* getFileDACL(JNIEnv* env, SECURITY_DESCRIPTOR* sd) { ACL *acl; int defaulted, present; if (!GetSecurityDescriptorDacl(sd, &present, &acl, &defaulted)) { JNU_ThrowIOExceptionWithLastError(env, "GetSecurityDescriptorDacl failed"); return NULL; } if (!present) { JNU_ThrowInternalError(env, "Security descriptor does not contain a DACL"); return NULL; } return acl; }
/** * Convert a GSList to an array of filenames (without the parent folder) */ static jobjectArray toFilenamesArray(JNIEnv *env, GSList* list) { jstring str; jclass stringCls; GSList *iterator; jobjectArray array; int i; char* entry; if (NULL == list) { return NULL; } stringCls = (*env)->FindClass(env, "java/lang/String"); if (stringCls == NULL) { JNU_ThrowInternalError(env, "Could not get java.lang.String class"); return NULL; } array = (*env)->NewObjectArray(env, g_slist_length(list), stringCls, NULL); if (array == NULL) { JNU_ThrowInternalError(env, "Could not instantiate array files array"); return NULL; } i = 0; for (iterator = list; iterator; iterator = iterator->next) { entry = (char*) iterator->data; entry = strrchr(entry, '/') + 1; str = (*env)->NewStringUTF(env, entry); (*env)->SetObjectArrayElement(env, array, i, str); i++; } return array; }
JNIEXPORT void JNICALL Java_sun_misc_VM_initialize(JNIEnv *env, jclass cls) { if (!JDK_InitJvmHandle()) { JNU_ThrowInternalError(env, "Handle for JVM not found for symbol lookup"); return; } // Registers implementations of native methods described in methods[] // above. // In particular, registers JVM_GetNanoTimeAdjustment as the implementation // of the native sun.misc.VM.getNanoTimeAdjustment - avoiding the cost of // introducing a Java_sun_misc_VM_getNanoTimeAdjustment wrapper (*env)->RegisterNatives(env, cls, methods, sizeof(methods)/sizeof(methods[0])); }
JNIEXPORT void JNICALL Java_sun_font_SunLayoutEngine_initGVIDs (JNIEnv *env, jclass cls) { gvdClass = env->FindClass(gvdClassName); if (!gvdClass) { JNU_ThrowClassNotFoundException(env, gvdClassName); return; } gvdClass = (jclass)env->NewGlobalRef(gvdClass); if (!gvdClass) { JNU_ThrowInternalError(env, "could not create global ref"); return; } gvdCountFID = env->GetFieldID(gvdClass, "_count", "I"); if (!gvdCountFID) { gvdClass = 0; JNU_ThrowNoSuchFieldException(env, "_count"); return; } gvdFlagsFID = env->GetFieldID(gvdClass, "_flags", "I"); if (!gvdFlagsFID) { gvdClass = 0; JNU_ThrowNoSuchFieldException(env, "_flags"); return; } gvdGlyphsFID = env->GetFieldID(gvdClass, "_glyphs", "[I"); if (!gvdGlyphsFID) { gvdClass = 0; JNU_ThrowNoSuchFieldException(env, "_glyphs"); return; } gvdPositionsFID = env->GetFieldID(gvdClass, "_positions", "[F"); if (!gvdPositionsFID) { gvdClass = 0; JNU_ThrowNoSuchFieldException(env, "_positions"); return; } gvdIndicesFID = env->GetFieldID(gvdClass, "_indices", "[I"); if (!gvdIndicesFID) { gvdClass = 0; JNU_ThrowNoSuchFieldException(env, "_indices"); return; } }