cpython/Lib/plat-mac/gensuitemodule.py

"""
gensuitemodule - Generate an AE suite module from an aete/aeut resource

Based on aete.py.

Reading and understanding this code is left as an exercise to the reader.
"""

from warnings import warnpy3k
warnpy3k("In 3.x, the gensuitemodule module is removed.", stacklevel=2)

import MacOS
import EasyDialogs
import os
import string
import sys
import types
import StringIO
import keyword
import macresource
import aetools
import distutils.sysconfig
import OSATerminology
from Carbon.Res import *
import Carbon.Folder
import MacOS
import getopt
import plistlib

_MAC_LIB_FOLDER=os.path.dirname(aetools.__file__)
DEFAULT_STANDARD_PACKAGEFOLDER=os.path.join(_MAC_LIB_FOLDER, 'lib-scriptpackages')
DEFAULT_USER_PACKAGEFOLDER=distutils.sysconfig.get_python_lib()

def usage():
    sys.stderr.write("Usage: %s [opts] application-or-resource-file\n" % sys.argv[0])
    sys.stderr.write("""Options:
--output pkgdir  Pathname of the output package (short: -o)
--resource       Parse resource file in stead of launching application (-r)
--base package   Use another base package in stead of default StdSuites (-b)
--edit old=new   Edit suite names, use empty new to skip a suite (-e)
--creator code   Set creator code for package (-c)
--dump           Dump aete resource to stdout in stead of creating module (-d)
--verbose        Tell us what happens (-v)
""")
    sys.exit(1)

def main():
    if len(sys.argv) > 1:
        SHORTOPTS = "rb:o:e:c:dv"
        LONGOPTS = ("resource", "base=", "output=", "edit=", "creator=", "dump", "verbose")
        try:
            opts, args = getopt.getopt(sys.argv[1:], SHORTOPTS, LONGOPTS)
        except getopt.GetoptError:
            usage()

        process_func = processfile
        basepkgname = 'StdSuites'
        output = None
        edit_modnames = []
        creatorsignature = None
        dump = None
        verbose = None

        for o, a in opts:
            if o in ('-r', '--resource'):
                process_func = processfile_fromresource
            if o in ('-b', '--base'):
                basepkgname = a
            if o in ('-o', '--output'):
                output = a
            if o in ('-e', '--edit'):
                split = a.split('=')
                if len(split) != 2:
                    usage()
                edit_modnames.append(split)
            if o in ('-c', '--creator'):
                if len(a) != 4:
                    sys.stderr.write("creator must be 4-char string\n")
                    sys.exit(1)
                creatorsignature = a
            if o in ('-d', '--dump'):
                dump = sys.stdout
            if o in ('-v', '--verbose'):
                verbose = sys.stderr


        if output and len(args) > 1:
            sys.stderr.write("%s: cannot specify --output with multiple inputs\n" % sys.argv[0])
            sys.exit(1)

        for filename in args:
            process_func(filename, output=output, basepkgname=basepkgname,
                edit_modnames=edit_modnames, creatorsignature=creatorsignature,
                dump=dump, verbose=verbose)
    else:
        main_interactive()

def main_interactive(interact=0, basepkgname='StdSuites'):
    if interact:
        # Ask for save-filename for each module
        edit_modnames = None
    else:
        # Use default filenames for each module
        edit_modnames = []
    appsfolder = Carbon.Folder.FSFindFolder(-32765, 'apps', 0)
    filename = EasyDialogs.AskFileForOpen(
        message='Select scriptable application',
        dialogOptionFlags=0x1056,       # allow selection of .app bundles
        defaultLocation=appsfolder)
    if not filename:
        return
    if not is_scriptable(filename):
        if EasyDialogs.AskYesNoCancel(
                "Warning: application does not seem scriptable",
                yes="Continue", default=2, no="") <= 0:
            return
    try:
        processfile(filename, edit_modnames=edit_modnames, basepkgname=basepkgname,
        verbose=sys.stderr)
    except MacOS.Error, arg:
        print "Error getting terminology:", arg
        print "Retry, manually parsing resources"
        processfile_fromresource(filename, edit_modnames=edit_modnames,
            basepkgname=basepkgname, verbose=sys.stderr)

def is_scriptable(application):
    """Return true if the application is scriptable"""
    if os.path.isdir(application):
        plistfile = os.path.join(application, 'Contents', 'Info.plist')
        if not os.path.exists(plistfile):
            return False
        plist = plistlib.Plist.fromFile(plistfile)
        return plist.get('NSAppleScriptEnabled', False)
    # If it is a file test for an aete/aeut resource.
    currf = CurResFile()
    try:
        refno = macresource.open_pathname(application)
    except MacOS.Error:
        return False
    UseResFile(refno)
    n_terminology = Count1Resources('aete') + Count1Resources('aeut') + \
        Count1Resources('scsz') + Count1Resources('osiz')
    CloseResFile(refno)
    UseResFile(currf)
    return n_terminology > 0

