jri.h

c++ Builder中网络图象渐进传输实例

	(((*(env))->CallStaticMethodCharA)(env, JRI_CallStaticMethodChar_op_array, clazz, methodID, args))

#define JRI_CallStaticMethodShort(env)	((*(env))->CallStaticMethodShort)
#define JRI_CallStaticMethodShortV(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodShortV)(env, JRI_CallStaticMethodShort_op_va_list, clazz, methodID, args))
#define JRI_CallStaticMethodShortA(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodShortA)(env, JRI_CallStaticMethodShort_op_array, clazz, methodID, args))

#define JRI_CallStaticMethodInt(env)	((*(env))->CallStaticMethodInt)
#define JRI_CallStaticMethodIntV(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodIntV)(env, JRI_CallStaticMethodInt_op_va_list, clazz, methodID, args))
#define JRI_CallStaticMethodIntA(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodIntA)(env, JRI_CallStaticMethodInt_op_array, clazz, methodID, args))

#define JRI_CallStaticMethodLong(env)	((*(env))->CallStaticMethodLong)
#define JRI_CallStaticMethodLongV(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodLongV)(env, JRI_CallStaticMethodLong_op_va_list, clazz, methodID, args))
#define JRI_CallStaticMethodLongA(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodLongA)(env, JRI_CallStaticMethodLong_op_array, clazz, methodID, args))

#define JRI_CallStaticMethodFloat(env)	((*(env))->CallStaticMethodFloat)
#define JRI_CallStaticMethodFloatV(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodFloatV)(env, JRI_CallStaticMethodFloat_op_va_list, clazz, methodID, args))
#define JRI_CallStaticMethodFloatA(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodFloatA)(env, JRI_CallStaticMethodFloat_op_array, clazz, methodID, args))

#define JRI_CallStaticMethodDouble(env)	((*(env))->CallStaticMethodDouble)
#define JRI_CallStaticMethodDoubleV(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodDoubleV)(env, JRI_CallStaticMethodDouble_op_va_list, clazz, methodID, args))
#define JRI_CallStaticMethodDoubleA(env, clazz, methodID, args)	\
	(((*(env))->CallStaticMethodDoubleA)(env, JRI_CallStaticMethodDouble_op_array, clazz, methodID, args))

#define JRI_GetStaticFieldID(env, clazz, name, sig)	\
	(((*(env))->GetStaticFieldID)(env, JRI_GetStaticFieldID_op, clazz, name, sig))

#define JRI_GetStaticField(env, clazz, fieldID)	\
	(((*(env))->GetStaticField)(env, JRI_GetStaticField_op, clazz, fieldID))

#define JRI_GetStaticFieldBoolean(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldBoolean)(env, JRI_GetStaticFieldBoolean_op, clazz, fieldID))

#define JRI_GetStaticFieldByte(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldByte)(env, JRI_GetStaticFieldByte_op, clazz, fieldID))

#define JRI_GetStaticFieldChar(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldChar)(env, JRI_GetStaticFieldChar_op, clazz, fieldID))

#define JRI_GetStaticFieldShort(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldShort)(env, JRI_GetStaticFieldShort_op, clazz, fieldID))

#define JRI_GetStaticFieldInt(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldInt)(env, JRI_GetStaticFieldInt_op, clazz, fieldID))

#define JRI_GetStaticFieldLong(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldLong)(env, JRI_GetStaticFieldLong_op, clazz, fieldID))

#define JRI_GetStaticFieldFloat(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldFloat)(env, JRI_GetStaticFieldFloat_op, clazz, fieldID))

#define JRI_GetStaticFieldDouble(env, clazz, fieldID)	\
	(((*(env))->GetStaticFieldDouble)(env, JRI_GetStaticFieldDouble_op, clazz, fieldID))

#define JRI_SetStaticField(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticField)(env, JRI_SetStaticField_op, clazz, fieldID, value))

#define JRI_SetStaticFieldBoolean(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldBoolean)(env, JRI_SetStaticFieldBoolean_op, clazz, fieldID, value))

#define JRI_SetStaticFieldByte(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldByte)(env, JRI_SetStaticFieldByte_op, clazz, fieldID, value))

#define JRI_SetStaticFieldChar(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldChar)(env, JRI_SetStaticFieldChar_op, clazz, fieldID, value))

