/* static */ PyObject *PyIActiveScript::InterruptScriptThread(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; int id; PyObject *obExcepInfo; int flags; if ( !PyArg_ParseTuple(args, "iOi:InterruptScriptThread", &id, &obExcepInfo, &flags) ) return NULL; IActiveScript *pIAS = GetI(self); if ( pIAS == NULL ) return NULL; EXCEPINFO excepInfo; memset(&excepInfo, 0, sizeof excepInfo); if ( !PyCom_ExcepInfoFromPyObject(obExcepInfo, &excepInfo) ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIAS->InterruptScriptThread((SCRIPTTHREADID)id, &excepInfo, (DWORD)flags); SysFreeString(excepInfo.bstrSource); SysFreeString(excepInfo.bstrDescription); SysFreeString(excepInfo.bstrHelpFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self, hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIDebugApplication|FireDebuggerEvent|Fire a generic event to the IApplicationDebugger (if any) PyObject *PyIDebugApplication::FireDebuggerEvent(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o PyIIID>|guid||A GUID. // @pyparm <o PyIUnknown>|unknown||An unknown object. PyObject *obguid, *obunk; if ( !PyArg_ParseTuple(args, "OO:FireDebuggerEvent", &obguid, &obunk) ) return NULL; BOOL bPythonIsHappy = TRUE; IUnknown *punk; IID iid; if (!PyWinObject_AsIID(obguid, &iid)) bPythonIsHappy = FALSE; if (!PyCom_InterfaceFromPyInstanceOrObject(obunk, IID_IUnknown, (void **)&punk, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->FireDebuggerEvent( iid, punk ); punk->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIDebugDocumentText|GetPositionOfContext|Description of GetPositionOfContext. PyObject *PyIDebugDocumentText::GetPositionOfContext(PyObject *self, PyObject *args) { IDebugDocumentText *pIDDT = GetI(self); if ( pIDDT == NULL ) return NULL; // @pyparm <o PyIDebugDocumentContext>|psc||Description for psc PyObject *obpsc; IDebugDocumentContext *psc; ULONG pcCharacterPosition; ULONG cNumChars; if ( !PyArg_ParseTuple(args, "O:GetPositionOfContext", &obpsc) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_InterfaceFromPyInstanceOrObject(obpsc, IID_IDebugDocumentContext, (void **)&psc, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDDT->GetPositionOfContext( psc, &pcCharacterPosition, &cNumChars ); psc->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); PyObject *pyretval = Py_BuildValue("ii", pcCharacterPosition, cNumChars); return pyretval; }
// @pymethod int|PyIActiveScriptSite|GetItemInfo| PyObject *PyIActiveScriptSite::GetItemInfo(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; PyObject *obName; int mask; IActiveScriptSite *pMySite = GetI(self); if (pMySite==NULL) return NULL; if (!PyArg_ParseTuple(args, "Oi:GetItemInfo", &obName, &mask)) return NULL; OLECHAR *name; if (!PyWinObject_AsWCHAR(obName, &name)) return NULL; IUnknown *punk = NULL; ITypeInfo *ptype = NULL; PY_INTERFACE_PRECALL; SCODE sc = pMySite->GetItemInfo(name, mask, &punk, &ptype); PY_INTERFACE_POSTCALL; PyWinObject_FreeWCHAR(name); if (FAILED(sc)) return SetPythonCOMError(self, sc); PyObject *obDispatch = PyCom_PyObjectFromIUnknown(punk, IID_IUnknown); PyObject *obType = PyCom_PyObjectFromIUnknown(ptype, IID_ITypeInfo); PyObject *rc = NULL; if (obDispatch && obType) rc = Py_BuildValue("OO", obDispatch, obType); Py_XDECREF(obDispatch); Py_XDECREF(obType); return rc; }
// @pymethod |PyIDebugApplication|SynchronousCallInDebuggerThread|Provides a mechanism for the caller to run code in the debugger thread. PyObject *PyIDebugApplication::SynchronousCallInDebuggerThread(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm This is generally // used so that language engines and hosts can implement free threaded objects on top // of their single threaded implementations. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o PyIDebugThreadCall>|pptc||Description for pptc // @pyparm int|dwParam1||Description for dwParam1 // @pyparm int|dwParam2||Description for dwParam2 // @pyparm int|dwParam3||Description for dwParam3 PyObject *obpptc; IDebugThreadCall *pptc; DWORD dwParam1; DWORD dwParam2; DWORD dwParam3; if ( !PyArg_ParseTuple(args, "Oiii:SynchronousCallInDebuggerThread", &obpptc, &dwParam1, &dwParam2, &dwParam3) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_InterfaceFromPyInstanceOrObject(obpptc, IID_IDebugThreadCall, (void **)&pptc, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->SynchronousCallInDebuggerThread( pptc, dwParam1, dwParam2, dwParam3 ); pptc->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod int|PyIDebugApplication|HandleBreakPoint|Called by the language engine in the context of a thread that has hit a breakpoint. PyObject *PyIDebugApplication::HandleBreakPoint(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm This method causes the current thread to block and a notification of the breakpoint // to be sent to the debugger IDE. When the debugger IDE resumes the application this // method returns with the action to be taken. // // Note: While in the breakpoint the language engine may be called in this thread to do // various things such as enumerating stack frames or evaluating expressions. // @rdesc The result is the break resume action - one of the BREAKRESUMEACTION contsants. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm int|br||Break reason - one of the BREAKREASON_* constants. BREAKREASON br; BREAKRESUMEACTION pbra; if ( !PyArg_ParseTuple(args, "i:HandleBreakPoint", &br) ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->HandleBreakPoint( br, &pbra ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); PyObject *pyretval = Py_BuildValue("i", pbra); return pyretval; }
// @pymethod |PyIDebugApplication|DebugOutput|Causes the given string to be displayed by the debugger IDE, normally in an output window. PyObject *PyIDebugApplication::DebugOutput(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm This mechanism provides the means for a language engine to implement language // specific debugging output support. Example: Debug.writeln("Help") in JavaScript. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o unicode>|pstr||Description for pstr PyObject *obpstr; BSTR pstr; if ( !PyArg_ParseTuple(args, "O:DebugOutput", &obpstr) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_BstrFromPyObject(obpstr, &pstr)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->DebugOutput( pstr ); PY_INTERFACE_POSTCALL; if (pstr) SysFreeString(pstr); if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
/* static */ PyObject *PyIActiveScript::GetScriptDispatch(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; PyObject *obItemName = Py_None; if ( !PyArg_ParseTuple(args, "|O:GetScriptDispatch", &obItemName) ) return NULL; IActiveScript *pIAS = GetI(self); if ( pIAS == NULL ) return NULL; BSTR pstrItemName = NULL; if (!PyWinObject_AsBstr(obItemName, &pstrItemName, TRUE)) return NULL; IDispatch *pdisp; PY_INTERFACE_PRECALL; HRESULT hr = pIAS->GetScriptDispatch(pstrItemName, &pdisp); PY_INTERFACE_POSTCALL; PyWinObject_FreeBstr(pstrItemName); if ( FAILED(hr) ) return SetPythonCOMError(self, hr); if ( !pdisp ) { Py_INCREF(Py_None); return Py_None; } return PyCom_PyObjectFromIUnknown((IUnknown *)pdisp, IID_IDispatch, FALSE); }
// @pymethod |PyIMachineDebugManager|AddApplication|Description of AddApplication. PyObject *PyIMachineDebugManager::AddApplication(PyObject *self, PyObject *args) { IMachineDebugManager *pIMDM = GetI(self); if ( pIMDM == NULL ) return NULL; // @pyparm <o PyIRemoteDebugApplication>|pda||Description for pda PyObject *obpda; if ( !PyArg_ParseTuple(args, "O:AddApplication", &obpda) ) return NULL; IRemoteDebugApplication *pda; BOOL bPythonIsHappy = TRUE; if (!PyCom_InterfaceFromPyInstanceOrObject(obpda, IID_IRemoteDebugApplication, (void **)&pda, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; DWORD dwAppCookie; PY_INTERFACE_PRECALL; HRESULT hr = pIMDM->AddApplication( pda, &dwAppCookie ); pda->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); PyObject *pyretval = Py_BuildValue("i", dwAppCookie); return pyretval; }
/* static */ PyObject *PyIActiveScript::AddTypeLib(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; PyObject *obiid; int major; int minor; int flags; if ( !PyArg_ParseTuple(args, "Oiii:AddTypeLib", &obiid, &major, &minor, &flags) ) return NULL; CLSID libiid; if ( !PyWinObject_AsIID(obiid, &libiid) ) return NULL; IActiveScript *pIAS = GetI(self); if ( pIAS == NULL ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIAS->AddTypeLib(libiid, (DWORD)major, (DWORD)minor, (DWORD)flags); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self, hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIDebugApplication|CreateAsyncDebugOperation|Creates an IDebugAsyncOperation object to wrap a provided <o PyIDebugSyncOperation> object. PyObject *PyIDebugApplication::CreateAsyncDebugOperation(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm This provides a mechanism for language engines to implement asynchronous expression and // evaluation, etc. without having to know the details of synchronization with the // debugger thread. See the descriptions for <o PyIDebugSyncOperation> and <o PyIDebugAsyncOperation> // for more details. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o PyIDebugSyncOperation>|psdo||Description for psdo PyObject *obpsdo; IDebugSyncOperation *psdo; IDebugAsyncOperation *ppado; if ( !PyArg_ParseTuple(args, "O:CreateAsyncDebugOperation", &obpsdo) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_InterfaceFromPyInstanceOrObject(obpsdo, IID_IDebugSyncOperation, (void **)&psdo, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->CreateAsyncDebugOperation( psdo, &ppado ); psdo->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(ppado, IID_IDebugAsyncOperation, FALSE); }
// @pymethod |PyIActiveScriptDebug|GetScriptletTextAttributes|Description of GetScriptletTextAttributes. PyObject *PyIActiveScriptDebug::GetScriptletTextAttributes(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; IActiveScriptDebug *pIASD = GetI(self); if ( pIASD == NULL ) return NULL; // @pyparm string|pstrCode||The script block text. // @pyparm string|pstrDelimiter||See <om PyIActiveScriptParse::ParseScriptText> for a description of this argument. // @pyparm int|dwFlags||See <om PyIActiveScriptParse::ParseScriptText> for a description of this argument. DWORD dwFlags; PyObject *obCode, *obDelim; if ( !PyArg_ParseTuple(args, "OOi:GetScriptletTextAttributes", &obCode, &obDelim, &dwFlags) ) return NULL; BOOL bPythonIsHappy = TRUE; WCHAR *pstrDelimiter; BSTR bstr; if (!PyWinObject_AsWCHAR(obDelim, &pstrDelimiter)) bPythonIsHappy = FALSE; if (!PyCom_BstrFromPyObject(obCode, &bstr)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; ULONG uNumCodeChars = SysStringLen(bstr); SOURCE_TEXT_ATTR *pattr = new SOURCE_TEXT_ATTR[uNumCodeChars]; PY_INTERFACE_PRECALL; HRESULT hr = pIASD->GetScriptletTextAttributes( bstr, uNumCodeChars, pstrDelimiter, dwFlags, pattr ); PY_INTERFACE_POSTCALL; SysFreeString(bstr); PyWinObject_FreeWCHAR(pstrDelimiter); if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyAXDebug_PyObject_FromSOURCE_TEXT_ATTR(pattr, uNumCodeChars); }
// @pymethod int|PyIDebugApplication|AddStackFrameSniffer|Adds a stack frame sniffer to this application. PyObject *PyIDebugApplication::AddStackFrameSniffer(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm Generally called by a language engine // to expose its stack frames to the debugger. It is possible for other entities to // expose stack frames. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o PyIDebugStackFrameSniffer>|pdsfs||Description for pdsfs PyObject *obpdsfs; IDebugStackFrameSniffer *pdsfs; DWORD pdwCookie; if ( !PyArg_ParseTuple(args, "O:AddStackFrameSniffer", &obpdsfs) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_InterfaceFromPyInstanceOrObject(obpdsfs, IID_IDebugStackFrameSniffer, (void **)&pdsfs, FALSE /* bNoneOK */)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->AddStackFrameSniffer( pdsfs, &pdwCookie ); pdsfs->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); PyObject *pyretval = Py_BuildValue("i", pdwCookie); return pyretval; // @rdesc The result is an integer cookie, to be passed to <om PyIDebugApplication.RemoveStackFrameSniffer> }
// @pymethod |PyIDebugApplication|SetName|Sets the name of the application. PyObject *PyIDebugApplication::SetName(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm The provided name will be returned in subsequent calls // to >om PyIRemoteDebugApplication.GetName>. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; // @pyparm <o unicode>|pstrName||The name of the application. PyObject *obpstrName; BSTR pstrName; if ( !PyArg_ParseTuple(args, "O:SetName", &obpstrName) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyCom_BstrFromPyObject(obpstrName, &pstrName)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->SetName( pstrName ); PY_INTERFACE_POSTCALL; if (pstrName) SysFreeString(pstrName); if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod int|PyIConnectionPoint|Advise|Establishes a connection between the connection point object and the client's sink. PyObject *PyIConnectionPoint::Advise(PyObject *self, PyObject *args) { PyObject *obUnk; // @pyparm <o PyIUnknown>|unk||The client's advise sink if ( !PyArg_ParseTuple(args, "O:Advise", &obUnk) ) return NULL; IUnknown *pUnk; if (!PyCom_InterfaceFromPyInstanceOrObject(obUnk, IID_IUnknown, (void **)&pUnk, FALSE)) return NULL; IConnectionPoint *pICP = GetI(self); if ( pICP == NULL ) return NULL; DWORD cookie; PY_INTERFACE_PRECALL; HRESULT hr = pICP->Advise( pUnk, &cookie ); pUnk->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); // @rdesc The result is the connection point identifier used by <om PyIConnectionPoint::Unadvise> return PyInt_FromLong(cookie); }
// @pymethod int|PyIActiveScriptSite|OnScriptTerminate| PyObject *PyIActiveScriptSite::OnScriptTerminate(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; PyObject *obResult, *obException; if (!PyArg_ParseTuple(args, "OO:OnScriptTerminate", &obResult, &obException)) return NULL; IActiveScriptSite *pMySite = GetI(self); if (pMySite==NULL) return NULL; VARIANT varResult; VARIANT *pVarResult = NULL; if (obResult!=Py_None) { pVarResult = &varResult; VariantInit(&varResult); if (!PyCom_VariantFromPyObject(obResult, pVarResult)) return NULL; } EXCEPINFO excep; EXCEPINFO *pExcep = NULL; if (obException!=Py_None) { pExcep = &excep; memset(pExcep, 0, sizeof(EXCEPINFO)); if (!PyCom_ExcepInfoFromPyObject(obException, pExcep)) return NULL; } PY_INTERFACE_PRECALL; SCODE sc = pMySite->OnScriptTerminate(pVarResult, pExcep); PY_INTERFACE_POSTCALL; if (pVarResult) VariantClear(pVarResult); if (FAILED(sc)) return SetPythonCOMError(self, sc); return PyInt_FromLong(sc); }
// @pymethod object|PyIEnumDebugStackFrames|Next|Retrieves a specified number of items in the enumeration sequence. PyObject *PyIEnumDebugStackFrames::Next(PyObject *self, PyObject *args) { long celt = 1; // @pyparm int|num|1|Number of items to retrieve. if ( !PyArg_ParseTuple(args, "|l:Next", &celt) ) return NULL; IEnumDebugStackFrames *pIEDebugStackFrames = GetI(self); if ( pIEDebugStackFrames == NULL ) return NULL; DebugStackFrameDescriptor *rgVar = new DebugStackFrameDescriptor [celt]; if ( rgVar == NULL ) { PyErr_SetString(PyExc_MemoryError, "allocating result IDebugStackFrameDescriptor"); return NULL; } int i; /* for ( i = celt; i--; ) // *** possibly init each structure element??? */ ULONG celtFetched = 0; PY_INTERFACE_PRECALL; HRESULT hr = pIEDebugStackFrames->Next(celt, rgVar, &celtFetched); PY_INTERFACE_POSTCALL; if ( HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS && FAILED(hr) ) { delete [] rgVar; return SetPythonCOMError(self,hr); } PyObject *result = PyTuple_New(celtFetched); if ( result != NULL ) { for ( i = celtFetched; i--; ) { // Make a result tuple. PyObject *obFrame = PyCom_PyObjectFromIUnknown(rgVar[i].pdsf, IID_IDebugStackFrame, FALSE); rgVar[i].pdsf = NULL; if ( obFrame == NULL) { Py_DECREF(result); result = NULL; break; } PyObject *obUnkFinal = PyCom_PyObjectFromIUnknown(rgVar[i].punkFinal, IID_IUnknown, TRUE); PyTuple_SET_ITEM(result, i, Py_BuildValue("OiiiO", obFrame, rgVar[i].dwMin, rgVar[i].dwLim, rgVar[i].fFinal, obUnkFinal)); Py_DECREF(obFrame); Py_XDECREF(obUnkFinal); } } for ( i = celtFetched; i--; ) PYCOM_RELEASE(rgVar[i].pdsf); delete [] rgVar; return result; }
// @pymethod object|PyIEnumRemoteDebugApplications|Next|Retrieves a specified number of items in the enumeration sequence. PyObject *PyIEnumRemoteDebugApplications::Next(PyObject *self, PyObject *args) { long celt = 1; // @pyparm int|num|1|Number of items to retrieve. if ( !PyArg_ParseTuple(args, "|l:Next", &celt) ) return NULL; IEnumRemoteDebugApplications *pIERemoteDebugApplications = GetI(self); if ( pIERemoteDebugApplications == NULL ) return NULL; IRemoteDebugApplication **rgVar = new IRemoteDebugApplication *[celt]; if ( rgVar == NULL ) { PyErr_SetString(PyExc_MemoryError, "allocating result IRemoteDebugApplications"); return NULL; } int i; /* for ( i = celt; i--; ) // *** possibly init each structure element??? */ ULONG celtFetched = 0; PY_INTERFACE_PRECALL; HRESULT hr = pIERemoteDebugApplications->Next(celt, rgVar, &celtFetched); PY_INTERFACE_POSTCALL; if ( HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS && FAILED(hr) ) { delete [] rgVar; return SetPythonCOMError(self,hr); } PyObject *result = PyTuple_New(celtFetched); if ( result != NULL ) { for ( i = celtFetched; i--; ) { PyObject *ob = PyCom_PyObjectFromIUnknown(rgVar[i], IID_IRemoteDebugApplication, FALSE); if ( ob == NULL ) { Py_DECREF(result); result = NULL; break; } PyTuple_SET_ITEM(result, i, ob); } } /* for ( i = celtFetched; i--; ) // *** possibly cleanup each structure element??? */ delete [] rgVar; return result; }
/* static */ PyObject *PyIActiveScript::SetScriptSite(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; PyObject *obSite; if ( !PyArg_ParseTuple(args, "O:SetScriptSite", &obSite) ) return NULL; IActiveScript *pIAS = GetI(self); if ( pIAS == NULL ) return NULL; if ( !PyIBase::is_object(obSite, &PyIUnknown::type) ) { PyErr_SetString(PyExc_ValueError, "argument is not a site"); return NULL; } IUnknown *punk = PyIUnknown::GetI(obSite); if ( !punk ) return NULL; /* exception was set by GetI() */ /* note: we don't explicitly hold a reference to punk */ IActiveScriptSite *pIASS; HRESULT hr; Py_BEGIN_ALLOW_THREADS hr = punk->QueryInterface(IID_IActiveScriptSite, (LPVOID*)&pIASS); Py_END_ALLOW_THREADS if ( FAILED(hr) ) return SetPythonCOMError(self, hr); PY_INTERFACE_PRECALL; hr = pIAS->SetScriptSite(pIASS); pIASS->Release(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self, hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIDebugStackFrame|GetCodeContext|Returns the current code context associated with the stack frame. PyObject *PyIDebugStackFrame::GetCodeContext(PyObject *self, PyObject *args) { IDebugStackFrame *pIDSF = GetI(self); if ( pIDSF == NULL ) return NULL; IDebugCodeContext *ppcc; if ( !PyArg_ParseTuple(args, ":GetCodeContext") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDSF->GetCodeContext( &ppcc ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(ppcc, IID_IDebugCodeContext, FALSE); }
// @pymethod <o PyIDebugApplicationThread>|PyIDebugStackFrame|GetThread|Returns the thread associated with this stack frame. PyObject *PyIDebugStackFrame::GetThread(PyObject *self, PyObject *args) { IDebugStackFrame *pIDSF = GetI(self); if ( pIDSF == NULL ) return NULL; IDebugApplicationThread *ppat; if ( !PyArg_ParseTuple(args, ":GetThread") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDSF->GetThread( &ppat ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(ppat, IID_IDebugApplicationThread, FALSE); }
// @pymethod <o PyIDebugProperty>|PyIDebugStackFrame|GetDebugProperty|Returns the debug property. PyObject *PyIDebugStackFrame::GetDebugProperty(PyObject *self, PyObject *args) { IDebugStackFrame *pIDSF = GetI(self); if ( pIDSF == NULL ) return NULL; IDebugProperty *ppdp; if ( !PyArg_ParseTuple(args, ":GetDebugProperty") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDSF->GetDebugProperty( &ppdp ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(ppdp, IID_IDebugProperty, FALSE); }
// @pymethod |PyIDispatchEx|DeleteMemberByDispID| PyObject *PyIDispatchEx::DeleteMemberByDispID(PyObject *self, PyObject *args) { long dispid; if (!PyArg_ParseTuple(args, "ll:DeleteMemberByDispID", &dispid)) // @pyparm int|dispid|| return NULL; IDispatchEx *pMyDispatchEx = GetI(self); if (pMyDispatchEx==NULL) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pMyDispatchEx->DeleteMemberByDispID((DISPID)dispid); PY_INTERFACE_POSTCALL; if (FAILED(hr)) return SetPythonCOMError(self, hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod str|PyIDispatchEx|GetMemberName|Returns the name associated with a member id PyObject *PyIDispatchEx::GetMemberName(PyObject *self, PyObject *args) { long dispid; BSTR name; if (!PyArg_ParseTuple(args, "l:GetMemberName", &dispid)) // @pyparm int|dispid||The member id return NULL; IDispatchEx *pMyDispatchEx = GetI(self); if (pMyDispatchEx==NULL) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pMyDispatchEx->GetMemberName(dispid, &name); PY_INTERFACE_POSTCALL; if (FAILED(hr)) return SetPythonCOMError(self, hr); return PyWinObject_FromBstr(name, TRUE); }
// @pymethod |PyIDebugExpression|QueryIsComplete|Description of QueryIsComplete. PyObject *PyIDebugExpression::QueryIsComplete(PyObject *self, PyObject *args) { IDebugExpression *pIDE = GetI(self); if ( pIDE == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":QueryIsComplete") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDE->QueryIsComplete( ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod <o PyIDebugApplicationThread>|PyIDebugApplication|GetCurrentThread|Returns the application thread object associated with the currently running thread. PyObject *PyIDebugApplication::GetCurrentThread(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; IDebugApplicationThread *pat; if ( !PyArg_ParseTuple(args, ":GetCurrentThread") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->GetCurrentThread( &pat ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(pat, IID_IDebugApplicationThread, FALSE); }
// @pymethod |PyIActiveScriptSiteDebug|GetRootApplicationNode|Description of GetRootApplicationNode. PyObject *PyIActiveScriptSiteDebug::GetRootApplicationNode(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; IActiveScriptSiteDebug *pIASSD = GetI(self); if ( pIASSD == NULL ) return NULL; IDebugApplicationNode *ppdan; if ( !PyArg_ParseTuple(args, ":GetRootApplicationNode") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIASSD->GetRootApplicationNode( &ppdan ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyCom_PyObjectFromIUnknown(ppdan, IID_IDebugApplicationNode, FALSE); }
// @pymethod int|PyIActiveScriptSite|GetLCID| PyObject *PyIActiveScriptSite::GetLCID(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; if (!PyArg_ParseTuple(args, ":GetLCID")) return NULL; IActiveScriptSite *pMySite = GetI(self); if (pMySite==NULL) return NULL; unsigned long lcid; PY_INTERFACE_PRECALL; SCODE sc = pMySite->GetLCID(&lcid); PY_INTERFACE_POSTCALL; if (FAILED(sc)) return SetPythonCOMError(self, sc); return PyInt_FromLong(lcid); }
// @pymethod |PyIDebugApplication|Close|Causes this application to release all references and enter a zombie state. PyObject *PyIDebugApplication::Close(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; // @comm Called by the owner of the application generally on shut down. IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":Close") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->Close( ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIDebugApplication|QueryCurrentThreadIsDebuggerThread|Determines if the current running thread is the debugger thread. PyObject *PyIDebugApplication::QueryCurrentThreadIsDebuggerThread(PyObject *self, PyObject *args) { PY_INTERFACE_METHOD; IDebugApplication *pIDA = GetI(self); if ( pIDA == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":QueryCurrentThreadIsDebuggerThread") ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIDA->QueryCurrentThreadIsDebuggerThread( ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return SetPythonCOMError(self,hr); return PyInt_FromLong(hr); // @rdesc Returns S_OK if the current running thread is the debugger thread. // Otherwise, returns S_FALSE. }