diff options
Diffstat (limited to 'Lib/plat-mac')
| -rw-r--r-- | Lib/plat-mac/gensuitemodule.py | 1132 |
1 files changed, 1132 insertions, 0 deletions
diff --git a/Lib/plat-mac/gensuitemodule.py b/Lib/plat-mac/gensuitemodule.py new file mode 100644 index 0000000..9e599c8 --- /dev/null +++ b/Lib/plat-mac/gensuitemodule.py @@ -0,0 +1,1132 @@ +""" +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. +""" + +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) +""") + sys.exit(1) + +def main(): + if len(sys.argv) > 1: + SHORTOPTS = "rb:o:e:c:" + LONGOPTS = ("resource", "base=", "output=", "edit=", "creator=") + 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 + + 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 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) + 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) + except MacOS.Error, arg: + print "Error getting terminology:", arg + print "Retry, manually parsing resources" + processfile_fromresource(filename, edit_modnames=edit_modnames, + basepkgname=basepkgname) + +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): + """Process all resources in a single file""" + if not is_scriptable(fullname): + print "Warning: app does not seem scriptable: %s" % fullname + cur = CurResFile() + print "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) + print "\nLISTING aete+aeut RESOURCES IN", `fullname` + aetelist = [] + for res in resources: + print "decoding", res.GetResInfo(), "..." + data = res.data + aete = decode(data) + aetelist.append((aete, res.GetResInfo())) + finally: + if rf <> cur: + CloseResFile(rf) + UseResFile(cur) + # switch back (needed for dialogs in Python) + UseResFile(cur) + compileaetelist(aetelist, fullname, output=output, + basepkgname=basepkgname, edit_modnames=edit_modnames, + creatorsignature=creatorsignature) + +def processfile(fullname, output=None, basepkgname=None, + edit_modnames=None, creatorsignature=None): + """Ask an application for its terminology and process that""" + if not is_scriptable(fullname): + print "Warning: app does not seem scriptable: %s" % fullname + print "\nASKING FOR aete DICTIONARY IN", `fullname` + try: + aedescobj, launched = OSATerminology.GetAppTerminology(fullname) + except MacOS.Error, arg: + if arg[0] in (-1701, -192): # errAEDescNotFound, resNotFound + print "GetAppTerminology failed with errAEDescNotFound/resNotFound, trying manually" + aedata, sig = getappterminology(fullname) + if not creatorsignature: + creatorsignature = sig + else: + raise + else: + if launched: + print "Launched", fullname + raw = aetools.unpack(aedescobj) + if not raw: + print 'Unpack returned empty value:', raw + return + if not raw[0].data: + print 'Unpack returned value without data:', raw + return + aedata = raw[0] + aete = decode(aedata.data) + compileaete(aete, None, fullname, output=output, basepkgname=basepkgname, + creatorsignature=creatorsignature, edit_modnames=edit_modnames) + +def getappterminology(fullname): + """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: + print '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): + for aete, resinfo in aetelist: + compileaete(aete, resinfo, fullname, output=output, + basepkgname=basepkgname, edit_modnames=edit_modnames, + creatorsignature=creatorsignature) + +def decode(data): + """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: + sys.stderr.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:', `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", `what`, args + res = vageneric(what, f, args) + print '->', `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: %s" % `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): + """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: + code, suite, pathname, modname, precompinfo = precompilesuite(suite, basepackage, + output=output, edit_modnames=edit_modnames) + if not code: + continue + allprecompinfo = allprecompinfo + precompinfo + suiteinfo = suite, pathname, modname + suitelist.append((code, modname)) + allsuites.append(suiteinfo) + for suiteinfo in allsuites: + compilesuite(suiteinfo, major, minor, language, script, fname, basepackage, + allprecompinfo, interact=(edit_modnames is None)) + 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("\t'%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("\t'%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("\tif not getattr(v, '_propdict', None):\n") + fp.write("\t\tv._propdict = {}\n") + fp.write("\t\tv._elemdict = {}\n") + fp.write("\t\tfor superclassname in getattr(v, '_superclassnames', []):\n") + fp.write("\t\t\tsuperclass = eval(superclassname)\n") + fp.write("\t\t\tgetbaseclasses(superclass)\n") + fp.write("\t\t\tv._propdict.update(getattr(superclass, '_propdict', {}))\n") + fp.write("\t\t\tv._elemdict.update(getattr(superclass, '_elemdict', {}))\n") + fp.write("\t\tv._propdict.update(getattr(v, '_privpropdict', {}))\n") + fp.write("\t\tv._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 + 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("\t%s : %s,\n" % (`k`, 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\t\t%s_Events"%modname) + fp.write(",\n\t\taetools.TalkTo):\n") + fp.write("\t_signature = %s\n\n"%`creatorsignature`) + fp.write("\t_moduleName = '%s'\n\n"%packagename) + fp.close() + +def precompilesuite(suite, basepackage=None, edit_modnames=None, output=None): + """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] = suite + + modname = identify(name) + if len(modname) > 28: + modname = modname[:27] + if edit_modnames is None: + pathname = EasyDialogs.AskFileForSave(message='Python output file', + savedFileName=modname+'.py') + else: + for old, new in edit_modnames: + if old == modname: + modname = new + if modname: + pathname = os.path.join(output, modname + '.py') + else: + pathname = None + if not pathname: + return None, None, None, None, None + + modname = os.path.splitext(os.path.split(pathname)[1])[0] + + if basepackage and basepackage._code_to_module.has_key(code): + # We are an extension of a baseclass (usually an application extending + # Standard_Suite or so). Import everything from our base module + basemodule = basepackage._code_to_module[code] + else: + # We are not an extension. + basemodule = None + + enumsneeded = {} + for event in events: + findenumsinevent(event, enumsneeded) + + objc = ObjectCompiler(None, basemodule, interact=(edit_modnames is None)) + 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 enumsneeded.keys(): + objc.checkforenum(enum) + + objc.dumpindex() + + precompinfo = objc.getprecompinfo(modname) + + return code, suite, pathname, modname, precompinfo + +def compilesuite((suite, pathname, modname), major, minor, language, script, + fname, basepackage, precompinfo, interact=1): + """Generate code for a single suite""" + [name, desc, code, level, version, events, classes, comps, enums] = suite + # Sort various lists, so re-generated source is easier compared + events.sort() + classes.sort() + comps.sort() + enums.sort() + + fp = open(pathname, 'w') + MacOS.SetCreatorAndType(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 = %s\n\n"% `code`) + if basepackage and basepackage._code_to_module.has_key(code): + # 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'%basepackage._code_to_fullname[code][0]) + basemodule = basepackage._code_to_module[code] + elif basepackage and basepackage._code_to_module.has_key(code.lower()): + # This is needed by CodeWarrior and some others. + fp.write('from %s import *\n'%basepackage._code_to_fullname[code.lower()][0]) + basemodule = basepackage._code_to_module[code.lower()] + else: + # We are not an extension. + basemodule = None + compileclassheader(fp, modname, basemodule) + + enumsneeded = {} + if events: + for event in events: + compileevent(fp, event, enumsneeded) + else: + fp.write("\tpass\n\n") + + objc = ObjectCompiler(fp, basemodule, precompinfo, interact=interact) + 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 enumsneeded.keys(): + objc.checkforenum(enum) + + objc.dumpindex() + + return code, modname + +def compileclassheader(fp, name, module=None): + """Generate class boilerplate""" + classname = '%s_Events'%name + if module: + modshortname = string.split(module.__name__, '.')[-1] + baseclassname = '%s_Events'%modshortname + fp.write("class %s(%s):\n\n"%(classname, baseclassname)) + else: + fp.write("class %s:\n\n"%classname) + +def compileevent(fp, event, enumsneeded): + """Generate code for a single event""" + [name, desc, code, subcode, returns, accepts, arguments] = event + funcname = identify(name) + # + # generate name->keyword map + # + if arguments: + fp.write("\t_argmap_%s = {\n"%funcname) + for a in arguments: + fp.write("\t\t%s : %s,\n"%(`identify(a[0])`, `a[1]`)) + fp.write("\t}\n\n") + + # + # Generate function header + # + has_arg = (not is_null(accepts)) + opt_arg = (has_arg and is_optional(accepts)) + + fp.write("\tdef %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('\t\t"""%s: %s\n'%(ascii(name), ascii(desc))) + if has_arg: + fp.write("\t\tRequired argument: %s\n"%getdatadoc(accepts)) + elif opt_arg: + fp.write("\t\tOptional argument: %s\n"%getdatadoc(accepts)) + for arg in arguments: + fp.write("\t\tKeyword argument %s: %s\n"%(identify(arg[0]), + getdatadoc(arg[2]))) + fp.write("\t\tKeyword argument _attributes: AppleEvent attribute dictionary\n") + if not is_null(returns): + fp.write("\t\tReturns: %s\n"%getdatadoc(returns)) + fp.write('\t\t"""\n') + # + # Fiddle the args so everything ends up in 'arguments' dictionary + # + fp.write("\t\t_code = %s\n"% `code`) + fp.write("\t\t_subcode = %s\n\n"% `subcode`) + # + # Do keyword name substitution + # + if arguments: + fp.write("\t\taetools.keysubst(_arguments, self._argmap_%s)\n"%funcname) + else: + fp.write("\t\tif _arguments: raise TypeError, 'No optional args expected'\n") + # + # Stuff required arg (if there is one) into arguments + # + if has_arg: + fp.write("\t\t_arguments['----'] = _object\n") + elif opt_arg: + fp.write("\t\tif _object:\n") + fp.write("\t\t\t_arguments['----'] = _object\n") + else: + fp.write("\t\tif _no_object != 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("\t\taetools.enumsubst(_arguments, %s, _Enum_%s)\n" % + (`kname`, identify(ename))) + enumsneeded[ename] = 1 + fp.write("\n") + # + # Do the transaction + # + fp.write("\t\t_reply, _arguments, _attributes = self.send(_code, _subcode,\n") + fp.write("\t\t\t\t_arguments, _attributes)\n") + # + # Error handling + # + fp.write("\t\tif _arguments.get('errn', 0):\n") + fp.write("\t\t\traise aetools.Error, aetools.decodeerror(_arguments)\n") + fp.write("\t\t# XXXX Optionally decode result\n") + # + # Decode result + # + fp.write("\t\tif _arguments.has_key('----'):\n") + if is_enum(returns): + fp.write("\t\t\t# XXXX Should do enum remapping here...\n") + fp.write("\t\t\treturn _arguments['----']\n") + fp.write("\n") + +# print "\n# Command %s -- %s (%s, %s)" % (`name`, `desc`, `code`, `subcode`) +# print "# returns", compiledata(returns) +# print "# accepts", compiledata(accepts) +# for arg in arguments: +# compileargument(arg) + +def compileargument(arg): + [name, keyword, what] = arg + print "# %s (%s)" % (name, `keyword`), compiledata(what) + +def findenumsinevent(event, enumsneeded): + """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 <> '****': + 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): + self.code2name = { + "property" : {}, + "class" : {}, + "enum" : {}, + "comparison" : {}, + } + self.name2code = { + "property" : {}, + "class" : {}, + "enum" : {}, + "comparison" : {}, + } + self.modulename = None + self.star_imported = 0 + self.can_interact = interact + + def addnamecode(self, type, name, code): + self.name2code[type][name] = code + if not self.code2name[type].has_key(code): + self.code2name[type][code] = name + + def hasname(self, type, name): + return self.name2code[type].has_key(name) + + def hascode(self, type, code): + return self.code2name[type].has_key(code) + + 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, basesuite=None, othernamemappers=None, interact=1): + self.fp = fp + self.basesuite = basesuite + self.can_interact = interact + self.namemappers = [CodeNameMapper(self.can_interact)] + if othernamemappers: + self.othernamemappers = othernamemappers[:] + else: + self.othernamemappers = [] + if basesuite: + basemapper = CodeNameMapper(self.can_interact) + 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) + mapper.addmodule(m, m.__name__, 0) + self.namemappers.append(mapper) + + def askdefinitionmodule(self, type, code): + if not self.can_interact: + print "** 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('\t"""%s - %s """\n' % (ascii(name), ascii(desc))) + self.fp.write('\twant = %s\n' % `code`) + self.namemappers[0].addnamecode('class', pname, code) + properties.sort() + for prop in properties: + self.compileproperty(prop) + elements.sort() + for elem in elements: + self.compileelement(elem) + + def compileproperty(self, prop): + [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%s = %s\n"%(pname, othername)) + else: + if self.fp: + self.fp.write("class %s(aetools.NProperty):\n" % pname) + self.fp.write('\t"""%s - %s """\n' % (ascii(name), ascii(what[1]))) + self.fp.write("\twhich = %s\n" % `code`) + self.fp.write("\twant = %s\n" % `what[0]`) + self.namemappers[0].addnamecode('property', pname, code) + + def compileelement(self, elem): + [code, keyform] = elem + if self.fp: + self.fp.write("# element %s 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. + 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 = %s\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 %s 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("\t'%s' : %s,\n"%(n, n)) + self.fp.write("}\n") + self.fp.write("%s._privelemdict = {\n"%cname) + for n, fulln in elist: + self.fp.write("\t'%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('\t"""%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("\t%s : %s,\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("\t%s : %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("\t%s : %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("\t%s : %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("\t%s : %s,\n" % (`k`, v)) + self.fp.write("}\n") + +def compiledata(data): + [type, description, flags] = data + return "%s -- %s %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 %s"%`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(`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) + - prepend _ 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) |