Lib/plat-mac/gensuitemodule.py

   1 """
   2 gensuitemodule - Generate an AE suite module from an aete/aeut resource
   3
   4 Based on aete.py.
   5
   6 Reading and understanding this code is left as an exercise to the reader.
   7 """
   8
   9 import MacOS
  10 import EasyDialogs
  11 import os
  12 import string
  13 import sys
  14 import types
  15 import StringIO
  16 import keyword
  17 import macresource
  18 import aetools
  19 import distutils.sysconfig
  20 import OSATerminology
  21 from Carbon.Res import *
  22 import Carbon.Folder
  23 import MacOS
  24 import getopt
  25 import plistlib
  26
  27 _MAC_LIB_FOLDER=os.path.dirname(aetools.__file__)
  28 DEFAULT_STANDARD_PACKAGEFOLDER=os.path.join(_MAC_LIB_FOLDER, 'lib-scriptpackages')
  29 DEFAULT_USER_PACKAGEFOLDER=distutils.sysconfig.get_python_lib()
  30
  31 def usage():
  32     sys.stderr.write("Usage: %s [opts] application-or-resource-file\n" % sys.argv[0])
  33     sys.stderr.write("""Options:
  34 --output pkgdir  Pathname of the output package (short: -o)
  35 --resource       Parse resource file in stead of launching application (-r)
  36 --base package   Use another base package in stead of default StdSuites (-b)
  37 --edit old=new   Edit suite names, use empty new to skip a suite (-e)
  38 --creator code   Set creator code for package (-c)
  39 --dump           Dump aete resource to stdout in stead of creating module (-d)
  40 --verbose        Tell us what happens (-v)
  41 """)
  42     sys.exit(1)
  43
  44 def main():
  45     if len(sys.argv) > 1:
  46         SHORTOPTS = "rb:o:e:c:dv"
  47         LONGOPTS = ("resource", "base=", "output=", "edit=", "creator=", "dump", "verbose")
  48         try:
  49             opts, args = getopt.getopt(sys.argv[1:], SHORTOPTS, LONGOPTS)
  50         except getopt.GetoptError:
  51             usage()
  52
  53         process_func = processfile
  54         basepkgname = 'StdSuites'
  55         output = None
  56         edit_modnames = []
  57         creatorsignature = None
  58         dump = None
  59         verbose = None
  60
  61         for o, a in opts:
  62             if o in ('-r', '--resource'):
  63                 process_func = processfile_fromresource
  64             if o in ('-b', '--base'):
  65                 basepkgname = a
  66             if o in ('-o', '--output'):
  67                 output = a
  68             if o in ('-e', '--edit'):
  69                 split = a.split('=')
  70                 if len(split) != 2:
  71                     usage()
  72                 edit_modnames.append(split)
  73             if o in ('-c', '--creator'):
  74                 if len(a) != 4:
  75                     sys.stderr.write("creator must be 4-char string\n")
  76                     sys.exit(1)
  77                 creatorsignature = a
  78             if o in ('-d', '--dump'):
  79                 dump = sys.stdout
  80             if o in ('-v', '--verbose'):
  81                 verbose = sys.stderr
  82
  83
  84         if output and len(args) > 1:
  85             sys.stderr.write("%s: cannot specify --output with multiple inputs\n" % sys.argv[0])
  86             sys.exit(1)
  87
  88         for filename in args:
  89             process_func(filename, output=output, basepkgname=basepkgname,
  90                 edit_modnames=edit_modnames, creatorsignature=creatorsignature,
  91                 dump=dump, verbose=verbose)
  92     else:
  93         main_interactive()
  94
  95 def main_interactive(interact=0, basepkgname='StdSuites'):
  96     if interact:
  97         # Ask for save-filename for each module
  98         edit_modnames = None
  99     else:
 100         # Use default filenames for each module
 101         edit_modnames = []
 102     appsfolder = Carbon.Folder.FSFindFolder(-32765, 'apps', 0)
 103     filename = EasyDialogs.AskFileForOpen(
 104         message='Select scriptable application',
 105         dialogOptionFlags=0x1056,       # allow selection of .app bundles
 106         defaultLocation=appsfolder)
 107     if not filename:
 108         return
 109     if not is_scriptable(filename):
 110         if EasyDialogs.AskYesNoCancel(
 111                 "Warning: application does not seem scriptable",
 112                 yes="Continue", default=2, no="") <= 0:
 113             return
 114     try:
 115         processfile(filename, edit_modnames=edit_modnames, basepkgname=basepkgname,
 116         verbose=sys.stderr)
 117     except MacOS.Error, arg:
 118         print "Error getting terminology:", arg
 119         print "Retry, manually parsing resources"
 120         processfile_fromresource(filename, edit_modnames=edit_modnames,
 121             basepkgname=basepkgname, verbose=sys.stderr)
 122
 123 def is_scriptable(application):
 124     """Return true if the application is scriptable"""
 125     if os.path.isdir(application):
 126         plistfile = os.path.join(application, 'Contents', 'Info.plist')
 127         if not os.path.exists(plistfile):
 128             return False
 129         plist = plistlib.Plist.fromFile(plistfile)
 130         return plist.get('NSAppleScriptEnabled', False)
 131     # If it is a file test for an aete/aeut resource.
 132     currf = CurResFile()
 133     try:
 134         refno = macresource.open_pathname(application)
 135     except MacOS.Error:
 136         return False
 137     UseResFile(refno)
 138     n_terminology = Count1Resources('aete') + Count1Resources('aeut') + \
 139         Count1Resources('scsz') + Count1Resources('osiz')
 140     CloseResFile(refno)
 141     UseResFile(currf)
 142     return n_terminology > 0
 143
 144 def processfile_fromresource(fullname, output=None, basepkgname=None,
 145         edit_modnames=None, creatorsignature=None, dump=None, verbose=None):
 146     """Process all resources in a single file"""
 147     if not is_scriptable(fullname) and verbose:
 148         print >>verbose, "Warning: app does not seem scriptable: %s" % fullname
 149     cur = CurResFile()
 150     if verbose:
 151         print >>verbose, "Processing", fullname
 152     rf = macresource.open_pathname(fullname)
 153     try:
 154         UseResFile(rf)
 155         resources = []
 156         for i in range(Count1Resources('aete')):
 157             res = Get1IndResource('aete', 1+i)
 158             resources.append(res)
 159         for i in range(Count1Resources('aeut')):
 160             res = Get1IndResource('aeut', 1+i)
 161             resources.append(res)
 162         if verbose:
 163             print >>verbose, "\nLISTING aete+aeut RESOURCES IN", repr(fullname)
 164         aetelist = []
 165         for res in resources:
 166             if verbose:
 167                 print >>verbose, "decoding", res.GetResInfo(), "..."
 168             data = res.data
 169             aete = decode(data, verbose)
 170             aetelist.append((aete, res.GetResInfo()))
 171     finally:
 172         if rf <> cur:
 173             CloseResFile(rf)
 174             UseResFile(cur)
 175     # switch back (needed for dialogs in Python)
 176     UseResFile(cur)
 177     if dump:
 178         dumpaetelist(aetelist, dump)
 179     compileaetelist(aetelist, fullname, output=output,
 180         basepkgname=basepkgname, edit_modnames=edit_modnames,
 181         creatorsignature=creatorsignature, verbose=verbose)
 182
 183 def processfile(fullname, output=None, basepkgname=None,
 184         edit_modnames=None, creatorsignature=None, dump=None,
 185         verbose=None):
 186     """Ask an application for its terminology and process that"""
 187     if not is_scriptable(fullname) and verbose:
 188         print >>verbose, "Warning: app does not seem scriptable: %s" % fullname
 189     if verbose:
 190         print >>verbose, "\nASKING FOR aete DICTIONARY IN", repr(fullname)
 191     try:
 192         aedescobj, launched = OSATerminology.GetAppTerminology(fullname)
 193     except MacOS.Error, arg:
 194         if arg[0] in (-1701, -192): # errAEDescNotFound, resNotFound
 195             if verbose:
 196                 print >>verbose, "GetAppTerminology failed with errAEDescNotFound/resNotFound, trying manually"
 197             aedata, sig = getappterminology(fullname, verbose=verbose)
 198             if not creatorsignature:
 199                 creatorsignature = sig
 200         else:
 201             raise
 202     else:
 203         if launched:
 204             if verbose:
 205                 print >>verbose, "Launched", fullname
 206         raw = aetools.unpack(aedescobj)
 207         if not raw:
 208             if verbose:
 209                 print >>verbose, 'Unpack returned empty value:', raw
 210             return
 211         if not raw[0].data:
 212             if verbose:
 213                 print >>verbose, 'Unpack returned value without data:', raw
 214             return
 215         aedata = raw[0]
 216     aete = decode(aedata.data, verbose)
 217     if dump:
 218         dumpaetelist([aete], dump)
 219         return
 220     compileaete(aete, None, fullname, output=output, basepkgname=basepkgname,
 221         creatorsignature=creatorsignature, edit_modnames=edit_modnames,
 222         verbose=verbose)
 223
 224 def getappterminology(fullname, verbose=None):
 225     """Get application terminology by sending an AppleEvent"""
 226     # First check that we actually can send AppleEvents
 227     if not MacOS.WMAvailable():
 228         raise RuntimeError, "Cannot send AppleEvents, no access to window manager"
 229     # Next, a workaround for a bug in MacOS 10.2: sending events will hang unless
 230     # you have created an event loop first.
 231     import Carbon.Evt
 232     Carbon.Evt.WaitNextEvent(0,0)
 233     if os.path.isdir(fullname):
 234         # Now get the signature of the application, hoping it is a bundle
 235         pkginfo = os.path.join(fullname, 'Contents', 'PkgInfo')
 236         if not os.path.exists(pkginfo):
 237             raise RuntimeError, "No PkgInfo file found"
 238         tp_cr = open(pkginfo, 'rb').read()
 239         cr = tp_cr[4:8]
 240     else:
 241         # Assume it is a file
 242         cr, tp = MacOS.GetCreatorAndType(fullname)
 243     # Let's talk to it and ask for its AETE
 244     talker = aetools.TalkTo(cr)
 245     try:
 246         talker._start()
 247     except (MacOS.Error, aetools.Error), arg:
 248         if verbose:
 249             print >>verbose, 'Warning: start() failed, continuing anyway:', arg
 250     reply = talker.send("ascr", "gdte")
 251     #reply2 = talker.send("ascr", "gdut")
 252     # Now pick the bits out of the return that we need.
 253     return reply[1]['----'], cr
 254
 255
 256 def compileaetelist(aetelist, fullname, output=None, basepkgname=None,
 257             edit_modnames=None, creatorsignature=None, verbose=None):
 258     for aete, resinfo in aetelist:
 259         compileaete(aete, resinfo, fullname, output=output,
 260             basepkgname=basepkgname, edit_modnames=edit_modnames,
 261             creatorsignature=creatorsignature, verbose=verbose)
 262
 263 def dumpaetelist(aetelist, output):
 264     import pprint
 265     pprint.pprint(aetelist, output)
 266
 267 def decode(data, verbose=None):
 268     """Decode a resource into a python data structure"""
 269     f = StringIO.StringIO(data)
 270     aete = generic(getaete, f)
 271     aete = simplify(aete)
 272     processed = f.tell()
 273     unprocessed = len(f.read())
 274     total = f.tell()
 275     if unprocessed and verbose:
 276         verbose.write("%d processed + %d unprocessed = %d total\n" %
 277                          (processed, unprocessed, total))
 278     return aete
 279
 280 def simplify(item):
 281     """Recursively replace singleton tuples by their constituent item"""
 282     if type(item) is types.ListType:
 283         return map(simplify, item)
 284     elif type(item) == types.TupleType and len(item) == 2:
 285         return simplify(item[1])
 286     else:
 287         return item
 288
 289
 290 # Here follows the aete resource decoder.
 291 # It is presented bottom-up instead of top-down because there are  direct
 292 # references to the lower-level part-decoders from the high-level part-decoders.
 293
 294 def getbyte(f, *args):
 295     c = f.read(1)
 296     if not c:
 297         raise EOFError, 'in getbyte' + str(args)
 298     return ord(c)
 299
 300 def getword(f, *args):
 301     getalign(f)
 302     s = f.read(2)
 303     if len(s) < 2:
 304         raise EOFError, 'in getword' + str(args)
 305     return (ord(s[0])<<8) | ord(s[1])
 306
 307 def getlong(f, *args):
 308     getalign(f)
 309     s = f.read(4)
 310     if len(s) < 4:
 311         raise EOFError, 'in getlong' + str(args)
 312     return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
 313
 314 def getostype(f, *args):
 315     getalign(f)
 316     s = f.read(4)
 317     if len(s) < 4:
 318         raise EOFError, 'in getostype' + str(args)
 319     return s
 320
 321 def getpstr(f, *args):
 322     c = f.read(1)
 323     if len(c) < 1:
 324         raise EOFError, 'in getpstr[1]' + str(args)
 325     nbytes = ord(c)
 326     if nbytes == 0: return ''
 327     s = f.read(nbytes)
 328     if len(s) < nbytes:
 329         raise EOFError, 'in getpstr[2]' + str(args)
 330     return s
 331
 332 def getalign(f):
 333     if f.tell() & 1:
 334         c = f.read(1)
 335         ##if c <> '\0':
 336         ##  print align:', repr(c)
 337
 338 def getlist(f, description, getitem):
 339     count = getword(f)
 340     list = []
 341     for i in range(count):
 342         list.append(generic(getitem, f))
 343         getalign(f)
 344     return list
 345
 346 def alt_generic(what, f, *args):
 347     print "generic", repr(what), args
 348     res = vageneric(what, f, args)
 349     print '->', repr(res)
 350     return res
 351
 352 def generic(what, f, *args):
 353     if type(what) == types.FunctionType:
 354         return apply(what, (f,) + args)
 355     if type(what) == types.ListType:
 356         record = []
 357         for thing in what:
 358             item = apply(generic, thing[:1] + (f,) + thing[1:])
 359             record.append((thing[1], item))
 360         return record
 361     return "BAD GENERIC ARGS: %r" % (what,)
 362
 363 getdata = [
 364     (getostype, "type"),
 365     (getpstr, "description"),
 366     (getword, "flags")
 367     ]
 368 getargument = [
 369     (getpstr, "name"),
 370     (getostype, "keyword"),
 371     (getdata, "what")
 372     ]
 373 getevent = [
 374     (getpstr, "name"),
 375     (getpstr, "description"),
 376     (getostype, "suite code"),
 377     (getostype, "event code"),
 378     (getdata, "returns"),
 379     (getdata, "accepts"),
 380     (getlist, "optional arguments", getargument)
 381     ]
 382 getproperty = [
 383     (getpstr, "name"),
 384     (getostype, "code"),
 385     (getdata, "what")
 386     ]
 387 getelement = [
 388     (getostype, "type"),
 389     (getlist, "keyform", getostype)
 390     ]
 391 getclass = [
 392     (getpstr, "name"),
 393     (getostype, "class code"),
 394     (getpstr, "description"),
 395     (getlist, "properties", getproperty),
 396     (getlist, "elements", getelement)
 397     ]
 398 getcomparison = [
 399     (getpstr, "operator name"),
 400     (getostype, "operator ID"),
 401     (getpstr, "operator comment"),
 402     ]
 403 getenumerator = [
 404     (getpstr, "enumerator name"),
 405     (getostype, "enumerator ID"),
 406     (getpstr, "enumerator comment")
 407     ]
 408 getenumeration = [
 409     (getostype, "enumeration ID"),
 410     (getlist, "enumerator", getenumerator)
 411     ]
 412 getsuite = [
 413     (getpstr, "suite name"),
 414     (getpstr, "suite description"),
 415     (getostype, "suite ID"),
 416     (getword, "suite level"),
 417     (getword, "suite version"),
 418     (getlist, "events", getevent),
 419     (getlist, "classes", getclass),
 420     (getlist, "comparisons", getcomparison),
 421     (getlist, "enumerations", getenumeration)
 422     ]
 423 getaete = [
 424     (getword, "major/minor version in BCD"),
 425     (getword, "language code"),
 426     (getword, "script code"),
 427     (getlist, "suites", getsuite)
 428     ]
 429
 430 def compileaete(aete, resinfo, fname, output=None, basepkgname=None,
 431         edit_modnames=None, creatorsignature=None, verbose=None):
 432     """Generate code for a full aete resource. fname passed for doc purposes"""
 433     [version, language, script, suites] = aete
 434     major, minor = divmod(version, 256)
 435     if not creatorsignature:
 436         creatorsignature, dummy = MacOS.GetCreatorAndType(fname)
 437     packagename = identify(os.path.splitext(os.path.basename(fname))[0])
 438     if language:
 439         packagename = packagename+'_lang%d'%language
 440     if script:
 441         packagename = packagename+'_script%d'%script
 442     if len(packagename) > 27:
 443         packagename = packagename[:27]
 444     if output:
 445         # XXXX Put this in site-packages if it isn't a full pathname?
 446         if not os.path.exists(output):
 447             os.mkdir(output)
 448         pathname = output
 449     else:
 450         pathname = EasyDialogs.AskFolder(message='Create and select package folder for %s'%packagename,
 451             defaultLocation=DEFAULT_USER_PACKAGEFOLDER)
 452         output = pathname
 453     if not pathname:
 454         return
 455     packagename = os.path.split(os.path.normpath(pathname))[1]
 456     if not basepkgname:
 457         basepkgname = EasyDialogs.AskFolder(message='Package folder for base suite (usually StdSuites)',
 458             defaultLocation=DEFAULT_STANDARD_PACKAGEFOLDER)
 459     if basepkgname:
 460         dirname, basepkgname = os.path.split(os.path.normpath(basepkgname))
 461         if dirname and not dirname in sys.path:
 462             sys.path.insert(0, dirname)
 463         basepackage = __import__(basepkgname)
 464     else:
 465         basepackage = None
 466     suitelist = []
 467     allprecompinfo = []
 468     allsuites = []
 469     for suite in suites:
 470         compiler = SuiteCompiler(suite, basepackage, output, edit_modnames, verbose)
 471         code, modname, precompinfo = compiler.precompilesuite()
 472         if not code:
 473             continue
 474         allprecompinfo = allprecompinfo + precompinfo
 475         suiteinfo = suite, pathname, modname
 476         suitelist.append((code, modname))
 477         allsuites.append(compiler)
 478     for compiler in allsuites:
 479         compiler.compilesuite(major, minor, language, script, fname, allprecompinfo)
 480     initfilename = os.path.join(output, '__init__.py')
 481     fp = open(initfilename, 'w')
 482     MacOS.SetCreatorAndType(initfilename, 'Pyth', 'TEXT')
 483     fp.write('"""\n')
 484     fp.write("Package generated from %s\n"%ascii(fname))
 485     if resinfo:
 486         fp.write("Resource %s resid %d %s\n"%(ascii(resinfo[1]), resinfo[0], ascii(resinfo[2])))
 487     fp.write('"""\n')
 488     fp.write('import aetools\n')
 489     fp.write('Error = aetools.Error\n')
 490     suitelist.sort()
 491     for code, modname in suitelist:
 492         fp.write("import %s\n" % modname)
 493     fp.write("\n\n_code_to_module = {\n")
 494     for code, modname in suitelist:
 495         fp.write("    '%s' : %s,\n"%(ascii(code), modname))
 496     fp.write("}\n\n")
 497     fp.write("\n\n_code_to_fullname = {\n")
 498     for code, modname in suitelist:
 499         fp.write("    '%s' : ('%s.%s', '%s'),\n"%(ascii(code), packagename, modname, modname))
 500     fp.write("}\n\n")
 501     for code, modname in suitelist:
 502         fp.write("from %s import *\n"%modname)
 503
 504     # Generate property dicts and element dicts for all types declared in this module
 505     fp.write("\ndef getbaseclasses(v):\n")
 506     fp.write("    if not getattr(v, '_propdict', None):\n")
 507     fp.write("        v._propdict = {}\n")
 508     fp.write("        v._elemdict = {}\n")
 509     fp.write("        for superclassname in getattr(v, '_superclassnames', []):\n")
 510     fp.write("            superclass = eval(superclassname)\n")
 511     fp.write("            getbaseclasses(superclass)\n")
 512     fp.write("            v._propdict.update(getattr(superclass, '_propdict', {}))\n")
 513     fp.write("            v._elemdict.update(getattr(superclass, '_elemdict', {}))\n")
 514     fp.write("        v._propdict.update(getattr(v, '_privpropdict', {}))\n")
 515     fp.write("        v._elemdict.update(getattr(v, '_privelemdict', {}))\n")
 516     fp.write("\n")
 517     fp.write("import StdSuites\n")
 518     allprecompinfo.sort()
 519     if allprecompinfo:
 520         fp.write("\n#\n# Set property and element dictionaries now that all classes have been defined\n#\n")
 521         for codenamemapper in allprecompinfo:
 522             for k, v in codenamemapper.getall('class'):
 523                 fp.write("getbaseclasses(%s)\n" % v)
 524
 525     # Generate a code-to-name mapper for all of the types (classes) declared in this module
 526     application_class = None
 527     if allprecompinfo:
 528         fp.write("\n#\n# Indices of types declared in this module\n#\n")
 529         fp.write("_classdeclarations = {\n")
 530         for codenamemapper in allprecompinfo:
 531             for k, v in codenamemapper.getall('class'):
 532                 fp.write("    %r : %s,\n" % (k, v))
 533                 if k == 'capp':
 534                     application_class = v
 535         fp.write("}\n")
 536
 537
 538     if suitelist:
 539         fp.write("\n\nclass %s(%s_Events"%(packagename, suitelist[0][1]))
 540         for code, modname in suitelist[1:]:
 541             fp.write(",\n        %s_Events"%modname)
 542         fp.write(",\n        aetools.TalkTo):\n")
 543         fp.write("    _signature = %r\n\n"%(creatorsignature,))
 544         fp.write("    _moduleName = '%s'\n\n"%packagename)
 545         if application_class:
 546             fp.write("    _elemdict = %s._elemdict\n" % application_class)
 547             fp.write("    _propdict = %s._propdict\n" % application_class)
 548     fp.close()
 549
 550 class SuiteCompiler:
 551     def __init__(self, suite, basepackage, output, edit_modnames, verbose):
 552         self.suite = suite
 553         self.basepackage = basepackage
 554         self.edit_modnames = edit_modnames
 555         self.output = output
 556         self.verbose = verbose
 557
 558         # Set by precompilesuite
 559         self.pathname = None
 560         self.modname = None
 561
 562         # Set by compilesuite
 563         self.fp = None
 564         self.basemodule = None
 565         self.enumsneeded = {}
 566
 567     def precompilesuite(self):
 568         """Parse a single suite without generating the output. This step is needed
 569         so we can resolve recursive references by suites to enums/comps/etc declared
 570         in other suites"""
 571         [name, desc, code, level, version, events, classes, comps, enums] = self.suite
 572
 573         modname = identify(name)
 574         if len(modname) > 28:
 575             modname = modname[:27]
 576         if self.edit_modnames is None:
 577             self.pathname = EasyDialogs.AskFileForSave(message='Python output file',
 578                 savedFileName=modname+'.py')
 579         else:
 580             for old, new in self.edit_modnames:
 581                 if old == modname:
 582                     modname = new
 583             if modname:
 584                 self.pathname = os.path.join(self.output, modname + '.py')
 585             else:
 586                 self.pathname = None
 587         if not self.pathname:
 588             return None, None, None
 589
 590         self.modname = os.path.splitext(os.path.split(self.pathname)[1])[0]
 591
 592         if self.basepackage and self.basepackage._code_to_module.has_key(code):
 593             # We are an extension of a baseclass (usually an application extending
 594             # Standard_Suite or so). Import everything from our base module
 595             basemodule = self.basepackage._code_to_module[code]
 596         else:
 597             # We are not an extension.
 598             basemodule = None
 599
 600         self.enumsneeded = {}
 601         for event in events:
 602             self.findenumsinevent(event)
 603
 604         objc = ObjectCompiler(None, self.modname, basemodule, interact=(self.edit_modnames is None),
 605             verbose=self.verbose)
 606         for cls in classes:
 607             objc.compileclass(cls)
 608         for cls in classes:
 609             objc.fillclasspropsandelems(cls)
 610         for comp in comps:
 611             objc.compilecomparison(comp)
 612         for enum in enums:
 613             objc.compileenumeration(enum)
 614
 615         for enum in self.enumsneeded.keys():
 616             objc.checkforenum(enum)
 617
 618         objc.dumpindex()
 619
 620         precompinfo = objc.getprecompinfo(self.modname)
 621
 622         return code, self.modname, precompinfo
 623
 624     def compilesuite(self, major, minor, language, script, fname, precompinfo):
 625         """Generate code for a single suite"""
 626         [name, desc, code, level, version, events, classes, comps, enums] = self.suite
 627         # Sort various lists, so re-generated source is easier compared
 628         def class_sorter(k1, k2):
 629             """Sort classes by code, and make sure main class sorts before synonyms"""
 630             # [name, code, desc, properties, elements] = cls
 631             if k1[1] < k2[1]: return -1
 632             if k1[1] > k2[1]: return 1
 633             if not k2[3] or k2[3][0][1] == 'c@#!':
 634                 # This is a synonym, the other one is better
 635                 return -1
 636             if not k1[3] or k1[3][0][1] == 'c@#!':
 637                 # This is a synonym, the other one is better
 638                 return 1
 639             return 0
 640
 641         events.sort()
 642         classes.sort(class_sorter)
 643         comps.sort()
 644         enums.sort()
 645
 646         self.fp = fp = open(self.pathname, 'w')
 647         MacOS.SetCreatorAndType(self.pathname, 'Pyth', 'TEXT')
 648
 649         fp.write('"""Suite %s: %s\n' % (ascii(name), ascii(desc)))
 650         fp.write("Level %d, version %d\n\n" % (level, version))
 651         fp.write("Generated from %s\n"%ascii(fname))
 652         fp.write("AETE/AEUT resource version %d/%d, language %d, script %d\n" % \
 653             (major, minor, language, script))
 654         fp.write('"""\n\n')
 655
 656         fp.write('import aetools\n')
 657         fp.write('import MacOS\n\n')
 658         fp.write("_code = %r\n\n"% (code,))
 659         if self.basepackage and self.basepackage._code_to_module.has_key(code):
 660             # We are an extension of a baseclass (usually an application extending
 661             # Standard_Suite or so). Import everything from our base module
 662             fp.write('from %s import *\n'%self.basepackage._code_to_fullname[code][0])
 663             basemodule = self.basepackage._code_to_module[code]
 664         elif self.basepackage and self.basepackage._code_to_module.has_key(code.lower()):
 665             # This is needed by CodeWarrior and some others.
 666             fp.write('from %s import *\n'%self.basepackage._code_to_fullname[code.lower()][0])
 667             basemodule = self.basepackage._code_to_module[code.lower()]
 668         else:
 669             # We are not an extension.
 670             basemodule = None
 671         self.basemodule = basemodule
 672         self.compileclassheader()
 673
 674         self.enumsneeded = {}
 675         if events:
 676             for event in events:
 677                 self.compileevent(event)
 678         else:
 679             fp.write("    pass\n\n")
 680
 681         objc = ObjectCompiler(fp, self.modname, basemodule, precompinfo, interact=(self.edit_modnames is None),
 682             verbose=self.verbose)
 683         for cls in classes:
 684             objc.compileclass(cls)
 685         for cls in classes:
 686             objc.fillclasspropsandelems(cls)
 687         for comp in comps:
 688             objc.compilecomparison(comp)
 689         for enum in enums:
 690             objc.compileenumeration(enum)
 691
 692         for enum in self.enumsneeded.keys():
 693             objc.checkforenum(enum)
 694
 695         objc.dumpindex()
 696
 697     def compileclassheader(self):
 698         """Generate class boilerplate"""
 699         classname = '%s_Events'%self.modname
 700         if self.basemodule:
 701             modshortname = string.split(self.basemodule.__name__, '.')[-1]
 702             baseclassname = '%s_Events'%modshortname
 703             self.fp.write("class %s(%s):\n\n"%(classname, baseclassname))
 704         else:
 705             self.fp.write("class %s:\n\n"%classname)
 706
 707     def compileevent(self, event):
 708         """Generate code for a single event"""
 709         [name, desc, code, subcode, returns, accepts, arguments] = event
 710         fp = self.fp
 711         funcname = identify(name)
 712         #
 713         # generate name->keyword map
 714         #
 715         if arguments:
 716             fp.write("    _argmap_%s = {\n"%funcname)
 717             for a in arguments:
 718                 fp.write("        %r : %r,\n"%(identify(a[0]), a[1]))
 719             fp.write("    }\n\n")
 720
 721         #
 722         # Generate function header
 723         #
 724         has_arg = (not is_null(accepts))
 725         opt_arg = (has_arg and is_optional(accepts))
 726
 727         fp.write("    def %s(self, "%funcname)
 728         if has_arg:
 729             if not opt_arg:
 730                 fp.write("_object, ")       # Include direct object, if it has one
 731             else:
 732                 fp.write("_object=None, ")  # Also include if it is optional
 733         else:
 734             fp.write("_no_object=None, ")   # For argument checking
 735         fp.write("_attributes={}, **_arguments):\n")    # include attribute dict and args
 736         #
 737         # Generate doc string (important, since it may be the only
 738         # available documentation, due to our name-remaping)
 739         #
 740         fp.write('        """%s: %s\n'%(ascii(name), ascii(desc)))
 741         if has_arg:
 742             fp.write("        Required argument: %s\n"%getdatadoc(accepts))
 743         elif opt_arg:
 744             fp.write("        Optional argument: %s\n"%getdatadoc(accepts))
 745         for arg in arguments:
 746             fp.write("        Keyword argument %s: %s\n"%(identify(arg[0]),
 747                     getdatadoc(arg[2])))
 748         fp.write("        Keyword argument _attributes: AppleEvent attribute dictionary\n")
 749         if not is_null(returns):
 750             fp.write("        Returns: %s\n"%getdatadoc(returns))
 751         fp.write('        """\n')
 752         #
 753         # Fiddle the args so everything ends up in 'arguments' dictionary
 754         #
 755         fp.write("        _code = %r\n"% (code,))
 756         fp.write("        _subcode = %r\n\n"% (subcode,))
 757         #
 758         # Do keyword name substitution
 759         #
 760         if arguments:
 761             fp.write("        aetools.keysubst(_arguments, self._argmap_%s)\n"%funcname)
 762         else:
 763             fp.write("        if _arguments: raise TypeError, 'No optional args expected'\n")
 764         #
 765         # Stuff required arg (if there is one) into arguments
 766         #
 767         if has_arg:
 768             fp.write("        _arguments['----'] = _object\n")
 769         elif opt_arg:
 770             fp.write("        if _object:\n")
 771             fp.write("            _arguments['----'] = _object\n")
 772         else:
 773             fp.write("        if _no_object != None: raise TypeError, 'No direct arg expected'\n")
 774         fp.write("\n")
 775         #
 776         # Do enum-name substitution
 777         #
 778         for a in arguments:
 779             if is_enum(a[2]):
 780                 kname = a[1]
 781                 ename = a[2][0]
 782                 if ename <> '****':
 783                     fp.write("        aetools.enumsubst(_arguments, %r, _Enum_%s)\n" %
 784                         (kname, identify(ename)))
 785                     self.enumsneeded[ename] = 1
 786         fp.write("\n")
 787         #
 788         # Do the transaction
 789         #
 790         fp.write("        _reply, _arguments, _attributes = self.send(_code, _subcode,\n")
 791         fp.write("                _arguments, _attributes)\n")
 792         #
 793         # Error handling
 794         #
 795         fp.write("        if _arguments.get('errn', 0):\n")
 796         fp.write("            raise aetools.Error, aetools.decodeerror(_arguments)\n")
 797         fp.write("        # XXXX Optionally decode result\n")
 798         #
 799         # Decode result
 800         #
 801         fp.write("        if _arguments.has_key('----'):\n")
 802         if is_enum(returns):
 803             fp.write("            # XXXX Should do enum remapping here...\n")
 804         fp.write("            return _arguments['----']\n")
 805         fp.write("\n")
 806
 807     def findenumsinevent(self, event):
 808         """Find all enums for a single event"""
 809         [name, desc, code, subcode, returns, accepts, arguments] = event
 810         for a in arguments:
 811             if is_enum(a[2]):
 812                 ename = a[2][0]
 813                 if ename <> '****':
 814                     self.enumsneeded[ename] = 1
 815
 816 #
 817 # This class stores the code<->name translations for a single module. It is used
 818 # to keep the information while we're compiling the module, but we also keep these objects
 819 # around so if one suite refers to, say, an enum in another suite we know where to
 820 # find it. Finally, if we really can't find a code, the user can add modules by
 821 # hand.
 822 #
 823 class CodeNameMapper:
 824
 825     def __init__(self, interact=1, verbose=None):
 826         self.code2name = {
 827             "property" : {},
 828             "class" : {},
 829             "enum" : {},
 830             "comparison" : {},
 831         }
 832         self.name2code =  {
 833             "property" : {},
 834             "class" : {},
 835             "enum" : {},
 836             "comparison" : {},
 837         }
 838         self.modulename = None
 839         self.star_imported = 0
 840         self.can_interact = interact
 841         self.verbose = verbose
 842
 843     def addnamecode(self, type, name, code):
 844         self.name2code[type][name] = code
 845         if not self.code2name[type].has_key(code):
 846             self.code2name[type][code] = name
 847
 848     def hasname(self, name):
 849         for dict in self.name2code.values():
 850             if dict.has_key(name):
 851                 return True
 852         return False
 853
 854     def hascode(self, type, code):
 855         return self.code2name[type].has_key(code)
 856
 857     def findcodename(self, type, code):
 858         if not self.hascode(type, code):
 859             return None, None, None
 860         name = self.code2name[type][code]
 861         if self.modulename and not self.star_imported:
 862             qualname = '%s.%s'%(self.modulename, name)
 863         else:
 864             qualname = name
 865         return name, qualname, self.modulename
 866
 867     def getall(self, type):
 868         return self.code2name[type].items()
 869
 870     def addmodule(self, module, name, star_imported):
 871         self.modulename = name
 872         self.star_imported = star_imported
 873         for code, name in module._propdeclarations.items():
 874             self.addnamecode('property', name, code)
 875         for code, name in module._classdeclarations.items():
 876             self.addnamecode('class', name, code)
 877         for code in module._enumdeclarations.keys():
 878             self.addnamecode('enum', '_Enum_'+identify(code), code)
 879         for code, name in module._compdeclarations.items():
 880             self.addnamecode('comparison', name, code)
 881
 882     def prepareforexport(self, name=None):
 883         if not self.modulename:
 884             self.modulename = name
 885         return self
 886
 887 class ObjectCompiler:
 888     def __init__(self, fp, modname, basesuite, othernamemappers=None, interact=1,
 889             verbose=None):
 890         self.fp = fp
 891         self.verbose = verbose
 892         self.basesuite = basesuite
 893         self.can_interact = interact
 894         self.modulename = modname
 895         self.namemappers = [CodeNameMapper(self.can_interact, self.verbose)]
 896         if othernamemappers:
 897             self.othernamemappers = othernamemappers[:]
 898         else:
 899             self.othernamemappers = []
 900         if basesuite:
 901             basemapper = CodeNameMapper(self.can_interact, self.verbose)
 902             basemapper.addmodule(basesuite, '', 1)
 903             self.namemappers.append(basemapper)
 904
 905     def getprecompinfo(self, modname):
 906         list = []
 907         for mapper in self.namemappers:
 908             emapper = mapper.prepareforexport(modname)
 909             if emapper:
 910                 list.append(emapper)
 911         return list
 912
 913     def findcodename(self, type, code):
 914         while 1:
 915             # First try: check whether we already know about this code.
 916             for mapper in self.namemappers:
 917                 if mapper.hascode(type, code):
 918                     return mapper.findcodename(type, code)
 919             # Second try: maybe one of the other modules knows about it.
 920             for mapper in self.othernamemappers:
 921                 if mapper.hascode(type, code):
 922                     self.othernamemappers.remove(mapper)
 923                     self.namemappers.append(mapper)
 924                     if self.fp:
 925                         self.fp.write("import %s\n"%mapper.modulename)
 926                     break
 927             else:
 928                 # If all this has failed we ask the user for a guess on where it could
 929                 # be and retry.
 930                 if self.fp:
 931                     m = self.askdefinitionmodule(type, code)
 932                 else:
 933                     m = None
 934                 if not m: return None, None, None
 935                 mapper = CodeNameMapper(self.can_interact, self.verbose)
 936                 mapper.addmodule(m, m.__name__, 0)
 937                 self.namemappers.append(mapper)
 938
 939     def hasname(self, name):
 940         for mapper in self.othernamemappers:
 941             if mapper.hasname(name) and mapper.modulename != self.modulename:
 942                 if self.verbose:
 943                     print >>self.verbose, "Duplicate Python identifier:", name, self.modulename, mapper.modulename
 944                 return True
 945         return False
 946
 947     def askdefinitionmodule(self, type, code):
 948         if not self.can_interact:
 949             if self.verbose:
 950                 print >>self.verbose, "** No definition for %s '%s' found" % (type, code)
 951             return None
 952         path = EasyDialogs.AskFileForSave(message='Where is %s %s declared?'%(type, code))
 953         if not path: return
 954         path, file = os.path.split(path)
 955         modname = os.path.splitext(file)[0]
 956         if not path in sys.path:
 957             sys.path.insert(0, path)
 958         m = __import__(modname)
 959         self.fp.write("import %s\n"%modname)
 960         return m
 961
 962     def compileclass(self, cls):
 963         [name, code, desc, properties, elements] = cls
 964         pname = identify(name)
 965         if self.namemappers[0].hascode('class', code):
 966             # plural forms and such
 967             othername, dummy, dummy = self.namemappers[0].findcodename('class', code)
 968             if self.fp:
 969                 self.fp.write("\n%s = %s\n"%(pname, othername))
 970         else:
 971             if self.fp:
 972                 self.fp.write('\nclass %s(aetools.ComponentItem):\n' % pname)
 973                 self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(desc)))
 974                 self.fp.write('    want = %r\n' % (code,))
 975         self.namemappers[0].addnamecode('class', pname, code)
 976         is_application_class = (code == 'capp')
 977         properties.sort()
 978         for prop in properties:
 979             self.compileproperty(prop, is_application_class)
 980         elements.sort()
 981         for elem in elements:
 982             self.compileelement(elem)
 983
 984     def compileproperty(self, prop, is_application_class=False):
 985         [name, code, what] = prop
 986         if code == 'c@#!':
 987             # Something silly with plurals. Skip it.
 988             return
 989         pname = identify(name)
 990         if self.namemappers[0].hascode('property', code):
 991             # plural forms and such
 992             othername, dummy, dummy = self.namemappers[0].findcodename('property', code)
 993             if pname == othername:
 994                 return
 995             if self.fp:
 996                 self.fp.write("\n_Prop_%s = _Prop_%s\n"%(pname, othername))
 997         else:
 998             if self.fp:
 999                 self.fp.write("class _Prop_%s(aetools.NProperty):\n" % pname)
