python/src/Lib/plat-irix6/flp.py - toolchain/benchmark - Git at Google

 #
 # flp - Module to load fl forms from fd files
 #
 # Jack Jansen, December 1991
 #
 from warnings import warnpy3k
 warnpy3k("the flp module has been removed in Python 3.0", stacklevel=2)
 del warnpy3k

 import os
 import sys
 import FL

 SPLITLINE = '--------------------'
 FORMLINE = '=============== FORM ==============='
 ENDLINE = '=============================='

 class error(Exception):
     pass

 ##################################################################
 #    Part 1 - The parsing routines                               #
 ##################################################################

 #
 # Externally visible function. Load form.
 #
 def parse_form(filename, formname):
     forms = checkcache(filename)
     if forms is None:
         forms = parse_forms(filename)
     if forms.has_key(formname):
         return forms[formname]
     else:
         raise error, 'No such form in fd file'

 #
 # Externally visible function. Load all forms.
 #
 def parse_forms(filename):
     forms = checkcache(filename)
     if forms is not None: return forms
     fp = _open_formfile(filename)
     nforms = _parse_fd_header(fp)
     forms = {}
     for i in range(nforms):
         form = _parse_fd_form(fp, None)
         forms[form[0].Name] = form
     writecache(filename, forms)
     return forms

 #
 # Internal: see if a cached version of the file exists
 #
 MAGIC = '.fdc'
 _internal_cache = {}                    # Used by frozen scripts only
 def checkcache(filename):
     if _internal_cache.has_key(filename):
         altforms = _internal_cache[filename]
         return _unpack_cache(altforms)
     import marshal
     fp, filename = _open_formfile2(filename)
     fp.close()
     cachename = filename + 'c'
     try:
         fp = open(cachename, 'r')
     except IOError:
         #print 'flp: no cache file', cachename
         return None
     try:
         if fp.read(4) != MAGIC:
             print 'flp: bad magic word in cache file', cachename
             return None
         cache_mtime = rdlong(fp)
         file_mtime = getmtime(filename)
         if cache_mtime != file_mtime:
             #print 'flp: outdated cache file', cachename
             return None
         #print 'flp: valid cache file', cachename
         altforms = marshal.load(fp)
         return _unpack_cache(altforms)
     finally:
         fp.close()

 def _unpack_cache(altforms):
     forms = {}
     for name in altforms.keys():
         altobj, altlist = altforms[name]
         obj = _newobj()
         obj.make(altobj)
         list = []
         for altobj in altlist:
             nobj = _newobj()
             nobj.make(altobj)
             list.append(nobj)
         forms[name] = obj, list
     return forms

 def rdlong(fp):
     s = fp.read(4)
     if len(s) != 4: return None
     a, b, c, d = s[0], s[1], s[2], s[3]
     return ord(a)<<24 | ord(b)<<16 | ord(c)<<8 | ord(d)

 def wrlong(fp, x):
     a, b, c, d = (x>>24)&0xff, (x>>16)&0xff, (x>>8)&0xff, x&0xff
     fp.write(chr(a) + chr(b) + chr(c) + chr(d))

 def getmtime(filename):
     import os
     from stat import ST_MTIME
     try:
         return os.stat(filename)[ST_MTIME]
     except os.error:
         return None

 #
 # Internal: write cached version of the form (parsing is too slow!)
 #
 def writecache(filename, forms):
     import marshal
     fp, filename = _open_formfile2(filename)
     fp.close()
     cachename = filename + 'c'
     try:
         fp = open(cachename, 'w')
     except IOError:
         print 'flp: can\'t create cache file', cachename
         return # Never mind
     fp.write('\0\0\0\0') # Seek back and write MAGIC when done
     wrlong(fp, getmtime(filename))
     altforms = _pack_cache(forms)
     marshal.dump(altforms, fp)
     fp.seek(0)
     fp.write(MAGIC)
     fp.close()
     #print 'flp: wrote cache file', cachename

 #
 # External: print some statements that set up the internal cache.
 # This is for use with the "freeze" script.  You should call
 # flp.freeze(filename) for all forms used by the script, and collect
 # the output on a file in a module file named "frozenforms.py".  Then
 # in the main program of the script import frozenforms.
 # (Don't forget to take this out when using the unfrozen version of
 # the script!)
 #
 def freeze(filename):
     forms = parse_forms(filename)
     altforms = _pack_cache(forms)
     print 'import flp'
     print 'flp._internal_cache[', repr(filename), '] =', altforms

 #
 # Internal: create the data structure to be placed in the cache
 #
 def _pack_cache(forms):
     altforms = {}
     for name in forms.keys():
         obj, list = forms[name]
         altobj = obj.__dict__
         altlist = []
         for obj in list: altlist.append(obj.__dict__)
         altforms[name] = altobj, altlist
     return altforms

 #
 # Internal: Locate form file (using PYTHONPATH) and open file
 #
 def _open_formfile(filename):
     return _open_formfile2(filename)[0]

 def _open_formfile2(filename):
     if filename[-3:] != '.fd':
         filename = filename + '.fd'
     if filename[0] == '/':
         try:
             fp = open(filename,'r')
         except IOError:
             fp = None
     else:
         for pc in sys.path:
             pn = os.path.join(pc, filename)
             try:
                 fp = open(pn, 'r')
                 filename = pn
                 break
             except IOError:
                 fp = None
     if fp is None:
         raise error, 'Cannot find forms file ' + filename
     return fp, filename

 #
 # Internal: parse the fd file header, return number of forms
 #
 def _parse_fd_header(file):
     # First read the magic header line
     datum = _parse_1_line(file)
     if datum != ('Magic', 12321):
         raise error, 'Not a forms definition file'
     # Now skip until we know number of forms
     while 1:
         datum = _parse_1_line(file)
         if type(datum) == type(()) and datum[0] == 'Numberofforms':
             break
     return datum[1]
 #
 # Internal: parse fd form, or skip if name doesn't match.
 # the special value None means 'always parse it'.
 #
 def _parse_fd_form(file, name):
     datum = _parse_1_line(file)
     if datum != FORMLINE:
         raise error, 'Missing === FORM === line'
     form = _parse_object(file)
     if form.Name == name or name is None:
         objs = []
         for j in range(form.Numberofobjects):
             obj = _parse_object(file)
             objs.append(obj)
         return (form, objs)
     else:
         for j in range(form.Numberofobjects):
             _skip_object(file)
     return None

 #
 # Internal class: a convenient place to store object info fields
 #
 class _newobj:
     def add(self, name, value):
         self.__dict__[name] = value
     def make(self, dict):
         for name in dict.keys():
             self.add(name, dict[name])

 #
 # Internal parsing routines.
 #
 def _parse_string(str):
     if '\\' in str:
         s = '\'' + str + '\''
         try:
             return eval(s)
         except:
             pass
     return str

 def _parse_num(str):
     return eval(str)

 def _parse_numlist(str):
     slist = str.split()
     nlist = []
     for i in slist:
         nlist.append(_parse_num(i))
     return nlist

 # This dictionary maps item names to parsing routines.
 # If no routine is given '_parse_num' is default.
 _parse_func = { \
         'Name':         _parse_string, \
         'Box':          _parse_numlist, \
         'Colors':       _parse_numlist, \
         'Label':        _parse_string, \
         'Name':         _parse_string, \
         'Callback':     _parse_string, \
         'Argument':     _parse_string }

 # This function parses a line, and returns either
 # a string or a tuple (name,value)

 import re
 prog = re.compile('^([^:]*): *(.*)')

 def _parse_line(line):
     match = prog.match(line)
     if not match:
         return line
     name, value = match.group(1, 2)
     if name[0] == 'N':
         name = ''.join(name.split())
         name = name.lower()
     name = name.capitalize()
     try:
         pf = _parse_func[name]
     except KeyError:
         pf = _parse_num
     value = pf(value)
     return (name, value)

 def _readline(file):
     line = file.readline()
     if not line:
         raise EOFError
     return line[:-1]

 def _parse_1_line(file):
     line = _readline(file)
     while line == '':
         line = _readline(file)
     return _parse_line(line)

 def _skip_object(file):
     line = ''
     while not line in (SPLITLINE, FORMLINE, ENDLINE):
         pos = file.tell()
         line = _readline(file)
     if line == FORMLINE:
         file.seek(pos)

 def _parse_object(file):
     obj = _newobj()
     while 1:
         pos = file.tell()
         datum = _parse_1_line(file)
         if datum in (SPLITLINE, FORMLINE, ENDLINE):
             if datum == FORMLINE:
                 file.seek(pos)
             return obj
         if type(datum) is not type(()) or len(datum) != 2:
             raise error, 'Parse error, illegal line in object: '+datum
         obj.add(datum[0], datum[1])

 #################################################################
 #   Part 2 - High-level object/form creation routines            #
 #################################################################

 #
 # External - Create a form an link to an instance variable.
 #
 def create_full_form(inst, (fdata, odatalist)):
     form = create_form(fdata)
     exec 'inst.'+fdata.Name+' = form\n'
     for odata in odatalist:
         create_object_instance(inst, form, odata)

 #
 # External - Merge a form into an existing form in an instance
 # variable.
 #
 def merge_full_form(inst, form, (fdata, odatalist)):
     exec 'inst.'+fdata.Name+' = form\n'
     if odatalist[0].Class != FL.BOX:
         raise error, 'merge_full_form() expects FL.BOX as first obj'
     for odata in odatalist[1:]:
         create_object_instance(inst, form, odata)


 #################################################################
 #   Part 3 - Low-level object/form creation routines            #
 #################################################################

 #
 # External Create_form - Create form from parameters
 #
 def create_form(fdata):
     import fl
     return fl.make_form(FL.NO_BOX, fdata.Width, fdata.Height)

 #
 # External create_object - Create an object. Make sure there are
 # no callbacks. Returns the object created.
 #
 def create_object(form, odata):
     obj = _create_object(form, odata)
     if odata.Callback:
         raise error, 'Creating free object with callback'
     return obj
 #
 # External create_object_instance - Create object in an instance.
 #
 def create_object_instance(inst, form, odata):
     obj = _create_object(form, odata)
     if odata.Callback:
         cbfunc = eval('inst.'+odata.Callback)
         obj.set_call_back(cbfunc, odata.Argument)
     if odata.Name:
         exec 'inst.' + odata.Name + ' = obj\n'
 #
 # Internal _create_object: Create the object and fill options
 #
 def _create_object(form, odata):
     crfunc = _select_crfunc(form, odata.Class)
     obj = crfunc(odata.Type, odata.Box[0], odata.Box[1], odata.Box[2], \
             odata.Box[3], odata.Label)
     if not odata.Class in (FL.BEGIN_GROUP, FL.END_GROUP):
         obj.boxtype = odata.Boxtype
         obj.col1 = odata.Colors[0]
         obj.col2 = odata.Colors[1]
         obj.align = odata.Alignment
         obj.lstyle = odata.Style
         obj.lsize = odata.Size
         obj.lcol = odata.Lcol
     return obj
 #
 # Internal crfunc: helper function that returns correct create function
 #
 def _select_crfunc(fm, cl):
     if cl == FL.BEGIN_GROUP: return fm.bgn_group
     elif cl == FL.END_GROUP: return fm.end_group
     elif cl == FL.BITMAP: return fm.add_bitmap
     elif cl == FL.BOX: return fm.add_box
     elif cl == FL.BROWSER: return fm.add_browser
     elif cl == FL.BUTTON: return fm.add_button
     elif cl == FL.CHART: return fm.add_chart
     elif cl == FL.CHOICE: return fm.add_choice
     elif cl == FL.CLOCK: return fm.add_clock
     elif cl == FL.COUNTER: return fm.add_counter
     elif cl == FL.DIAL: return fm.add_dial
     elif cl == FL.FREE: return fm.add_free
     elif cl == FL.INPUT: return fm.add_input
     elif cl == FL.LIGHTBUTTON: return fm.add_lightbutton
     elif cl == FL.MENU: return fm.add_menu
     elif cl == FL.POSITIONER: return fm.add_positioner
     elif cl == FL.ROUNDBUTTON: return fm.add_roundbutton
     elif cl == FL.SLIDER: return fm.add_slider
     elif cl == FL.VALSLIDER: return fm.add_valslider
     elif cl == FL.TEXT: return fm.add_text
     elif cl == FL.TIMER: return fm.add_timer
     else:
         raise error, 'Unknown object type: %r' % (cl,)


 def test():
     import time
     t0 = time.time()
     if len(sys.argv) == 2:
         forms = parse_forms(sys.argv[1])
         t1 = time.time()
         print 'parse time:', 0.001*(t1-t0), 'sec.'
         keys = forms.keys()
         keys.sort()
         for i in keys:
             _printform(forms[i])
     elif len(sys.argv) == 3:
         form = parse_form(sys.argv[1], sys.argv[2])
         t1 = time.time()
         print 'parse time:', round(t1-t0, 3), 'sec.'
         _printform(form)
     else:
         print 'Usage: test fdfile [form]'

 def _printform(form):
     f = form[0]
     objs = form[1]
     print 'Form ', f.Name, ', size: ', f.Width, f.Height, ' Nobj ', f.Numberofobjects
     for i in objs:
         print '  Obj ', i.Name, ' type ', i.Class, i.Type
         print '    Box ', i.Box, ' btype ', i.Boxtype
         print '    Label ', i.Label, ' size/style/col/align ', i.Size,i.Style, i.Lcol, i.Alignment
         print '    cols ', i.Colors
         print '    cback ', i.Callback, i.Argument
	#
	# flp - Module to load fl forms from fd files
	#
	# Jack Jansen, December 1991
	#
	from warnings import warnpy3k
	warnpy3k("the flp module has been removed in Python 3.0", stacklevel=2)
	del warnpy3k

	import os
	import sys
	import FL

	SPLITLINE = '--------------------'
	FORMLINE = '=============== FORM ==============='
	ENDLINE = '=============================='

	class error(Exception):
	pass

	##################################################################
	# Part 1 - The parsing routines #
	##################################################################

	#
	# Externally visible function. Load form.
	#
	def parse_form(filename, formname):
	forms = checkcache(filename)
	if forms is None:
	forms = parse_forms(filename)
	if forms.has_key(formname):
	return forms[formname]
	else:
	raise error, 'No such form in fd file'

	#
	# Externally visible function. Load all forms.
	#
	def parse_forms(filename):
	forms = checkcache(filename)
	if forms is not None: return forms
	fp = _open_formfile(filename)
	nforms = _parse_fd_header(fp)
	forms = {}
	for i in range(nforms):
	form = _parse_fd_form(fp, None)
	forms[form[0].Name] = form
	writecache(filename, forms)
	return forms

	#
	# Internal: see if a cached version of the file exists
	#
	MAGIC = '.fdc'
	_internal_cache = {} # Used by frozen scripts only
	def checkcache(filename):
	if _internal_cache.has_key(filename):
	altforms = _internal_cache[filename]
	return _unpack_cache(altforms)
	import marshal
	fp, filename = _open_formfile2(filename)
	fp.close()
	cachename = filename + 'c'
	try:
	fp = open(cachename, 'r')
	except IOError:
	#print 'flp: no cache file', cachename
	return None
	try:
	if fp.read(4) != MAGIC:
	print 'flp: bad magic word in cache file', cachename
	return None
	cache_mtime = rdlong(fp)
	file_mtime = getmtime(filename)
	if cache_mtime != file_mtime:
	#print 'flp: outdated cache file', cachename
	return None
	#print 'flp: valid cache file', cachename
	altforms = marshal.load(fp)
	return _unpack_cache(altforms)
	finally:
	fp.close()

	def _unpack_cache(altforms):
	forms = {}
	for name in altforms.keys():
	altobj, altlist = altforms[name]
	obj = _newobj()
	obj.make(altobj)
	list = []
	for altobj in altlist:
	nobj = _newobj()
	nobj.make(altobj)
	list.append(nobj)
	forms[name] = obj, list
	return forms

	def rdlong(fp):
	s = fp.read(4)
	if len(s) != 4: return None
	a, b, c, d = s[0], s[1], s[2], s[3]
	return ord(a)<<24 \| ord(b)<<16 \| ord(c)<<8 \| ord(d)

	def wrlong(fp, x):
	a, b, c, d = (x>>24)&0xff, (x>>16)&0xff, (x>>8)&0xff, x&0xff
	fp.write(chr(a) + chr(b) + chr(c) + chr(d))

	def getmtime(filename):
	import os
	from stat import ST_MTIME
	try:
	return os.stat(filename)[ST_MTIME]
	except os.error:
	return None

	#
	# Internal: write cached version of the form (parsing is too slow!)
	#
	def writecache(filename, forms):
	import marshal
	fp, filename = _open_formfile2(filename)
	fp.close()
	cachename = filename + 'c'
	try:
	fp = open(cachename, 'w')
	except IOError:
	print 'flp: can\'t create cache file', cachename
	return # Never mind
	fp.write('\0\0\0\0') # Seek back and write MAGIC when done
	wrlong(fp, getmtime(filename))
	altforms = _pack_cache(forms)
	marshal.dump(altforms, fp)
	fp.seek(0)
	fp.write(MAGIC)
	fp.close()
	#print 'flp: wrote cache file', cachename

	#
	# External: print some statements that set up the internal cache.
	# This is for use with the "freeze" script. You should call
	# flp.freeze(filename) for all forms used by the script, and collect
	# the output on a file in a module file named "frozenforms.py". Then
	# in the main program of the script import frozenforms.
	# (Don't forget to take this out when using the unfrozen version of
	# the script!)
	#
	def freeze(filename):
	forms = parse_forms(filename)
	altforms = _pack_cache(forms)
	print 'import flp'
	print 'flp._internal_cache[', repr(filename), '] =', altforms

	#
	# Internal: create the data structure to be placed in the cache
	#
	def _pack_cache(forms):
	altforms = {}
	for name in forms.keys():
	obj, list = forms[name]
	altobj = obj.__dict__
	altlist = []
	for obj in list: altlist.append(obj.__dict__)
	altforms[name] = altobj, altlist
	return altforms

	#
	# Internal: Locate form file (using PYTHONPATH) and open file
	#
	def _open_formfile(filename):
	return _open_formfile2(filename)[0]

	def _open_formfile2(filename):
	if filename[-3:] != '.fd':
	filename = filename + '.fd'
	if filename[0] == '/':
	try:
	fp = open(filename,'r')
	except IOError:
	fp = None
	else:
	for pc in sys.path:
	pn = os.path.join(pc, filename)
	try:
	fp = open(pn, 'r')
	filename = pn
	break
	except IOError:
	fp = None
	if fp is None:
	raise error, 'Cannot find forms file ' + filename
	return fp, filename

	#
	# Internal: parse the fd file header, return number of forms
	#
	def _parse_fd_header(file):
	# First read the magic header line
	datum = _parse_1_line(file)
	if datum != ('Magic', 12321):
	raise error, 'Not a forms definition file'
	# Now skip until we know number of forms
	while 1:
	datum = _parse_1_line(file)
	if type(datum) == type(()) and datum[0] == 'Numberofforms':
	break
	return datum[1]
	#
	# Internal: parse fd form, or skip if name doesn't match.
	# the special value None means 'always parse it'.
	#
	def _parse_fd_form(file, name):
	datum = _parse_1_line(file)
	if datum != FORMLINE:
	raise error, 'Missing === FORM === line'
	form = _parse_object(file)
	if form.Name == name or name is None:
	objs = []
	for j in range(form.Numberofobjects):
	obj = _parse_object(file)
	objs.append(obj)
	return (form, objs)
	else:
	for j in range(form.Numberofobjects):
	_skip_object(file)
	return None

	#
	# Internal class: a convenient place to store object info fields
	#
	class _newobj:
	def add(self, name, value):
	self.__dict__[name] = value
	def make(self, dict):
	for name in dict.keys():
	self.add(name, dict[name])

	#
	# Internal parsing routines.
	#
	def _parse_string(str):
	if '\\' in str:
	s = '\'' + str + '\''
	try:
	return eval(s)
	except:
	pass
	return str

	def _parse_num(str):
	return eval(str)

	def _parse_numlist(str):
	slist = str.split()
	nlist = []
	for i in slist:
	nlist.append(_parse_num(i))
	return nlist

	# This dictionary maps item names to parsing routines.
	# If no routine is given '_parse_num' is default.
	_parse_func = { \
	'Name': _parse_string, \
	'Box': _parse_numlist, \
	'Colors': _parse_numlist, \
	'Label': _parse_string, \
	'Name': _parse_string, \
	'Callback': _parse_string, \
	'Argument': _parse_string }

	# This function parses a line, and returns either
	# a string or a tuple (name,value)

	import re
	prog = re.compile('^([^:]): (.*)')

	def _parse_line(line):
	match = prog.match(line)
	if not match:
	return line
	name, value = match.group(1, 2)
	if name[0] == 'N':
	name = ''.join(name.split())
	name = name.lower()
	name = name.capitalize()
	try:
	pf = _parse_func[name]
	except KeyError:
	pf = _parse_num
	value = pf(value)
	return (name, value)

	def _readline(file):
	line = file.readline()
	if not line:
	raise EOFError
	return line[:-1]

	def _parse_1_line(file):
	line = _readline(file)
	while line == '':
	line = _readline(file)
	return _parse_line(line)

	def _skip_object(file):
	line = ''
	while not line in (SPLITLINE, FORMLINE, ENDLINE):
	pos = file.tell()
	line = _readline(file)
	if line == FORMLINE:
	file.seek(pos)

	def _parse_object(file):
	obj = _newobj()
	while 1:
	pos = file.tell()
	datum = _parse_1_line(file)
	if datum in (SPLITLINE, FORMLINE, ENDLINE):
	if datum == FORMLINE:
	file.seek(pos)
	return obj
	if type(datum) is not type(()) or len(datum) != 2:
	raise error, 'Parse error, illegal line in object: '+datum
	obj.add(datum[0], datum[1])

	#################################################################
	# Part 2 - High-level object/form creation routines #
	#################################################################

	#
	# External - Create a form an link to an instance variable.
	#
	def create_full_form(inst, (fdata, odatalist)):
	form = create_form(fdata)
	exec 'inst.'+fdata.Name+' = form\n'
	for odata in odatalist:
	create_object_instance(inst, form, odata)

	#
	# External - Merge a form into an existing form in an instance
	# variable.
	#
	def merge_full_form(inst, form, (fdata, odatalist)):
	exec 'inst.'+fdata.Name+' = form\n'
	if odatalist[0].Class != FL.BOX:
	raise error, 'merge_full_form() expects FL.BOX as first obj'
	for odata in odatalist[1:]:
	create_object_instance(inst, form, odata)


	#################################################################
	# Part 3 - Low-level object/form creation routines #
	#################################################################

	#
	# External Create_form - Create form from parameters
	#
	def create_form(fdata):
	import fl
	return fl.make_form(FL.NO_BOX, fdata.Width, fdata.Height)

	#
	# External create_object - Create an object. Make sure there are
	# no callbacks. Returns the object created.
	#
	def create_object(form, odata):
	obj = _create_object(form, odata)
	if odata.Callback:
	raise error, 'Creating free object with callback'
	return obj
	#
	# External create_object_instance - Create object in an instance.
	#
	def create_object_instance(inst, form, odata):
	obj = _create_object(form, odata)
	if odata.Callback:
	cbfunc = eval('inst.'+odata.Callback)
	obj.set_call_back(cbfunc, odata.Argument)
	if odata.Name:
	exec 'inst.' + odata.Name + ' = obj\n'
	#
	# Internal _create_object: Create the object and fill options
	#
	def _create_object(form, odata):
	crfunc = _select_crfunc(form, odata.Class)
	obj = crfunc(odata.Type, odata.Box[0], odata.Box[1], odata.Box[2], \
	odata.Box[3], odata.Label)
	if not odata.Class in (FL.BEGIN_GROUP, FL.END_GROUP):
	obj.boxtype = odata.Boxtype
	obj.col1 = odata.Colors[0]
	obj.col2 = odata.Colors[1]
	obj.align = odata.Alignment
	obj.lstyle = odata.Style
	obj.lsize = odata.Size
	obj.lcol = odata.Lcol
	return obj
	#
	# Internal crfunc: helper function that returns correct create function
	#
	def _select_crfunc(fm, cl):
	if cl == FL.BEGIN_GROUP: return fm.bgn_group
	elif cl == FL.END_GROUP: return fm.end_group
	elif cl == FL.BITMAP: return fm.add_bitmap
	elif cl == FL.BOX: return fm.add_box
	elif cl == FL.BROWSER: return fm.add_browser
	elif cl == FL.BUTTON: return fm.add_button
	elif cl == FL.CHART: return fm.add_chart
	elif cl == FL.CHOICE: return fm.add_choice
	elif cl == FL.CLOCK: return fm.add_clock
	elif cl == FL.COUNTER: return fm.add_counter
	elif cl == FL.DIAL: return fm.add_dial
	elif cl == FL.FREE: return fm.add_free
	elif cl == FL.INPUT: return fm.add_input
	elif cl == FL.LIGHTBUTTON: return fm.add_lightbutton
	elif cl == FL.MENU: return fm.add_menu
	elif cl == FL.POSITIONER: return fm.add_positioner
	elif cl == FL.ROUNDBUTTON: return fm.add_roundbutton
	elif cl == FL.SLIDER: return fm.add_slider
	elif cl == FL.VALSLIDER: return fm.add_valslider
	elif cl == FL.TEXT: return fm.add_text
	elif cl == FL.TIMER: return fm.add_timer
	else:
	raise error, 'Unknown object type: %r' % (cl,)


	def test():
	import time
	t0 = time.time()
	if len(sys.argv) == 2:
	forms = parse_forms(sys.argv[1])
	t1 = time.time()
	print 'parse time:', 0.001*(t1-t0), 'sec.'
	keys = forms.keys()
	keys.sort()
	for i in keys:
	_printform(forms[i])
	elif len(sys.argv) == 3:
	form = parse_form(sys.argv[1], sys.argv[2])
	t1 = time.time()
	print 'parse time:', round(t1-t0, 3), 'sec.'
	_printform(form)
	else:
	print 'Usage: test fdfile [form]'

	def _printform(form):
	f = form[0]
	objs = form[1]
	print 'Form ', f.Name, ', size: ', f.Width, f.Height, ' Nobj ', f.Numberofobjects
	for i in objs:
	print ' Obj ', i.Name, ' type ', i.Class, i.Type
	print ' Box ', i.Box, ' btype ', i.Boxtype
	print ' Label ', i.Label, ' size/style/col/align ', i.Size,i.Style, i.Lcol, i.Alignment
	print ' cols ', i.Colors
	print ' cback ', i.Callback, i.Argument