path: root/Mac/Unsupported/PythonScript/printaete.py

"""
Produces a human readable file of an application's aete

v.02 january 29, 1998 bug fix Main()
v.03 january 31, 1998 added support for inheriting suites from aeut
v.04 april 16, 1998 Changed identify to match getaete
"""

import aetools
import sys
import MacOS
import StringIO
import types
import macfs
import string
import macpath
from Carbon.Res import *

# for testing only
app = 'MACS'#CSOm'#'nwSP'#'ezVu'#

#Dialect file hard coded as a tempoary measure
DIALECT = 'Hermit:System Folder:Scripting Additions:Dialects:English Dialect'

#Restrict the application suites to the dialect we want to use.
LANG = 0 # 0 = English, 1 = French, 11 = Japanese

#The following are neaded to open the application aete
kASAppleScriptSuite	= 'ascr'
kGetAETE			= 'gdte'
attributes = {}
arguments = {}

class AETE(aetools.TalkTo):
	pass
	
def Main(appl):
	fss, ok = macfs.PromptGetFile('Application to work on', 'FNDR', 'APPL')#
	if not ok:
		return
	app = fss.GetCreatorType()[0]
	path = macpath.split(sys.argv[0])[0]
	appname =  macpath.split(fss.as_pathname())[1]
	appname = appname + '.aete'
	appname = macpath.join(path, appname)
	try:
		data = Getaete(app)
	except MacOS.Error, msg:
		if msg[0] == -609:
			_launch(app)
			data = Getaete(app)
#	print data
	data = decode(data['----'].data)
	data = compileaete(data, appname)
	
	
def decode(data):
	"""Decode an aete into a python data structure"""
	f = StringIO.StringIO(data)
	aete = generic(getaete, f)
	aete = simplify(aete)
	return aete

def simplify(item):
	"""Recursively replace singleton tuples by their constituent item"""
	if type(item) is types.ListType:
		return map(simplify, item)
	elif type(item) == types.TupleType and len(item) == 2:
		return simplify(item[1])
	else:
		return item


## Here follows the aete resource decoder.
## It is presented bottom-up instead of top-down because there are  direct
## references to the lower-level part-decoders from the high-level part-decoders.
#
def getbyte(f, *args):
	c = f.read(1)
	if not c:
		raise EOFError, 'in getbyte' + str(args)
	return ord(c)

def getword(f, *args):
	getalign(f)
	s = f.read(2)
	if len(s) < 2:
		raise EOFError, 'in getword' + str(args)
	return (ord(s[0])<<8) | ord(s[1])

def getlong(f, *args):
	getalign(f)
	s = f.read(4)
	if len(s) < 4:
		raise EOFError, 'in getlong' + str(args)
	return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])

def getostype(f, *args):
	getalign(f)
	s = f.read(4)
	if len(s) < 4:
		raise EOFError, 'in getostype' + str(args)
	return s

def getpstr(f, *args):
	c = f.read(1)
	if len(c) < 1:
		raise EOFError, 'in getpstr[1]' + str(args)
	nbytes = ord(c)
	if nbytes == 0: return ''
	s = f.read(nbytes)
	if len(s) < nbytes:
		raise EOFError, 'in getpstr[2]' + str(args)
	return s

def getalign(f):
	if f.tell() & 1:
		c = f.read(1)
		##if c <> '\0':
		##	print 'align:', `c`

def getlist(f, description, getitem):
	count = getword(f)
	list = []
	for i in range(count):
		list.append(generic(getitem, f))
		getalign(f)
	return list

def alt_generic(what, f, *args):
	print "generic", `what`, args
	res = vageneric(what, f, args)
	print '->', `res`
	return res

def generic(what, f, *args):
	if type(what) == types.FunctionType:
		return apply(what, (f,) + args)
	if type(what) == types.ListType:
		record = []
		for thing in what:
#			print thing
			item = apply(generic, thing[:1] + (f,) + thing[1:])
			record.append((thing[1], item))
		return record
	return "BAD GENERIC ARGS: %s" % `what`

getdata = [
	(getostype, "type"),
	(getpstr, "description"),
	(getword, "flags")
	]
getargument = [
	(getpstr, "name"),
	(getostype, "keyword"),
	(getdata, "what")
	]
getevent = [
	(getpstr, "name"),
	(getpstr, "description"),
	(getostype, "suite code"),
	(getostype, "event code"),
	(getdata, "returns"),
	(getdata, "accepts"),
	(getlist, "optional arguments", getargument)
	]
getproperty = [
	(getpstr, "name"),
	(getostype, "code"),
	(getdata, "what")
	]
getelement = [
	(getostype, "type"),
	(getlist, "keyform", getostype)
	]
getclass = [
	(getpstr, "name"),
	(getostype, "class code"),
	(getpstr, "description"),
	(getlist, "properties", getproperty),
	(getlist, "elements", getelement)
	]