def processfile_fromresource(fullname, output=None, basepkgname=None,
        edit_modnames=None, creatorsignature=None, dump=None, verbose=None):
    """Process all resources in a single file"""
    if not is_scriptable(fullname) and verbose:
        print >>verbose, "Warning: app does not seem scriptable: %s" % fullname
    cur = CurResFile()
    if verbose:
        print >>verbose, "Processing", fullname
    rf = macresource.open_pathname(fullname)
    try:
        UseResFile(rf)
        resources = []
        for i in range(Count1Resources('aete')):
            res = Get1IndResource('aete', 1+i)
            resources.append(res)
        for i in range(Count1Resources('aeut')):
            res = Get1IndResource('aeut', 1+i)
            resources.append(res)
        if verbose:
            print >>verbose, "\nLISTING aete+aeut RESOURCES IN", repr(fullname)
        aetelist = []
        for res in resources:
            if verbose:
                print >>verbose, "decoding", res.GetResInfo(), "..."
            data = res.data
            aete = decode(data, verbose)
            aetelist.append((aete, res.GetResInfo()))
    finally:
        if rf != cur:
            CloseResFile(rf)
            UseResFile(cur)
    # switch back (needed for dialogs in Python)
    UseResFile(cur)
    if dump:
        dumpaetelist(aetelist, dump)
    compileaetelist(aetelist, fullname, output=output,
        basepkgname=basepkgname, edit_modnames=edit_modnames,
        creatorsignature=creatorsignature, verbose=verbose)

def processfile(fullname, output=None, basepkgname=None,
        edit_modnames=None, creatorsignature=None, dump=None,
        verbose=None):
    """Ask an application for its terminology and process that"""
    if not is_scriptable(fullname) and verbose:
        print >>verbose, "Warning: app does not seem scriptable: %s" % fullname
    if verbose:
        print >>verbose, "\nASKING FOR aete DICTIONARY IN", repr(fullname)
    try:
        aedescobj, launched = OSATerminology.GetAppTerminology(fullname)
    except MacOS.Error, arg:
        if arg[0] in (-1701, -192): # errAEDescNotFound, resNotFound
            if verbose:
                print >>verbose, "GetAppTerminology failed with errAEDescNotFound/resNotFound, trying manually"
            aedata, sig = getappterminology(fullname, verbose=verbose)
            if not creatorsignature:
                creatorsignature = sig
        else:
            raise
    else:
        if launched:
            if verbose:
                print >>verbose, "Launched", fullname
        raw = aetools.unpack(aedescobj)
        if not raw:
            if verbose:
                print >>verbose, 'Unpack returned empty value:', raw
            return
        if not raw[0].data:
            if verbose:
                print >>verbose, 'Unpack returned value without data:', raw
            return
        aedata = raw[0]
    aete = decode(aedata.data, verbose)
    if dump:
        dumpaetelist([aete], dump)
        return
    compileaete(aete, None, fullname, output=output, basepkgname=basepkgname,
        creatorsignature=creatorsignature, edit_modnames=edit_modnames,
        verbose=verbose)

def getappterminology(fullname, verbose=None):
    """Get application terminology by sending an AppleEvent"""
    # First check that we actually can send AppleEvents
    if not MacOS.WMAvailable():
        raise RuntimeError, "Cannot send AppleEvents, no access to window manager"
    # Next, a workaround for a bug in MacOS 10.2: sending events will hang unless
    # you have created an event loop first.
    import Carbon.Evt
    Carbon.Evt.WaitNextEvent(0,0)
    if os.path.isdir(fullname):
        # Now get the signature of the application, hoping it is a bundle
        pkginfo = os.path.join(fullname, 'Contents', 'PkgInfo')
        if not os.path.exists(pkginfo):
            raise RuntimeError, "No PkgInfo file found"
        tp_cr = open(pkginfo, 'rb').read()
        cr = tp_cr[4:8]
    else:
        # Assume it is a file
        cr, tp = MacOS.GetCreatorAndType(fullname)
    # Let's talk to it and ask for its AETE
    talker = aetools.TalkTo(cr)
    try:
        talker._start()
    except (MacOS.Error, aetools.Error), arg:
        if verbose:
            print >>verbose, 'Warning: start() failed, continuing anyway:', arg
    reply = talker.send("ascr", "gdte")
    #reply2 = talker.send("ascr", "gdut")
    # Now pick the bits out of the return that we need.
    return reply[1]['----'], cr


def compileaetelist(aetelist, fullname, output=None, basepkgname=None,
            edit_modnames=None, creatorsignature=None, verbose=None):
    for aete, resinfo in aetelist:
        compileaete(aete, resinfo, fullname, output=output,
            basepkgname=basepkgname, edit_modnames=edit_modnames,
            creatorsignature=creatorsignature, verbose=verbose)

def dumpaetelist(aetelist, output):
    import pprint
    pprint.pprint(aetelist, output)

def decode(data, verbose=None):
    """Decode a resource into a python data structure"""
    f = StringIO.StringIO(data)
    aete = generic(getaete, f)
    aete = simplify(aete)
    processed = f.tell()
    unprocessed = len(f.read())
    total = f.tell()
    if unprocessed and verbose:
        verbose.write("%d processed + %d unprocessed = %d total\n" %
                         (processed, unprocessed, total))
    return aete

def simplify(item):
    """Recursively replace singleton tuples by their constituent item"""
    if type(item) is types.ListType:
        return map(simplify, item)
    elif type(item) == types.TupleType and len(item) == 2:
        return simplify(item[1])
    else:
        return item


