diff --git a/PC/_msi.c b/PC/_msi.c index 591fc4a054b..574dddec058 100644 --- a/PC/_msi.c +++ b/PC/_msi.c @@ -26,13 +26,13 @@ uuidcreate(PyObject* obj, PyObject*args) For RPC_S_UUID_NO_ADDRESS, it's not clear whether we can use the result. */ if (UuidCreate(&result) == RPC_S_UUID_NO_ADDRESS) { - PyErr_SetString(PyExc_NotImplementedError, "processing 'no address' result"); - return NULL; + PyErr_SetString(PyExc_NotImplementedError, "processing 'no address' result"); + return NULL; } if (UuidToString(&result, &cresult) == RPC_S_OUT_OF_MEMORY) { - PyErr_SetString(PyExc_MemoryError, "out of memory in uuidgen"); - return NULL; + PyErr_SetString(PyExc_MemoryError, "out of memory in uuidgen"); + return NULL; } oresult = PyString_FromString(cresult); @@ -57,7 +57,7 @@ static FNFCIOPEN(cb_open) { int result = _open(pszFile, oflag, pmode); if (result == -1) - *err = errno; + *err = errno; return result; } @@ -65,7 +65,7 @@ static FNFCIREAD(cb_read) { UINT result = (UINT)_read(hf, memory, cb); if (result != cb) - *err = errno; + *err = errno; return result; } @@ -73,7 +73,7 @@ static FNFCIWRITE(cb_write) { UINT result = (UINT)_write(hf, memory, cb); if (result != cb) - *err = errno; + *err = errno; return result; } @@ -81,7 +81,7 @@ static FNFCICLOSE(cb_close) { int result = _close(hf); if (result != 0) - *err = errno; + *err = errno; return result; } @@ -89,7 +89,7 @@ static FNFCISEEK(cb_seek) { long result = (long)_lseek(hf, dist, seektype); if (result == -1) - *err = errno; + *err = errno; return result; } @@ -97,7 +97,7 @@ static FNFCIDELETE(cb_delete) { int result = remove(pszFile); if (result != 0) - *err = errno; + *err = errno; return result; } @@ -110,9 +110,9 @@ static FNFCIGETTEMPFILE(cb_gettempfile) { char *name = _tempnam("", "tmp"); if ((name != NULL) && ((int)strlen(name) < cbTempName)) { - strcpy(pszTempName, name); - free(name); - return TRUE; + strcpy(pszTempName, name); + free(name); + return TRUE; } if (name) free(name); @@ -122,10 +122,10 @@ static FNFCIGETTEMPFILE(cb_gettempfile) static FNFCISTATUS(cb_status) { if (pv) { - PyObject *result = PyObject_CallMethod(pv, "status", "iii", typeStatus, cb1, cb2); - if (result == NULL) - return -1; - Py_DECREF(result); + PyObject *result = PyObject_CallMethod(pv, "status", "iii", typeStatus, cb1, cb2); + if (result == NULL) + return -1; + Py_DECREF(result); } return 0; } @@ -133,18 +133,18 @@ static FNFCISTATUS(cb_status) static FNFCIGETNEXTCABINET(cb_getnextcabinet) { if (pv) { - PyObject *result = PyObject_CallMethod(pv, "getnextcabinet", "i", pccab->iCab); - if (result == NULL) - return -1; - if (!PyString_Check(result)) { - PyErr_Format(PyExc_TypeError, - "Incorrect return type %s from getnextcabinet", - result->ob_type->tp_name); - Py_DECREF(result); - return FALSE; - } - strncpy(pccab->szCab, PyString_AsString(result), sizeof(pccab->szCab)); - return TRUE; + PyObject *result = PyObject_CallMethod(pv, "getnextcabinet", "i", pccab->iCab); + if (result == NULL) + return -1; + if (!PyString_Check(result)) { + PyErr_Format(PyExc_TypeError, + "Incorrect return type %s from getnextcabinet", + result->ob_type->tp_name); + Py_DECREF(result); + return FALSE; + } + strncpy(pccab->szCab, PyString_AsString(result), sizeof(pccab->szCab)); + return TRUE; } return FALSE; } @@ -157,21 +157,21 @@ static FNFCIGETOPENINFO(cb_getopeninfo) /* Need Win32 handle to get time stamps */ handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (handle == INVALID_HANDLE_VALUE) - return -1; + return -1; if (GetFileInformationByHandle(handle, &bhfi) == FALSE) { - CloseHandle(handle); - return -1; + CloseHandle(handle); + return -1; } FileTimeToLocalFileTime(&bhfi.ftLastWriteTime, &filetime); FileTimeToDosDateTime(&filetime, pdate, ptime); *pattribs = (int)(bhfi.dwFileAttributes & - (_A_RDONLY | _A_SYSTEM | _A_HIDDEN | _A_ARCH)); + (_A_RDONLY | _A_SYSTEM | _A_HIDDEN | _A_ARCH)); CloseHandle(handle); @@ -189,11 +189,11 @@ static PyObject* fcicreate(PyObject* obj, PyObject* args) if (!PyArg_ParseTuple(args, "sO:FCICreate", &cabname, &files)) - return NULL; + return NULL; if (!PyList_Check(files)) { - PyErr_SetString(PyExc_TypeError, "FCICreate expects a list"); - return NULL; + PyErr_SetString(PyExc_TypeError, "FCICreate expects a list"); + return NULL; } ccab.cb = INT_MAX; /* no need to split CAB into multiple media */ @@ -209,49 +209,49 @@ static PyObject* fcicreate(PyObject* obj, PyObject* args) ccab.szDisk[0] = '\0'; for (i = 0, p = cabname; *p; p = CharNext(p)) - if (*p == '\\' || *p == '/') - i = p - cabname + 1; + if (*p == '\\' || *p == '/') + i = p - cabname + 1; if (i >= sizeof(ccab.szCabPath) || - strlen(cabname+i) >= sizeof(ccab.szCab)) { - PyErr_SetString(PyExc_ValueError, "path name too long"); - return 0; + strlen(cabname+i) >= sizeof(ccab.szCab)) { + PyErr_SetString(PyExc_ValueError, "path name too long"); + return 0; } if (i > 0) { - memcpy(ccab.szCabPath, cabname, i); - ccab.szCabPath[i] = '\0'; - strcpy(ccab.szCab, cabname+i); + memcpy(ccab.szCabPath, cabname, i); + ccab.szCabPath[i] = '\0'; + strcpy(ccab.szCab, cabname+i); } else { - strcpy(ccab.szCabPath, ".\\"); - strcpy(ccab.szCab, cabname); + strcpy(ccab.szCabPath, ".\\"); + strcpy(ccab.szCab, cabname); } hfci = FCICreate(&erf, cb_fileplaced, cb_alloc, cb_free, - cb_open, cb_read, cb_write, cb_close, cb_seek, cb_delete, - cb_gettempfile, &ccab, NULL); + cb_open, cb_read, cb_write, cb_close, cb_seek, cb_delete, + cb_gettempfile, &ccab, NULL); if (hfci == NULL) { - PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper); - return NULL; + PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper); + return NULL; } for (i=0; i < PyList_GET_SIZE(files); i++) { - PyObject *item = PyList_GET_ITEM(files, i); - char *filename, *cabname; - if (!PyArg_ParseTuple(item, "ss", &filename, &cabname)) - goto err; - if (!FCIAddFile(hfci, filename, cabname, FALSE, - cb_getnextcabinet, cb_status, cb_getopeninfo, - tcompTYPE_MSZIP)) - goto err; + PyObject *item = PyList_GET_ITEM(files, i); + char *filename, *cabname; + if (!PyArg_ParseTuple(item, "ss", &filename, &cabname)) + goto err; + if (!FCIAddFile(hfci, filename, cabname, FALSE, + cb_getnextcabinet, cb_status, cb_getopeninfo, + tcompTYPE_MSZIP)) + goto err; } if (!FCIFlushCabinet(hfci, FALSE, cb_getnextcabinet, cb_status)) - goto err; + goto err; if (!FCIDestroy(hfci)) - goto err; + goto err; Py_INCREF(Py_None); return Py_None; @@ -292,41 +292,41 @@ msierror(int status) MSIHANDLE err = MsiGetLastErrorRecord(); if (err == 0) { - switch(status) { - case ERROR_ACCESS_DENIED: - PyErr_SetString(MSIError, "access denied"); - return NULL; - case ERROR_FUNCTION_FAILED: - PyErr_SetString(MSIError, "function failed"); - return NULL; - case ERROR_INVALID_DATA: - PyErr_SetString(MSIError, "invalid data"); - return NULL; - case ERROR_INVALID_HANDLE: - PyErr_SetString(MSIError, "invalid handle"); - return NULL; - case ERROR_INVALID_STATE: - PyErr_SetString(MSIError, "invalid state"); - return NULL; - case ERROR_INVALID_PARAMETER: - PyErr_SetString(MSIError, "invalid parameter"); - return NULL; - default: - PyErr_Format(MSIError, "unknown error %x", status); - return NULL; - } + switch(status) { + case ERROR_ACCESS_DENIED: + PyErr_SetString(MSIError, "access denied"); + return NULL; + case ERROR_FUNCTION_FAILED: + PyErr_SetString(MSIError, "function failed"); + return NULL; + case ERROR_INVALID_DATA: + PyErr_SetString(MSIError, "invalid data"); + return NULL; + case ERROR_INVALID_HANDLE: + PyErr_SetString(MSIError, "invalid handle"); + return NULL; + case ERROR_INVALID_STATE: + PyErr_SetString(MSIError, "invalid state"); + return NULL; + case ERROR_INVALID_PARAMETER: + PyErr_SetString(MSIError, "invalid parameter"); + return NULL; + default: + PyErr_Format(MSIError, "unknown error %x", status); + return NULL; + } } code = MsiRecordGetInteger(err, 1); /* XXX code */ if (MsiFormatRecord(0, err, res, &size) == ERROR_MORE_DATA) { - res = malloc(size+1); - MsiFormatRecord(0, err, res, &size); - res[size]='\0'; + res = malloc(size+1); + MsiFormatRecord(0, err, res, &size); + res[size]='\0'; } MsiCloseHandle(err); PyErr_SetString(MSIError, res); if (res != buf) - free(res); + free(res); return NULL; } @@ -345,11 +345,11 @@ record_getinteger(msiobj* record, PyObject* args) int status; if (!PyArg_ParseTuple(args, "I:GetInteger", &field)) - return NULL; + return NULL; status = MsiRecordGetInteger(record->h, field); if (status == MSI_NULL_INTEGER){ - PyErr_SetString(MSIError, "could not convert record field to integer"); - return NULL; + PyErr_SetString(MSIError, "could not convert record field to integer"); + return NULL; } return PyInt_FromLong((long) status); } @@ -365,19 +365,19 @@ record_getstring(msiobj* record, PyObject* args) PyObject* string; if (!PyArg_ParseTuple(args, "I:GetString", &field)) - return NULL; + return NULL; status = MsiRecordGetString(record->h, field, res, &size); if (status == ERROR_MORE_DATA) { - res = (char*) malloc(size + 1); - if (res == NULL) - return PyErr_NoMemory(); - status = MsiRecordGetString(record->h, field, res, &size); + res = (char*) malloc(size + 1); + if (res == NULL) + return PyErr_NoMemory(); + status = MsiRecordGetString(record->h, field, res, &size); } if (status != ERROR_SUCCESS) - return msierror((int) status); + return msierror((int) status); string = PyString_FromString(res); if (buf != res) - free(res); + free(res); return string; } @@ -386,7 +386,7 @@ record_cleardata(msiobj* record, PyObject *args) { int status = MsiRecordClearData(record->h); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -400,10 +400,10 @@ record_setstring(msiobj* record, PyObject *args) char *data; if (!PyArg_ParseTuple(args, "is:SetString", &field, &data)) - return NULL; + return NULL; if ((status = MsiRecordSetString(record->h, field, data)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -417,10 +417,10 @@ record_setstream(msiobj* record, PyObject *args) char *data; if (!PyArg_ParseTuple(args, "is:SetStream", &field, &data)) - return NULL; + return NULL; if ((status = MsiRecordSetStream(record->h, field, data)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -434,10 +434,10 @@ record_setinteger(msiobj* record, PyObject *args) int data; if (!PyArg_ParseTuple(args, "ii:SetInteger", &field, &data)) - return NULL; + return NULL; if ((status = MsiRecordSetInteger(record->h, field, data)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -447,64 +447,64 @@ record_setinteger(msiobj* record, PyObject *args) static PyMethodDef record_methods[] = { { "GetFieldCount", (PyCFunction)record_getfieldcount, METH_NOARGS, - PyDoc_STR("GetFieldCount() -> int\nWraps MsiRecordGetFieldCount")}, + PyDoc_STR("GetFieldCount() -> int\nWraps MsiRecordGetFieldCount")}, { "GetInteger", (PyCFunction)record_getinteger, METH_VARARGS, PyDoc_STR("GetInteger(field) -> int\nWraps MsiRecordGetInteger")}, { "GetString", (PyCFunction)record_getstring, METH_VARARGS, PyDoc_STR("GetString(field) -> string\nWraps MsiRecordGetString")}, { "SetString", (PyCFunction)record_setstring, METH_VARARGS, - PyDoc_STR("SetString(field,str) -> None\nWraps MsiRecordSetString")}, + PyDoc_STR("SetString(field,str) -> None\nWraps MsiRecordSetString")}, { "SetStream", (PyCFunction)record_setstream, METH_VARARGS, - PyDoc_STR("SetStream(field,filename) -> None\nWraps MsiRecordSetInteger")}, + PyDoc_STR("SetStream(field,filename) -> None\nWraps MsiRecordSetInteger")}, { "SetInteger", (PyCFunction)record_setinteger, METH_VARARGS, - PyDoc_STR("SetInteger(field,int) -> None\nWraps MsiRecordSetInteger")}, + PyDoc_STR("SetInteger(field,int) -> None\nWraps MsiRecordSetInteger")}, { "ClearData", (PyCFunction)record_cleardata, METH_NOARGS, - PyDoc_STR("ClearData() -> int\nWraps MsiRecordGClearData")}, + PyDoc_STR("ClearData() -> int\nWraps MsiRecordGClearData")}, { NULL, NULL } }; static PyTypeObject record_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_msi.Record", /*tp_name*/ - sizeof(msiobj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor)msiobj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - PyObject_GenericGetAttr,/*tp_getattro*/ - PyObject_GenericSetAttr,/*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - record_methods, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - 0, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ + PyVarObject_HEAD_INIT(NULL, 0) + "_msi.Record", /*tp_name*/ + sizeof(msiobj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)msiobj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr,/*tp_getattro*/ + PyObject_GenericSetAttr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + record_methods, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + 0, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ }; static PyObject* @@ -513,8 +513,8 @@ record_new(MSIHANDLE h) msiobj *result = PyObject_NEW(struct msiobj, &record_Type); if (!result) { - MsiCloseHandle(h); - return NULL; + MsiCloseHandle(h); + return NULL; } result->h = h; @@ -537,27 +537,27 @@ summary_getproperty(msiobj* si, PyObject *args) DWORD ssize = sizeof(sval); if (!PyArg_ParseTuple(args, "i:GetProperty", &field)) - return NULL; + return NULL; - status = MsiSummaryInfoGetProperty(si->h, field, &type, &ival, - &fval, sval, &ssize); - if (status == ERROR_MORE_DATA) { - sval = malloc(ssize); status = MsiSummaryInfoGetProperty(si->h, field, &type, &ival, &fval, sval, &ssize); + if (status == ERROR_MORE_DATA) { + sval = malloc(ssize); + status = MsiSummaryInfoGetProperty(si->h, field, &type, &ival, + &fval, sval, &ssize); } switch(type) { - case VT_I2: case VT_I4: - return PyInt_FromLong(ival); - case VT_FILETIME: - PyErr_SetString(PyExc_NotImplementedError, "FILETIME result"); - return NULL; - case VT_LPSTR: - result = PyString_FromStringAndSize(sval, ssize); - if (sval != sbuf) - free(sval); - return result; + case VT_I2: case VT_I4: + return PyInt_FromLong(ival); + case VT_FILETIME: + PyErr_SetString(PyExc_NotImplementedError, "FILETIME result"); + return NULL; + case VT_LPSTR: + result = PyString_FromStringAndSize(sval, ssize); + if (sval != sbuf) + free(sval); + return result; } PyErr_Format(PyExc_NotImplementedError, "result of type %d", type); return NULL; @@ -571,7 +571,7 @@ summary_getpropertycount(msiobj* si, PyObject *args) status = MsiSummaryInfoGetPropertyCount(si->h, &result); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); return PyInt_FromLong(result); } @@ -584,21 +584,21 @@ summary_setproperty(msiobj* si, PyObject *args) PyObject* data; if (!PyArg_ParseTuple(args, "iO:SetProperty", &field, &data)) - return NULL; + return NULL; if (PyString_Check(data)) { - status = MsiSummaryInfoSetProperty(si->h, field, VT_LPSTR, - 0, NULL, PyString_AsString(data)); + status = MsiSummaryInfoSetProperty(si->h, field, VT_LPSTR, + 0, NULL, PyString_AsString(data)); } else if (PyInt_Check(data)) { - status = MsiSummaryInfoSetProperty(si->h, field, VT_I4, - PyInt_AsLong(data), NULL, NULL); + status = MsiSummaryInfoSetProperty(si->h, field, VT_I4, + PyInt_AsLong(data), NULL, NULL); } else { - PyErr_SetString(PyExc_TypeError, "unsupported type"); - return NULL; + PyErr_SetString(PyExc_TypeError, "unsupported type"); + return NULL; } if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -612,65 +612,65 @@ summary_persist(msiobj* si, PyObject *args) status = MsiSummaryInfoPersist(si->h); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; } static PyMethodDef summary_methods[] = { { "GetProperty", (PyCFunction)summary_getproperty, METH_VARARGS, - PyDoc_STR("GetProperty(propid) -> value\nWraps MsiSummaryInfoGetProperty")}, + PyDoc_STR("GetProperty(propid) -> value\nWraps MsiSummaryInfoGetProperty")}, { "GetPropertyCount", (PyCFunction)summary_getpropertycount, METH_NOARGS, - PyDoc_STR("GetProperty() -> int\nWraps MsiSummaryInfoGetPropertyCount")}, + PyDoc_STR("GetProperty() -> int\nWraps MsiSummaryInfoGetPropertyCount")}, { "SetProperty", (PyCFunction)summary_setproperty, METH_VARARGS, - PyDoc_STR("SetProperty(value) -> None\nWraps MsiSummaryInfoProperty")}, + PyDoc_STR("SetProperty(value) -> None\nWraps MsiSummaryInfoProperty")}, { "Persist", (PyCFunction)summary_persist, METH_NOARGS, - PyDoc_STR("Persist() -> None\nWraps MsiSummaryInfoPersist")}, + PyDoc_STR("Persist() -> None\nWraps MsiSummaryInfoPersist")}, { NULL, NULL } }; static PyTypeObject summary_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_msi.SummaryInformation", /*tp_name*/ - sizeof(msiobj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor)msiobj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - PyObject_GenericGetAttr,/*tp_getattro*/ - PyObject_GenericSetAttr,/*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - summary_methods, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - 0, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ + PyVarObject_HEAD_INIT(NULL, 0) + "_msi.SummaryInformation", /*tp_name*/ + sizeof(msiobj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)msiobj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr,/*tp_getattro*/ + PyObject_GenericSetAttr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + summary_methods, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + 0, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ }; /*************************** View objects **************/ @@ -683,19 +683,19 @@ view_execute(msiobj *view, PyObject*args) PyObject *oparams = Py_None; if (!PyArg_ParseTuple(args, "O:Execute", &oparams)) - return NULL; + return NULL; if (oparams != Py_None) { - if (oparams->ob_type != &record_Type) { - PyErr_SetString(PyExc_TypeError, "Execute argument must be a record"); - return NULL; - } - params = ((msiobj*)oparams)->h; + if (oparams->ob_type != &record_Type) { + PyErr_SetString(PyExc_TypeError, "Execute argument must be a record"); + return NULL; + } + params = ((msiobj*)oparams)->h; } status = MsiViewExecute(view->h, params); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -708,7 +708,7 @@ view_fetch(msiobj *view, PyObject*args) MSIHANDLE result; if ((status = MsiViewFetch(view->h, &result)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); return record_new(result); } @@ -721,10 +721,10 @@ view_getcolumninfo(msiobj *view, PyObject *args) MSIHANDLE result; if (!PyArg_ParseTuple(args, "i:GetColumnInfo", &kind)) - return NULL; + return NULL; if ((status = MsiViewGetColumnInfo(view->h, kind, &result)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); return record_new(result); } @@ -737,15 +737,15 @@ view_modify(msiobj *view, PyObject *args) int status; if (!PyArg_ParseTuple(args, "iO:Modify", &kind, &data)) - return NULL; + return NULL; if (data->ob_type != &record_Type) { - PyErr_SetString(PyExc_TypeError, "Modify expects a record object"); - return NULL; + PyErr_SetString(PyExc_TypeError, "Modify expects a record object"); + return NULL; } if ((status = MsiViewModify(view->h, kind, ((msiobj*)data)->h)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -757,7 +757,7 @@ view_close(msiobj *view, PyObject*args) int status; if ((status = MsiViewClose(view->h)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -765,60 +765,60 @@ view_close(msiobj *view, PyObject*args) static PyMethodDef view_methods[] = { { "Execute", (PyCFunction)view_execute, METH_VARARGS, - PyDoc_STR("Execute(params=None) -> None\nWraps MsiViewExecute")}, + PyDoc_STR("Execute(params=None) -> None\nWraps MsiViewExecute")}, { "GetColumnInfo", (PyCFunction)view_getcolumninfo, METH_VARARGS, - PyDoc_STR("GetColumnInfo() -> result\nWraps MsiGetColumnInfo")}, + PyDoc_STR("GetColumnInfo() -> result\nWraps MsiGetColumnInfo")}, { "Fetch", (PyCFunction)view_fetch, METH_NOARGS, - PyDoc_STR("Fetch() -> result\nWraps MsiViewFetch")}, + PyDoc_STR("Fetch() -> result\nWraps MsiViewFetch")}, { "Modify", (PyCFunction)view_modify, METH_VARARGS, - PyDoc_STR("Modify(mode,record) -> None\nWraps MsiViewModify")}, + PyDoc_STR("Modify(mode,record) -> None\nWraps MsiViewModify")}, { "Close", (PyCFunction)view_close, METH_NOARGS, - PyDoc_STR("Close() -> result\nWraps MsiViewClose")}, + PyDoc_STR("Close() -> result\nWraps MsiViewClose")}, { NULL, NULL } }; static PyTypeObject msiview_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_msi.View", /*tp_name*/ - sizeof(msiobj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor)msiobj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - PyObject_GenericGetAttr,/*tp_getattro*/ - PyObject_GenericSetAttr,/*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - view_methods, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - 0, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ + PyVarObject_HEAD_INIT(NULL, 0) + "_msi.View", /*tp_name*/ + sizeof(msiobj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)msiobj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr,/*tp_getattro*/ + PyObject_GenericSetAttr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + view_methods, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + 0, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ }; /*************************** Database objects **************/ @@ -832,15 +832,15 @@ msidb_openview(msiobj *msidb, PyObject *args) msiobj *result; if (!PyArg_ParseTuple(args, "s:OpenView", &sql)) - return NULL; + return NULL; if ((status = MsiDatabaseOpenView(msidb->h, sql, &hView)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); result = PyObject_NEW(struct msiobj, &msiview_Type); if (!result) { - MsiCloseHandle(hView); - return NULL; + MsiCloseHandle(hView); + return NULL; } result->h = hView; @@ -853,7 +853,7 @@ msidb_commit(msiobj *msidb, PyObject *args) int status; if ((status = MsiDatabaseCommit(msidb->h)) != ERROR_SUCCESS) - return msierror(status); + return msierror(status); Py_INCREF(Py_None); return Py_None; @@ -868,16 +868,16 @@ msidb_getsummaryinformation(msiobj *db, PyObject *args) msiobj *oresult; if (!PyArg_ParseTuple(args, "i:GetSummaryInformation", &count)) - return NULL; + return NULL; status = MsiGetSummaryInformation(db->h, NULL, count, &result); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); oresult = PyObject_NEW(struct msiobj, &summary_Type); if (!result) { - MsiCloseHandle(result); - return NULL; + MsiCloseHandle(result); + return NULL; } oresult->h = result; @@ -886,56 +886,56 @@ msidb_getsummaryinformation(msiobj *db, PyObject *args) static PyMethodDef db_methods[] = { { "OpenView", (PyCFunction)msidb_openview, METH_VARARGS, - PyDoc_STR("OpenView(sql) -> viewobj\nWraps MsiDatabaseOpenView")}, + PyDoc_STR("OpenView(sql) -> viewobj\nWraps MsiDatabaseOpenView")}, { "Commit", (PyCFunction)msidb_commit, METH_NOARGS, - PyDoc_STR("Commit() -> None\nWraps MsiDatabaseCommit")}, + PyDoc_STR("Commit() -> None\nWraps MsiDatabaseCommit")}, { "GetSummaryInformation", (PyCFunction)msidb_getsummaryinformation, METH_VARARGS, - PyDoc_STR("GetSummaryInformation(updateCount) -> viewobj\nWraps MsiGetSummaryInformation")}, + PyDoc_STR("GetSummaryInformation(updateCount) -> viewobj\nWraps MsiGetSummaryInformation")}, { NULL, NULL } }; static PyTypeObject msidb_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "_msi.Database", /*tp_name*/ - sizeof(msiobj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor)msiobj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - PyObject_GenericGetAttr,/*tp_getattro*/ - PyObject_GenericSetAttr,/*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - db_methods, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - 0, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ + PyVarObject_HEAD_INIT(NULL, 0) + "_msi.Database", /*tp_name*/ + sizeof(msiobj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)msiobj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr,/*tp_getattro*/ + PyObject_GenericSetAttr,/*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + db_methods, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + 0, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ }; static PyObject* msiopendb(PyObject *obj, PyObject *args) @@ -947,16 +947,16 @@ static PyObject* msiopendb(PyObject *obj, PyObject *args) msiobj *result; if (!PyArg_ParseTuple(args, "si:MSIOpenDatabase", &path, &persist)) - return NULL; + return NULL; - status = MsiOpenDatabase(path, (LPCSTR)persist, &h); + status = MsiOpenDatabase(path, (LPCSTR)persist, &h); if (status != ERROR_SUCCESS) - return msierror(status); + return msierror(status); result = PyObject_NEW(struct msiobj, &msidb_Type); if (!result) { - MsiCloseHandle(h); - return NULL; + MsiCloseHandle(h); + return NULL; } result->h = h; return (PyObject*)result; @@ -969,26 +969,26 @@ createrecord(PyObject *o, PyObject *args) MSIHANDLE h; if (!PyArg_ParseTuple(args, "i:CreateRecord", &count)) - return NULL; + return NULL; h = MsiCreateRecord(count); if (h == 0) - return msierror(0); + return msierror(0); return record_new(h); } static PyMethodDef msi_methods[] = { - {"UuidCreate", (PyCFunction)uuidcreate, METH_NOARGS, - PyDoc_STR("UuidCreate() -> string")}, - {"FCICreate", (PyCFunction)fcicreate, METH_VARARGS, - PyDoc_STR("fcicreate(cabname,files) -> None")}, - {"OpenDatabase", (PyCFunction)msiopendb, METH_VARARGS, - PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiOpenDatabase")}, - {"CreateRecord", (PyCFunction)createrecord, METH_VARARGS, - PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiCreateRecord")}, - {NULL, NULL} /* sentinel */ + {"UuidCreate", (PyCFunction)uuidcreate, METH_NOARGS, + PyDoc_STR("UuidCreate() -> string")}, + {"FCICreate", (PyCFunction)fcicreate, METH_VARARGS, + PyDoc_STR("fcicreate(cabname,files) -> None")}, + {"OpenDatabase", (PyCFunction)msiopendb, METH_VARARGS, + PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiOpenDatabase")}, + {"CreateRecord", (PyCFunction)createrecord, METH_VARARGS, + PyDoc_STR("OpenDatabase(name, flags) -> dbobj\nWraps MsiCreateRecord")}, + {NULL, NULL} /* sentinel */ }; static char msi_doc[] = "Documentation"; @@ -1000,7 +1000,7 @@ init_msi(void) m = Py_InitModule3("_msi", msi_methods, msi_doc); if (m == NULL) - return; + return; PyModule_AddIntConstant(m, "MSIDBOPEN_CREATEDIRECT", (int)MSIDBOPEN_CREATEDIRECT); PyModule_AddIntConstant(m, "MSIDBOPEN_CREATE", (int)MSIDBOPEN_CREATE); @@ -1046,6 +1046,6 @@ init_msi(void) MSIError = PyErr_NewException ("_msi.MSIError", NULL, NULL); if (!MSIError) - return; + return; PyModule_AddObject(m, "MSIError", MSIError); }