Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

** NOT PART OF TBOX BUILDS **

Browse Source 
BlackConnect M2 check in.
It should be possible to implement any scriptable interface in java.
Also it should be possible to use any scriptable object from java.
Fixed: 15498, 15500


git-svn-id: svn://10.0.0.236/trunk@78858 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
idk%eng.sun.com
2000-09-12 08:54:13 +00:00
parent 3aedef481f
commit 15e68a5a17
43 changed files with 1734 additions and 844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
mozilla/java/xpcom/java/src/Makefile.in
View File

@@ -51,17 +51,18 @@ CPPSRCS = \
CXXFLAGS += -I$(JDKHOME)/include -I$(JDKHOME)/include/linux $(MOZ_TOOLKIT_REGISTRY_CFLAGS) -D_REENTRANT -DOJI_DISABLE -I$(CONNECT_SRC)/public
DSO_LDOPTS += \
-L$(JDKHOME)/jre/lib/$(HOSTTYPE)/ \
-L$(JDKHOME)/jre/lib/$(HOSTTYPE)/classic \
-L$(JDKHOME)/jre/lib/$(HOSTTYPE)/native_threads \
-ljvm -lhpi -ljava\
$(NULL)
#DSO_LDOPTS += \
# -L$(JDKHOME)/jre/lib/$(HOSTTYPE)/ \
# -L$(JDKHOME)/jre/lib/$(HOSTTYPE)/classic \
# -L$(JDKHOME)/jre/bin \
# -L$(JDKHOME)/jre/bin/classic \
# -ljvm \
# $(NULL)
DSO_LDOPTS += \
-L$(JDKHOME)/jre/bin \
-L$(JDKHOME)/jre/bin/classic \
-ljvm \
$(NULL)
ifneq ($(OS_ARCH), Linux)
DSO_LDOPTS += \

4
mozilla/java/xpcom/java/src/bcIIDJava.cpp
View File