1000                 self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(what[1])))
1001                 self.fp.write("    which = %r\n" % (code,))
1002                 self.fp.write("    want = %r\n" % (what[0],))
1003         self.namemappers[0].addnamecode('property', pname, code)
1004         if is_application_class and self.fp:
1005             self.fp.write("%s = _Prop_%s()\n" % (pname, pname))
1006
1007     def compileelement(self, elem):
1008         [code, keyform] = elem
1009         if self.fp:
1010             self.fp.write("#        element %r as %s\n" % (code, keyform))
1011
1012     def fillclasspropsandelems(self, cls):
1013         [name, code, desc, properties, elements] = cls
1014         cname = identify(name)
1015         if self.namemappers[0].hascode('class', code) and \
1016                 self.namemappers[0].findcodename('class', code)[0] != cname:
1017             # This is an other name (plural or so) for something else. Skip.
1018             if self.fp and (elements or len(properties) > 1 or (len(properties) == 1 and
1019                 properties[0][1] != 'c@#!')):
1020                 if self.verbose:
1021                     print >>self.verbose, '** Skip multiple %s of %s (code %r)' % (cname, self.namemappers[0].findcodename('class', code)[0], code)
1022                 raise RuntimeError, "About to skip non-empty class"
1023             return
1024         plist = []
1025         elist = []
1026         superclasses = []
1027         for prop in properties:
1028             [pname, pcode, what] = prop
1029             if pcode == "c@#^":
1030                 superclasses.append(what)
1031             if pcode == 'c@#!':
1032                 continue
1033             pname = identify(pname)
1034             plist.append(pname)
1035
1036         superclassnames = []
1037         for superclass in superclasses:
1038             superId, superDesc, dummy = superclass
1039             superclassname, fullyqualifiedname, module = self.findcodename("class", superId)
1040             # I don't think this is correct:
1041             if superclassname == cname:
1042                 pass # superclassnames.append(fullyqualifiedname)
1043             else:
1044                 superclassnames.append(superclassname)
1045
1046         if self.fp:
1047             self.fp.write("%s._superclassnames = %r\n"%(cname, superclassnames))
1048
1049         for elem in elements:
1050             [ecode, keyform] = elem
1051             if ecode == 'c@#!':
1052                 continue
1053             name, ename, module = self.findcodename('class', ecode)
1054             if not name:
1055                 if self.fp:
1056                     self.fp.write("# XXXX %s element %r not found!!\n"%(cname, ecode))
1057             else:
1058                 elist.append((name, ename))
1059
1060         plist.sort()
1061         elist.sort()
1062
1063         if self.fp:
1064             self.fp.write("%s._privpropdict = {\n"%cname)
1065             for n in plist:
1066                 self.fp.write("    '%s' : _Prop_%s,\n"%(n, n))
1067             self.fp.write("}\n")
1068             self.fp.write("%s._privelemdict = {\n"%cname)
1069             for n, fulln in elist:
1070                 self.fp.write("    '%s' : %s,\n"%(n, fulln))
1071             self.fp.write("}\n")
1072
1073     def compilecomparison(self, comp):
1074         [name, code, comment] = comp
1075         iname = identify(name)
1076         self.namemappers[0].addnamecode('comparison', iname, code)
1077         if self.fp:
1078             self.fp.write("class %s(aetools.NComparison):\n" % iname)
1079             self.fp.write('    """%s - %s """\n' % (ascii(name), ascii(comment)))
1080
1081     def compileenumeration(self, enum):
1082         [code, items] = enum
1083         name = "_Enum_%s" % identify(code)
1084         if self.fp:
1085             self.fp.write("%s = {\n" % name)
1086             for item in items:
1087                 self.compileenumerator(item)
1088             self.fp.write("}\n\n")
1089         self.namemappers[0].addnamecode('enum', name, code)
1090         return code
1091
1092     def compileenumerator(self, item):
1093         [name, code, desc] = item
1094         self.fp.write("    %r : %r,\t# %s\n" % (identify(name), code, ascii(desc)))
1095
1096     def checkforenum(self, enum):
1097         """This enum code is used by an event. Make sure it's available"""
1098         name, fullname, module = self.findcodename('enum', enum)
1099         if not name:
1100             if self.fp:
1101                 self.fp.write("_Enum_%s = None # XXXX enum %s not found!!\n"%(identify(enum), ascii(enum)))
1102             return
1103         if module:
1104             if self.fp:
1105                 self.fp.write("from %s import %s\n"%(module, name))
1106
1107     def dumpindex(self):
1108         if not self.fp:
1109             return
1110         self.fp.write("\n#\n# Indices of types declared in this module\n#\n")
1111
1112         self.fp.write("_classdeclarations = {\n")
1113         classlist = self.namemappers[0].getall('class')
1114         classlist.sort()
1115         for k, v in classlist:
1116             self.fp.write("    %r : %s,\n" % (k, v))
1117         self.fp.write("}\n")
1118
1119         self.fp.write("\n_propdeclarations = {\n")
1120         proplist = self.namemappers[0].getall('property')
1121         proplist.sort()
1122         for k, v in proplist:
1123             self.fp.write("    %r : _Prop_%s,\n" % (k, v))
1124         self.fp.write("}\n")
1125
1126         self.fp.write("\n_compdeclarations = {\n")
1127         complist = self.namemappers[0].getall('comparison')
1128         complist.sort()
1129         for k, v in complist:
1130             self.fp.write("    %r : %s,\n" % (k, v))
1131         self.fp.write("}\n")
1132
1133         self.fp.write("\n_enumdeclarations = {\n")
1134         enumlist = self.namemappers[0].getall('enum')
1135         enumlist.sort()
1136         for k, v in enumlist:
1137             self.fp.write("    %r : %s,\n" % (k, v))
1138         self.fp.write("}\n")
1139
1140 def compiledata(data):
1141     [type, description, flags] = data
1142     return "%r -- %r %s" % (type, description, compiledataflags(flags))
1143
1144 def is_null(data):
1145     return data[0] == 'null'
1146
1147 def is_optional(data):
1148     return (data[2] & 0x8000)
1149
1150 def is_enum(data):
1151     return (data[2] & 0x2000)
1152
1153 def getdatadoc(data):
1154     [type, descr, flags] = data
1155     if descr:
1156         return ascii(descr)
1157     if type == '****':
1158         return 'anything'
1159     if type == 'obj ':
1160         return 'an AE object reference'
1161     return "undocumented, typecode %r"%(type,)
1162
1163 dataflagdict = {15: "optional", 14: "list", 13: "enum", 12: "mutable"}
1164 def compiledataflags(flags):
1165     bits = []
1166     for i in range(16):
1167         if flags & (1<<i):
1168             if i in dataflagdict.keys():
1169                 bits.append(dataflagdict[i])
1170             else:
1171                 bits.append(repr(i))
1172     return '[%s]' % string.join(bits)
1173
1174 def ascii(str):
1175     """Return a string with all non-ascii characters hex-encoded"""
1176     if type(str) != type(''):
1177         return map(ascii, str)
1178     rv = ''
1179     for c in str:
1180         if c in ('\t', '\n', '\r') or ' ' <= c < chr(0x7f):
1181             rv = rv + c
1182         else:
1183             rv = rv + '\\' + 'x%02.2x' % ord(c)
1184     return rv
1185
1186 def identify(str):
1187     """Turn any string into an identifier:
1188     - replace space by _
1189     - replace other illegal chars by _xx_ (hex code)
1190     - append _ if the result is a python keyword
1191     """
1192     if not str:
1193         return "empty_ae_name_"
1194     rv = ''
1195     ok = string.ascii_letters + '_'
1196     ok2 = ok + string.digits
1197     for c in str:
1198         if c in ok:
1199             rv = rv + c
1200         elif c == ' ':
1201             rv = rv + '_'
1202         else:
1203             rv = rv + '_%02.2x_'%ord(c)
1204         ok = ok2
1205     if keyword.iskeyword(rv):
1206         rv = rv + '_'
1207     return rv
1208
1209 # Call the main program
1210
1211 if __name__ == '__main__':
1212     main()
1213     sys.exit(1)