/* * Class: sun_dc_pr_PathStroker * Method: cInitialize * Signature: (Lsun/dc/path/PathConsumer;)V */ JNIEXPORT void JNICALL Java_sun_dc_pr_PathStroker_cInitialize (JNIEnv *env, jobject obj, jobject out) { jclass cls; jfieldID fid; jmethodID mid; PathStroker cdata; doeE cenv = doeE_make(); doeE_setPCtxt(cenv, env); cdata = (PathStroker)doeMem_malloc(cenv, sizeof(PathStrokerData)); if (doeError_occurred(cenv)) { CJError_throw(cenv); return; } (*env)->SetLongField(env, obj, fidCData, ptr_to_jlong(cdata)); /* __________________________ * the c environment variable */ cdata->env = cenv; /* Register the data for disposal */ Disposer_AddRecord(env, obj, PathStroker_DisposeOps, ptr_to_jlong(cdata)); /* __________________________________ * the corresponding CJ path consumer * (always created so as to be able to deal with any type of * incoming out path consumers) */ cdata->cjout = CJPathConsumer_create(cenv, out); if (doeError_occurred(cenv)) { CJError_throw(cenv); return; } /* ________________________________________________ * determines if "out" has a native implementation. */ cls = (*env)->GetObjectClass(env, out); mid = (*env)->GetMethodID(env, cls, "getCPathConsumer", "()J"); cdata->cout = (dcPathConsumer) jlong_to_ptr((*env)->CallLongMethod(env, out, mid)); /* ________________________ * the actual c PathStroker */ if (cdata->cout) { cdata->stroker = dcPathStroker_create(cenv, cdata->cout); } else { cdata->stroker = dcPathStroker_create(cenv, (dcPathConsumer)cdata->cjout); } if (doeError_occurred(cenv)) { CJError_throw(cenv); return; } }
void set_native_handle(JNIEnv *env, jclass_type_t type, jobject obj, void *handle) { switch (type) { case JCLASS_DATAOBJECT: return (*env)->SetLongField(env, obj, jc_dataobject.fid.native, ptr_to_jlong(handle)); case JCLASS_NODE: return (*env)->SetLongField(env, obj, jc_node.fid.native, ptr_to_jlong(handle)); case JCLASS_ATTRIBUTE: return (*env)->SetLongField(env, obj, jc_attribute.fid.native, ptr_to_jlong(handle)); case JCLASS_HANDLE: return (*env)->SetLongField(env, obj, jc_handle.fid.native, ptr_to_jlong(handle)); case JCLASS_INTERFACE: return (*env)->SetLongField(env, obj, jc_interface.fid.native, ptr_to_jlong(handle)); } }
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; }
SocketStreamHandle::SocketStreamHandle(const KURL& url, Page* page, SocketStreamHandleClient* client) : SocketStreamHandleBase(url, client) { String host = url.host(); bool ssl = url.protocolIs("wss"); int port = url.hasPort() ? url.port() : (ssl ? 443 : 80); JNIEnv* env = WebCore_GetJavaEnv(); static jmethodID mid = env->GetStaticMethodID( GetSocketStreamHandleClass(env), "fwkCreate", "(Ljava/lang/String;IZLcom/sun/webkit/WebPage;J)" "Lcom/sun/webkit/network/SocketStreamHandle;"); ASSERT(mid); m_ref = JLObject(env->CallStaticObjectMethod( GetSocketStreamHandleClass(env), mid, (jstring) host.toJavaString(env), port, bool_to_jbool(ssl), (jobject) WebPage::jobjectFromPage(page), ptr_to_jlong(this))); CheckAndClearException(env); }
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 jlong JNICALL Java_java_util_zip_ZipFile_getNextEntry(JNIEnv *env, jclass cls, jlong zfile, jint n) { jzentry *ze = ZIP_GetNextEntry(jlong_to_ptr(zfile), n); return ptr_to_jlong(ze); }
/** * Returns a pointer (as a jlong) to the native GLXGraphicsConfigInfo * associated with the given OGLSDOps. This method can be called from * shared code to retrieve the native GraphicsConfig data in a platform- * independent manner. */ jlong OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo) { GLXSDOps *glxsdo; if (oglsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null"); return 0L; } glxsdo = (GLXSDOps *)oglsdo->privOps; if (glxsdo == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: glx ops are null"); return 0L; } if (glxsdo->configData == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: config data is null"); return 0L; } return ptr_to_jlong(glxsdo->configData->glxInfo); }
JNIEXPORT jlong JNICALL Java_java_util_zip_ZipFile_open(JNIEnv *env, jclass cls, jstring name, jint mode) { const char *path = JNU_GetStringPlatformChars(env, name, 0); jlong result = 0; int flag = 0; if (mode & OPEN_READ) flag |= O_RDONLY; if (mode & OPEN_DELETE) flag |= JVM_O_DELETE; if (path != 0) { char *msg; jzfile *zip = ZIP_Open_Generic(path, &msg, flag); JNU_ReleaseStringPlatformChars(env, name, path); if (zip != 0) { result = ptr_to_jlong(zip); } else if (msg != 0) { ThrowZipException(env, msg); } else if (errno == ENOMEM) { JNU_ThrowOutOfMemoryError(env, 0); } else { ThrowZipException(env, "error in opening zip file"); } } return result; }
/* * Class: sun_awt_shell_Win32ShellFolder2 * Method: getStandardViewButton0 * Signature: (I)[I */ JNIEXPORT jintArray JNICALL Java_sun_awt_shell_Win32ShellFolder2_getStandardViewButton0 (JNIEnv* env, jclass cls, jint iconIndex) { jintArray result = NULL; // Create a toolbar HWND hWndToolbar = ::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL); if (hWndToolbar != NULL) { SendMessage(hWndToolbar, TB_LOADIMAGES, (WPARAM)IDB_VIEW_SMALL_COLOR, (LPARAM)HINST_COMMCTRL); HIMAGELIST hImageList = (HIMAGELIST) SendMessage(hWndToolbar, TB_GETIMAGELIST, 0, 0); if (hImageList != NULL) { HICON hIcon = ImageList_GetIcon(hImageList, iconIndex, ILD_TRANSPARENT); if (hIcon != NULL) { result = Java_sun_awt_shell_Win32ShellFolder2_getIconBits(env, cls, ptr_to_jlong(hIcon), 16); DestroyIcon(hIcon); } ImageList_Destroy(hImageList); } DestroyWindow(hWndToolbar); } return result; }
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; } } }
JNIEXPORT jlong JNICALL Java_java_util_zip_ZipFile_getEntry(JNIEnv *env, jclass cls, jlong zfile, jstring name, jboolean addSlash) { #define MAXNAME 1024 jzfile *zip = jlong_to_ptr(zfile); jsize slen = (*env)->GetStringLength(env, name); jsize ulen = (*env)->GetStringUTFLength(env, name); char buf[MAXNAME+2], *path; jzentry *ze; if (ulen > MAXNAME) { path = malloc(ulen + 2); if (path == 0) { JNU_ThrowOutOfMemoryError(env, 0); return 0; } } else { path = buf; } (*env)->GetStringUTFRegion(env, name, 0, slen, path); path[ulen] = '\0'; if (addSlash == JNI_FALSE) { ze = ZIP_GetEntry(zip, path, 0); } else { ze = ZIP_GetEntry(zip, path, (jint)ulen); } if (path != buf) { free(path); } return ptr_to_jlong(ze); }
JNIEXPORT jlong JNICALL Java_sun_java2d_opengl_GLXGraphicsConfig_initNativeSharedContext (JNIEnv *env, jobject glxsd) { GLXCtxInfo *sharedCtxInfo; OGLContext *oglc; J2dTraceLn(J2D_TRACE_INFO, "in GLXGraphicsConfig_initNativeSharedContext"); if (sharedContext == NULL || sharedConfigInfo == NULL) { J2dTraceLn(J2D_TRACE_ERROR, "shared context not yet inited"); return 0L; } sharedCtxInfo = (GLXCtxInfo *)sharedContext->ctxInfo; oglc = GLXGC_InitOGLContext(env, sharedConfigInfo, sharedCtxInfo->context, JNI_TRUE); if (oglc == NULL) { J2dTraceLn(J2D_TRACE_ERROR, "could not create native shared context"); return 0L; } return ptr_to_jlong(oglc); }
JNIEXPORT jlong JNICALL Java_java_lang_ProcessImpl_openForAtomicAppend(JNIEnv *env, jclass ignored, jstring path) { const DWORD access = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); const DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; const DWORD disposition = OPEN_ALWAYS; const DWORD flagsAndAttributes = FILE_ATTRIBUTE_NORMAL; HANDLE h; WCHAR *pathbuf = getPath(env, path); if (pathbuf == NULL) { /* Exception already pending */ return -1; } h = CreateFileW( pathbuf, /* Wide char path name */ access, /* Read and/or write permission */ sharing, /* File sharing flags */ NULL, /* Security attributes */ disposition, /* creation disposition */ flagsAndAttributes, /* flags and attributes */ NULL); free(pathbuf); if (h == INVALID_HANDLE_VALUE) { JNU_ThrowIOExceptionWithLastError(env, "CreateFileW"); } return ptr_to_jlong(h); }
/* * Class: com_sun_media_jfxmediaimpl_NativeVideoBuffer * Method: nativeConvertToFormat * Signature: (JI)J */ JNIEXPORT jlong JNICALL Java_com_sun_media_jfxmediaimpl_NativeVideoBuffer_nativeConvertToFormat (JNIEnv *env, jobject obj, jlong nativeHandle, jint newFormat) { CVideoFrame *frame = (CVideoFrame*)jlong_to_ptr(nativeHandle); if (frame) { return ptr_to_jlong(frame->ConvertToFormat((CVideoFrame::FrameType)newFormat)); } return 0; }
/* * Add the given pkcs11Implementation object to the list of present modules. * Attach the given data to the entry. If the given pkcs11Implementation is * already in the lsit, just override its old module data with the new one. * None of the arguments can be NULL. If one of the arguments is NULL, this * function does nothing. */ void putModuleEntry(JNIEnv *env, jobject pkcs11Implementation, ModuleData *moduleData) { if (pkcs11Implementation == NULL_PTR) { return ; } if (moduleData == NULL) { return ; } (*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, ptr_to_jlong(moduleData)); }
JNIEXPORT jlong JNICALL Java_sun_font_NullFontScaler_getNullScalerContext (JNIEnv *env, jclass scalerClass) { if (theNullScalerContext == NULL) { theNullScalerContext = malloc(1); } return ptr_to_jlong(theNullScalerContext); }
/** * This is the implementation of the general DisposeFunc defined in * SurfaceData.h and used by the Disposer mechanism. It first flushes all * native OpenGL resources and then frees any memory allocated within the * native OGLSDOps structure. */ void OGLSD_Dispose(JNIEnv *env, SurfaceDataOps *ops) { OGLSDOps *oglsdo = (OGLSDOps *)ops; jlong pConfigInfo = OGLSD_GetNativeConfigInfo(oglsdo); JNU_CallStaticMethodByName(env, NULL, "sun/java2d/opengl/OGLSurfaceData", "dispose", "(JJ)V", ptr_to_jlong(ops), pConfigInfo); }
void D3DSD_Dispose(JNIEnv *env, SurfaceDataOps *ops) { D3DSDOps *d3dsdo = (D3DSDOps *)ops; RETURN_IF_NULL(d3dsdo); JNU_CallStaticMethodByName(env, NULL, "sun/java2d/d3d/D3DSurfaceData", "dispose", "(J)V", ptr_to_jlong(ops)); }
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"); } }
void PopupMenuJava::createPopupMenuJava(Page* page) { JNIEnv* env = WebCore_GetJavaEnv(); static jmethodID mid = env->GetStaticMethodID(getJPopupMenuClass(), "fwkCreatePopupMenu", "(J)Lcom/sun/webkit/PopupMenu;"); ASSERT(mid); JLObject jPopupMenu(env->CallStaticObjectMethod(getJPopupMenuClass(), mid, ptr_to_jlong(this))); ASSERT(jPopupMenu); CheckAndClearException(env); m_popup = jPopupMenu; }
/* * Class: sun_java2d_d3d_D3DSurfaceData * Method: getNativeResourceNative * Signature: (JI)J */ JNIEXPORT jlong JNICALL Java_sun_java2d_d3d_D3DSurfaceData_getNativeResourceNative (JNIEnv *env, jclass d3sdc, jlong pData, jint resType) { D3DSDOps *d3dsdo; J2dTraceLn(J2D_TRACE_INFO, "D3DSurfaceData_getNativeResourceNative") RETURN_STATUS_IF_NULL(d3dsdo = (D3DSDOps *)jlong_to_ptr(pData), 0L); if (resType == D3D_DEVICE_RESOURCE) { HRESULT res; D3DPipelineManager *pMgr; D3DContext *pCtx; RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), 0L); if (FAILED(res = pMgr->GetD3DContext(d3dsdo->adapter, &pCtx))) { D3DRQ_MarkLostIfNeeded(res, d3dsdo); return 0L; } return ptr_to_jlong(pCtx->Get3DDevice()); } RETURN_STATUS_IF_NULL(d3dsdo->pResource, 0L); if (resType == RT_PLAIN || resType == RT_TEXTURE) { return ptr_to_jlong(d3dsdo->pResource->GetSurface()); } if (resType == TEXTURE) { return ptr_to_jlong(d3dsdo->pResource->GetTexture()); } if (resType == FLIP_BACKBUFFER) { return ptr_to_jlong(d3dsdo->pResource->GetSwapChain()); } return 0L; }
JNIEXPORT jlong JNICALL Java_java_util_zip_ZipFile_open(JNIEnv *env, jclass cls, jstring name, jint mode, jlong lastModified, jboolean usemmap) { const char *path = JNU_GetStringPlatformChars(env, name, 0); char *msg = 0; jlong result = 0; int flag = 0; jzfile *zip = 0; if (mode & OPEN_READ) flag |= O_RDONLY; if (mode & OPEN_DELETE) flag |= JVM_O_DELETE; if (path != 0) { zip = ZIP_Get_From_Cache(path, &msg, lastModified); if (zip == 0 && msg == 0) { ZFILE zfd = 0; #ifdef WIN32 zfd = winFileHandleOpen(env, name, flag); if (zfd == -1) { /* Exception already pending. */ goto finally; } #else zfd = JVM_Open(path, flag, 0); if (zfd < 0) { throwFileNotFoundException(env, name); goto finally; } #endif zip = ZIP_Put_In_Cache0(path, zfd, &msg, lastModified, usemmap); } if (zip != 0) { result = ptr_to_jlong(zip); } else if (msg != 0) { ThrowZipException(env, msg); free(msg); } else if (errno == ENOMEM) { JNU_ThrowOutOfMemoryError(env, 0); } else { ThrowZipException(env, "error in opening zip file"); } finally: JNU_ReleaseStringPlatformChars(env, name, path); } return result; }
/* * Class: sun_awt_shell_Win32ShellFolder2 * Method: getIconResource * Signature: (Ljava/lang/String;IIIZ)J */ JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder2_getIconResource (JNIEnv* env, jclass cls, jstring libName, jint iconID, jint cxDesired, jint cyDesired, jboolean useVGAColors) { const char *pLibName = env->GetStringUTFChars(libName, NULL); JNU_CHECK_EXCEPTION_RETURN(env, 0); HINSTANCE libHandle = (HINSTANCE)JDK_LoadSystemLibrary(pLibName); if (libHandle != NULL) { UINT fuLoad = (useVGAColors && !IS_WINXP) ? LR_VGACOLOR : 0; return ptr_to_jlong(LoadImage(libHandle, MAKEINTRESOURCE(iconID), IMAGE_ICON, cxDesired, cyDesired, fuLoad)); } return 0; }
void Watchdog::initTimer() { JSC_GETJAVAENV_CHKRET(env); static jmethodID mid = env->GetStaticMethodID( GetWatchdogTimerClass(env), "fwkCreate", "(J)Lcom/sun/webkit/WatchdogTimer;"); ASSERT(mid); m_timer = JLObject(env->CallStaticObjectMethod( GetWatchdogTimerClass(env), mid, ptr_to_jlong(timerDidFireAddress()))); CheckAndClearException(env); }
JNIEXPORT jlong JNICALL Java_sun_java2d_opengl_GLXContext_initNativeContext(JNIEnv *env, jobject glxc, jlong aData) { AwtGraphicsConfigDataPtr configData = (AwtGraphicsConfigDataPtr)jlong_to_ptr(aData); GLXCtxInfo *sharedInfo = (GLXCtxInfo *)sharedContext->ctxInfo; OGLContext *oglc; J2dTraceLn(J2D_TRACE_INFO, "in GLXContext_initNativeContext"); oglc = GLXGC_InitOGLContext(env, configData->glxInfo, sharedInfo->context, JNI_TRUE); return ptr_to_jlong(oglc); }
/* * Class: sun_font_FreetypeFontScaler * Method: getLayoutTableCacheNative * Signature: (J)J */ JNIEXPORT jlong JNICALL Java_sun_font_FreetypeFontScaler_getLayoutTableCacheNative( JNIEnv *env, jobject scaler, jlong pScaler) { FTScalerInfo *scalerInfo = (FTScalerInfo*) jlong_to_ptr(pScaler); if (scalerInfo == NULL) { invalidateJavaScaler(env, scaler, scalerInfo); return 0L; } // init layout table cache in font // we're assuming the font is a file font and moreover it is Truetype font // otherwise we shouldn't be able to get here... if (scalerInfo->layoutTables == NULL) { scalerInfo->layoutTables = newLayoutTableCache(); } return ptr_to_jlong(scalerInfo->layoutTables); }
void AwtCursor::Dispose() { delete[] mask; delete[] cols; if (custom) { ::DestroyIcon(hCursor); } JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); jobject localObj = env->NewLocalRef(jCursor); if (localObj != NULL) { setPData(localObj, ptr_to_jlong(NULL)); env->DeleteLocalRef(localObj); } env->DeleteWeakGlobalRef(jCursor); AwtObject::Dispose(); }
jobject java_object_new(JNIEnv *env, jclass_type_t type, void *native_obj) { jobject obj; jclass cls; jfieldID fid; // Create object without calling constructor. // The constructor would call into native methods to create a new native data object. switch (type) { case JCLASS_DATAOBJECT: fid = jc_dataobject.fid.native; cls = jc_dataobject.cls; break; case JCLASS_NODE: fid = jc_node.fid.native; cls = jc_node.cls; break; case JCLASS_ATTRIBUTE: fid = jc_attribute.fid.native; cls = jc_attribute.cls; break; case JCLASS_HANDLE: fid = jc_handle.fid.native; cls = jc_handle.cls; break; case JCLASS_INTERFACE: fid = jc_interface.fid.native; cls = jc_interface.cls; break; default: return NULL; } obj = (*env)->AllocObject(env, cls); if (!obj) return NULL; (*env)->SetLongField(env, obj, fid, ptr_to_jlong(native_obj)); return obj; }
JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_Secmod_nssGetLibraryHandle (JNIEnv *env, jclass thisClass, jstring jLibName) { void *hModule; const char *libName = (*env)->GetStringUTFChars(env, jLibName, NULL); if (libName == NULL) { return 0L; } // look up existing handle only, do not load #if defined(AIX) hModule = dlopen(libName, RTLD_LAZY); #else hModule = dlopen(libName, RTLD_NOLOAD); #endif dprintf2("-handle for %s: %u\n", libName, hModule); (*env)->ReleaseStringUTFChars(env, jLibName, libName); return ptr_to_jlong(hModule); }