home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Shareware / Comunicatii / jyte / jyte.exe / genpy.py < prev    next >
Text File  |  2004-01-26  |  42KB  |  1,005 lines
  1. """genpy.py - The worker for makepy.  See makepy.py for more details
  2.  
  3. This code was moved simply to speed Python in normal circumstances.  As the makepy.py
  4. is normally run from the command line, it reparses the code each time.  Now makepy
  5. is nothing more than the command line handler and public interface.
  6.  
  7. The makepy command line etc handling is also getting large enough in its own right!
  8. """
  9.  
  10. # NOTE - now supports a "demand" mechanism - the top-level is a package, and
  11. # each class etc can be made individually.
  12. # This should eventually become the default.
  13. # Then the old non-package technique should be removed.
  14. # There should be no b/w compat issues, and will just help clean the code.
  15. # This will be done once the new "demand" mechanism gets a good workout.
  16. import os
  17. import sys
  18. import string
  19. import time
  20. import win32com
  21.  
  22. import pythoncom
  23. import build
  24.  
  25. error = "makepy.error"
  26. makepy_version = "0.4.9" # Written to generated file.
  27.  
  28. GEN_FULL="full"
  29. GEN_DEMAND_BASE = "demand(base)"
  30. GEN_DEMAND_CHILD = "demand(child)"
  31.  
  32. try:
  33.     TrueRepr = repr(True)
  34.     FalseRepr = repr(False)
  35. except NameError:
  36.     TrueRepr = "1"
  37.     FalseRepr = "0"
  38.  
  39. # This map is used purely for the users benefit -it shows the
  40. # raw, underlying type of Alias/Enums, etc.  The COM implementation
  41. # does not use this map at runtime - all Alias/Enum have already
  42. # been translated.
  43. mapVTToTypeString = {
  44.     pythoncom.VT_I2: 'types.IntType',
  45.     pythoncom.VT_I4: 'types.IntType',
  46.     pythoncom.VT_R4: 'types.FloatType',
  47.     pythoncom.VT_R8: 'types.FloatType',
  48.     pythoncom.VT_BSTR: 'types.StringType',
  49.     pythoncom.VT_BOOL: 'types.IntType',
  50.     pythoncom.VT_VARIANT: 'types.TypeType',
  51.     pythoncom.VT_I1: 'types.IntType',
  52.     pythoncom.VT_UI1: 'types.IntType',
  53.     pythoncom.VT_UI2: 'types.IntType',
  54.     pythoncom.VT_UI4: 'types.IntType',
  55.     pythoncom.VT_I8: 'types.LongType',
  56.     pythoncom.VT_UI8: 'types.LongType',
  57.     pythoncom.VT_INT: 'types.IntType',
  58.     pythoncom.VT_DATE: 'pythoncom.PyTimeType',
  59.     pythoncom.VT_UINT: 'types.IntType',
  60. }
  61.  
  62. # Given a propget function's arg desc, return the default parameters for all
  63. # params bar the first.  Eg, then Python does a:
  64. # object.Property = "foo"
  65. # Python can only pass the "foo" value.  If the property has
  66. # multiple args, and the rest have default values, this allows
  67. # Python to correctly pass those defaults.
  68. def MakeDefaultArgsForPropertyPut(argsDesc):
  69.     ret = []
  70.     for desc in argsDesc[1:]:
  71.         default = build.MakeDefaultArgRepr(desc)
  72.         if default is None:
  73.             break
  74.         ret.append(default)
  75.     return tuple(ret)
  76.                             
  77.  
  78. def MakeMapLineEntry(dispid, wFlags, retType, argTypes, user, resultCLSID):
  79.     # Strip the default value
  80.     argTypes = tuple(map(lambda what: what[:2], argTypes))
  81.     return '(%s, %d, %s, %s, "%s", %s)' % \
  82.         (dispid, wFlags, retType[:2], argTypes, user, resultCLSID)
  83.  
  84. def MakeEventMethodName(eventName):
  85.     if eventName[:2]=="On":
  86.         return eventName
  87.     else:
  88.         return "On"+eventName
  89.  
  90. def WriteSinkEventMap(obj):
  91.     print '\t_dispid_to_func_ = {'
  92.     for name, entry in obj.propMapGet.items() + obj.propMapPut.items() + obj.mapFuncs.items():
  93.         fdesc = entry.desc
  94.         print '\t\t%9d : "%s",' % (entry.desc[0], MakeEventMethodName(entry.names[0]))
  95.     print '\t\t}'
  96.     
  97.  
  98. # MI is used to join my writable helpers, and the OLE
  99. # classes.
  100. class WritableItem:
  101.     def __cmp__(self, other):
  102.         "Compare for sorting"   
  103.         ret = cmp(self.order, other.order)
  104.         if ret==0 and self.doc: ret = cmp(self.doc[0], other.doc[0])
  105.         return ret
  106.     def __repr__(self):
  107.         return "OleItem: doc=%s, order=%d" % (`self.doc`, self.order)
  108.  
  109.  
  110. class RecordItem(build.OleItem, WritableItem):
  111.   order = 9
  112.   typename = "RECORD"
  113.  
  114.   def __init__(self, typeInfo, typeAttr, doc=None, bForUser=1):
  115. ##    sys.stderr.write("Record %s: size %s\n" % (doc,typeAttr.cbSizeInstance))
  116. ##    sys.stderr.write(" cVars = %s\n" % (typeAttr.cVars,))
  117. ##    for i in range(typeAttr.cVars):
  118. ##        vdesc = typeInfo.GetVarDesc(i)
  119. ##        sys.stderr.write(" Var %d has value %s, type %d, desc=%s\n" % (i, vdesc.value, vdesc.varkind, vdesc.elemdescVar))
  120. ##        sys.stderr.write(" Doc is %s\n" % (typeInfo.GetDocumentation(vdesc.memid),))
  121.  
  122.     build.OleItem.__init__(self, doc)
  123.     self.clsid = typeAttr[0]
  124.  
  125.   def WriteClass(self, generator):
  126.     pass
  127.  
  128. # Given an enum, write all aliases for it.
  129. # (no longer necessary for new style code, but still used for old code.
  130. def WriteAliasesForItem(item, aliasItems):
  131.   for alias in aliasItems.values():
  132.     if item.doc and alias.aliasDoc and (alias.aliasDoc[0]==item.doc[0]):
  133.       alias.WriteAliasItem(aliasItems)
  134.       
  135. class AliasItem(build.OleItem, WritableItem):
  136.   order = 2
  137.   typename = "ALIAS"
  138.  
  139.   def __init__(self, typeinfo, attr, doc=None, bForUser = 1):
  140.     build.OleItem.__init__(self, doc)
  141.  
  142.     ai = attr[14]
  143.     self.attr = attr
  144.     if type(ai) == type(()) and \
  145.       type(ai[1])==type(0): # XXX - This is a hack - why tuples?  Need to resolve?
  146.       href = ai[1]
  147.       alinfo = typeinfo.GetRefTypeInfo(href)
  148.       self.aliasDoc = alinfo.GetDocumentation(-1)
  149.       self.aliasAttr = alinfo.GetTypeAttr()
  150.     else:
  151.       self.aliasDoc = None
  152.       self.aliasAttr = None
  153.  
  154.   def WriteAliasItem(self, aliasDict):
  155.     # we could have been written as part of an alias dependency
  156.     if self.bWritten:
  157.       return
  158.  
  159.     if self.aliasDoc:
  160.       depName = self.aliasDoc[0]
  161.       if aliasDict.has_key(depName):
  162.         aliasDict[depName].WriteAliasItem(aliasDict)
  163.       print self.doc[0] + " = " + depName
  164.     else:
  165.       ai = self.attr[14]
  166.       if type(ai) == type(0):
  167.         try:
  168.           typeStr = mapVTToTypeString[ai]
  169.           print "# %s=%s" % (self.doc[0], typeStr)
  170.         except KeyError:
  171.           print self.doc[0] + " = None # Can't convert alias info " + str(ai)
  172.     print
  173.     self.bWritten = 1
  174.  
  175. class EnumerationItem(build.OleItem, WritableItem):
  176.   order = 1
  177.   typename = "ENUMERATION"
  178.  
  179.   def __init__(self, typeinfo, attr, doc=None, bForUser=1):
  180.     build.OleItem.__init__(self, doc)
  181.  
  182.     self.clsid = attr[0]
  183.     self.mapVars = {}
  184.     typeFlags = attr[11]
  185.     self.hidden = typeFlags & pythoncom.TYPEFLAG_FHIDDEN or \
  186.                   typeFlags & pythoncom.TYPEFLAG_FRESTRICTED
  187.  
  188.     for j in range(attr[7]):
  189.       vdesc = typeinfo.GetVarDesc(j)
  190.       name = typeinfo.GetNames(vdesc[0])[0]
  191.       self.mapVars[name] = build.MapEntry(vdesc)
  192.  
  193. ##  def WriteEnumerationHeaders(self, aliasItems):
  194. ##    enumName = self.doc[0]
  195. ##    print "%s=constants # Compatibility with previous versions." % (enumName)
  196. ##    WriteAliasesForItem(self, aliasItems)
  197.     
  198.   def WriteEnumerationItems(self):
  199.     enumName = self.doc[0]
  200.     # Write in name alpha order
  201.     names = self.mapVars.keys()
  202.     names.sort()
  203.     for name in names:
  204.       entry = self.mapVars[name]
  205.       vdesc = entry.desc
  206.       if vdesc[4] == pythoncom.VAR_CONST:
  207.         val = vdesc[1]
  208.         if type(val)==type(0):
  209.           if val==0x80000000L: # special case
  210.             use = "0x80000000L" # 'L' for future warning
  211.           elif val > 0x80000000L or val < 0: # avoid a FutureWarning
  212.             use = long(val)
  213.           else:
  214.             use = hex(val)
  215.         else:
  216.           use = repr(str(val))
  217.         print "\t%-30s=%-10s # from enum %s" % \
  218.               (build.MakePublicAttributeName(name, True), use, enumName)
  219.  
  220. class VTableItem(build.VTableItem, WritableItem):
  221.     order = 4
  222.  
  223.     def WriteClass(self, generator):
  224.         self.WriteVTableMap(generator)
  225.         self.bWritten = 1
  226.  
  227.     def WriteVTableMap(self, generator):
  228.         print "%s_vtables_dispatch_ = %d" % (self.python_name, self.bIsDispatch)
  229.         print "%s_vtables_ = [" % (self.python_name, ) 
  230.         for v in self.vtableFuncs:
  231.             chunks = []
  232.             names, dispid, desc = v
  233.             arg_desc = desc[2]
  234.  
  235.             arg_reprs = []
  236.             for arg in arg_desc:
  237.                 defval = build.MakeDefaultArgRepr(arg)
  238.                 if arg[3] is None:
  239.                     arg3_repr = None
  240.                 else:
  241.                     arg3_repr = repr(arg[3])
  242.                 arg_reprs.append((arg[0], arg[1], defval, arg3_repr))
  243.             desc = desc[:2] + (arg_reprs,) + desc[3:]
  244.             chunks.append("\t(%r, %d, %r)," % (names, dispid, desc))
  245.             print "".join(chunks)
  246.         print "]"
  247.         print
  248.  
  249. class DispatchItem(build.DispatchItem, WritableItem):
  250.     order = 3
  251.  
  252.     def __init__(self, typeinfo, attr, doc=None):
  253.         build.DispatchItem.__init__(self, typeinfo, attr, doc)
  254.         self.type_attr = attr
  255.         self.coclass_clsid = None
  256.  
  257.     def WriteClass(self, generator):
  258.       if not self.bIsDispatch and not self.type_attr.typekind == pythoncom.TKIND_DISPATCH:
  259.           return
  260.       # This is pretty screwey - now we have vtable support we
  261.       # should probably rethink this (ie, maybe write both sides for sinks, etc)
  262.       if self.bIsSink:
  263.           self.WriteEventSinkClassHeader(generator)
  264.           self.WriteCallbackClassBody(generator)
  265.       else:
  266.           self.WriteClassHeader(generator)
  267.           self.WriteClassBody(generator)
  268.       print
  269.       self.bWritten = 1
  270.  
  271.     def WriteClassHeader(self, generator):
  272.         generator.checkWriteDispatchBaseClass()
  273.         doc = self.doc
  274.         print 'class ' + self.python_name + '(DispatchBaseClass):'
  275.         if doc[1]: print '\t' + build._safeQuotedString(doc[1])
  276.         try:
  277.             progId = pythoncom.ProgIDFromCLSID(self.clsid)
  278.             print "\t# This class is creatable by the name '%s'" % (progId)
  279.         except pythoncom.com_error:
  280.             pass
  281.         print "\tCLSID = " + repr(self.clsid)
  282.         if self.coclass_clsid is None:
  283.             print "\tcoclass_clsid = None"
  284.         else:
  285.             print "\tcoclass_clsid = " + repr(self.coclass_clsid)
  286.         print
  287.         self.bWritten = 1
  288.  
  289.     def WriteEventSinkClassHeader(self, generator):
  290.         generator.checkWriteEventBaseClass()
  291.         doc = self.doc
  292.         print 'class ' + self.python_name + ':'
  293.         if doc[1]: print '\t' + build._safeQuotedString(doc[1])
  294.         try:
  295.             progId = pythoncom.ProgIDFromCLSID(self.clsid)
  296.             print "\t# This class is creatable by the name '%s'" % (progId)
  297.         except pythoncom.com_error:
  298.             pass
  299.         print '\tCLSID = CLSID_Sink = ' + repr(self.clsid)
  300.         if self.coclass_clsid is None:
  301.             print "\tcoclass_clsid = None"
  302.         else:
  303.             print "\tcoclass_clsid = " + repr(self.coclass_clsid)
  304.         print '\t_public_methods_ = [] # For COM Server support'
  305.         WriteSinkEventMap(self)
  306.         print
  307.         print '\tdef __init__(self, oobj = None):'
  308.         print "\t\tif oobj is None:"
  309.         print "\t\t\tself._olecp = None"
  310.         print "\t\telse:"
  311.         print '\t\t\timport win32com.server.util'
  312.         print '\t\t\tfrom win32com.server.policy import EventHandlerPolicy'
  313.         print '\t\t\tcpc=oobj._oleobj_.QueryInterface(pythoncom.IID_IConnectionPointContainer)'
  314.         print '\t\t\tcp=cpc.FindConnectionPoint(self.CLSID_Sink)'
  315.         print '\t\t\tcookie=cp.Advise(win32com.server.util.wrap(self, usePolicy=EventHandlerPolicy))'
  316.         print '\t\t\tself._olecp,self._olecp_cookie = cp,cookie'
  317.         print '\tdef __del__(self):'
  318.         print '\t\ttry:'
  319.         print '\t\t\tself.close()'
  320.         print '\t\texcept pythoncom.com_error:'
  321.         print '\t\t\tpass'
  322.         print '\tdef close(self):'
  323.         print '\t\tif self._olecp is not None:'
  324.         print '\t\t\tcp,cookie,self._olecp,self._olecp_cookie = self._olecp,self._olecp_cookie,None,None'
  325.         print '\t\t\tcp.Unadvise(cookie)'
  326.         print '\tdef _query_interface_(self, iid):'
  327.         print '\t\timport win32com.server.util'
  328.         print '\t\tif iid==self.CLSID_Sink: return win32com.server.util.wrap(self)'
  329.         print
  330.         self.bWritten = 1
  331.  
  332.     def WriteCallbackClassBody(self, generator):
  333.         print "\t# Event Handlers"
  334.         print "\t# If you create handlers, they should have the following prototypes:"
  335.         for name, entry in self.propMapGet.items() + self.propMapPut.items() + self.mapFuncs.items():
  336.             fdesc = entry.desc
  337.             methName = MakeEventMethodName(entry.names[0])
  338.             print '#\tdef ' + methName + '(self' + build.BuildCallList(fdesc, entry.names, "defaultNamedOptArg", "defaultNamedNotOptArg","defaultUnnamedArg", "pythoncom.Missing") + '):'
  339.             if entry.doc and entry.doc[1]: print '#\t\t' + build._safeQuotedString(entry.doc[1])
  340.         print
  341.         self.bWritten = 1
  342.  
  343.     def WriteClassBody(self, generator):
  344.         # Write in alpha order.
  345.         names = self.mapFuncs.keys()
  346.         names.sort()
  347.         specialItems = {"count":None, "item":None,"value":None,"_newenum":None} # If found, will end up with (entry, invoke_tupe)
  348.         itemCount = None
  349.         for name in names:
  350.             entry=self.mapFuncs[name]
  351.             # skip [restricted] methods, unless it is the
  352.             # enumerator (which, being part of the "system",
  353.             # we know about and can use)
  354.             dispid = entry.desc[0]
  355.             if entry.desc[9] & pythoncom.FUNCFLAG_FRESTRICTED and \
  356.                 dispid != pythoncom.DISPID_NEWENUM:
  357.                 continue
  358.             # If not accessible via IDispatch, then we can't use it here.
  359.             if entry.desc[3] != pythoncom.FUNC_DISPATCH:
  360.                 continue
  361.             if dispid==pythoncom.DISPID_VALUE:
  362.                 lkey = "value"
  363.             elif dispid==pythoncom.DISPID_NEWENUM:
  364.                 specialItems["_newenum"] = (entry, entry.desc[4], None)
  365.                 continue # Dont build this one now!
  366.             else:
  367.                 lkey = string.lower(name)
  368.             if specialItems.has_key(lkey) and specialItems[lkey] is None: # remember if a special one.
  369.                 specialItems[lkey] = (entry, entry.desc[4], None)
  370.             if generator.bBuildHidden or not entry.hidden:
  371.                 if entry.GetResultName():
  372.                     print '\t# Result is of type ' + entry.GetResultName()
  373.                 if entry.wasProperty:
  374.                     print '\t# The method %s is actually a property, but must be used as a method to correctly pass the arguments' % name
  375.                 ret = self.MakeFuncMethod(entry,build.MakePublicAttributeName(name))
  376.                 for line in ret:
  377.                     print line
  378.         print "\t_prop_map_get_ = {"
  379.         names = self.propMap.keys(); names.sort()
  380.         for key in names:
  381.             entry = self.propMap[key]
  382.             if generator.bBuildHidden or not entry.hidden:
  383.                 resultName = entry.GetResultName()
  384.                 if resultName:
  385.                     print "\t\t# Property '%s' is an object of type '%s'" % (key, resultName)
  386.                 lkey = string.lower(key)
  387.                 details = entry.desc
  388.                 resultDesc = details[2]
  389.                 argDesc = ()
  390.                 mapEntry = MakeMapLineEntry(details[0], pythoncom.DISPATCH_PROPERTYGET, resultDesc, argDesc, key, entry.GetResultCLSIDStr())
  391.             
  392.                 if entry.desc[0]==pythoncom.DISPID_VALUE:
  393.                     lkey = "value"
  394.                 elif entry.desc[0]==pythoncom.DISPID_NEWENUM:
  395.                     lkey = "_newenum"
  396.                 else:
  397.                     lkey = string.lower(key)
  398.                 if specialItems.has_key(lkey) and specialItems[lkey] is None: # remember if a special one.
  399.                     specialItems[lkey] = (entry, pythoncom.DISPATCH_PROPERTYGET, mapEntry)
  400.                     # All special methods, except _newenum, are written
  401.                     # "normally".  This is a mess!
  402.                     if entry.desc[0]==pythoncom.DISPID_NEWENUM:
  403.                         continue 
  404.  
  405.                 print '\t\t"%s": %s,' % (key, mapEntry)
  406.         names = self.propMapGet.keys(); names.sort()
  407.         for key in names:
  408.             entry = self.propMapGet[key]
  409.             if generator.bBuildHidden or not entry.hidden:
  410.                 if entry.GetResultName():
  411.                     print "\t\t# Method '%s' returns object of type '%s'" % (key, entry.GetResultName())
  412.                 details = entry.desc
  413.                 lkey = string.lower(key)
  414.                 argDesc = details[2]
  415.                 resultDesc = details[8]
  416.                 mapEntry = MakeMapLineEntry(details[0], pythoncom.DISPATCH_PROPERTYGET, resultDesc, argDesc, key, entry.GetResultCLSIDStr())
  417.                 if entry.desc[0]==pythoncom.DISPID_VALUE:
  418.                     lkey = "value"
  419.                 elif entry.desc[0]==pythoncom.DISPID_NEWENUM:
  420.                     lkey = "_newenum"
  421.                 else:
  422.                     lkey = string.lower(key)
  423.                 if specialItems.has_key(lkey) and specialItems[lkey] is None: # remember if a special one.
  424.                     specialItems[lkey]=(entry, pythoncom.DISPATCH_PROPERTYGET, mapEntry)
  425.                     # All special methods, except _newenum, are written
  426.                     # "normally".  This is a mess!
  427.                     if entry.desc[0]==pythoncom.DISPID_NEWENUM:
  428.                         continue 
  429.                 print '\t\t"%s": %s,' % (key, mapEntry)
  430.  
  431.         print "\t}"
  432.  
  433.         print "\t_prop_map_put_ = {"
  434.         # These are "Invoke" args
  435.         names = self.propMap.keys(); names.sort()
  436.         for key in names:
  437.             entry = self.propMap[key]
  438.             if generator.bBuildHidden or not entry.hidden:
  439.                 lkey=string.lower(key)
  440.                 details = entry.desc
  441.                 # If default arg is None, write an empty tuple
  442.                 defArgDesc = build.MakeDefaultArgRepr(details[2])
  443.                 if defArgDesc is None:
  444.                     defArgDesc = ""
  445.                 else:
  446.                     defArgDesc = defArgDesc + ","
  447.                 print '\t\t"%s" : ((%s, LCID, %d, 0),(%s)),' % (key, details[0], pythoncom.DISPATCH_PROPERTYPUT, defArgDesc)
  448.  
  449.         names = self.propMapPut.keys(); names.sort()
  450.         for key in names:
  451.             entry = self.propMapPut[key]
  452.             if generator.bBuildHidden or not entry.hidden:
  453.                 details = entry.desc
  454.                 defArgDesc = MakeDefaultArgsForPropertyPut(details[2])
  455.                 print '\t\t"%s": ((%s, LCID, %d, 0),%s),' % (key, details[0], details[4], defArgDesc)
  456.         print "\t}"
  457.         
  458.         if specialItems["value"]:
  459.             entry, invoketype, propArgs = specialItems["value"]
  460.             if propArgs is None:
  461.                 typename = "method"
  462.                 ret = self.MakeFuncMethod(entry,'__call__')
  463.             else:
  464.                 typename = "property"
  465.                 ret = [ "\tdef __call__(self):\n\t\treturn self._ApplyTypes_(*%s)" % propArgs]
  466.             print "\t# Default %s for this class is '%s'" % (typename, entry.names[0])
  467.             for line in ret:
  468.                 print line
  469.             print "\t# str(ob) and int(ob) will use __call__"
  470.             print "\tdef __unicode__(self, *args):"
  471.             print "\t\ttry:"
  472.             print "\t\t\treturn unicode(self.__call__(*args))"
  473.             print "\t\texcept pythoncom.com_error:"
  474.             print "\t\t\treturn repr(self)"
  475.             print "\tdef __str__(self, *args):"
  476.             print "\t\treturn str(self.__unicode__(*args))"
  477.             print "\tdef __int__(self, *args):"
  478.             print "\t\treturn int(self.__call__(*args))"
  479.             
  480.  
  481.         if specialItems["_newenum"]:
  482.             enumEntry, invoketype, propArgs = specialItems["_newenum"]
  483.             resultCLSID = enumEntry.GetResultCLSIDStr()
  484.             # If we dont have a good CLSID for the enum result, assume it is the same as the Item() method.
  485.             if resultCLSID == "None" and self.mapFuncs.has_key("Item"):
  486.                 resultCLSID = self.mapFuncs["Item"].GetResultCLSIDStr()
  487.             # "Native" Python iterator support
  488.             print '\tdef __iter__(self):'
  489.             print '\t\t"Return a Python iterator for this object"'
  490.             print '\t\tob = self._oleobj_.InvokeTypes(%d,LCID,%d,(13, 10),())' % (pythoncom.DISPID_NEWENUM, enumEntry.desc[4])
  491.             print '\t\treturn win32com.client.util.Iterator(ob)'
  492.             # And 'old style' iterator support - magically used to simulate iterators
  493.             # before Python grew them
  494.             print '\tdef _NewEnum(self):'
  495.             print '\t\t"Create an enumerator from this object"'
  496.             print '\t\treturn win32com.client.util.WrapEnum(self._oleobj_.InvokeTypes(%d,LCID,%d,(13, 10),()),%s)' % (pythoncom.DISPID_NEWENUM, enumEntry.desc[4], resultCLSID)
  497.             print '\tdef __getitem__(self, index):'
  498.             print '\t\t"Allow this class to be accessed as a collection"'
  499.             print "\t\tif not self.__dict__.has_key('_enum_'):"
  500.             print "\t\t\tself.__dict__['_enum_'] = self._NewEnum()"
  501.             print "\t\treturn self._enum_.__getitem__(index)"
  502.         else: # Not an Enumerator, but may be an "Item/Count" based collection
  503.             if specialItems["item"]:
  504.                 entry, invoketype, propArgs = specialItems["item"]
  505.                 print '\t#This class has Item property/method which may take args - allow indexed access'
  506.                 print '\tdef __getitem__(self, item):'
  507.                 print '\t\treturn self._get_good_object_(self._oleobj_.Invoke(*(%d, LCID, %d, 1, item)), "Item")' % (entry.desc[0], invoketype)
  508.         if specialItems["count"]:
  509.             entry, invoketype, propArgs = specialItems["count"]
  510.             if propArgs is None:
  511.                 typename = "method"
  512.                 ret = self.MakeFuncMethod(entry,'__len__')
  513.             else:
  514.                 typename = "property"
  515.                 ret = [ "\tdef __len__(self):\n\t\treturn self._ApplyTypes_(*%s)" % propArgs]
  516.             print "\t#This class has Count() %s - allow len(ob) to provide this" % (typename)
  517.             for line in ret:
  518.                 print line
  519.             # Also include a __nonzero__
  520.             print "\t#This class has a __len__ - this is needed so 'if object:' always returns TRUE."
  521.             print "\tdef __nonzero__(self):"
  522.             print "\t\treturn %s" % (TrueRepr,)
  523.  
  524. class CoClassItem(build.OleItem, WritableItem):
  525.   order = 5
  526.   typename = "COCLASS"
  527.  
  528.   def __init__(self, typeinfo, attr, doc=None, sources = [], interfaces = [], bForUser=1):
  529.     build.OleItem.__init__(self, doc)
  530.     self.clsid = attr[0]
  531.     self.sources = sources
  532.     self.interfaces = interfaces
  533.     self.bIsDispatch = 1 # Pretend it is so it is written to the class map.
  534.  
  535.   def WriteClass(self, generator):
  536.     generator.checkWriteCoClassBaseClass()
  537.     doc = self.doc
  538.     if generator.generate_type == GEN_DEMAND_CHILD:
  539.       # Some special imports we must setup.
  540.       referenced_items = []
  541.       for ref, flag in self.sources:
  542.         referenced_items.append(ref)
  543.       for ref, flag in self.interfaces:
  544.         referenced_items.append(ref)
  545.       print "import sys"
  546.       for ref in referenced_items:
  547.         print "__import__('%s.%s')" % (generator.base_mod_name, ref.python_name)
  548.         print "%s = sys.modules['%s.%s'].%s" % (ref.python_name, generator.base_mod_name, ref.python_name, ref.python_name)
  549.     try:
  550.       progId = pythoncom.ProgIDFromCLSID(self.clsid)
  551.       print "# This CoClass is known by the name '%s'" % (progId)
  552.     except pythoncom.com_error:
  553.       pass
  554.     print 'class %s(CoClassBaseClass): # A CoClass' % (self.python_name)
  555.     if doc and doc[1]: print '\t# ' + doc[1]
  556.     print '\tCLSID = %r' % (self.clsid,)
  557.     print '\tcoclass_sources = ['
  558.     defItem = None
  559.     for item, flag in self.sources:
  560.       if flag & pythoncom.IMPLTYPEFLAG_FDEFAULT:
  561.         defItem = item
  562.       # check if non-dispatchable - if so no real Python class has been written.  Write the iid as a string instead.
  563.       if item.bIsDispatch: key = item.python_name
  564.       else: key = repr(str(item.clsid)) # really the iid.
  565.       print '\t\t%s,' % (key)
  566.     print '\t]'
  567.     if defItem:
  568.       if defItem.bIsDispatch: defName = defItem.python_name
  569.       else: defName = repr(str(defItem.clsid)) # really the iid.
  570.       print '\tdefault_source = %s' % (defName,)
  571.     print '\tcoclass_interfaces = ['
  572.     defItem = None
  573.     for item, flag in self.interfaces:
  574.       if flag & pythoncom.IMPLTYPEFLAG_FDEFAULT: # and dual:
  575.         defItem = item
  576.       # check if non-dispatchable - if so no real Python class has been written.  Write the iid as a string instead.
  577.       if item.bIsDispatch: key = item.python_name
  578.       else: key = repr(str(item.clsid)) # really the iid.
  579.       print '\t\t%s,' % (key,)
  580.     print '\t]'
  581.     if defItem:
  582.       if defItem.bIsDispatch: defName = defItem.python_name
  583.       else: defName = repr(str(defItem.clsid)) # really the iid.
  584.       print '\tdefault_interface = %s' % (defName,)
  585.     self.bWritten = 1
  586.     print
  587.  
  588. class GeneratorProgress:
  589.     def __init__(self):
  590.         pass
  591.     def Starting(self, tlb_desc):
  592.         """Called when the process starts.
  593.         """
  594.         self.tlb_desc = tlb_desc
  595.     def Finished(self):
  596.         """Called when the process is complete.
  597.         """
  598.     def SetDescription(self, desc, maxticks = None):
  599.         """We are entering a major step.  If maxticks, then this
  600.         is how many ticks we expect to make until finished
  601.         """
  602.     def Tick(self, desc = None):
  603.         """Minor progress step.  Can provide new description if necessary
  604.         """
  605.     def VerboseProgress(self, desc):
  606.         """Verbose/Debugging output.
  607.         """
  608.     def LogWarning(self, desc):
  609.         """If a warning is generated
  610.         """
  611.     def LogBeginGenerate(self, filename):
  612.         pass
  613.     def Close(self):
  614.         pass
  615.  
  616. class Generator:
  617.   def __init__(self, typelib, sourceFilename, progressObject, bBuildHidden=1, bUnicodeToString=0):
  618.     self.bHaveWrittenDispatchBaseClass = 0
  619.     self.bHaveWrittenCoClassBaseClass = 0
  620.     self.bHaveWrittenEventBaseClass = 0
  621.  
  622.     self.typelib = typelib
  623.     self.sourceFilename = sourceFilename
  624.     self.bBuildHidden = bBuildHidden
  625.     self.bUnicodeToString = bUnicodeToString
  626.     self.progress = progressObject
  627.     # These 2 are later additions and most of the code still 'print's...
  628.     self.file = None
  629.  
  630.   def CollectOleItemInfosFromType(self):
  631.     ret = []
  632.     for i in xrange(self.typelib.GetTypeInfoCount()):
  633.       info = self.typelib.GetTypeInfo(i)
  634.       infotype = self.typelib.GetTypeInfoType(i)
  635.       doc = self.typelib.GetDocumentation(i)
  636.       attr = info.GetTypeAttr()
  637.       ret.append((info, infotype, doc, attr))
  638.     return ret
  639.  
  640.   def _Build_CoClass(self, type_info_tuple):
  641.     info, infotype, doc, attr = type_info_tuple
  642.     # find the source and dispinterfaces for the coclass
  643.     child_infos = []
  644.     for j in range(attr[8]):
  645.       flags = info.GetImplTypeFlags(j)
  646.       refType = info.GetRefTypeInfo(info.GetRefTypeOfImplType(j))
  647.       refAttr = refType.GetTypeAttr()
  648.       child_infos.append( (info, refAttr.typekind, refType, refType.GetDocumentation(-1), refAttr, flags) )
  649.       
  650.     # Done generating children - now the CoClass itself.
  651.     newItem = CoClassItem(info, attr, doc)
  652.     return newItem, child_infos
  653.  
  654.   def _Build_CoClassChildren(self, coclass, coclass_info, oleItems, vtableItems):
  655.     sources = {}
  656.     interfaces = {}
  657.     for info, info_type, refType, doc, refAttr, flags in coclass_info:
  658. #          sys.stderr.write("Attr typeflags for coclass referenced object %s=%d (%d), typekind=%d\n" % (name, refAttr.wTypeFlags, refAttr.wTypeFlags & pythoncom.TYPEFLAG_FDUAL,refAttr.typekind))
  659.         if refAttr.typekind == pythoncom.TKIND_DISPATCH:
  660.           clsid = refAttr[0]
  661.           if oleItems.has_key(clsid):
  662.             dispItem = oleItems[clsid]
  663.           else:
  664.             dispItem = DispatchItem(refType, refAttr, doc)
  665.             oleItems[dispItem.clsid] = dispItem
  666.           dispItem.coclass_clsid = coclass.clsid
  667.           if flags & pythoncom.IMPLTYPEFLAG_FSOURCE:
  668.             dispItem.bIsSink = 1
  669.             sources[dispItem.clsid] = (dispItem, flags)
  670.           else:
  671.             interfaces[dispItem.clsid] = (dispItem, flags)
  672.           # If dual interface, make do that too.
  673.           if not vtableItems.has_key(clsid) and refAttr[11] & pythoncom.TYPEFLAG_FDUAL:
  674.             refType = refType.GetRefTypeInfo(refType.GetRefTypeOfImplType(-1))
  675.             refAttr = refType.GetTypeAttr()
  676.             assert refAttr.typekind == pythoncom.TKIND_INTERFACE, "must be interface bynow!"
  677.             vtableItem = VTableItem(refType, refAttr, doc)
  678.             vtableItems[clsid] = vtableItem
  679.     coclass.sources = sources.values()
  680.     coclass.interfaces = interfaces.values()
  681.  
  682.   def _Build_Interface(self, type_info_tuple):
  683.     info, infotype, doc, attr = type_info_tuple
  684.     oleItem = vtableItem = None
  685.     if infotype == pythoncom.TKIND_DISPATCH:
  686.         oleItem = DispatchItem(info, attr, doc)
  687.         # If this DISPATCH interface dual, then build that too.
  688.         if (attr.wTypeFlags & pythoncom.TYPEFLAG_FDUAL):
  689. #                sys.stderr.write("interface " + doc[0] + " is not dual\n");
  690.             # Get the vtable interface
  691.             refhtype = info.GetRefTypeOfImplType(-1)
  692.             info = info.GetRefTypeInfo(refhtype)
  693.             attr = info.GetTypeAttr()
  694.             infotype = pythoncom.TKIND_INTERFACE
  695.         else:
  696.             infotype = None
  697.     assert infotype in [None, pythoncom.TKIND_INTERFACE], "Must be a real interface at this point"
  698.     if infotype == pythoncom.TKIND_INTERFACE:
  699.         vtableItem = VTableItem(info, attr, doc)
  700.     return oleItem, vtableItem
  701.  
  702.   def BuildOleItemsFromType(self):
  703.     assert self.bBuildHidden, "This code doesnt look at the hidden flag - I thought everyone set it true!?!?!"
  704.     oleItems = {}
  705.     enumItems = {}
  706.     recordItems = {}
  707.     vtableItems = {}
  708.     
  709.     for type_info_tuple in self.CollectOleItemInfosFromType():
  710.       info, infotype, doc, attr = type_info_tuple
  711.       clsid = attr[0]
  712.       if infotype == pythoncom.TKIND_ENUM or infotype == pythoncom.TKIND_MODULE:
  713.         newItem = EnumerationItem(info, attr, doc)
  714.         enumItems[newItem.doc[0]] = newItem
  715.       # We never hide interfaces (MSAccess, for example, nominates interfaces as
  716.       # hidden, assuming that you only ever use them via the CoClass)
  717.       elif infotype in [pythoncom.TKIND_DISPATCH, pythoncom.TKIND_INTERFACE]:
  718.         if not oleItems.has_key(clsid):
  719.           oleItem, vtableItem = self._Build_Interface(type_info_tuple)
  720.           oleItems[clsid] = oleItem # Even "None" goes in here.
  721.           if vtableItem is not None:
  722.               vtableItems[clsid] = vtableItem
  723.       elif infotype == pythoncom.TKIND_RECORD or infotype == pythoncom.TKIND_UNION:
  724.         newItem = RecordItem(info, attr, doc)
  725.         recordItems[newItem.clsid] = newItem
  726.       elif infotype == pythoncom.TKIND_ALIAS:
  727.         # We dont care about alias' - handled intrinsicly.
  728.         continue
  729.       elif infotype == pythoncom.TKIND_COCLASS:
  730.         newItem, child_infos = self._Build_CoClass(type_info_tuple)
  731.         self._Build_CoClassChildren(newItem, child_infos, oleItems, vtableItems)
  732.         oleItems[newItem.clsid] = newItem
  733.       else:
  734.         self.progress.LogWarning("Unknown TKIND found: %d" % infotype)
  735.   
  736.     return oleItems, enumItems, recordItems, vtableItems
  737.  
  738.   def generate(self, file, is_for_demand = 0):
  739.     if is_for_demand:
  740.       self.generate_type = GEN_DEMAND_BASE
  741.     else:
  742.       self.generate_type = GEN_FULL
  743.     self.file = file
  744.     oldOut = sys.stdout
  745.     sys.stdout = file
  746.     try:
  747.       self.do_generate()
  748.     finally:
  749.       sys.stdout = oldOut
  750.       self.file = None
  751.       self.progress.Finished()
  752.  
  753.   def do_gen_file_header(self):
  754.     la = self.typelib.GetLibAttr()
  755.     moduleDoc = self.typelib.GetDocumentation(-1)
  756.     docDesc = ""
  757.     if moduleDoc[1]:
  758.       docDesc = moduleDoc[1]
  759.  
  760.     # encodings were giving me grief with McMillan's Installer
  761.     # until I get to the bottom of this, don't generate
  762.     # a coding line when frozen.
  763.     if not hasattr(sys, "frozen"):
  764.         print >> self.file, '# -*- coding: mbcs -*-' # Is this always correct?
  765.     print >> self.file, '# Created by makepy.py version %s' % (makepy_version,)
  766.     print >> self.file, '# By python version %s' % (sys.version,)
  767.     if self.sourceFilename:
  768.         print >> self.file, "# From type library '%s'" % (os.path.split(self.sourceFilename)[1],)
  769.     print >> self.file, '# On %s' % time.ctime(time.time())
  770.  
  771.     print >> self.file, '"""' + docDesc + '"""'
  772.  
  773.     print >> self.file, 'makepy_version =', `makepy_version`
  774.     try:
  775.         print >> self.file, 'python_version = 0x%x' % (sys.hexversion,)
  776.     except AttributeError:
  777.         print >> self.file, 'python_version = 0x0 # Presumably Python 1.5.2 - 0x0 is not a problem'
  778.     print>> self.file
  779.     print >> self.file, 'import win32com.client.CLSIDToClass, pythoncom'
  780.     print >> self.file, 'import win32com.client.util'
  781.     print >> self.file, 'from pywintypes import IID'
  782.     print >> self.file, 'from win32com.client import Dispatch'
  783.     print>> self.file
  784.     print >> self.file, '# The following 3 lines may need tweaking for the particular server'
  785.     print >> self.file, '# Candidates are pythoncom.Missing and pythoncom.Empty'
  786.     print >> self.file, 'defaultNamedOptArg=pythoncom.Empty'
  787.     print >> self.file, 'defaultNamedNotOptArg=pythoncom.Empty'
  788.     print >> self.file, 'defaultUnnamedArg=pythoncom.Empty'
  789.     print >> self.file
  790.     print >> self.file, 'CLSID = ' + repr(la[0])
  791.     print >> self.file, 'MajorVersion = ' + str(la[3])
  792.     print >> self.file, 'MinorVersion = ' + str(la[4])
  793.     print >> self.file, 'LibraryFlags = ' + str(la[5])
  794.     print >> self.file, 'LCID = ' + hex(la[1])
  795.     print >> self.file
  796.  
  797.   def do_generate(self):
  798.     moduleDoc = self.typelib.GetDocumentation(-1)
  799.     docDesc = ""
  800.     if moduleDoc[1]:
  801.       docDesc = moduleDoc[1]
  802.     self.progress.Starting(docDesc)
  803.     self.progress.SetDescription("Building definitions from type library...")
  804.  
  805.     self.do_gen_file_header()
  806.  
  807.     oleItems, enumItems, recordItems, vtableItems = self.BuildOleItemsFromType()
  808.  
  809.     self.progress.SetDescription("Generating...", len(oleItems)+len(enumItems)+len(vtableItems))
  810.  
  811.     # Generate the constants and their support.
  812.     if enumItems:
  813.         print "class constants:"
  814.         list = enumItems.values()
  815.         list.sort()
  816.         for oleitem in list:
  817.             oleitem.WriteEnumerationItems()
  818.             self.progress.Tick()
  819.         print
  820.  
  821.     if self.generate_type == GEN_FULL:
  822.       list = oleItems.values()
  823.       list = filter(lambda l: l is not None, list)
  824.       list.sort()
  825.       for oleitem in list:
  826.         self.progress.Tick()
  827.         oleitem.WriteClass(self)
  828.  
  829.       list = vtableItems.values()
  830.       list.sort()
  831.       for oleitem in list:
  832.         self.progress.Tick()
  833.         oleitem.WriteClass(self)
  834.     else:
  835.         self.progress.Tick(len(oleItems)+len(vtableItems))
  836.  
  837.     print 'RecordMap = {'
  838.     list = recordItems.values()
  839.     for record in list:
  840.         if str(record.clsid) == pythoncom.IID_NULL:
  841.             print "\t###%s: %s, # Typedef disabled because it doesn't have a non-null GUID" % (`record.doc[0]`, `str(record.clsid)`)
  842.         else:
  843.             print "\t%s: %s," % (`record.doc[0]`, `str(record.clsid)`)
  844.     print "}"
  845.     print
  846.  
  847.     # Write out _all_ my generated CLSID's in the map
  848.     if self.generate_type == GEN_FULL:
  849.       print 'CLSIDToClassMap = {'
  850.       for item in oleItems.values():
  851.           if item is not None and item.bWritten and item.bIsDispatch:
  852.               print "\t'%s' : %s," % (str(item.clsid), item.python_name)
  853.       print '}'
  854.       print 'CLSIDToPackageMap = {}'
  855.       print 'win32com.client.CLSIDToClass.RegisterCLSIDsFromDict( CLSIDToClassMap )'
  856.       print "VTablesToPackageMap = {}"
  857.       print "VTablesToClassMap = {"
  858.       for item in vtableItems.values():
  859.         print "\t'%s' : '%s'," % (item.clsid,item.python_name)
  860.       print '}'
  861.       print 
  862.  
  863.     else:
  864.       print 'CLSIDToClassMap = {}'
  865.       print 'CLSIDToPackageMap = {'
  866.       for item in oleItems.values():
  867.         if item is not None:
  868.           print "\t'%s' : %s," % (str(item.clsid), `item.python_name`)
  869.       print '}'
  870.       print "VTablesToClassMap = {}"
  871.       print "VTablesToPackageMap = {"
  872.       for item in vtableItems.values():
  873.         print "\t'%s' : '%s'," % (item.clsid,item.python_name)
  874.       print '}'
  875.       print 
  876.  
  877.     print
  878.     # Bit of a hack - build a temp map of iteItems + vtableItems - coClasses
  879.     map = {}
  880.     for item in oleItems.values():
  881.         if item is not None and not isinstance(item, CoClassItem):
  882.             map[item.python_name] = item.clsid
  883.     for item in vtableItems.values(): # No nones or CoClasses in this map
  884.         map[item.python_name] = item.clsid
  885.             
  886.     print "NamesToIIDMap = {"
  887.     for name, iid in map.items():
  888.         print "\t'%s' : '%s'," % (name, iid)
  889.     print '}'
  890.     print
  891.  
  892.     if enumItems:
  893.       print 'win32com.client.constants.__dicts__.append(constants.__dict__)'
  894.     print
  895.  
  896.   def generate_child(self, child, dir):
  897.     "Generate a single child.  May force a few children to be built as we generate deps"
  898.     self.generate_type = GEN_DEMAND_CHILD
  899.     oldOut = sys.stdout
  900.  
  901.     la = self.typelib.GetLibAttr()
  902.     lcid = la[1]
  903.     clsid = la[0]
  904.     major=la[3]
  905.     minor=la[4]
  906.     self.base_mod_name = "win32com.gen_py." + str(clsid)[1:-1] + "x%sx%sx%s" % (lcid, major, minor)
  907.     try:
  908.       # Process the type library's CoClass objects, looking for the
  909.       # specified name, or where a child has the specified name.
  910.       # This ensures that all interesting things (including event interfaces)
  911.       # are generated correctly.
  912.       oleItems = {}
  913.       vtableItems = {}
  914.       infos = self.CollectOleItemInfosFromType()
  915.       found = 0
  916.       for type_info_tuple in infos:
  917.         info, infotype, doc, attr = type_info_tuple
  918.         if infotype == pythoncom.TKIND_COCLASS:
  919.             coClassItem, child_infos = self._Build_CoClass(type_info_tuple)
  920.             found = build.MakePublicAttributeName(doc[0])==child
  921.             if not found:
  922.                 # OK, check the child interfaces
  923.                 for info, info_type, refType, doc, refAttr, flags in child_infos:
  924.                     if build.MakePublicAttributeName(doc[0]) == child:
  925.                         found = 1
  926.                         break
  927.             if found:
  928.                 oleItems[coClassItem.clsid] = coClassItem
  929.                 self._Build_CoClassChildren(coClassItem, child_infos, oleItems, vtableItems)
  930.                 break
  931.       if not found:
  932.         # Doesn't appear in a class defn - look in the interface objects for it
  933.         for type_info_tuple in infos:
  934.           info, infotype, doc, attr = type_info_tuple
  935.           if infotype in [pythoncom.TKIND_INTERFACE, pythoncom.TKIND_DISPATCH]:
  936.             if build.MakePublicAttributeName(doc[0]) == child:
  937.               found = 1
  938.               oleItem, vtableItem = self._Build_Interface(type_info_tuple)
  939.               oleItems[clsid] = oleItem # Even "None" goes in here.
  940.               if vtableItem is not None:
  941.                 vtableItems[clsid] = vtableItem
  942.                 
  943.       assert found, "Cant find the '%s' interface in the CoClasses, or the interfaces" % (child,)
  944.       # Make a map of iid: dispitem, vtableitem)
  945.       items = {}
  946.       for key, value in oleItems.items():
  947.           items[key] = (value,None)
  948.       for key, value in vtableItems.items():
  949.           existing = items.get(key, None)
  950.           if existing is not None:
  951.               new_val = existing[0], value
  952.           else:
  953.               new_val = None, value
  954.           items[key] = new_val
  955.  
  956.       self.progress.SetDescription("Generating...", len(items))
  957.       for oleitem, vtableitem in items.values():
  958.         an_item = oleitem or vtableitem
  959.         self.file = open(os.path.join(dir, an_item.python_name) + ".py", "w")
  960.         sys.stdout = self.file
  961.         try:
  962.           if oleitem is not None:
  963.             self.do_gen_child_item(oleitem)
  964.           if vtableitem is not None:
  965.             self.do_gen_child_item(vtableitem)
  966.           self.progress.Tick()
  967.         finally:
  968.           sys.stdout = oldOut
  969.           self.file.close()
  970.           self.file = None
  971.     finally:
  972.       sys.stdout = oldOut
  973.       self.progress.Finished()
  974.  
  975.   def do_gen_child_item(self, oleitem):
  976.     moduleDoc = self.typelib.GetDocumentation(-1)
  977.     docDesc = ""
  978.     if moduleDoc[1]:
  979.       docDesc = moduleDoc[1]
  980.     self.progress.Starting(docDesc)
  981.     self.progress.SetDescription("Building definitions from type library...")
  982.     self.do_gen_file_header()
  983.     oleitem.WriteClass(self)
  984.     if oleitem.bIsDispatch:
  985.         print 'win32com.client.CLSIDToClass.RegisterCLSID( "%s", %s )' % (oleitem.clsid, oleitem.python_name)
  986.  
  987.   def checkWriteDispatchBaseClass(self):
  988.     if not self.bHaveWrittenDispatchBaseClass:
  989.       print "from win32com.client import DispatchBaseClass"
  990.       self.bHaveWrittenDispatchBaseClass = 1
  991.  
  992.   def checkWriteCoClassBaseClass(self):
  993.     if not self.bHaveWrittenCoClassBaseClass:
  994.       print "from win32com.client import CoClassBaseClass"
  995.       self.bHaveWrittenCoClassBaseClass = 1
  996.  
  997.   def checkWriteEventBaseClass(self):
  998.     # Not a base class as such...
  999.       if not self.bHaveWrittenEventBaseClass:
  1000.         # Nothing to do any more!
  1001.         self.bHaveWrittenEventBaseClass = 1
  1002.  
  1003. if __name__=='__main__':
  1004.   print "This is a worker module.  Please use makepy to generate Python files."
  1005.