comtypes 1.1.14__zip → 1.2.1__zip

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/tools/codegenerator.py

@@ -1,24 +1,29 @@
 # Code generator to generate code for everything contained in COM type
 # libraries.
 from __future__ import print_function
+import ctypes
+import keyword
+import logging
 import os
 import sys
+import textwrap
 if sys.version_info >= (3, 0):
     import io
 else:
     import cStringIO as io
-import keyword
-import ctypes
-import textwrap
 
-from comtypes.tools import typedesc
 import comtypes
-import comtypes.client
-import comtypes.client._generate
+from comtypes import TYPE_CHECKING, typeinfo
+from comtypes.tools import tlbparser, typedesc
+
+if TYPE_CHECKING:
+    from typing import (
+        Any, Dict, Iterator, List, Optional, Tuple, Union as _UnionT,
+    )
+
 
 version = comtypes.__version__
 
-import logging
 logger = logging.getLogger(__name__)
 
 __warn_on_munge__ = __debug__
@@ -158,17 +163,273 @@ def storage(t):
 
 ################################################################
 
-class Generator(object):
+def name_wrapper_module(tlib):
+    """Determine the name of a typelib wrapper module"""
+    libattr = tlib.GetLibAttr()
+    modname = "_%s_%s_%s_%s" % \
+              (str(libattr.guid)[1:-1].replace("-", "_"),
+               libattr.lcid,
+               libattr.wMajorVerNum,
+               libattr.wMinorVerNum)
+    return "comtypes.gen.%s" % modname
+
+
+def name_friendly_module(tlib):
+    """Determine the friendly-name of a typelib module.
+    If cannot get friendly-name from typelib, returns `None`.
+    """
+    try:
+        modulename = tlib.GetDocumentation(-1)[0]
+    except comtypes.COMError:
+        return
+    return "comtypes.gen.%s" % modulename
+
+################################################################
+
+
+def _to_arg_definition(type_name, arg_name, idlflags, default):
+    # type: (str, str, List[str], _UnionT[lcid, Any, None]) -> str
+    if default is not None:
+        elms = (idlflags, type_name, arg_name, default)
+        code = "        (%r, %s, '%s', %r)" % elms
+        if len(code) > 80:
+            code = (
+                "        (\n"
+                "            %r,\n"
+                "            %s,\n"
+                "            '%s',\n"
+                "            %r\n"
+                "        )"
+            ) % elms
+    else:
+        elms = (idlflags, type_name, arg_name)
+        code = "        (%r, %s, '%s')" % elms
+        if len(code) > 80:
+            code = (
+                "        (\n"
+                "            %r,\n"
+                "            %s,\n"
+                "            '%s',\n"
+                "        )"
+            ) % elms
+    return code
+
+
+class ComMethodGenerator(object):
+    def __init__(self, m, isdual):
+        # type: (typedesc.ComMethod, bool) -> None
+        self._m = m
+        self._isdual = isdual
+        self._stream = io.StringIO()
+        self._to_type_name = TypeNamer()
+
+    def generate(self):
+        # () -> str
+        if not self._m.arguments:
+            self._make_noargs()
+        else:
+            self._make_withargs()
+        return self._stream.getvalue()
+
+    def _get_common_elms(self):
+        # type: () -> Tuple[List[_UnionT[str, dispid, helpstring]], str, str]
+        idlflags = []  # type: List[_UnionT[str, dispid, helpstring]]
+        if self._isdual:
+            idlflags.append(dispid(self._m.memid))
+            idlflags.extend(self._m.idlflags)
+        else:  # We don't include the dispid for non-dispatch COM interfaces
+            idlflags.extend(self._m.idlflags)
+        if __debug__ and self._m.doc:
+            idlflags.insert(1, helpstring(self._m.doc))
+        type_name = self._to_type_name(self._m.returns)
+        return (idlflags, type_name, self._m.name)
+
+    def _make_noargs(self):
+        # type: () -> None
+        elms = self._get_common_elms()
+        code = "    COMMETHOD(%r, %s, '%s')," % elms
+        if len(code) > 80:
+            code = (
+                "    COMMETHOD(\n"
+                "        %r,\n"
+                "        %s,\n"
+                "        '%s',\n"
+                "    ),"
+            ) % elms
+        print(code, file=self._stream)
+    
+    def _make_withargs(self):
+        # type: () -> None
+        code = (
+            "    COMMETHOD(\n"
+            "        %r,\n"
+            "        %s,\n"
+            "        '%s',"
+        ) % self._get_common_elms()
+        print(code, file=self._stream)
+        arglist = [_to_arg_definition(*i) for i in self._iter_args()]
+        print(",\n".join(arglist), file=self._stream)
+        print("    ),", file=self._stream)
+
+    def _iter_args(self):
+        # type: () -> Iterator[Tuple[str, str, List[str], _UnionT[lcid, Any, None]]]
+        for typ, arg_name, _f, _defval in self._m.arguments:
+            ###########################################################
+            # IDL files that contain 'open arrays' or 'conformant
+            # varying arrays' method parameters are strange.
+            # These arrays have both a 'size_is()' and
+            # 'length_is()' attribute, like this example from
+            # dia2.idl (in the DIA SDK):
+            #
+            # interface IDiaSymbol: IUnknown {
+            # ...
+            #     HRESULT get_dataBytes(
+            #         [in] DWORD cbData,
+            #         [out] DWORD *pcbData,
+            #         [out, size_is(cbData),
+            #          length_is(*pcbData)] BYTE data[]
+            #     );
+            #
+            # The really strange thing is that the decompiled type
+            # library then contains this declaration, which declares
+            # the interface itself as [out] method parameter:
+            #
+            # interface IDiaSymbol: IUnknown {
+            # ...
+            #     HRESULT _stdcall get_dataBytes(
+            #         [in] unsigned long cbData,
+            #         [out] unsigned long* pcbData,
+            #         [out] IDiaSymbol data);
+            #
+            # Of course, comtypes does not accept a COM interface
+            # as method parameter; so replace the parameter type
+            # with the comtypes spelling of 'unsigned char *', and
+            # mark the parameter as [in, out], so the IDL
+            # equivalent would be like this:
+            #
+            # interface IDiaSymbol: IUnknown {
+            # ...
+            #     HRESULT _stdcall get_dataBytes(
+            #         [in] unsigned long cbData,
+            #         [out] unsigned long* pcbData,
+            #         [in, out] BYTE data[]);
+            ###########################################################
+            idlflags = list(_f)  # shallow copy to avoid side effects
+            if isinstance(typ, typedesc.ComInterface):
+                type_name = "OPENARRAY"
+                if 'in' not in idlflags:
+                    idlflags.append('in')
+            else:
+                type_name = self._to_type_name(typ)
+            if 'lcid' in idlflags:# and 'in' in idlflags:
+                default = lcid
+            else:
+                default = _defval
+            yield (type_name, arg_name, idlflags, default)
+
+
+class DispMethodGenerator(object):
+    def __init__(self, m):
+        # type: (typedesc.DispMethod) -> None
+        self._m = m
+        self._stream = io.StringIO()
+        self._to_type_name = TypeNamer()
 
