mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-08 12:37:37 +00:00
315 lines
7.3 KiB
C++
315 lines
7.3 KiB
C++
/*
|
|
* The contents of this file are subject to the Mozilla Public License
|
|
* Version 1.0 (the "License"); you may not use this file except
|
|
* in compliance with the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
|
|
* the specific language governing rights and limitations under the License.
|
|
*
|
|
* Contributors:
|
|
* Frank Mitchell (frank.mitchell@sun.com)
|
|
*/
|
|
#include <iostream.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include "nscore.h"
|
|
#include "nsIFactory.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsIInterfaceInfo.h"
|
|
#include "nsIInterfaceInfoManager.h"
|
|
#include "xptinfo.h"
|
|
#include "xptcall.h"
|
|
#include "xpt_struct.h"
|
|
#include "nsIAllocator.h"
|
|
#include "JSISample.h"
|
|
#include "JSSample.h"
|
|
|
|
#include "nsSpecialSystemDirectory.h"
|
|
|
|
#include "xpjava.h"
|
|
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
static NS_DEFINE_IID(kISampleIID, JSISAMPLE_IID);
|
|
static NS_DEFINE_CID(kSampleCID, JS_SAMPLE_CID);
|
|
|
|
static NS_DEFINE_IID(kAllocatorCID, NS_ALLOCATOR_CID);
|
|
|
|
#ifdef XP_PC
|
|
#define XPCOM_DLL "xpcom32.dll"
|
|
#define SAMPLE_DLL "sampl32.dll"
|
|
#else
|
|
#ifdef XP_MAC
|
|
#define XPCOM_DLL "XPCOM_DLL"
|
|
#define SAMPLE_DLL "SAMPL_DLL"
|
|
#else
|
|
#define XPCOM_DLL "libxpcom.so"
|
|
#define SAMPLE_DLL "libsample.so"
|
|
#endif
|
|
#endif
|
|
|
|
|
|
nsXPTCVariant *ParamsFromArgv(const nsXPTMethodInfo *mi,
|
|
int argi, int argc, char **argv) {
|
|
uint8 paramcount = mi->GetParamCount();
|
|
|
|
nsXPTCVariant *result = new nsXPTCVariant[paramcount];
|
|
|
|
for (int i = 0; i < paramcount; i++) {
|
|
nsXPTParamInfo param = mi->GetParam(i);
|
|
|
|
result[i].ptr = 0;
|
|
result[i].type = param.GetType().TagPart();
|
|
result[i].flags = 0;
|
|
|
|
if (param.IsIn()) {
|
|
assert(argi < argc);
|
|
|
|
cerr << "Consuming " << argv[argi] << endl;
|
|
|
|
switch(result[i].type) {
|
|
case nsXPTType::T_I8:
|
|
result[i].val.i8 = atoi(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_I16:
|
|
result[i].val.i16 = atoi(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_I32:
|
|
result[i].val.i32 = atol(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_I64:
|
|
result[i].val.i64 = atol(argv[argi]); //s.b. conversion to long long
|
|
break;
|
|
case nsXPTType::T_U8:
|
|
result[i].val.u8 = atoi(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_U16:
|
|
result[i].val.u16 = atoi(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_U32:
|
|
result[i].val.u32 = atol(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_U64:
|
|
result[i].val.u64 = atol(argv[argi]); //s.b. conversion to long long
|
|
break;
|
|
case nsXPTType::T_FLOAT:
|
|
result[i].val.f = atof(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_DOUBLE:
|
|
result[i].val.d = atof(argv[argi]);
|
|
break;
|
|
case nsXPTType::T_BOOL:
|
|
switch (argv[argi][0]) {
|
|
case '1':
|
|
case 't':
|
|
case 'T':
|
|
result[i].val.b = 1;
|
|
break;
|
|
default:
|
|
result[i].val.b = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case nsXPTType::T_CHAR:
|
|
result[i].val.c = argv[argi][0];
|
|
break;
|
|
case nsXPTType::T_WCHAR:
|
|
result[i].val.wc = argv[argi][0]; // PENDING: not wide
|
|
break;
|
|
case nsXPTType::T_CHAR_STR:
|
|
result[i].val.p = argv[argi];
|
|
#if 0
|
|
// Copying every time would be wasteful
|
|
if (param.IsOut()) {
|
|
char *tmpstr = new char[strlen(argv[argi]) + 1];
|
|
strcpy(tmpstr, argv[argi]);
|
|
result[i].val.p = tmpstr;
|
|
result[i].flags |= nsXPTCVariant::VAL_IS_OWNED;
|
|
}
|
|
#endif
|
|
break;
|
|
case nsXPTType::T_VOID:
|
|
case nsXPTType::T_IID:
|
|
case nsXPTType::T_BSTR:
|
|
case nsXPTType::T_WCHAR_STR:
|
|
case nsXPTType::T_INTERFACE:
|
|
case nsXPTType::T_INTERFACE_IS:
|
|
// Ignore for now
|
|
break;
|
|
}
|
|
// VAL_IS_OWNED: val.p holds alloc'd ptr that must be freed
|
|
// VAL_IS_IFACE: val.p holds interface ptr that must be released
|
|
|
|
argi++;
|
|
}
|
|
|
|
if (param.IsOut()) {
|
|
// PTR_IS_DATA: ptr points to 'real' data in val
|
|
result[i].flags |= nsXPTCVariant::PTR_IS_DATA;
|
|
|
|
switch(result[i].type) {
|
|
case nsXPTType::T_I8:
|
|
result[i].ptr = &result[i].val.i8;
|
|
break;
|
|
case nsXPTType::T_I16:
|
|
result[i].ptr = &result[i].val.i16;
|
|
break;
|
|
case nsXPTType::T_I32:
|
|
result[i].ptr = &result[i].val.i32;
|
|
break;
|
|
case nsXPTType::T_I64:
|
|
result[i].ptr = &result[i].val.i64;
|
|
break;
|
|
case nsXPTType::T_U8:
|
|
result[i].ptr = &result[i].val.u8;
|
|
break;
|
|
case nsXPTType::T_U16:
|
|
result[i].ptr = &result[i].val.u16;
|
|
break;
|
|
case nsXPTType::T_U32:
|
|
result[i].ptr = &result[i].val.u32;
|
|
break;
|
|
case nsXPTType::T_U64:
|
|
result[i].ptr = &result[i].val.u64;
|
|
break;
|
|
case nsXPTType::T_FLOAT:
|
|
result[i].ptr = &result[i].val.f;
|
|
break;
|
|
case nsXPTType::T_DOUBLE:
|
|
result[i].ptr = &result[i].val.d;
|
|
break;
|
|
case nsXPTType::T_BOOL:
|
|
result[i].ptr = &result[i].val.b;
|
|
break;
|
|
case nsXPTType::T_CHAR:
|
|
result[i].ptr = &result[i].val.c;
|
|
break;
|
|
case nsXPTType::T_WCHAR:
|
|
result[i].ptr = &result[i].val.wc;
|
|
break;
|
|
default:
|
|
result[i].ptr = &result[i].val.p;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
JSISample *sample;
|
|
nsresult res;
|
|
char *commandName;
|
|
|
|
cout << "Starting ..." << endl;
|
|
|
|
// Get options
|
|
|
|
// Get command vector
|
|
if (argc > 1) {
|
|
commandName = argv[1];
|
|
}
|
|
else {
|
|
commandName = "PrintStats";
|
|
}
|
|
|
|
// Initialize XPCOM
|
|
InitXPCOM();
|
|
|
|
// Register Factory
|
|
cerr << "Registering Sample Factory" << endl;
|
|
|
|
res = nsComponentManager::RegisterComponent(kSampleCID,
|
|
"JSSample",
|
|
"component://javasoft/sample",
|
|
SAMPLE_DLL,
|
|
PR_FALSE,
|
|
PR_FALSE);
|
|
|
|
if (NS_FAILED(res)) {
|
|
cerr << "Failed to register factory" << endl;
|
|
return res;
|
|
}
|
|
|
|
// Create Instance
|
|
res = nsComponentManager::CreateInstance(kSampleCID,
|
|
nsnull,
|
|
kISampleIID,
|
|
(void **) &sample);
|
|
|
|
if (NS_FAILED(res)) {
|
|
cerr << "Failed to create instance" << endl;
|
|
return 1;
|
|
}
|
|
|
|
// Get info
|
|
int index;
|
|
const nsXPTMethodInfo *mi;
|
|
|
|
res = GetMethodInfoByName(&kISampleIID, commandName, PR_FALSE,
|
|
&mi, &index);
|
|
|
|
if (NS_FAILED(res)) {
|
|
cerr << "Failed to find " << commandName << endl;
|
|
return 1;
|
|
}
|
|
|
|
uint8 paramcount = mi->GetParamCount();
|
|
|
|
cerr << mi->GetName()
|
|
<< ":" << endl;
|
|
|
|
for (int i = 0; i < paramcount; i++) {
|
|
nsXPTParamInfo param = mi->GetParam(i);
|
|
nsXPTType type = param.GetType();
|
|
|
|
cerr << '\t' << i << ": "
|
|
<< " type = " << (int)type.TagPart()
|
|
<< (type.IsUniquePointer() ? " UNIQUE" : "")
|
|
<< (type.IsReference() ? " REF" : "")
|
|
<< (type.IsPointer() ? " POINTER" : "")
|
|
<< (param.IsIn() ? ", in" : "")
|
|
<< (param.IsOut() ? ", out" : "")
|
|
<< (param.IsRetval() ? ", retval" : "")
|
|
<< (param.IsShared() ? ", shared" : "")
|
|
<< endl;
|
|
}
|
|
|
|
// Translate and marshall arguments
|
|
nsXPTCVariant *params = ParamsFromArgv(mi, 2, argc, argv);
|
|
|
|
cerr << "Arguments are: " << endl;
|
|
|
|
PrintParams(params, paramcount);
|
|
|
|
// Invoke command
|
|
|
|
cerr << "Calling XPTC_InvokeByIndex( " << sample
|
|
<< ", " << (int)index
|
|
<< ", " << (int)paramcount
|
|
<< ", " << params
|
|
<< ")" << endl;
|
|
|
|
res = XPTC_InvokeByIndex(sample,
|
|
(PRUint32)index,
|
|
(PRUint32)paramcount,
|
|
params);
|
|
|
|
// Get result
|
|
|
|
cerr << "Results are: " << endl;
|
|
|
|
PrintParams(params, paramcount);
|
|
|
|
delete [] params;
|
|
|
|
// Release Instance
|
|
NS_RELEASE(sample);
|
|
|
|
return 0;
|
|
}
|