home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / MacHacksBug / Python 1.5.2c1 / Mac / scripts / gensuitemodule.py < prev    next >
Encoding:
Python Source  |  2000-06-23  |  16.7 KB  |  623 lines
  1. """
  2. gensuitemodule - Generate an AE suite module from an aete/aeut resource
  3.  
  4. Based on aete.py
  5. """
  6.  
  7. import MacOS
  8. import os
  9. import string
  10. import sys
  11. import types
  12. import StringIO
  13. import macfs
  14.  
  15. from Res import *
  16.  
  17. def main():
  18.     fss, ok = macfs.PromptGetFile('Select file with aeut/aete resource:')
  19.     if not ok:
  20.         sys.exit(0)
  21.     process(fss.as_pathname())
  22.  
  23. def process(fullname):
  24.     """Process all resources in a single file"""
  25.     cur = CurResFile()
  26.     print fullname
  27.     rf = OpenRFPerm(fullname, 0, 1)
  28.     try:
  29.         UseResFile(rf)
  30.         resources = []
  31.         for i in range(Count1Resources('aete')):
  32.             res = Get1IndResource('aete', 1+i)
  33.             resources.append(res)
  34.         for i in range(Count1Resources('aeut')):
  35.             res = Get1IndResource('aeut', 1+i)
  36.             resources.append(res)
  37.         print "\nLISTING aete+aeut RESOURCES IN", `fullname`
  38.         for res in resources:
  39.             print "decoding", res.GetResInfo(), "..."
  40.             data = res.data
  41.             aete = decode(data)
  42.             # switch back (needed for dialogs in Python)
  43.             UseResFile(cur)
  44.             compileaete(aete, fullname)
  45.             UseResFile(rf)
  46.     finally:
  47.         if rf <> cur:
  48.             CloseResFile(rf)
  49.             UseResFile(cur)
  50.  
  51. def decode(data):
  52.     """Decode a resource into a python data structure"""
  53.     f = StringIO.StringIO(data)
  54.     aete = generic(getaete, f)
  55.     aete = simplify(aete)
  56.     processed = f.tell()
  57.     unprocessed = len(f.read())
  58.     total = f.tell()
  59.     if unprocessed:
  60.         sys.stderr.write("%d processed + %d unprocessed = %d total\n" %
  61.                          (processed, unprocessed, total))
  62.     return aete
  63.  
  64. def simplify(item):
  65.     """Recursively replace singleton tuples by their constituent item"""
  66.     if type(item) is types.ListType:
  67.         return map(simplify, item)
  68.     elif type(item) == types.TupleType and len(item) == 2:
  69.         return simplify(item[1])
  70.     else:
  71.         return item
  72.  
  73.  
  74. # Here follows the aete resource decoder.
  75. # It is presented bottom-up instead of top-down because there are  direct
  76. # references to the lower-level part-decoders from the high-level part-decoders.
  77.  
  78. def getbyte(f, *args):
  79.     c = f.read(1)
  80.     if not c:
  81.         raise EOFError, 'in getbyte' + str(args)
  82.     return ord(c)
  83.  
  84. def getword(f, *args):
  85.     getalign(f)
  86.     s = f.read(2)
  87.     if len(s) < 2:
  88.         raise EOFError, 'in getword' + str(args)
  89.     return (ord(s[0])<<8) | ord(s[1])
  90.  
  91. def getlong(f, *args):
  92.     getalign(f)
  93.     s = f.read(4)
  94.     if len(s) < 4:
  95.         raise EOFError, 'in getlong' + str(args)
  96.     return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
  97.  
  98. def getostype(f, *args):
  99.     getalign(f)
  100.     s = f.read(4)
  101.     if len(s) < 4:
  102.         raise EOFError, 'in getostype' + str(args)
  103.     return s
  104.  
  105. def getpstr(f, *args):
  106.     c = f.read(1)
  107.     if len(c) < 1:
  108.         raise EOFError, 'in getpstr[1]' + str(args)
  109.     nbytes = ord(c)
  110.     if nbytes == 0: return ''
  111.     s = f.read(nbytes)
  112.     if len(s) < nbytes:
  113.         raise EOFError, 'in getpstr[2]' + str(args)
  114.     return s
  115.  
  116. def getalign(f):
  117.     if f.tell() & 1:
  118.         c = f.read(1)
  119.         ##if c <> '\0':
  120.         ##    print 'align:', `c`
  121.  
  122. def getlist(f, description, getitem):
  123.     count = getword(f)
  124.     list = []
  125.     for i in range(count):
  126.         list.append(generic(getitem, f))
  127.         getalign(f)
  128.     return list
  129.  
  130. def alt_generic(what, f, *args):
  131.     print "generic", `what`, args
  132.     res = vageneric(what, f, args)
  133.     print '->', `res`
  134.     return res
  135.  
  136. def generic(what, f, *args):
  137.     if type(what) == types.FunctionType:
  138.         return apply(what, (f,) + args)
  139.     if type(what) == types.ListType:
  140.         record = []
  141.         for thing in what:
  142.             item = apply(generic, thing[:1] + (f,) + thing[1:])
  143.             record.append((thing[1], item))
  144.         return record
  145.     return "BAD GENERIC ARGS: %s" % `what`
  146.  
  147. getdata = [
  148.     (getostype, "type"),
  149.     (getpstr, "description"),
  150.     (getword, "flags")
  151.     ]
  152. getargument = [
  153.     (getpstr, "name"),
  154.     (getostype, "keyword"),
  155.     (getdata, "what")
  156.     ]
  157. getevent = [
  158.     (getpstr, "name"),
  159.     (getpstr, "description"),
  160.     (getostype, "suite code"),
  161.     (getostype, "event code"),
  162.     (getdata, "returns"),
  163.     (getdata, "accepts"),
  164.     (getlist, "optional arguments", getargument)
  165.     ]
  166. getproperty = [
  167.     (getpstr, "name"),
  168.     (getostype, "code"),
  169.     (getdata, "what")
  170.     ]
  171. getelement = [
  172.     (getostype, "type"),
  173.     (getlist, "keyform", getostype)
  174.     ]
  175. getclass = [
  176.     (getpstr, "name"),
  177.     (getostype, "class code"),
  178.     (getpstr, "description"),
  179.     (getlist, "properties", getproperty),
  180.     (getlist, "elements", getelement)
  181.     ]
  182. getcomparison = [
  183.     (getpstr, "operator name"),
  184.     (getostype, "operator ID"),
  185.     (getpstr, "operator comment"),
  186.     ]
  187. getenumerator = [
  188.     (getpstr, "enumerator name"),
  189.     (getostype, "enumerator ID"),
  190.     (getpstr, "enumerator comment")
  191.     ]
  192. getenumeration = [
  193.     (getostype, "enumeration ID"),
  194.     (getlist, "enumerator", getenumerator)
  195.     ]
  196. getsuite = [
  197.     (getpstr, "suite name"),
  198.     (getpstr, "suite description"),
  199.     (getostype, "suite ID"),
  200.     (getword, "suite level"),
  201.     (getword, "suite version"),
  202.     (getlist, "events", getevent),
  203.     (getlist, "classes", getclass),
  204.     (getlist, "comparisons", getcomparison),
  205.     (getlist, "enumerations", getenumeration)
  206.     ]
  207. getaete = [
  208.     (getword, "major/minor version in BCD"),
  209.     (getword, "language code"),
  210.     (getword, "script code"),
  211.     (getlist, "suites", getsuite)
  212.     ]
  213.  
  214. def compileaete(aete, fname):
  215.     """Generate code for a full aete resource. fname passed for doc purposes"""
  216.     [version, language, script, suites] = aete
  217.     major, minor = divmod(version, 256)
  218.     for suite in suites:
  219.         compilesuite(suite, major, minor, language, script, fname)
  220.  
  221. def compilesuite(suite, major, minor, language, script, fname):
  222.     """Generate code for a single suite"""
  223.     [name, desc, code, level, version, events, classes, comps, enums] = suite
  224.     
  225.     modname = identify(name)
  226.     fss, ok = macfs.StandardPutFile('Python output file', modname+'.py')
  227.     if not ok:
  228.         return
  229.     fp = open(fss.as_pathname(), 'w')
  230.     fss.SetCreatorType('Pyth', 'TEXT')
  231.     
  232.     fp.write('"""Suite %s: %s\n' % (name, desc))
  233.     fp.write("Level %d, version %d\n\n" % (level, version))
  234.     fp.write("Generated from %s\n"%fname)
  235.     fp.write("AETE/AEUT resource version %d/%d, language %d, script %d\n" % \
  236.         (major, minor, language, script))
  237.     fp.write('"""\n\n')
  238.     
  239.     fp.write('import aetools\n')
  240.     fp.write('import MacOS\n\n')
  241.     fp.write("_code = %s\n\n"% `code`)
  242.     
  243.     compileclassheader(fp, modname)
  244.  
  245.     enumsneeded = {}
  246.     if events:
  247.         for event in events:
  248.             compileevent(fp, event, enumsneeded)
  249.     else:
  250.         fp.write("\tpass\n\n")
  251.  
  252.     objc = ObjectCompiler(fp)
  253.     for cls in classes:
  254.         objc.compileclass(cls)
  255.     for cls in classes:
  256.         objc.fillclasspropsandelems(cls)
  257.     for comp in comps:
  258.         objc.compilecomparison(comp)
  259.     for enum in enums:
  260.         objc.compileenumeration(enum)
  261.     
  262.     for enum in enumsneeded.keys():
  263.         objc.checkforenum(enum)
  264.         
  265.     objc.dumpindex()
  266.  
  267. def compileclassheader(fp, name):
  268.     """Generate class boilerplate"""
  269.     fp.write("class %s:\n\n"%name)
  270.     
  271. def compileevent(fp, event, enumsneeded):
  272.     """Generate code for a single event"""
  273.     [name, desc, code, subcode, returns, accepts, arguments] = event
  274.     funcname = identify(name)
  275.     #
  276.     # generate name->keyword map
  277.     #
  278.     if arguments:
  279.         fp.write("\t_argmap_%s = {\n"%funcname)
  280.         for a in arguments:
  281.             fp.write("\t\t%s : %s,\n"%(`identify(a[0])`, `a[1]`))
  282.         fp.write("\t}\n\n")
  283.         
  284.     #
  285.     # Generate function header
  286.     #
  287.     has_arg = (not is_null(accepts))
  288.     opt_arg = (has_arg and is_optional(accepts))
  289.     
  290.     fp.write("\tdef %s(self, "%funcname)
  291.     if has_arg:
  292.         if not opt_arg:
  293.             fp.write("_object, ")        # Include direct object, if it has one
  294.         else:
  295.             fp.write("_object=None, ")    # Also include if it is optional
  296.     else:
  297.         fp.write("_no_object=None, ")    # For argument checking
  298.     fp.write("_attributes={}, **_arguments):\n")    # include attribute dict and args
  299.     #
  300.     # Generate doc string (important, since it may be the only
  301.     # available documentation, due to our name-remaping)
  302.     #
  303.     fp.write('\t\t"""%s: %s\n'%(name, desc))
  304.     if has_arg:
  305.         fp.write("\t\tRequired argument: %s\n"%getdatadoc(accepts))
  306.     elif opt_arg:
  307.         fp.write("\t\tOptional argument: %s\n"%getdatadoc(accepts))
  308.     for arg in arguments:
  309.         fp.write("\t\tKeyword argument %s: %s\n"%(identify(arg[0]),
  310.                 getdatadoc(arg[2])))
  311.     fp.write("\t\tKeyword argument _attributes: AppleEvent attribute dictionary\n")
  312.     if not is_null(returns):
  313.         fp.write("\t\tReturns: %s\n"%getdatadoc(returns))
  314.     fp.write('\t\t"""\n')
  315.     #
  316.     # Fiddle the args so everything ends up in 'arguments' dictionary
  317.     #
  318.     fp.write("\t\t_code = %s\n"% `code`)
  319.     fp.write("\t\t_subcode = %s\n\n"% `subcode`)
  320.     #
  321.     # Do keyword name substitution
  322.     #
  323.     if arguments:
  324.         fp.write("\t\taetools.keysubst(_arguments, self._argmap_%s)\n"%funcname)
  325.     else:
  326.         fp.write("\t\tif _arguments: raise TypeError, 'No optional args expected'\n")
  327.     #
  328.     # Stuff required arg (if there is one) into arguments
  329.     #
  330.     if has_arg:
  331.         fp.write("\t\t_arguments['----'] = _object\n")
  332.     elif opt_arg:
  333.         fp.write("\t\tif _object:\n")
  334.         fp.write("\t\t\t_arguments['----'] = _object\n")
  335.     else:
  336.         fp.write("\t\tif _no_object != None: raise TypeError, 'No direct arg expected'\n")
  337.     fp.write("\n")
  338.     #
  339.     # Do enum-name substitution
  340.     #
  341.     for a in arguments:
  342.         if is_enum(a[2]):
  343.             kname = a[1]
  344.             ename = a[2][0]
  345.             if ename <> '****':
  346.                 fp.write("\t\taetools.enumsubst(_arguments, %s, _Enum_%s)\n" %
  347.                     (`kname`, ename))
  348.                 enumsneeded[ename] = 1
  349.     fp.write("\n")
  350.     #
  351.     # Do the transaction
  352.     #
  353.     fp.write("\t\t_reply, _arguments, _attributes = self.send(_code, _subcode,\n")
  354.     fp.write("\t\t\t\t_arguments, _attributes)\n")
  355.     #
  356.     # Error handling
  357.     #
  358.     fp.write("\t\tif _arguments.has_key('errn'):\n")
  359.     fp.write("\t\t\traise aetools.Error, aetools.decodeerror(_arguments)\n")
  360.     fp.write("\t\t# XXXX Optionally decode result\n")
  361.     #
  362.     # Decode result
  363.     #
  364.     fp.write("\t\tif _arguments.has_key('----'):\n")
  365.     if is_enum(returns):
  366.         fp.write("\t\t\t# XXXX Should do enum remapping here...\n")
  367.     fp.write("\t\t\treturn _arguments['----']\n")
  368.     fp.write("\n")
  369.     
  370. #    print "\n#    Command %s -- %s (%s, %s)" % (`name`, `desc`, `code`, `subcode`)
  371. #    print "#        returns", compiledata(returns)
  372. #    print "#        accepts", compiledata(accepts)
  373. #    for arg in arguments:
  374. #        compileargument(arg)
  375.  
  376. def compileargument(arg):
  377.     [name, keyword, what] = arg
  378.     print "#        %s (%s)" % (name, `keyword`), compiledata(what)
  379.  
  380. class ObjectCompiler:
  381.     def __init__(self, fp):
  382.         self.fp = fp
  383.         self.propnames = {}
  384.         self.classnames = {}
  385.         self.propcodes = {}
  386.         self.classcodes = {}
  387.         self.compcodes = {}
  388.         self.enumcodes = {}
  389.         self.othersuites = []
  390.         
  391.     def findcodename(self, type, code):
  392.         while 1:
  393.             if type == 'property':
  394.                 if self.propcodes.has_key(code):
  395.                     return self.propcodes[code], self.propcodes[code], None
  396.                 for s in self.othersuites:
  397.                     if s._propdeclarations.has_key(code):
  398.                         name = s._propdeclarations[code].__name__
  399.                         return name, '%s.%s' % (s.__name__, name), s.__name__
  400.             if type == 'class':
  401.                 if self.classcodes.has_key(code):
  402.                     return self.classcodes[code], self.classcodes[code], None
  403.                 for s in self.othersuites:
  404.                     if s._classdeclarations.has_key(code):
  405.                         name = s._classdeclarations[code].__name__
  406.                         return name, '%s.%s' % (s.__name__, name), s.__name__
  407.             if type == 'enum':
  408.                 if self.enumcodes.has_key(code):
  409.                     return self.enumcodes[code], self.enumcodes[code], None
  410.                 for s in self.othersuites:
  411.                     if s._enumdeclarations.has_key(code):
  412.                         name = '_Enum_' + identify(code)
  413.                         return name, '%s.%s' % (s.__name__, name), s.__name__
  414.             if type == 'comparison':
  415.                 if self.compcodes.has_key(code):
  416.                     return self.compcodes[code], self.compcodes[code], None
  417.                 for s in self.othersuites:
  418.                     if s._compdeclarations.has_key(code):
  419.                         name = s._compdeclarations[code].__name__
  420.                         return name, '%s.%s' % (s.__name__, name), s.__name__
  421.                         
  422.             m = self.askdefinitionmodule(type, code)
  423.             if not m: return None, None, None
  424.             self.othersuites.append(m)
  425.     
  426.     def askdefinitionmodule(self, type, code):
  427.         fss, ok = macfs.PromptGetFile('Where is %s %s declared?'%(type, code))
  428.         if not ok: return
  429.         path, file = os.path.split(fss.as_pathname())
  430.         modname = os.path.splitext(file)[0]
  431.         if not path in sys.path:
  432.             sys.path.insert(0, path)
  433.         m = __import__(modname)
  434.         self.fp.write("import %s\n"%modname)
  435.         return m
  436.         
  437.     def compileclass(self, cls):
  438.         [name, code, desc, properties, elements] = cls
  439.         pname = identify(name)
  440.         if self.classcodes.has_key(code):
  441.             # plural forms and such
  442.             self.fp.write("\n%s = %s\n"%(pname, self.classcodes[code]))
  443.             self.classnames[pname] = code
  444.         else:
  445.             self.fp.write('\nclass %s(aetools.ComponentItem):\n' % pname)
  446.             self.fp.write('\t"""%s - %s"""\n' % (name, desc))
  447.             self.fp.write('\twant = %s\n' % `code`)
  448.             self.classnames[pname] = code
  449.             self.classcodes[code] = pname
  450.         for prop in properties:
  451.             self.compileproperty(prop)
  452.         for elem in elements:
  453.             self.compileelement(elem)
  454.     
  455.     def compileproperty(self, prop):
  456.         [name, code, what] = prop
  457.         if code == 'c@#!':
  458.             # Something silly with plurals. Skip it.
  459.             return
  460.         pname = identify(name)
  461.         if self.propcodes.has_key(code):
  462.             self.fp.write("# repeated property %s %s\n"%(pname, what[1]))
  463.         else:
  464.             self.fp.write("class %s(aetools.NProperty):\n" % pname)
  465.             self.fp.write('\t"""%s - %s"""\n' % (name, what[1]))
  466.             self.fp.write("\twhich = %s\n" % `code`)
  467.             self.fp.write("\twant = %s\n" % `what[0]`)
  468.             self.propnames[pname] = code
  469.             self.propcodes[code] = pname
  470.     
  471.     def compileelement(self, elem):
  472.         [code, keyform] = elem
  473.         self.fp.write("#        element %s as %s\n" % (`code`, keyform))
  474.  
  475.     def fillclasspropsandelems(self, cls):
  476.         [name, code, desc, properties, elements] = cls
  477.         cname = identify(name)
  478.         if self.classcodes[code] != cname:
  479.             # This is an other name (plural or so) for something else. Skip.
  480.             return
  481.         plist = []
  482.         elist = []
  483.         for prop in properties:
  484.             [pname, pcode, what] = prop
  485.             if pcode == 'c@#!':
  486.                 continue
  487.             pname = identify(pname)
  488.             plist.append(pname)
  489.         for elem in elements:
  490.             [ecode, keyform] = elem
  491.             if ecode == 'c@#!':
  492.                 continue
  493.             name, ename, module = self.findcodename('class', ecode)
  494.             if not name:
  495.                 self.fp.write("# XXXX %s element %s not found!!\n"%(cname, `ecode`))
  496.             else:
  497.                 elist.append(name, ename)
  498.             
  499.         self.fp.write("%s._propdict = {\n"%cname)
  500.         for n in plist:
  501.             self.fp.write("\t'%s' : %s,\n"%(n, n))
  502.         self.fp.write("}\n")
  503.         self.fp.write("%s._elemdict = {\n"%cname)
  504.         for n, fulln in elist:
  505.             self.fp.write("\t'%s' : %s,\n"%(n, fulln))
  506.         self.fp.write("}\n")
  507.     
  508.     def compilecomparison(self, comp):
  509.         [name, code, comment] = comp
  510.         iname = identify(name)
  511.         self.compcodes[code] = iname
  512.         self.fp.write("class %s(aetools.NComparison):\n" % iname)
  513.         self.fp.write('\t"""%s - %s"""\n' % (name, comment))
  514.         
  515.     def compileenumeration(self, enum):
  516.         [code, items] = enum
  517.         name = "_Enum_%s" % identify(code)
  518.         self.fp.write("%s = {\n" % name)
  519.         for item in items:
  520.             self.compileenumerator(item)
  521.         self.fp.write("}\n\n")
  522.         self.enumcodes[code] = name
  523.         return code
  524.     
  525.     def compileenumerator(self, item):
  526.         [name, code, desc] = item
  527.         self.fp.write("\t%s : %s,\t# %s\n" % (`identify(name)`, `code`, desc))
  528.         
  529.     def checkforenum(self, enum):
  530.         """This enum code is used by an event. Make sure it's available"""
  531.         name, fullname, module = self.findcodename('enum', enum)
  532.         if not name:
  533.             self.fp.write("# XXXX enum %s not found!!\n"%(enum))
  534.             return
  535.         if module:
  536.             self.fp.write("from %s import %s\n"%(module, name))
  537.         
  538.     def dumpindex(self):
  539.         self.fp.write("\n#\n# Indices of types declared in this module\n#\n")
  540.         self.fp.write("_classdeclarations = {\n")
  541.         for k in self.classcodes.keys():
  542.             self.fp.write("\t%s : %s,\n" % (`k`, self.classcodes[k]))
  543.         self.fp.write("}\n")
  544.         self.fp.write("\n_propdeclarations = {\n")
  545.         for k in self.propcodes.keys():
  546.             self.fp.write("\t%s : %s,\n" % (`k`, self.propcodes[k]))
  547.         self.fp.write("}\n")
  548.         self.fp.write("\n_compdeclarations = {\n")
  549.         for k in self.compcodes.keys():
  550.             self.fp.write("\t%s : %s,\n" % (`k`, self.compcodes[k]))
  551.         self.fp.write("}\n")
  552.         self.fp.write("\n_enumdeclarations = {\n")
  553.         for k in self.enumcodes.keys():
  554.             self.fp.write("\t%s : %s,\n" % (`k`, self.enumcodes[k]))
  555.         self.fp.write("}\n")
  556.  
  557. def compiledata(data):
  558.     [type, description, flags] = data
  559.     return "%s -- %s %s" % (`type`, `description`, compiledataflags(flags))
  560.     
  561. def is_null(data):
  562.     return data[0] == 'null'
  563.     
  564. def is_optional(data):
  565.     return (data[2] & 0x8000)
  566.     
  567. def is_enum(data):
  568.     return (data[2] & 0x2000)
  569.     
  570. def getdatadoc(data):
  571.     [type, descr, flags] = data
  572.     if descr:
  573.         return descr
  574.     if type == '****':
  575.         return 'anything'
  576.     if type == 'obj ':
  577.         return 'an AE object reference'
  578.     return "undocumented, typecode %s"%`type`
  579.  
  580. dataflagdict = {15: "optional", 14: "list", 13: "enum", 12: "mutable"}
  581. def compiledataflags(flags):
  582.     bits = []
  583.     for i in range(16):
  584.         if flags & (1<<i):
  585.             if i in dataflagdict.keys():
  586.                 bits.append(dataflagdict[i])
  587.             else:
  588.                 bits.append(`i`)
  589.     return '[%s]' % string.join(bits)
  590.     
  591. # XXXX Do we have a set of python keywords somewhere?
  592. illegal_ids = [ "for", "in", "from", "and", "or", "not", "print", "class", "return",
  593.     "def" ]
  594.  
  595. def identify(str):
  596.     """Turn any string into an identifier:
  597.     - replace space by _
  598.     - replace other illegal chars by _xx_ (hex code)
  599.     - prepend _ if the result is a python keyword
  600.     """
  601.     if not str:
  602.         return "_empty_ae_name"
  603.     rv = ''
  604.     ok = string.letters  + '_'
  605.     ok2 = ok + string.digits
  606.     for c in str:
  607.         if c in ok:
  608.             rv = rv + c
  609.         elif c == ' ':
  610.             rv = rv + '_'
  611.         else:
  612.             rv = rv + '_%02.2x_'%ord(c)
  613.         ok = ok2
  614.     if rv in illegal_ids:
  615.         rv = '_' + rv
  616.     return rv
  617.  
  618. # Call the main program
  619.  
  620. if __name__ == '__main__':
  621.     main()
  622.     sys.exit(1)
  623.