#!/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(' -- 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" % (self.name, self.value, self.name)) elif ( self.content_type == MixedContainer.TypeInteger or self.content_type == MixedContainer.TypeBoolean ): outfile.write("<%s>%d" % (self.name, self.value, self.name)) elif ( self.content_type == MixedContainer.TypeFloat or self.content_type == MixedContainer.TypeDecimal ): outfile.write("<%s>%f" % (self.name, self.value, self.name)) elif self.content_type == MixedContainer.TypeDouble: outfile.write("<%s>%g" % (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("\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("\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( "%s\n" % quote_xml(self.getCustomattributes()) ) showIndent(outfile, level) outfile.write( "%s\n" % quote_xml(self.getClassdeclarations()) ) showIndent(outfile, level) outfile.write( "%s\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("\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("\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("\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("\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("\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("\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("%s\n" % quote_xml(GuiCommand_)) for PreferencesPage_ in self.getPreferencespage(): showIndent(outfile, level) outfile.write("%s\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("\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("\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("\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("\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("%s\n" % quote_xml(self.getDeveloperdocu())) showIndent(outfile, level) outfile.write("%s\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("\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("\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("\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 .py [ -s ] 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('\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('\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('\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('\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('\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()')