# Here follows the aete resource decoder.
# It is presented bottom-up instead of top-down because there are  direct
# references to the lower-level part-decoders from the high-level part-decoders.

def getbyte(f, *args):
    c = f.read(1)
    if not c:
        raise EOFError, 'in getbyte' + str(args)
    return ord(c)

def getword(f, *args):
    getalign(f)
    s = f.read(2)
    if len(s) < 2:
        raise EOFError, 'in getword' + str(args)
    return (ord(s[0])<<8) | ord(s[1])

def getlong(f, *args):
    getalign(f)
    s = f.read(4)
    if len(s) < 4:
        raise EOFError, 'in getlong' + str(args)
    return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])

def getostype(f, *args):
    getalign(f)
    s = f.read(4)
    if len(s) < 4:
        raise EOFError, 'in getostype' + str(args)
    return s

def getpstr(f, *args):
    c = f.read(1)
    if len(c) < 1:
        raise EOFError, 'in getpstr[1]' + str(args)
    nbytes = ord(c)
    if nbytes == 0: return ''
    s = f.read(nbytes)
    if len(s) < nbytes:
        raise EOFError, 'in getpstr[2]' + str(args)
    return s

def getalign(f):
    if f.tell() & 1:
        c = f.read(1)
        ##if c != '\0':
        ##  print align:', repr(c)

def getlist(f, description, getitem):
    count = getword(f)
    list = []
    for i in range(count):
        list.append(generic(getitem, f))
        getalign(f)
    return list

def alt_generic(what, f, *args):
    print "generic", repr(what), args
    res = vageneric(what, f, args)
    print '->', repr(res)
    return res

def generic(what, f, *args):
    if type(what) == types.FunctionType:
        return apply(what, (f,) + args)
    if type(what) == types.ListType:
        record = []
        for thing in what:
            item = apply(generic, thing[:1] + (f,) + thing[1:])
            record.append((thing[1], item))
        return record
    return "BAD GENERIC ARGS: %r" % (what,)

getdata = [
    (getostype, "type"),
    (getpstr, "description"),
    (getword, "flags")
    ]
getargument = [
    (getpstr, "name"),
    (getostype, "keyword"),
    (getdata, "what")
    ]
getevent = [
    (getpstr, "name"),
    (getpstr, "description"),
    (getostype, "suite code"),
    (getostype, "event code"),
    (getdata, "returns"),
    (getdata, "accepts"),
    (getlist, "optional arguments", getargument)
    ]
getproperty = [
    (getpstr, "name"),
    (getostype, "code"),
    (getdata, "what")
    ]
getelement = [
    (getostype, "type"),
    (getlist, "keyform", getostype)
    ]
getclass = [
    (getpstr, "name"),
    (getostype, "class code"),
    (getpstr, "description"),
    (getlist, "properties", getproperty),
    (getlist, "elements", getelement)
    ]
getcomparison = [
    (getpstr, "operator name"),
    (getostype, "operator ID"),
    (getpstr, "operator comment"),
    ]
getenumerator = [
    (getpstr, "enumerator name"),
    (getostype, "enumerator ID"),
    (getpstr, "enumerator comment")
    ]
getenumeration = [
    (getostype, "enumeration ID"),
    (getlist, "enumerator", getenumerator)
    ]
getsuite = [
    (getpstr, "suite name"),
    (getpstr, "suite description"),
    (getostype, "suite ID"),
    (getword, "suite level"),
    (getword, "suite version"),
    (getlist, "events", getevent),
    (getlist, "classes", getclass),
    (getlist, "comparisons", getcomparison),
    (getlist, "enumerations", getenumeration)
    ]
getaete = [
    (getword, "major/minor version in BCD"),
    (getword, "language code"),
    (getword, "script code"),
    (getlist, "suites", getsuite)
    ]