-    def __init__(self, ofi, known_symbols=None):
-        self.output = ofi
+    def generate(self):
+        # () -> str
+        if not self._m.arguments:
+            self._make_noargs()
+        else:
+            self._make_withargs()
+        return self._stream.getvalue()
+
+    def _get_common_elms(self):
+        # type: () -> Tuple[List[_UnionT[str, dispid, helpstring]], str, str]
+        idlflags = []  # type: List[_UnionT[str, dispid, helpstring]]
+        idlflags.append(dispid(self._m.dispid))
+        idlflags.extend(self._m.idlflags)
+        if __debug__ and self._m.doc:
+            idlflags.insert(1, helpstring(self._m.doc))
+        type_name = self._to_type_name(self._m.returns)
+        return (idlflags, type_name, self._m.name)
+
+    def _make_noargs(self):
+        # type: () -> None
+        elms = self._get_common_elms()
+        code = "    DISPMETHOD(%r, %s, '%s')," % elms
+        if len(code) > 80:
+            code = (
+                "    DISPMETHOD(\n"
+                "        %r,\n"
+                "        %s,\n"
+                "        '%s',\n"
+                "    ),"
+            ) % elms
+        print(code, file=self._stream)
+    
+    def _make_withargs(self):
+        # type: () -> None
+        code = (
+            "    DISPMETHOD(\n"
+            "        %r,\n"
+            "        %s,\n"
+            "        '%s',"
+        ) % self._get_common_elms()
+        print(code, file=self._stream)
+        arglist = [_to_arg_definition(*i) for i in self._iter_args()]
+        print(",\n".join(arglist), file=self._stream)
+        print("    ),", file=self._stream)
+
+    def _iter_args(self):
+        # type: () -> Iterator[Tuple[str, str, List[str], _UnionT[lcid, Any, None]]]
+        for typ, arg_name, idlflags, default in self._m.arguments:
+            type_name = self._to_type_name(typ)
+            yield (type_name, arg_name, idlflags, default)
+
+
+class DispPropertyGenerator(object):
+    def __init__(self, m):
+        # type: (typedesc.DispProperty) -> None
+        self._m = m
+        self._to_type_name = TypeNamer()
+
+    def generate(self):
+        # () -> str
+        elms = self._get_common_elms()
+        code = "    DISPPROPERTY(%r, %s, '%s')," % elms
+        if len(code) > 80:
+            code = (
+                "    DISPPROPERTY(\n"
+                "        %r,\n"
+                "        %s,\n"
+                "        '%s'\n"
+                "    ),"
+            ) % elms
+        return code + "\n"
+
+    def _get_common_elms(self):
+        # type: () -> Tuple[List[_UnionT[str, dispid, helpstring]], str, str]
+        idlflags = []  # type: List[_UnionT[str, dispid, helpstring]]
+        idlflags.append(dispid(self._m.dispid))
+        idlflags.extend(self._m.idlflags)
+        if __debug__ and self._m.doc:
+            idlflags.insert(1, helpstring(self._m.doc))
+        type_name = self._to_type_name(self._m.typ)
+        return (idlflags, type_name, self._m.name)
+
+
+class CodeGenerator(object):
+
+    def __init__(self, known_symbols=None):
         self.stream = io.StringIO()
         self.imports = ImportedNamespaces()
         self.declarations = DeclaredNamespaces()
+        self._to_type_name = TypeNamer()
         self.known_symbols = known_symbols or {}
 
         self.done = set() # type descriptions that have been generated
         self.names = set() # names that have been generated