#define JRI_SetStaticFieldShort(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldShort)(env, JRI_SetStaticFieldShort_op, clazz, fieldID, value))

#define JRI_SetStaticFieldInt(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldInt)(env, JRI_SetStaticFieldInt_op, clazz, fieldID, value))

#define JRI_SetStaticFieldLong(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldLong)(env, JRI_SetStaticFieldLong_op, clazz, fieldID, value))

#define JRI_SetStaticFieldFloat(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldFloat)(env, JRI_SetStaticFieldFloat_op, clazz, fieldID, value))

#define JRI_SetStaticFieldDouble(env, clazz, fieldID, value)	\
	(((*(env))->SetStaticFieldDouble)(env, JRI_SetStaticFieldDouble_op, clazz, fieldID, value))

#define JRI_NewString(env, unicode, len)	\
	(((*(env))->NewString)(env, JRI_NewString_op, unicode, len))

#define JRI_GetStringLength(env, string)	\
	(((*(env))->GetStringLength)(env, JRI_GetStringLength_op, string))

#define JRI_GetStringChars(env, string)	\
	(((*(env))->GetStringChars)(env, JRI_GetStringChars_op, string))

#define JRI_NewStringUTF(env, utf, len)	\
	(((*(env))->NewStringUTF)(env, JRI_NewStringUTF_op, utf, len))

#define JRI_GetStringUTFLength(env, string)	\
	(((*(env))->GetStringUTFLength)(env, JRI_GetStringUTFLength_op, string))

#define JRI_GetStringUTFChars(env, string)	\
	(((*(env))->GetStringUTFChars)(env, JRI_GetStringUTFChars_op, string))

#define JRI_NewScalarArray(env, length, elementSig, initialElements)	\
	(((*(env))->NewScalarArray)(env, JRI_NewScalarArray_op, length, elementSig, initialElements))

#define JRI_GetScalarArrayLength(env, array)	\
	(((*(env))->GetScalarArrayLength)(env, JRI_GetScalarArrayLength_op, array))

#define JRI_GetScalarArrayElements(env, array)	\
	(((*(env))->GetScalarArrayElements)(env, JRI_GetScalarArrayElements_op, array))

#define JRI_NewObjectArray(env, length, elementClass, initialElement)	\
	(((*(env))->NewObjectArray)(env, JRI_NewObjectArray_op, length, elementClass, initialElement))

#define JRI_GetObjectArrayLength(env, array)	\
	(((*(env))->GetObjectArrayLength)(env, JRI_GetObjectArrayLength_op, array))

#define JRI_GetObjectArrayElement(env, array, index)	\
	(((*(env))->GetObjectArrayElement)(env, JRI_GetObjectArrayElement_op, array, index))

#define JRI_SetObjectArrayElement(env, array, index, value)	\
	(((*(env))->SetObjectArrayElement)(env, JRI_SetObjectArrayElement_op, array, index, value))

#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray)	\
	(((*(env))->RegisterNatives)(env, JRI_RegisterNatives_op, clazz, nameAndSigArray, nativeProcArray))

#define JRI_UnregisterNatives(env, clazz)	\
	(((*(env))->UnregisterNatives)(env, JRI_UnregisterNatives_op, clazz))

#define JRI_NewStringPlatform(env, string, len, encoding, encodingLength)	\
	(((*(env))->NewStringPlatform)(env, JRI_NewStringPlatform_op, string, len, encoding, encodingLength))

#define JRI_GetStringPlatformChars(env, string, encoding, encodingLength)	\
	(((*(env))->GetStringPlatformChars)(env, JRI_GetStringPlatformChars_op, string, encoding, encodingLength))


/*******************************************************************************
 * JRIEnv Interface
 ******************************************************************************/

struct java_lang_ClassLoader;
struct java_lang_Class;
struct java_lang_Throwable;
struct java_lang_Object;
struct java_lang_String;

