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; }