+        self.externals = []  # typelibs imported to generated module
         self.last_item_class = False
 
     def generate(self, item):
@@ -248,8 +509,8 @@ class Generator(object):
 
         if filename is not None:
             # get full path to DLL first (os.stat can't work with relative DLL paths properly)
-            loaded_typelib = comtypes.typeinfo.LoadTypeLib(filename)
-            full_filename = comtypes.tools.tlbparser.get_tlib_filename(
+            loaded_typelib = typeinfo.LoadTypeLib(filename)
+            full_filename = tlbparser.get_tlib_filename(
                 loaded_typelib)
 
             while full_filename and not os.path.exists(full_filename):
@@ -281,88 +542,29 @@ class Generator(object):
         if tlib_mtime is not None:
             logger.debug("filename: \"%s\": tlib_mtime: %s", filename, tlib_mtime)
             self.imports.add('comtypes', '_check_version')
-
+        output = io.StringIO()
         if filename is not None:
             # Hm, what is the CORRECT encoding?
-            print("# -*- coding: mbcs -*-", file=self.output)
-            print(file=self.output)
-        print(self.imports.getvalue(), file=self.output)
-        print(file=self.output)
-        print(self.declarations.getvalue(), file=self.output)
-        print(file=self.output)
-        print(self.stream.getvalue(), file=self.output)
-        dunder_all = "__all__ = [%s]" % ", ".join(repr(str(n)) for n in self.names)
+            print("# -*- coding: mbcs -*-", file=output)
+            print(file=output)
+        print(self.imports.getvalue(), file=output)
+        print(file=output)
+        print(self.declarations.getvalue(), file=output)
+        print(file=output)
+        print(self.stream.getvalue(), file=output)
+        names = ", ".join(repr(str(n)) for n in self.names)
+        dunder_all = "__all__ = [%s]" % names
         if len(dunder_all) > 80:
             wrapper = textwrap.TextWrapper(subsequent_indent="    ",
                                            initial_indent="    ",
                                            break_long_words=False)
-            names = ", ".join(repr(str(n)) for n in self.names)
             dunder_all = "__all__ = [\n%s\n]" % "\n".join(wrapper.wrap(names))
-        print(dunder_all, file=self.output)
-        print(file=self.output)
+        print(dunder_all, file=output)
+        print(file=output)
         if tlib_mtime is not None:
             print("_check_version(%r, %f)" % (version, tlib_mtime),
-                    file=self.output)
-
-        return loops
-
-    def type_name(self, t):
-        # Return a string, containing an expression which can be used
-        # to refer to the type. Assumes the 'from ctypes import *'
-        # namespace is available.
-        if isinstance(t, typedesc.SAFEARRAYType):
-            return "_midlSAFEARRAY(%s)" % self.type_name(t.typ)
-        # if isinstance(t, typedesc.CoClass):
-        #     return "%s._com_interfaces_[0]" % t.name
-        if isinstance(t, typedesc.Typedef):
-            return t.name
-        if isinstance(t, typedesc.PointerType):
-            if ASSUME_STRINGS:
-                x = get_real_type(t.typ)
-                if isinstance(x, typedesc.FundamentalType):
-                    if x.name == "char":
-                        return "STRING"
-                    elif x.name == "wchar_t":
-                        return "WSTRING"
-
-            result = "POINTER(%s)" % self.type_name(t.typ)
-            # XXX Better to inspect t.typ!
-            if result.startswith("POINTER(WINFUNCTYPE"):
-                return result[len("POINTER("):-1]
-            if result.startswith("POINTER(CFUNCTYPE"):
-                return result[len("POINTER("):-1]
-            elif result == "POINTER(None)":
-                return "c_void_p"
-            return result
-        elif isinstance(t, typedesc.ArrayType):
-            return "%s * %s" % (self.type_name(t.typ), int(t.max)+1)
-        elif isinstance(t, typedesc.FunctionType):
-            args = [self.type_name(x) for x in [t.returns] + list(t.iterArgTypes())]
-            if "__stdcall__" in t.attributes:
-                return "WINFUNCTYPE(%s)" % ", ".join(args)
-            else:
-                return "CFUNCTYPE(%s)" % ", ".join(args)
-        elif isinstance(t, typedesc.CvQualifiedType):
-            # const and volatile are ignored
-            return "%s" % self.type_name(t.typ)
-        elif isinstance(t, typedesc.FundamentalType):
-            return ctypes_names[t.name]
-        elif isinstance(t, typedesc.Structure):
-            return t.name
-        elif isinstance(t, typedesc.Enumeration):
-            if t.name:
-                return t.name
-            return "c_int" # enums are integers
-        elif isinstance(t, typedesc.EnumValue):
-            if keyword.iskeyword(t.name):
-                return t.name + "_"
-            return t.name
-        elif isinstance(t, typedesc.External):
-            # t.symbol_name - symbol to generate
-            # t.tlib - the ITypeLib pointer to the typelibrary containing the symbols definition
-            modname = comtypes.client._generate._name_module(t.tlib)
-            return "%s.%s" % (modname, t.symbol_name)
-        return t.name
+                    file=output)
+        return output.getvalue()
 
     def need_VARIANT_imports(self, value):
         text = repr(value)
@@ -371,10 +573,6 @@ class Generator(object):
         if "datetime.datetime(" in text:
             self.imports.add("datetime")
 