struct JRIEnvInterface {
	void*	reserved0;
	void*	reserved1;
	void*	reserved2;
	void*	reserved3;
	struct java_lang_Class*	(*FindClass)(JRIEnv* env, jint op, const char* a);
	void	(*Throw)(JRIEnv* env, jint op, struct java_lang_Throwable* a);
	void	(*ThrowNew)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b);
	struct java_lang_Throwable*	(*ExceptionOccurred)(JRIEnv* env, jint op);
	void	(*ExceptionDescribe)(JRIEnv* env, jint op);
	void	(*ExceptionClear)(JRIEnv* env, jint op);
	jglobal	(*NewGlobalRef)(JRIEnv* env, jint op, void* a);
	void	(*DisposeGlobalRef)(JRIEnv* env, jint op, jglobal a);
	void*	(*GetGlobalRef)(JRIEnv* env, jint op, jglobal a);
	void	(*SetGlobalRef)(JRIEnv* env, jint op, jglobal a, void* b);
	jbool	(*IsSameObject)(JRIEnv* env, jint op, void* a, void* b);
	void*	(*NewObject)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
	void*	(*NewObjectV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
	void*	(*NewObjectA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
	struct java_lang_Class*	(*GetObjectClass)(JRIEnv* env, jint op, void* a);
	jbool	(*IsInstanceOf)(JRIEnv* env, jint op, void* a, struct java_lang_Class* b);
	jint	(*GetMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
	void*	(*CallMethod)(JRIEnv* env, jint op, void* a, jint b, ...);
	void*	(*CallMethodV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	void*	(*CallMethodA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jbool	(*CallMethodBoolean)(JRIEnv* env, jint op, void* a, jint b, ...);
	jbool	(*CallMethodBooleanV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jbool	(*CallMethodBooleanA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jbyte	(*CallMethodByte)(JRIEnv* env, jint op, void* a, jint b, ...);
	jbyte	(*CallMethodByteV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jbyte	(*CallMethodByteA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jchar	(*CallMethodChar)(JRIEnv* env, jint op, void* a, jint b, ...);
	jchar	(*CallMethodCharV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jchar	(*CallMethodCharA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jshort	(*CallMethodShort)(JRIEnv* env, jint op, void* a, jint b, ...);
	jshort	(*CallMethodShortV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jshort	(*CallMethodShortA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jint	(*CallMethodInt)(JRIEnv* env, jint op, void* a, jint b, ...);
	jint	(*CallMethodIntV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jint	(*CallMethodIntA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jlong	(*CallMethodLong)(JRIEnv* env, jint op, void* a, jint b, ...);
	jlong	(*CallMethodLongV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jlong	(*CallMethodLongA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jfloat	(*CallMethodFloat)(JRIEnv* env, jint op, void* a, jint b, ...);
	jfloat	(*CallMethodFloatV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jfloat	(*CallMethodFloatA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jdouble	(*CallMethodDouble)(JRIEnv* env, jint op, void* a, jint b, ...);
	jdouble	(*CallMethodDoubleV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
	jdouble	(*CallMethodDoubleA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
	jint	(*GetFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
	void*	(*GetField)(JRIEnv* env, jint op, void* a, jint b);
	jbool	(*GetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b);
	jbyte	(*GetFieldByte)(JRIEnv* env, jint op, void* a, jint b);
	jchar	(*GetFieldChar)(JRIEnv* env, jint op, void* a, jint b);
	jshort	(*GetFieldShort)(JRIEnv* env, jint op, void* a, jint b);
	jint	(*GetFieldInt)(JRIEnv* env, jint op, void* a, jint b);
	jlong	(*GetFieldLong)(JRIEnv* env, jint op, void* a, jint b);
	jfloat	(*GetFieldFloat)(JRIEnv* env, jint op, void* a, jint b);
	jdouble	(*GetFieldDouble)(JRIEnv* env, jint op, void* a, jint b);
	void	(*SetField)(JRIEnv* env, jint op, void* a, jint b, void* c);
	void	(*SetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b, jbool c);
	void	(*SetFieldByte)(JRIEnv* env, jint op, void* a, jint b, jbyte c);
	void	(*SetFieldChar)(JRIEnv* env, jint op, void* a, jint b, jchar c);
	void	(*SetFieldShort)(JRIEnv* env, jint op, void* a, jint b, jshort c);
	void	(*SetFieldInt)(JRIEnv* env, jint op, void* a, jint b, jint c);
	void	(*SetFieldLong)(JRIEnv* env, jint op, void* a, jint b, jlong c);
	void	(*SetFieldFloat)(JRIEnv* env, jint op, void* a, jint b, jfloat c);
	void	(*SetFieldDouble)(JRIEnv* env, jint op, void* a, jint b, jdouble c);