getcomparison = [
	(getpstr, "operator name"),
	(getostype, "operator ID"),
	(getpstr, "operator comment"),
	]
getenumerator = [
	(getpstr, "enumerator name"),
	(getostype, "enumerator ID"),
	(getpstr, "enumerator comment")
	]
getenumeration = [
	(getostype, "enumeration ID"),
	(getlist, "enumerator", getenumerator)
	]
getsuite = [
	(getpstr, "suite name"),
	(getpstr, "suite description"),
	(getostype, "suite ID"),
	(getword, "suite level"),
	(getword, "suite version"),
	(getlist, "events", getevent),
	(getlist, "classes", getclass),
	(getlist, "comparisons", getcomparison),
	(getlist, "enumerations", getenumeration)
	]
getaete = [
	(getword, "major/minor version in BCD"),
	(getword, "language code"),
	(getword, "script code"),
	(getlist, "suites", getsuite)
	]

def compileaete(aete, appname):
	"""Generate dictionary file for a full aete resource."""
	[version, language, script, suites] = aete
	major, minor = divmod(version, 256)
	fp = open(appname, 'w')
	
	fp.write('%s:\n' % (appname))
	fp.write("AETE resource version %d/%d, language %d, script %d\n" % \
		(major, minor, language, script))
	fp.write('\n\n')
	gsuites = openaeut()
	for suite in suites:
		if language == LANG:
			suitecode = suite[2]
			if suite[5] == []:
				for gsuite in gsuites:
					if suitecode == gsuite[2]:
						suite = gsuite
			[name, desc, code, level, version, events, classes, comps, enums] = suite
			fp.write('\n%s Suite: %s\n' % (name, desc))
			fp.write('\n\tEvents:\n')
			for event in events:
				fp.write('\n\t%s: %s\n' % (identify(event[0]), event[1]))
				fp.write('\t\t%s: %s -- %s\n' % (identify(event[0]), event[5][1], event[5][0]))
				fp.write('\t\tResult: %s -- %s\n' % (event[4][1], event[4][0]))
				for ev in event[6]:
					fp.write('\t\t\t%s: %s -- %s\n' % (identify(ev[0]), ev[2][0], ev[2][1]))
			fp.write('\n\tClasses')
			for klass in classes:
				fp.write('\n\t%s: %s\n' % (identify(klass[0]), klass[2]))
				if klass[3]:
					if not klass[3][0][0]: continue
					fp.write('\t\tProperties\n')
					for cl in klass[3]:
						fp.write('\t\t\t%s: %s -- %s\n' % (identify(cl[0]), cl[2][1], cl[2][0]))#,, cl[3][3][1]))
				if klass[4]:
					fp.write('\n\t\t\tElements\n')
					for cl in klass[4]:
						fp.write('\t\t\t\t%s: %s\n' % (identify(cl[0]), cl[1]))
						
				
					
		
	

illegal_ids = [ "for", "in", "from", "and", "or", "not", "print", "class", "return",
	"def", "name" ]

def identify(str):
	"""Turn any string into an identifier:
	- replace space by _
	- prepend _ if the result is a python keyword
	"""

	rv = string.replace(str, ' ', '_')
	rv = string.replace(rv, '-', '')
	rv = string.replace(rv, ',', '')
	rv = string.capitalize(rv)
	return rv


def Getaete(app):
	'''Read the target aete'''
	arguments['----'] = LANG
	_aete = AETE(app)
	_reply, _arguments, _attributes = _aete.send('ascr', 'gdte', arguments, attributes)
	if _arguments.has_key('errn'):
		raise aetools.Error, aetools.decodeerror(_arguments)
	return  _arguments

def openaeut():
	"""Open and read a aeut file.
	XXXXX This has been temporarily hard coded until a Python aeut is written XXXX"""

	fullname = DIALECT
	
	rf = OpenRFPerm(fullname, 0, 1)
	try:
		UseResFile(rf)
		resources = []
		for i in range(Count1Resources('aeut')):
			res = Get1IndResource('aeut', 1+i)
			resources.append(res)
		for res in resources:
			data = res.data
			data = decode(data)[3]
	finally:
		CloseResFile(rf)
	return data


#The following should be replaced by direct access to a python 'aeut'

class _miniFinder(aetools.TalkTo):
	def open(self, _object, _attributes={}, **_arguments):
		"""open: Open the specified object(s)
		Required argument: list of objects to open
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'aevt'
		_subcode = 'odoc'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.has_key('errn'):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']
	
_finder = _miniFinder('MACS')

def _launch(appfile):
	"""Open a file thru the finder. Specify file by name or fsspec"""
	_finder.open(_application_file(('ID  ', appfile)))


class _application_file(aetools.ComponentItem):
	"""application file - An application's file on disk"""
	want = 'appf'
	
_application_file._propdict = {
}
_application_file._elemdict = {
}

Main(app)
sys.exit(1)