-    def need_GUID(self):
-        if "GUID" in self.known_symbols:
-            self.imports.add("GUID", symbols=self.known_symbols)
-
     def _to_docstring(self, orig, depth=1):
         # type: (str, int) -> str
         # increasing `depth` by one increases indentation by one
@@ -383,28 +581,25 @@ class Generator(object):
         repled = orig.replace("\\", r"\\").replace("\"", r"'")
         return '%s"""%s"""' % (indent, repled)
 
-    _arraytypes = 0
     def ArrayType(self, tp):
-        self._arraytypes += 1
+        # type: (typedesc.ArrayType) -> None
         self.generate(get_real_type(tp.typ))
         self.generate(tp.typ)
 
-    _enumvalues = 0
     def EnumValue(self, tp):
+        # type: (typedesc.EnumValue) -> None
         self.last_item_class = False
         value = int(tp.value)
         if keyword.iskeyword(tp.name):
             # XXX use logging!
             if __warn_on_munge__:
                 print("# Fixing keyword as EnumValue for %s" % tp.name)
-        tp_name = self.type_name(tp)
+        tp_name = self._to_type_name(tp)
         print("%s = %d" % (tp_name, value), file=self.stream)
         self.names.add(tp_name)
-        self._enumvalues += 1
 
-    _enumtypes = 0
     def Enumeration(self, tp):
-        self._enumtypes += 1
+        # type: (typedesc.Enumeration) -> None
         self.last_item_class = False
         if tp.name:
             print("# values for enumeration '%s'" % tp.name, file=self.stream)
@@ -420,15 +615,14 @@ class Generator(object):
             print("%s = c_int  # enum" % tp.name, file=self.stream)
             self.names.add(tp.name)
 
-    _typedefs = 0
     def Typedef(self, tp):
-        self._typedefs += 1
-        if type(tp.typ) in (typedesc.Structure, typedesc.Union):
+        # type: (typedesc.Typedef) -> None
+        if isinstance(tp.typ, (typedesc.Structure, typedesc.Union)):
             self.generate(tp.typ.get_head())
             self.more.add(tp.typ)
         else:
             self.generate(tp.typ)
-        definition = self.type_name(tp.typ)
+        definition = self._to_type_name(tp.typ)
         if tp.name != definition:
             if definition in self.known_symbols:
                 self.declarations.add(tp.name, definition)
@@ -438,18 +632,20 @@ class Generator(object):
         self.names.add(tp.name)
 
     def FundamentalType(self, item):
+        # type: (typedesc.FundamentalType) -> None
         pass # we should check if this is known somewhere
 
     def StructureHead(self, head):
+        # type: (typedesc.StructureHead) -> None
         for struct in head.struct.bases:
             self.generate(struct.get_head())
             self.more.add(struct)
         if head.struct.location:
             self.last_item_class = False
             print("# %s %s" % head.struct.location, file=self.stream)
-        basenames = [self.type_name(b) for b in head.struct.bases]
+        basenames = [self._to_type_name(b) for b in head.struct.bases]
         if basenames:
-            self.need_GUID()
+            self.imports.add("comtypes", "GUID")
 
             if not self.last_item_class:
                 print(file=self.stream)
@@ -519,17 +715,20 @@ class Generator(object):
                 print(file=self.stream)
         self.names.add(head.struct.name)
 
-    _structures = 0
     def Structure(self, struct):
-        self._structures += 1
+        # type: (typedesc.Structure) -> None
         self.generate(struct.get_head())
         self.generate(struct.get_body())
 
-    Union = Structure
+    def Union(self, union):
+        # type: (typedesc.Union) -> None
+        self.generate(union.get_head())
+        self.generate(union.get_body())
 
     def StructureBody(self, body):
-        fields = []
-        methods = []
+        # type: (typedesc.StructureBody) -> None
+        fields = []  # type: List[typedesc.Field]
+        methods = []  # type: List[typedesc.Method]
         for m in body.struct.members:
             if type(m) is typedesc.Field:
                 fields.append(m)
@@ -563,11 +762,6 @@ class Generator(object):
             if body.struct.bases:
                 assert len(body.struct.bases) == 1
                 self.generate(body.struct.bases[0].get_body())
-            # field definition normally span several lines.
-            # Before we generate them, we need to 'import' everything they need.
-            # So, call type_name for each field once,
-            for f in fields:
-                self.type_name(f.typ)
 
             if not self.last_item_class:
                 print(file=self.stream)
@@ -590,9 +784,9 @@ class Generator(object):
                 else:
                     fieldname = f.name
                 if f.bits is None:
-                    print("    ('%s', %s)," % (fieldname, self.type_name(f.typ)), file=self.stream)
+                    print("    ('%s', %s)," % (fieldname, self._to_type_name(f.typ)), file=self.stream)
                 else:
-                    print("    ('%s', %s, %s)," % (fieldname, self.type_name(f.typ), f.bits), file=self.stream)
+                    print("    ('%s', %s, %s)," % (fieldname, self._to_type_name(f.typ), f.bits), file=self.stream)
             print("]", file=self.stream)
 
             if body.struct.size is None:
@@ -611,13 +805,6 @@ class Generator(object):
 
         if methods:
             self.imports.add("comtypes", "COMMETHOD")