@@ -70,7 +70,7 @@ jobject bcIIDJava::GetObject(nsIID *iid) {
char *str = iid->ToString(); //nb free ?
jstring jstr = NULL;
if (str) {
char *siid = str+1; //we do need to have {_fdsf_}
char *siid = str+1; //we do need to have it. The format is {_xxx-xxx-xxx_}
siid[strlen(siid)-1] = 0;
jstr = env->NewStringUTF((const char *)siid);
}
@@ -90,7 +90,7 @@ nsIID bcIIDJava::GetIID(jobject obj) {
}
jstring jstr = (jstring)env->CallObjectMethod(obj, getStringMID);
const char * str = NULL;
str = env->GetStringUTFChars(jstr,NULL);
str = env->GetStringUTFChars(jstr,NULL);
iid.Parse(str);
env->ReleaseStringUTFChars(jstr,str);

13
mozilla/java/xpcom/java/src/bcJavaGlobal.cpp
View File

@@ -38,7 +38,6 @@ JavaVM *bcJavaGlobal::jvm = NULL;
#endif
JNIEnv * bcJavaGlobal::GetJNIEnv(void) {
printf("--bcJavaGlobal::GetJNIEnv begin\n");
JNIEnv * env;
int res;
if (!jvm) {
@@ -47,7 +46,6 @@ JNIEnv * bcJavaGlobal::GetJNIEnv(void) {
if (jvm) {
res = jvm->AttachCurrentThread(JNIENV &env,NULL);
}
printf("--bcJavaGlobal::GetJNIEnv %d\n",res);
return env;
}
@@ -62,6 +60,7 @@ void bcJavaGlobal::StartJVM() {
if (jvmCount) {
return;
}
#if 0
JDK1_1InitArgs vm_args;
char classpath[1024];
JNI_GetDefaultJavaVMInitArgs(&vm_args);
@@ -78,16 +77,18 @@ void bcJavaGlobal::StartJVM() {
vm_args.classpath = classpath;
/* Create the Java VM */
res = JNI_CreateJavaVM(&jvm, JNIENV &env, &vm_args);
#if 0
#endif
#if 1
char classpath[1024];
JavaVMInitArgs vm_args;
JavaVMOption options[2];
sprintf(classpath, "-Djava.class.path=%s",PR_GetEnv("CLASSPATH"));
sprintf(classpath, "-Djava.class.path=%s:/ws/mozilla/dist/classes",PR_GetEnv("CLASSPATH"));
printf("--[c++] classpath %s\n",classpath);
options[0].optionString = classpath;
options[1].optionString="-Djava.compiler=NONE";
options[1].optionString=""; //-Djava.compiler=NONE";
vm_args.version = 0x00010002;
vm_args.options = options;
vm_args.nOptions = 1;
vm_args.nOptions = 2;
vm_args.ignoreUnrecognized = JNI_TRUE;
/* Create the Java VM */
res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);

861
mozilla/java/xpcom/java/src/bcJavaMarshalToolkit.cpp
View File

@@ -28,39 +28,54 @@
#include "nsIServiceManager.h"
jclass bcJavaMarshalToolkit::objectClass = NULL;
jclass bcJavaMarshalToolkit::objectArrayClass = NULL;
jclass bcJavaMarshalToolkit::booleanClass = NULL;
jclass bcJavaMarshalToolkit::booleanArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::booleanInitMID = NULL;
jmethodID bcJavaMarshalToolkit::booleanValueMID = NULL;
jclass bcJavaMarshalToolkit::characterClass = NULL;
jmethodID bcJavaMarshalToolkit::characterInitMID = NULL;
jmethodID bcJavaMarshalToolkit::characterValueMID = NULL;
jclass bcJavaMarshalToolkit::charClass = NULL;
jclass bcJavaMarshalToolkit::charArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::charInitMID = NULL;
jmethodID bcJavaMarshalToolkit::charValueMID = NULL;
jclass bcJavaMarshalToolkit::byteClass = NULL;
jclass bcJavaMarshalToolkit::byteArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::byteInitMID = NULL;
jmethodID bcJavaMarshalToolkit::byteValueMID = NULL;
jclass bcJavaMarshalToolkit::shortClass = NULL;
jclass bcJavaMarshalToolkit::shortArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::shortInitMID = NULL;
jmethodID bcJavaMarshalToolkit::shortValueMID = NULL;
jclass bcJavaMarshalToolkit::integerClass = NULL;
jmethodID bcJavaMarshalToolkit::integerInitMID = NULL;
jmethodID bcJavaMarshalToolkit::integerValueMID = NULL;
jclass bcJavaMarshalToolkit::intClass = NULL;
jclass bcJavaMarshalToolkit::intArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::intInitMID = NULL;
jmethodID bcJavaMarshalToolkit::intValueMID = NULL;
jclass bcJavaMarshalToolkit::longClass = NULL;
jclass bcJavaMarshalToolkit::longArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::longInitMID = NULL;
jmethodID bcJavaMarshalToolkit::longValueMID = NULL;
jclass bcJavaMarshalToolkit::floatClass = NULL;
jclass bcJavaMarshalToolkit::floatArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::floatInitMID = NULL;
jmethodID bcJavaMarshalToolkit::floatValueMID = NULL;
jclass bcJavaMarshalToolkit::doubleClass = NULL;
jclass bcJavaMarshalToolkit::doubleArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::doubleInitMID = NULL;
jmethodID bcJavaMarshalToolkit::doubleValueMID = NULL;
jclass bcJavaMarshalToolkit::stringClass = NULL;
jclass bcJavaMarshalToolkit::stringArrayClass = NULL;
jclass bcJavaMarshalToolkit::iidClass = NULL;
jclass bcJavaMarshalToolkit::iidArrayClass = NULL;
jmethodID bcJavaMarshalToolkit::getClassMID = NULL;
static NS_DEFINE_CID(kJavaStubsAndProxies,BC_JAVASTUBSANDPROXIES_CID);
@@ -85,12 +100,6 @@ bcJavaMarshalToolkit::bcJavaMarshalToolkit(PRUint16 _methodIndex,
bcJavaMarshalToolkit::~bcJavaMarshalToolkit() {
}
nsresult bcJavaMarshalToolkit::Marshal(bcIMarshaler *m) {
//nb todo
return NS_OK;
}
class javaAllocator : public bcIAllocator {
public:
javaAllocator(nsIAllocator *_allocator) {
@@ -110,351 +119,589 @@ private:
nsCOMPtr<nsIAllocator> allocator;
};
nsresult bcJavaMarshalToolkit::Marshal(bcIMarshaler *m) {
PRUint32 paramCount = info->GetParamCount();
nsresult r = NS_OK;
for (unsigned int i = 0; (i < paramCount) && NS_SUCCEEDED(r); i++) {
nsXPTParamInfo param = info->GetParam(i);
if ((callSide == onClient && !param.IsIn())
|| (callSide == onServer && !param.IsOut())) {
continue;
}
jobject object = env->GetObjectArrayElement(args,i);
r = MarshalElement(m, object, param.IsOut(), &param, XPTType2bcXPType(param.GetType().TagPart()), i);
}
return r;
}
nsresult bcJavaMarshalToolkit::UnMarshal(bcIUnMarshaler *um) {
printf("--nsresult bcJavaMarshalToolkit::UnMarshal\n");
bcIAllocator * allocator = new javaAllocator(nsAllocator::GetGlobalAllocator());
PRUint32 paramCount = info->GetParamCount();
jobject value;
void * data = allocator->Alloc(sizeof(nsXPTCMiniVariant)); // sizeof(nsXPTCMiniVariant) is ok
for (unsigned int i = 0; i < paramCount; i++) {
nsXPTParamInfo param = info->GetParam(i);
PRBool isOut = param.IsOut();
nsXPTType type = param.GetType();
if ( (callSide == onServer && !param.IsIn()
if ( (callSide == onServer && !param.IsIn()
|| (callSide == onClient && !param.IsOut()))){
if (callSide == onServer
&& isOut) { //we need to allocate memory for out parametr
value = Native2Java(NULL,XPTType2bcXPType(type.TagPart()),1);
UnMarshalElement(&value, i, NULL, 1, &param, XPTType2bcXPType(type.TagPart()),allocator);
env->SetObjectArrayElement(args,i,value);
}
continue;
}
switch(type.TagPart()) {
case nsXPTType::T_IID :
case nsXPTType::T_I8 :
case nsXPTType::T_U8 :
case nsXPTType::T_I16 :
case nsXPTType::T_U16 :
case nsXPTType::T_I32 :
case nsXPTType::T_U32 :
case nsXPTType::T_I64 :
case nsXPTType::T_U64 :
case nsXPTType::T_FLOAT :
case nsXPTType::T_DOUBLE :
case nsXPTType::T_BOOL :
case nsXPTType::T_CHAR :
case nsXPTType::T_WCHAR :
um->ReadSimple(data,XPTType2bcXPType(type.TagPart()));
value = Native2Java(data,XPTType2bcXPType(type.TagPart()),isOut);
break;
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_WCHAR_STR :
size_t size;
um->ReadString(data,&size,allocator);
//nb to do
break;
case nsXPTType::T_INTERFACE :
case nsXPTType::T_INTERFACE_IS :
{
printf("--[c++] we have an interface\n");
bcOID oid;
um->ReadSimple(&oid,XPTType2bcXPType(type.TagPart()));
printf("%d oid", oid);
nsIID iid;
um->ReadSimple(&iid,bc_T_IID);
void * p[2];
p[0]=&oid; p[1]= &iid;
data = p;
value = Native2Java(data,bc_T_INTERFACE,isOut);
break;
}
case nsXPTType::T_ARRAY:
{
nsXPTType datumType;
if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, &param, 1,&datumType))) {
return NS_ERROR_FAILURE;
}
//nb to do array
break;
}
default:
return NS_ERROR_FAILURE;
}
UnMarshalElement(&value, i, um, isOut, &param, XPTType2bcXPType(type.TagPart()),allocator);
env->SetObjectArrayElement(args,i,value);
}
delete allocator;
return NS_OK;
}
#define MARSHAL_SIMPLE_ELEMENT(_type_,_Type_) \
do { \
int indexInArray; \
j##_type_ data; \
if (! isOut \
&& (modifier == none)) { \
data = env->Call##_Type_##Method(value,_type_##ValueMID); \
} else if (isOut && (modifier == array)) { \
/* could not happend. We take care about it in T_ARRAY case */ \
} else if (modifier == arrayElement \
|| (isOut && (modifier == none))) { \
indexInArray = (modifier == arrayElement) ? ind : 0; \
env->Get##_Type_##ArrayRegion((j##_type_##Array)value, indexInArray, 1, &data); \
} \
m->WriteSimple(&data,type); \
} while (0)
nsresult
bcJavaMarshalToolkit::MarshalElement(bcIMarshaler *m, jobject value, PRBool isOut, nsXPTParamInfo * param,
bcXPType type, uint8 ind, ArrayModifier modifier) {
nsresult r = NS_OK;
switch(type) {
case bc_T_I8:
case bc_T_U8:
{
MARSHAL_SIMPLE_ELEMENT(byte,Byte);
break;
}
case bc_T_I16:
case bc_T_U16:
{
MARSHAL_SIMPLE_ELEMENT(short,Short);
break;
};
case bc_T_I32:
case bc_T_U32:
{
MARSHAL_SIMPLE_ELEMENT(int,Int);
break;
}
case bc_T_I64:
case bc_T_U64:
{
MARSHAL_SIMPLE_ELEMENT(long,Long);
break;
}
case bc_T_FLOAT:
{
MARSHAL_SIMPLE_ELEMENT(float,Float);
break;
}
case bc_T_DOUBLE:
{
MARSHAL_SIMPLE_ELEMENT(double,Double);
break;
}
case bc_T_BOOL:
{
MARSHAL_SIMPLE_ELEMENT(boolean,Boolean);
break;
}
case bc_T_CHAR:
case bc_T_WCHAR:
{
MARSHAL_SIMPLE_ELEMENT(char,Char);
break;
}
case bc_T_CHAR_STR:
case bc_T_WCHAR_STR: //nb not sure about this
{
int indexInArray;
jstring data = NULL;
if (! isOut
&& (modifier == none)) {
data = (jstring)value;
} else if (modifier == arrayElement
|| (isOut && (modifier == none))) {
indexInArray = (modifier == arrayElement) ? ind : 0;
data = (jstring)env->GetObjectArrayElement((jobjectArray)value,indexInArray);
}
char * str = NULL;
if (data) {
str = (char*)env->GetStringUTFChars((jstring)data,NULL);
m->WriteString(str,strlen(str)+1);
env->ReleaseStringUTFChars(data,str);
} else {
m->WriteString(str,0);
}
break;
}
case bc_T_IID:
{
int indexInArray;
jobject data = NULL;
if (! isOut
&& (modifier == none)) {
data = value;
} else if (modifier == arrayElement
|| (isOut && (modifier == none))) {
indexInArray = (modifier == arrayElement) ? ind : 0;
data = (jstring)env->GetObjectArrayElement((jobjectArray)value,indexInArray);
}
nsIID iid = bcIIDJava::GetIID(data);
m->WriteSimple(&iid, type);
break;
}
case bc_T_INTERFACE:
{
int indexInArray;
jobject data = NULL;
printf("--marshalElement we got interface\n");
bcOID oid = 0;
nsIID *iid;
if (! isOut
&& (modifier == none)) {
data = value;
} else if (modifier == arrayElement
|| (isOut && (modifier == none))) {
indexInArray = (modifier == arrayElement) ? ind : 0;
data = env->GetObjectArrayElement((jobjectArray)value,indexInArray);
}
if (data != NULL) {
NS_WITH_SERVICE(bcJavaStubsAndProxies, javaStubsAndProxies, kJavaStubsAndProxies, &r);
if (NS_FAILED(r)) {
return NS_ERROR_FAILURE;
}
javaStubsAndProxies->GetOID(data, orb, &oid);
}
m->WriteSimple(&oid,type);
if (param->GetType().TagPart() == nsXPTType::T_INTERFACE) {
if(NS_FAILED(r = interfaceInfo->
GetIIDForParam(methodIndex, param, &iid))) {
return r;
}
m->WriteSimple(iid,bc_T_IID);
} else {
uint8 argnum;
if (NS_FAILED(r = interfaceInfo->GetInterfaceIsArgNumberForParam(methodIndex,
param, &argnum))) {
return r;
}
const nsXPTParamInfo& arg_param = info->GetParam(argnum);
jobject object = env->GetObjectArrayElement(args,argnum);
r = MarshalElement(m, object, arg_param.IsOut(),(nsXPTParamInfo*)&arg_param,
XPTType2bcXPType(arg_param.GetType().TagPart()), (uint8)0);
}
break;
}
case bc_T_ARRAY:
{
nsXPTType datumType;
if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) {
return NS_ERROR_FAILURE;
}
bcXPType type = XPTType2bcXPType(datumType.TagPart());
jobject arrayValue = value;
if (isOut) {
arrayValue = env->GetObjectArrayElement((jobjectArray)value,0);
}
if (m != NULL) {
PRUint32 arraySize = (arrayValue == NULL) ? 0 : env->GetArrayLength((jarray)arrayValue);
m->WriteSimple(&arraySize,bc_T_U32);
for (PRUint32 i = 0; i < arraySize; i++) {
MarshalElement(m,arrayValue,PR_FALSE,param,type,i,arrayElement);
}
}
break;
}
default:
printf("--it should not happend\n");
;
}
return r;
}
#define UNMARSHAL_SIMPLE_ELEMENT(_type_,_Type_) \
do { \
int indexInArray; \
j##_type_ data; \
if (um) { \
um->ReadSimple(&data,type); \
} \
if ( ! isOut \
&& (modifier == none) ) { \
*value = env->NewObject(_type_##Class,_type_##InitMID,data); \
} else if (isOut && (modifier == array)) { \
*value = env->NewObjectArray(1, _type_##ArrayClass, NULL); \
} else if (isOut \
|| (modifier == array)) { \
int arraySize; \
arraySize = (modifier == array) ? ind : 1; \
*value = env->New##_Type_##Array(arraySize); \
} \
if (modifier == arrayElement \
|| (isOut && (modifier == none)) \
) { \
indexInArray = (modifier == arrayElement) ? ind : 0; \
env->Set##_Type_##ArrayRegion((j##_type_##Array)*value, indexInArray, 1, &data); \
} \
} while(0)
nsresult
bcJavaMarshalToolkit::UnMarshalElement(jobject *value, uint8 ind, bcIUnMarshaler *um, int isOut, nsXPTParamInfo * param,
bcXPType type, bcIAllocator *allocator, ArrayModifier modifier) {
switch(type) {
case bc_T_I8:
case bc_T_U8:
{
UNMARSHAL_SIMPLE_ELEMENT(byte,Byte);
break;
}
case bc_T_I16:
case bc_T_U16:
{
UNMARSHAL_SIMPLE_ELEMENT(short,Short);
break;
};
case bc_T_I32:
case bc_T_U32:
{
UNMARSHAL_SIMPLE_ELEMENT(int,Int);
break;
}
case bc_T_I64:
case bc_T_U64:
{
UNMARSHAL_SIMPLE_ELEMENT(long,Long);
break;
}
case bc_T_FLOAT:
{
UNMARSHAL_SIMPLE_ELEMENT(float,Float);
break;
}
case bc_T_DOUBLE:
{
UNMARSHAL_SIMPLE_ELEMENT(double,Double);
break;
}
case bc_T_BOOL:
{
UNMARSHAL_SIMPLE_ELEMENT(boolean,Boolean);
break;
}
case bc_T_CHAR:
case bc_T_WCHAR:
{
UNMARSHAL_SIMPLE_ELEMENT(char,Char);
break;
}
case bc_T_CHAR_STR:
case bc_T_WCHAR_STR: //nb not sure about this
{
int indexInArray;
size_t size;
jstring data = NULL;
if (um) {
um->ReadString(&data,&size,allocator);
data = env->NewStringUTF((const char*)data);
}
if ( ! isOut
&& (modifier == none) ) {
*value = data;
} else if (isOut && (modifier == array)) {
*value = env->NewObjectArray(1, stringArrayClass, NULL);
} else if (isOut
|| (modifier == array)) {
int arraySize;
arraySize = (modifier == array) ? ind : 1;
*value = env->NewObjectArray(arraySize,stringClass,NULL);
}
if (modifier == arrayElement
|| (isOut && (modifier == none))
) {
indexInArray = (modifier == arrayElement) ? ind : 0;
env->SetObjectArrayElement((jobjectArray)*value, indexInArray, data);
}
break;
}
case bc_T_IID:
{
int indexInArray = 0;
jobject data = NULL;
if (um) {
nsIID iid;
um->ReadSimple(&iid,type);
data = bcIIDJava::GetObject(&iid);
}
if ( ! isOut
&& (modifier == none) ) {
*value = data;
} else if (isOut && (modifier == array)) {
*value = env->NewObjectArray(1, iidArrayClass, NULL);
} else if (isOut
|| (modifier == array)) {
int arraySize;
arraySize = (modifier == array) ? ind : 1;
*value = env->NewObjectArray(arraySize,iidClass,NULL);
}
if (modifier == arrayElement
|| (isOut && (modifier == none))
) {
indexInArray = (modifier == arrayElement) ? ind : 0;
env->SetObjectArrayElement((jobjectArray)*value, indexInArray, data);
}
break;
}
case bc_T_INTERFACE:
{
printf("--[c++] bcJavaMarshalToolkit::UnMarshalElement we have an interface\n");
int indexInArray = 0;
jobject data = NULL;
bcOID oid = 0;
nsIID iid;
nsresult r;
jclass clazz = objectClass;
if (um) {
um->ReadSimple(&oid,type);
um->ReadSimple(&iid,bc_T_IID);
printf("%d oid\n",(int) oid);
NS_WITH_SERVICE(bcJavaStubsAndProxies, javaStubsAndProxies, kJavaStubsAndProxies, &r);
if (NS_FAILED(r)) {
return NS_ERROR_FAILURE;
}
if (oid != 0) {
javaStubsAndProxies->GetProxy(oid, iid, orb, &data);
}
javaStubsAndProxies->GetInterface(iid,&clazz);
}
if ( ! isOut
&& (modifier == none) ) {
*value = data;
} else if (isOut && (modifier == array)) { //how to create type[][] ?
jobject arrayObject;
arrayObject = env->NewObjectArray(1,clazz,NULL);
jclass arrayClass = (jclass) env->CallObjectMethod(arrayObject,getClassMID); //nb how to to it better ?
*value = env->NewObjectArray(1, arrayClass, NULL);
} else if (isOut
|| (modifier == array)) {
int arraySize;
arraySize = (modifier == array) ? ind : 1;
*value = env->NewObjectArray(arraySize,clazz,NULL);
}
if (modifier == arrayElement
|| (isOut && (modifier == none))
) {
indexInArray = (modifier == arrayElement) ? ind : 0;
env->SetObjectArrayElement((jobjectArray)*value, indexInArray, data);
}
break;
}
case bc_T_ARRAY:
{
nsXPTType datumType;
if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) {
return NS_ERROR_FAILURE;
}
bcXPType type = XPTType2bcXPType(datumType.TagPart());
if (isOut) {
UnMarshalElement(value,ind,NULL,isOut,param,type,allocator,array);
}
if (um != NULL) {
PRUint32 arraySize;
um->ReadSimple(&arraySize,bc_T_U32);
jobject arrayValue = NULL;
UnMarshalElement(&arrayValue,arraySize,NULL,0,param,type,allocator,array);
if (isOut) {
env->SetObjectArrayElement((jobjectArray)*value,0,arrayValue);
} else {
*value = arrayValue;
}
for (PRUint32 i = 0; i < arraySize; i++) {
UnMarshalElement(&arrayValue,i,um,0,param,type,allocator,arrayElement);
}
}
break;
}
default:
;
}
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
return NS_ERROR_FAILURE;
}
return NS_OK;
}
bcXPType bcJavaMarshalToolkit::XPTType2bcXPType(uint8 type) {
switch(type) {
case nsXPTType::T_I8 :
return bc_T_I8;
case nsXPTType::T_U8 :
return bc_T_U8;
case nsXPTType::T_I16 :
return bc_T_I16;
case nsXPTType::T_U16 :
return bc_T_U16;
case nsXPTType::T_I32 :
return bc_T_I32;
case nsXPTType::T_U32 :
return bc_T_U32;
case nsXPTType::T_I64 :
return bc_T_I64;
case nsXPTType::T_U64 :
return bc_T_U64;
case nsXPTType::T_FLOAT :
return bc_T_FLOAT;
case nsXPTType::T_DOUBLE :
return bc_T_DOUBLE;
case nsXPTType::T_BOOL :
return bc_T_BOOL;
case nsXPTType::T_CHAR :
return bc_T_CHAR;
case nsXPTType::T_WCHAR :
return bc_T_WCHAR;
case nsXPTType::T_IID :
return bc_T_IID;
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_PSTRING_SIZE_IS:
return bc_T_CHAR_STR;
case nsXPTType::T_WCHAR_STR :
case nsXPTType::T_PWSTRING_SIZE_IS:
return bc_T_WCHAR_STR;
case nsXPTType::T_INTERFACE :
case nsXPTType::T_INTERFACE_IS :
return bc_T_INTERFACE;
case nsXPTType::T_ARRAY:
return bc_T_ARRAY;
default:
return bc_T_UNDEFINED;
case nsXPTType::T_I8 :
return bc_T_I8;
case nsXPTType::T_U8 :
return bc_T_U8;
case nsXPTType::T_I16 :
return bc_T_I16;
case nsXPTType::T_U16 :
return bc_T_U16;
case nsXPTType::T_I32 :
return bc_T_I32;
case nsXPTType::T_U32 :
return bc_T_U32;
case nsXPTType::T_I64 :
return bc_T_I64;
case nsXPTType::T_U64 :
return bc_T_U64;
case nsXPTType::T_FLOAT :
return bc_T_FLOAT;
case nsXPTType::T_DOUBLE :
return bc_T_DOUBLE;
case nsXPTType::T_BOOL :
return bc_T_BOOL;
case nsXPTType::T_CHAR :
return bc_T_CHAR;
case nsXPTType::T_WCHAR :
return bc_T_WCHAR;
case nsXPTType::T_IID :
return bc_T_IID;
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_PSTRING_SIZE_IS:
return bc_T_CHAR_STR;
case nsXPTType::T_WCHAR_STR :
case nsXPTType::T_PWSTRING_SIZE_IS:
return bc_T_WCHAR_STR;
case nsXPTType::T_INTERFACE :
case nsXPTType::T_INTERFACE_IS :
return bc_T_INTERFACE;
case nsXPTType::T_ARRAY:
return bc_T_ARRAY;
default:
return bc_T_UNDEFINED;
}
}
//if p == 0 and isOut than return one element array
jobject bcJavaMarshalToolkit::Native2Java(void *p, bcXPType type, int isOut) {
//nb we shoud care about endianes. should we?
printf("--[c++]bcJavaMarshalToolkit::Native2Java \n");
jobject res = NULL;
if (!p
&& !isOut) {
printf("--[c++]bcJavaMarshalToolkit::Native2Java !p && !isOut\n");
return res;
}
switch (type) {
case bc_T_I8:
case bc_T_U8:
if (isOut) {
res = env->NewByteArray(1);
if (p) {
env->SetByteArrayRegion((jbyteArray)res,0,1,(jbyte*)p);
}
} else {
res = env->NewObject(byteClass,byteInitMID,*(jbyte*)p);
}
break;
case bc_T_I16:
case bc_T_U16:
if (isOut) {
res = env->NewShortArray(1);
if (p) {
env->SetShortArrayRegion((jshortArray)res,0,1,(jshort*)p);
}
} else {
res = env->NewObject(shortClass,shortInitMID,*(jshort*)p);
}
break;
case bc_T_I32:
case bc_T_U32:
if (isOut) {
res = env->NewIntArray(1);
if (p) {
env->SetIntArrayRegion((jintArray)res,0,1,(jint*)p);
}
} else {
res = env->NewObject(integerClass,integerInitMID,*(jint*)p);
printf("--bcJavaMarshalToolkit::Native2Java we'v got i32\n");
}
break;
case bc_T_I64:
case bc_T_U64:
if (isOut) {
res = env->NewLongArray(1);
if (p) {
env->SetLongArrayRegion((jlongArray)res,0,1,(jlong*)p);
}
} else {
res = env->NewObject(longClass,longInitMID,*(jlong*)p);
}
break;
case bc_T_FLOAT:
if (isOut) {
res = env->NewFloatArray(1);
if (p) {
env->SetFloatArrayRegion((jfloatArray)res,0,1,(jfloat*)p);
}
} else {
res = env->NewObject(floatClass,floatInitMID,*(jfloat*)p);
}
break;
case bc_T_DOUBLE:
if (isOut) {
res = env->NewDoubleArray(1);
if (p) {
env->SetDoubleArrayRegion((jdoubleArray)res,0,1,(jdouble*)p);
}
} else {
res = env->NewObject(doubleClass,doubleInitMID,*(jdouble*)p);
}
break;
case bc_T_BOOL:
if (isOut) {
res = env->NewBooleanArray(1);
if (p) {
env->SetBooleanArrayRegion((jbooleanArray)res,0,1,(jboolean*)p);
}
} else {
res = env->NewObject(booleanClass,booleanInitMID,*(jboolean*)p);
}
break;
case bc_T_CHAR:
case bc_T_WCHAR:
if (isOut) {
res = env->NewCharArray(1);
if (p) {
env->SetCharArrayRegion((jcharArray)res,0,1,(jchar*)p);
}
} else {
res = env->NewObject(characterClass,characterInitMID,*(jchar*)p);
}
break;
case bc_T_CHAR_STR:
case bc_T_WCHAR_STR: //nb not sure about this
{
jstring str = NULL;
if (p) {
str = env->NewStringUTF((const char*)p);
}
if (isOut) {
res = env->NewObjectArray(1,stringClass,NULL);
if (str) {
env->SetObjectArrayElement((jobjectArray)res,0,str);
}
} else {
res = str;
}
break;
}
case bc_T_IID:
{
jobject iid = NULL;
if (p) {
iid = bcIIDJava::GetObject((nsIID*)p);
}
if (isOut) {
res = env->NewObjectArray(1,bcIIDJava::GetClass(),NULL);
env->SetObjectArrayElement((jobjectArray)res,0,iid);
} else {
res = iid;
}
break;
}
case bc_T_INTERFACE:
{
printf("--[c++]bcJavaMarshalToolkit::... we have an Interfaces \n");
jobject obj = NULL;
nsresult r;
nsIID *iid;
bcOID *oid;
jobject proxy;
if (p) {
oid = (bcOID*)((void**)p)[0];
iid = (bcIID*)((void**)p)[1];
NS_WITH_SERVICE(bcJavaStubsAndProxies, javaStubsAndProxies, kJavaStubsAndProxies, &r);
if (NS_FAILED(r)) {
return NULL;
}
javaStubsAndProxies->GetProxy(*oid, *iid, orb, &proxy);
}
if (isOut) { //nb to do
/*
res = env->NewObjectArray(1,bcIIDJava::GetClass(),NULL);
env->SetObjectArrayElement((jobjectArray)res,0,proxy);
*/
} else {
res = proxy;
}
break;
}
default:
;
}
return res;
}
void bcJavaMarshalToolkit::InitializeStatic() {
jclass clazz;
if (!(clazz = env->FindClass("java/lang/Object"))
|| !(objectClass = (jclass) env->NewGlobalRef(clazz))) {
return;
|| !(objectClass = (jclass) env->NewGlobalRef(clazz))
) {
return;
}
if (!(clazz = env->FindClass("java/lang/Boolean"))
|| !(booleanClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(booleanClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Boolean;"))
|| !(booleanArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Character"))
|| !(characterClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(charClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Character;"))
|| !(charArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Byte"))
|| !(byteClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(byteClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Byte;"))
|| !(byteArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Short"))
|| !(shortClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(shortClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Short;"))
|| !(shortArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Integer"))
|| !(integerClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(intClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Integer;"))
|| !(intArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Long"))
|| !(longClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(longClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Long;"))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Float"))
|| !(floatClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(floatClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Float;"))
|| !(floatArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("java/lang/Double"))
|| !(doubleClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(doubleClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/Double;"))
|| !(doubleArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
}
return;
}
if (!(clazz = env->FindClass("java/lang/String"))
|| !(stringClass = (jclass) env->NewGlobalRef(clazz))) {
|| !(stringClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Ljava/lang/String;"))
|| !(stringArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
return;
}
if (!(clazz = env->FindClass("org/mozilla/xpcom/IID"))
|| !(iidClass = (jclass) env->NewGlobalRef(clazz))
|| !(clazz = env->FindClass("[Lorg/mozilla/xpcom/IID;"))
|| !(iidArrayClass = (jclass) env->NewGlobalRef(clazz))
) {
DeInitializeStatic();
return;
}
if (!(booleanInitMID = env->GetMethodID(booleanClass,"<init>","(Z)V"))) {
DeInitializeStatic();
return;
@@ -464,11 +711,11 @@ void bcJavaMarshalToolkit::InitializeStatic() {
return;
}
if (!(characterInitMID = env->GetMethodID(characterClass,"<init>","(C)V"))) {
if (!(charInitMID = env->GetMethodID(charClass,"<init>","(C)V"))) {
DeInitializeStatic();
return;
}
if (!(characterValueMID = env->GetMethodID(characterClass,"charValue","()C"))) {
if (!(charValueMID = env->GetMethodID(charClass,"charValue","()C"))) {
DeInitializeStatic();
return;
}
@@ -490,11 +737,11 @@ void bcJavaMarshalToolkit::InitializeStatic() {
return;
}
if (!(integerInitMID = env->GetMethodID(integerClass,"<init>","(I)V"))) {
if (!(intInitMID = env->GetMethodID(intClass,"<init>","(I)V"))) {
DeInitializeStatic();
return;
}
if (!(integerValueMID = env->GetMethodID(integerClass,"intValue","()I"))) {
if (!(intValueMID = env->GetMethodID(intClass,"intValue","()I"))) {
DeInitializeStatic();
return;
}
@@ -507,7 +754,7 @@ void bcJavaMarshalToolkit::InitializeStatic() {
DeInitializeStatic();
return;
}
if (!(floatInitMID = env->GetMethodID(floatClass,"<init>","(F)V"))) {
DeInitializeStatic();
return;
@@ -526,11 +773,15 @@ void bcJavaMarshalToolkit::InitializeStatic() {
return;
}
if (!(getClassMID = env->GetMethodID(objectClass,"getClass","()Ljava/lang/Class;"))) {
DeInitializeStatic();
return;
}
}
void bcJavaMarshalToolkit::DeInitializeStatic() { //nb need to do
printf("--[c++]void bcJavaMarshalToolkit::DeInitializeStatic() - boomer \n");
}

45
mozilla/java/xpcom/java/src/bcJavaMarshalToolkit.h
View File

@@ -40,6 +40,9 @@ public:
nsresult Marshal(bcIMarshaler *);
nsresult UnMarshal(bcIUnMarshaler *);
private:
enum ArrayModifier { none, arrayElement, array};
enum { unDefined, onServer, onClient } callSide;
JNIEnv *env;
PRUint16 methodIndex;
@@ -49,38 +52,64 @@ private:
jobjectArray args;
static jclass objectClass;
static jclass objectArrayClass;
static jclass booleanClass;
static jclass booleanArrayClass;
static jmethodID booleanInitMID;
static jmethodID booleanValueMID;
static jclass characterClass;
static jmethodID characterInitMID;
static jmethodID characterValueMID;
static jclass charClass;
static jclass charArrayClass;
static jmethodID charInitMID;
static jmethodID charValueMID;
static jclass byteClass;
static jclass byteArrayClass;
static jmethodID byteInitMID;
static jmethodID byteValueMID;
static jclass shortClass;
static jclass shortArrayClass;
static jmethodID shortInitMID;
static jmethodID shortValueMID;
static jclass integerClass;
static jmethodID integerInitMID;
static jmethodID integerValueMID;
static jclass intClass;
static jclass intArrayClass;
static jmethodID intInitMID;
static jmethodID intValueMID;
static jclass longClass;
static jclass longArrayClass;
static jmethodID longInitMID;
static jmethodID longValueMID;
static jclass floatClass;
static jclass floatArrayClass;
static jmethodID floatInitMID;
static jmethodID floatValueMID;
static jclass doubleClass;
static jclass doubleArrayClass;
static jmethodID doubleInitMID;
static jmethodID doubleValueMID;
static jclass stringClass;
static jclass stringArrayClass;
static jclass iidClass;
static jclass iidArrayClass;
static jmethodID getClassMID;
void InitializeStatic();
void DeInitializeStatic();
bcXPType XPTType2bcXPType(uint8 type);
jobject Native2Java(void *,bcXPType type,int isOut = 0);
// nsresult MarshalElement(bcIMarshaler *m, jobject array, nsXPTParamInfo * param, bcXPType type,
// uint8 ind, ArrayModifier modifier = none);
nsresult
MarshalElement(bcIMarshaler *m, jobject value, PRBool isOut, nsXPTParamInfo * param,
bcXPType type, uint8 ind, ArrayModifier modifier = none);
nsresult
UnMarshalElement(jobject *value, uint8 ind, bcIUnMarshaler *um, PRBool isOut , nsXPTParamInfo * param,
bcXPType type, bcIAllocator *allocator, ArrayModifier modifier = none);
};
#endif

6
mozilla/java/xpcom/java/src/bcJavaStub.cpp
View File

@@ -57,7 +57,7 @@ void bcJavaStub::Dispatch(bcICall *call) {
call->GetParams(&iid, &oid, &mid);
nsIInterfaceInfo *interfaceInfo;
nsIInterfaceInfoManager* iimgr;
if(iimgr = XPTI_GetInterfaceInfoManager()) {
if((iimgr = XPTI_GetInterfaceInfoManager()) != NULL) {
if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) {
return; //nb exception handling
}
@@ -81,8 +81,10 @@ void bcJavaStub::Dispatch(bcICall *call) {
jobject jiid = bcIIDJava::GetObject(&iid);
bcJavaGlobal::GetJNIEnv()->CallStaticObjectMethod(utilitiesClass, callMethodByIndexMID, object, jiid, (jint)mid, args);
//nb return value; excepion handling
bcIMarshaler * m = call->GetMarshaler(); //nb ** to do
bcIMarshaler * m = call->GetMarshaler();
mt->Marshal(m);
//nb memory deallocation
delete m; delete um; delete mt;
return;
}

71
mozilla/java/xpcom/java/src/bcJavaStubsAndProxies.cpp
View File

@@ -32,6 +32,7 @@ jmethodID bcJavaStubsAndProxies::loadComponentID = 0;
jclass bcJavaStubsAndProxies::proxyFactory = 0;
jmethodID bcJavaStubsAndProxies::getProxyID = 0;
jmethodID bcJavaStubsAndProxies::getInterfaceID = 0;
NS_DEFINE_CID(kORBCIID,BC_ORB_CID);
NS_GENERIC_FACTORY_CONSTRUCTOR(bcJavaStubsAndProxies);
@@ -60,7 +61,7 @@ bcJavaStubsAndProxies::~bcJavaStubsAndProxies() {
NS_IMETHODIMP bcJavaStubsAndProxies::GetStub(jobject obj, bcIStub **stub) {
if (!stub) {
return NS_ERROR_NULL_POINTER;
return NS_ERROR_NULL_POINTER;
}
*stub = new bcJavaStub(obj);
return NS_OK;
@@ -69,7 +70,7 @@ NS_IMETHODIMP bcJavaStubsAndProxies::GetStub(jobject obj, bcIStub **stub) {
NS_IMETHODIMP bcJavaStubsAndProxies::GetProxy(bcOID oid, const nsIID &iid, bcIORB *orb, jobject *proxy) {
printf("--[c++] bcJavaStubsAndProxies::GetProxy\n");
if (!componentLoader) {
Init();
Init();
}
JNIEnv * env = bcJavaGlobal::GetJNIEnv();
@@ -78,6 +79,23 @@ NS_IMETHODIMP bcJavaStubsAndProxies::GetProxy(bcOID oid, const nsIID &iid, bcIOR
return NS_OK;
}
NS_IMETHODIMP bcJavaStubsAndProxies::GetInterface(const nsIID &iid, jclass *clazz) {
printf("--[c++] bcJavaStubsAndProxies::GetInterface\n");
if (!componentLoader) {
Init();
}
JNIEnv * env = bcJavaGlobal::GetJNIEnv();
jobject jiid = bcIIDJava::GetObject((nsIID*)&iid);
*clazz = (jclass)env->CallStaticObjectMethod(proxyFactory,getInterfaceID, jiid);
return NS_OK;
}
NS_IMETHODIMP bcJavaStubsAndProxies::GetOID(jobject object, bcIORB *orb, bcOID *oid) {
bcIStub *stub = new bcJavaStub(object);
*oid = orb->RegisterStub(stub);
return NS_OK;
}
NS_IMETHODIMP bcJavaStubsAndProxies::GetOID(char *location, bcOID *oid) {
printf("--bcJavaStubsAndProxies::GetOID %s\n",location);
@@ -85,7 +103,7 @@ NS_IMETHODIMP bcJavaStubsAndProxies::GetOID(char *location, bcOID *oid) {
nsresult result;
if (!componentLoader) {
Init();
Init();
}
//location[strlen(location)-5] = 0; //nb dirty hack. location is xyz.jar.info
strcpy(location + strlen(location)-4,"comp");
@@ -94,8 +112,8 @@ NS_IMETHODIMP bcJavaStubsAndProxies::GetOID(char *location, bcOID *oid) {
bcIStub *stub = new bcJavaStub(object);
NS_WITH_SERVICE(bcORB,_orb,kORBCIID,&result);
if (NS_FAILED(result)) {
printf("--bcJavaStubsAndProxies::GetOID failed\n");
return result;
printf("--bcJavaStubsAndProxies::GetOID failed\n");
return result;
}
bcIORB *orb;
_orb->GetORB(&orb);
@@ -108,40 +126,47 @@ void bcJavaStubsAndProxies::Init(void) {
JNIEnv * env = bcJavaGlobal::GetJNIEnv();
componentLoader = env->FindClass("org/mozilla/xpcom/ComponentLoader");
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
componentLoader = (jclass)env->NewGlobalRef(componentLoader);
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
loadComponentID = env->GetStaticMethodID(componentLoader,"loadComponent","(Ljava/lang/String;)Ljava/lang/Object;");
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
proxyFactory = env->FindClass("org/mozilla/xpcom/ProxyFactory");
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
proxyFactory = (jclass)env->NewGlobalRef(proxyFactory);
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
getProxyID = env->GetStaticMethodID(proxyFactory, "getProxy","(JLorg/mozilla/xpcom/IID;J)Ljava/lang/Object;");
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
env->ExceptionDescribe();
componentLoader = 0;
return;
}
getInterfaceID = env->GetStaticMethodID(proxyFactory, "getInterface","(Lorg/mozilla/xpcom/IID;)Ljava/lang/Class;");
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
componentLoader = 0;
return;
}
}

3
mozilla/java/xpcom/java/src/bcJavaStubsAndProxies.h
View File

@@ -45,7 +45,9 @@ class bcJavaStubsAndProxies : public nsISupports {
NS_DEFINE_STATIC_IID_ACCESSOR(BC_JAVASTUBSANDPROXIES_IID)
NS_IMETHOD GetStub(jobject obj, bcIStub **stub);
NS_IMETHOD GetOID(char *location, bcOID *); //load component by location
NS_IMETHOD GetOID(jobject object, bcIORB *orb, bcOID *oid);
NS_IMETHOD GetProxy(bcOID oid, const nsIID &iid, bcIORB *orb, jobject *proxy);
NS_IMETHOD GetInterface(const nsIID &iid, jclass *clazz);
bcJavaStubsAndProxies();
virtual ~bcJavaStubsAndProxies();
protected:
@@ -54,6 +56,7 @@ class bcJavaStubsAndProxies : public nsISupports {
static jmethodID loadComponentID;
static jclass proxyFactory;
static jmethodID getProxyID;
static jmethodID getInterfaceID;
};
#endif /* __bcJavaStubsAndProxies_h */

28
mozilla/java/xpcom/java/src/org_mozilla_xpcom_Utilities.cpp
View File

@@ -24,7 +24,10 @@
#include "bcIORB.h"
#include "bcICall.h"
#include "bcDefs.h"
#include "xptcall.h"
#include "nsIInterfaceInfo.h"
#include "nsIInterfaceInfoManager.h"
#include "bcJavaMarshalToolkit.h"
/*
* Class: org_mozilla_xpcom_Utilities
@@ -33,17 +36,36 @@
*/
JNIEXPORT jobject JNICALL Java_org_mozilla_xpcom_Utilities_callMethodByIndex
(JNIEnv *env, jclass clazz, jlong _oid, jint mid, jstring jiid, jlong _orb, jobjectArray) {
(JNIEnv *env, jclass clazz, jlong _oid, jint mid, jstring jiid, jlong _orb, jobjectArray args) {
bcIORB * orb = (bcIORB*) _orb;
bcOID oid = (bcOID)_oid;
nsIID iid;
printf("--[c++] jni %d\n",(int)mid);
printf("--[c++] jni Java_org_mozilla_xpcom_Utilities_callMethodByIndex %d\n",(int)mid);
const char * str = NULL;
str = env->GetStringUTFChars(jiid,NULL);
iid.Parse(str);
env->ReleaseStringUTFChars(jiid,str);
bcICall *call = orb->CreateCall(&iid, &oid, mid);
/*****/
nsIInterfaceInfo *interfaceInfo;
nsIInterfaceInfoManager* iimgr;
if( (iimgr = XPTI_GetInterfaceInfoManager()) != NULL) {
if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) {
return NULL; //nb exception handling
}
NS_RELEASE(iimgr);
} else {
return NULL;
}
/*****/
bcIMarshaler * m = call->GetMarshaler();
bcJavaMarshalToolkit * mt = new bcJavaMarshalToolkit(mid, interfaceInfo, args, env, 0, orb);
mt->Marshal(m);
orb->SendReceive(call);
bcIUnMarshaler * um = call->GetUnMarshaler();
mt->UnMarshal(um);
delete m; delete um; delete mt;
return NULL;
}