mirror of
https://github.com/openjdk/jdk.git
synced 2026-01-28 20:18:48 +00:00
535 lines
17 KiB
C
535 lines
17 KiB
C
/*
|
|
* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
#ifndef JNI_UTIL_H
|
|
#define JNI_UTIL_H
|
|
|
|
#include "jni.h"
|
|
#include "jlong.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
* This file contains utility functions that can be implemented in pure JNI.
|
|
*
|
|
* Caution: Callers of functions declared in this file should be
|
|
* particularly aware of the fact that these functions are convenience
|
|
* functions, and as such are often compound operations, each one of
|
|
* which may throw an exception. Therefore, the functions this file
|
|
* will often return silently if an exception has occurred, and callers
|
|
* must check for exception themselves.
|
|
*/
|
|
|
|
/* Throw a Java exception by name. Similar to SignalError. */
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowByName(JNIEnv *env, const char *name, const char *msg);
|
|
|
|
/* Throw common exceptions */
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNullPointerException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowArrayIndexOutOfBoundsException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowOutOfMemoryError(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowIllegalArgumentException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowIllegalAccessError(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowIllegalAccessException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowInternalError(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowIOException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNoSuchFieldException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNoSuchMethodException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowClassNotFoundException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNumberFormatException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNoSuchFieldError(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowNoSuchMethodError(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowStringIndexOutOfBoundsException(JNIEnv *env, const char *msg);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowInstantiationException(JNIEnv *env, const char *msg);
|
|
|
|
/* Throw an exception by name, using the string returned by
|
|
* getLastErrorString for the detail string. If the last-error
|
|
* string is NULL, use the given default detail string.
|
|
*/
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowByNameWithLastError(JNIEnv *env, const char *name,
|
|
const char *defaultDetail);
|
|
|
|
/* Throw an exception by name, using a given message and the string
|
|
* returned by getLastErrorString to construct the detail string.
|
|
*/
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowByNameWithMessageAndLastError
|
|
(JNIEnv *env, const char *name, const char *message);
|
|
|
|
/* Throw an IOException, using the last-error string for the detail
|
|
* string. If the last-error string is NULL, use the given default
|
|
* detail string.
|
|
*/
|
|
JNIEXPORT void JNICALL
|
|
JNU_ThrowIOExceptionWithLastError(JNIEnv *env, const char *defaultDetail);
|
|
|
|
/* Convert between Java strings and i18n C strings */
|
|
JNIEXPORT jstring
|
|
NewStringPlatform(JNIEnv *env, const char *str);
|
|
|
|
JNIEXPORT const char *
|
|
GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy);
|
|
|
|
JNIEXPORT jstring JNICALL
|
|
JNU_NewStringPlatform(JNIEnv *env, const char *str);
|
|
|
|
JNIEXPORT const char * JNICALL
|
|
JNU_GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_ReleaseStringPlatformChars(JNIEnv *env, jstring jstr, const char *str);
|
|
|
|
/* Class constants */
|
|
JNIEXPORT jclass JNICALL
|
|
JNU_ClassString(JNIEnv *env);
|
|
|
|
JNIEXPORT jclass JNICALL
|
|
JNU_ClassClass(JNIEnv *env);
|
|
|
|
JNIEXPORT jclass JNICALL
|
|
JNU_ClassObject(JNIEnv *env);
|
|
|
|
JNIEXPORT jclass JNICALL
|
|
JNU_ClassThrowable(JNIEnv *env);
|
|
|
|
/* Copy count number of arguments from src to dst. Array bounds
|
|
* and ArrayStoreException are checked.
|
|
*/
|
|
JNIEXPORT jint JNICALL
|
|
JNU_CopyObjectArray(JNIEnv *env, jobjectArray dst, jobjectArray src,
|
|
jint count);
|
|
|
|
/* Invoke a object-returning static method, based on class name,
|
|
* method name, and signature string.
|
|
*
|
|
* The caller should check for exceptions by setting hasException
|
|
* argument. If the caller is not interested in whether an exception
|
|
* has occurred, pass in NULL.
|
|
*/
|
|
JNIEXPORT jvalue JNICALL
|
|
JNU_CallStaticMethodByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
const char *class_name,
|
|
const char *name,
|
|
const char *signature,
|
|
...);
|
|
|
|
/* Invoke an instance method by name.
|
|
*/
|
|
JNIEXPORT jvalue JNICALL
|
|
JNU_CallMethodByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
jobject obj,
|
|
const char *name,
|
|
const char *signature,
|
|
...);
|
|
|
|
JNIEXPORT jvalue JNICALL
|
|
JNU_CallMethodByNameV(JNIEnv *env,
|
|
jboolean *hasException,
|
|
jobject obj,
|
|
const char *name,
|
|
const char *signature,
|
|
va_list args);
|
|
|
|
/* Construct a new object of class, specifying the class by name,
|
|
* and specififying which constructor to run and what arguments to
|
|
* pass to it.
|
|
*
|
|
* The method will return an initialized instance if successful.
|
|
* It will return NULL if an error has occurred (for example if
|
|
* it ran out of memory) and the appropriate Java exception will
|
|
* have been thrown.
|
|
*/
|
|
JNIEXPORT jobject JNICALL
|
|
JNU_NewObjectByName(JNIEnv *env, const char *class_name,
|
|
const char *constructor_sig, ...);
|
|
|
|
/* returns:
|
|
* 0: object is not an instance of the class named by classname.
|
|
* 1: object is an instance of the class named by classname.
|
|
* -1: the class named by classname cannot be found. An exception
|
|
* has been thrown.
|
|
*/
|
|
JNIEXPORT jint JNICALL
|
|
JNU_IsInstanceOfByName(JNIEnv *env, jobject object, char *classname);
|
|
|
|
|
|
/* Get or set class and instance fields.
|
|
* Note that set functions take a variable number of arguments,
|
|
* but only one argument of the appropriate type can be passed.
|
|
* For example, to set an integer field i to 100:
|
|
*
|
|
* JNU_SetFieldByName(env, &exc, obj, "i", "I", 100);
|
|
*
|
|
* To set a float field f to 12.3:
|
|
*
|
|
* JNU_SetFieldByName(env, &exc, obj, "f", "F", 12.3);
|
|
*
|
|
* The caller should check for exceptions by setting hasException
|
|
* argument. If the caller is not interested in whether an exception
|
|
* has occurred, pass in NULL.
|
|
*/
|
|
JNIEXPORT jvalue JNICALL
|
|
JNU_GetFieldByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
jobject obj,
|
|
const char *name,
|
|
const char *sig);
|
|
JNIEXPORT void JNICALL
|
|
JNU_SetFieldByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
jobject obj,
|
|
const char *name,
|
|
const char *sig,
|
|
...);
|
|
|
|
JNIEXPORT jvalue JNICALL
|
|
JNU_GetStaticFieldByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
const char *classname,
|
|
const char *name,
|
|
const char *sig);
|
|
JNIEXPORT void JNICALL
|
|
JNU_SetStaticFieldByName(JNIEnv *env,
|
|
jboolean *hasException,
|
|
const char *classname,
|
|
const char *name,
|
|
const char *sig,
|
|
...);
|
|
|
|
|
|
/*
|
|
* Calls the .equals method.
|
|
*/
|
|
JNIEXPORT jboolean JNICALL
|
|
JNU_Equals(JNIEnv *env, jobject object1, jobject object2);
|
|
|
|
|
|
/************************************************************************
|
|
* Thread calls
|
|
*
|
|
* Convenience thread-related calls on the java.lang.Object class.
|
|
*/
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_MonitorWait(JNIEnv *env, jobject object, jlong timeout);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_Notify(JNIEnv *env, jobject object);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_NotifyAll(JNIEnv *env, jobject object);
|
|
|
|
|
|
/************************************************************************
|
|
* Miscellaneous utilities used by the class libraries
|
|
*/
|
|
|
|
#define IS_NULL(obj) ((obj) == NULL)
|
|
#define JNU_IsNull(env,obj) ((obj) == NULL)
|
|
|
|
/************************************************************************
|
|
* Miscellaneous utilities used by the class libraries to return from
|
|
* a function if a value is NULL or an exception is pending.
|
|
*/
|
|
|
|
#define CHECK_NULL(x) \
|
|
do { \
|
|
if ((x) == NULL) { \
|
|
return; \
|
|
} \
|
|
} while (0) \
|
|
|
|
#define CHECK_NULL_THROW_NPE(env, x, msg) \
|
|
do { \
|
|
if ((x) == NULL) { \
|
|
JNU_ThrowNullPointerException((env), (msg));\
|
|
return; \
|
|
} \
|
|
} while(0) \
|
|
|
|
#define CHECK_NULL_THROW_NPE_RETURN(env, x, msg, z)\
|
|
do { \
|
|
if ((x) == NULL) { \
|
|
JNU_ThrowNullPointerException((env), (msg));\
|
|
return (z); \
|
|
} \
|
|
} while(0) \
|
|
|
|
#define CHECK_NULL_RETURN(x, y) \
|
|
do { \
|
|
if ((x) == NULL) { \
|
|
return (y); \
|
|
} \
|
|
} while (0) \
|
|
|
|
#ifdef __cplusplus
|
|
#define JNU_CHECK_EXCEPTION(env) \
|
|
do { \
|
|
if ((env)->ExceptionCheck()) { \
|
|
return; \
|
|
} \
|
|
} while (0) \
|
|
|
|
#define JNU_CHECK_EXCEPTION_RETURN(env, y) \
|
|
do { \
|
|
if ((env)->ExceptionCheck()) { \
|
|
return (y); \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define JNU_CHECK_EXCEPTION(env) \
|
|
do { \
|
|
if ((*env)->ExceptionCheck(env)) { \
|
|
return; \
|
|
} \
|
|
} while (0) \
|
|
|
|
#define JNU_CHECK_EXCEPTION_RETURN(env, y) \
|
|
do { \
|
|
if ((*env)->ExceptionCheck(env)) { \
|
|
return (y); \
|
|
} \
|
|
} while (0)
|
|
#endif /* __cplusplus */
|
|
/************************************************************************
|
|
* Debugging utilities
|
|
*/
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_PrintString(JNIEnv *env, char *hdr, jstring string);
|
|
|
|
JNIEXPORT void JNICALL
|
|
JNU_PrintClass(JNIEnv *env, char *hdr, jobject object);
|
|
|
|
JNIEXPORT jstring JNICALL
|
|
JNU_ToString(JNIEnv *env, jobject object);
|
|
|
|
/*
|
|
* Package shorthand for use by native libraries
|
|
*/
|
|
#define JNU_JAVAPKG "java/lang/"
|
|
#define JNU_JAVAIOPKG "java/io/"
|
|
#define JNU_JAVANETPKG "java/net/"
|
|
|
|
/*
|
|
* Check if the current thread is attached to the VM, and returns
|
|
* the JNIEnv of the specified version if the thread is attached.
|
|
*
|
|
* If the current thread is not attached, this function returns 0.
|
|
*
|
|
* If the current thread is attached, this function returns the
|
|
* JNI environment, or returns (void *)JNI_ERR if the specified
|
|
* version is not supported.
|
|
*/
|
|
JNIEXPORT void * JNICALL
|
|
JNU_GetEnv(JavaVM *vm, jint version);
|
|
|
|
/*
|
|
* Warning free access to pointers stored in Java long fields.
|
|
*/
|
|
#define JNU_GetLongFieldAsPtr(env,obj,id) \
|
|
(jlong_to_ptr((*(env))->GetLongField((env),(obj),(id))))
|
|
#define JNU_SetLongFieldFromPtr(env,obj,id,val) \
|
|
(*(env))->SetLongField((env),(obj),(id),ptr_to_jlong(val))
|
|
|
|
/*
|
|
* Internal use only.
|
|
*/
|
|
enum {
|
|
NO_ENCODING_YET = 0, /* "sun.jnu.encoding" not yet set */
|
|
NO_FAST_ENCODING, /* Platform encoding is not fast */
|
|
FAST_8859_1, /* ISO-8859-1 */
|
|
FAST_CP1252, /* MS-DOS Cp1252 */
|
|
FAST_646_US, /* US-ASCII : ISO646-US */
|
|
FAST_UTF_8
|
|
};
|
|
|
|
int getFastEncoding();
|
|
|
|
JNIEXPORT void InitializeEncoding(JNIEnv *env, const char *name);
|
|
|
|
void* getProcessHandle();
|
|
|
|
void buildJniFunctionName(const char *sym, const char *cname,
|
|
char *jniEntryName);
|
|
|
|
JNIEXPORT size_t JNICALL
|
|
getLastErrorString(char *buf, size_t len);
|
|
|
|
JNIEXPORT int JNICALL
|
|
getErrorString(int err, char *buf, size_t len);
|
|
|
|
#ifdef STATIC_BUILD
|
|
/* Macros for handling declaration of static/dynamic
|
|
* JNI library Load/Unload functions
|
|
*
|
|
* Use DEF_JNI_On{Un}Load when you want a static and non-static entry points.
|
|
* Use DEF_STATIC_JNI_On{Un}Load when you only want a static one.
|
|
*
|
|
* LIBRARY_NAME must be set to the name of the library
|
|
*/
|
|
|
|
/* These three macros are needed to get proper concatenation of
|
|
* the LIBRARY_NAME
|
|
*
|
|
* NOTE: LIBRARY_NAME must be set for static builds.
|
|
*/
|
|
#define ADD_LIB_NAME3(name, lib) name ## lib
|
|
#define ADD_LIB_NAME2(name, lib) ADD_LIB_NAME3(name, lib)
|
|
#define ADD_LIB_NAME(entry) ADD_LIB_NAME2(entry, LIBRARY_NAME)
|
|
|
|
#define DEF_JNI_OnLoad \
|
|
ADD_LIB_NAME(JNI_OnLoad_)(JavaVM *vm, void *reserved) \
|
|
{ \
|
|
jint JNICALL ADD_LIB_NAME(JNI_OnLoad_dynamic_)(JavaVM *vm, void *reserved); \
|
|
ADD_LIB_NAME(JNI_OnLoad_dynamic_)(vm, reserved); \
|
|
return JNI_VERSION_1_8; \
|
|
} \
|
|
jint JNICALL ADD_LIB_NAME(JNI_OnLoad_dynamic_)
|
|
|
|
#define DEF_STATIC_JNI_OnLoad \
|
|
JNIEXPORT jint JNICALL ADD_LIB_NAME(JNI_OnLoad_)(JavaVM *vm, void *reserved) { \
|
|
return JNI_VERSION_1_8; \
|
|
}
|
|
|
|
#define DEF_JNI_OnUnload \
|
|
ADD_LIB_NAME(JNI_OnUnload_)(JavaVM *vm, void *reserved) \
|
|
{ \
|
|
void JNICALL ADD_LIB_NAME(JNI_OnUnload_dynamic_)(JavaVM *vm, void *reserved); \
|
|
ADD_LIB_NAME(JNI_OnUnload_dynamic_)(vm, reserved); \
|
|
} \
|
|
void JNICALL ADD_LIB_NAME(JNI_OnUnload_dynamic_)
|
|
|
|
#define DEF_STATIC_JNI_OnUnload \
|
|
ADD_LIB_NAME(JNI_OnUnload_)
|
|
|
|
#else
|
|
|
|
#define DEF_JNI_OnLoad JNI_OnLoad
|
|
#define DEF_STATIC_JNI_OnLoad
|
|
#define DEF_JNI_OnUnload JNI_OnUnload
|
|
#define DEF_STATIC_JNI_OnUnload
|
|
#endif
|
|
|
|
#ifdef STATIC_BUILD
|
|
/* Macros for handling declaration of static/dynamic
|
|
* Agent library Load/Attach/Unload functions
|
|
*
|
|
* Use DEF_Agent_OnLoad, DEF_Agent_OnAttach or DEF_Agent_OnUnload
|
|
* when you want both static and non-static entry points.
|
|
* Use DEF_STATIC_Agent_OnLoad, DEF_STATIC_Agent_OnAttach or
|
|
* DEF_STATIC_Agent_OnUnload when you only want a static one.
|
|
*
|
|
* LIBRARY_NAME must be set to the name of the library for static builds.
|
|
*/
|
|
|
|
#define DEF_Agent_OnLoad \
|
|
ADD_LIB_NAME(Agent_OnLoad_)(JavaVM *vm, char *options, void *reserved) \
|
|
{ \
|
|
jint JNICALL ADD_LIB_NAME(Agent_OnLoad_dynamic_)(JavaVM *vm, char *options, void *reserved); \
|
|
return ADD_LIB_NAME(Agent_OnLoad_dynamic_)(vm, options, reserved); \
|
|
} \
|
|
jint JNICALL ADD_LIB_NAME(Agent_OnLoad_dynamic_)
|
|
|
|
#define DEF_STATIC_Agent_OnLoad \
|
|
JNIEXPORT jint JNICALL ADD_LIB_NAME(Agent_OnLoad_)(JavaVM *vm, char *options, void *reserved) { \
|
|
return JNI_FALSE; \
|
|
}
|
|
|
|
#define DEF_Agent_OnAttach \
|
|
ADD_LIB_NAME(Agent_OnAttach_)(JavaVM *vm, char *options, void *reserved) \
|
|
{ \
|
|
jint JNICALL ADD_LIB_NAME(Agent_OnAttach_dynamic_)(JavaVM *vm, char *options, void *reserved); \
|
|
return ADD_LIB_NAME(Agent_OnAttach_dynamic_)(vm, options, reserved); \
|
|
} \
|
|
jint JNICALL ADD_LIB_NAME(Agent_OnAttach_dynamic_)
|
|
|
|
#define DEF_STATIC_Agent_OnAttach \
|
|
JNIEXPORT jint JNICALL ADD_LIB_NAME(Agent_OnLoad_)(JavaVM *vm, char *options, void *reserved) { \
|
|
return JNI_FALSE; \
|
|
}
|
|
|
|
#define DEF_Agent_OnUnload \
|
|
ADD_LIB_NAME(Agent_OnUnload_)(JavaVM *vm) \
|
|
{ \
|
|
void JNICALL ADD_LIB_NAME(Agent_OnUnload_dynamic_)(JavaVM *vm); \
|
|
ADD_LIB_NAME(Agent_OnUnload_dynamic_)(vm); \
|
|
} \
|
|
void JNICALL ADD_LIB_NAME(Agent_OnUnload_dynamic_)
|
|
|
|
#define DEF_STATIC_Agent_OnUnload \
|
|
ADD_LIB_NAME(Agent_OnUnload_)
|
|
|
|
#else
|
|
#define DEF_Agent_OnLoad Agent_OnLoad
|
|
#define DEF_Agent_OnAttach Agent_OnAttach
|
|
#define DEF_Agent_OnUnload Agent_OnUnload
|
|
#define DEF_STATIC_Agent_OnLoad
|
|
#define DEF_STATIC_Agent_OnAttach
|
|
#define DEF_STATIC_Agent_OnUnload
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
} /* extern "C" */
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* JNI_UTIL_H */
|