def compileaete(aete, resinfo, fname, output=None, basepkgname=None,
        edit_modnames=None, creatorsignature=None, verbose=None):
    """Generate code for a full aete resource. fname passed for doc purposes"""
    [version, language, script, suites] = aete
    major, minor = divmod(version, 256)
    if not creatorsignature:
        creatorsignature, dummy = MacOS.GetCreatorAndType(fname)
    packagename = identify(os.path.splitext(os.path.basename(fname))[0])
    if language:
        packagename = packagename+'_lang%d'%language
    if script:
        packagename = packagename+'_script%d'%script
    if len(packagename) > 27:
        packagename = packagename[:27]
    if output:
        # XXXX Put this in site-packages if it isn't a full pathname?
        if not os.path.exists(output):
            os.mkdir(output)
        pathname = output
    else:
        pathname = EasyDialogs.AskFolder(message='Create and select package folder for %s'%packagename,
            defaultLocation=DEFAULT_USER_PACKAGEFOLDER)
        output = pathname
    if not pathname:
        return
    packagename = os.path.split(os.path.normpath(pathname))[1]
    if not basepkgname:
        basepkgname = EasyDialogs.AskFolder(message='Package folder for base suite (usually StdSuites)',
            defaultLocation=DEFAULT_STANDARD_PACKAGEFOLDER)
    if basepkgname:
        dirname, basepkgname = os.path.split(os.path.normpath(basepkgname))
        if dirname and not dirname in sys.path:
            sys.path.insert(0, dirname)
        basepackage = __import__(basepkgname)
    else:
        basepackage = None
    suitelist = []
    allprecompinfo = []
    allsuites = []
    for suite in suites:
        compiler = SuiteCompiler(suite, basepackage, output, edit_modnames, verbose)
        code, modname, precompinfo = compiler.precompilesuite()
        if not code:
            continue
        allprecompinfo = allprecompinfo + precompinfo
        suiteinfo = suite, pathname, modname
        suitelist.append((code, modname))
        allsuites.append(compiler)
    for compiler in allsuites:
        compiler.compilesuite(major, minor, language, script, fname, allprecompinfo)
    initfilename = os.path.join(output, '__init__.py')
    fp = open(initfilename, 'w')
    MacOS.SetCreatorAndType(initfilename, 'Pyth', 'TEXT')
    fp.write('"""\n')
    fp.write("Package generated from %s\n"%ascii(fname))
    if resinfo:
        fp.write("Resource %s resid %d %s\n"%(ascii(resinfo[1]), resinfo[0], ascii(resinfo[2])))
    fp.write('"""\n')
    fp.write('import aetools\n')
    fp.write('Error = aetools.Error\n')
    suitelist.sort()
    for code, modname in suitelist:
        fp.write("import %s\n" % modname)
    fp.write("\n\n_code_to_module = {\n")
    for code, modname in suitelist:
        fp.write("    '%s' : %s,\n"%(ascii(code), modname))
    fp.write("}\n\n")
    fp.write("\n\n_code_to_fullname = {\n")
    for code, modname in suitelist:
        fp.write("    '%s' : ('%s.%s', '%s'),\n"%(ascii(code), packagename, modname, modname))
    fp.write("}\n\n")
    for code, modname in suitelist:
        fp.write("from %s import *\n"%modname)

    # Generate property dicts and element dicts for all types declared in this module
    fp.write("\ndef getbaseclasses(v):\n")
    fp.write("    if not getattr(v, '_propdict', None):\n")
    fp.write("        v._propdict = {}\n")
    fp.write("        v._elemdict = {}\n")
    fp.write("        for superclassname in getattr(v, '_superclassnames', []):\n")
    fp.write("            superclass = eval(superclassname)\n")
    fp.write("            getbaseclasses(superclass)\n")
    fp.write("            v._propdict.update(getattr(superclass, '_propdict', {}))\n")
    fp.write("            v._elemdict.update(getattr(superclass, '_elemdict', {}))\n")
    fp.write("        v._propdict.update(getattr(v, '_privpropdict', {}))\n")
    fp.write("        v._elemdict.update(getattr(v, '_privelemdict', {}))\n")
    fp.write("\n")
    fp.write("import StdSuites\n")
    allprecompinfo.sort()
    if allprecompinfo:
        fp.write("\n#\n# Set property and element dictionaries now that all classes have been defined\n#\n")
        for codenamemapper in allprecompinfo:
            for k, v in codenamemapper.getall('class'):
                fp.write("getbaseclasses(%s)\n" % v)

    # Generate a code-to-name mapper for all of the types (classes) declared in this module
    application_class = None
    if allprecompinfo:
        fp.write("\n#\n# Indices of types declared in this module\n#\n")
        fp.write("_classdeclarations = {\n")
        for codenamemapper in allprecompinfo:
            for k, v in codenamemapper.getall('class'):
                fp.write("    %r : %s,\n" % (k, v))
                if k == 'capp':
                    application_class = v
        fp.write("}\n")


    if suitelist:
        fp.write("\n\nclass %s(%s_Events"%(packagename, suitelist[0][1]))
        for code, modname in suitelist[1:]:
            fp.write(",\n        %s_Events"%modname)
        fp.write(",\n        aetools.TalkTo):\n")
        fp.write("    _signature = %r\n\n"%(creatorsignature,))
        fp.write("    _moduleName = '%s'\n\n"%packagename)
        if application_class:
            fp.write("    _elemdict = %s._elemdict\n" % application_class)
            fp.write("    _propdict = %s._propdict\n" % application_class)
    fp.close()

