Generate class, property and comparison code (finally!). The resulting
code isn't ideal yet: xxx.Window(1).Paragraph(3).font will only work
if all the classes and properties are declared in the same suite, but
at least font(Paragraph(3, Window(1))) always works.
diff --git a/Mac/scripts/gensuitemodule.py b/Mac/scripts/gensuitemodule.py
index ff818fc..53da22c 100644
--- a/Mac/scripts/gensuitemodule.py
+++ b/Mac/scripts/gensuitemodule.py
@@ -39,7 +39,10 @@
print "decoding", res.GetResInfo(), "..."
data = res.data
aete = decode(data)
+ # switch back (needed for dialogs in Python)
+ UseResFile(cur)
compileaete(aete, fullname)
+ UseResFile(rf)
finally:
if rf <> cur:
CloseResFile(rf)
@@ -237,27 +240,35 @@
fp.write('import MacOS\n\n')
fp.write("_code = %s\n\n"% `code`)
- enum_names = []
- for enum in enums:
- name = compileenumeration(fp, enum)
- enum_names.append(enum)
-
compileclassheader(fp, modname)
+
+ enumsneeded = {}
if events:
for event in events:
- compileevent(fp, event)
+ compileevent(fp, event, enumsneeded)
else:
fp.write("\tpass\n\n")
+
+ objc = ObjectCompiler(fp)
for cls in classes:
- compileclass(fp, cls)
+ objc.compileclass(cls)
+ for cls in classes:
+ objc.fillclasspropsandelems(cls)
for comp in comps:
- compilecomparison(fp, comp)
+ objc.compilecomparison(comp)
+ for enum in enums:
+ objc.compileenumeration(enum)
+
+ for enum in enumsneeded.keys():
+ objc.checkforenum(enum)
+
+ objc.dumpindex()
def compileclassheader(fp, name):
"""Generate class boilerplate"""
fp.write("class %s:\n\n"%name)
-def compileevent(fp, event):
+def compileevent(fp, event, enumsneeded):
"""Generate code for a single event"""
[name, desc, code, subcode, returns, accepts, arguments] = event
funcname = identify(name)
@@ -334,6 +345,7 @@
if ename <> '****':
fp.write("\t\taetools.enumsubst(_arguments, %s, _Enum_%s)\n" %
(`kname`, ename))
+ enumsneeded[ename] = 1
fp.write("\n")
#
# Do the transaction
@@ -365,37 +377,182 @@
[name, keyword, what] = arg
print "# %s (%s)" % (name, `keyword`), compiledata(what)
-def compileclass(fp, cls):
- [name, code, desc, properties, elements] = cls
- fp.write("\n# Class %s (%s) -- %s\n" % (`name`, `code`, `desc`))
- for prop in properties:
- compileproperty(fp, prop)
- for elem in elements:
- compileelement(fp, elem)
+class ObjectCompiler:
+ def __init__(self, fp):
+ self.fp = fp
+ self.propnames = {}
+ self.classnames = {}
+ self.propcodes = {}
+ self.classcodes = {}
+ self.compcodes = {}
+ self.enumcodes = {}
+ self.othersuites = []
+
+ def findcodename(self, type, code):
+ while 1:
+ if type == 'property':
+ if self.propcodes.has_key(code):
+ return self.propcodes[code], self.propcodes[code], None
+ for s in self.othersuites:
+ if s._propdeclarations.has_key(code):
+ name = s._propdeclarations[code].__name__
+ return name, '%s.%s' % (s.__name__, name), s.__name__
+ if type == 'class':
+ if self.classcodes.has_key(code):
+ return self.classcodes[code], self.classcodes[code], None
+ for s in self.othersuites:
+ if s._classdeclarations.has_key(code):
+ name = s._classdeclarations[code].__name__
+ return name, '%s.%s' % (s.__name__, name), s.__name__
+ if type == 'enum':
+ if self.enumcodes.has_key(code):
+ return self.enumcodes[code], self.enumcodes[code], None
+ for s in self.othersuites:
+ if s._enumdeclarations.has_key(code):
+ name = '_Enum_' + identify(code)
+ return name, '%s.%s' % (s.__name__, name), s.__name__
+ if type == 'comparison':
+ if self.compcodes.has_key(code):
+ return self.compcodes[code], self.compcodes[code], None
+ for s in self.othersuites:
+ if s._compdeclarations.has_key(code):
+ name = s._compdeclarations[code].__name__
+ return name, '%s.%s' % (s.__name__, name), s.__name__
+
+ m = self.askdefinitionmodule(type, code)
+ if not m: return None, None, None
+ self.othersuites.append(m)
+
+ def askdefinitionmodule(self, type, code):
+ fss, ok = macfs.PromptGetFile('Where is %s %s declared?'%(type, code))
+ if not ok: return
+ path, file = os.path.split(fss.as_pathname())
+ 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.classcodes.has_key(code):
+ # plural forms and such
+ self.fp.write("\n%s = %s\n"%(pname, self.classcodes[code]))
+ self.classnames[pname] = code
+ else:
+ self.fp.write('\nclass %s(aetools.ComponentItem):\n' % pname)
+ self.fp.write('\t"""%s - %s"""\n' % (name, desc))
+ self.fp.write('\twant = %s\n' % `code`)
+ self.classnames[pname] = code
+ self.classcodes[code] = pname
+ for prop in properties:
+ self.compileproperty(prop)
+ 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.propcodes.has_key(code):
+ self.fp.write("# repeated property %s %s\n"%(pname, what[1]))
+ else:
+ self.fp.write("class %s(aetools.NProperty):\n" % pname)
+ self.fp.write('\t"""%s - %s"""\n' % (name, what[1]))
+ self.fp.write("\twhich = %s\n" % `code`)
+ self.fp.write("\twant = %s\n" % `what[0]`)
+ self.propnames[pname] = code
+ self.propcodes[code] = pname
+
+ def compileelement(self, elem):
+ [code, keyform] = elem
+ self.fp.write("# element %s as %s\n" % (`code`, keyform))
-def compileproperty(fp, prop):
- [name, code, what] = prop
- fp.write("# property %s (%s) %s\n" % (`name`, `code`, compiledata(what)))
-
-def compileelement(fp, elem):
- [code, keyform] = elem
- fp.write("# element %s as %s\n" % (`code`, keyform))
-
-def compilecomparison(fp, comp):
- [name, code, comment] = comp
- fp.write("# comparison %s (%s) -- %s\n" % (`name`, `code`, comment))
-
-def compileenumeration(fp, enum):
- [code, items] = enum
- fp.write("_Enum_%s = {\n" % identify(code))
- for item in items:
- compileenumerator(fp, item)
- fp.write("}\n\n")
- return code
-
-def compileenumerator(fp, item):
- [name, code, desc] = item
- fp.write("\t%s : %s,\t# %s\n" % (`identify(name)`, `code`, desc))
+ def fillclasspropsandelems(self, cls):
+ [name, code, desc, properties, elements] = cls
+ cname = identify(name)
+ if self.classcodes[code] != cname:
+ # This is an other name (plural or so) for something else. Skip.
+ return
+ plist = []
+ elist = []
+ for prop in properties:
+ [pname, pcode, what] = prop
+ if pcode == 'c@#!':
+ continue
+ pname = identify(pname)
+ plist.append(pname)
+ for elem in elements:
+ [ecode, keyform] = elem
+ if ecode == 'c@#!':
+ continue
+ name, ename, module = self.findcodename('class', ecode)
+ if not name:
+ self.fp.write("# XXXX %s element %s not found!!\n"%(cname, `ecode`))
+ else:
+ elist.append(name, ename)
+
+ self.fp.write("%s._propdict = {\n"%cname)
+ for n in plist:
+ self.fp.write("\t'%s' : %s,\n"%(n, n))
+ self.fp.write("}\n")
+ self.fp.write("%s._elemdict = {\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.compcodes[code] = iname
+ self.fp.write("class %s(aetools.NComparison):\n" % iname)
+ self.fp.write('\t"""%s - %s"""\n' % (name, comment))
+
+ def compileenumeration(self, enum):
+ [code, items] = enum
+ name = "_Enum_%s" % identify(code)
+ self.fp.write("%s = {\n" % name)
+ for item in items:
+ self.compileenumerator(item)
+ self.fp.write("}\n\n")
+ self.enumcodes[code] = name
+ return code
+
+ def compileenumerator(self, item):
+ [name, code, desc] = item
+ self.fp.write("\t%s : %s,\t# %s\n" % (`identify(name)`, `code`, 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:
+ self.fp.write("# XXXX enum %s not found!!\n"%(enum))
+ return
+ if module:
+ self.fp.write("from %s import %s\n"%(module, name))
+
+ def dumpindex(self):
+ self.fp.write("\n#\n# Indices of types declared in this module\n#\n")
+ self.fp.write("_classdeclarations = {\n")
+ for k in self.classcodes.keys():
+ self.fp.write("\t%s : %s,\n" % (`k`, self.classcodes[k]))
+ self.fp.write("}\n")
+ self.fp.write("\n_propdeclarations = {\n")
+ for k in self.propcodes.keys():
+ self.fp.write("\t%s : %s,\n" % (`k`, self.propcodes[k]))
+ self.fp.write("}\n")
+ self.fp.write("\n_compdeclarations = {\n")
+ for k in self.compcodes.keys():
+ self.fp.write("\t%s : %s,\n" % (`k`, self.compcodes[k]))
+ self.fp.write("}\n")
+ self.fp.write("\n_enumdeclarations = {\n")
+ for k in self.enumcodes.keys():
+ self.fp.write("\t%s : %s,\n" % (`k`, self.enumcodes[k]))
+ self.fp.write("}\n")
def compiledata(data):
[type, description, flags] = data
@@ -432,7 +589,8 @@
return '[%s]' % string.join(bits)
# XXXX Do we have a set of python keywords somewhere?
-illegal_ids = [ "for", "in", "from", "and", "or", "not", "print" ]
+illegal_ids = [ "for", "in", "from", "and", "or", "not", "print", "class", "return",
+ "def" ]
def identify(str):
"""Turn any string into an identifier:
@@ -440,6 +598,8 @@
- 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.letters + '_'
ok2 = ok + string.digits