-            # method definitions normally span several lines.
-            # Before we generate them, we need to 'import' everything they need.
-            # So, call type_name for each field once,
-            for m in methods:
-                self.type_name(m.returns)
-                for a in m.iterArgTypes():
-                    self.type_name(a)
 
             if not self.last_item_class:
                 print(file=self.stream)
@@ -636,11 +823,11 @@ class Generator(object):
                         "        [], \n"
                         "        %s,\n"
                         "        '%s',\n"
-                    ) % (self.type_name(m.returns), m.name),
+                    ) % (self._to_type_name(m.returns), m.name),
                     file=self.stream
                 )
                 for a in m.iterArgTypes():
-                    print("        ([], %s),\n" % self.type_name(a), file=self.stream)
+                    print("        ([], %s),\n" % self._to_type_name(a), file=self.stream)
                     print("    ),", file=self.stream)
             print("]", file=self.stream)
 
@@ -648,8 +835,7 @@ class Generator(object):
     # top-level typedesc generators
     #
     def TypeLib(self, lib):
-        # lib.name, lib.gui, lib.major, lib.minor, lib.doc
-
+        # type: (typedesc.TypeLib) -> None
         # Hm, in user code we have to write:
         # class MyServer(COMObject, ...):
         #     _com_interfaces_ = [MyTypeLib.IInterface]
@@ -676,25 +862,27 @@ class Generator(object):
         print(file=self.stream)
 
     def External(self, ext):
-        modname = comtypes.client._generate._name_module(ext.tlib)
+        # type: (typedesc.External) -> None
+        modname = name_wrapper_module(ext.tlib)
         if modname not in self.imports:
-            comtypes.client.GetModule(ext.tlib)
+            self.externals.append(ext.tlib)
             self.imports.add(modname)
 
     def Constant(self, tp):
+        # type: (typedesc.Constant) -> None
         self.last_item_class = False
         print("%s = %r  # Constant %s" % (tp.name,
                                          tp.value,
-                                         self.type_name(tp.typ)), file=self.stream)
+                                         self._to_type_name(tp.typ)), file=self.stream)
         self.names.add(tp.name)
 
     def SAFEARRAYType(self, sa):
+        # type: (typedesc.SAFEARRAYType) -> None
         self.generate(sa.typ)
         self.imports.add("comtypes.automation", "_midlSAFEARRAY")
 
-    _pointertypes = 0
     def PointerType(self, tp):
-        self._pointertypes += 1
+        # type: (typedesc.PointerType) -> None
         if type(tp.typ) is typedesc.ComInterface:
             # this defines the class
             self.generate(tp.typ.get_head())
@@ -719,7 +907,8 @@ class Generator(object):
                 self.declarations.add("WSTRING", "c_wchar_p")
 
     def CoClass(self, coclass):
-        self.need_GUID()
+        # type: (typedesc.CoClass) -> None
+        self.imports.add("comtypes", "GUID")
         self.imports.add("comtypes", "CoClass")
         if not self.last_item_class:
             print(file=self.stream)
@@ -757,9 +946,9 @@ class Generator(object):
                 where = implemented
             if item[1] & 1: # IMPLTYPEFLAG_FDEAULT
                 # The default interface should be the first item on the list
-                where.insert(0, self.type_name(item[0]))
+                where.insert(0, self._to_type_name(item[0]))
             else:
-                where.append(self.type_name(item[0]))
+                where.append(self._to_type_name(item[0]))
 
         if implemented:
             self.last_item_class = False
@@ -771,11 +960,13 @@ class Generator(object):
         self.names.add(coclass.name)
 
     def ComInterface(self, itf):
+        # type: (typedesc.ComInterface) -> None
         self.generate(itf.get_head())
         self.generate(itf.get_body())
         self.names.add(itf.name)
 
     def _is_enuminterface(self, itf):
+        # type: (typedesc.ComInterface) -> bool
         # Check if this is an IEnumXXX interface
         if not itf.name.startswith("IEnum"):
             return False
@@ -786,6 +977,7 @@ class Generator(object):
         return True
 
     def ComInterfaceHead(self, head):
+        # type: (typedesc.ComInterfaceHead) -> None
         if head.itf.name in self.known_symbols:
             return
         base = head.itf.base
@@ -794,9 +986,9 @@ class Generator(object):
             return
         self.generate(base.get_head())
         self.more.add(base)
-        basename = self.type_name(head.itf.base)
+        basename = self._to_type_name(head.itf.base)
 
-        self.need_GUID()
+        self.imports.add("comtypes", "GUID")
 
         if not self.last_item_class:
             print(file=self.stream)
@@ -838,6 +1030,7 @@ class Generator(object):
         print(file=self.stream)
 
     def ComInterfaceBody(self, body):
+        # type: (typedesc.ComInterfaceBody) -> None
         # The base class must be fully generated, including the
         # _methods_ list.
         self.generate(body.itf.base)
@@ -908,15 +1101,17 @@ class Generator(object):
             print("#", file=self.stream)
 
     def DispInterface(self, itf):
+        # type: (typedesc.DispInterface) -> None
         self.generate(itf.get_head())
         self.generate(itf.get_body())
         self.names.add(itf.name)
 
     def DispInterfaceHead(self, head):
+        # type: (typedesc.DispInterfaceHead) -> None
         self.generate(head.itf.base)