class SuiteCompiler:
    def __init__(self, suite, basepackage, output, edit_modnames, verbose):
        self.suite = suite
        self.basepackage = basepackage
        self.edit_modnames = edit_modnames
        self.output = output
        self.verbose = verbose

        # Set by precompilesuite
        self.pathname = None
        self.modname = None

        # Set by compilesuite
        self.fp = None
        self.basemodule = None
        self.enumsneeded = {}

    def precompilesuite(self):
        """Parse a single suite without generating the output. This step is needed
        so we can resolve recursive references by suites to enums/comps/etc declared
        in other suites"""
        [name, desc, code, level, version, events, classes, comps, enums] = self.suite

        modname = identify(name)
        if len(modname) > 28:
            modname = modname[:27]
        if self.edit_modnames is None:
            self.pathname = EasyDialogs.AskFileForSave(message='Python output file',
                savedFileName=modname+'.py')
        else:
            for old, new in self.edit_modnames:
                if old == modname:
                    modname = new
            if modname:
                self.pathname = os.path.join(self.output, modname + '.py')
            else:
                self.pathname = None
        if not self.pathname:
            return None, None, None

        self.modname = os.path.splitext(os.path.split(self.pathname)[1])[0]

        if self.basepackage and code in self.basepackage._code_to_module:
            # We are an extension of a baseclass (usually an application extending
            # Standard_Suite or so). Import everything from our base module
            basemodule = self.basepackage._code_to_module[code]
        else:
            # We are not an extension.
            basemodule = None

        self.enumsneeded = {}
        for event in events:
            self.findenumsinevent(event)

        objc = ObjectCompiler(None, self.modname, basemodule, interact=(self.edit_modnames is None),
            verbose=self.verbose)
        for cls in classes:
            objc.compileclass(cls)
        for cls in classes:
            objc.fillclasspropsandelems(cls)
        for comp in comps:
            objc.compilecomparison(comp)
        for enum in enums:
            objc.compileenumeration(enum)

        for enum in self.enumsneeded.keys():
            objc.checkforenum(enum)

        objc.dumpindex()

        precompinfo = objc.getprecompinfo(self.modname)

        return code, self.modname, precompinfo

    def compilesuite(self, major, minor, language, script, fname, precompinfo):
        """Generate code for a single suite"""
        [name, desc, code, level, version, events, classes, comps, enums] = self.suite
        # Sort various lists, so re-generated source is easier compared
        def class_sorter(k1, k2):
            """Sort classes by code, and make sure main class sorts before synonyms"""
            # [name, code, desc, properties, elements] = cls
            if k1[1] < k2[1]: return -1
            if k1[1] > k2[1]: return 1
            if not k2[3] or k2[3][0][1] == 'c@#!':
                # This is a synonym, the other one is better
                return -1
            if not k1[3] or k1[3][0][1] == 'c@#!':
                # This is a synonym, the other one is better
                return 1
            return 0

        events.sort()
        classes.sort(class_sorter)
        comps.sort()
        enums.sort()

        self.fp = fp = open(self.pathname, 'w')
        MacOS.SetCreatorAndType(self.pathname, 'Pyth', 'TEXT')

        fp.write('"""Suite %s: %s\n' % (ascii(name), ascii(desc)))
        fp.write("Level %d, version %d\n\n" % (level, version))
        fp.write("Generated from %s\n"%ascii(fname))
        fp.write("AETE/AEUT resource version %d/%d, language %d, script %d\n" % \
            (major, minor, language, script))
        fp.write('"""\n\n')

        fp.write('import aetools\n')
        fp.write('import MacOS\n\n')
        fp.write("_code = %r\n\n"% (code,))
        if self.basepackage and code in self.basepackage._code_to_module:
            # We are an extension of a baseclass (usually an application extending
            # Standard_Suite or so). Import everything from our base module
            fp.write('from %s import *\n'%self.basepackage._code_to_fullname[code][0])
            basemodule = self.basepackage._code_to_module[code]
        elif self.basepackage and code.lower() in self.basepackage._code_to_module:
            # This is needed by CodeWarrior and some others.
            fp.write('from %s import *\n'%self.basepackage._code_to_fullname[code.lower()][0])
            basemodule = self.basepackage._code_to_module[code.lower()]
        else:
            # We are not an extension.
            basemodule = None
        self.basemodule = basemodule
        self.compileclassheader()

        self.enumsneeded = {}
        if events:
            for event in events:
                self.compileevent(event)
        else:
            fp.write("    pass\n\n")

        objc = ObjectCompiler(fp, self.modname, basemodule, precompinfo, interact=(self.edit_modnames is None),
            verbose=self.verbose)
        for cls in classes:
            objc.compileclass(cls)
        for cls in classes:
            objc.fillclasspropsandelems(cls)
        for comp in comps:
            objc.compilecomparison(comp)
        for enum in enums:
            objc.compileenumeration(enum)

        for enum in self.enumsneeded.keys():
            objc.checkforenum(enum)

        objc.dumpindex()

    def compileclassheader(self):
        """Generate class boilerplate"""
        classname = '%s_Events'%self.modname
        if self.basemodule:
            modshortname = string.split(self.basemodule.__name__, '.')[-1]
            baseclassname = '%s_Events'%modshortname
            self.fp.write("class %s(%s):\n\n"%(classname, baseclassname))
        else:
            self.fp.write("class %s:\n\n"%classname)

    def compileevent(self, event):
        """Generate code for a single event"""
        [name, desc, code, subcode, returns, accepts, arguments] = event
        fp = self.fp
        funcname = identify(name)
        #
        # generate name->keyword map
        #
        if arguments:
            fp.write("    _argmap_%s = {\n"%funcname)
            for a in arguments:
                fp.write("        %r : %r,\n"%(identify(a[0]), a[1]))
            fp.write("    }\n\n")

        #
        # Generate function header
        #
        has_arg = (not is_null(accepts))
        opt_arg = (has_arg and is_optional(accepts))

        fp.write("    def %s(self, "%funcname)
        if has_arg:
            if not opt_arg:
                fp.write("_object, ")       # Include direct object, if it has one
            else:
                fp.write("_object=None, ")  # Also include if it is optional
        else:
            fp.write("_no_object=None, ")   # For argument checking
        fp.write("_attributes={}, **_arguments):\n")    # include attribute dict and args
        #
        # Generate doc string (important, since it may be the only
        # available documentation, due to our name-remaping)
        #
        fp.write('        """%s: %s\n'%(ascii(name), ascii(desc)))
        if has_arg:
            fp.write("        Required argument: %s\n"%getdatadoc(accepts))
        elif opt_arg:
            fp.write("        Optional argument: %s\n"%getdatadoc(accepts))
        for arg in arguments:
            fp.write("        Keyword argument %s: %s\n"%(identify(arg[0]),
                    getdatadoc(arg[2])))
        fp.write("        Keyword argument _attributes: AppleEvent attribute dictionary\n")
        if not is_null(returns):
            fp.write("        Returns: %s\n"%getdatadoc(returns))
        fp.write('        """\n')
        #
        # Fiddle the args so everything ends up in 'arguments' dictionary
        #
        fp.write("        _code = %r\n"% (code,))
        fp.write("        _subcode = %r\n\n"% (subcode,))
        #
        # Do keyword name substitution
        #
        if arguments:
            fp.write("        aetools.keysubst(_arguments, self._argmap_%s)\n"%funcname)
        else:
            fp.write("        if _arguments: raise TypeError, 'No optional args expected'\n")
        #
        # Stuff required arg (if there is one) into arguments
        #
        if has_arg:
            fp.write("        _arguments['----'] = _object\n")
        elif opt_arg:
            fp.write("        if _object:\n")
            fp.write("            _arguments['----'] = _object\n")
        else:
            fp.write("        if _no_object is not None: raise TypeError, 'No direct arg expected'\n")
        fp.write("\n")
        #
        # Do enum-name substitution
        #
        for a in arguments:
            if is_enum(a[2]):
                kname = a[1]
                ename = a[2][0]
                if ename != '****':
                    fp.write("        aetools.enumsubst(_arguments, %r, _Enum_%s)\n" %
                        (kname, identify(ename)))
                    self.enumsneeded[ename] = 1
        fp.write("\n")
        #
        # Do the transaction
        #
        fp.write("        _reply, _arguments, _attributes = self.send(_code, _subcode,\n")
        fp.write("                _arguments, _attributes)\n")
        #
        # Error handling
        #
        fp.write("        if _arguments.get('errn', 0):\n")
        fp.write("            raise aetools.Error, aetools.decodeerror(_arguments)\n")
        fp.write("        # XXXX Optionally decode result\n")
        #
        # Decode result
        #
        fp.write("        if '----' in _arguments:\n")
        if is_enum(returns):
            fp.write("            # XXXX Should do enum remapping here...\n")
        fp.write("            return _arguments['----']\n")
        fp.write("\n")

    def findenumsinevent(self, event):
        """Find all enums for a single event"""
        [name, desc, code, subcode, returns, accepts, arguments] = event
        for a in arguments:
            if is_enum(a[2]):
                ename = a[2][0]
                if ename != '****':
                    self.enumsneeded[ename] = 1

