ALINA_KURBANOVA/AIM-PIbd-32-Kurbanova-A-A
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d82b74e2e8
AIM-PIbd-32-Kurbanova-A-A/aimenv/Lib/site-packages/win32comext/axscript/client/framework.py

1271 lines
44 KiB
Python
Raw Normal View History

lab 1 is done
2024-10-02 22:15:59 +04:00
"""AXScript Client Framework
This module provides a core framework for an ActiveX Scripting client.
Derived classes actually implement the AX Client itself, including the
scoping rules, etc.
There are classes defined for the engine itself, and for ScriptItems
"""
import re
import sys
import pythoncom # Need simple connection point support
import win32api
import win32com.client.connect
import win32com.server.util
import winerror
from win32com.axscript import axscript
def RemoveCR(text):
# No longer just "RemoveCR" - should be renamed to
# FixNewlines, or something. Idea is to fix arbitary newlines into
# something Python can compile...
return re.sub("(\r\n)|\r|(\n\r)", "\n", text)
SCRIPTTEXT_FORCEEXECUTION = -2147483648 # 0x80000000
SCRIPTTEXT_ISEXPRESSION = 0x00000020
SCRIPTTEXT_ISPERSISTENT = 0x00000040
from win32com.server.exception import Exception, IsCOMServerException
from . import error # ax.client.error
state_map = {
axscript.SCRIPTSTATE_UNINITIALIZED: "SCRIPTSTATE_UNINITIALIZED",
axscript.SCRIPTSTATE_INITIALIZED: "SCRIPTSTATE_INITIALIZED",
axscript.SCRIPTSTATE_STARTED: "SCRIPTSTATE_STARTED",
axscript.SCRIPTSTATE_CONNECTED: "SCRIPTSTATE_CONNECTED",
axscript.SCRIPTSTATE_DISCONNECTED: "SCRIPTSTATE_DISCONNECTED",
axscript.SCRIPTSTATE_CLOSED: "SCRIPTSTATE_CLOSED",
}
def profile(fn, *args):
import profile
prof = profile.Profile()
try:
# roll on 1.6 :-)
# return prof.runcall(fn, *args)
return prof.runcall(*(fn,) + args)
finally:
import pstats
# Damn - really want to send this to Excel!
# width, list = pstats.Stats(prof).strip_dirs().get_print_list([])
pstats.Stats(prof).strip_dirs().sort_stats("time").print_stats()
class SafeOutput:
softspace = 1
def __init__(self, redir=None):
if redir is None:
redir = sys.stdout
self.redir = redir
def write(self, message):
try:
self.redir.write(message)
except:
win32api.OutputDebugString(message)
def flush(self):
pass
def close(self):
pass
# Make sure we have a valid sys.stdout/stderr, otherwise out
# print and trace statements may raise an exception
def MakeValidSysOuts():
if not isinstance(sys.stdout, SafeOutput):
sys.stdout = sys.stderr = SafeOutput()
# and for the sake of working around something I can't understand...
# prevent keyboard interrupts from killing IIS
import signal
def noOp(a, b):
# it would be nice to get to the bottom of this, so a warning to
# the debug console can't hurt.
print("WARNING: Ignoring keyboard interrupt from ActiveScripting engine")
# If someone else has already redirected, then assume they know what they are doing!
if signal.getsignal(signal.SIGINT) == signal.default_int_handler:
try:
signal.signal(signal.SIGINT, noOp)
except ValueError:
# Not the main thread - can't do much.
pass
def trace(*args):
"""A function used instead of "print" for debugging output."""
for arg in args:
print(arg, end=" ")
print()
def RaiseAssert(scode, desc):
"""A debugging function that raises an exception considered an "Assertion"."""
print("**************** ASSERTION FAILED *******************")
print(desc)
raise Exception(desc, scode)
class AXScriptCodeBlock:
"""An object which represents a chunk of code in an AX Script"""
def __init__(self, name, codeText, sourceContextCookie, startLineNumber, flags):
self.name = name
self.codeText = codeText
self.codeObject = None
self.sourceContextCookie = sourceContextCookie
self.startLineNumber = startLineNumber
self.flags = flags
self.beenExecuted = 0
def GetFileName(self):
# Gets the "file name" for Python - uses <...> so Python doesnt think
# it is a real file.
return "<%s>" % self.name
def GetDisplayName(self):
return self.name
def GetLineNo(self, no):
pos = -1
for i in range(no - 1):
pos = self.codeText.find("\n", pos + 1)
if pos == -1:
pos = len(self.codeText)
epos = self.codeText.find("\n", pos + 1)
if epos == -1:
epos = len(self.codeText)
return self.codeText[pos + 1 : epos].strip()
class Event:
"""A single event for a ActiveX named object."""
def __init__(self):
self.name = "<None>"
def __repr__(self):
return "<%s at %d: %s>" % (self.__class__.__name__, id(self), self.name)
def Reset(self):
pass
def Close(self):
pass
def Build(self, typeinfo, funcdesc):
self.dispid = funcdesc[0]
self.name = typeinfo.GetNames(self.dispid)[0]
# print "Event.Build() - Event Name is ", self.name
class EventSink:
"""A set of events against an item. Note this is a COM client for connection points."""
_public_methods_ = []
def __init__(self, myItem, coDispatch):
self.events = {}
self.connection = None
self.coDispatch = coDispatch
self.myScriptItem = myItem
self.myInvokeMethod = myItem.GetEngine().ProcessScriptItemEvent
self.iid = None
def Reset(self):
self.Disconnect()
def Close(self):
self.iid = None
self.myScriptItem = None
self.myInvokeMethod = None
self.coDispatch = None
for event in self.events.values():
event.Reset()
self.events = {}
self.Disconnect()
# COM Connection point methods.
def _query_interface_(self, iid):
if iid == self.iid:
return win32com.server.util.wrap(self)
def _invoke_(self, dispid, lcid, wFlags, args):
try:
event = self.events[dispid]
except:
raise Exception(scode=winerror.DISP_E_MEMBERNOTFOUND)
# print "Invoke for ", event, "on", self.myScriptItem, " - calling", self.myInvokeMethod
return self.myInvokeMethod(self.myScriptItem, event, lcid, wFlags, args)
def GetSourceTypeInfo(self, typeinfo):
"""Gets the typeinfo for the Source Events for the passed typeinfo"""
attr = typeinfo.GetTypeAttr()
cFuncs = attr[6]
typeKind = attr[5]
if typeKind not in [pythoncom.TKIND_COCLASS, pythoncom.TKIND_INTERFACE]:
RaiseAssert(
winerror.E_UNEXPECTED, "The typeKind of the object is unexpected"
)
cImplType = attr[8]
for i in range(cImplType):
# Look for the [source, default] interface on the coclass
# that isn't marked as restricted.
flags = typeinfo.GetImplTypeFlags(i)
flagsNeeded = (
pythoncom.IMPLTYPEFLAG_FDEFAULT | pythoncom.IMPLTYPEFLAG_FSOURCE
)
if (flags & (flagsNeeded | pythoncom.IMPLTYPEFLAG_FRESTRICTED)) == (
flagsNeeded
):
# Get the handle to the implemented interface.
href = typeinfo.GetRefTypeOfImplType(i)
return typeinfo.GetRefTypeInfo(href)
def BuildEvents(self):
# See if it is an extender object.
try:
mainTypeInfo = self.coDispatch.QueryInterface(
axscript.IID_IProvideMultipleClassInfo
)
isMulti = 1
numTypeInfos = mainTypeInfo.GetMultiTypeInfoCount()
except pythoncom.com_error:
isMulti = 0
numTypeInfos = 1
try:
mainTypeInfo = self.coDispatch.QueryInterface(
pythoncom.IID_IProvideClassInfo
)
except pythoncom.com_error:
numTypeInfos = 0
# Create an event handler for the item.
for item in range(numTypeInfos):
if isMulti:
typeinfo, flags = mainTypeInfo.GetInfoOfIndex(
item, axscript.MULTICLASSINFO_GETTYPEINFO
)
else:
typeinfo = mainTypeInfo.GetClassInfo()
sourceType = self.GetSourceTypeInfo(typeinfo)
cFuncs = 0
if sourceType:
attr = sourceType.GetTypeAttr()
self.iid = attr[0]
cFuncs = attr[6]
for i in range(cFuncs):
funcdesc = sourceType.GetFuncDesc(i)
event = Event()
event.Build(sourceType, funcdesc)
self.events[event.dispid] = event
def Connect(self):
if self.connection is not None or self.iid is None:
return
# trace("Connect for sink item", self.myScriptItem.name, "with IID",str(self.iid))
self.connection = win32com.client.connect.SimpleConnection(
self.coDispatch, self, self.iid
)
def Disconnect(self):
if self.connection:
try:
self.connection.Disconnect()
except pythoncom.com_error:
pass # Ignore disconnection errors.
self.connection = None
class ScriptItem:
"""An item (or subitem) that is exposed to the ActiveX script"""
def __init__(self, parentItem, name, dispatch, flags):
self.parentItem = parentItem
self.dispatch = dispatch
self.name = name
self.flags = flags
self.eventSink = None
self.subItems = {}
self.createdConnections = 0
self.isRegistered = 0
# trace("Creating ScriptItem", name, "of parent", parentItem,"with dispatch", dispatch)
def __repr__(self):
flagsDesc = ""
if self.flags is not None and self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS:
flagsDesc = "/Global"
return "<%s at %d: %s%s>" % (
self.__class__.__name__,
id(self),
self.name,
flagsDesc,
)
def _dump_(self, level):
flagDescs = []
if self.flags is not None and self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS:
flagDescs.append("GLOBAL!")
if self.flags is None or self.flags & axscript.SCRIPTITEM_ISVISIBLE == 0:
flagDescs.append("NOT VISIBLE")
if self.flags is not None and self.flags & axscript.SCRIPTITEM_ISSOURCE:
flagDescs.append("EVENT SINK")
if self.flags is not None and self.flags & axscript.SCRIPTITEM_CODEONLY:
flagDescs.append("CODE ONLY")
print(" " * level, "Name=", self.name, ", flags=", "/".join(flagDescs), self)
for subItem in self.subItems.values():
subItem._dump_(level + 1)
def Reset(self):
self.Disconnect()
if self.eventSink:
self.eventSink.Reset()
self.isRegistered = 0
for subItem in self.subItems.values():
subItem.Reset()
def Close(self):
self.Reset()
self.dispatch = None
self.parentItem = None
if self.eventSink:
self.eventSink.Close()
self.eventSink = None
for subItem in self.subItems.values():
subItem.Close()
self.subItems = []
self.createdConnections = 0
def Register(self):
if self.isRegistered:
return
# Get the type info to use to build this item.
# if not self.dispatch:
# id = self.parentItem.dispatch.GetIDsOfNames(self.name)
# print "DispID of me is", id
# result = self.parentItem.dispatch.Invoke(id, 0, pythoncom.DISPATCH_PROPERTYGET,1)
# if type(result)==pythoncom.TypeIIDs[pythoncom.IID_IDispatch]:
# self.dispatch = result
# else:
# print "*** No dispatch"
# return
# print "**** Made dispatch"
self.isRegistered = 1
# Register the sub-items.
for item in self.subItems.values():
if not item.isRegistered:
item.Register()
def IsGlobal(self):
return self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS
def IsVisible(self):
return (
self.flags & (axscript.SCRIPTITEM_ISVISIBLE | axscript.SCRIPTITEM_ISSOURCE)
) != 0
def GetEngine(self):
item = self
while item.parentItem.__class__ == self.__class__:
item = item.parentItem
return item.parentItem
def _GetFullItemName(self):
ret = self.name
if self.parentItem:
try:
ret = self.parentItem._GetFullItemName() + "." + ret
except AttributeError:
pass
return ret
def GetSubItemClass(self):
return self.__class__
def GetSubItem(self, name):
return self.subItems[name.lower()]
def GetCreateSubItem(self, parentItem, name, dispatch, flags):
keyName = name.lower()
try:
rc = self.subItems[keyName]
# No changes allowed to existing flags.
if not rc.flags is None and not flags is None and rc.flags != flags:
raise Exception(scode=winerror.E_INVALIDARG)
# Existing item must not have a dispatch.
if not rc.dispatch is None and not dispatch is None:
raise Exception(scode=winerror.E_INVALIDARG)
rc.flags = flags # Setup the real flags.
rc.dispatch = dispatch
except KeyError:
rc = self.subItems[keyName] = self.GetSubItemClass()(
parentItem, name, dispatch, flags
)
return rc
# if self.dispatch is None:
# RaiseAssert(winerror.E_UNEXPECTED, "??")
def CreateConnections(self):
# Create (but do not connect to) the connection points.
if self.createdConnections:
return
self.createdConnections = 1
# Nothing to do unless this is an event source
# This flags means self, _and_ children, are connectable.
if self.flags & axscript.SCRIPTITEM_ISSOURCE:
self.BuildEvents()
self.FindBuildSubItemEvents()
def Connect(self):
# Connect to the already created connection points.
if self.eventSink:
self.eventSink.Connect()
for subItem in self.subItems.values():
subItem.Connect()
def Disconnect(self):
# Disconnect from the connection points.
if self.eventSink:
self.eventSink.Disconnect()
for subItem in self.subItems.values():
subItem.Disconnect()
def BuildEvents(self):
if self.eventSink is not None or self.dispatch is None:
RaiseAssert(
winerror.E_UNEXPECTED,
"Item already has built events, or no dispatch available?",
)
# trace("BuildEvents for named item", self._GetFullItemName())
self.eventSink = EventSink(self, self.dispatch)
self.eventSink.BuildEvents()
def FindBuildSubItemEvents(self):
# Called during connection to event source. Seeks out and connects to
# all children. As per the AX spec, this is not recursive
# (ie, children sub-items are not seeked)
try:
multiTypeInfo = self.dispatch.QueryInterface(
axscript.IID_IProvideMultipleClassInfo
)
numTypeInfos = multiTypeInfo.GetMultiTypeInfoCount()
except pythoncom.com_error:
return
for item in range(numTypeInfos):
typeinfo, flags = multiTypeInfo.GetInfoOfIndex(
item, axscript.MULTICLASSINFO_GETTYPEINFO
)
defaultType = self.GetDefaultSourceTypeInfo(typeinfo)
index = 0
while 1:
try:
fdesc = defaultType.GetFuncDesc(index)
except pythoncom.com_error:
break # No more funcs
index = index + 1
dispid = fdesc[0]
funckind = fdesc[3]
invkind = fdesc[4]
elemdesc = fdesc[8]
funcflags = fdesc[9]
try:
isSubObject = (
not (funcflags & pythoncom.FUNCFLAG_FRESTRICTED)
and funckind == pythoncom.FUNC_DISPATCH
and invkind == pythoncom.INVOKE_PROPERTYGET
and elemdesc[0][0] == pythoncom.VT_PTR
and elemdesc[0][1][0] == pythoncom.VT_USERDEFINED
)
except:
isSubObject = 0
if isSubObject:
try:
# We found a sub-object.
names = typeinfo.GetNames(dispid)
result = self.dispatch.Invoke(
dispid, 0x0, pythoncom.DISPATCH_PROPERTYGET, 1
)
# IE has an interesting problem - there are lots of synonyms for the same object. Eg
# in a simple form, "window.top", "window.window", "window.parent", "window.self"
# all refer to the same object. Our event implementation code does not differentiate
# eg, "window_onload" will fire for *all* objects named "window". Thus,
# "window" and "window.window" will fire the same event handler :(
# One option would be to check if the sub-object is indeed the
# parent object - however, this would stop "top_onload" from firing,
# as no event handler for "top" would work.
# I think we simply need to connect to a *single* event handler.
# As use in IE is deprecated, I am not solving this now.
if type(result) == pythoncom.TypeIIDs[pythoncom.IID_IDispatch]:
name = names[0]
subObj = self.GetCreateSubItem(
self, name, result, axscript.SCRIPTITEM_ISVISIBLE
)
# print "subobj", name, "flags are", subObj.flags, "mydisp=", self.dispatch, "result disp=", result, "compare=", self.dispatch==result
subObj.BuildEvents()
subObj.Register()
except pythoncom.com_error:
pass
def GetDefaultSourceTypeInfo(self, typeinfo):
"""Gets the typeinfo for the Default Dispatch for the passed typeinfo"""
attr = typeinfo.GetTypeAttr()
cFuncs = attr[6]
typeKind = attr[5]
if typeKind not in [pythoncom.TKIND_COCLASS, pythoncom.TKIND_INTERFACE]:
RaiseAssert(
winerror.E_UNEXPECTED, "The typeKind of the object is unexpected"
)
cImplType = attr[8]
for i in range(cImplType):
# Look for the [source, default] interface on the coclass
# that isn't marked as restricted.
flags = typeinfo.GetImplTypeFlags(i)
if (
flags
& (
pythoncom.IMPLTYPEFLAG_FDEFAULT
| pythoncom.IMPLTYPEFLAG_FSOURCE
| pythoncom.IMPLTYPEFLAG_FRESTRICTED
)
) == pythoncom.IMPLTYPEFLAG_FDEFAULT:
# Get the handle to the implemented interface.
href = typeinfo.GetRefTypeOfImplType(i)
defTypeInfo = typeinfo.GetRefTypeInfo(href)
attr = defTypeInfo.GetTypeAttr()
typeKind = attr[5]
typeFlags = attr[11]
if (
typeKind == pythoncom.TKIND_INTERFACE
and typeFlags & pythoncom.TYPEFLAG_FDUAL
):
# Get corresponding Disp interface
# -1 is a special value which does this for us.
href = typeinfo.GetRefTypeOfImplType(-1)
return defTypeInfo.GetRefTypeInfo(href)
else:
return defTypeInfo
IActiveScriptMethods = [
"SetScriptSite",
"GetScriptSite",
"SetScriptState",
"GetScriptState",
"Close",
"AddNamedItem",
"AddTypeLib",
"GetScriptDispatch",
"GetCurrentScriptThreadID",
"GetScriptThreadID",
"GetScriptThreadState",
"InterruptScriptThread",
"Clone",
]
IActiveScriptParseMethods = ["InitNew", "AddScriptlet", "ParseScriptText"]
IObjectSafetyMethods = ["GetInterfaceSafetyOptions", "SetInterfaceSafetyOptions"]
# ActiveScriptParseProcedure is a new interface with IIS4/IE4.
IActiveScriptParseProcedureMethods = ["ParseProcedureText"]
class COMScript:
"""An ActiveX Scripting engine base class.
This class implements the required COM interfaces for ActiveX scripting.
"""
_public_methods_ = (
IActiveScriptMethods
+ IActiveScriptParseMethods
+ IObjectSafetyMethods
+ IActiveScriptParseProcedureMethods
)
_com_interfaces_ = [
axscript.IID_IActiveScript,
axscript.IID_IActiveScriptParse,
axscript.IID_IObjectSafety,
] # , axscript.IID_IActiveScriptParseProcedure]
def __init__(self):
# Make sure we can print/trace wihout an exception!
MakeValidSysOuts()
# trace("AXScriptEngine object created", self)
self.baseThreadId = -1
self.debugManager = None
self.threadState = axscript.SCRIPTTHREADSTATE_NOTINSCRIPT
self.scriptState = axscript.SCRIPTSTATE_UNINITIALIZED
self.scriptSite = None
self.safetyOptions = 0
self.lcid = 0
self.subItems = {}
self.scriptCodeBlocks = {}
def _query_interface_(self, iid):
if self.debugManager:
return self.debugManager._query_interface_for_debugger_(iid)
# trace("ScriptEngine QI - unknown IID", iid)
return 0
# IActiveScriptParse
def InitNew(self):
if self.scriptSite is not None:
self.SetScriptState(axscript.SCRIPTSTATE_INITIALIZED)
def AddScriptlet(
self,
defaultName,
code,
itemName,
subItemName,
eventName,
delimiter,
sourceContextCookie,
startLineNumber,
):
# trace ("AddScriptlet", defaultName, code, itemName, subItemName, eventName, delimiter, sourceContextCookie, startLineNumber)
self.DoAddScriptlet(
defaultName,
code,
itemName,
subItemName,
eventName,
delimiter,
sourceContextCookie,
startLineNumber,
)
def ParseScriptText(
self,
code,
itemName,
context,
delimiter,
sourceContextCookie,
startLineNumber,
flags,
bWantResult,
):
# trace ("ParseScriptText", code[:20],"...", itemName, context, delimiter, sourceContextCookie, startLineNumber, flags, bWantResult)
if (
bWantResult
or self.scriptState == axscript.SCRIPTSTATE_STARTED
or self.scriptState == axscript.SCRIPTSTATE_CONNECTED
or self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED
):
flags = flags | SCRIPTTEXT_FORCEEXECUTION
else:
flags = flags & (~SCRIPTTEXT_FORCEEXECUTION)
if flags & SCRIPTTEXT_FORCEEXECUTION:
# About to execute the code.
self.RegisterNewNamedItems()
return self.DoParseScriptText(
code, sourceContextCookie, startLineNumber, bWantResult, flags
)
#
# IActiveScriptParseProcedure
def ParseProcedureText(
self,
code,
formalParams,
procName,
itemName,
unkContext,
delimiter,
contextCookie,
startingLineNumber,
flags,
):
trace(
"ParseProcedureText",
code,
formalParams,
procName,
itemName,
unkContext,
delimiter,
contextCookie,
startingLineNumber,
flags,
)
# NOTE - this is never called, as we have disabled this interface.
# Problem is, once enabled all even code comes via here, rather than AddScriptlet.
# However, the "procName" is always an empty string - ie, itemName is the object whose event we are handling,
# but no idea what the specific event is!?
# Problem is disabling this block is that AddScriptlet is _not_ passed
# <SCRIPT for="whatever" event="onClick" language="Python">
# (but even for those blocks, the "onClick" information is still missing!?!?!?)
# self.DoAddScriptlet(None, code, itemName, subItemName, eventName, delimiter,sourceContextCookie, startLineNumber)
return None
#
# IActiveScript
def SetScriptSite(self, site):
# We should still work with an existing site (or so MSXML believes :)
self.scriptSite = site
if self.debugManager is not None:
self.debugManager.Close()
import traceback
try:
import win32com.axdebug.axdebug # see if the core exists.
from . import debug
self.debugManager = debug.DebugManager(self)
except pythoncom.com_error:
# COM errors will occur if the debugger interface has never been
# seen on the target system
trace("Debugging interfaces not available - debugging is disabled..")
self.debugManager = None
except ImportError:
trace(
"Debugging extensions (axdebug) module does not exist - debugging is disabled.."
)
self.debugManager = None
except:
traceback.print_exc()
trace(
"*** Debugger Manager could not initialize - %s: %s"
% (sys.exc_info()[0], sys.exc_info()[1])
)
self.debugManager = None
try:
self.lcid = site.GetLCID()
except pythoncom.com_error:
self.lcid = win32api.GetUserDefaultLCID()
self.Reset()
def GetScriptSite(self, iid):
if self.scriptSite is None:
raise Exception(scode=winerror.S_FALSE)
return self.scriptSite.QueryInterface(iid)
def SetScriptState(self, state):
# print "SetScriptState with %s - currentstate = %s" % (state_map.get(state),state_map.get(self.scriptState))
if state == self.scriptState:
return
# If closed, allow no other state transitions
if self.scriptState == axscript.SCRIPTSTATE_CLOSED:
raise Exception(scode=winerror.E_INVALIDARG)
if state == axscript.SCRIPTSTATE_INITIALIZED:
# Re-initialize - shutdown then reset.
if self.scriptState in [
axscript.SCRIPTSTATE_CONNECTED,
axscript.SCRIPTSTATE_STARTED,
]:
self.Stop()
elif state == axscript.SCRIPTSTATE_STARTED:
if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
self.Disconnect()
if self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED:
self.Reset()
self.Run()
self.ChangeScriptState(axscript.SCRIPTSTATE_STARTED)
elif state == axscript.SCRIPTSTATE_CONNECTED:
if self.scriptState in [
axscript.SCRIPTSTATE_UNINITIALIZED,
axscript.SCRIPTSTATE_INITIALIZED,
]:
self.ChangeScriptState(
axscript.SCRIPTSTATE_STARTED
) # report transition through started
self.Run()
if self.scriptState == axscript.SCRIPTSTATE_STARTED:
self.Connect()
self.ChangeScriptState(state)
elif state == axscript.SCRIPTSTATE_DISCONNECTED:
if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
self.Disconnect()
elif state == axscript.SCRIPTSTATE_CLOSED:
self.Close()
elif state == axscript.SCRIPTSTATE_UNINITIALIZED:
if self.scriptState == axscript.SCRIPTSTATE_STARTED:
self.Stop()
if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
self.Disconnect()
if self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED:
self.Reset()
self.ChangeScriptState(state)
else:
raise Exception(scode=winerror.E_INVALIDARG)
def GetScriptState(self):
return self.scriptState
def Close(self):
# trace("Close")
if self.scriptState in [
axscript.SCRIPTSTATE_CONNECTED,
axscript.SCRIPTSTATE_DISCONNECTED,
]:
self.Stop()
if self.scriptState in [
axscript.SCRIPTSTATE_CONNECTED,
axscript.SCRIPTSTATE_DISCONNECTED,
axscript.SCRIPTSTATE_INITIALIZED,
axscript.SCRIPTSTATE_STARTED,
]:
pass # engine.close??
if self.scriptState in [
axscript.SCRIPTSTATE_UNINITIALIZED,
axscript.SCRIPTSTATE_CONNECTED,
axscript.SCRIPTSTATE_DISCONNECTED,
axscript.SCRIPTSTATE_INITIALIZED,
axscript.SCRIPTSTATE_STARTED,
]:
self.ChangeScriptState(axscript.SCRIPTSTATE_CLOSED)
# Completely reset all named items (including persistent)
for item in self.subItems.values():
item.Close()
self.subItems = {}
self.baseThreadId = -1
if self.debugManager:
self.debugManager.Close()
self.debugManager = None
self.scriptSite = None
self.scriptCodeBlocks = {}
self.persistLoaded = 0
def AddNamedItem(self, name, flags):
if self.scriptSite is None:
raise Exception(scode=winerror.E_INVALIDARG)
try:
unknown = self.scriptSite.GetItemInfo(name, axscript.SCRIPTINFO_IUNKNOWN)[0]
dispatch = unknown.QueryInterface(pythoncom.IID_IDispatch)
except pythoncom.com_error:
raise Exception(
scode=winerror.E_NOINTERFACE,
desc="Object has no dispatch interface available.",
)
newItem = self.subItems[name] = self.GetNamedItemClass()(
self, name, dispatch, flags
)
if newItem.IsGlobal():
newItem.CreateConnections()
def GetScriptDispatch(self, name):
# Base classes should override.
raise Exception(scode=winerror.E_NOTIMPL)
def GetCurrentScriptThreadID(self):
return self.baseThreadId
def GetScriptThreadID(self, win32ThreadId):
if self.baseThreadId == -1:
raise Exception(scode=winerror.E_UNEXPECTED)
if self.baseThreadId != win32ThreadId:
raise Exception(scode=winerror.E_INVALIDARG)
return self.baseThreadId
def GetScriptThreadState(self, scriptThreadId):
if self.baseThreadId == -1:
raise Exception(scode=winerror.E_UNEXPECTED)
if scriptThreadId != self.baseThreadId:
raise Exception(scode=winerror.E_INVALIDARG)
return self.threadState
def AddTypeLib(self, uuid, major, minor, flags):
# Get the win32com gencache to register this library.
from win32com.client import gencache
gencache.EnsureModule(uuid, self.lcid, major, minor, bForDemand=1)
# This is never called by the C++ framework - it does magic.
# See PyGActiveScript.cpp
# def InterruptScriptThread(self, stidThread, exc_info, flags):
# raise Exception("Not Implemented", scode=winerror.E_NOTIMPL)
def Clone(self):
raise Exception("Not Implemented", scode=winerror.E_NOTIMPL)
#
# IObjectSafety
# Note that IE seems to insist we say we support all the flags, even tho
# we dont accept them all. If unknown flags come in, they are ignored, and never
# reflected in GetInterfaceSafetyOptions and the QIs obviously fail, but still IE
# allows our engine to initialize.
def SetInterfaceSafetyOptions(self, iid, optionsMask, enabledOptions):
# trace ("SetInterfaceSafetyOptions", iid, optionsMask, enabledOptions)
if optionsMask & enabledOptions == 0:
return
# See comments above.
# if (optionsMask & enabledOptions & \
# ~(axscript.INTERFACESAFE_FOR_UNTRUSTED_DATA | axscript.INTERFACESAFE_FOR_UNTRUSTED_CALLER)):
# # request for options we don't understand
# RaiseAssert(scode=winerror.E_FAIL, desc="Unknown safety options")
if iid in [
pythoncom.IID_IPersist,
pythoncom.IID_IPersistStream,
pythoncom.IID_IPersistStreamInit,
axscript.IID_IActiveScript,
axscript.IID_IActiveScriptParse,
]:
supported = self._GetSupportedInterfaceSafetyOptions()
self.safetyOptions = supported & optionsMask & enabledOptions
else:
raise Exception(scode=winerror.E_NOINTERFACE)
def _GetSupportedInterfaceSafetyOptions(self):
return 0
def GetInterfaceSafetyOptions(self, iid):
if iid in [
pythoncom.IID_IPersist,
pythoncom.IID_IPersistStream,
pythoncom.IID_IPersistStreamInit,
axscript.IID_IActiveScript,
axscript.IID_IActiveScriptParse,
]:
supported = self._GetSupportedInterfaceSafetyOptions()
return supported, self.safetyOptions
else:
raise Exception(scode=winerror.E_NOINTERFACE)
#
# Other helpers.
def ExecutePendingScripts(self):
self.RegisterNewNamedItems()
self.DoExecutePendingScripts()
def ProcessScriptItemEvent(self, item, event, lcid, wFlags, args):
# trace("ProcessScriptItemEvent", item, event, lcid, wFlags, args)
self.RegisterNewNamedItems()
return self.DoProcessScriptItemEvent(item, event, lcid, wFlags, args)
def _DumpNamedItems_(self):
for item in self.subItems.values():
item._dump_(0)
def ResetNamedItems(self):
# Due to the way we work, we re-create persistent ones.
existing = self.subItems
self.subItems = {}
for name, item in existing.items():
item.Close()
if item.flags & axscript.SCRIPTITEM_ISPERSISTENT:
self.AddNamedItem(item.name, item.flags)
def GetCurrentSafetyOptions(self):
return self.safetyOptions
def ProcessNewNamedItemsConnections(self):
# Process all sub-items.
for item in self.subItems.values():
if not item.createdConnections: # Fast-track!
item.CreateConnections()
def RegisterNewNamedItems(self):
# Register all sub-items.
for item in self.subItems.values():
if not item.isRegistered: # Fast-track!
self.RegisterNamedItem(item)
def RegisterNamedItem(self, item):
item.Register()
def CheckConnectedOrDisconnected(self):
if self.scriptState in [
axscript.SCRIPTSTATE_CONNECTED,
axscript.SCRIPTSTATE_DISCONNECTED,
]:
return
RaiseAssert(
winerror.E_UNEXPECTED,
"Not connected or disconnected - %d" % self.scriptState,
)
def Connect(self):
self.ProcessNewNamedItemsConnections()
self.RegisterNewNamedItems()
self.ConnectEventHandlers()
def Run(self):
# trace("AXScript running...")
if (
self.scriptState != axscript.SCRIPTSTATE_INITIALIZED
and self.scriptState != axscript.SCRIPTSTATE_STARTED
):
raise Exception(scode=winerror.E_UNEXPECTED)
# self._DumpNamedItems_()
self.ExecutePendingScripts()
self.DoRun()
def Stop(self):
# Stop all executing scripts, and disconnect.
if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
self.Disconnect()
# Reset back to initialized.
self.Reset()
def Disconnect(self):
self.CheckConnectedOrDisconnected()
try:
self.DisconnectEventHandlers()
except pythoncom.com_error:
# Ignore errors when disconnecting.
pass
self.ChangeScriptState(axscript.SCRIPTSTATE_DISCONNECTED)
def ConnectEventHandlers(self):
# trace ("Connecting to event handlers")
for item in self.subItems.values():
item.Connect()
self.ChangeScriptState(axscript.SCRIPTSTATE_CONNECTED)
def DisconnectEventHandlers(self):
# trace ("Disconnecting from event handlers")
for item in self.subItems.values():
item.Disconnect()
def Reset(self):
# Keeping persistent engine state, reset back an initialized state
self.ResetNamedItems()
self.ChangeScriptState(axscript.SCRIPTSTATE_INITIALIZED)
def ChangeScriptState(self, state):
# print " ChangeScriptState with %s - currentstate = %s" % (state_map.get(state),state_map.get(self.scriptState))
self.DisableInterrupts()
try:
self.scriptState = state
try:
if self.scriptSite:
self.scriptSite.OnStateChange(state)
except pythoncom.com_error as xxx_todo_changeme:
(hr, desc, exc, arg) = xxx_todo_changeme.args
# Ignore all errors here - E_NOTIMPL likely from scriptlets.
finally:
self.EnableInterrupts()
# This stack frame is debugged - therefore we do as little as possible in it.
def _ApplyInScriptedSection(self, fn, args):
if self.debugManager:
self.debugManager.OnEnterScript()
if self.debugManager.adb.appDebugger:
return self.debugManager.adb.runcall(fn, *args)
else:
return fn(*args)
else:
return fn(*args)
def ApplyInScriptedSection(self, codeBlock, fn, args):
self.BeginScriptedSection()
try:
try:
# print "ApplyInSS", codeBlock, fn, args
return self._ApplyInScriptedSection(fn, args)
finally:
if self.debugManager:
self.debugManager.OnLeaveScript()
self.EndScriptedSection()
except:
self.HandleException(codeBlock)
# This stack frame is debugged - therefore we do as little as possible in it.
def _CompileInScriptedSection(self, code, name, type):
if self.debugManager:
self.debugManager.OnEnterScript()
return compile(code, name, type)
def CompileInScriptedSection(self, codeBlock, type, realCode=None):
if codeBlock.codeObject is not None: # already compiled
return 1
if realCode is None:
code = codeBlock.codeText
else:
code = realCode
name = codeBlock.GetFileName()
self.BeginScriptedSection()
try:
try:
codeObject = self._CompileInScriptedSection(RemoveCR(code), name, type)
codeBlock.codeObject = codeObject
return 1
finally:
if self.debugManager:
self.debugManager.OnLeaveScript()
self.EndScriptedSection()
except:
self.HandleException(codeBlock)
# This stack frame is debugged - therefore we do as little as possible in it.
def _ExecInScriptedSection(self, codeObject, globals, locals=None):
if self.debugManager:
self.debugManager.OnEnterScript()
if self.debugManager.adb.appDebugger:
return self.debugManager.adb.run(codeObject, globals, locals)
else:
exec(codeObject, globals, locals)
else:
exec(codeObject, globals, locals)
def ExecInScriptedSection(self, codeBlock, globals, locals=None):
if locals is None:
locals = globals
assert (
not codeBlock.beenExecuted
), "This code block should not have been executed"
codeBlock.beenExecuted = 1
self.BeginScriptedSection()
try:
try:
self._ExecInScriptedSection(codeBlock.codeObject, globals, locals)
finally:
if self.debugManager:
self.debugManager.OnLeaveScript()
self.EndScriptedSection()
except:
self.HandleException(codeBlock)
def _EvalInScriptedSection(self, codeBlock, globals, locals=None):
if self.debugManager:
self.debugManager.OnEnterScript()
if self.debugManager.adb.appDebugger:
return self.debugManager.adb.runeval(codeBlock, globals, locals)
else:
return eval(codeBlock, globals, locals)
else:
return eval(codeBlock, globals, locals)
def EvalInScriptedSection(self, codeBlock, globals, locals=None):
if locals is None:
locals = globals
assert (
not codeBlock.beenExecuted
), "This code block should not have been executed"
codeBlock.beenExecuted = 1
self.BeginScriptedSection()
try:
try:
return self._EvalInScriptedSection(
codeBlock.codeObject, globals, locals
)
finally:
if self.debugManager:
self.debugManager.OnLeaveScript()
self.EndScriptedSection()
except:
self.HandleException(codeBlock)
def HandleException(self, codeBlock):
# NOTE - Never returns - raises a ComException
exc_type, exc_value, exc_traceback = sys.exc_info()
# If a SERVER exception, re-raise it. If a client side COM error, it is
# likely to have originated from the script code itself, and therefore
# needs to be reported like any other exception.
if IsCOMServerException(exc_type):
# Ensure the traceback doesnt cause a cycle.
exc_traceback = None
raise
# It could be an error by another script.
if (
issubclass(pythoncom.com_error, exc_type)
and exc_value.hresult == axscript.SCRIPT_E_REPORTED
):
# Ensure the traceback doesnt cause a cycle.
exc_traceback = None
raise Exception(scode=exc_value.hresult)
exception = error.AXScriptException(
self, codeBlock, exc_type, exc_value, exc_traceback
)
# Ensure the traceback doesnt cause a cycle.
exc_traceback = None
result_exception = error.ProcessAXScriptException(
self.scriptSite, self.debugManager, exception
)
if result_exception is not None:
try:
self.scriptSite.OnScriptTerminate(None, result_exception)
except pythoncom.com_error:
pass # Ignore errors telling engine we stopped.
# reset ourselves to 'connected' so further events continue to fire.
self.SetScriptState(axscript.SCRIPTSTATE_CONNECTED)
raise result_exception
# I think that in some cases this should just return - but the code
# that could return None above is disabled, so it never happens.
RaiseAssert(
winerror.E_UNEXPECTED, "Don't have an exception to raise to the caller!"
)
def BeginScriptedSection(self):
if self.scriptSite is None:
raise Exception(scode=winerror.E_UNEXPECTED)
self.scriptSite.OnEnterScript()
def EndScriptedSection(self):
if self.scriptSite is None:
raise Exception(scode=winerror.E_UNEXPECTED)
self.scriptSite.OnLeaveScript()
def DisableInterrupts(self):
pass
def EnableInterrupts(self):
pass
def GetNamedItem(self, name):
try:
return self.subItems[name]
except KeyError:
raise Exception(scode=winerror.E_INVALIDARG)
def GetNamedItemClass(self):
return ScriptItem
def _AddScriptCodeBlock(self, codeBlock):
self.scriptCodeBlocks[codeBlock.GetFileName()] = codeBlock
if self.debugManager:
self.debugManager.AddScriptBlock(codeBlock)
if __name__ == "__main__":
print("This is a framework class - please use pyscript.py etc")
def dumptypeinfo(typeinfo):
return
attr = typeinfo.GetTypeAttr()
# Loop over all methods
print("Methods")
for j in range(attr[6]):
fdesc = list(typeinfo.GetFuncDesc(j))
id = fdesc[0]
try:
names = typeinfo.GetNames(id)
except pythoncom.ole_error:
names = None
doc = typeinfo.GetDocumentation(id)
print(" ", names, "has attr", fdesc)
# Loop over all variables (ie, properties)
print("Variables")
for j in range(attr[7]):
fdesc = list(typeinfo.GetVarDesc(j))
names = typeinfo.GetNames(id)
print(" ", names, "has attr", fdesc)
Reference in New Issue Copy Permalink