Esempio n. 1
0
BOOL PyObject_AsPROPVARIANTs(PyObject *ob, PROPVARIANT **ppRet, ULONG *pcRet)
{
	BOOL ret=FALSE;
	DWORD len, i;
	PyObject *tuple=PyWinSequence_Tuple(ob, &len);
	if (tuple==NULL)
		return FALSE;

	PROPVARIANT *pRet = new PROPVARIANT[len];
	if (pRet==NULL){
		PyErr_NoMemory();
		goto cleanup;
		}
	for (i=0;i<len;i++)
		PropVariantInit(pRet+i);

	for (i=0;i<len;i++) {
		PyObject *sub = PyTuple_GET_ITEM(tuple, i);
		if (!PyObject_AsPROPVARIANT(sub, pRet+i))
			goto cleanup;
		}
	ret=TRUE;
cleanup:
	if (ret){
		*ppRet = pRet;
		*pcRet = len;
		}
	else if (pRet)
		PyObject_FreePROPVARIANTs(pRet, len);
	Py_DECREF(tuple);
	return ret;
}
Esempio n. 2
0
// @object PROPSPEC|Identifies a property.  Can be either an int property id, or a str/unicode property name.
BOOL PyWinObject_AsPROPSPECs( PyObject *ob, PROPSPEC **ppRet, ULONG *pcRet)
{
	TmpPyObject tuple=PyWinSequence_Tuple(ob, pcRet);
	if (tuple==NULL)
		return FALSE;
	size_t numBytes = sizeof(PROPSPEC) * *pcRet;
	*ppRet = (PROPSPEC *)malloc(numBytes);
	if (*ppRet==NULL) {
		PyErr_NoMemory();
		return FALSE;
	}
	ZeroMemory(*ppRet, numBytes);
	for (DWORD i=0; i<*pcRet; i++) {
		PyObject *sub = PyTuple_GET_ITEM((PyObject *)tuple, i);
		(*ppRet)[i].propid = PyInt_AsUnsignedLongMask(sub);
		if ((*ppRet)[i].propid != (ULONG)-1 || !PyErr_Occurred())
			(*ppRet)[i].ulKind = PRSPEC_PROPID;
		else{
			PyErr_Clear();
			(*ppRet)[i].lpwstr = NULL;
			if (PyWinObject_AsWCHAR(sub, &(*ppRet)[i].lpwstr))
				(*ppRet)[i].ulKind = PRSPEC_LPWSTR;
			else{
				PyErr_Clear();
				PyErr_SetString(PyExc_TypeError, "PROPSPECs must be a sequence of strings or integers");
				PyObject_FreePROPSPECs(*ppRet, *pcRet);
				*ppRet=NULL;
				return FALSE;
				}
			}
		}
	return TRUE;
}
Esempio n. 3
0
BOOL PyWinObject_AsCharArray(PyObject *str_seq, char ***pchars, DWORD *str_cnt, BOOL bNoneOK)
{
	BOOL ret=FALSE;
	PyObject *str_tuple=NULL, *tuple_item;
	DWORD bufsize, tuple_index;
	*pchars=NULL;
	*str_cnt=0;

	if (bNoneOK && str_seq==Py_None)
		return TRUE;
	if ((str_tuple=PyWinSequence_Tuple(str_seq, str_cnt))==NULL)
		return FALSE;
	bufsize=*str_cnt * sizeof(char *);
	*pchars=(char **)malloc(bufsize);
	if (*pchars==NULL){
		PyErr_Format(PyExc_MemoryError, "Unable to allocate %d bytes", bufsize);
		goto done;
		}
	ZeroMemory(*pchars, bufsize);
	for (tuple_index=0;tuple_index<*str_cnt;tuple_index++){
		tuple_item=PyTuple_GET_ITEM(str_tuple, tuple_index);
		if (!PyWinObject_AsString(tuple_item, &((*pchars)[tuple_index]), FALSE)){
			PyWinObject_FreeCharArray(*pchars, *str_cnt);
			*pchars=NULL;
			*str_cnt=0;
			goto done;
			}
		}
	ret=TRUE;
done:
	Py_DECREF(str_tuple);
	return ret;
}
Esempio n. 4
0
// @object PROPSPEC|Identifies a property.  Can be either an int property id, or a str/unicode property name.
BOOL PyObject_AsPROPSPECs( PyObject *ob, PROPSPEC **ppRet, ULONG *pcRet)
{
	BOOL ret=FALSE;
	DWORD len, i;
	PyObject *tuple=PyWinSequence_Tuple(ob, &len);
	if (tuple==NULL)
		return FALSE;

	// First count the items, and the total string space we need.
	size_t cChars = 0;
	for (i=0;i<len;i++) {
		PyObject *sub = PyTuple_GET_ITEM(tuple, i);
		if (PyUnicode_Check(sub))
			cChars += PyUnicode_GET_SIZE(sub) + 1;
		else if (PyString_Check(sub))
			cChars += PyString_Size(sub) + 1;
		else if (PyInt_Check(sub))
			;	// PROPID is a ULONG, so this may fail for values that require a python long
		else {
			PyErr_SetString(PyExc_TypeError, "PROPSPECs must be a sequence of strings or integers");
			goto cleanup;
		}
	}
	size_t numBytes;
	numBytes = (sizeof(PROPSPEC) * len) + (sizeof(WCHAR) * cChars);
	PROPSPEC *pRet;
	pRet = (PROPSPEC *)malloc(numBytes);
	if (pRet==NULL) {
		PyErr_SetString(PyExc_MemoryError, "allocating PROPSPECs");
		goto cleanup;
	}
	WCHAR *curBuf;
	curBuf = (WCHAR *)(pRet+len);
	for (i=0;i<len;i++) {
		PyObject *sub = PyTuple_GET_ITEM(tuple, i);
		BSTR bstr;
		if (PyWinObject_AsBstr(sub, &bstr)) {
			pRet[i].ulKind = PRSPEC_LPWSTR;
			pRet[i].lpwstr = curBuf;
			wcscpy( curBuf, bstr);
			curBuf += wcslen(curBuf) + 1;
			PyWinObject_FreeBstr(bstr);
		} else {
			PyErr_Clear();
			pRet[i].ulKind = PRSPEC_PROPID;
			pRet[i].propid = PyInt_AsLong(sub);
		}
	}
	ret=TRUE;
	*ppRet = pRet;
	*pcRet = len;
cleanup:
	Py_DECREF(tuple);
	return ret;
}
Esempio n. 5
0
// Same conversion as PyObject_AsPROPVARIANTs, but PROPVARIANT array is allocated by caller
BOOL PyObject_AsPreallocatedPROPVARIANTs(PyObject *ob, PROPVARIANT *propvars, ULONG cpropvars)
{
	DWORD len, i;
	TmpPyObject tuple=PyWinSequence_Tuple(ob, &len);
	if (tuple==NULL)
		return FALSE;
	if (len != cpropvars){
		PyErr_SetString(PyExc_ValueError, "Sequence not of required length");
		return FALSE;
		}
	for (i=0; i<cpropvars; i++) {
		PyObject *sub = PyTuple_GET_ITEM((PyObject *)tuple, i);
		if (!PyObject_AsPROPVARIANT(sub, &propvars[i]))
			for (; i--;)
				PropVariantClear(&propvars[i]);
			return FALSE;
		}
	return TRUE;
}
Esempio n. 6
0
// Alocates and populates an array of DWORDS from a sequence of Python ints
BOOL PyWinObject_AsDWORDArray(PyObject *obdwords, DWORD **pdwords, DWORD *item_cnt, BOOL bNoneOk)
{
	BOOL ret=TRUE;
	DWORD bufsize, tuple_index;
	PyObject *dwords_tuple=NULL, *tuple_item;
	*pdwords=NULL;
	*item_cnt=0;
	if (obdwords==Py_None){
		if (bNoneOk)
			return TRUE;
		PyErr_SetString(PyExc_ValueError,"Sequence of dwords cannot be None");
		return FALSE;
		}
	if ((dwords_tuple=PyWinSequence_Tuple(obdwords, item_cnt))==NULL)
		return FALSE;	// last exit without cleaning up
	bufsize=*item_cnt * sizeof(DWORD);
	*pdwords=(DWORD *)malloc(bufsize);
	if (*pdwords==NULL){
		PyErr_Format(PyExc_MemoryError, "Unable to allocate %d bytes", bufsize);
		ret=FALSE;
		}
	else
		for (tuple_index=0; tuple_index<*item_cnt; tuple_index++){
			tuple_item=PyTuple_GET_ITEM(dwords_tuple,tuple_index);
			// Doesn't check for overflow, but will accept a python long
			//  greater than INT_MAX (even on python 2.3).  Also accepts
			//  negatives and converts to the correct hex representation
			(*pdwords)[tuple_index]=PyInt_AsUnsignedLongMask(tuple_item);
			if (((*pdwords)[tuple_index]==-1) && PyErr_Occurred()){
				ret=FALSE;
				break;
				}
			}
	if (!ret)
		if (*pdwords!=NULL){
			free(*pdwords);
			*pdwords=NULL;
			*item_cnt=0;
			}
	Py_XDECREF(dwords_tuple);
	return ret;
}
Esempio n. 7
0
// Converts a sequence of strings into a caller-allocated array of WCHAR pointers,
// each of which is allocated using CoTaskMemAlloc
BOOL PyWinObject_AsTaskAllocatedWCHARArray(PyObject *str_seq, LPWSTR *wchars, ULONG str_cnt)
{
	TmpPyObject str_tuple;
	ULONG seq_size, tuple_index;
	ZeroMemory(wchars, str_cnt * sizeof(WCHAR *));
	if ((str_tuple=PyWinSequence_Tuple(str_seq, &seq_size))==NULL)
		return FALSE;
	if (seq_size != str_cnt){
		PyErr_SetString(PyExc_ValueError, "Sequence not of required length");
		return FALSE;
		}
	for (tuple_index=0; tuple_index<str_cnt; tuple_index++){
		PyObject *tuple_item=PyTuple_GET_ITEM((PyObject *)str_tuple, tuple_index);
		if (!PyWinObject_AsTaskAllocatedWCHAR(tuple_item, &wchars[tuple_index], FALSE)){
			for (tuple_index=0; tuple_index<str_cnt; tuple_index++)
				if (wchars[tuple_index])
					CoTaskMemFree(wchars[tuple_index]);
			return FALSE;
			}
		}
	return TRUE;
}