#
# This class stores the code<->name translations for a single module. It is used
# to keep the information while we're compiling the module, but we also keep these objects
# around so if one suite refers to, say, an enum in another suite we know where to
# find it. Finally, if we really can't find a code, the user can add modules by
# hand.
#
class CodeNameMapper:

    def __init__(self, interact=1, verbose=None):
        self.code2name = {
            "property" : {},
            "class" : {},
            "enum" : {},
            "comparison" : {},
        }
        self.name2code =  {
            "property" : {},
            "class" : {},
            "enum" : {},
            "comparison" : {},
        }
        self.modulename = None
        self.star_imported = 0
        self.can_interact = interact
        self.verbose = verbose

    def addnamecode(self, type, name, code):
        self.name2code[type][name] = code
        if code not in self.code2name[type]:
            self.code2name[type][code] = name

    def hasname(self, name):
        for dict in self.name2code.values():
            if name in dict:
                return True
        return False

    def hascode(self, type, code):
        return code in self.code2name[type]

    def findcodename(self, type, code):
        if not self.hascode(type, code):
            return None, None, None
        name = self.code2name[type][code]
        if self.modulename and not self.star_imported:
            qualname = '%s.%s'%(self.modulename, name)
        else:
            qualname = name
        return name, qualname, self.modulename

    def getall(self, type):
        return self.code2name[type].items()

    def addmodule(self, module, name, star_imported):
        self.modulename = name
        self.star_imported = star_imported
        for code, name in module._propdeclarations.items():
            self.addnamecode('property', name, code)
        for code, name in module._classdeclarations.items():
            self.addnamecode('class', name, code)
        for code in module._enumdeclarations.keys():
            self.addnamecode('enum', '_Enum_'+identify(code), code)
        for code, name in module._compdeclarations.items():
            self.addnamecode('comparison', name, code)

    def prepareforexport(self, name=None):
        if not self.modulename:
            self.modulename = name
        return self

