/*
* 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;
}
}
