PyObject *PyMAPIObject_FromMAPINAMEIDArray(MAPINAMEID **pp, ULONG numEntries) { PyObject *ret = PyList_New(numEntries); if (ret==NULL) return NULL; for (int i=0; (ULONG)i<numEntries; i++) { MAPINAMEID *pLook = pp[i]; PyObject *value, *guid; if (pLook==NULL) { value = Py_None; Py_INCREF(Py_None); guid = Py_None; Py_INCREF(Py_None); } else { value = pLook->ulKind==MNID_STRING ? PyWinObject_FromOLECHAR(pLook->Kind.lpwstrName) : PyInt_FromLong(pLook->Kind.lID); guid = PyWinObject_FromIID(*pLook->lpguid); } PyObject *newItem = PyTuple_New(2); PyTuple_SetItem(newItem, 0, guid); PyTuple_SetItem(newItem, 1, value); PyList_SetItem(ret, i, newItem); } return ret; }
STDMETHODIMP PyGDebugApplication::DebugOutput( /* [in] */ LPCOLESTR pstr) { PY_GATEWAY_METHOD; PyObject *obpstr; obpstr = PyWinObject_FromOLECHAR(pstr); HRESULT hr=InvokeViaPolicy("DebugOutput", NULL, "O", obpstr); Py_XDECREF(obpstr); return hr; }
STDMETHODIMP PyGDebugApplication::SetName( /* [in] */ LPCOLESTR pstrName) { PY_GATEWAY_METHOD; PyObject *obpstrName; obpstrName = PyWinObject_FromOLECHAR(pstrName); HRESULT hr=InvokeViaPolicy("SetName", NULL, "O", obpstrName); Py_XDECREF(obpstrName); return hr; }
// @pymethod (str,...)|PyIPropertyStorage|ReadPropertyNames|Retrieves any existing string names for the specified property identifiers. PyObject *PyIPropertyStorage::ReadPropertyNames(PyObject *self, PyObject *args) { IPropertyStorage *pIPS = GetI(self); if ( pIPS == NULL ) return NULL; PyObject *obProps; // @pyparm (int, ...)|props||Sequence of ints containing property IDs. if ( !PyArg_ParseTuple(args, "O:ReadPropertyNames", &obProps)) return NULL; ULONG cProps; PROPID *pProps; if (!PyObject_AsPROPIDs( obProps, &pProps, &cProps)) return NULL; HRESULT hr; LPWSTR *ppStrs = new LPWSTR[cProps]; if (ppStrs==NULL){ PyErr_NoMemory(); goto cleanup; } memset(ppStrs, 0, sizeof(LPWSTR)*cProps); { PY_INTERFACE_PRECALL; hr = pIPS->ReadPropertyNames( cProps, pProps, ppStrs ); PY_INTERFACE_POSTCALL; } PyObject *rc; if ( FAILED(hr) ) rc = PyCom_BuildPyException(hr, pIPS, IID_IPropertyStorage); else { rc = PyTuple_New(cProps); if (rc==NULL) goto cleanup; for (ULONG i=0;i<cProps;i++){ PyObject *propname=PyWinObject_FromOLECHAR(ppStrs[i]); if (propname==NULL){ Py_DECREF(rc); rc=NULL; goto cleanup; } PyTuple_SET_ITEM( rc, i, propname); } } cleanup: if (ppStrs){ for (ULONG i=0;i<cProps;i++) if (ppStrs[i]) CoTaskMemFree(ppStrs[i]); delete [] ppStrs; } PyObject_FreePROPIDs(pProps, cProps); return rc; }
STDMETHODIMP PyGActiveScriptDebug::GetScriptTextAttributes( /* [size_is][in] */ LPCOLESTR pstrCode, /* [in] */ ULONG uNumCodeChars, /* [in] */ LPCOLESTR pstrDelimiter, /* [in] */ DWORD dwFlags, /* [size_is][out][in] */ SOURCE_TEXT_ATTR __RPC_FAR * pattr) { PY_GATEWAY_METHOD; PyObject *obCode = PyWinObject_FromOLECHAR(pstrCode,uNumCodeChars); PyObject *obszpstrDelimiter = PyWinObject_FromOLECHAR(pstrDelimiter); PyObject *result; HRESULT hr=InvokeViaPolicy("GetScriptTextAttributes", &result, "OOi", obCode, obszpstrDelimiter, dwFlags); Py_XDECREF(obCode); Py_XDECREF(obszpstrDelimiter); if (FAILED(hr)) return hr; if (!PyAXDebug_PyObject_AsSOURCE_TEXT_ATTR(result, pattr, uNumCodeChars)) hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/); Py_DECREF(result); return hr; }
// @pymethod |PyIDebugDocumentText|GetText|Description of GetText. PyObject *PyIDebugDocumentText::GetText(PyObject *self, PyObject *args) { IDebugDocumentText *pIDDT = GetI(self); if ( pIDDT == NULL ) return NULL; PyObject *obpcharText; ULONG cCharacterPosition; ULONG cMaxChars; BOOL bWantAttr = 1; // @pyparm int|cCharacterPosition|| // @pyparm int|cMaxChars||Max chars to return // @pyparm int|bWantAttr|1|Should the attributes be returned? if ( !PyArg_ParseTuple(args, "ii|i:GetText", &cCharacterPosition, &cMaxChars, &bWantAttr) ) return NULL; OLECHAR *buf = new OLECHAR [cMaxChars+1]; SOURCE_TEXT_ATTR *attrbuf = bWantAttr ? new SOURCE_TEXT_ATTR [cMaxChars+1] : NULL; ULONG cNumChars = 0; PY_INTERFACE_PRECALL; HRESULT hr = pIDDT->GetText( cCharacterPosition, buf, attrbuf, &cNumChars, cMaxChars ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self, hr); obpcharText = PyWinObject_FromOLECHAR(buf, cNumChars); PyObject *obattr; if (attrbuf) { obattr = PyAXDebug_PyObject_FromSOURCE_TEXT_ATTR(attrbuf, cNumChars); } else { obattr = Py_None; Py_INCREF(Py_None); } PyObject *pyretval = Py_BuildValue("OO", obpcharText, obattr); Py_XDECREF(obpcharText); Py_XDECREF(obattr); delete [] buf; delete [] attrbuf; return pyretval; }
PyObject *PyObject_FromPROPVARIANT( PROPVARIANT *pVar ) { switch (pVar->vt) { case VT_EMPTY: case VT_NULL: case VT_ILLEGAL: Py_INCREF(Py_None); return Py_None; case VT_I1: return PyInt_FromLong(pVar->cVal); case VT_I1|VT_VECTOR: return VectorToSeq(pVar->cac.pElems, pVar->cac.cElems, PyWinObject_FromCHAR); case VT_UI1: return PyInt_FromLong(pVar->bVal); case VT_UI1|VT_VECTOR: return VectorToSeq(pVar->caub.pElems, pVar->caub.cElems, PyWinObject_FromUCHAR); case VT_I2: return PyInt_FromLong(pVar->iVal); case VT_I2|VT_VECTOR: return VectorToSeq(pVar->cai.pElems, pVar->cai.cElems, PyWinObject_FromSHORT); case VT_UI2: return PyInt_FromLong(pVar->uiVal); case VT_UI2|VT_VECTOR: return VectorToSeq(pVar->caui.pElems, pVar->caui.cElems, PyWinObject_FromUSHORT); case VT_I4: return PyInt_FromLong(pVar->lVal); case VT_I4|VT_VECTOR: return VectorToSeq(pVar->cal.pElems, pVar->cal.cElems, PyInt_FromLong); case VT_INT: return PyInt_FromLong(pVar->intVal); case VT_UI4: return PyLong_FromUnsignedLong(pVar->ulVal); case VT_UI4|VT_VECTOR: return VectorToSeq(pVar->caul.pElems, pVar->caul.cElems, PyLong_FromUnsignedLong); case VT_UINT: return PyLong_FromUnsignedLong(pVar->uintVal); case VT_I8: return PyWinObject_FromLARGE_INTEGER(pVar->hVal); case VT_I8|VT_VECTOR: return VectorToSeq<LARGE_INTEGER>(pVar->cah.pElems, pVar->cah.cElems, PyWinObject_FromLARGE_INTEGER); case VT_UI8: return PyWinObject_FromULARGE_INTEGER(pVar->uhVal); case VT_UI8|VT_VECTOR: return VectorToSeq<ULARGE_INTEGER>(pVar->cauh.pElems, pVar->cauh.cElems, PyWinObject_FromULARGE_INTEGER); case VT_R4: return PyFloat_FromDouble(pVar->fltVal); case VT_R4|VT_VECTOR: return VectorToSeq(pVar->caflt.pElems, pVar->caflt.cElems, PyWinObject_FromFLOAT); case VT_R8: return PyFloat_FromDouble(pVar->dblVal); case VT_R8|VT_VECTOR: return VectorToSeq(pVar->cadbl.pElems, pVar->cadbl.cElems, PyFloat_FromDouble); case VT_CY: return PyObject_FromCurrency(pVar->cyVal); case VT_CY|VT_VECTOR: return VectorToSeq<CY>(pVar->cacy.pElems, pVar->cacy.cElems, PyObject_FromCurrency); case VT_DATE: return PyWinObject_FromDATE(pVar->date); case VT_DATE|VT_VECTOR: return VectorToSeq(pVar->cadate.pElems, pVar->cadate.cElems, PyWinObject_FromDATE); case VT_BSTR: return PyWinObject_FromBstr(pVar->bstrVal); case VT_BSTR|VT_VECTOR: return VectorToSeq(pVar->cabstr.pElems, pVar->cabstr.cElems, PyWinObject_FromVT_BSTR); case VT_BOOL: return PyWinObject_FromVARIANT_BOOL(pVar->boolVal); case VT_BOOL|VT_VECTOR: return VectorToSeq(pVar->cabool.pElems, pVar->cabool.cElems, PyWinObject_FromVARIANT_BOOL); case VT_ERROR: return PyInt_FromLong(pVar->scode); case VT_ERROR|VT_VECTOR: return VectorToSeq(pVar->cascode.pElems, pVar->cascode.cElems, PyInt_FromLong); case VT_FILETIME: return PyWinObject_FromFILETIME(pVar->filetime); case VT_FILETIME|VT_VECTOR: return VectorToSeq<FILETIME>(pVar->cafiletime.pElems, pVar->cafiletime.cElems, PyWinObject_FromFILETIME); case VT_LPSTR: if (pVar->pszVal == NULL) { Py_INCREF(Py_None); return Py_None; } return PyWinCoreString_FromString(pVar->pszVal); case VT_LPSTR|VT_VECTOR: { PyObject *ret = PyList_New(pVar->calpstr.cElems); if (ret==NULL) return NULL; for (ULONG i=0; i<pVar->calpstr.cElems;i++){ PyObject *elem=PyWinCoreString_FromString(pVar->calpstr.pElems[i]); if (elem==NULL){ Py_DECREF(ret); return NULL; } PyList_SET_ITEM(ret, i, elem); } return ret; } case VT_LPWSTR: return PyWinObject_FromOLECHAR(pVar->pwszVal); case VT_LPWSTR|VT_VECTOR: { PyObject *ret = PyList_New(pVar->calpwstr.cElems); if (ret==NULL) return NULL; for (ULONG i=0; i<pVar->calpwstr.cElems;i++){ PyObject *elem=PyWinObject_FromWCHAR(pVar->calpwstr.pElems[i]); if (elem==NULL){ Py_DECREF(ret); return NULL; } PyList_SET_ITEM(ret, i, elem); } return ret; } case VT_CLSID: return PyWinObject_FromIID(*pVar->puuid); case VT_CLSID|VT_VECTOR: return VectorToSeq<CLSID>(pVar->cauuid.pElems, pVar->cauuid.cElems, PyWinObject_FromIID); case VT_STREAM: case VT_STREAMED_OBJECT: return PyCom_PyObjectFromIUnknown(pVar->pStream, IID_IStream, TRUE); case VT_STORAGE: case VT_STORED_OBJECT: return PyCom_PyObjectFromIUnknown(pVar->pStorage, IID_IStorage, TRUE); case VT_VECTOR | VT_VARIANT: return PyObject_FromPROPVARIANTs(pVar->capropvar.pElems, pVar->capropvar.cElems); case VT_BLOB: case VT_BLOB_OBJECT: return PyString_FromStringAndSize((const char *)pVar->blob.pBlobData, pVar->blob.cbSize); // case VT_UNKNOWN: // return PyCom_PyObjectFromIUnknown(pVar->punkVal, IID_IUnknown, TRUE); // case VT_DISPATCH: // return PyCom_PyObjectFromIUnknown(pVar->pdispVal, IID_IDispatch, TRUE); /* // Want to get VT_CF and VT_BLOB working with a test case first! case VT_CF: { // special "clipboard format" // cbSize is the size of the buffer pointed to // by pClipData, plus sizeof(ulClipFmt) // XXX - in that case, shouldn't we pass // pClipData + sizeof(DWORD) to Py_BuildValue?? ULONG cb = CBPCLIPDATA(*pVar->pclipdata); return Py_BuildValue("is#", pVar->pclipdata->ulClipFmt, pVar->pclipdata->pClipData, (int)cb); } */ default: PyErr_Format(PyExc_TypeError, "Unsupported property type 0x%x", pVar->vt); return NULL; } }
PyObject * dataconv_ReadFromInTuple(PyObject *self, PyObject *args) { PyObject *obArgTypes; PyObject *obArgType; PyObject *obPtr; BYTE *pb; BYTE *pbArg; Py_ssize_t cArgs, i; PyObject *obArgs = NULL; PyObject *obArg; VARTYPE vtArgType; UINT cb; VARIANT var; BOOL bIsByRef; if (!PyArg_ParseTuple(args, "OO:ReadFromInTuple", &obArgTypes, &obPtr)) return NULL; pbArg = (BYTE *)PyLong_AsVoidPtr(obPtr); assert(pbArg); if (!pbArg) return NULL; pb = pbArg; if (!PyTuple_Check(obArgTypes)) { PyErr_SetString(PyExc_TypeError, "OLE type description - expecting a tuple"); return NULL; } cArgs = PyTuple_Size(obArgTypes); obArgs = PyTuple_New(cArgs); if (!obArgs) return NULL; for(i = 0 ; i < cArgs; i++) { // (<type tuple>, argPtr offset, arg size) if (PyTuple_Size(PyTuple_GET_ITEM(obArgTypes, i)) != 3) { PyErr_SetString(PyExc_TypeError, "OLE type description - expecting an arg desc tuple of size 3"); goto Error; } obArgType = PyTuple_GET_ITEM(PyTuple_GET_ITEM(obArgTypes, i), 0); // Position pb to point to the current argument. pb = pbArg + PyInt_AS_LONG(PyTuple_GET_ITEM(PyTuple_GET_ITEM(obArgTypes, i), 1)); vtArgType = (VARTYPE)PyInt_AS_LONG(obArgType); #ifdef _M_IX86 bIsByRef = vtArgType & VT_BYREF; #elif _M_X64 // params > 64bits always passed by address - and the only // arg we support > 64 bits is a VARIANT structure. bIsByRef = (vtArgType==VT_VARIANT) || (vtArgType & VT_BYREF); #else #error Unknown platform #endif VARTYPE vtConversionType = vtArgType & VT_TYPEMASK; if (vtArgType & VT_ARRAY) { SAFEARRAY FAR *psa = *((SAFEARRAY **)pb); if (psa==NULL) { // A NULL array Py_INCREF(Py_None); obArg = Py_None; } else { if (vtArgType & VT_BYREF) // one more level of indirection psa = *((SAFEARRAY FAR **)psa); if (psa==NULL) { // A NULL array Py_INCREF(Py_None); obArg = Py_None; } else obArg = PyCom_PyObjectFromSAFEARRAY(psa, (VARENUM)vtConversionType); } } else { switch (vtConversionType) { // If they can fit in a VARIANT, cheat and make that code do all of the work... case VT_I2: case VT_I4: case VT_R4: case VT_R8: case VT_CY: case VT_DATE: case VT_BSTR: case VT_ERROR: case VT_BOOL: case VT_I1: case VT_UI1: case VT_UI2: case VT_UI4: case VT_INT: case VT_UINT: case VT_UNKNOWN: case VT_DISPATCH: case VT_HRESULT: VariantInit(&var); if (vtConversionType == VT_HRESULT || vtConversionType == VT_INT) { // Preserve VT_BYREF or VT_ARRAY vtArgType = VT_I4 | (vtArgType & VT_TYPEMASK); } if (vtArgType == VT_UINT) { // Preserve VT_BYREF or VT_ARRAY vtArgType = VT_UI4 | (vtArgType & VT_TYPEMASK); } V_VT(&var) = vtArgType; // Copy the data into the variant... if (!SizeOfVT(V_VT(&var), (int *)&cb, NULL)) goto Error; memcpy(&V_I4(&var), pb, cb); // Convert it into a PyObject: obArg = PyCom_PyObjectFromVariant(&var); break; case VT_VARIANT: // A _real_ variant. if (bIsByRef) obArg = PyCom_PyObjectFromVariant(*(VARIANT**)pb); else obArg = PyCom_PyObjectFromVariant((VARIANT*)pb); break; case VT_LPSTR: obArg = PyString_FromString(*(CHAR **)pb); break; case VT_LPWSTR: obArg = PyWinObject_FromOLECHAR(*(OLECHAR **)pb); break; // Special cases: case VT_UI8: if (bIsByRef) { obArg = PyWinObject_FromULARGE_INTEGER(*(ULARGE_INTEGER *)pb); } else { obArg = PyWinObject_FromULARGE_INTEGER(**(ULARGE_INTEGER **)pb); } break; case VT_I8: if (bIsByRef) { obArg = PyWinObject_FromLARGE_INTEGER(*(LARGE_INTEGER *)pb); } else { obArg = PyWinObject_FromLARGE_INTEGER(**(LARGE_INTEGER **)pb); } break; // Pointers to unhandled arguments: // neither of these will be VT_BYREF'd. case VT_RECORD: case VT_PTR: obArg = PyLong_FromVoidPtr((void *)pb); break; // None of these should ever happen: case VT_USERDEFINED: // Should have been coerced into VT_PTR. case VT_CARRAY: default: obArg = NULL; PyErr_SetString(PyExc_TypeError, "Unknown/bad type description type!"); // barf here, we don't wtf they were thinking... break; } // switch } // if ARRAY if (obArg == NULL) { goto Error; } PyTuple_SET_ITEM(obArgs, i, obArg); } return obArgs; Error: Py_XDECREF(obArgs); return NULL; }