static PyObject *PyCurrentItem(PyObject *self, PyObject *args)
{
PyObject *obIID = NULL;
if (!PyArg_ParseTuple(args, "|O:CurrentItem", &obIID))
return NULL;
nsIID iid(NS_GET_IID(nsISupports));
if (obIID != NULL && !Py_nsIID::IIDFromPyObject(obIID, &iid))
return NULL;
nsIEnumerator *pI = GetI(self);
if (pI==NULL)
return NULL;
nsISupports *pRet = nsnull;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->CurrentItem(&pRet);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
if (obIID) {
nsISupports *temp;
Py_BEGIN_ALLOW_THREADS;
r = pRet->QueryInterface(iid, (void **)&temp);
pRet->Release();
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) ) {
return PyXPCOM_BuildPyException(r);
}
pRet = temp;
}
return Py_nsISupports::PyObjectFromInterface(pRet, iid, PR_FALSE);
}
static PyObject *DoPyRead_Size(nsIInputStream *pI, PRUint32 n)
{
if (n==(PRUint32)-1) {
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->Available(&n);
Py_END_ALLOW_THREADS;
if (NS_FAILED(r))
return PyXPCOM_BuildPyException(r);
}
if (n==0) { // mozilla will assert if we alloc zero bytes.
return PyBuffer_New(0);
}
char *buf = (char *)nsMemory::Alloc(n);
if (buf==NULL) {
PyErr_NoMemory();
return NULL;
}
nsresult r;
PRUint32 nread;
Py_BEGIN_ALLOW_THREADS;
r = pI->Read(buf, n, &nread);
Py_END_ALLOW_THREADS;
PyObject *rc = NULL;
if ( NS_SUCCEEDED(r) ) {
rc = PyBuffer_New(nread);
if (rc != NULL) {
void *ob_buf;
Py_ssize_t buf_len;
if (PyObject_AsWriteBuffer(rc, &ob_buf, &buf_len) != 0) {
// should never fail - we just created it!
return NULL;
}
if ( (buf_len & 0xFFFFFFFF) != buf_len) {
PyErr_SetString(PyExc_RuntimeError, "Python Buffer length overflows 32-bit in PyObject_AsWriteBuffer");
return NULL;
}
if (buf_len != nread) {
PyErr_SetString(PyExc_RuntimeError, "New buffer isn't the size we created it!");
return NULL;
}
memcpy(ob_buf, buf, nread);
}
} else
PyXPCOM_BuildPyException(r);
nsMemory::Free(buf);
return rc;
}
/* virtual */ PyObject *
Py_nsISupports::getattr(const char *name)
{
if (strcmp(name, "IID")==0)
return Py_nsIID::PyObjectFromIID( m_iid );
// Support for __unicode__ until we get a tp_unicode slot.
if (strcmp(name, "__unicode__")==0) {
nsresult rv;
PRUnichar *val = NULL;
Py_BEGIN_ALLOW_THREADS;
{ // scope to kill pointer while thread-lock released.
nsCOMPtr<nsISupportsString> ss( do_QueryInterface(m_obj, &rv ));
if (NS_SUCCEEDED(rv))
rv = ss->ToString(&val);
} // end-scope
Py_END_ALLOW_THREADS;
PyObject *ret = NS_FAILED(rv) ?
PyXPCOM_BuildPyException(rv) :
PyObject_FromNSString(val);
if (val) nsMemory::Free(val);
return ret;
}
PyXPCOM_TypeObject *this_type = (PyXPCOM_TypeObject *)ob_type;
return Py_FindMethodInChain(&this_type->chain, this, (char *)name);
}
static PyObject *DoPyRead_Buffer(nsIInputStream *pI, PyObject *obBuffer, PRUint32 n)
{
PRUint32 nread;
void *buf;
Py_ssize_t buf_len;
if (PyObject_AsWriteBuffer(obBuffer, &buf, &buf_len) != 0) {
PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "The buffer object does not have a write buffer!");
return NULL;
}
if ( (buf_len & 0xFFFFFFFF) != buf_len) {
PyErr_Clear();
PyErr_SetString(PyExc_RuntimeError, "Python Buffer length overflows 32-bit in PyObject_AsWriteBuffer");
return NULL;
}
if (n==(PRUint32)-1) {
n = buf_len;
} else {
if (n > buf_len) {
NS_WARNING("Warning: PyIInputStream::read() was passed an integer size greater than the size of the passed buffer! Buffer size used.\n");
n = buf_len;
}
}
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->Read((char *)buf, n, &nread);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return PyInt_FromLong(nread);
}
static PyObject *PyGetNameForIID(PyObject *self, PyObject *args)
{
PyObject *obIID = NULL;
if (!PyArg_ParseTuple(args, "O", &obIID))
return NULL;
nsIInterfaceInfoManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIID iid;
if (!Py_nsIID::IIDFromPyObject(obIID, &iid))
return NULL;
char *ret_name = NULL;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetNameForIID(&iid, &ret_name);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
PyObject *ret = PyString_FromString(ret_name);
nsMemory::Free(ret_name);
return ret;
}
static PyObject *PyCreateInstance(PyObject *self, PyObject *args)
{
char *notyet = NULL;
PyObject *obClassID = NULL, *obIID = NULL;
if (!PyArg_ParseTuple(args, "O|zO", &obClassID, ¬yet, &obIID))
return NULL;
if (notyet != NULL) {
PyErr_SetString(PyExc_ValueError, "2nd arg must be none");
return NULL;
}
nsIComponentManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIID classID;
if (!Py_nsIID::IIDFromPyObject(obClassID, &classID))
return NULL;
nsIID iid;
if (obIID==NULL)
iid = NS_GET_IID(nsISupports);
else
if (!Py_nsIID::IIDFromPyObject(obIID, &iid))
return NULL;
nsCOMPtr<nsISupports> pis;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->CreateInstance(classID, NULL, iid, getter_AddRefs(pis));
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
/* Return a type based on the IID (with no extra ref) */
return Py_nsISupports::PyObjectFromInterface(pis, iid, PR_FALSE);
}
static PyObject *PyCreateInstanceByContractID(PyObject *self, PyObject *args)
{
// second arg to CreateInstanceByContractID is a "delegate" - we
// aren't sure of the semantics of this yet and it seems rarely used,
// so we just punt for now.
char *pid, *notyet = NULL;
PyObject *obIID = NULL;
if (!PyArg_ParseTuple(args, "s|zO", &pid, ¬yet, &obIID))
return NULL;
if (notyet != NULL) {
PyErr_SetString(PyExc_ValueError, "2nd arg must be none");
return NULL;
}
nsIComponentManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIID iid;
if (obIID==NULL)
iid = NS_GET_IID(nsISupports);
else
if (!Py_nsIID::IIDFromPyObject(obIID, &iid))
return NULL;
nsCOMPtr<nsISupports> pis;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->CreateInstanceByContractID(pid, NULL, iid, getter_AddRefs(pis));
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
/* Return a type based on the IID (with no extra ref) */
return Py_nsISupports::PyObjectFromInterface(pis, iid, PR_FALSE);
}
static PyObject *PyGetInfoForIID(PyObject *self, PyObject *args)
{
PyObject *obIID = NULL;
if (!PyArg_ParseTuple(args, "O", &obIID))
return NULL;
nsIInterfaceInfoManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIID iid;
if (!Py_nsIID::IIDFromPyObject(obIID, &iid))
return NULL;
nsCOMPtr<nsIInterfaceInfo> pi;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetInfoForIID(&iid, getter_AddRefs(pi));
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
/* Return a type based on the IID (with no extra ref) */
nsIID new_iid = NS_GET_IID(nsIInterfaceInfo);
// Can not auto-wrap the interface info manager as it is critical to
// building the support we need for autowrap.
return Py_nsISupports::PyObjectFromInterface(pi, new_iid, PR_FALSE);
}
static PyObject *PyGetMethodInfoForName(PyObject *self, PyObject *args)
{
char *name;
if (!PyArg_ParseTuple(args, "s:GetMethodInfoForName", &name))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
const nsXPTMethodInfo *pRet;
PRUint16 index;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetMethodInfoForName(name, &index, &pRet);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
PyObject *ret_i = PyObject_FromXPTMethodDescriptor(pRet);
if (ret_i==NULL)
return NULL;
PyObject *real_ret = Py_BuildValue("iO", (int)index, ret_i);
Py_DECREF(ret_i);
return real_ret;
}
static PyObject *PyGetMethodInfo(PyObject *self, PyObject *args)
{
PRUint16 index;
if (!PyArg_ParseTuple(args, "h:GetMethodInfo", &index))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
PRUint16 nmethods;
pI->GetMethodCount(&nmethods);
if (index>=nmethods) {
PyErr_SetString(PyExc_ValueError, "The method index is out of range");
return NULL;
}
const nsXPTMethodInfo *pRet;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetMethodInfo(index, &pRet);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return PyObject_FromXPTMethodDescriptor(pRet);
}
static PyObject *GetAsISupports(PyObject *self, PyObject *args) {
nsIVariant *pI = GetI(self);
if (pI==NULL) return NULL;
if (!PyArg_ParseTuple(args, ":GetAsISupports")) return NULL;
nsCOMPtr<nsISupports> p;
nsresult nr = pI->GetAsISupports(getter_AddRefs(p));
if (NS_FAILED(nr)) return PyXPCOM_BuildPyException(nr);
return Py_nsISupports::PyObjectFromInterface(p, NS_GET_IID(nsISupports));
}
static PyObject *GetAsInterface(PyObject *self, PyObject *args) {
nsIVariant *pI = GetI(self);
if (pI==NULL) return NULL;
if (!PyArg_ParseTuple(args, ":GetAsInterface")) return NULL;
nsCOMPtr<nsISupports> p;
nsIID *iid;
nsresult nr = pI->GetAsInterface(&iid, getter_AddRefs(p));
if (NS_FAILED(nr)) return PyXPCOM_BuildPyException(nr);
PyObject *ret = Py_nsISupports::PyObjectFromInterface(p, *iid);
nsMemory::Free(iid);
return ret;
}
PRBool
Py_nsISupports::InterfaceFromPyISupports(PyObject *ob,
const nsIID &iid,
nsISupports **ppv)
{
nsISupports *pis;
PRBool rc = PR_FALSE;
if ( !Check(ob) )
{
PyErr_Format(PyExc_TypeError, "Objects of type '%s' can not be used as COM objects", ob->ob_type->tp_name);
goto done;
}
nsIID already_iid;
pis = GetI(ob, &already_iid);
if ( !pis )
goto done; /* exception was set by GetI() */
/* note: we don't (yet) explicitly hold a reference to pis */
if (iid.Equals(Py_nsIID_NULL)) {
// a bit of a hack - we are asking for the arbitary interface
// wrapped by this object, not some other specific interface -
// so no QI, just an AddRef();
Py_BEGIN_ALLOW_THREADS
pis->AddRef();
Py_END_ALLOW_THREADS
*ppv = pis;
} else {
// specific interface requested - if it is not already the
// specific interface, QI for it and discard pis.
if (iid.Equals(already_iid)) {
*ppv = pis;
pis->AddRef();
} else {
nsresult r;
Py_BEGIN_ALLOW_THREADS
r = pis->QueryInterface(iid, (void **)ppv);
Py_END_ALLOW_THREADS
if ( NS_FAILED(r) )
{
PyXPCOM_BuildPyException(r);
goto done;
}
/* note: the QI added a ref for the return value */
}
}
rc = PR_TRUE;
done:
return rc;
}
static PyObject *PyGetInfoForParam(PyObject *self, PyObject *args)
{
nsIInterfaceInfo *pii = GetI(self);
if (pii==NULL)
return NULL;
PRUint16 mi, pi;
if (!PyArg_ParseTuple(args, "hh:GetInfoForParam", &mi, &pi))
return NULL;
const nsXPTMethodInfo *pmi;
if (!__GetMethodInfoHelper(pii, mi, pi, &pmi))
return NULL;
const nsXPTParamInfo& param_info = pmi->GetParam((PRUint8)pi);
nsCOMPtr<nsIInterfaceInfo> pnewii;
nsresult n = pii->GetInfoForParam(mi, ¶m_info, getter_AddRefs(pnewii));
if (NS_FAILED(n))
return PyXPCOM_BuildPyException(n);
return Py_nsISupports::PyObjectFromInterface(pnewii, NS_GET_IID(nsIInterfaceInfo));
}
static PyObject *PyIsScriptable(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":IsScriptable"))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
PRBool b_ret;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->IsScriptable(&b_ret);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return PyInt_FromLong(b_ret);
}
static PyObject *PyGetInterfaceIsArgNumberForParam(PyObject *self, PyObject *args)
{
nsIInterfaceInfo *pii = GetI(self);
if (pii==NULL)
return NULL;
PRUint16 mi, pi;
if (!PyArg_ParseTuple(args, "hhh:GetInterfaceIsArgNumberForParam", &mi, &pi))
return NULL;
const nsXPTMethodInfo *pmi;
if (!__GetMethodInfoHelper(pii, mi, pi, &pmi))
return NULL;
PRUint8 ret;
const nsXPTParamInfo& param_info = pmi->GetParam((PRUint8)pi);
nsresult n = pii->GetInterfaceIsArgNumberForParam(mi, ¶m_info, &ret);
if (NS_FAILED(n))
return PyXPCOM_BuildPyException(n);
return PyInt_FromLong(ret);
}
static PyObject *PyGetTypeForParam(PyObject *self, PyObject *args)
{
nsIInterfaceInfo *pii = GetI(self);
if (pii==NULL)
return NULL;
PRUint16 mi, pi, dim;
if (!PyArg_ParseTuple(args, "hhh:GetTypeForParam", &mi, &pi, &dim))
return NULL;
const nsXPTMethodInfo *pmi;
if (!__GetMethodInfoHelper(pii, mi, pi, &pmi))
return NULL;
nsXPTType datumType;
const nsXPTParamInfo& param_info = pmi->GetParam((PRUint8)pi);
nsresult n = pii->GetTypeForParam(mi, ¶m_info, dim, &datumType);
if (NS_FAILED(n))
return PyXPCOM_BuildPyException(n);
return PyObject_FromXPTType(&datumType);
}
static PyObject *PyGetParent(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":GetParent"))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
nsCOMPtr<nsIInterfaceInfo> pRet;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetParent(getter_AddRefs(pRet));
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return Py_nsISupports::PyObjectFromInterface(pRet, NS_GET_IID(nsIInterfaceInfo), PR_FALSE);
}
static PyObject *PyGetConstantCount(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":GetConstantCount"))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
PRUint16 ret;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetConstantCount(&ret);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return PyInt_FromLong(ret);
}
PyObject *
Py_nsIVariant::getattr(const char *name)
{
PyObject *ret = NULL;
if (strcmp(name, "dataType")==0) {
nsIVariant *pI = ::GetI(this);
if (pI) {
PRUint16 dt;
nsresult nr = pI->GetDataType(&dt);
if (NS_FAILED(nr)) return PyXPCOM_BuildPyException(nr);
ret = PyInt_FromLong(dt);
}
} else {
ret = Py_nsISupports::getattr(name);
}
return ret;
}
static PyObject *PyIsDone(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":IsDone"))
return NULL;
nsIEnumerator *pI = GetI(self);
nsresult r;
if (pI==NULL)
return NULL;
Py_BEGIN_ALLOW_THREADS;
r = pI->IsDone();
Py_END_ALLOW_THREADS;
if (NS_FAILED(r))
return PyXPCOM_BuildPyException(r);
PyObject *ret = r==NS_OK ? Py_True : Py_False;
Py_INCREF(ret);
return ret;
}
static PyObject *PyGetConstant(PyObject *self, PyObject *args)
{
PRUint16 index;
if (!PyArg_ParseTuple(args, "h:GetConstant", &index))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
const nsXPTConstant *pRet;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetConstant(index, &pRet);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return PyObject_FromXPTConstant(pRet);
}
static PyObject *PyEnumerateInterfaces(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
nsIInterfaceInfoManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsCOMPtr<nsIEnumerator> pRet;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->EnumerateInterfaces(getter_AddRefs(pRet));
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
return Py_nsISupports::PyObjectFromInterface(pRet, NS_GET_IID(nsIEnumerator));
}
static PyObject *PyGetIIDForParam(PyObject *self, PyObject *args)
{
nsIInterfaceInfo *pii = GetI(self);
if (pii==NULL)
return NULL;
PRUint16 mi, pi;
if (!PyArg_ParseTuple(args, "hh:GetIIDForParam", &mi, &pi))
return NULL;
const nsXPTMethodInfo *pmi;
if (!__GetMethodInfoHelper(pii, mi, pi, &pmi))
return NULL;
const nsXPTParamInfo& param_info = pmi->GetParam((PRUint8)pi);
nsIID *piid;
nsresult n = pii->GetIIDForParam(mi, ¶m_info, &piid);
if (NS_FAILED(n) || piid==nsnull)
return PyXPCOM_BuildPyException(n);
PyObject *rc = Py_nsIID::PyObjectFromIID(*piid);
nsMemory::Free((void*)piid);
return rc;
}
static PyObject *PyGetIID(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":GetIID"))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIID *iid_ret;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetInterfaceIID(&iid_ret);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
PyObject *ret = Py_nsIID::PyObjectFromIID(*iid_ret);
nsMemory::Free(iid_ret);
return ret;
}
// @pymethod <o Py_nsISupports>|Py_nsISupports|QueryInterface|Queries an object for a specific interface.
PyObject *
Py_nsISupports::QueryInterface(PyObject *self, PyObject *args)
{
PyObject *obiid;
int bWrap = 1;
// @pyparm IID|iid||The IID requested.
// @rdesc The result is always a <o Py_nsISupports> object.
// Any error (including E_NOINTERFACE) will generate a <o com_error> exception.
if (!PyArg_ParseTuple(args, "O|i:QueryInterface", &obiid, &bWrap))
return NULL;
nsIID iid;
if (!Py_nsIID::IIDFromPyObject(obiid, &iid))
return NULL;
nsISupports *pMyIS = GetI(self);
if (pMyIS==NULL) return NULL;
// Optimization, If we already wrap the IID, just return
// ourself.
if (!bWrap && iid.Equals(((Py_nsISupports *)self)->m_iid)) {
Py_INCREF(self);
return self;
}
nsCOMPtr<nsISupports> pis;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pMyIS->QueryInterface(iid, getter_AddRefs(pis));
Py_END_ALLOW_THREADS;
/* Note that this failure may include E_NOINTERFACE */
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
/* Return a type based on the IID (with no extra ref) */
return ((Py_nsISupports *)self)->MakeInterfaceResult(pis, iid, (PRBool)bWrap);
}
static PyObject *PyGetInfoForName(PyObject *self, PyObject *args)
{
char *name;
if (!PyArg_ParseTuple(args, "s", &name))
return NULL;
nsIInterfaceInfoManager *pI = GetI(self);
if (pI==NULL)
return NULL;
nsIInterfaceInfo *pi;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetInfoForName(name, &pi);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
/* Return a type based on the IID (with no extra ref) */
// Can not auto-wrap the interface info manager as it is critical to
// building the support we need for autowrap.
return Py_nsISupports::PyObjectFromInterface(pi, NS_GET_IID(nsIInterfaceInfo), PR_FALSE, PR_FALSE);
}
/*static*/ PRBool
Py_nsIID::IIDFromPyObject(PyObject *ob, nsIID *pRet) {
PRBool ok = PR_TRUE;
nsIID iid;
if (ob==NULL) {
PyErr_SetString(PyExc_RuntimeError, "The IID object is invalid!");
return PR_FALSE;
}
if (PyString_Check(ob)) {
ok = iid.Parse(PyString_AsString(ob));
if (!ok) {
PyXPCOM_BuildPyException(NS_ERROR_ILLEGAL_VALUE);
return PR_FALSE;
}
} else if (ob->ob_type == &type) {
iid = ((Py_nsIID *)ob)->m_iid;
} else if (PyInstance_Check(ob)) {
// Get the _iidobj_ attribute
PyObject *use_ob = PyObject_GetAttrString(ob, "_iidobj_");
if (use_ob==NULL) {
PyErr_SetString(PyExc_TypeError, "Only instances with _iidobj_ attributes can be used as IID objects");
return PR_FALSE;
}
if (use_ob->ob_type != &type) {
Py_DECREF(use_ob);
PyErr_SetString(PyExc_TypeError, "instance _iidobj_ attributes must be raw IID object");
return PR_FALSE;
}
iid = ((Py_nsIID *)use_ob)->m_iid;
Py_DECREF(use_ob);
} else {
PyErr_Format(PyExc_TypeError, "Objects of type '%s' can not be converted to an IID", ob->ob_type->tp_name);
ok = PR_FALSE;
}
if (ok) *pRet = iid;
return ok;
}
static PRBool __GetMethodInfoHelper(nsIInterfaceInfo *pii, int mi, int pi, const nsXPTMethodInfo **ppmi)
{
PRUint16 nmethods=0;
pii->GetMethodCount(&nmethods);
if (mi<0 || mi>=nmethods) {
PyErr_SetString(PyExc_ValueError, "The method index is out of range");
return PR_FALSE;
}
const nsXPTMethodInfo *pmi;
nsresult r = pii->GetMethodInfo(mi, &pmi);
if ( NS_FAILED(r) ) {
PyXPCOM_BuildPyException(r);
return PR_FALSE;
}
int nparams=0;
nparams = pmi->GetParamCount();
if (pi<0 || pi>=nparams) {
PyErr_SetString(PyExc_ValueError, "The param index is out of range");
return PR_FALSE;
}
*ppmi = pmi;
return PR_TRUE;
}
static PyObject *PyGetName(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":GetName"))
return NULL;
nsIInterfaceInfo *pI = GetI(self);
if (pI==NULL)
return NULL;
char *name;
nsresult r;
Py_BEGIN_ALLOW_THREADS;
r = pI->GetName(&name);
Py_END_ALLOW_THREADS;
if ( NS_FAILED(r) )
return PyXPCOM_BuildPyException(r);
#if PY_MAJOR_VERSION <= 2
PyObject *ret = PyString_FromString(name);
#else
PyObject *ret = PyUnicode_FromString(name);
#endif
nsMemory::Free(name);
return ret;
}
