FreeCAD / src /Tools /bindings /model /generateModel_Module.py

Upload folder using huggingface_hub

985c397 verified about 1 month ago

111 kB

	#!/usr/bin/env python3
	# SPDX-License-Identifier: LGPL-2.1-or-later

	#
	# Generated Wed Sep 27 11:00:46 2023 by generateDS.py.
	# Update it with: python generateDS.py -o generateModel_Module.py generateMetaModel_Module.xsd
	#
	# WARNING! All changes made in this file will be lost!
	#


	import sys
	import getopt
	from xml.dom import minidom
	from xml.dom import Node

	#
	# If you have installed IPython you can uncomment and use the following.
	# IPython is available from http://ipython.scipy.org/.
	#

	## from IPython.Shell import IPShellEmbed
	## args = ''
	## ipshell = IPShellEmbed(args,
	## banner = 'Dropping into IPython',
	## exit_msg = 'Leaving Interpreter, back to program.')

	# Then use the following line where and when you want to drop into the
	# IPython shell:
	# ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')

	#
	# Support/utility functions.
	#


	def showIndent(outfile, level):
	for idx in range(level):
	outfile.write(" ")


	def quote_xml(inStr):
	s1 = inStr
	s1 = s1.replace("&", "&")
	s1 = s1.replace("<", "<")
	s1 = s1.replace('"', """)
	return s1


	def quote_python(inStr):
	s1 = inStr
	if s1.find("'") == -1:
	if s1.find("\n") == -1:
	return "'%s'" % s1
	else:
	return "'''%s'''" % s1
	else:
	if s1.find('"') != -1:
	s1 = s1.replace('"', '\\"')
	if s1.find("\n") == -1:
	return '"%s"' % s1
	else:
	return '"""%s"""' % s1


	class MixedContainer:
	# Constants for category:
	CategoryNone = 0
	CategoryText = 1
	CategorySimple = 2
	CategoryComplex = 3
	# Constants for content_type:
	TypeNone = 0
	TypeText = 1
	TypeString = 2
	TypeInteger = 3
	TypeFloat = 4
	TypeDecimal = 5
	TypeDouble = 6
	TypeBoolean = 7

	def __init__(self, category, content_type, name, value):
	self.category = category
	self.content_type = content_type
	self.name = name
	self.value = value

	def getCategory(self):
	return self.category

	def getContenttype(self, content_type):
	return self.content_type

	def getValue(self):
	return self.value

	def getName(self):
	return self.name

	def export(self, outfile, level, name):
	if self.category == MixedContainer.CategoryText:
	outfile.write(self.value)
	elif self.category == MixedContainer.CategorySimple:
	self.exportSimple(outfile, level, name)
	else: # category == MixedContainer.CategoryComplex
	self.value.export(outfile, level, name)

	def exportSimple(self, outfile, level, name):
	if self.content_type == MixedContainer.TypeString:
	outfile.write("<%s>%s</%s>" % (self.name, self.value, self.name))
	elif (
	self.content_type == MixedContainer.TypeInteger
	or self.content_type == MixedContainer.TypeBoolean
	):
	outfile.write("<%s>%d</%s>" % (self.name, self.value, self.name))
	elif (
	self.content_type == MixedContainer.TypeFloat
	or self.content_type == MixedContainer.TypeDecimal
	):
	outfile.write("<%s>%f</%s>" % (self.name, self.value, self.name))
	elif self.content_type == MixedContainer.TypeDouble:
	outfile.write("<%s>%g</%s>" % (self.name, self.value, self.name))

	def exportLiteral(self, outfile, level, name):
	if self.category == MixedContainer.CategoryText:
	showIndent(outfile, level)
	outfile.write(
	'MixedContainer(%d, %d, "%s", "%s"),\n'
	% (self.category, self.content_type, self.name, self.value)
	)
	elif self.category == MixedContainer.CategorySimple:
	showIndent(outfile, level)
	outfile.write(
	'MixedContainer(%d, %d, "%s", "%s"),\n'
	% (self.category, self.content_type, self.name, self.value)
	)
	else: # category == MixedContainer.CategoryComplex
	showIndent(outfile, level)
	outfile.write(
	'MixedContainer(%d, %d, "%s",\n'
	% (
	self.category,
	self.content_type,
	self.name,
	)
	)
	self.value.exportLiteral(outfile, level + 1)
	showIndent(outfile, level)
	outfile.write(")\n")


	#
	# Data representation classes.
	#


	class GenerateModel:
	subclass = None

	def __init__(self, Module=None, PythonExport=None):
	if Module is None:
	self.Module = []
	else:
	self.Module = Module
	if PythonExport is None:
	self.PythonExport = []
	else:
	self.PythonExport = PythonExport

	def factory(args_, *kwargs_):
	if GenerateModel.subclass:
	return GenerateModel.subclass(args_, *kwargs_)
	else:
	return GenerateModel(args_, *kwargs_)

	factory = staticmethod(factory)

	def getModule(self):
	return self.Module

	def setModule(self, Module):
	self.Module = Module

	def addModule(self, value):
	self.Module.append(value)

	def insertModule(self, index, value):
	self.Module[index] = value

	def getPythonexport(self):
	return self.PythonExport

	def setPythonexport(self, PythonExport):
	self.PythonExport = PythonExport

	def addPythonexport(self, value):
	self.PythonExport.append(value)

	def insertPythonexport(self, index, value):
	self.PythonExport[index] = value

	def export(self, outfile, level, name_="GenerateModel"):
	showIndent(outfile, level)
	outfile.write("<%s>\n" % name_)
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="GenerateModel"):
	pass

	def exportChildren(self, outfile, level, name_="GenerateModel"):
	for Module_ in self.getModule():
	Module_.export(outfile, level)
	for PythonExport_ in self.getPythonexport():
	PythonExport_.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="GenerateModel"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	pass

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write("Module=[\n")
	level += 1
	for Module in self.Module:
	showIndent(outfile, level)
	outfile.write("Module(\n")
	Module.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("PythonExport=[\n")
	level += 1
	for PythonExport in self.PythonExport:
	showIndent(outfile, level)
	outfile.write("PythonExport(\n")
	PythonExport.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	pass

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Module":
	obj_ = Module.factory()
	obj_.build(child_)
	self.Module.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "PythonExport":
	obj_ = PythonExport.factory()
	obj_.build(child_)
	self.PythonExport.append(obj_)


	# end class GenerateModel


	class PythonExport:
	subclass = None

	def __init__(
	self,
	Name="",
	PythonName="",
	Include="",
	Father="",
	Twin="",
	Namespace="",
	FatherInclude="",
	FatherNamespace="",
	Constructor=0,
	NumberProtocol=0,
	RichCompare=0,
	TwinPointer="",
	Delete=0,
	Reference=0,
	Initialization=0,
	DisableNotify=0,
	DescriptorGetter=0,
	DescriptorSetter=0,
	Documentation=None,
	Methode=None,
	Attribute=None,
	Sequence=None,
	CustomAttributes="",
	ClassDeclarations="",
	ForwardDeclarations="",
	):
	self.Name = Name
	self.PythonName = PythonName
	self.Include = Include
	self.Father = Father
	self.Twin = Twin
	self.Namespace = Namespace
	self.FatherInclude = FatherInclude
	self.FatherNamespace = FatherNamespace
	self.Constructor = Constructor
	self.NumberProtocol = NumberProtocol
	self.RichCompare = RichCompare
	self.TwinPointer = TwinPointer
	self.Delete = Delete
	self.Reference = Reference
	self.Initialization = Initialization
	self.DisableNotify = DisableNotify
	self.DescriptorGetter = DescriptorGetter
	self.DescriptorSetter = DescriptorSetter
	self.Documentation = Documentation
	if Methode is None:
	self.Methode = []
	else:
	self.Methode = Methode
	if Attribute is None:
	self.Attribute = []
	else:
	self.Attribute = Attribute
	self.Sequence = Sequence
	self.CustomAttributes = CustomAttributes
	self.ClassDeclarations = ClassDeclarations
	self.ForwardDeclarations = ForwardDeclarations

	def factory(args_, *kwargs_):
	if PythonExport.subclass:
	return PythonExport.subclass(args_, *kwargs_)
	else:
	return PythonExport(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getMethode(self):
	return self.Methode

	def setMethode(self, Methode):
	self.Methode = Methode

	def addMethode(self, value):
	self.Methode.append(value)

	def insertMethode(self, index, value):
	self.Methode[index] = value

	def getAttribute(self):
	return self.Attribute

	def setAttribute(self, Attribute):
	self.Attribute = Attribute

	def addAttribute(self, value):
	self.Attribute.append(value)

	def insertAttribute(self, index, value):
	self.Attribute[index] = value

	def getSequence(self):
	return self.Sequence

	def setSequence(self, Sequence):
	self.Sequence = Sequence

	def getCustomattributes(self):
	return self.CustomAttributes

	def setCustomattributes(self, CustomAttributes):
	self.CustomAttributes = CustomAttributes

	def getClassdeclarations(self):
	return self.ClassDeclarations

	def setClassdeclarations(self, ClassDeclarations):
	self.ClassDeclarations = ClassDeclarations

	def getForwarddeclarations(self):
	return self.ForwardDeclarations

	def setForwarddeclarations(self, ForwardDeclarations):
	self.ForwardDeclarations = ForwardDeclarations

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getPythonname(self):
	return self.PythonName

	def setPythonname(self, PythonName):
	self.PythonName = PythonName

	def getInclude(self):
	return self.Include

	def setInclude(self, Include):
	self.Include = Include

	def getFather(self):
	return self.Father

	def setFather(self, Father):
	self.Father = Father

	def getTwin(self):
	return self.Twin

	def setTwin(self, Twin):
	self.Twin = Twin

	def getNamespace(self):
	return self.Namespace

	def setNamespace(self, Namespace):
	self.Namespace = Namespace

	def getFatherinclude(self):
	return self.FatherInclude

	def setFatherinclude(self, FatherInclude):
	self.FatherInclude = FatherInclude

	def getFathernamespace(self):
	return self.FatherNamespace

	def setFathernamespace(self, FatherNamespace):
	self.FatherNamespace = FatherNamespace

	def getConstructor(self):
	return self.Constructor

	def setConstructor(self, Constructor):
	self.Constructor = Constructor

	def getNumberprotocol(self):
	return self.NumberProtocol

	def setNumberprotocol(self, NumberProtocol):
	self.NumberProtocol = NumberProtocol

	def getRichcompare(self):
	return self.RichCompare

	def setRichcompare(self, RichCompare):
	self.RichCompare = RichCompare

	def getTwinpointer(self):
	return self.TwinPointer

	def setTwinpointer(self, TwinPointer):
	self.TwinPointer = TwinPointer

	def getDelete(self):
	return self.Delete

	def setDelete(self, Delete):
	self.Delete = Delete

	def getReference(self):
	return self.Reference

	def setReference(self, Reference):
	self.Reference = Reference

	def getInitialization(self):
	return self.Initialization

	def setInitialization(self, Initialization):
	self.Initialization = Initialization

	def getDisablenotify(self):
	return self.DisableNotify

	def setDisablenotify(self, DisableNotify):
	self.DisableNotify = DisableNotify

	def getDescriptorgetter(self):
	return self.DescriptorGetter

	def setDescriptorgetter(self, DescriptorGetter):
	self.DescriptorGetter = DescriptorGetter

	def getDescriptorsetter(self):
	return self.DescriptorSetter

	def setDescriptorsetter(self, DescriptorSetter):
	self.DescriptorSetter = DescriptorSetter

	def export(self, outfile, level, name_="PythonExport"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="PythonExport")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="PythonExport"):
	outfile.write(' Name="%s"' % (self.getName(),))
	if self.getPythonname() is not None:
	outfile.write(' PythonName="%s"' % (self.getPythonname(),))
	outfile.write(' Include="%s"' % (self.getInclude(),))
	outfile.write(' Father="%s"' % (self.getFather(),))
	outfile.write(' Twin="%s"' % (self.getTwin(),))
	outfile.write(' Namespace="%s"' % (self.getNamespace(),))
	outfile.write(' FatherInclude="%s"' % (self.getFatherinclude(),))
	outfile.write(' FatherNamespace="%s"' % (self.getFathernamespace(),))
	if self.getConstructor() is not None:
	outfile.write(' Constructor="%s"' % (self.getConstructor(),))
	if self.getNumberprotocol() is not None:
	outfile.write(' NumberProtocol="%s"' % (self.getNumberprotocol(),))
	if self.getRichcompare() is not None:
	outfile.write(' RichCompare="%s"' % (self.getRichcompare(),))
	outfile.write(' TwinPointer="%s"' % (self.getTwinpointer(),))
	if self.getDelete() is not None:
	outfile.write(' Delete="%s"' % (self.getDelete(),))
	if self.getReference() is not None:
	outfile.write(' Reference="%s"' % (self.getReference(),))
	if self.getInitialization() is not None:
	outfile.write(' Initialization="%s"' % (self.getInitialization(),))
	if self.getDisablenotify() is not None:
	outfile.write(' DisableNotify="%s"' % (self.getDisablenotify(),))
	if self.getDescriptorgetter() is not None:
	outfile.write(' DescriptorGetter="%s"' % (self.getDescriptorgetter(),))
	if self.getDescriptorsetter() is not None:
	outfile.write(' DescriptorSetter="%s"' % (self.getDescriptorsetter(),))

	def exportChildren(self, outfile, level, name_="PythonExport"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	for Methode_ in self.getMethode():
	Methode_.export(outfile, level)
	for Attribute_ in self.getAttribute():
	Attribute_.export(outfile, level)
	if self.Sequence:
	self.Sequence.export(outfile, level)
	showIndent(outfile, level)
	outfile.write(
	"<CustomAttributes>%s</CustomAttributes>\n" % quote_xml(self.getCustomattributes())
	)
	showIndent(outfile, level)
	outfile.write(
	"<ClassDeclarations>%s</ClassDeclarations>\n" % quote_xml(self.getClassdeclarations())
	)
	showIndent(outfile, level)
	outfile.write(
	"<ForwardDeclarations>%s</ForwardDeclarations>\n"
	% quote_xml(self.getForwarddeclarations())
	)

	def exportLiteral(self, outfile, level, name_="PythonExport"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('PythonName = "%s",\n' % (self.getPythonname(),))
	showIndent(outfile, level)
	outfile.write('Include = "%s",\n' % (self.getInclude(),))
	showIndent(outfile, level)
	outfile.write('Father = "%s",\n' % (self.getFather(),))
	showIndent(outfile, level)
	outfile.write('Twin = "%s",\n' % (self.getTwin(),))
	showIndent(outfile, level)
	outfile.write('Namespace = "%s",\n' % (self.getNamespace(),))
	showIndent(outfile, level)
	outfile.write('FatherInclude = "%s",\n' % (self.getFatherinclude(),))
	showIndent(outfile, level)
	outfile.write('FatherNamespace = "%s",\n' % (self.getFathernamespace(),))
	showIndent(outfile, level)
	outfile.write('Constructor = "%s",\n' % (self.getConstructor(),))
	showIndent(outfile, level)
	outfile.write('NumberProtocol = "%s",\n' % (self.getNumberprotocol(),))
	showIndent(outfile, level)
	outfile.write('RichCompare = "%s",\n' % (self.getRichcompare(),))
	showIndent(outfile, level)
	outfile.write('TwinPointer = "%s",\n' % (self.getTwinpointer(),))
	showIndent(outfile, level)
	outfile.write('Delete = "%s",\n' % (self.getDelete(),))
	showIndent(outfile, level)
	outfile.write('Reference = "%s",\n' % (self.getReference(),))
	showIndent(outfile, level)
	outfile.write('Initialization = "%s",\n' % (self.getInitialization(),))
	showIndent(outfile, level)
	outfile.write('DisableNotify = "%s",\n' % (self.getDisablenotify(),))
	showIndent(outfile, level)
	outfile.write('DescriptorGetter = "%s",\n' % (self.getDescriptorgetter(),))
	showIndent(outfile, level)
	outfile.write('DescriptorSetter = "%s",\n' % (self.getDescriptorsetter(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("Methode=[\n")
	level += 1
	for Methode in self.Methode:
	showIndent(outfile, level)
	outfile.write("Methode(\n")
	Methode.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("Attribute=[\n")
	level += 1
	for Attribute in self.Attribute:
	showIndent(outfile, level)
	outfile.write("Attribute(\n")
	Attribute.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	if self.Sequence:
	showIndent(outfile, level)
	outfile.write("Sequence=Sequence(\n")
	self.Sequence.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("CustomAttributes=%s,\n" % quote_python(self.getCustomattributes()))
	showIndent(outfile, level)
	outfile.write("ClassDeclarations=%s,\n" % quote_python(self.getClassdeclarations()))
	showIndent(outfile, level)
	outfile.write("ForwardDeclarations=%s,\n" % quote_python(self.getForwarddeclarations()))

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("PythonName"):
	self.PythonName = attrs.get("PythonName").value
	if attrs.get("Include"):
	self.Include = attrs.get("Include").value
	if attrs.get("Father"):
	self.Father = attrs.get("Father").value
	if attrs.get("Twin"):
	self.Twin = attrs.get("Twin").value
	if attrs.get("Namespace"):
	self.Namespace = attrs.get("Namespace").value
	if attrs.get("FatherInclude"):
	self.FatherInclude = attrs.get("FatherInclude").value
	if attrs.get("FatherNamespace"):
	self.FatherNamespace = attrs.get("FatherNamespace").value
	if attrs.get("Constructor"):
	if attrs.get("Constructor").value in ("true", "1"):
	self.Constructor = 1
	elif attrs.get("Constructor").value in ("false", "0"):
	self.Constructor = 0
	else:
	raise ValueError("Bad boolean attribute (Constructor)")
	if attrs.get("NumberProtocol"):
	if attrs.get("NumberProtocol").value in ("true", "1"):
	self.NumberProtocol = 1
	elif attrs.get("NumberProtocol").value in ("false", "0"):
	self.NumberProtocol = 0
	else:
	raise ValueError("Bad boolean attribute (NumberProtocol)")
	if attrs.get("RichCompare"):
	if attrs.get("RichCompare").value in ("true", "1"):
	self.RichCompare = 1
	elif attrs.get("RichCompare").value in ("false", "0"):
	self.RichCompare = 0
	else:
	raise ValueError("Bad boolean attribute (RichCompare)")
	if attrs.get("TwinPointer"):
	self.TwinPointer = attrs.get("TwinPointer").value
	if attrs.get("Delete"):
	if attrs.get("Delete").value in ("true", "1"):
	self.Delete = 1
	elif attrs.get("Delete").value in ("false", "0"):
	self.Delete = 0
	else:
	raise ValueError("Bad boolean attribute (Delete)")
	if attrs.get("Reference"):
	if attrs.get("Reference").value in ("true", "1"):
	self.Reference = 1
	elif attrs.get("Reference").value in ("false", "0"):
	self.Reference = 0
	else:
	raise ValueError("Bad boolean attribute (Reference)")
	if attrs.get("Initialization"):
	if attrs.get("Initialization").value in ("true", "1"):
	self.Initialization = 1
	elif attrs.get("Initialization").value in ("false", "0"):
	self.Initialization = 0
	else:
	raise ValueError("Bad boolean attribute (Initialization)")
	if attrs.get("DisableNotify"):
	if attrs.get("DisableNotify").value in ("true", "1"):
	self.DisableNotify = 1
	elif attrs.get("DisableNotify").value in ("false", "0"):
	self.DisableNotify = 0
	else:
	raise ValueError("Bad boolean attribute (DisableNotify)")
	if attrs.get("DescriptorGetter"):
	if attrs.get("DescriptorGetter").value in ("true", "1"):
	self.DescriptorGetter = 1
	elif attrs.get("DescriptorGetter").value in ("false", "0"):
	self.DescriptorGetter = 0
	else:
	raise ValueError("Bad boolean attribute (DescriptorGetter)")
	if attrs.get("DescriptorSetter"):
	if attrs.get("DescriptorSetter").value in ("true", "1"):
	self.DescriptorSetter = 1
	elif attrs.get("DescriptorSetter").value in ("false", "0"):
	self.DescriptorSetter = 0
	else:
	raise ValueError("Bad boolean attribute (DescriptorSetter)")

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Methode":
	obj_ = Methode.factory()
	obj_.build(child_)
	self.Methode.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Attribute":
	obj_ = Attribute.factory()
	obj_.build(child_)
	self.Attribute.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Sequence":
	obj_ = Sequence.factory()
	obj_.build(child_)
	self.setSequence(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "CustomAttributes":
	CustomAttributes_ = ""
	for text__content_ in child_.childNodes:
	CustomAttributes_ += text__content_.nodeValue
	self.CustomAttributes = CustomAttributes_
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ClassDeclarations":
	ClassDeclarations_ = ""
	for text__content_ in child_.childNodes:
	ClassDeclarations_ += text__content_.nodeValue
	self.ClassDeclarations = ClassDeclarations_
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ForwardDeclarations":
	ForwardDeclarations_ = ""
	for text__content_ in child_.childNodes:
	ForwardDeclarations_ += text__content_.nodeValue
	self.ForwardDeclarations = ForwardDeclarations_


	# end class PythonExport


	class Methode:
	subclass = None

	def __init__(
	self,
	Name="",
	Const=0,
	Keyword=0,
	NoArgs=0,
	Class=0,
	Static=0,
	Documentation=None,
	Parameter=None,
	):
	self.Name = Name
	self.Const = Const
	self.Keyword = Keyword
	self.NoArgs = NoArgs
	self.Class = Class
	self.Static = Static
	self.Documentation = Documentation
	if Parameter is None:
	self.Parameter = []
	else:
	self.Parameter = Parameter

	def factory(args_, *kwargs_):
	if Methode.subclass:
	return Methode.subclass(args_, *kwargs_)
	else:
	return Methode(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getParameter(self):
	return self.Parameter

	def setParameter(self, Parameter):
	self.Parameter = Parameter

	def addParameter(self, value):
	self.Parameter.append(value)

	def insertParameter(self, index, value):
	self.Parameter[index] = value

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getConst(self):
	return self.Const

	def setConst(self, Const):
	self.Const = Const

	def getKeyword(self):
	return self.Keyword

	def setKeyword(self, Keyword):
	self.Keyword = Keyword

	def getNoargs(self):
	return self.NoArgs

	def setNoargs(self, NoArgs):
	self.NoArgs = NoArgs

	def getClass(self):
	return self.Class

	def setClass(self, Class):
	self.Class = Class

	def getStatic(self):
	return self.Static

	def setStatic(self, Static):
	self.Static = Static

	def export(self, outfile, level, name_="Methode"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Methode")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Methode"):
	outfile.write(' Name="%s"' % (self.getName(),))
	if self.getConst() is not None:
	outfile.write(' Const="%s"' % (self.getConst(),))
	if self.getKeyword() is not None:
	outfile.write(' Keyword="%s"' % (self.getKeyword(),))
	if self.getNoargs() is not None:
	outfile.write(' NoArgs="%s"' % (self.getNoargs(),))
	if self.getClass() is not None:
	outfile.write(' Class="%s"' % (self.getClass(),))
	if self.getStatic() is not None:
	outfile.write(' Static="%s"' % (self.getStatic(),))

	def exportChildren(self, outfile, level, name_="Methode"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	for Parameter_ in self.getParameter():
	Parameter_.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Methode"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('Const = "%s",\n' % (self.getConst(),))
	showIndent(outfile, level)
	outfile.write('Keyword = "%s",\n' % (self.getKeyword(),))
	showIndent(outfile, level)
	outfile.write('NoArgs = "%s",\n' % (self.getNoargs(),))
	showIndent(outfile, level)
	outfile.write('Class = "%s",\n' % (self.getClass(),))
	showIndent(outfile, level)
	outfile.write('Static = "%s",\n' % (self.getStatic(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("Parameter=[\n")
	level += 1
	for Parameter in self.Parameter:
	showIndent(outfile, level)
	outfile.write("Parameter(\n")
	Parameter.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("Const"):
	if attrs.get("Const").value in ("true", "1"):
	self.Const = 1
	elif attrs.get("Const").value in ("false", "0"):
	self.Const = 0
	else:
	raise ValueError("Bad boolean attribute (Const)")
	if attrs.get("Keyword"):
	if attrs.get("Keyword").value in ("true", "1"):
	self.Keyword = 1
	elif attrs.get("Keyword").value in ("false", "0"):
	self.Keyword = 0
	else:
	raise ValueError("Bad boolean attribute (Keyword)")
	if attrs.get("NoArgs"):
	if attrs.get("NoArgs").value in ("true", "1"):
	self.NoArgs = 1
	elif attrs.get("NoArgs").value in ("false", "0"):
	self.NoArgs = 0
	else:
	raise ValueError("Bad boolean attribute (NoArgs)")
	if attrs.get("Class"):
	if attrs.get("Class").value in ("true", "1"):
	self.Class = 1
	elif attrs.get("Class").value in ("false", "0"):
	self.Class = 0
	else:
	raise ValueError("Bad boolean attribute (Class)")
	if attrs.get("Static"):
	if attrs.get("Static").value in ("true", "1"):
	self.Static = 1
	elif attrs.get("Static").value in ("false", "0"):
	self.Static = 0
	else:
	raise ValueError("Bad boolean attribute (Static)")

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Parameter":
	obj_ = Parameter.factory()
	obj_.build(child_)
	self.Parameter.append(obj_)


	# end class Methode


	class Attribute:
	subclass = None

	def __init__(self, Name="", ReadOnly=0, Documentation=None, Parameter=None):
	self.Name = Name
	self.ReadOnly = ReadOnly
	self.Documentation = Documentation
	self.Parameter = Parameter

	def factory(args_, *kwargs_):
	if Attribute.subclass:
	return Attribute.subclass(args_, *kwargs_)
	else:
	return Attribute(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getParameter(self):
	return self.Parameter

	def setParameter(self, Parameter):
	self.Parameter = Parameter

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getReadonly(self):
	return self.ReadOnly

	def setReadonly(self, ReadOnly):
	self.ReadOnly = ReadOnly

	def export(self, outfile, level, name_="Attribute"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Attribute")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Attribute"):
	outfile.write(' Name="%s"' % (self.getName(),))
	outfile.write(' ReadOnly="%s"' % (self.getReadonly(),))

	def exportChildren(self, outfile, level, name_="Attribute"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	if self.Parameter:
	self.Parameter.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Attribute"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('ReadOnly = "%s",\n' % (self.getReadonly(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	if self.Parameter:
	showIndent(outfile, level)
	outfile.write("Parameter=Parameter(\n")
	self.Parameter.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("ReadOnly"):
	if attrs.get("ReadOnly").value in ("true", "1"):
	self.ReadOnly = 1
	elif attrs.get("ReadOnly").value in ("false", "0"):
	self.ReadOnly = 0
	else:
	raise ValueError("Bad boolean attribute (ReadOnly)")

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Parameter":
	obj_ = Parameter.factory()
	obj_.build(child_)
	self.setParameter(obj_)


	# end class Attribute


	class Sequence:
	subclass = None

	def __init__(
	self,
	sq_length=0,
	sq_concat=0,
	sq_repeat=0,
	sq_item=0,
	mp_subscript=0,
	sq_ass_item=0,
	mp_ass_subscript=0,
	sq_contains=0,
	sq_inplace_concat=0,
	sq_inplace_repeat=0,
	valueOf_="",
	):
	self.sq_length = sq_length
	self.sq_concat = sq_concat
	self.sq_repeat = sq_repeat
	self.sq_item = sq_item
	self.mp_subscript = mp_subscript
	self.sq_ass_item = sq_ass_item
	self.mp_ass_subscript = mp_ass_subscript
	self.sq_contains = sq_contains
	self.sq_inplace_concat = sq_inplace_concat
	self.sq_inplace_repeat = sq_inplace_repeat
	self.valueOf_ = valueOf_

	def factory(args_, *kwargs_):
	if Sequence.subclass:
	return Sequence.subclass(args_, *kwargs_)
	else:
	return Sequence(args_, *kwargs_)

	factory = staticmethod(factory)

	def getSq_length(self):
	return self.sq_length

	def setSq_length(self, sq_length):
	self.sq_length = sq_length

	def getSq_concat(self):
	return self.sq_concat

	def setSq_concat(self, sq_concat):
	self.sq_concat = sq_concat

	def getSq_repeat(self):
	return self.sq_repeat

	def setSq_repeat(self, sq_repeat):
	self.sq_repeat = sq_repeat

	def getSq_item(self):
	return self.sq_item

	def setSq_item(self, sq_item):
	self.sq_item = sq_item

	def getMp_subscript(self):
	return self.mp_subscript

	def setMp_subscript(self, mp_subscript):
	self.mp_subscript = mp_subscript

	def getSq_ass_item(self):
	return self.sq_ass_item

	def setSq_ass_item(self, sq_ass_item):
	self.sq_ass_item = sq_ass_item

	def getMp_ass_subscript(self):
	return self.mp_ass_subscript

	def setMp_ass_subscript(self, mp_ass_subscript):
	self.mp_ass_subscript = mp_ass_subscript

	def getSq_contains(self):
	return self.sq_contains

	def setSq_contains(self, sq_contains):
	self.sq_contains = sq_contains

	def getSq_inplace_concat(self):
	return self.sq_inplace_concat

	def setSq_inplace_concat(self, sq_inplace_concat):
	self.sq_inplace_concat = sq_inplace_concat

	def getSq_inplace_repeat(self):
	return self.sq_inplace_repeat

	def setSq_inplace_repeat(self, sq_inplace_repeat):
	self.sq_inplace_repeat = sq_inplace_repeat

	def getValueOf_(self):
	return self.valueOf_

	def setValueOf_(self, valueOf_):
	self.valueOf_ = valueOf_

	def export(self, outfile, level, name_="Sequence"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Sequence")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Sequence"):
	outfile.write(' sq_length="%s"' % (self.getSq_length(),))
	outfile.write(' sq_concat="%s"' % (self.getSq_concat(),))
	outfile.write(' sq_repeat="%s"' % (self.getSq_repeat(),))
	outfile.write(' sq_item="%s"' % (self.getSq_item(),))
	outfile.write(' mp_subscript="%s"' % (self.getMp_subscript(),))
	outfile.write(' sq_ass_item="%s"' % (self.getSq_ass_item(),))
	outfile.write(' mp_ass_subscript="%s"' % (self.getMp_ass_subscript(),))
	outfile.write(' sq_contains="%s"' % (self.getSq_contains(),))
	outfile.write(' sq_inplace_concat="%s"' % (self.getSq_inplace_concat(),))
	outfile.write(' sq_inplace_repeat="%s"' % (self.getSq_inplace_repeat(),))

	def exportChildren(self, outfile, level, name_="Sequence"):
	outfile.write(self.valueOf_)

	def exportLiteral(self, outfile, level, name_="Sequence"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('sq_length = "%s",\n' % (self.getSq_length(),))
	showIndent(outfile, level)
	outfile.write('sq_concat = "%s",\n' % (self.getSq_concat(),))
	showIndent(outfile, level)
	outfile.write('sq_repeat = "%s",\n' % (self.getSq_repeat(),))
	showIndent(outfile, level)
	outfile.write('sq_item = "%s",\n' % (self.getSq_item(),))
	showIndent(outfile, level)
	outfile.write('mp_subscript = "%s",\n' % (self.getMp_subscript(),))
	showIndent(outfile, level)
	outfile.write('sq_ass_item = "%s",\n' % (self.getSq_ass_item(),))
	showIndent(outfile, level)
	outfile.write('mp_ass_subscript = "%s",\n' % (self.getMp_ass_subscript(),))
	showIndent(outfile, level)
	outfile.write('sq_contains = "%s",\n' % (self.getSq_contains(),))
	showIndent(outfile, level)
	outfile.write('sq_inplace_concat = "%s",\n' % (self.getSq_inplace_concat(),))
	showIndent(outfile, level)
	outfile.write('sq_inplace_repeat = "%s",\n' % (self.getSq_inplace_repeat(),))

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("sq_length"):
	if attrs.get("sq_length").value in ("true", "1"):
	self.sq_length = 1
	elif attrs.get("sq_length").value in ("false", "0"):
	self.sq_length = 0
	else:
	raise ValueError("Bad boolean attribute (sq_length)")
	if attrs.get("sq_concat"):
	if attrs.get("sq_concat").value in ("true", "1"):
	self.sq_concat = 1
	elif attrs.get("sq_concat").value in ("false", "0"):
	self.sq_concat = 0
	else:
	raise ValueError("Bad boolean attribute (sq_concat)")
	if attrs.get("sq_repeat"):
	if attrs.get("sq_repeat").value in ("true", "1"):
	self.sq_repeat = 1
	elif attrs.get("sq_repeat").value in ("false", "0"):
	self.sq_repeat = 0
	else:
	raise ValueError("Bad boolean attribute (sq_repeat)")
	if attrs.get("sq_item"):
	if attrs.get("sq_item").value in ("true", "1"):
	self.sq_item = 1
	elif attrs.get("sq_item").value in ("false", "0"):
	self.sq_item = 0
	else:
	raise ValueError("Bad boolean attribute (sq_item)")
	if attrs.get("mp_subscript"):
	if attrs.get("mp_subscript").value in ("true", "1"):
	self.mp_subscript = 1
	elif attrs.get("mp_subscript").value in ("false", "0"):
	self.mp_subscript = 0
	else:
	raise ValueError("Bad boolean attribute (mp_subscript)")
	if attrs.get("sq_ass_item"):
	if attrs.get("sq_ass_item").value in ("true", "1"):
	self.sq_ass_item = 1
	elif attrs.get("sq_ass_item").value in ("false", "0"):
	self.sq_ass_item = 0
	else:
	raise ValueError("Bad boolean attribute (sq_ass_item)")
	if attrs.get("mp_ass_subscript"):
	if attrs.get("mp_ass_subscript").value in ("true", "1"):
	self.mp_ass_subscript = 1
	elif attrs.get("mp_ass_subscript").value in ("false", "0"):
	self.mp_ass_subscript = 0
	else:
	raise ValueError("Bad boolean attribute (mp_ass_subscript)")
	if attrs.get("sq_contains"):
	if attrs.get("sq_contains").value in ("true", "1"):
	self.sq_contains = 1
	elif attrs.get("sq_contains").value in ("false", "0"):
	self.sq_contains = 0
	else:
	raise ValueError("Bad boolean attribute (sq_contains)")
	if attrs.get("sq_inplace_concat"):
	if attrs.get("sq_inplace_concat").value in ("true", "1"):
	self.sq_inplace_concat = 1
	elif attrs.get("sq_inplace_concat").value in ("false", "0"):
	self.sq_inplace_concat = 0
	else:
	raise ValueError("Bad boolean attribute (sq_inplace_concat)")
	if attrs.get("sq_inplace_repeat"):
	if attrs.get("sq_inplace_repeat").value in ("true", "1"):
	self.sq_inplace_repeat = 1
	elif attrs.get("sq_inplace_repeat").value in ("false", "0"):
	self.sq_inplace_repeat = 0
	else:
	raise ValueError("Bad boolean attribute (sq_inplace_repeat)")

	def buildChildren(self, child_, nodeName_):
	self.valueOf_ = ""
	for child in child_.childNodes:
	if child.nodeType == Node.TEXT_NODE:
	self.valueOf_ += child.nodeValue


	# end class Sequence


	class Module:
	subclass = None

	def __init__(self, Name="", Documentation=None, Dependencies=None, Content=None):
	self.Name = Name
	self.Documentation = Documentation
	self.Dependencies = Dependencies
	self.Content = Content

	def factory(args_, *kwargs_):
	if Module.subclass:
	return Module.subclass(args_, *kwargs_)
	else:
	return Module(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getDependencies(self):
	return self.Dependencies

	def setDependencies(self, Dependencies):
	self.Dependencies = Dependencies

	def getContent(self):
	return self.Content

	def setContent(self, Content):
	self.Content = Content

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def export(self, outfile, level, name_="Module"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Module")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Module"):
	outfile.write(' Name="%s"' % (self.getName(),))

	def exportChildren(self, outfile, level, name_="Module"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	if self.Dependencies:
	self.Dependencies.export(outfile, level)
	if self.Content:
	self.Content.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Module"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	if self.Dependencies:
	showIndent(outfile, level)
	outfile.write("Dependencies=Dependencies(\n")
	self.Dependencies.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	if self.Content:
	showIndent(outfile, level)
	outfile.write("Content=Content(\n")
	self.Content.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Dependencies":
	obj_ = Dependencies.factory()
	obj_.build(child_)
	self.setDependencies(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Content":
	obj_ = Content.factory()
	obj_.build(child_)
	self.setContent(obj_)


	# end class Module


	class Dependencies:
	subclass = None

	def __init__(self, Module=None):
	if Module is None:
	self.Module = []
	else:
	self.Module = Module

	def factory(args_, *kwargs_):
	if Dependencies.subclass:
	return Dependencies.subclass(args_, *kwargs_)
	else:
	return Dependencies(args_, *kwargs_)

	factory = staticmethod(factory)

	def getModule(self):
	return self.Module

	def setModule(self, Module):
	self.Module = Module

	def addModule(self, value):
	self.Module.append(value)

	def insertModule(self, index, value):
	self.Module[index] = value

	def export(self, outfile, level, name_="Dependencies"):
	showIndent(outfile, level)
	outfile.write("<%s>\n" % name_)
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Dependencies"):
	pass

	def exportChildren(self, outfile, level, name_="Dependencies"):
	for Module_ in self.getModule():
	Module_.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Dependencies"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	pass

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write("Module=[\n")
	level += 1
	for Module in self.Module:
	showIndent(outfile, level)
	outfile.write("Module(\n")
	Module.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	pass

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Module":
	obj_ = Module.factory()
	obj_.build(child_)
	self.Module.append(obj_)


	# end class Dependencies


	class Content:
	subclass = None

	def __init__(
	self, Property=None, Feature=None, DocObject=None, GuiCommand=None, PreferencesPage=None
	):
	if Property is None:
	self.Property = []
	else:
	self.Property = Property
	if Feature is None:
	self.Feature = []
	else:
	self.Feature = Feature
	if DocObject is None:
	self.DocObject = []
	else:
	self.DocObject = DocObject
	if GuiCommand is None:
	self.GuiCommand = []
	else:
	self.GuiCommand = GuiCommand
	if PreferencesPage is None:
	self.PreferencesPage = []
	else:
	self.PreferencesPage = PreferencesPage

	def factory(args_, *kwargs_):
	if Content.subclass:
	return Content.subclass(args_, *kwargs_)
	else:
	return Content(args_, *kwargs_)

	factory = staticmethod(factory)

	def getProperty(self):
	return self.Property

	def setProperty(self, Property):
	self.Property = Property

	def addProperty(self, value):
	self.Property.append(value)

	def insertProperty(self, index, value):
	self.Property[index] = value

	def getFeature(self):
	return self.Feature

	def setFeature(self, Feature):
	self.Feature = Feature

	def addFeature(self, value):
	self.Feature.append(value)

	def insertFeature(self, index, value):
	self.Feature[index] = value

	def getDocobject(self):
	return self.DocObject

	def setDocobject(self, DocObject):
	self.DocObject = DocObject

	def addDocobject(self, value):
	self.DocObject.append(value)

	def insertDocobject(self, index, value):
	self.DocObject[index] = value

	def getGuicommand(self):
	return self.GuiCommand

	def setGuicommand(self, GuiCommand):
	self.GuiCommand = GuiCommand

	def addGuicommand(self, value):
	self.GuiCommand.append(value)

	def insertGuicommand(self, index, value):
	self.GuiCommand[index] = value

	def getPreferencespage(self):
	return self.PreferencesPage

	def setPreferencespage(self, PreferencesPage):
	self.PreferencesPage = PreferencesPage

	def addPreferencespage(self, value):
	self.PreferencesPage.append(value)

	def insertPreferencespage(self, index, value):
	self.PreferencesPage[index] = value

	def export(self, outfile, level, name_="Content"):
	showIndent(outfile, level)
	outfile.write("<%s>\n" % name_)
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Content"):
	pass

	def exportChildren(self, outfile, level, name_="Content"):
	for Property_ in self.getProperty():
	Property_.export(outfile, level)
	for Feature_ in self.getFeature():
	Feature_.export(outfile, level)
	for DocObject_ in self.getDocobject():
	DocObject_.export(outfile, level)
	for GuiCommand_ in self.getGuicommand():
	showIndent(outfile, level)
	outfile.write("<GuiCommand>%s</GuiCommand>\n" % quote_xml(GuiCommand_))
	for PreferencesPage_ in self.getPreferencespage():
	showIndent(outfile, level)
	outfile.write("<PreferencesPage>%s</PreferencesPage>\n" % quote_xml(PreferencesPage_))

	def exportLiteral(self, outfile, level, name_="Content"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	pass

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write("Property=[\n")
	level += 1
	for Property in self.Property:
	showIndent(outfile, level)
	outfile.write("Property(\n")
	Property.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("Feature=[\n")
	level += 1
	for Feature in self.Feature:
	showIndent(outfile, level)
	outfile.write("Feature(\n")
	Feature.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("DocObject=[\n")
	level += 1
	for DocObject in self.DocObject:
	showIndent(outfile, level)
	outfile.write("DocObject(\n")
	DocObject.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("GuiCommand=[\n")
	level += 1
	for GuiCommand in self.GuiCommand:
	showIndent(outfile, level)
	outfile.write("%s,\n" % quote_python(GuiCommand))
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	showIndent(outfile, level)
	outfile.write("PreferencesPage=[\n")
	level += 1
	for PreferencesPage in self.PreferencesPage:
	showIndent(outfile, level)
	outfile.write("%s,\n" % quote_python(PreferencesPage))
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	pass

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Property":
	obj_ = Property.factory()
	obj_.build(child_)
	self.Property.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Feature":
	obj_ = Feature.factory()
	obj_.build(child_)
	self.Feature.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "DocObject":
	obj_ = DocObject.factory()
	obj_.build(child_)
	self.DocObject.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "GuiCommand":
	GuiCommand_ = ""
	for text__content_ in child_.childNodes:
	GuiCommand_ += text__content_.nodeValue
	self.GuiCommand.append(GuiCommand_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "PreferencesPage":
	PreferencesPage_ = ""
	for text__content_ in child_.childNodes:
	PreferencesPage_ += text__content_.nodeValue
	self.PreferencesPage.append(PreferencesPage_)


	# end class Content


	class Feature:
	subclass = None

	def __init__(self, Name="", Documentation=None, Property=None, ViewProvider=None):
	self.Name = Name
	self.Documentation = Documentation
	if Property is None:
	self.Property = []
	else:
	self.Property = Property
	self.ViewProvider = ViewProvider

	def factory(args_, *kwargs_):
	if Feature.subclass:
	return Feature.subclass(args_, *kwargs_)
	else:
	return Feature(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getProperty(self):
	return self.Property

	def setProperty(self, Property):
	self.Property = Property

	def addProperty(self, value):
	self.Property.append(value)

	def insertProperty(self, index, value):
	self.Property[index] = value

	def getViewprovider(self):
	return self.ViewProvider

	def setViewprovider(self, ViewProvider):
	self.ViewProvider = ViewProvider

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def export(self, outfile, level, name_="Feature"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Feature")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Feature"):
	outfile.write(' Name="%s"' % (self.getName(),))

	def exportChildren(self, outfile, level, name_="Feature"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	for Property_ in self.getProperty():
	Property_.export(outfile, level)
	if self.ViewProvider:
	self.ViewProvider.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Feature"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("Property=[\n")
	level += 1
	for Property in self.Property:
	showIndent(outfile, level)
	outfile.write("Property(\n")
	Property.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")
	if self.ViewProvider:
	showIndent(outfile, level)
	outfile.write("ViewProvider=ViewProvider(\n")
	self.ViewProvider.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Property":
	obj_ = Property.factory()
	obj_.build(child_)
	self.Property.append(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ViewProvider":
	obj_ = ViewProvider.factory()
	obj_.build(child_)
	self.setViewprovider(obj_)


	# end class Feature


	class DocObject:
	subclass = None

	def __init__(self, Name="", Documentation=None, Property=None):
	self.Name = Name
	self.Documentation = Documentation
	if Property is None:
	self.Property = []
	else:
	self.Property = Property

	def factory(args_, *kwargs_):
	if DocObject.subclass:
	return DocObject.subclass(args_, *kwargs_)
	else:
	return DocObject(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getProperty(self):
	return self.Property

	def setProperty(self, Property):
	self.Property = Property

	def addProperty(self, value):
	self.Property.append(value)

	def insertProperty(self, index, value):
	self.Property[index] = value

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def export(self, outfile, level, name_="DocObject"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="DocObject")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="DocObject"):
	outfile.write(' Name="%s"' % (self.getName(),))

	def exportChildren(self, outfile, level, name_="DocObject"):
	if self.Documentation:
	self.Documentation.export(outfile, level)
	for Property_ in self.getProperty():
	Property_.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="DocObject"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("Property=[\n")
	level += 1
	for Property in self.Property:
	showIndent(outfile, level)
	outfile.write("Property(\n")
	Property.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Property":
	obj_ = Property.factory()
	obj_.build(child_)
	self.Property.append(obj_)


	# end class DocObject


	class Property:
	subclass = None

	def __init__(self, Name="", Type="", StartValue="", Documentation=None):
	self.Name = Name
	self.Type = Type
	self.StartValue = StartValue
	self.Documentation = Documentation

	def factory(args_, *kwargs_):
	if Property.subclass:
	return Property.subclass(args_, *kwargs_)
	else:
	return Property(args_, *kwargs_)

	factory = staticmethod(factory)

	def getDocumentation(self):
	return self.Documentation

	def setDocumentation(self, Documentation):
	self.Documentation = Documentation

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getType(self):
	return self.Type

	def setType(self, Type):
	self.Type = Type

	def getStartvalue(self):
	return self.StartValue

	def setStartvalue(self, StartValue):
	self.StartValue = StartValue

	def export(self, outfile, level, name_="Property"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Property")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Property"):
	outfile.write(' Name="%s"' % (self.getName(),))
	outfile.write(' Type="%s"' % (self.getType(),))
	if self.getStartvalue() is not None:
	outfile.write(' StartValue="%s"' % (self.getStartvalue(),))

	def exportChildren(self, outfile, level, name_="Property"):
	if self.Documentation:
	self.Documentation.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="Property"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('Type = "%s",\n' % (self.getType(),))
	showIndent(outfile, level)
	outfile.write('StartValue = "%s",\n' % (self.getStartvalue(),))

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Documentation:
	showIndent(outfile, level)
	outfile.write("Documentation=Documentation(\n")
	self.Documentation.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("Type"):
	self.Type = attrs.get("Type").value
	if attrs.get("StartValue"):
	self.StartValue = attrs.get("StartValue").value

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Documentation":
	obj_ = Documentation.factory()
	obj_.build(child_)
	self.setDocumentation(obj_)


	# end class Property


	class Documentation:
	subclass = None

	def __init__(self, Author=None, DeveloperDocu="", UserDocu=""):
	self.Author = Author
	self.DeveloperDocu = DeveloperDocu
	self.UserDocu = UserDocu

	def factory(args_, *kwargs_):
	if Documentation.subclass:
	return Documentation.subclass(args_, *kwargs_)
	else:
	return Documentation(args_, *kwargs_)

	factory = staticmethod(factory)

	def getAuthor(self):
	return self.Author

	def setAuthor(self, Author):
	self.Author = Author

	def getDeveloperdocu(self):
	return self.DeveloperDocu

	def setDeveloperdocu(self, DeveloperDocu):
	self.DeveloperDocu = DeveloperDocu

	def getUserdocu(self):
	return self.UserDocu

	def setUserdocu(self, UserDocu):
	self.UserDocu = UserDocu

	def export(self, outfile, level, name_="Documentation"):
	showIndent(outfile, level)
	outfile.write("<%s>\n" % name_)
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Documentation"):
	pass

	def exportChildren(self, outfile, level, name_="Documentation"):
	if self.Author:
	self.Author.export(outfile, level)
	showIndent(outfile, level)
	outfile.write("<DeveloperDocu>%s</DeveloperDocu>\n" % quote_xml(self.getDeveloperdocu()))
	showIndent(outfile, level)
	outfile.write("<UserDocu>%s</UserDocu>\n" % quote_xml(self.getUserdocu()))

	def exportLiteral(self, outfile, level, name_="Documentation"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	pass

	def exportLiteralChildren(self, outfile, level, name_):
	if self.Author:
	showIndent(outfile, level)
	outfile.write("Author=Author(\n")
	self.Author.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	showIndent(outfile, level)
	outfile.write("DeveloperDocu=%s,\n" % quote_python(self.getDeveloperdocu()))
	showIndent(outfile, level)
	outfile.write("UserDocu=%s,\n" % quote_python(self.getUserdocu()))

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	pass

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Author":
	obj_ = Author.factory()
	obj_.build(child_)
	self.setAuthor(obj_)
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "DeveloperDocu":
	DeveloperDocu_ = ""
	for text__content_ in child_.childNodes:
	DeveloperDocu_ += text__content_.nodeValue
	self.DeveloperDocu = DeveloperDocu_
	elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "UserDocu":
	UserDocu_ = ""
	for text__content_ in child_.childNodes:
	UserDocu_ += text__content_.nodeValue
	self.UserDocu = UserDocu_


	# end class Documentation


	class Author:
	subclass = None

	def __init__(self, Name="", EMail="", Licence="", valueOf_=""):
	self.Name = Name
	self.EMail = EMail
	self.Licence = Licence
	self.valueOf_ = valueOf_

	def factory(args_, *kwargs_):
	if Author.subclass:
	return Author.subclass(args_, *kwargs_)
	else:
	return Author(args_, *kwargs_)

	factory = staticmethod(factory)

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getEmail(self):
	return self.EMail

	def setEmail(self, EMail):
	self.EMail = EMail

	def getLicence(self):
	return self.Licence

	def setLicence(self, Licence):
	self.Licence = Licence

	def getValueOf_(self):
	return self.valueOf_

	def setValueOf_(self, valueOf_):
	self.valueOf_ = valueOf_

	def export(self, outfile, level, name_="Author"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Author")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Author"):
	outfile.write(' Name="%s"' % (self.getName(),))
	outfile.write(' EMail="%s"' % (self.getEmail(),))
	if self.getLicence() is not None:
	outfile.write(' Licence="%s"' % (self.getLicence(),))

	def exportChildren(self, outfile, level, name_="Author"):
	outfile.write(self.valueOf_)

	def exportLiteral(self, outfile, level, name_="Author"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('EMail = "%s",\n' % (self.getEmail(),))
	showIndent(outfile, level)
	outfile.write('Licence = "%s",\n' % (self.getLicence(),))

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("EMail"):
	self.EMail = attrs.get("EMail").value
	if attrs.get("Licence"):
	self.Licence = attrs.get("Licence").value

	def buildChildren(self, child_, nodeName_):
	self.valueOf_ = ""
	for child in child_.childNodes:
	if child.nodeType == Node.TEXT_NODE:
	self.valueOf_ += child.nodeValue


	# end class Author


	class ViewProvider:
	subclass = None

	def __init__(self, Property=None):
	if Property is None:
	self.Property = []
	else:
	self.Property = Property

	def factory(args_, *kwargs_):
	if ViewProvider.subclass:
	return ViewProvider.subclass(args_, *kwargs_)
	else:
	return ViewProvider(args_, *kwargs_)

	factory = staticmethod(factory)

	def getProperty(self):
	return self.Property

	def setProperty(self, Property):
	self.Property = Property

	def addProperty(self, value):
	self.Property.append(value)

	def insertProperty(self, index, value):
	self.Property[index] = value

	def export(self, outfile, level, name_="ViewProvider"):
	showIndent(outfile, level)
	outfile.write("<%s>\n" % name_)
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="ViewProvider"):
	pass

	def exportChildren(self, outfile, level, name_="ViewProvider"):
	for Property_ in self.getProperty():
	Property_.export(outfile, level)

	def exportLiteral(self, outfile, level, name_="ViewProvider"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	pass

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write("Property=[\n")
	level += 1
	for Property in self.Property:
	showIndent(outfile, level)
	outfile.write("Property(\n")
	Property.exportLiteral(outfile, level)
	showIndent(outfile, level)
	outfile.write("),\n")
	level -= 1
	showIndent(outfile, level)
	outfile.write("],\n")

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	pass

	def buildChildren(self, child_, nodeName_):
	if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "Property":
	obj_ = Property.factory()
	obj_.build(child_)
	self.Property.append(obj_)


	# end class ViewProvider


	class Parameter:
	subclass = None

	def __init__(self, Name="", Type="", valueOf_=""):
	self.Name = Name
	self.Type = Type
	self.valueOf_ = valueOf_

	def factory(args_, *kwargs_):
	if Parameter.subclass:
	return Parameter.subclass(args_, *kwargs_)
	else:
	return Parameter(args_, *kwargs_)

	factory = staticmethod(factory)

	def getName(self):
	return self.Name

	def setName(self, Name):
	self.Name = Name

	def getType(self):
	return self.Type

	def setType(self, Type):
	self.Type = Type

	def getValueOf_(self):
	return self.valueOf_

	def setValueOf_(self, valueOf_):
	self.valueOf_ = valueOf_

	def export(self, outfile, level, name_="Parameter"):
	showIndent(outfile, level)
	outfile.write("<%s" % (name_,))
	self.exportAttributes(outfile, level, name_="Parameter")
	outfile.write(">\n")
	self.exportChildren(outfile, level + 1, name_)
	showIndent(outfile, level)
	outfile.write("</%s>\n" % name_)

	def exportAttributes(self, outfile, level, name_="Parameter"):
	outfile.write(' Name="%s"' % (self.getName(),))
	outfile.write(' Type="%s"' % (self.getType(),))

	def exportChildren(self, outfile, level, name_="Parameter"):
	outfile.write(self.valueOf_)

	def exportLiteral(self, outfile, level, name_="Parameter"):
	level += 1
	self.exportLiteralAttributes(outfile, level, name_)
	self.exportLiteralChildren(outfile, level, name_)

	def exportLiteralAttributes(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('Name = "%s",\n' % (self.getName(),))
	showIndent(outfile, level)
	outfile.write('Type = "%s",\n' % (self.getType(),))

	def exportLiteralChildren(self, outfile, level, name_):
	showIndent(outfile, level)
	outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

	def build(self, node_):
	attrs = node_.attributes
	self.buildAttributes(attrs)
	for child_ in node_.childNodes:
	nodeName_ = child_.nodeName.split(":")[-1]
	self.buildChildren(child_, nodeName_)

	def buildAttributes(self, attrs):
	if attrs.get("Name"):
	self.Name = attrs.get("Name").value
	if attrs.get("Type"):
	self.Type = attrs.get("Type").value

	def buildChildren(self, child_, nodeName_):
	self.valueOf_ = ""
	for child in child_.childNodes:
	if child.nodeType == Node.TEXT_NODE:
	self.valueOf_ += child.nodeValue


	# end class Parameter


	from xml.sax import handler, make_parser


	class SaxStackElement:
	def __init__(self, name="", obj=None):
	self.name = name
	self.obj = obj
	self.content = ""


	#
	# SAX handler
	#
	class SaxGeneratemodelHandler(handler.ContentHandler):
	def __init__(self):
	self.stack = []
	self.root = None

	def getRoot(self):
	return self.root

	def setDocumentLocator(self, locator):
	self.locator = locator

	def showError(self, msg):
	print("*** (showError):", msg)
	sys.exit(-1)

	def startElement(self, name, attrs):
	done = 0
	if name == "GenerateModel":
	obj = GenerateModel.factory()
	stackObj = SaxStackElement("GenerateModel", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Module":
	obj = Module.factory()
	stackObj = SaxStackElement("Module", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "PythonExport":
	obj = PythonExport.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	val = attrs.get("PythonName", None)
	if val is not None:
	obj.setPythonname(val)
	val = attrs.get("Include", None)
	if val is not None:
	obj.setInclude(val)
	val = attrs.get("Father", None)
	if val is not None:
	obj.setFather(val)
	val = attrs.get("Twin", None)
	if val is not None:
	obj.setTwin(val)
	val = attrs.get("Namespace", None)
	if val is not None:
	obj.setNamespace(val)
	val = attrs.get("FatherInclude", None)
	if val is not None:
	obj.setFatherinclude(val)
	val = attrs.get("FatherNamespace", None)
	if val is not None:
	obj.setFathernamespace(val)
	val = attrs.get("Constructor", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setConstructor(1)
	elif val in ("false", "0"):
	obj.setConstructor(0)
	else:
	self.reportError(
	'"Constructor" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("NumberProtocol", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setNumberprotocol(1)
	elif val in ("false", "0"):
	obj.setNumberprotocol(0)
	else:
	self.reportError(
	'"NumberProtocol" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("RichCompare", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setRichcompare(1)
	elif val in ("false", "0"):
	obj.setRichcompare(0)
	else:
	self.reportError(
	'"RichCompare" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("TwinPointer", None)
	if val is not None:
	obj.setTwinpointer(val)
	val = attrs.get("Delete", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setDelete(1)
	elif val in ("false", "0"):
	obj.setDelete(0)
	else:
	self.reportError(
	'"Delete" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("Reference", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setReference(1)
	elif val in ("false", "0"):
	obj.setReference(0)
	else:
	self.reportError(
	'"Reference" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("Initialization", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setInitialization(1)
	elif val in ("false", "0"):
	obj.setInitialization(0)
	else:
	self.reportError(
	'"Initialization" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("DisableNotify", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setDisablenotify(1)
	elif val in ("false", "0"):
	obj.setDisablenotify(0)
	else:
	self.reportError(
	'"DisableNotify" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("DescriptorGetter", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setDescriptorgetter(1)
	elif val in ("false", "0"):
	obj.setDescriptorgetter(0)
	else:
	self.reportError(
	'"DescriptorGetter" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("DescriptorSetter", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setDescriptorsetter(1)
	elif val in ("false", "0"):
	obj.setDescriptorsetter(0)
	else:
	self.reportError(
	'"DescriptorSetter" attribute must be boolean ("true", "1", "false", "0")'
	)
	stackObj = SaxStackElement("PythonExport", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Documentation":
	obj = Documentation.factory()
	stackObj = SaxStackElement("Documentation", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Methode":
	obj = Methode.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	val = attrs.get("Const", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setConst(1)
	elif val in ("false", "0"):
	obj.setConst(0)
	else:
	self.reportError(
	'"Const" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("Keyword", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setKeyword(1)
	elif val in ("false", "0"):
	obj.setKeyword(0)
	else:
	self.reportError(
	'"Keyword" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("NoArgs", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setNoargs(1)
	elif val in ("false", "0"):
	obj.setNoargs(0)
	else:
	self.reportError(
	'"NoArgs" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("Class", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setClass(1)
	elif val in ("false", "0"):
	obj.setClass(0)
	else:
	self.reportError(
	'"Class" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("Static", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setStatic(1)
	elif val in ("false", "0"):
	obj.setStatic(0)
	else:
	self.reportError(
	'"Static" attribute must be boolean ("true", "1", "false", "0")'
	)
	stackObj = SaxStackElement("Methode", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Parameter":
	obj = Parameter.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	val = attrs.get("Type", None)
	if val is not None:
	obj.setType(val)
	stackObj = SaxStackElement("Parameter", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Attribute":
	obj = Attribute.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	val = attrs.get("ReadOnly", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setReadonly(1)
	elif val in ("false", "0"):
	obj.setReadonly(0)
	else:
	self.reportError(
	'"ReadOnly" attribute must be boolean ("true", "1", "false", "0")'
	)
	stackObj = SaxStackElement("Attribute", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Sequence":
	obj = Sequence.factory()
	val = attrs.get("sq_length", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_length(1)
	elif val in ("false", "0"):
	obj.setSq_length(0)
	else:
	self.reportError(
	'"sq_length" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_concat", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_concat(1)
	elif val in ("false", "0"):
	obj.setSq_concat(0)
	else:
	self.reportError(
	'"sq_concat" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_repeat", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_repeat(1)
	elif val in ("false", "0"):
	obj.setSq_repeat(0)
	else:
	self.reportError(
	'"sq_repeat" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_item", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_item(1)
	elif val in ("false", "0"):
	obj.setSq_item(0)
	else:
	self.reportError(
	'"sq_item" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("mp_subscript", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setMp_subscript(1)
	elif val in ("false", "0"):
	obj.setMp_subscript(0)
	else:
	self.reportError(
	'"mp_subscript" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_ass_item", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_ass_item(1)
	elif val in ("false", "0"):
	obj.setSq_ass_item(0)
	else:
	self.reportError(
	'"sq_ass_item" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("mp_ass_subscript", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setMp_ass_subscript(1)
	elif val in ("false", "0"):
	obj.setMp_ass_subscript(0)
	else:
	self.reportError(
	'"mp_ass_subscript" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_contains", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_contains(1)
	elif val in ("false", "0"):
	obj.setSq_contains(0)
	else:
	self.reportError(
	'"sq_contains" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_inplace_concat", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_inplace_concat(1)
	elif val in ("false", "0"):
	obj.setSq_inplace_concat(0)
	else:
	self.reportError(
	'"sq_inplace_concat" attribute must be boolean ("true", "1", "false", "0")'
	)
	val = attrs.get("sq_inplace_repeat", None)
	if val is not None:
	if val in ("true", "1"):
	obj.setSq_inplace_repeat(1)
	elif val in ("false", "0"):
	obj.setSq_inplace_repeat(0)
	else:
	self.reportError(
	'"sq_inplace_repeat" attribute must be boolean ("true", "1", "false", "0")'
	)
	stackObj = SaxStackElement("Sequence", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "CustomAttributes":
	stackObj = SaxStackElement("CustomAttributes", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "ClassDeclarations":
	stackObj = SaxStackElement("ClassDeclarations", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "ForwardDeclarations":
	stackObj = SaxStackElement("ForwardDeclarations", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "Dependencies":
	obj = Dependencies.factory()
	stackObj = SaxStackElement("Dependencies", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Content":
	obj = Content.factory()
	stackObj = SaxStackElement("Content", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Property":
	obj = Property.factory()
	stackObj = SaxStackElement("Property", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "Feature":
	obj = Feature.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	stackObj = SaxStackElement("Feature", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "ViewProvider":
	obj = ViewProvider.factory()
	stackObj = SaxStackElement("ViewProvider", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "DocObject":
	obj = DocObject.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	stackObj = SaxStackElement("DocObject", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "GuiCommand":
	stackObj = SaxStackElement("GuiCommand", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "PreferencesPage":
	stackObj = SaxStackElement("PreferencesPage", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "Author":
	obj = Author.factory()
	val = attrs.get("Name", None)
	if val is not None:
	obj.setName(val)
	val = attrs.get("EMail", None)
	if val is not None:
	obj.setEmail(val)
	val = attrs.get("Licence", None)
	if val is not None:
	obj.setLicence(val)
	stackObj = SaxStackElement("Author", obj)
	self.stack.append(stackObj)
	done = 1
	elif name == "DeveloperDocu":
	stackObj = SaxStackElement("DeveloperDocu", None)
	self.stack.append(stackObj)
	done = 1
	elif name == "UserDocu":
	stackObj = SaxStackElement("UserDocu", None)
	self.stack.append(stackObj)
	done = 1
	if not done:
	self.reportError('"%s" element not allowed here.' % name)

	def endElement(self, name):
	done = 0
	if name == "GenerateModel":
	if len(self.stack) == 1:
	self.root = self.stack[-1].obj
	self.stack.pop()
	done = 1
	elif name == "Module":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addModule(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "PythonExport":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addPythonexport(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Documentation":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setDocumentation(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Methode":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addMethode(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Parameter":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addParameter(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Attribute":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addAttribute(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Sequence":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setSequence(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "CustomAttributes":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.setCustomattributes(content)
	self.stack.pop()
	done = 1
	elif name == "ClassDeclarations":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.setClassdeclarations(content)
	self.stack.pop()
	done = 1
	elif name == "ForwardDeclarations":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.setForwarddeclarations(content)
	self.stack.pop()
	done = 1
	elif name == "Dependencies":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setDependencies(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Content":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setContent(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Property":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addProperty(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "Feature":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addFeature(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "ViewProvider":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setViewprovider(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "DocObject":
	if len(self.stack) >= 2:
	self.stack[-2].obj.addDocobject(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "GuiCommand":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.addGuicommand(content)
	self.stack.pop()
	done = 1
	elif name == "PreferencesPage":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.addPreferencespage(content)
	self.stack.pop()
	done = 1
	elif name == "Author":
	if len(self.stack) >= 2:
	self.stack[-2].obj.setAuthor(self.stack[-1].obj)
	self.stack.pop()
	done = 1
	elif name == "DeveloperDocu":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.setDeveloperdocu(content)
	self.stack.pop()
	done = 1
	elif name == "UserDocu":
	if len(self.stack) >= 2:
	content = self.stack[-1].content
	self.stack[-2].obj.setUserdocu(content)
	self.stack.pop()
	done = 1
	if not done:
	self.reportError('"%s" element not allowed here.' % name)

	def characters(self, chrs, start, end):
	if len(self.stack) > 0:
	self.stack[-1].content += chrs[start:end]

	def reportError(self, mesg):
	locator = self.locator
	sys.stderr.write(
	"Doc: %s Line: %d Column: %d\n"
	% (locator.getSystemId(), locator.getLineNumber(), locator.getColumnNumber() + 1)
	)
	sys.stderr.write(mesg)
	sys.stderr.write("\n")
	sys.exit(-1)
	# raise RuntimeError


	USAGE_TEXT = """
	Usage: python <Parser>.py [ -s ] <in_xml_file>
	Options:
	-s Use the SAX parser, not the minidom parser.
	"""


	def usage():
	print(USAGE_TEXT)
	sys.exit(-1)


	#
	# SAX handler used to determine the top level element.
	#
	class SaxSelectorHandler(handler.ContentHandler):
	def __init__(self):
	self.topElementName = None

	def getTopElementName(self):
	return self.topElementName

	def startElement(self, name, attrs):
	self.topElementName = name
	raise StopIteration


	def parseSelect(inFileName):
	infile = open(inFileName, "r")
	topElementName = None
	parser = make_parser()
	documentHandler = SaxSelectorHandler()
	parser.setContentHandler(documentHandler)
	try:
	try:
	parser.parse(infile)
	except StopIteration:
	topElementName = documentHandler.getTopElementName()
	if topElementName is None:
	raise RuntimeError("no top level element")
	topElementName = topElementName.replace("-", "_").replace(":", "_")
	if topElementName not in globals():
	raise RuntimeError("no class for top element: %s" % topElementName)
	topElement = globals()[topElementName]
	infile.seek(0)
	doc = minidom.parse(infile)
	finally:
	infile.close()
	rootNode = doc.childNodes[0]
	rootObj = topElement.factory()
	rootObj.build(rootNode)
	# Enable Python to collect the space used by the DOM.
	doc = None
	sys.stdout.write('<?xml version="1.0" ?>\n')
	rootObj.export(sys.stdout, 0)
	return rootObj


	def saxParse(inFileName):
	parser = make_parser()
	documentHandler = SaxGeneratemodelHandler()
	parser.setDocumentHandler(documentHandler)
	parser.parse("file:%s" % inFileName)
	root = documentHandler.getRoot()
	sys.stdout.write('<?xml version="1.0" ?>\n')
	root.export(sys.stdout, 0)
	return root


	def saxParseString(inString):
	parser = make_parser()
	documentHandler = SaxGeneratemodelHandler()
	parser.setDocumentHandler(documentHandler)
	parser.feed(inString)
	parser.close()
	rootObj = documentHandler.getRoot()
	# sys.stdout.write('<?xml version="1.0" ?>\n')
	# rootObj.export(sys.stdout, 0)
	return rootObj


	def parse(inFileName):
	doc = minidom.parse(inFileName)
	rootNode = doc.documentElement
	rootObj = GenerateModel.factory()
	rootObj.build(rootNode)
	# Enable Python to collect the space used by the DOM.
	doc = None
	# sys.stdout.write('<?xml version="1.0" ?>\n')
	# rootObj.export(sys.stdout, 0, name_="GenerateModel")
	return rootObj


	def parseString(inString):
	doc = minidom.parseString(inString)
	rootNode = doc.documentElement
	rootObj = GenerateModel.factory()
	rootObj.build(rootNode)
	# Enable Python to collect the space used by the DOM.
	doc = None
	sys.stdout.write('<?xml version="1.0" ?>\n')
	rootObj.export(sys.stdout, 0, name_="GenerateModel")
	return rootObj


	def parseLiteral(inFileName):
	doc = minidom.parse(inFileName)
	rootNode = doc.documentElement
	rootObj = GenerateModel.factory()
	rootObj.build(rootNode)
	# Enable Python to collect the space used by the DOM.
	doc = None
	sys.stdout.write("from generateModel_Module import *\n\n")
	sys.stdout.write("rootObj = GenerateModel(\n")
	rootObj.exportLiteral(sys.stdout, 0, name_="GenerateModel")
	sys.stdout.write(")\n")
	return rootObj


	def main():
	args = sys.argv[1:]
	if len(args) == 2 and args[0] == "-s":
	saxParse(args[1])
	elif len(args) == 1:
	parse(args[0])
	else:
	usage()


	if __name__ == "__main__":
	main()
	# import pdb
	# pdb.run('main()')