class ObjectCompiler:
    def __init__(self, fp, modname, basesuite, othernamemappers=None, interact=1,
            verbose=None):
        self.fp = fp
        self.verbose = verbose
        self.basesuite = basesuite
        self.can_interact = interact
        self.modulename = modname
        self.namemappers = [CodeNameMapper(self.can_interact, self.verbose)]
        if othernamemappers:
            self.othernamemappers = othernamemappers[:]
        else:
            self.othernamemappers = []
        if basesuite:
            basemapper = CodeNameMapper(self.can_interact, self.verbose)
            basemapper.addmodule(basesuite, '', 1)
            self.namemappers.append(basemapper)

    def getprecompinfo(self, modname):
        list = []
        for mapper in self.namemappers:
            emapper = mapper.prepareforexport(modname)
            if emapper:
                list.append(emapper)
        return list

    def findcodename(self, type, code):
        while 1:
            # First try: check whether we already know about this code.
            for mapper in self.namemappers:
                if mapper.hascode(type, code):
                    return mapper.findcodename(type, code)
            # Second try: maybe one of the other modules knows about it.
            for mapper in self.othernamemappers:
                if mapper.hascode(type, code):
                    self.othernamemappers.remove(mapper)
                    self.namemappers.append(mapper)
                    if self.fp:
                        self.fp.write("import %s\n"%mapper.modulename)
                    break
            else:
                # If all this has failed we ask the user for a guess on where it could
                # be and retry.
                if self.fp:
                    m = self.askdefinitionmodule(type, code)
                else:
                    m = None
                if not m: return None, None, None
                mapper = CodeNameMapper(self.can_interact, self.verbose)
                mapper.addmodule(m, m.__name__, 0)
                self.namemappers.append(mapper)

    def hasname(self, name):
        for mapper in self.othernamemappers:
            if mapper.hasname(name) and mapper.modulename != self.modulename:
                if self.verbose:
                    print >>self.verbose, "Duplicate Python identifier:", name, self.modulename, mapper.modulename
                return True
        return False

    def askdefinitionmodule(self, type, code):
        if not self.can_interact:
            if self.verbose:
                print >>self.verbose, "** No definition for %s '%s' found" % (type, code)
            return None
        path = EasyDialogs.AskFileForSave(message='Where is %s %s declared?'%(type, code))
        if not path: return
        path, file = os.path.split(path)
        modname = os.path.splitext(file)[0]
        if not path in sys.path:
            sys.path.insert(0, path)
        m = __import__(modname)
        self.fp.write("import %s\n"%modname)
        return m

    def compileclass(self, cls):
        [name, code, desc, properties, elements] = cls
        pname = identify(name)
        if self.namemappers[0].hascode('class', code):
            # plural forms and such
            othername, dummy, dummy = self.namemappers[0].findcodename('class', code)
            if self.fp:
                self.fp.write("\n%s = %s\n"%(pname, othername))
        else:
            if self.fp:
                self.fp.write('\nclass %s(aetools.ComponentItem):\n' % pname)
                self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(desc)))
                self.fp.write('    want = %r\n' % (code,))
        self.namemappers[0].addnamecode('class', pname, code)
        is_application_class = (code == 'capp')
        properties.sort()
        for prop in properties:
            self.compileproperty(prop, is_application_class)
        elements.sort()
        for elem in elements:
            self.compileelement(elem)

    def compileproperty(self, prop, is_application_class=False):
        [name, code, what] = prop
        if code == 'c@#!':
            # Something silly with plurals. Skip it.
            return
        pname = identify(name)
        if self.namemappers[0].hascode('property', code):
            # plural forms and such
            othername, dummy, dummy = self.namemappers[0].findcodename('property', code)
            if pname == othername:
                return
            if self.fp:
                self.fp.write("\n_Prop_%s = _Prop_%s\n"%(pname, othername))
        else:
            if self.fp:
                self.fp.write("class _Prop_%s(aetools.NProperty):\n" % pname)
                self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(what[1])))
                self.fp.write("    which = %r\n" % (code,))
                self.fp.write("    want = %r\n" % (what[0],))
        self.namemappers[0].addnamecode('property', pname, code)
        if is_application_class and self.fp:
            self.fp.write("%s = _Prop_%s()\n" % (pname, pname))

    def compileelement(self, elem):
        [code, keyform] = elem
        if self.fp:
            self.fp.write("#        element %r as %s\n" % (code, keyform))

    def fillclasspropsandelems(self, cls):
        [name, code, desc, properties, elements] = cls
        cname = identify(name)
        if self.namemappers[0].hascode('class', code) and \
                self.namemappers[0].findcodename('class', code)[0] != cname:
            # This is an other name (plural or so) for something else. Skip.
            if self.fp and (elements or len(properties) > 1 or (len(properties) == 1 and
                properties[0][1] != 'c@#!')):
                if self.verbose:
                    print >>self.verbose, '** Skip multiple %s of %s (code %r)' % (cname, self.namemappers[0].findcodename('class', code)[0], code)
                raise RuntimeError, "About to skip non-empty class"
            return
        plist = []
        elist = []
        superclasses = []
        for prop in properties:
            [pname, pcode, what] = prop
            if pcode == "c@#^":
                superclasses.append(what)
            if pcode == 'c@#!':
                continue
            pname = identify(pname)
            plist.append(pname)

        superclassnames = []
        for superclass in superclasses:
            superId, superDesc, dummy = superclass
            superclassname, fullyqualifiedname, module = self.findcodename("class", superId)
            # I don't think this is correct:
            if superclassname == cname:
                pass # superclassnames.append(fullyqualifiedname)
            else:
                superclassnames.append(superclassname)

        if self.fp:
            self.fp.write("%s._superclassnames = %r\n"%(cname, superclassnames))

        for elem in elements:
            [ecode, keyform] = elem
            if ecode == 'c@#!':
                continue
            name, ename, module = self.findcodename('class', ecode)
            if not name:
                if self.fp:
                    self.fp.write("# XXXX %s element %r not found!!\n"%(cname, ecode))
            else:
                elist.append((name, ename))

        plist.sort()
        elist.sort()

        if self.fp:
            self.fp.write("%s._privpropdict = {\n"%cname)
            for n in plist:
                self.fp.write("    '%s' : _Prop_%s,\n"%(n, n))
            self.fp.write("}\n")
            self.fp.write("%s._privelemdict = {\n"%cname)
            for n, fulln in elist:
                self.fp.write("    '%s' : %s,\n"%(n, fulln))
            self.fp.write("}\n")

    def compilecomparison(self, comp):
        [name, code, comment] = comp
        iname = identify(name)
        self.namemappers[0].addnamecode('comparison', iname, code)
        if self.fp:
            self.fp.write("class %s(aetools.NComparison):\n" % iname)
            self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(comment)))

    def compileenumeration(self, enum):
        [code, items] = enum
        name = "_Enum_%s" % identify(code)
        if self.fp:
            self.fp.write("%s = {\n" % name)
            for item in items:
                self.compileenumerator(item)
            self.fp.write("}\n\n")
        self.namemappers[0].addnamecode('enum', name, code)
        return code

    def compileenumerator(self, item):
        [name, code, desc] = item
        self.fp.write("    %r : %r,\t# %s\n" % (identify(name), code, ascii(desc)))

    def checkforenum(self, enum):
        """This enum code is used by an event. Make sure it's available"""
        name, fullname, module = self.findcodename('enum', enum)
        if not name:
            if self.fp:
                self.fp.write("_Enum_%s = None # XXXX enum %s not found!!\n"%(identify(enum), ascii(enum)))
            return
        if module:
            if self.fp:
                self.fp.write("from %s import %s\n"%(module, name))

    def dumpindex(self):
        if not self.fp:
            return
        self.fp.write("\n#\n# Indices of types declared in this module\n#\n")

        self.fp.write("_classdeclarations = {\n")
        classlist = self.namemappers[0].getall('class')
        classlist.sort()
        for k, v in classlist:
            self.fp.write("    %r : %s,\n" % (k, v))
        self.fp.write("}\n")

        self.fp.write("\n_propdeclarations = {\n")
        proplist = self.namemappers[0].getall('property')
        proplist.sort()
        for k, v in proplist:
            self.fp.write("    %r : _Prop_%s,\n" % (k, v))
        self.fp.write("}\n")

        self.fp.write("\n_compdeclarations = {\n")
        complist = self.namemappers[0].getall('comparison')
        complist.sort()
        for k, v in complist:
            self.fp.write("    %r : %s,\n" % (k, v))
        self.fp.write("}\n")

        self.fp.write("\n_enumdeclarations = {\n")
        enumlist = self.namemappers[0].getall('enum')
        enumlist.sort()
        for k, v in enumlist:
            self.fp.write("    %r : %s,\n" % (k, v))
        self.fp.write("}\n")