-        basename = self.type_name(head.itf.base)
+        basename = self._to_type_name(head.itf.base)
 
-        self.need_GUID()
+        self.imports.add("comtypes", "GUID")
         if not self.last_item_class:
             print(file=self.stream)
             print(file=self.stream)
@@ -924,10 +1119,10 @@ class Generator(object):
         self.last_item_class = True
 
         print("class %s(%s):" % (head.itf.name, basename), file=self.stream)
-        print("    _case_insensitive_ = True", file=self.stream)
         doc = getattr(head.itf, "doc", None)
         if doc:
-            print("    %r" % doc, file=self.stream)
+            print(self._to_docstring(doc), file=self.stream)
+        print("    _case_insensitive_ = True", file=self.stream)
         print("    _iid_ = GUID(%r)" % head.itf.iid, file=self.stream)
         print("    _idlflags_ = %s" % head.itf.idlflags, file=self.stream)
         print("    _methods_ = []", file=self.stream)
@@ -935,6 +1130,7 @@ class Generator(object):
         print(file=self.stream)
 
     def DispInterfaceBody(self, body):
+        # type: (typedesc.DispInterfaceBody) -> None
         # make sure we can generate the body
         for m in body.itf.members:
             if isinstance(m, typedesc.DispMethod):
@@ -965,206 +1161,108 @@ class Generator(object):
     # non-toplevel method generators
     #
     def make_ComMethod(self, m, isdual):
+        # type: (typedesc.ComMethod, bool) -> None
         self.imports.add("comtypes", "COMMETHOD")
-        # typ, name, idlflags, default
         if isdual:
             self.imports.add("comtypes", "dispid")
-            idlflags = [dispid(m.memid)] + m.idlflags
-        else:
-            # We don't include the dispid for non-dispatch COM interfaces
-            idlflags = m.idlflags
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
-            idlflags.insert(1, helpstring(m.doc))
-
+        gen = ComMethodGenerator(m, isdual)
+        print(gen.generate(), file=self.stream, end="")
         self.last_item_class = False
-        if not m.arguments:
-            code = "    COMMETHOD(%r, %s, '%s')," % (idlflags, self.type_name(m.returns), m.name)
-            if len(code) > 80:
-                code = (
-                    "    COMMETHOD(\n"
-                    "        %r,\n"
-                    "        %s,\n"
-                    "        '%s',\n"
-                    "    ),"
-                ) % (idlflags, self.type_name(m.returns), m.name)
-
-            print(code, file=self.stream)
-        else:
-            code = (
-                "    COMMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',"
-            ) % (idlflags, self.type_name(m.returns), m.name)
-            print(code, file=self.stream)
-            arglist = []
-            for typ, name, idlflags, default in m.arguments:
-                type_name = self.type_name(typ)
-                ###########################################################
-                # IDL files that contain 'open arrays' or 'conformant
-                # varying arrays' method parameters are strange.
-                # These arrays have both a 'size_is()' and
-                # 'length_is()' attribute, like this example from
-                # dia2.idl (in the DIA SDK):
-                #
-                # interface IDiaSymbol: IUnknown {
-                # ...
-                #     HRESULT get_dataBytes(
-                #         [in] DWORD cbData,
-                #         [out] DWORD *pcbData,
-                #         [out, size_is(cbData),
-                #          length_is(*pcbData)] BYTE data[]
-                #     );
-                #
-                # The really strange thing is that the decompiled type
-                # library then contains this declaration, which declares
-                # the interface itself as [out] method parameter:
-                #
-                # interface IDiaSymbol: IUnknown {
-                # ...
-                #     HRESULT _stdcall get_dataBytes(
-                #         [in] unsigned long cbData,
-                #         [out] unsigned long* pcbData,
-                #         [out] IDiaSymbol data);
-                #
-                # Of course, comtypes does not accept a COM interface
-                # as method parameter; so replace the parameter type
-                # with the comtypes spelling of 'unsigned char *', and
-                # mark the parameter as [in, out], so the IDL
-                # equivalent would be like this:
-                #
-                # interface IDiaSymbol: IUnknown {
-                # ...
-                #     HRESULT _stdcall get_dataBytes(
-                #         [in] unsigned long cbData,
-                #         [out] unsigned long* pcbData,
-                #         [in, out] BYTE data[]);
-                ###########################################################
-                if isinstance(typ, typedesc.ComInterface):
-                    self.declarations.add("OPENARRAY", "POINTER(c_ubyte)",
-                        "hack, see comtypes/tools/codegenerator.py")
-                    type_name = "OPENARRAY"
-                    if 'in' not in idlflags:
-                        idlflags.append('in')
-                if 'lcid' in idlflags:# and 'in' in idlflags:
-                    default = lcid
-                if default is not None:
-                    self.need_VARIANT_imports(default)
-
-                    code = "        (%r, %s, '%s', %r)" % (idlflags, type_name, name, default)
-
-                    if len(code) > 80:
-                        code = (
-                            "        (\n"
-                            "            %r,\n"
-                            "            %s,\n"
-                            "            '%s',\n"
-                            "            %r\n"
-                            "        )"
-                        ) % (idlflags, type_name, name, default)
-                else:
-                    code = "        (%r, %s, '%s')" % (idlflags, type_name, name)
-                    if len(code) > 80:
-                        code = (
-                            "        (\n"
-                            "            %r,\n"
-                            "            %s,\n"
-                            "            '%s',\n"
-                            "        )"
-                        ) % (idlflags, type_name, name)
-
-                arglist.append(code)
-
-            print(",\n".join(arglist), file=self.stream)
-            print("    ),", file=self.stream)
+        for typ, _, _, default in m.arguments:
+            if isinstance(typ, typedesc.ComInterface):
+                self.declarations.add("OPENARRAY", "POINTER(c_ubyte)",
+                    "hack, see comtypes/tools/codegenerator.py")
+            if default is not None:
+                self.need_VARIANT_imports(default)
 
     def make_DispMethod(self, m):
