diff options
Diffstat (limited to 'np_sdk')
| -rw-r--r-- | np_sdk/mozsrc/jri.h | 532 | ||||
| -rw-r--r-- | np_sdk/mozsrc/jri_md.h | 316 | ||||
| -rw-r--r-- | np_sdk/mozsrc/jritypes.h | 122 | ||||
| -rw-r--r-- | np_sdk/mozsrc/npapi.h | 80 | ||||
| -rw-r--r-- | np_sdk/mozsrc/npunix.c | 20 | ||||
| -rw-r--r-- | np_sdk/mozsrc/npupp.h | 368 | ||||
| -rw-r--r-- | np_sdk/mozsrc/npwin.cpp | 48 |
7 files changed, 743 insertions, 743 deletions
diff --git a/np_sdk/mozsrc/jri.h b/np_sdk/mozsrc/jri.h index 04e237f2d144..1d54785a016f 100644 --- a/np_sdk/mozsrc/jri.h +++ b/np_sdk/mozsrc/jri.h @@ -14,7 +14,7 @@ * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -22,7 +22,7 @@ * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or + * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only @@ -53,343 +53,343 @@ extern "C" { ******************************************************************************/ /* The type of the JRIEnv interface. */ -typedef struct JRIEnvInterface JRIEnvInterface; +typedef struct JRIEnvInterface JRIEnvInterface; /* The type of a JRIEnv instance. */ -typedef const JRIEnvInterface* JRIEnv; +typedef const JRIEnvInterface* JRIEnv; /******************************************************************************* * JRIEnv Operations ******************************************************************************/ -#define JRI_DefineClass(env, classLoader, buf, bufLen) \ +#define JRI_DefineClass(env, classLoader, buf, bufLen) \ (((*(env))->DefineClass)(env, JRI_DefineClass_op, classLoader, buf, bufLen)) -#define JRI_FindClass(env, name) \ +#define JRI_FindClass(env, name) \ (((*(env))->FindClass)(env, JRI_FindClass_op, name)) -#define JRI_Throw(env, obj) \ +#define JRI_Throw(env, obj) \ (((*(env))->Throw)(env, JRI_Throw_op, obj)) -#define JRI_ThrowNew(env, clazz, message) \ +#define JRI_ThrowNew(env, clazz, message) \ (((*(env))->ThrowNew)(env, JRI_ThrowNew_op, clazz, message)) -#define JRI_ExceptionOccurred(env) \ +#define JRI_ExceptionOccurred(env) \ (((*(env))->ExceptionOccurred)(env, JRI_ExceptionOccurred_op)) -#define JRI_ExceptionDescribe(env) \ +#define JRI_ExceptionDescribe(env) \ (((*(env))->ExceptionDescribe)(env, JRI_ExceptionDescribe_op)) -#define JRI_ExceptionClear(env) \ +#define JRI_ExceptionClear(env) \ (((*(env))->ExceptionClear)(env, JRI_ExceptionClear_op)) -#define JRI_NewGlobalRef(env, ref) \ +#define JRI_NewGlobalRef(env, ref) \ (((*(env))->NewGlobalRef)(env, JRI_NewGlobalRef_op, ref)) -#define JRI_DisposeGlobalRef(env, gref) \ +#define JRI_DisposeGlobalRef(env, gref) \ (((*(env))->DisposeGlobalRef)(env, JRI_DisposeGlobalRef_op, gref)) -#define JRI_GetGlobalRef(env, gref) \ +#define JRI_GetGlobalRef(env, gref) \ (((*(env))->GetGlobalRef)(env, JRI_GetGlobalRef_op, gref)) -#define JRI_SetGlobalRef(env, gref, ref) \ +#define JRI_SetGlobalRef(env, gref, ref) \ (((*(env))->SetGlobalRef)(env, JRI_SetGlobalRef_op, gref, ref)) -#define JRI_IsSameObject(env, a, b) \ +#define JRI_IsSameObject(env, a, b) \ (((*(env))->IsSameObject)(env, JRI_IsSameObject_op, a, b)) -#define JRI_NewObject(env) ((*(env))->NewObject) -#define JRI_NewObjectV(env, clazz, methodID, args) \ +#define JRI_NewObject(env) ((*(env))->NewObject) +#define JRI_NewObjectV(env, clazz, methodID, args) \ (((*(env))->NewObjectV)(env, JRI_NewObject_op_va_list, clazz, methodID, args)) -#define JRI_NewObjectA(env, clazz, method, args) \ +#define JRI_NewObjectA(env, clazz, method, args) \ (((*(env))->NewObjectA)(env, JRI_NewObject_op_array, clazz, methodID, args)) -#define JRI_GetObjectClass(env, obj) \ +#define JRI_GetObjectClass(env, obj) \ (((*(env))->GetObjectClass)(env, JRI_GetObjectClass_op, obj)) -#define JRI_IsInstanceOf(env, obj, clazz) \ +#define JRI_IsInstanceOf(env, obj, clazz) \ (((*(env))->IsInstanceOf)(env, JRI_IsInstanceOf_op, obj, clazz)) -#define JRI_GetMethodID(env, clazz, name, sig) \ +#define JRI_GetMethodID(env, clazz, name, sig) \ (((*(env))->GetMethodID)(env, JRI_GetMethodID_op, clazz, name, sig)) -#define JRI_CallMethod(env) ((*(env))->CallMethod) -#define JRI_CallMethodV(env, obj, methodID, args) \ +#define JRI_CallMethod(env) ((*(env))->CallMethod) +#define JRI_CallMethodV(env, obj, methodID, args) \ (((*(env))->CallMethodV)(env, JRI_CallMethod_op_va_list, obj, methodID, args)) -#define JRI_CallMethodA(env, obj, methodID, args) \ +#define JRI_CallMethodA(env, obj, methodID, args) \ (((*(env))->CallMethodA)(env, JRI_CallMethod_op_array, obj, methodID, args)) -#define JRI_CallMethodBoolean(env) ((*(env))->CallMethodBoolean) -#define JRI_CallMethodBooleanV(env, obj, methodID, args) \ +#define JRI_CallMethodBoolean(env) ((*(env))->CallMethodBoolean) +#define JRI_CallMethodBooleanV(env, obj, methodID, args) \ (((*(env))->CallMethodBooleanV)(env, JRI_CallMethodBoolean_op_va_list, obj, methodID, args)) -#define JRI_CallMethodBooleanA(env, obj, methodID, args) \ +#define JRI_CallMethodBooleanA(env, obj, methodID, args) \ (((*(env))->CallMethodBooleanA)(env, JRI_CallMethodBoolean_op_array, obj, methodID, args)) -#define JRI_CallMethodByte(env) ((*(env))->CallMethodByte) -#define JRI_CallMethodByteV(env, obj, methodID, args) \ +#define JRI_CallMethodByte(env) ((*(env))->CallMethodByte) +#define JRI_CallMethodByteV(env, obj, methodID, args) \ (((*(env))->CallMethodByteV)(env, JRI_CallMethodByte_op_va_list, obj, methodID, args)) -#define JRI_CallMethodByteA(env, obj, methodID, args) \ +#define JRI_CallMethodByteA(env, obj, methodID, args) \ (((*(env))->CallMethodByteA)(env, JRI_CallMethodByte_op_array, obj, methodID, args)) -#define JRI_CallMethodChar(env) ((*(env))->CallMethodChar) -#define JRI_CallMethodCharV(env, obj, methodID, args) \ +#define JRI_CallMethodChar(env) ((*(env))->CallMethodChar) +#define JRI_CallMethodCharV(env, obj, methodID, args) \ (((*(env))->CallMethodCharV)(env, JRI_CallMethodChar_op_va_list, obj, methodID, args)) -#define JRI_CallMethodCharA(env, obj, methodID, args) \ +#define JRI_CallMethodCharA(env, obj, methodID, args) \ (((*(env))->CallMethodCharA)(env, JRI_CallMethodChar_op_array, obj, methodID, args)) -#define JRI_CallMethodShort(env) ((*(env))->CallMethodShort) -#define JRI_CallMethodShortV(env, obj, methodID, args) \ +#define JRI_CallMethodShort(env) ((*(env))->CallMethodShort) +#define JRI_CallMethodShortV(env, obj, methodID, args) \ (((*(env))->CallMethodShortV)(env, JRI_CallMethodShort_op_va_list, obj, methodID, args)) -#define JRI_CallMethodShortA(env, obj, methodID, args) \ +#define JRI_CallMethodShortA(env, obj, methodID, args) \ (((*(env))->CallMethodShortA)(env, JRI_CallMethodShort_op_array, obj, methodID, args)) -#define JRI_CallMethodInt(env) ((*(env))->CallMethodInt) -#define JRI_CallMethodIntV(env, obj, methodID, args) \ +#define JRI_CallMethodInt(env) ((*(env))->CallMethodInt) +#define JRI_CallMethodIntV(env, obj, methodID, args) \ (((*(env))->CallMethodIntV)(env, JRI_CallMethodInt_op_va_list, obj, methodID, args)) -#define JRI_CallMethodIntA(env, obj, methodID, args) \ +#define JRI_CallMethodIntA(env, obj, methodID, args) \ (((*(env))->CallMethodIntA)(env, JRI_CallMethodInt_op_array, obj, methodID, args)) -#define JRI_CallMethodLong(env) ((*(env))->CallMethodLong) -#define JRI_CallMethodLongV(env, obj, methodID, args) \ +#define JRI_CallMethodLong(env) ((*(env))->CallMethodLong) +#define JRI_CallMethodLongV(env, obj, methodID, args) \ (((*(env))->CallMethodLongV)(env, JRI_CallMethodLong_op_va_list, obj, methodID, args)) -#define JRI_CallMethodLongA(env, obj, methodID, args) \ +#define JRI_CallMethodLongA(env, obj, methodID, args) \ (((*(env))->CallMethodLongA)(env, JRI_CallMethodLong_op_array, obj, methodID, args)) -#define JRI_CallMethodFloat(env) ((*(env))->CallMethodFloat) -#define JRI_CallMethodFloatV(env, obj, methodID, args) \ +#define JRI_CallMethodFloat(env) ((*(env))->CallMethodFloat) +#define JRI_CallMethodFloatV(env, obj, methodID, args) \ (((*(env))->CallMethodFloatV)(env, JRI_CallMethodFloat_op_va_list, obj, methodID, args)) -#define JRI_CallMethodFloatA(env, obj, methodID, args) \ +#define JRI_CallMethodFloatA(env, obj, methodID, args) \ (((*(env))->CallMethodFloatA)(env, JRI_CallMethodFloat_op_array, obj, methodID, args)) -#define JRI_CallMethodDouble(env) ((*(env))->CallMethodDouble) -#define JRI_CallMethodDoubleV(env, obj, methodID, args) \ +#define JRI_CallMethodDouble(env) ((*(env))->CallMethodDouble) +#define JRI_CallMethodDoubleV(env, obj, methodID, args) \ (((*(env))->CallMethodDoubleV)(env, JRI_CallMethodDouble_op_va_list, obj, methodID, args)) -#define JRI_CallMethodDoubleA(env, obj, methodID, args) \ +#define JRI_CallMethodDoubleA(env, obj, methodID, args) \ (((*(env))->CallMethodDoubleA)(env, JRI_CallMethodDouble_op_array, obj, methodID, args)) -#define JRI_GetFieldID(env, clazz, name, sig) \ +#define JRI_GetFieldID(env, clazz, name, sig) \ (((*(env))->GetFieldID)(env, JRI_GetFieldID_op, clazz, name, sig)) -#define JRI_GetField(env, obj, fieldID) \ +#define JRI_GetField(env, obj, fieldID) \ (((*(env))->GetField)(env, JRI_GetField_op, obj, fieldID)) -#define JRI_GetFieldBoolean(env, obj, fieldID) \ +#define JRI_GetFieldBoolean(env, obj, fieldID) \ (((*(env))->GetFieldBoolean)(env, JRI_GetFieldBoolean_op, obj, fieldID)) -#define JRI_GetFieldByte(env, obj, fieldID) \ +#define JRI_GetFieldByte(env, obj, fieldID) \ (((*(env))->GetFieldByte)(env, JRI_GetFieldByte_op, obj, fieldID)) -#define JRI_GetFieldChar(env, obj, fieldID) \ +#define JRI_GetFieldChar(env, obj, fieldID) \ (((*(env))->GetFieldChar)(env, JRI_GetFieldChar_op, obj, fieldID)) -#define JRI_GetFieldShort(env, obj, fieldID) \ +#define JRI_GetFieldShort(env, obj, fieldID) \ (((*(env))->GetFieldShort)(env, JRI_GetFieldShort_op, obj, fieldID)) -#define JRI_GetFieldInt(env, obj, fieldID) \ +#define JRI_GetFieldInt(env, obj, fieldID) \ (((*(env))->GetFieldInt)(env, JRI_GetFieldInt_op, obj, fieldID)) -#define JRI_GetFieldLong(env, obj, fieldID) \ +#define JRI_GetFieldLong(env, obj, fieldID) \ (((*(env))->GetFieldLong)(env, JRI_GetFieldLong_op, obj, fieldID)) -#define JRI_GetFieldFloat(env, obj, fieldID) \ +#define JRI_GetFieldFloat(env, obj, fieldID) \ (((*(env))->GetFieldFloat)(env, JRI_GetFieldFloat_op, obj, fieldID)) -#define JRI_GetFieldDouble(env, obj, fieldID) \ +#define JRI_GetFieldDouble(env, obj, fieldID) \ (((*(env))->GetFieldDouble)(env, JRI_GetFieldDouble_op, obj, fieldID)) -#define JRI_SetField(env, obj, fieldID, value) \ +#define JRI_SetField(env, obj, fieldID, value) \ (((*(env))->SetField)(env, JRI_SetField_op, obj, fieldID, value)) -#define JRI_SetFieldBoolean(env, obj, fieldID, value) \ +#define JRI_SetFieldBoolean(env, obj, fieldID, value) \ (((*(env))->SetFieldBoolean)(env, JRI_SetFieldBoolean_op, obj, fieldID, value)) -#define JRI_SetFieldByte(env, obj, fieldID, value) \ +#define JRI_SetFieldByte(env, obj, fieldID, value) \ (((*(env))->SetFieldByte)(env, JRI_SetFieldByte_op, obj, fieldID, value)) -#define JRI_SetFieldChar(env, obj, fieldID, value) \ +#define JRI_SetFieldChar(env, obj, fieldID, value) \ (((*(env))->SetFieldChar)(env, JRI_SetFieldChar_op, obj, fieldID, value)) -#define JRI_SetFieldShort(env, obj, fieldID, value) \ +#define JRI_SetFieldShort(env, obj, fieldID, value) \ (((*(env))->SetFieldShort)(env, JRI_SetFieldShort_op, obj, fieldID, value)) -#define JRI_SetFieldInt(env, obj, fieldID, value) \ +#define JRI_SetFieldInt(env, obj, fieldID, value) \ (((*(env))->SetFieldInt)(env, JRI_SetFieldInt_op, obj, fieldID, value)) -#define JRI_SetFieldLong(env, obj, fieldID, value) \ +#define JRI_SetFieldLong(env, obj, fieldID, value) \ (((*(env))->SetFieldLong)(env, JRI_SetFieldLong_op, obj, fieldID, value)) -#define JRI_SetFieldFloat(env, obj, fieldID, value) \ +#define JRI_SetFieldFloat(env, obj, fieldID, value) \ (((*(env))->SetFieldFloat)(env, JRI_SetFieldFloat_op, obj, fieldID, value)) -#define JRI_SetFieldDouble(env, obj, fieldID, value) \ +#define JRI_SetFieldDouble(env, obj, fieldID, value) \ (((*(env))->SetFieldDouble)(env, JRI_SetFieldDouble_op, obj, fieldID, value)) -#define JRI_IsSubclassOf(env, a, b) \ +#define JRI_IsSubclassOf(env, a, b) \ (((*(env))->IsSubclassOf)(env, JRI_IsSubclassOf_op, a, b)) -#define JRI_GetStaticMethodID(env, clazz, name, sig) \ +#define JRI_GetStaticMethodID(env, clazz, name, sig) \ (((*(env))->GetStaticMethodID)(env, JRI_GetStaticMethodID_op, clazz, name, sig)) -#define JRI_CallStaticMethod(env) ((*(env))->CallStaticMethod) -#define JRI_CallStaticMethodV(env, clazz, methodID, args) \ +#define JRI_CallStaticMethod(env) ((*(env))->CallStaticMethod) +#define JRI_CallStaticMethodV(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodV)(env, JRI_CallStaticMethod_op_va_list, clazz, methodID, args)) -#define JRI_CallStaticMethodA(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodA(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodA)(env, JRI_CallStaticMethod_op_array, clazz, methodID, args)) -#define JRI_CallStaticMethodBoolean(env) ((*(env))->CallStaticMethodBoolean) -#define JRI_CallStaticMethodBooleanV(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodBoolean(env) ((*(env))->CallStaticMethodBoolean) +#define JRI_CallStaticMethodBooleanV(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodBooleanV)(env, JRI_CallStaticMethodBoolean_op_va_list, clazz, methodID, args)) -#define JRI_CallStaticMethodBooleanA(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodBooleanA(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodBooleanA)(env, JRI_CallStaticMethodBoolean_op_array, clazz, methodID, args)) -#define JRI_CallStaticMethodByte(env) ((*(env))->CallStaticMethodByte) -#define JRI_CallStaticMethodByteV(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodByte(env) ((*(env))->CallStaticMethodByte) +#define JRI_CallStaticMethodByteV(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodByteV)(env, JRI_CallStaticMethodByte_op_va_list, clazz, methodID, args)) -#define JRI_CallStaticMethodByteA(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodByteA(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodByteA)(env, JRI_CallStaticMethodByte_op_array, clazz, methodID, args)) -#define JRI_CallStaticMethodChar(env) ((*(env))->CallStaticMethodChar) -#define JRI_CallStaticMethodCharV(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodChar(env) ((*(env))->CallStaticMethodChar) +#define JRI_CallStaticMethodCharV(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodCharV)(env, JRI_CallStaticMethodChar_op_va_list, clazz, methodID, args)) -#define JRI_CallStaticMethodCharA(env, clazz, methodID, args) \ +#define JRI_CallStaticMethodCharA(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodCharA)(env, JRI_CallStaticMethodChar_op_array, clazz, methodID, args)) -#define JRI_CallStaticMethodShort(env) ((*(env))->CallStaticMethodShort) -#define JRI_CallStaticMethodShortV(env, 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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#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) \ +#define JRI_CallStaticMethodDoubleA(env, clazz, methodID, args) \ (((*(env))->CallStaticMethodDoubleA)(env, JRI_CallStaticMethodDouble_op_array, clazz, methodID, args)) -#define JRI_GetStaticFieldID(env, clazz, name, sig) \ +#define JRI_GetStaticFieldID(env, clazz, name, sig) \ (((*(env))->GetStaticFieldID)(env, JRI_GetStaticFieldID_op, clazz, name, sig)) -#define JRI_GetStaticField(env, clazz, fieldID) \ +#define JRI_GetStaticField(env, clazz, fieldID) \ (((*(env))->GetStaticField)(env, JRI_GetStaticField_op, clazz, fieldID)) -#define JRI_GetStaticFieldBoolean(env, clazz, fieldID) \ +#define JRI_GetStaticFieldBoolean(env, clazz, fieldID) \ (((*(env))->GetStaticFieldBoolean)(env, JRI_GetStaticFieldBoolean_op, clazz, fieldID)) -#define JRI_GetStaticFieldByte(env, clazz, fieldID) \ +#define JRI_GetStaticFieldByte(env, clazz, fieldID) \ (((*(env))->GetStaticFieldByte)(env, JRI_GetStaticFieldByte_op, clazz, fieldID)) -#define JRI_GetStaticFieldChar(env, clazz, fieldID) \ +#define JRI_GetStaticFieldChar(env, clazz, fieldID) \ (((*(env))->GetStaticFieldChar)(env, JRI_GetStaticFieldChar_op, clazz, fieldID)) -#define JRI_GetStaticFieldShort(env, clazz, fieldID) \ +#define JRI_GetStaticFieldShort(env, clazz, fieldID) \ (((*(env))->GetStaticFieldShort)(env, JRI_GetStaticFieldShort_op, clazz, fieldID)) -#define JRI_GetStaticFieldInt(env, clazz, fieldID) \ +#define JRI_GetStaticFieldInt(env, clazz, fieldID) \ (((*(env))->GetStaticFieldInt)(env, JRI_GetStaticFieldInt_op, clazz, fieldID)) -#define JRI_GetStaticFieldLong(env, clazz, fieldID) \ +#define JRI_GetStaticFieldLong(env, clazz, fieldID) \ (((*(env))->GetStaticFieldLong)(env, JRI_GetStaticFieldLong_op, clazz, fieldID)) -#define JRI_GetStaticFieldFloat(env, clazz, fieldID) \ +#define JRI_GetStaticFieldFloat(env, clazz, fieldID) \ (((*(env))->GetStaticFieldFloat)(env, JRI_GetStaticFieldFloat_op, clazz, fieldID)) -#define JRI_GetStaticFieldDouble(env, clazz, fieldID) \ +#define JRI_GetStaticFieldDouble(env, clazz, fieldID) \ (((*(env))->GetStaticFieldDouble)(env, JRI_GetStaticFieldDouble_op, clazz, fieldID)) -#define JRI_SetStaticField(env, clazz, fieldID, value) \ +#define JRI_SetStaticField(env, clazz, fieldID, value) \ (((*(env))->SetStaticField)(env, JRI_SetStaticField_op, clazz, fieldID, value)) -#define JRI_SetStaticFieldBoolean(env, 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) \ +#define JRI_SetStaticFieldByte(env, clazz, fieldID, value) \ (((*(env))->SetStaticFieldByte)(env, JRI_SetStaticFieldByte_op, clazz, fieldID, value)) -#define JRI_SetStaticFieldChar(env, 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) \ +#define JRI_SetStaticFieldShort(env, clazz, fieldID, value) \ (((*(env))->SetStaticFieldShort)(env, JRI_SetStaticFieldShort_op, clazz, fieldID, value)) -#define JRI_SetStaticFieldInt(env, 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) \ +#define JRI_SetStaticFieldLong(env, clazz, fieldID, value) \ (((*(env))->SetStaticFieldLong)(env, JRI_SetStaticFieldLong_op, clazz, fieldID, value)) -#define JRI_SetStaticFieldFloat(env, 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) \ +#define JRI_SetStaticFieldDouble(env, clazz, fieldID, value) \ (((*(env))->SetStaticFieldDouble)(env, JRI_SetStaticFieldDouble_op, clazz, fieldID, value)) -#define JRI_NewString(env, unicode, len) \ +#define JRI_NewString(env, unicode, len) \ (((*(env))->NewString)(env, JRI_NewString_op, unicode, len)) -#define JRI_GetStringLength(env, string) \ +#define JRI_GetStringLength(env, string) \ (((*(env))->GetStringLength)(env, JRI_GetStringLength_op, string)) -#define JRI_GetStringChars(env, string) \ +#define JRI_GetStringChars(env, string) \ (((*(env))->GetStringChars)(env, JRI_GetStringChars_op, string)) -#define JRI_NewStringUTF(env, utf, len) \ +#define JRI_NewStringUTF(env, utf, len) \ (((*(env))->NewStringUTF)(env, JRI_NewStringUTF_op, utf, len)) -#define JRI_GetStringUTFLength(env, string) \ +#define JRI_GetStringUTFLength(env, string) \ (((*(env))->GetStringUTFLength)(env, JRI_GetStringUTFLength_op, string)) -#define JRI_GetStringUTFChars(env, string) \ +#define JRI_GetStringUTFChars(env, string) \ (((*(env))->GetStringUTFChars)(env, JRI_GetStringUTFChars_op, string)) -#define JRI_NewScalarArray(env, length, elementSig, initialElements) \ +#define JRI_NewScalarArray(env, length, elementSig, initialElements) \ (((*(env))->NewScalarArray)(env, JRI_NewScalarArray_op, length, elementSig, initialElements)) -#define JRI_GetScalarArrayLength(env, array) \ +#define JRI_GetScalarArrayLength(env, array) \ (((*(env))->GetScalarArrayLength)(env, JRI_GetScalarArrayLength_op, array)) -#define JRI_GetScalarArrayElements(env, array) \ +#define JRI_GetScalarArrayElements(env, array) \ (((*(env))->GetScalarArrayElements)(env, JRI_GetScalarArrayElements_op, array)) -#define JRI_NewObjectArray(env, length, elementClass, initialElement) \ +#define JRI_NewObjectArray(env, length, elementClass, initialElement) \ (((*(env))->NewObjectArray)(env, JRI_NewObjectArray_op, length, elementClass, initialElement)) -#define JRI_GetObjectArrayLength(env, array) \ +#define JRI_GetObjectArrayLength(env, array) \ (((*(env))->GetObjectArrayLength)(env, JRI_GetObjectArrayLength_op, array)) -#define JRI_GetObjectArrayElement(env, array, index) \ +#define JRI_GetObjectArrayElement(env, array, index) \ (((*(env))->GetObjectArrayElement)(env, JRI_GetObjectArrayElement_op, array, index)) -#define JRI_SetObjectArrayElement(env, array, index, value) \ +#define JRI_SetObjectArrayElement(env, array, index, value) \ (((*(env))->SetObjectArrayElement)(env, JRI_SetObjectArrayElement_op, array, index, value)) -#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray) \ +#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray) \ (((*(env))->RegisterNatives)(env, JRI_RegisterNatives_op, clazz, nameAndSigArray, nativeProcArray)) -#define JRI_UnregisterNatives(env, clazz) \ +#define JRI_UnregisterNatives(env, clazz) \ (((*(env))->UnregisterNatives)(env, JRI_UnregisterNatives_op, clazz)) -#define JRI_NewStringPlatform(env, string, len, encoding, encodingLength) \ +#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) \ +#define JRI_GetStringPlatformChars(env, string, encoding, encodingLength) \ (((*(env))->GetStringPlatformChars)(env, JRI_GetStringPlatformChars_op, string, encoding, encodingLength)) @@ -404,139 +404,139 @@ 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); - jbool (*IsSubclassOf)(JRIEnv* env, jint op, struct java_lang_Class* a, struct java_lang_Class* b); - jint (*GetStaticMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); - void* (*CallStaticMethod)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - void* (*CallStaticMethodV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - void* (*CallStaticMethodA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jbool (*CallStaticMethodBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jbool (*CallStaticMethodBooleanV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jbool (*CallStaticMethodBooleanA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jbyte (*CallStaticMethodByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jbyte (*CallStaticMethodByteV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jbyte (*CallStaticMethodByteA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jchar (*CallStaticMethodChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jchar (*CallStaticMethodCharV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jchar (*CallStaticMethodCharA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jshort (*CallStaticMethodShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jshort (*CallStaticMethodShortV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jshort (*CallStaticMethodShortA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jint (*CallStaticMethodInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jint (*CallStaticMethodIntV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jint (*CallStaticMethodIntA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jlong (*CallStaticMethodLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jlong (*CallStaticMethodLongV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jlong (*CallStaticMethodLongA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jfloat (*CallStaticMethodFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jfloat (*CallStaticMethodFloatV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jfloat (*CallStaticMethodFloatA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jdouble (*CallStaticMethodDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); - jdouble (*CallStaticMethodDoubleV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); - jdouble (*CallStaticMethodDoubleA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); - jint (*GetStaticFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); - void* (*GetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jbool (*GetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jbyte (*GetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jchar (*GetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jshort (*GetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jint (*GetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jlong (*GetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jfloat (*GetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - jdouble (*GetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); - void (*SetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, void* c); - void (*SetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbool c); - void (*SetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbyte c); - void (*SetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jchar c); - void (*SetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jshort c); - void (*SetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jint c); - void (*SetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jlong c); - void (*SetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jfloat c); - void (*SetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jdouble c); - struct java_lang_String* (*NewString)(JRIEnv* env, jint op, const jchar* a, jint b); - jint (*GetStringLength)(JRIEnv* env, jint op, struct java_lang_String* a); - const jchar* (*GetStringChars)(JRIEnv* env, jint op, struct java_lang_String* a); - struct java_lang_String* (*NewStringUTF)(JRIEnv* env, jint op, const jbyte* a, jint b); - jint (*GetStringUTFLength)(JRIEnv* env, jint op, struct java_lang_String* a); - const jbyte* (*GetStringUTFChars)(JRIEnv* env, jint op, struct java_lang_String* a); - void* (*NewScalarArray)(JRIEnv* env, jint op, jint a, const char* b, const jbyte* c); - jint (*GetScalarArrayLength)(JRIEnv* env, jint op, void* a); - jbyte* (*GetScalarArrayElements)(JRIEnv* env, jint op, void* a); - void* (*NewObjectArray)(JRIEnv* env, jint op, jint a, struct java_lang_Class* b, void* c); - jint (*GetObjectArrayLength)(JRIEnv* env, jint op, void* a); - void* (*GetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b); - void (*SetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b, void* c); - void (*RegisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a, char** b, void** c); - void (*UnregisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a); - struct java_lang_Class* (*DefineClass)(JRIEnv* env, jint op, struct java_lang_ClassLoader* a, jbyte* b, jsize bLen); - struct java_lang_String* (*NewStringPlatform)(JRIEnv* env, jint op, const jbyte* a, jint b, const jbyte* c, jint d); - const jbyte* (*GetStringPlatformChars)(JRIEnv* env, jint op, struct java_lang_String* a, const jbyte* b, jint c); + 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); + jbool (*IsSubclassOf)(JRIEnv* env, jint op, struct java_lang_Class* a, struct java_lang_Class* b); + jint (*GetStaticMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*CallStaticMethod)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + void* (*CallStaticMethodV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + void* (*CallStaticMethodA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbool (*CallStaticMethodBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbool (*CallStaticMethodBooleanV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbool (*CallStaticMethodBooleanA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jbyte (*CallStaticMethodByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jbyte (*CallStaticMethodByteV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jbyte (*CallStaticMethodByteA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jchar (*CallStaticMethodChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jchar (*CallStaticMethodCharV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jchar (*CallStaticMethodCharA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jshort (*CallStaticMethodShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jshort (*CallStaticMethodShortV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jshort (*CallStaticMethodShortA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*CallStaticMethodInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jint (*CallStaticMethodIntV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jint (*CallStaticMethodIntA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jlong (*CallStaticMethodLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jlong (*CallStaticMethodLongV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jlong (*CallStaticMethodLongA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jfloat (*CallStaticMethodFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jfloat (*CallStaticMethodFloatV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jfloat (*CallStaticMethodFloatA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jdouble (*CallStaticMethodDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...); + jdouble (*CallStaticMethodDoubleV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c); + jdouble (*CallStaticMethodDoubleA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c); + jint (*GetStaticFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c); + void* (*GetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbool (*GetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jbyte (*GetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jchar (*GetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jshort (*GetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jint (*GetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jlong (*GetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jfloat (*GetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + jdouble (*GetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b); + void (*SetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, void* c); + void (*SetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbool c); + void (*SetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbyte c); + void (*SetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jchar c); + void (*SetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jshort c); + void (*SetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jint c); + void (*SetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jlong c); + void (*SetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jfloat c); + void (*SetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jdouble c); + struct java_lang_String* (*NewString)(JRIEnv* env, jint op, const jchar* a, jint b); + jint (*GetStringLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jchar* (*GetStringChars)(JRIEnv* env, jint op, struct java_lang_String* a); + struct java_lang_String* (*NewStringUTF)(JRIEnv* env, jint op, const jbyte* a, jint b); + jint (*GetStringUTFLength)(JRIEnv* env, jint op, struct java_lang_String* a); + const jbyte* (*GetStringUTFChars)(JRIEnv* env, jint op, struct java_lang_String* a); + void* (*NewScalarArray)(JRIEnv* env, jint op, jint a, const char* b, const jbyte* c); + jint (*GetScalarArrayLength)(JRIEnv* env, jint op, void* a); + jbyte* (*GetScalarArrayElements)(JRIEnv* env, jint op, void* a); + void* (*NewObjectArray)(JRIEnv* env, jint op, jint a, struct java_lang_Class* b, void* c); + jint (*GetObjectArrayLength)(JRIEnv* env, jint op, void* a); + void* (*GetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b); + void (*SetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b, void* c); + void (*RegisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a, char** b, void** c); + void (*UnregisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a); + struct java_lang_Class* (*DefineClass)(JRIEnv* env, jint op, struct java_lang_ClassLoader* a, jbyte* b, jsize bLen); + struct java_lang_String* (*NewStringPlatform)(JRIEnv* env, jint op, const jbyte* a, jint b, const jbyte* c, jint d); + const jbyte* (*GetStringPlatformChars)(JRIEnv* env, jint op, struct java_lang_String* a, const jbyte* b, jint c); }; /* diff --git a/np_sdk/mozsrc/jri_md.h b/np_sdk/mozsrc/jri_md.h index 393299f386f5..0bc2e902a604 100644 --- a/np_sdk/mozsrc/jri_md.h +++ b/np_sdk/mozsrc/jri_md.h @@ -14,7 +14,7 @@ * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -22,7 +22,7 @@ * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or + * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only @@ -38,7 +38,7 @@ /******************************************************************************* * Java Runtime Interface - Machine Dependent Types ******************************************************************************/ - + #ifndef JRI_MD_H #define JRI_MD_H @@ -50,19 +50,19 @@ extern "C" { /******************************************************************************* * WHAT'S UP WITH THIS FILE? - * + * * This is where we define the mystical JRI_PUBLIC_API macro that works on all - * platforms. If you're running with Visual C++, Symantec C, or Borland's + * platforms. If you're running with Visual C++, Symantec C, or Borland's * development environment on the PC, you're all set. Or if you're on the Mac * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't * matter. * * On UNIX though you probably care about a couple of other symbols though: - * IS_LITTLE_ENDIAN must be defined for little-endian systems - * HAVE_LONG_LONG must be defined on systems that have 'long long' integers - * HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned - * HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned - * IS_64 must be defined on 64-bit machines (like Dec Alpha) + * IS_LITTLE_ENDIAN must be defined for little-endian systems + * HAVE_LONG_LONG must be defined on systems that have 'long long' integers + * HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned + * HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned + * IS_64 must be defined on 64-bit machines (like Dec Alpha) ******************************************************************************/ /* DLL Entry modifiers... */ @@ -70,100 +70,100 @@ extern "C" { /* PC */ #if defined(XP_OS2) # ifdef XP_OS2_VACPP -# define JRI_PUBLIC_API(ResultType) ResultType _Optlink -# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_API(ResultType) ResultType _Optlink +# define JRI_PUBLIC_VAR(VarType) VarType # define JRI_CALLBACK # else -# define JRI_PUBLIC_API(ResultType) ResultType -# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType # define JRI_CALLBACK # endif #elif defined(XP_PC) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) -# include <windows.h> -# if defined(_MSC_VER) || defined(__MINGW32__) -# if defined(WIN32) || defined(_WIN32) -# define JRI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType -# define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) _declspec(dllexport) VarType -# define JRI_PUBLIC_VAR_IMP(VarType) _declspec(dllimport) VarType -# define JRI_NATIVE_STUB(ResultType) _declspec(dllexport) ResultType -# define JRI_CALLBACK -# else /* !_WIN32 */ -# if defined(_WINDLL) -# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds -# define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds -# define JRI_CALLBACK __loadds -# else /* !WINDLL */ -# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export -# define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __export -# define JRI_CALLBACK __export +# include <windows.h> +# if defined(_MSC_VER) || defined(__MINGW32__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) _declspec(dllexport) VarType +# define JRI_PUBLIC_VAR_IMP(VarType) _declspec(dllimport) VarType +# define JRI_NATIVE_STUB(ResultType) _declspec(dllexport) ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# if defined(_WINDLL) +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds +# define JRI_CALLBACK __loadds +# else /* !WINDLL */ +# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __export +# define JRI_CALLBACK __export # endif /* !WINDLL */ -# endif /* !_WIN32 */ -# elif defined(__BORLANDC__) -# if defined(WIN32) || defined(_WIN32) -# define JRI_PUBLIC_API(ResultType) __export ResultType -# define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) __export VarType -# define JRI_PUBLIC_VAR_IMP(VarType) __import VarType -# define JRI_NATIVE_STUB(ResultType) __export ResultType -# define JRI_CALLBACK -# else /* !_WIN32 */ -# define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds -# define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export VarType -# define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import VarType -# define JRI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds -# define JRI_CALLBACK _loadds -# endif -# else -# error Unsupported PC development environment. -# endif -# ifndef IS_LITTLE_ENDIAN -# define IS_LITTLE_ENDIAN -# endif +# endif /* !_WIN32 */ +# elif defined(__BORLANDC__) +# if defined(WIN32) || defined(_WIN32) +# define JRI_PUBLIC_API(ResultType) __export ResultType +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __import VarType +# define JRI_NATIVE_STUB(ResultType) __export ResultType +# define JRI_CALLBACK +# else /* !_WIN32 */ +# define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds +# define JRI_PUBLIC_VAR(VarType) VarType +# define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export VarType +# define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import VarType +# define JRI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds +# define JRI_CALLBACK _loadds +# endif +# else +# error Unsupported PC development environment. +# endif +# ifndef IS_LITTLE_ENDIAN +# define IS_LITTLE_ENDIAN +# endif /* Mac */ #elif defined (macintosh) || Macintosh || THINK_C -# if defined(__MWERKS__) /* Metrowerks */ -# if !__option(enumsalwaysint) -# error You need to define 'Enums Always Int' for your project. -# endif -# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM -# if !__option(fourbyteints) -# error You need to define 'Struct Alignment: 68k' for your project. -# endif -# endif /* !GENERATINGCFM */ -# define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType -# define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) -# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) -# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) -# define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultType) -# elif defined(__SC__) /* Symantec */ -# error What are the Symantec defines? (warren@netscape.com) -# elif macintosh && applec /* MPW */ -# error Please upgrade to the latest MPW compiler (SC). -# else -# error Unsupported Mac development environment. -# endif -# define JRI_CALLBACK +# if defined(__MWERKS__) /* Metrowerks */ +# if !__option(enumsalwaysint) +# error You need to define 'Enums Always Int' for your project. +# endif +# if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM +# if !__option(fourbyteints) +# error You need to define 'Struct Alignment: 68k' for your project. +# endif +# endif /* !GENERATINGCFM */ +# define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType +# define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) +# define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultType) +# elif defined(__SC__) /* Symantec */ +# error What are the Symantec defines? (warren@netscape.com) +# elif macintosh && applec /* MPW */ +# error Please upgrade to the latest MPW compiler (SC). +# else +# error Unsupported Mac development environment. +# endif +# define JRI_CALLBACK /* Unix or else */ #else -# define JRI_PUBLIC_API(ResultType) ResultType +# define JRI_PUBLIC_API(ResultType) ResultType # define JRI_PUBLIC_VAR(VarType) VarType -# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) -# define JRI_NATIVE_STUB(ResultType) ResultType -# define JRI_CALLBACK +# define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) +# define JRI_NATIVE_STUB(ResultType) ResultType +# define JRI_CALLBACK #endif -#ifndef FAR /* for non-Win16 */ +#ifndef FAR /* for non-Win16 */ #define FAR #endif @@ -178,22 +178,22 @@ typedef class _jobject *jref; typedef struct _jobject *jref; #endif -typedef unsigned char jbool; -typedef char jbyte; -typedef short jchar; -typedef short jshort; +typedef unsigned char jbool; +typedef char jbyte; +typedef short jchar; +typedef short jshort; #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */ -typedef unsigned int juint; -typedef int jint; +typedef unsigned int juint; +typedef int jint; #else -typedef unsigned long juint; -typedef long jint; +typedef unsigned long juint; +typedef long jint; #endif -typedef float jfloat; -typedef double jdouble; +typedef float jfloat; +typedef double jdouble; -typedef juint jsize; +typedef juint jsize; /******************************************************************************* @@ -203,8 +203,8 @@ typedef juint jsize; /* ** Bit masking macros. (n must be <= 31 to be portable) */ -#define JRI_BIT(n) ((juint)1 << (n)) -#define JRI_BITMASK(n) (JRI_BIT(n) - 1) +#define JRI_BIT(n) ((juint)1 << (n)) +#define JRI_BITMASK(n) (JRI_BIT(n) - 1) #ifdef HAVE_LONG_LONG @@ -235,40 +235,40 @@ typedef unsigned long long julong; #endif -#define jlong_IS_ZERO(a) ((a) == 0) -#define jlong_EQ(a, b) ((a) == (b)) -#define jlong_NE(a, b) ((a) != (b)) -#define jlong_GE_ZERO(a) ((a) >= 0) -#define jlong_CMP(a, op, b) ((a) op (b)) - -#define jlong_AND(r, a, b) ((r) = (a) & (b)) -#define jlong_OR(r, a, b) ((r) = (a) | (b)) -#define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) -#define jlong_OR2(r, a) ((r) = (r) | (a)) -#define jlong_NOT(r, a) ((r) = ~(a)) - -#define jlong_NEG(r, a) ((r) = -(a)) -#define jlong_ADD(r, a, b) ((r) = (a) + (b)) -#define jlong_SUB(r, a, b) ((r) = (a) - (b)) - -#define jlong_MUL(r, a, b) ((r) = (a) * (b)) -#define jlong_DIV(r, a, b) ((r) = (a) / (b)) -#define jlong_MOD(r, a, b) ((r) = (a) % (b)) - -#define jlong_SHL(r, a, b) ((r) = (a) << (b)) -#define jlong_SHR(r, a, b) ((r) = (a) >> (b)) -#define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) -#define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) - -#define jlong_L2I(i, l) ((i) = (int)(l)) -#define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) -#define jlong_L2F(f, l) ((f) = (l)) -#define jlong_L2D(d, l) ((d) = (l)) - -#define jlong_I2L(l, i) ((l) = (i)) -#define jlong_UI2L(l, ui) ((l) = (ui)) -#define jlong_F2L(l, f) ((l) = (f)) -#define jlong_D2L(l, d) ((l) = (d)) +#define jlong_IS_ZERO(a) ((a) == 0) +#define jlong_EQ(a, b) ((a) == (b)) +#define jlong_NE(a, b) ((a) != (b)) +#define jlong_GE_ZERO(a) ((a) >= 0) +#define jlong_CMP(a, op, b) ((a) op (b)) + +#define jlong_AND(r, a, b) ((r) = (a) & (b)) +#define jlong_OR(r, a, b) ((r) = (a) | (b)) +#define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) +#define jlong_OR2(r, a) ((r) = (r) | (a)) +#define jlong_NOT(r, a) ((r) = ~(a)) + +#define jlong_NEG(r, a) ((r) = -(a)) +#define jlong_ADD(r, a, b) ((r) = (a) + (b)) +#define jlong_SUB(r, a, b) ((r) = (a) - (b)) + +#define jlong_MUL(r, a, b) ((r) = (a) * (b)) +#define jlong_DIV(r, a, b) ((r) = (a) / (b)) +#define jlong_MOD(r, a, b) ((r) = (a) % (b)) + +#define jlong_SHL(r, a, b) ((r) = (a) << (b)) +#define jlong_SHR(r, a, b) ((r) = (a) >> (b)) +#define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) +#define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) + +#define jlong_L2I(i, l) ((i) = (int)(l)) +#define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) +#define jlong_L2F(f, l) ((f) = (l)) +#define jlong_L2D(d, l) ((d) = (l)) + +#define jlong_I2L(l, i) ((l) = (i)) +#define jlong_UI2L(l, ui) ((l) = (ui)) +#define jlong_F2L(l, f) ((l) = (f)) +#define jlong_D2L(l, d) ((l) = (d)) #define jlong_UDIVMOD(qp, rp, a, b) \ (*(qp) = ((julong)(a) / (b)), \ @@ -283,35 +283,35 @@ typedef struct { juint hi, lo; #endif } jlong; -typedef jlong julong; +typedef jlong julong; extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; -#define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) -#define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) -#define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) -#define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) +#define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) +#define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) +#define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) +#define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) /* * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >). */ -#define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ +#define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ (((a).hi == (b).hi) && ((a).lo op (b).lo))) -#define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ +#define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ (((a).hi == (b).hi) && ((a).lo op (b).lo))) -#define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ +#define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ (r).hi = (a).hi & (b).hi) -#define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ +#define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ (r).hi = (a).hi | (b).hi) -#define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ +#define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ (r).hi = (a).hi ^ (b).hi) -#define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ +#define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ (r).hi = (r).hi | (a).hi) -#define jlong_NOT(r, a) ((r).lo = ~(a).lo, \ +#define jlong_NOT(r, a) ((r).lo = ~(a).lo, \ (r).hi = ~(a).hi) -#define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ +#define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ (r).hi = -(int32)(a).hi - ((r).lo != 0)) #define jlong_ADD(r, a, b) { \ jlong _a, _b; \ @@ -340,8 +340,8 @@ extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; } /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */ -#define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) -#define _jlong_hi16(a) ((a) >> 16) +#define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) +#define _jlong_hi16(a) ((a) >> 16) /* * Multiply 32-bit operands a and b to get 64-bit result r. @@ -367,7 +367,7 @@ extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder. * Minimize effort if one of qp and rp is null. */ -#define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) +#define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) extern JRI_PUBLIC_API(void) jlong_udivmod(julong *qp, julong *rp, julong a, julong b); @@ -479,9 +479,9 @@ jlong_udivmod(julong *qp, julong *rp, julong a, julong b); } \ } -#define jlong_L2I(i, l) ((i) = (l).lo) -#define jlong_L2UI(ui, l) ((ui) = (l).lo) -#define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d; } +#define jlong_L2I(i, l) ((i) = (l).lo) +#define jlong_L2UI(ui, l) ((ui) = (l).lo) +#define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d; } #define jlong_L2D(d, l) { \ int32 _negative; \ @@ -498,9 +498,9 @@ jlong_udivmod(julong *qp, julong *rp, julong a, julong b); (d) = -(d); \ } -#define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) -#define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) -#define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } +#define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) +#define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) +#define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } #define jlong_D2L(l, d) { \ int _negative; \ diff --git a/np_sdk/mozsrc/jritypes.h b/np_sdk/mozsrc/jritypes.h index 03a7a9dcfe41..8735f1078c3f 100644 --- a/np_sdk/mozsrc/jritypes.h +++ b/np_sdk/mozsrc/jritypes.h @@ -14,7 +14,7 @@ * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -22,7 +22,7 @@ * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or + * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only @@ -57,42 +57,42 @@ extern "C" { struct JRIEnvInterface; -typedef void* JRIRef; -typedef void* JRIGlobalRef; +typedef void* JRIRef; +typedef void* JRIGlobalRef; -typedef jint JRIFieldID; -typedef jint JRIMethodID; +typedef jint JRIFieldID; +typedef jint JRIMethodID; /* synonyms: */ -typedef JRIGlobalRef jglobal; +typedef JRIGlobalRef jglobal; typedef union JRIValue { - jbool z; - jbyte b; - jchar c; - jshort s; - jint i; - jlong l; - jfloat f; - jdouble d; - jref r; + jbool z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong l; + jfloat f; + jdouble d; + jref r; } JRIValue; typedef enum JRIBoolean { - JRIFalse = 0, - JRITrue = 1 + JRIFalse = 0, + JRITrue = 1 } JRIBoolean; typedef enum JRIConstant { - JRIUninitialized = -1 + JRIUninitialized = -1 } JRIConstant; /* convenience types (these must be distinct struct types for c++ overloading): */ -typedef struct jstringArrayStruct* jstringArray; -typedef struct jarrayArrayStruct* jarrayArray; +typedef struct jstringArrayStruct* jstringArray; +typedef struct jarrayArrayStruct* jarrayArray; -#define JRIConstructorMethodName "<init>" +#define JRIConstructorMethodName "<init>" /******************************************************************************* * Signature Construction Macros @@ -103,29 +103,29 @@ typedef struct jarrayArrayStruct* jarrayArray; ** are a little easier to remember than the single character they correspond to. ** For example, to specify the signature of the method: ** -** public int read(byte b[], int off, int len); +** public int read(byte b[], int off, int len); ** ** you could write something like this in C: ** -** char* readSig = JRISigMethod(JRISigArray(JRISigByte) -** JRISigInt -** JRISigInt) JRISigInt; +** char* readSig = JRISigMethod(JRISigArray(JRISigByte) +** JRISigInt +** JRISigInt) JRISigInt; ** ** Of course, don't put commas between the types. */ -#define JRISigArray(T) "[" T -#define JRISigByte "B" -#define JRISigChar "C" -#define JRISigClass(name) "L" name ";" -#define JRISigFloat "F" -#define JRISigDouble "D" -#define JRISigMethod(args) "(" args ")" -#define JRISigNoArgs "" -#define JRISigInt "I" -#define JRISigLong "J" -#define JRISigShort "S" -#define JRISigVoid "V" -#define JRISigBoolean "Z" +#define JRISigArray(T) "[" T +#define JRISigByte "B" +#define JRISigChar "C" +#define JRISigClass(name) "L" name ";" +#define JRISigFloat "F" +#define JRISigDouble "D" +#define JRISigMethod(args) "(" args ")" +#define JRISigNoArgs "" +#define JRISigInt "I" +#define JRISigLong "J" +#define JRISigShort "S" +#define JRISigVoid "V" +#define JRISigBoolean "Z" /******************************************************************************* * Environments @@ -146,53 +146,53 @@ JRI_GetCurrentEnv(void); ** passing them to a native method. */ -#define JRI_NewByteArray(env, length, initialValues) \ +#define JRI_NewByteArray(env, length, initialValues) \ JRI_NewScalarArray(env, length, JRISigByte, (jbyte*)(initialValues)) -#define JRI_GetByteArrayLength(env, array) \ +#define JRI_GetByteArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetByteArrayElements(env, array) \ +#define JRI_GetByteArrayElements(env, array) \ JRI_GetScalarArrayElements(env, array) -#define JRI_NewCharArray(env, length, initialValues) \ +#define JRI_NewCharArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jchar)), JRISigChar, (jbyte*)(initialValues)) -#define JRI_GetCharArrayLength(env, array) \ +#define JRI_GetCharArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetCharArrayElements(env, array) \ +#define JRI_GetCharArrayElements(env, array) \ ((jchar*)JRI_GetScalarArrayElements(env, array)) -#define JRI_NewShortArray(env, length, initialValues) \ +#define JRI_NewShortArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jshort)), JRISigShort, (jbyte*)(initialValues)) -#define JRI_GetShortArrayLength(env, array) \ +#define JRI_GetShortArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetShortArrayElements(env, array) \ +#define JRI_GetShortArrayElements(env, array) \ ((jshort*)JRI_GetScalarArrayElements(env, array)) -#define JRI_NewIntArray(env, length, initialValues) \ +#define JRI_NewIntArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jint)), JRISigInt, (jbyte*)(initialValues)) -#define JRI_GetIntArrayLength(env, array) \ +#define JRI_GetIntArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetIntArrayElements(env, array) \ +#define JRI_GetIntArrayElements(env, array) \ ((jint*)JRI_GetScalarArrayElements(env, array)) -#define JRI_NewLongArray(env, length, initialValues) \ +#define JRI_NewLongArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jlong)), JRISigLong, (jbyte*)(initialValues)) -#define JRI_GetLongArrayLength(env, array) \ +#define JRI_GetLongArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetLongArrayElements(env, array) \ +#define JRI_GetLongArrayElements(env, array) \ ((jlong*)JRI_GetScalarArrayElements(env, array)) -#define JRI_NewFloatArray(env, length, initialValues) \ +#define JRI_NewFloatArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jfloat)), JRISigFloat, (jbyte*)(initialValues)) -#define JRI_GetFloatArrayLength(env, array) \ +#define JRI_GetFloatArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetFloatArrayElements(env, array) \ +#define JRI_GetFloatArrayElements(env, array) \ ((jfloat*)JRI_GetScalarArrayElements(env, array)) -#define JRI_NewDoubleArray(env, length, initialValues) \ +#define JRI_NewDoubleArray(env, length, initialValues) \ JRI_NewScalarArray(env, ((length) * sizeof(jdouble)), JRISigDouble, (jbyte*)(initialValues)) -#define JRI_GetDoubleArrayLength(env, array) \ +#define JRI_GetDoubleArrayLength(env, array) \ JRI_GetScalarArrayLength(env, array) -#define JRI_GetDoubleArrayElements(env, array) \ +#define JRI_GetDoubleArrayElements(env, array) \ ((jdouble*)JRI_GetScalarArrayElements(env, array)) /******************************************************************************/ @@ -212,7 +212,7 @@ typedef union JRI_JDK_stack_item { unsigned char *addr; #ifdef IS_64 double d; - long l; /* == 64bits! */ + long l; /* == 64bits! */ #endif } JRI_JDK_stack_item; diff --git a/np_sdk/mozsrc/npapi.h b/np_sdk/mozsrc/npapi.h index ef2b21a6223f..af64042804cc 100644 --- a/np_sdk/mozsrc/npapi.h +++ b/np_sdk/mozsrc/npapi.h @@ -14,7 +14,7 @@ * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -52,30 +52,30 @@ #include "jri.h" /* Java Runtime Interface */ #if defined (__OS2__ ) || defined (OS2) -# ifndef XP_OS2 -# define XP_OS2 1 -# endif /* XP_OS2 */ +# ifndef XP_OS2 +# define XP_OS2 1 +# endif /* XP_OS2 */ #endif /* __OS2__ */ #ifdef _WINDOWS -# ifndef XP_WIN -# define XP_WIN 1 -# endif /* XP_WIN */ +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* XP_WIN */ #endif /* _WINDOWS */ #ifdef __MWERKS__ -# define _declspec __declspec -# ifdef macintosh -# ifndef XP_MAC -# define XP_MAC 1 -# endif /* XP_MAC */ -# endif /* macintosh */ -# ifdef __INTEL__ -# undef NULL -# ifndef XP_WIN -# define XP_WIN 1 -# endif /* __INTEL__ */ -# endif /* XP_PC */ +# define _declspec __declspec +# ifdef macintosh +# ifndef XP_MAC +# define XP_MAC 1 +# endif /* XP_MAC */ +# endif /* macintosh */ +# ifdef __INTEL__ +# undef NULL +# ifndef XP_WIN +# define XP_WIN 1 +# endif /* __INTEL__ */ +# endif /* XP_PC */ #endif /* __MWERKS__ */ #ifdef XP_MAC @@ -188,10 +188,10 @@ typedef long int32; #define NULL (0L) #endif -typedef unsigned char NPBool; -typedef int16 NPError; -typedef int16 NPReason; -typedef char* NPMIMEType; +typedef unsigned char NPBool; +typedef int16 NPError; +typedef int16 NPReason; +typedef char* NPMIMEType; @@ -208,8 +208,8 @@ typedef char* NPMIMEType; */ typedef struct _NPP { - void* pdata; /* plug-in private data */ - void* ndata; /* netscape private data */ + void* pdata; /* plug-in private data */ + void* ndata; /* netscape private data */ } NPP_t; typedef NPP_t* NPP; @@ -236,8 +236,8 @@ typedef struct _NPByteRange typedef struct _NPSavedData { - int32 len; - void* buf; + int32 len; + void* buf; } NPSavedData; @@ -249,11 +249,11 @@ typedef struct _NPRect uint16 right; } NPRect; -typedef struct _NPSize -{ - int32 width; - int32 height; -} NPSize; +typedef struct _NPSize +{ + int32 width; + int32 height; +} NPSize; #ifdef XP_UNIX /* @@ -344,11 +344,11 @@ typedef struct _NPWindow /* OS/2: x - Position of bottom left corner */ /* OS/2: y - relative to visible netscape window */ int32 x; /* Position of top left corner relative */ - int32 y; /* to a netscape page. */ + int32 y; /* to a netscape page. */ uint32 width; /* Maximum window size */ uint32 height; NPRect clipRect; /* Clipping rectangle in port coordinates */ - /* Used by MAC only. */ + /* Used by MAC only. */ #ifdef XP_UNIX void * ws_info; /* Platform-dependent additonal data */ #endif /* XP_UNIX */ @@ -359,7 +359,7 @@ typedef struct _NPWindow typedef struct _NPFullPrint { NPBool pluginPrinted;/* Set TRUE if plugin handled fullscreen printing */ - NPBool printOne; /* TRUE if plugin should print one copy to default printer */ + NPBool printOne; /* TRUE if plugin should print one copy to default printer */ void* platformPrint; /* Platform-specific printing info */ } NPFullPrint; @@ -380,7 +380,7 @@ typedef struct _NPPrint } NPPrint; #ifdef XP_MAC -typedef EventRecord NPEvent; +typedef EventRecord NPEvent; #elif defined(XP_WIN) typedef struct _NPEvent { @@ -398,7 +398,7 @@ typedef struct _NPEvent #elif defined (XP_UNIX) && !defined(NO_X11) typedef XEvent NPEvent; #else -typedef void* NPEvent; +typedef void* NPEvent; #endif /* XP_MAC */ #ifdef XP_MAC @@ -458,7 +458,7 @@ enum NPEventType { #define NP_ASFILE 3 #define NP_ASFILEONLY 4 -#define NP_MAXREADY (((unsigned)(~0)<<1)>>1) +#define NP_MAXREADY (((unsigned)(~0)<<1)>>1) #ifdef XP_MAC #pragma options align=reset @@ -466,7 +466,7 @@ enum NPEventType { /*----------------------------------------------------------------------*/ -/* Error and Reason Code definitions */ +/* Error and Reason Code definitions */ /*----------------------------------------------------------------------*/ /* @@ -585,7 +585,7 @@ NPError NP_LOADDS NPN_NewStream(NPP instance, NPMIMEType type, int32 NP_LOADDS NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer); NPError NP_LOADDS NPN_DestroyStream(NPP instance, NPStream* stream, NPReason reason); void NP_LOADDS NPN_Status(NPP instance, const char* message); -const char* NP_LOADDS NPN_UserAgent(NPP instance); +const char* NP_LOADDS NPN_UserAgent(NPP instance); void* NP_LOADDS NPN_MemAlloc(uint32 size); void NP_LOADDS NPN_MemFree(void* ptr); uint32 NP_LOADDS NPN_MemFlush(uint32 size); diff --git a/np_sdk/mozsrc/npunix.c b/np_sdk/mozsrc/npunix.c index 55d0fa5316d2..cb92d8562a3c 100644 --- a/np_sdk/mozsrc/npunix.c +++ b/np_sdk/mozsrc/npunix.c @@ -244,7 +244,7 @@ NPN_ForceRedraw(NPP instance) * Wrapper functions : Netscape Navigator -> plugin * * These functions let the plugin developer just create the APIs - * as documented and defined in npapi.h, without needing to + * as documented and defined in npapi.h, without needing to * install those functions in the function table or worry about * setting up globals for 68K plugins. * @@ -257,7 +257,7 @@ Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, NPError ret; PLUGINDEBUGSTR("New"); ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved); - return ret; + return ret; } NPError @@ -325,7 +325,7 @@ Private_DestroyStream(NPP instance, NPStream* stream, NPError reason) void Private_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData) - + { PLUGINDEBUGSTR("URLNotify"); NPP_URLNotify(instance, url, reason, notifyData); @@ -353,7 +353,7 @@ Private_GetJavaClass(void) } #endif -/*********************************************************************** +/*********************************************************************** * * These functions are located automagically by netscape. * @@ -406,12 +406,12 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) NPError err = NPERR_NO_ERROR; PLUGINDEBUGSTR("NP_Initialize"); - + /* validate input parameters */ if ((nsTable == NULL) || (pluginFuncs == NULL)) err = NPERR_INVALID_FUNCTABLE_ERROR; - + /* * Check the major version passed in Netscape's function table. * We won't load if the major version is newer than what we expect. @@ -426,11 +426,11 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) err = NPERR_INCOMPATIBLE_VERSION_ERROR; if (nsTable->size < sizeof(NPNetscapeFuncs)) err = NPERR_INVALID_FUNCTABLE_ERROR; - if (pluginFuncs->size < sizeof(NPPluginFuncs)) + if (pluginFuncs->size < sizeof(NPPluginFuncs)) err = NPERR_INVALID_FUNCTABLE_ERROR; } - - + + if (err == NPERR_NO_ERROR) { /* * Copy all the fields of Netscape function table into our @@ -485,7 +485,7 @@ NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) err = NPP_Initialize(); } - + return err; } diff --git a/np_sdk/mozsrc/npupp.h b/np_sdk/mozsrc/npupp.h index 6d433f1afb00..9cf63e12c571 100644 --- a/np_sdk/mozsrc/npupp.h +++ b/np_sdk/mozsrc/npupp.h @@ -14,7 +14,7 @@ * * The Original Code is mozilla.org code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -79,21 +79,21 @@ typedef UniversalProcPtr NPP_InitializeUPP; enum { uppNPP_InitializeProcInfo = kThinkCStackBased - | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPP_InitializeProc(FUNC) \ +#define NewNPP_InitializeProc(FUNC) \ (NPP_InitializeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_InitializeProcInfo, GetCurrentArchitecture()) -#define CallNPP_InitializeProc(FUNC) \ +#define CallNPP_InitializeProc(FUNC) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_InitializeProcInfo) - + #else typedef void (* NP_LOADDS NPP_InitializeUPP)(void); -#define NewNPP_InitializeProc(FUNC) \ +#define NewNPP_InitializeProc(FUNC) \ ((NPP_InitializeUPP) (FUNC)) -#define CallNPP_InitializeProc(FUNC) \ +#define CallNPP_InitializeProc(FUNC) \ (*(FUNC))() #endif @@ -106,21 +106,21 @@ typedef UniversalProcPtr NPP_ShutdownUPP; enum { uppNPP_ShutdownProcInfo = kThinkCStackBased - | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) + | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(0)) | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPP_ShutdownProc(FUNC) \ +#define NewNPP_ShutdownProc(FUNC) \ (NPP_ShutdownUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_ShutdownProcInfo, GetCurrentArchitecture()) -#define CallNPP_ShutdownProc(FUNC) \ +#define CallNPP_ShutdownProc(FUNC) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_ShutdownProcInfo) - + #else typedef void (* NP_LOADDS NPP_ShutdownUPP)(void); -#define NewNPP_ShutdownProc(FUNC) \ +#define NewNPP_ShutdownProc(FUNC) \ ((NPP_ShutdownUPP) (FUNC)) -#define CallNPP_ShutdownProc(FUNC) \ +#define CallNPP_ShutdownProc(FUNC) \ (*(FUNC))() #endif @@ -143,17 +143,17 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_NewProc(FUNC) \ +#define NewNPP_NewProc(FUNC) \ (NPP_NewUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewProcInfo, GetCurrentArchitecture()) #define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewProcInfo, \ (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) #else -typedef NPError (* NP_LOADDS NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved); -#define NewNPP_NewProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_NewUPP)(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved); +#define NewNPP_NewProc(FUNC) \ ((NPP_NewUPP) (FUNC)) -#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ +#define CallNPP_NewProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) #endif @@ -170,16 +170,16 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPSavedData **))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_DestroyProc(FUNC) \ +#define NewNPP_DestroyProc(FUNC) \ (NPP_DestroyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyProcInfo, GetCurrentArchitecture()) -#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyProcInfo, (ARG1), (ARG2)) #else -typedef NPError (* NP_LOADDS NPP_DestroyUPP)(NPP instance, NPSavedData** save); -#define NewNPP_DestroyProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_DestroyUPP)(NPP instance, NPSavedData** save); +#define NewNPP_DestroyProc(FUNC) \ ((NPP_DestroyUPP) (FUNC)) -#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ +#define CallNPP_DestroyProc(FUNC, ARG1, ARG2) \ (*(FUNC))((ARG1), (ARG2)) #endif @@ -196,17 +196,17 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPWindow *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_SetWindowProc(FUNC) \ +#define NewNPP_SetWindowProc(FUNC) \ (NPP_SetWindowUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetWindowProcInfo, GetCurrentArchitecture()) -#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetWindowProcInfo, (ARG1), (ARG2)) #else -typedef NPError (* NP_LOADDS NPP_SetWindowUPP)(NPP instance, NPWindow* window); -#define NewNPP_SetWindowProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_SetWindowUPP)(NPP instance, NPWindow* window); +#define NewNPP_SetWindowProc(FUNC) \ ((NPP_SetWindowUPP) (FUNC)) -#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ +#define CallNPP_SetWindowProc(FUNC, ARG1, ARG2) \ (*(FUNC))((ARG1), (ARG2)) #endif @@ -226,14 +226,14 @@ enum { | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(uint16 *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_NewStreamProc(FUNC) \ +#define NewNPP_NewStreamProc(FUNC) \ (NPP_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_NewStreamProcInfo, GetCurrentArchitecture()) -#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ +#define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_NewStreamProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) #else -typedef NPError (* NP_LOADDS NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype); -#define NewNPP_NewStreamProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_NewStreamUPP)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16* stype); +#define NewNPP_NewStreamProc(FUNC) \ ((NPP_NewStreamUPP) (FUNC)) #define CallNPP_NewStreamProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) @@ -252,17 +252,17 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_DestroyStreamProc(FUNC) \ +#define NewNPP_DestroyStreamProc(FUNC) \ (NPP_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, GetCurrentArchitecture()) -#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_DestroyStreamProcInfo, (NPParg), (NPStreamPtr), (NPReasonArg)) #else -typedef NPError (* NP_LOADDS NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); -#define NewNPP_DestroyStreamProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); +#define NewNPP_DestroyStreamProc(FUNC) \ ((NPP_DestroyStreamUPP) (FUNC)) -#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ +#define CallNPP_DestroyStreamProc(FUNC, NPParg, NPStreamPtr, NPReasonArg) \ (*(FUNC))((NPParg), (NPStreamPtr), (NPReasonArg)) #endif @@ -279,17 +279,17 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPStream *))) | RESULT_SIZE(SIZE_CODE(sizeof(int32))) }; -#define NewNPP_WriteReadyProc(FUNC) \ +#define NewNPP_WriteReadyProc(FUNC) \ (NPP_WriteReadyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, GetCurrentArchitecture()) -#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteReadyProcInfo, (NPParg), (NPStreamPtr)) #else typedef int32 (* NP_LOADDS NPP_WriteReadyUPP)(NPP instance, NPStream* stream); -#define NewNPP_WriteReadyProc(FUNC) \ +#define NewNPP_WriteReadyProc(FUNC) \ ((NPP_WriteReadyUPP) (FUNC)) -#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ +#define CallNPP_WriteReadyProc(FUNC, NPParg, NPStreamPtr) \ (*(FUNC))((NPParg), (NPStreamPtr)) #endif @@ -309,17 +309,17 @@ enum { | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void*))) | RESULT_SIZE(SIZE_CODE(sizeof(int32))) }; -#define NewNPP_WriteProc(FUNC) \ +#define NewNPP_WriteProc(FUNC) \ (NPP_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_WriteProcInfo, GetCurrentArchitecture()) -#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_WriteProcInfo, (NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) #else typedef int32 (* NP_LOADDS NPP_WriteUPP)(NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer); -#define NewNPP_WriteProc(FUNC) \ +#define NewNPP_WriteProc(FUNC) \ ((NPP_WriteUPP) (FUNC)) -#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ +#define CallNPP_WriteProc(FUNC, NPParg, NPStreamPtr, offsetArg, lenArg, bufferPtr) \ (*(FUNC))((NPParg), (NPStreamPtr), (offsetArg), (lenArg), (bufferPtr)) #endif @@ -337,17 +337,17 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char *))) | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPP_StreamAsFileProc(FUNC) \ +#define NewNPP_StreamAsFileProc(FUNC) \ (NPP_StreamAsFileUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, GetCurrentArchitecture()) -#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_StreamAsFileProcInfo, (ARG1), (ARG2), (ARG3)) #else typedef void (* NP_LOADDS NPP_StreamAsFileUPP)(NPP instance, NPStream* stream, const char* fname); -#define NewNPP_StreamAsFileProc(FUNC) \ +#define NewNPP_StreamAsFileProc(FUNC) \ ((NPP_StreamAsFileUPP) (FUNC)) -#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPP_StreamAsFileProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -363,17 +363,17 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPPrint *))) | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPP_PrintProc(FUNC) \ +#define NewNPP_PrintProc(FUNC) \ (NPP_PrintUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_PrintProcInfo, GetCurrentArchitecture()) -#define CallNPP_PrintProc(FUNC, NPParg, voidPtr) \ +#define CallNPP_PrintProc(FUNC, NPParg, voidPtr) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_PrintProcInfo, (NPParg), (voidPtr)) #else typedef void (* NP_LOADDS NPP_PrintUPP)(NPP instance, NPPrint* platformPrint); -#define NewNPP_PrintProc(FUNC) \ +#define NewNPP_PrintProc(FUNC) \ ((NPP_PrintUPP) (FUNC)) -#define CallNPP_PrintProc(FUNC, NPParg, NPPrintArg) \ +#define CallNPP_PrintProc(FUNC, NPParg, NPPrintArg) \ (*(FUNC))((NPParg), (NPPrintArg)) #endif @@ -390,17 +390,17 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *))) | RESULT_SIZE(SIZE_CODE(sizeof(int16))) }; -#define NewNPP_HandleEventProc(FUNC) \ +#define NewNPP_HandleEventProc(FUNC) \ (NPP_HandleEventUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_HandleEventProcInfo, GetCurrentArchitecture()) -#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ (int16)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_HandleEventProcInfo, (NPParg), (voidPtr)) #else typedef int16 (* NP_LOADDS NPP_HandleEventUPP)(NPP instance, void* event); -#define NewNPP_HandleEventProc(FUNC) \ +#define NewNPP_HandleEventProc(FUNC) \ ((NPP_HandleEventUPP) (FUNC)) -#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ +#define CallNPP_HandleEventProc(FUNC, NPParg, voidPtr) \ (*(FUNC))((NPParg), (voidPtr)) #endif @@ -419,17 +419,17 @@ enum { | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) | RESULT_SIZE(SIZE_CODE(SIZE_CODE(0))) }; -#define NewNPP_URLNotifyProc(FUNC) \ +#define NewNPP_URLNotifyProc(FUNC) \ (NPP_URLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, GetCurrentArchitecture()) -#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_URLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) #else typedef void (* NP_LOADDS NPP_URLNotifyUPP)(NPP instance, const char* url, NPReason reason, void* notifyData); -#define NewNPP_URLNotifyProc(FUNC) \ +#define NewNPP_URLNotifyProc(FUNC) \ ((NPP_URLNotifyUPP) (FUNC)) -#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ +#define CallNPP_URLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) #endif @@ -447,16 +447,16 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_GetValueProc(FUNC) \ +#define NewNPP_GetValueProc(FUNC) \ (NPP_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_GetValueProcInfo, GetCurrentArchitecture()) #define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) #else -typedef NPError (* NP_LOADDS NPP_GetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); -#define NewNPP_GetValueProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_GetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPP_GetValueProc(FUNC) \ ((NPP_GetValueUPP) (FUNC)) -#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPP_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -473,16 +473,16 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_SetValueProc(FUNC) \ +#define NewNPP_SetValueProc(FUNC) \ (NPP_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_SetValueProcInfo, GetCurrentArchitecture()) #define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPP_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) #else -typedef NPError (* NP_LOADDS NPP_SetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); -#define NewNPP_SetValueProc(FUNC) \ +typedef NPError (* NP_LOADDS NPP_SetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPP_SetValueProc(FUNC) \ ((NPP_SetValueUPP) (FUNC)) -#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPP_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -506,16 +506,16 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_GetValueProc(FUNC) \ +#define NewNPN_GetValueProc(FUNC) \ (NPN_GetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetValueProcInfo, GetCurrentArchitecture()) #define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetValueProcInfo, (ARG1), (ARG2), (ARG3)) #else -typedef NPError (* NP_LOADDS NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); -#define NewNPN_GetValueProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_GetValueUPP)(NPP instance, NPNVariable variable, void *ret_alue); +#define NewNPN_GetValueProc(FUNC) \ ((NPN_GetValueUPP) (FUNC)) -#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPN_GetValueProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -532,16 +532,16 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_SetValueProc(FUNC) \ +#define NewNPN_SetValueProc(FUNC) \ (NPN_SetValueUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_SetValueProcInfo, GetCurrentArchitecture()) #define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_SetValueProcInfo, (ARG1), (ARG2), (ARG3)) #else -typedef NPError (* NP_LOADDS NPN_SetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); -#define NewNPN_SetValueProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_SetValueUPP)(NPP instance, NPPVariable variable, void *ret_alue); +#define NewNPN_SetValueProc(FUNC) \ ((NPN_SetValueUPP) (FUNC)) -#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPN_SetValueProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -559,16 +559,16 @@ enum { | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_GetURLNotifyProc(FUNC) \ +#define NewNPN_GetURLNotifyProc(FUNC) \ (NPN_GetURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, GetCurrentArchitecture()) #define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4)) #else -typedef NPError (* NP_LOADDS NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData); -#define NewNPN_GetURLNotifyProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_GetURLNotifyUPP)(NPP instance, const char* url, const char* window, void* notifyData); +#define NewNPN_GetURLNotifyProc(FUNC) \ ((NPN_GetURLNotifyUPP) (FUNC)) -#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ +#define CallNPN_GetURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4)) #endif @@ -589,14 +589,14 @@ enum { | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(void*))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_PostURLNotifyProc(FUNC) \ +#define NewNPN_PostURLNotifyProc(FUNC) \ (NPN_PostURLNotifyUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, GetCurrentArchitecture()) #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLNotifyProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) #else typedef NPError (* NP_LOADDS NPN_PostURLNotifyUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData); -#define NewNPN_PostURLNotifyProc(FUNC) \ +#define NewNPN_PostURLNotifyProc(FUNC) \ ((NPN_PostURLNotifyUPP) (FUNC)) #define CallNPN_PostURLNotifyProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) @@ -615,16 +615,16 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(const char*))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_GetURLProc(FUNC) \ +#define NewNPN_GetURLProc(FUNC) \ (NPN_GetURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetURLProcInfo, GetCurrentArchitecture()) #define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetURLProcInfo, (ARG1), (ARG2), (ARG3)) #else -typedef NPError (* NP_LOADDS NPN_GetURLUPP)(NPP instance, const char* url, const char* window); -#define NewNPN_GetURLProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_GetURLUPP)(NPP instance, const char* url, const char* window); +#define NewNPN_GetURLProc(FUNC) \ ((NPN_GetURLUPP) (FUNC)) -#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ +#define CallNPN_GetURLProc(FUNC, ARG1, ARG2, ARG3) \ (*(FUNC))((ARG1), (ARG2), (ARG3)) #endif @@ -644,14 +644,14 @@ enum { | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(NPBool))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_PostURLProc(FUNC) \ +#define NewNPN_PostURLProc(FUNC) \ (NPN_PostURLUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_PostURLProcInfo, GetCurrentArchitecture()) #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_PostURLProcInfo, (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) #else typedef NPError (* NP_LOADDS NPN_PostURLUPP)(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file); -#define NewNPN_PostURLProc(FUNC) \ +#define NewNPN_PostURLProc(FUNC) \ ((NPN_PostURLUPP) (FUNC)) #define CallNPN_PostURLProc(FUNC, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ (*(FUNC))((ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) @@ -669,17 +669,17 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NPByteRange *))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_RequestReadProc(FUNC) \ +#define NewNPN_RequestReadProc(FUNC) \ (NPN_RequestReadUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_RequestReadProcInfo, GetCurrentArchitecture()) -#define CallNPN_RequestReadProc(FUNC, stream, range) \ +#define CallNPN_RequestReadProc(FUNC, stream, range) \ (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_RequestReadProcInfo, (stream), (range)) #else -typedef NPError (* NP_LOADDS NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList); -#define NewNPN_RequestReadProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_RequestReadUPP)(NPStream* stream, NPByteRange* rangeList); +#define NewNPN_RequestReadProc(FUNC) \ ((NPN_RequestReadUPP) (FUNC)) -#define CallNPN_RequestReadProc(FUNC, stream, range) \ +#define CallNPN_RequestReadProc(FUNC, stream, range) \ (*(FUNC))((stream), (range)) #endif @@ -698,17 +698,17 @@ enum { | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(NPStream **))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_NewStreamProc(FUNC) \ +#define NewNPN_NewStreamProc(FUNC) \ (NPN_NewStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_NewStreamProcInfo, GetCurrentArchitecture()) -#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ - (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream)) +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_NewStreamProcInfo, (npp), (type), (window), (stream)) #else -typedef NPError (* NP_LOADDS NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream); -#define NewNPN_NewStreamProc(FUNC) \ +typedef NPError (* NP_LOADDS NPN_NewStreamUPP)(NPP instance, NPMIMEType type, const char* window, NPStream** stream); +#define NewNPN_NewStreamProc(FUNC) \ ((NPN_NewStreamUPP) (FUNC)) -#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ +#define CallNPN_NewStreamProc(FUNC, npp, type, window, stream) \ (*(FUNC))((npp), (type), (window), (stream)) #endif @@ -727,17 +727,17 @@ enum { | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))) | RESULT_SIZE(SIZE_CODE(sizeof(int32))) }; -#define NewNPN_WriteProc(FUNC) \ +#define NewNPN_WriteProc(FUNC) \ (NPN_WriteUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_WriteProcInfo, GetCurrentArchitecture()) -#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ - (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer)) +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ + (int32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_WriteProcInfo, (npp), (stream), (len), (buffer)) #else typedef int32 (* NP_LOADDS NPN_WriteUPP)(NPP instance, NPStream* stream, int32 len, void* buffer); -#define NewNPN_WriteProc(FUNC) \ +#define NewNPN_WriteProc(FUNC) \ ((NPN_WriteUPP) (FUNC)) -#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ +#define CallNPN_WriteProc(FUNC, npp, stream, len, buffer) \ (*(FUNC))((npp), (stream), (len), (buffer)) #endif @@ -755,17 +755,17 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPReason))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPN_DestroyStreamProc(FUNC) \ +#define NewNPN_DestroyStreamProc(FUNC) \ (NPN_DestroyStreamUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, GetCurrentArchitecture()) -#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ - (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason)) +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ + (NPError)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_DestroyStreamProcInfo, (npp), (stream), (reason)) #else typedef NPError (* NP_LOADDS NPN_DestroyStreamUPP)(NPP instance, NPStream* stream, NPReason reason); -#define NewNPN_DestroyStreamProc(FUNC) \ +#define NewNPN_DestroyStreamProc(FUNC) \ ((NPN_DestroyStreamUPP) (FUNC)) -#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ +#define CallNPN_DestroyStreamProc(FUNC, npp, stream, reason) \ (*(FUNC))((npp), (stream), (reason)) #endif @@ -782,18 +782,18 @@ enum { | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *))) }; -#define NewNPN_StatusProc(FUNC) \ +#define NewNPN_StatusProc(FUNC) \ (NPN_StatusUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_StatusProcInfo, GetCurrentArchitecture()) -#define CallNPN_StatusProc(FUNC, npp, msg) \ - (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg)) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_StatusProcInfo, (npp), (msg)) #else typedef void (* NP_LOADDS NPN_StatusUPP)(NPP instance, const char* message); -#define NewNPN_StatusProc(FUNC) \ +#define NewNPN_StatusProc(FUNC) \ ((NPN_StatusUPP) (FUNC)) -#define CallNPN_StatusProc(FUNC, npp, msg) \ - (*(FUNC))((npp), (msg)) +#define CallNPN_StatusProc(FUNC, npp, msg) \ + (*(FUNC))((npp), (msg)) #endif @@ -815,7 +815,7 @@ enum { #else -typedef const char* (* NP_LOADDS NPN_UserAgentUPP)(NPP instance); +typedef const char* (* NP_LOADDS NPN_UserAgentUPP)(NPP instance); #define NewNPN_UserAgentProc(FUNC) \ ((NPN_UserAgentUPP) (FUNC)) #define CallNPN_UserAgentProc(FUNC, ARG1) \ @@ -834,18 +834,18 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(void *))) }; -#define NewNPN_MemAllocProc(FUNC) \ +#define NewNPN_MemAllocProc(FUNC) \ (NPN_MemAllocUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemAllocProcInfo, GetCurrentArchitecture()) -#define CallNPN_MemAllocProc(FUNC, ARG1) \ - (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1)) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (void*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemAllocProcInfo, (ARG1)) #else typedef void* (* NP_LOADDS NPN_MemAllocUPP)(uint32 size); -#define NewNPN_MemAllocProc(FUNC) \ +#define NewNPN_MemAllocProc(FUNC) \ ((NPN_MemAllocUPP) (FUNC)) -#define CallNPN_MemAllocProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_MemAllocProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -860,18 +860,18 @@ enum { | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *))) }; -#define NewNPN_MemFreeProc(FUNC) \ +#define NewNPN_MemFreeProc(FUNC) \ (NPN_MemFreeUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFreeProcInfo, GetCurrentArchitecture()) -#define CallNPN_MemFreeProc(FUNC, ARG1) \ +#define CallNPN_MemFreeProc(FUNC, ARG1) \ (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFreeProcInfo, (ARG1)) #else typedef void (* NP_LOADDS NPN_MemFreeUPP)(void* ptr); -#define NewNPN_MemFreeProc(FUNC) \ +#define NewNPN_MemFreeProc(FUNC) \ ((NPN_MemFreeUPP) (FUNC)) -#define CallNPN_MemFreeProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_MemFreeProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -887,18 +887,18 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(uint32))) }; -#define NewNPN_MemFlushProc(FUNC) \ +#define NewNPN_MemFlushProc(FUNC) \ (NPN_MemFlushUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_MemFlushProcInfo, GetCurrentArchitecture()) -#define CallNPN_MemFlushProc(FUNC, ARG1) \ - (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1)) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (uint32)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_MemFlushProcInfo, (ARG1)) #else typedef uint32 (* NP_LOADDS NPN_MemFlushUPP)(uint32 size); -#define NewNPN_MemFlushProc(FUNC) \ +#define NewNPN_MemFlushProc(FUNC) \ ((NPN_MemFlushUPP) (FUNC)) -#define CallNPN_MemFlushProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_MemFlushProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -915,18 +915,18 @@ enum { | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPN_ReloadPluginsProc(FUNC) \ +#define NewNPN_ReloadPluginsProc(FUNC) \ (NPN_ReloadPluginsUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, GetCurrentArchitecture()) -#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ - (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ReloadPluginsProcInfo, (ARG1)) #else typedef void (* NP_LOADDS NPN_ReloadPluginsUPP)(NPBool reloadPages); -#define NewNPN_ReloadPluginsProc(FUNC) \ +#define NewNPN_ReloadPluginsProc(FUNC) \ ((NPN_ReloadPluginsUPP) (FUNC)) -#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_ReloadPluginsProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -941,17 +941,17 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(JRIEnv*))) }; -#define NewNPN_GetJavaEnvProc(FUNC) \ +#define NewNPN_GetJavaEnvProc(FUNC) \ (NPN_GetJavaEnvUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo, GetCurrentArchitecture()) -#define CallNPN_GetJavaEnvProc(FUNC) \ - (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) +#define CallNPN_GetJavaEnvProc(FUNC) \ + (JRIEnv*)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaEnvProcInfo) #else typedef JRIEnv* (* NP_LOADDS NPN_GetJavaEnvUPP)(void); -#define NewNPN_GetJavaEnvProc(FUNC) \ +#define NewNPN_GetJavaEnvProc(FUNC) \ ((NPN_GetJavaEnvUPP) (FUNC)) -#define CallNPN_GetJavaEnvProc(FUNC) \ - (*(FUNC))() +#define CallNPN_GetJavaEnvProc(FUNC) \ + (*(FUNC))() #endif @@ -967,18 +967,18 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(jref))) }; -#define NewNPN_GetJavaPeerProc(FUNC) \ +#define NewNPN_GetJavaPeerProc(FUNC) \ (NPN_GetJavaPeerUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, GetCurrentArchitecture()) -#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ - (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1)) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_GetJavaPeerProcInfo, (ARG1)) #else typedef jref (* NP_LOADDS NPN_GetJavaPeerUPP)(NPP instance); -#define NewNPN_GetJavaPeerProc(FUNC) \ +#define NewNPN_GetJavaPeerProc(FUNC) \ ((NPN_GetJavaPeerUPP) (FUNC)) -#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_GetJavaPeerProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -995,18 +995,18 @@ enum { | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPN_InvalidateRectProc(FUNC) \ +#define NewNPN_InvalidateRectProc(FUNC) \ (NPN_InvalidateRectUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, GetCurrentArchitecture()) -#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ - (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, (ARG1), (ARG2)) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRectProcInfo, (ARG1), (ARG2)) #else typedef void (* NP_LOADDS NPN_InvalidateRectUPP)(NPP instance, NPRect *rect); -#define NewNPN_InvalidateRectProc(FUNC) \ +#define NewNPN_InvalidateRectProc(FUNC) \ ((NPN_InvalidateRectUPP) (FUNC)) -#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ - (*(FUNC))((ARG1), (ARG2)) +#define CallNPN_InvalidateRectProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) #endif @@ -1023,18 +1023,18 @@ enum { | RESULT_SIZE(SIZE_CODE(0)) }; -#define NewNPN_InvalidateRegionProc(FUNC) \ +#define NewNPN_InvalidateRegionProc(FUNC) \ (NPN_InvalidateRegionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, GetCurrentArchitecture()) -#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ - (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, (ARG1), (ARG2)) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (void)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_InvalidateRegionProcInfo, (ARG1), (ARG2)) #else typedef void (* NP_LOADDS NPN_InvalidateRegionUPP)(NPP instance, NPRegion region); -#define NewNPN_InvalidateRegionProc(FUNC) \ +#define NewNPN_InvalidateRegionProc(FUNC) \ ((NPN_InvalidateRegionUPP) (FUNC)) -#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ - (*(FUNC))((ARG1), (ARG2)) +#define CallNPN_InvalidateRegionProc(FUNC, ARG1, ARG2) \ + (*(FUNC))((ARG1), (ARG2)) #endif @@ -1049,18 +1049,18 @@ enum { | RESULT_SIZE(SIZE_CODE(sizeof(0))) }; -#define NewNPN_ForceRedrawProc(FUNC) \ +#define NewNPN_ForceRedrawProc(FUNC) \ (NPN_ForceRedrawUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, GetCurrentArchitecture()) -#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ - (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, (ARG1)) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (jref)CallUniversalProc((UniversalProcPtr)(FUNC), uppNPN_ForceRedrawProcInfo, (ARG1)) #else typedef void (* NP_LOADDS NPN_ForceRedrawUPP)(NPP instance); -#define NewNPN_ForceRedrawProc(FUNC) \ +#define NewNPN_ForceRedrawProc(FUNC) \ ((NPN_ForceRedrawUPP) (FUNC)) -#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ - (*(FUNC))((ARG1)) +#define CallNPN_ForceRedrawProc(FUNC, ARG1) \ + (*(FUNC))((ARG1)) #endif @@ -1149,17 +1149,17 @@ enum { | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(NPP_ShutdownUPP*))) | RESULT_SIZE(SIZE_CODE(sizeof(NPError))) }; -#define NewNPP_MainEntryProc(FUNC) \ +#define NewNPP_MainEntryProc(FUNC) \ (NPP_MainEntryUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNPP_MainEntryProcInfo, GetCurrentArchitecture()) -#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNPP_MainEntryProcInfo, (netscapeFunc), (pluginFunc), (shutdownUPP)) #else typedef NPError (* NP_LOADDS NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownUPP*); -#define NewNPP_MainEntryProc(FUNC) \ +#define NewNPP_MainEntryProc(FUNC) \ ((NPP_MainEntryUPP) (FUNC)) -#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ +#define CallNPP_MainEntryProc(FUNC, netscapeFunc, pluginFunc, shutdownUPP) \ (*(FUNC))((netscapeFunc), (pluginFunc), (shutdownUPP)) #endif @@ -1170,7 +1170,7 @@ typedef NPError (* NP_LOADDS NPP_MainEntryUPP)(NPNetscapeFuncs*, NPPluginFuncs*, * These can be called to retreive MIME information from the plugin dynamically * * Note: For compatibility with Quicktime, BPSupportedMIMEtypes is another way - * to get mime info from the plugin only on OSX and may not be supported + * to get mime info from the plugin only on OSX and may not be supported * in furture version--use NP_GetMIMEDescription instead */ @@ -1195,9 +1195,9 @@ enum { uppNP_GetMIMEDescEntryProc = kThinkCStackBased | RESULT_SIZE(SIZE_CODE(sizeof(const char *))) }; -#define NewNP_GetMIMEDescEntryProc(FUNC) \ +#define NewNP_GetMIMEDescEntryProc(FUNC) \ (NP_GetMIMEDescriptionUPP) NewRoutineDescriptor((ProcPtr)(FUNC), uppNP_GetMIMEDescEntryProc, GetCurrentArchitecture()) -#define CallNP_GetMIMEDescEntryProc(FUNC) \ +#define CallNP_GetMIMEDescEntryProc(FUNC) \ (const char *)CallUniversalProc((UniversalProcPtr)(FUNC), (ProcInfoType)uppNP_GetMIMEDescEntryProc) @@ -1206,15 +1206,15 @@ enum { // NP_GetMIMEDescription #define NP_GETMIMEDESCRIPTION_NAME "NP_GetMIMEDescription" typedef const char* (* NP_LOADDS NP_GetMIMEDescriptionUPP)(); -#define NewNP_GetMIMEDescEntryProc(FUNC) \ +#define NewNP_GetMIMEDescEntryProc(FUNC) \ ((NP_GetMIMEDescriptionUPP) (FUNC)) -#define CallNP_GetMIMEDescEntryProc(FUNC) \ +#define CallNP_GetMIMEDescEntryProc(FUNC) \ (*(FUNC))() // BP_GetSupportedMIMETypes typedef OSErr (* NP_LOADDS BP_GetSupportedMIMETypesUPP)(BPSupportedMIMETypes*, UInt32); -#define NewBP_GetSupportedMIMETypesEntryProc(FUNC) \ +#define NewBP_GetSupportedMIMETypesEntryProc(FUNC) \ ((BP_GetSupportedMIMETypesUPP) (FUNC)) -#define CallBP_GetMIMEDescEntryProc(FUNC, mimeInfo, flags) \ +#define CallBP_GetMIMEDescEntryProc(FUNC, mimeInfo, flags) \ (*(FUNC))((mimeInfo), (flags)) #endif @@ -1259,7 +1259,7 @@ NPError OSCALL NP_Initialize(NPNetscapeFuncs* pFuncs); NPError OSCALL NP_Shutdown(); -char* NP_GetMIMEDescription(); +char* NP_GetMIMEDescription(); #ifdef __cplusplus } @@ -1279,9 +1279,9 @@ extern "C" { /* plugin meta member functions */ -char* NP_GetMIMEDescription(void); -NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*); -NPError NP_Shutdown(void); +char* NP_GetMIMEDescription(void); +NPError NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*); +NPError NP_Shutdown(void); #ifdef __cplusplus } diff --git a/np_sdk/mozsrc/npwin.cpp b/np_sdk/mozsrc/npwin.cpp index 2855290529ab..1fb4d3e68e14 100644 --- a/np_sdk/mozsrc/npwin.cpp +++ b/np_sdk/mozsrc/npwin.cpp @@ -14,7 +14,7 @@ * * The Original Code is Mozilla Communicator client code. * - * The Initial Developer of the Original Code is + * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. @@ -22,7 +22,7 @@ * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or + * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only @@ -63,8 +63,8 @@ JRIGlobalRef Private_GetJavaClass(void); ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // Private_GetJavaClass (global function) // -// Given a Java class reference (thru NPP_GetJavaClass) inform JRT -// of this class existence +// Given a Java class reference (thru NPP_GetJavaClass) inform JRT +// of this class existence // JRIGlobalRef Private_GetJavaClass(void) @@ -80,7 +80,7 @@ Private_GetJavaClass(void) //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. -// PLUGIN DLL entry points +// PLUGIN DLL entry points // // These are the Windows specific DLL entry points. They must be exoprted // @@ -95,19 +95,19 @@ static NPPluginFuncs* g_pluginFuncs; ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_GetEntryPoints // -// fills in the func table used by Navigator to call entry points in +// fills in the func table used by Navigator to call entry points in // plugin DLL. Note that these entry points ensure that DS is loaded // by using the NP_LOADDS macro, when compiling for Win16 // NPError WINAPI NP_EXPORT NP_GetEntryPoints(NPPluginFuncs* pFuncs) { - // trap a NULL ptr + // trap a NULL ptr if(pFuncs == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; // if the plugin's function table is smaller than the plugin expects, - // then they are incompatible, and should return an error + // then they are incompatible, and should return an error pFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR; pFuncs->newp = NPP_New; @@ -119,9 +119,9 @@ NP_GetEntryPoints(NPPluginFuncs* pFuncs) pFuncs->writeready = NPP_WriteReady; pFuncs->write = NPP_Write; pFuncs->print = NPP_Print; - pFuncs->event = 0; /// reserved + pFuncs->event = 0; /// reserved - g_pluginFuncs = pFuncs; + g_pluginFuncs = pFuncs; return NPERR_NO_ERROR; } @@ -130,19 +130,19 @@ NP_GetEntryPoints(NPPluginFuncs* pFuncs) ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_Initialize // -// called immediately after the plugin DLL is loaded +// called immediately after the plugin DLL is loaded // -NPError WINAPI NP_EXPORT +NPError WINAPI NP_EXPORT NP_Initialize(NPNetscapeFuncs* pFuncs) { - // trap a NULL ptr + // trap a NULL ptr if(pFuncs == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; - g_pNavigatorFuncs = pFuncs; // save it for future reference + g_pNavigatorFuncs = pFuncs; // save it for future reference // if the plugin's major ver level is lower than the Navigator's, - // then they are incompatible, and should return an error + // then they are incompatible, and should return an error if(HIBYTE(pFuncs->version) > NP_VERSION_MAJOR) return NPERR_INCOMPATIBLE_VERSION_ERROR; @@ -152,8 +152,8 @@ NP_Initialize(NPNetscapeFuncs* pFuncs) if( navMinorVers >= NPVERS_HAS_NOTIFICATION ) { g_pluginFuncs->urlnotify = NPP_URLNotify; } - -#ifdef OJI + +#ifdef OJI if( navMinorVers >= NPVERS_HAS_LIVECONNECT ) { g_pluginFuncs->javaClass = Private_GetJavaClass(); } @@ -167,11 +167,11 @@ NP_Initialize(NPNetscapeFuncs* pFuncs) ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. // NP_Shutdown // -// called immediately before the plugin DLL is unloaded. -// This functio shuold check for some ref count on the dll to see if it is -// unloadable or it needs to stay in memory. +// called immediately before the plugin DLL is unloaded. +// This functio shuold check for some ref count on the dll to see if it is +// unloadable or it needs to stay in memory. // -NPError WINAPI NP_EXPORT +NPError WINAPI NP_EXPORT NP_Shutdown() { NPP_Shutdown(); @@ -184,7 +184,7 @@ char * NP_GetMIMEDescription() return NPP_GetMIMEDescription(); } -// END - PLUGIN DLL entry points +// END - PLUGIN DLL entry points ////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//. //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\. @@ -267,7 +267,7 @@ NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) /* Creates a new stream of data from the plug-in to be interpreted by Netscape in the current window. */ -NPError NPN_NewStream(NPP instance, NPMIMEType type, +NPError NPN_NewStream(NPP instance, NPMIMEType type, const char* target, NPStream** stream) { int navMinorVersion = g_pNavigatorFuncs->version & 0xFF; @@ -299,7 +299,7 @@ int32 NPN_Write(NPP instance, NPStream *stream, return result; } -/* Closes a stream object. +/* Closes a stream object. reason indicates why the stream was closed. */ NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) |