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