+        # type: (typedesc.DispMethod) -> None
         self.imports.add("comtypes", "DISPMETHOD")
         self.imports.add("comtypes", "dispid")
-        idlflags = [dispid(m.dispid)] + m.idlflags
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
-            idlflags.insert(1, helpstring(m.doc))
-
+        gen = DispMethodGenerator(m)
+        print(gen.generate(), file=self.stream, end="")
         self.last_item_class = False
-
-        # typ, name, idlflags, default
-        if not m.arguments:
-            code = "    DISPMETHOD(%r, %s, '%s')," % (idlflags, self.type_name(m.returns), m.name)
-            if len(code) > 80:
-                code = (
-                    "    DISPMETHOD(\n"
-                    "        %r,\n"
-                    "        %s,\n"
-                    "        '%s'\n"
-                    "    ),"
-                ) % (idlflags, self.type_name(m.returns), m.name)
-
-            print(code, file=self.stream)
-        else:
-            code = (
-                "    DISPMETHOD(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s',"
-                ) % (idlflags, self.type_name(m.returns), m.name)
-
-            print(code, file=self.stream)
-
-            arglist = []
-            for typ, name, idlflags, default in m.arguments:
+        for _, _, _, default in m.arguments:
+            if default is not None:
                 self.need_VARIANT_imports(default)
-                if default is not None:
-                    code = "        (%r, %s, '%s', %r)" % (idlflags, self.type_name(typ), name, default)
-                    if len(code) > 80:
-                        code = (
-                            "        (\n"
-                            "            %r,\n"
-                            "            %s,\n"
-                            "            '%s',\n"
-                            "            %r\n"
-                            "        )"
-                        ) % (idlflags, self.type_name(typ), name, default)
-
-
-                else:
-                    code = "        (%r, %s, '%s')" % (idlflags, self.type_name(typ), name)
-
-                    if len(code) > 80:
-                        code = (
-                            "        (\n"
-                            "            %r,\n"
-                            "            %s,\n"
-                            "            '%s'\n"
-                            "        )"
-                        ) % (idlflags, self.type_name(typ), name)
-
-                arglist.append(code)
-
-            print(",\n".join(arglist), file=self.stream)
-            print("    ),", file=self.stream)
 
     def make_DispProperty(self, prop):
+        # type: (typedesc.DispProperty) -> None
         self.imports.add("comtypes", "DISPPROPERTY")
         self.imports.add("comtypes", "dispid")
-        idlflags = [dispid(prop.dispid)] + prop.idlflags
         if __debug__ and prop.doc:
             self.imports.add("comtypes", "helpstring")
-            idlflags.insert(1, helpstring(prop.doc))
-
+        gen = DispPropertyGenerator(prop)
+        print(gen.generate(), file=self.stream, end="")
         self.last_item_class = False
-        code = "    DISPPROPERTY(%r, %s, '%s')," % (idlflags, self.type_name(prop.typ), prop.name)
-        if len(code) > 80:
-            code = (
-                "    DISPPROPERTY(\n"
-                "        %r,\n"
-                "        %s,\n"
-                "        '%s'\n"
-                "    ),"
-            ) % (idlflags, self.type_name(prop.typ), prop.name)
 
-        print(code, file=self.stream)
+
+class TypeNamer(object):
+    def __call__(self, t):
+        # type: (Any) -> str
+        # Return a string, containing an expression which can be used
+        # to refer to the type. Assumes the 'from ctypes import *'
+        # namespace is available.
+        if isinstance(t, typedesc.SAFEARRAYType):
+            return "_midlSAFEARRAY(%s)" % self(t.typ)
+        # if isinstance(t, typedesc.CoClass):
+        #     return "%s._com_interfaces_[0]" % t.name
+        if isinstance(t, typedesc.Typedef):
+            return t.name
+        if isinstance(t, typedesc.PointerType):
+            _t, pcnt = self._inspect_PointerType(t)
+            return "%s%s%s" % ("POINTER("*pcnt, self(_t), ")"*pcnt)
+        elif isinstance(t, typedesc.ArrayType):
+            return "%s * %s" % (self(t.typ), int(t.max)+1)
+        elif isinstance(t, typedesc.FunctionType):
+            args = [self(x) for x in [t.returns] + list(t.iterArgTypes())]
+            if "__stdcall__" in t.attributes:
+                return "WINFUNCTYPE(%s)" % ", ".join(args)
+            else:
+                return "CFUNCTYPE(%s)" % ", ".join(args)
+        elif isinstance(t, typedesc.CvQualifiedType):
+            # const and volatile are ignored
+            return "%s" % self(t.typ)
+        elif isinstance(t, typedesc.FundamentalType):
+            return ctypes_names[t.name]
+        elif isinstance(t, typedesc.Structure):
+            return t.name
+        elif isinstance(t, typedesc.Enumeration):
+            if t.name:
+                return t.name
+            return "c_int" # enums are integers
+        elif isinstance(t, typedesc.EnumValue):
+            if keyword.iskeyword(t.name):
+                return t.name + "_"
+            return t.name
+        elif isinstance(t, typedesc.External):
+            # t.symbol_name - symbol to generate
+            # t.tlib - the ITypeLib pointer to the typelibrary containing the symbols definition
+            modname = name_wrapper_module(t.tlib)
+            return "%s.%s" % (modname, t.symbol_name)
+        return t.name
+
+    def _inspect_PointerType(self, t, count=0):
+        # type: (typedesc.PointerType, int) -> Tuple[Any, int]
+        if ASSUME_STRINGS:
+            x = get_real_type(t.typ)
+            if isinstance(x, typedesc.FundamentalType):
+                if x.name == "char":
+                    return typedesc.Typedef("STRING", x), count
+                elif x.name == "wchar_t":
+                    return typedesc.Typedef("WSTRING", x), count
+        if isinstance(t.typ, typedesc.FunctionType):
+            return t.typ, count
+        if isinstance(t.typ, typedesc.FundamentalType):
+            if t.typ.name == "void":
+                return typedesc.Typedef("c_void_p", t.typ), count
+        if isinstance(t.typ, typedesc.PointerType):
+            return self._inspect_PointerType(t.typ, count + 1)
+        return t.typ, count + 1
 
 
 class ImportedNamespaces(object):