def compiledata(data):
    [type, description, flags] = data
    return "%r -- %r %s" % (type, description, compiledataflags(flags))

def is_null(data):
    return data[0] == 'null'

def is_optional(data):
    return (data[2] & 0x8000)

def is_enum(data):
    return (data[2] & 0x2000)

def getdatadoc(data):
    [type, descr, flags] = data
    if descr:
        return ascii(descr)
    if type == '****':
        return 'anything'
    if type == 'obj ':
        return 'an AE object reference'
    return "undocumented, typecode %r"%(type,)

dataflagdict = {15: "optional", 14: "list", 13: "enum", 12: "mutable"}
def compiledataflags(flags):
    bits = []
    for i in range(16):
        if flags & (1<<i):
            if i in dataflagdict.keys():
                bits.append(dataflagdict[i])
            else:
                bits.append(repr(i))
    return '[%s]' % string.join(bits)

def ascii(str):
    """Return a string with all non-ascii characters hex-encoded"""
    if type(str) != type(''):
        return map(ascii, str)
    rv = ''
    for c in str:
        if c in ('\t', '\n', '\r') or ' ' <= c < chr(0x7f):
            rv = rv + c
        else:
            rv = rv + '\\' + 'x%02.2x' % ord(c)
    return rv

def identify(str):
    """Turn any string into an identifier:
    - replace space by _
    - replace other illegal chars by _xx_ (hex code)
    - append _ if the result is a python keyword
    """
    if not str:
        return "empty_ae_name_"
    rv = ''
    ok = string.ascii_letters + '_'
    ok2 = ok + string.digits
    for c in str:
        if c in ok:
            rv = rv + c
        elif c == ' ':
            rv = rv + '_'
        else:
            rv = rv + '_%02.2x_'%ord(c)
        ok = ok2
    if keyword.iskeyword(rv):
        rv = rv + '_'
    return rv

# Call the main program

if __name__ == '__main__':
    main()
    sys.exit(1)