| """ |
| 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) |
