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