@@ -1184,16 +1282,33 @@ class ImportedNamespaces(object):
             >>> imports.add('ctypes', '*')
             >>> imports.add('decimal', 'Decimal')
             >>> imports.add('GUID', symbols={'GUID': 'comtypes'})
-            >>> for name in ('COMMETHOD', 'IUnknown', 'dispid', 'CoClass',
-            ...              'BSTR', 'DISPPROPERTY'):
+            >>> for name in ('COMMETHOD', 'DISPMETHOD', 'IUnknown', 'dispid',
+            ...              'CoClass', 'BSTR', 'DISPPROPERTY'):
             ...     imports.add('comtypes', name)
             >>> imports.add('ctypes.wintypes')
             >>> print(imports.getvalue())
             from ctypes import *
             import datetime
             from decimal import Decimal
-            from comtypes import BSTR, CoClass, COMMETHOD, dispid, DISPPROPERTY, \\
-                GUID, IUnknown
+            from comtypes import (
+                BSTR, CoClass, COMMETHOD, dispid, DISPMETHOD, DISPPROPERTY, GUID,
+                IUnknown
+            )
+            import ctypes.wintypes
+            >>> print(imports.getvalue(for_stub=True))
+            from ctypes import *
+            import datetime
+            from decimal import Decimal as Decimal
+            from comtypes import (
+                BSTR as BSTR,
+                CoClass as CoClass,
+                COMMETHOD as COMMETHOD,
+                dispid as dispid,
+                DISPMETHOD as DISPMETHOD,
+                DISPPROPERTY as DISPPROPERTY,
+                GUID as GUID,
+                IUnknown as IUnknown,
+            )
             import ctypes.wintypes
         """
         if name2 is None:
@@ -1232,32 +1347,40 @@ class ImportedNamespaces(object):
             return self.data[import_] == from_
         return False
 
-    def _make_line(self, import_, from_=None):
-        if from_ is None:
-            return "import %s" % import_
+    def _make_line(self, from_, imports, for_stub):
+        if for_stub:
+            import_ = ", ".join("%s as %s" % (n, n) for n in imports)
+        else:
+            import_ = ", ".join(imports)
         code = "from %s import %s" % (from_, import_)
-        if len(code) > 80:
+        if len(code) <= 80:
+            return code
+        if for_stub:
+            import_ = "\n".join("    %s as %s," % (n, n) for n in imports)
+        else:
             wrapper = textwrap.TextWrapper(subsequent_indent="    ",
+                                           initial_indent="    ",
                                            break_long_words=False)
-            code = " \\\n".join(wrapper.wrap(code))
+            import_ = "\n".join(wrapper.wrap(import_))
+        code = "from %s import (\n%s\n)" % (from_, import_)
         return code
 
-    def getvalue(self):
+    def getvalue(self, for_stub=False):
         ns = {}
         lines = []
         for key, val in self.data.items():
             if val is None:
                 ns[key] = val
             elif key == "*":
-                lines.append(self._make_line("*", val))
+                lines.append("from %s import *" % val)
             else:
                 ns.setdefault(val, set()).add(key)
         for key, val in ns.items():
             if val is None:
-                lines.append(self._make_line(key))
+                lines.append("import %s" % key)
             else:
-                names = ", ".join(sorted(val, key=lambda s: s.lower()))
-                lines.append(self._make_line(names, key))
+                names = sorted(val, key=lambda s: s.lower())
+                lines.append(self._make_line(key, names, for_stub=for_stub))
         return "\n".join(lines)
 
 
@@ -1290,9 +1413,3 @@ class DeclaredNamespaces(object):
                 code = code + "  # %s" % comment
             lines.append(code)
         return "\n".join(lines)
-
-
-# shortcut for development
-if __name__ == "__main__":
-    from . import tlbparser
-    tlbparser.main()