コード例 #1
0
    def ToXml(self, Header, BootModes, Events, Hobs, Key):
        if self.ModuleType:
            pass
        AttributeList = [
            ['SupArchList',
             GetStringOfList(Header.GetSupArchList())],
        ]

        NodeList = [
            ['ModuleType', Header.GetModuleType()],
            ['Path', Header.GetModulePath()],
            ['PcdIsDriver', Header.GetPcdIsDriver()],
            ['UefiSpecificationVersion',
             Header.GetUefiSpecificationVersion()],
            ['PiSpecificationVersion',
             Header.GetPiSpecificationVersion()],
        ]
        for Item in Header.GetSpecList():
            Spec, Version = Item
            SpecElem = CreateXmlElement('Specification', Spec, [],
                                        [['Version', Version]])
            NodeList.append(SpecElem)

        for Item in BootModes:
            Tmp = BootModeXml()
            NodeList.append(Tmp.ToXml(Item, 'BootMode'))
        for Item in Events:
            Tmp = EventXml()
            NodeList.append(Tmp.ToXml(Item, 'Event'))
        for Item in Hobs:
            Tmp = HobXml()
            NodeList.append(Tmp.ToXml(Item, 'HOB'))
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #2
0
    def ToXml(self, DistributionPackageHeader, Key):
        if self.Header:
            pass
        Element1 = CreateXmlElement('Name', \
                                    DistributionPackageHeader.GetName(), [], \
                                    [['BaseName', \
                                    DistributionPackageHeader.GetBaseName()]])
        Element2 = CreateXmlElement('GUID', \
                                    DistributionPackageHeader.GetGuid(), [], \
                                    [['Version', \
                                    DistributionPackageHeader.GetVersion()]])
        AttributeList = []
        if DistributionPackageHeader.ReadOnly != '':
            AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])
        if DistributionPackageHeader.RePackage != '':
            AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])

        NodeList = [Element1,
                    Element2,
                    ['Vendor', DistributionPackageHeader.Vendor],
                    ['Date', DistributionPackageHeader.Date],
                    ['Copyright', DistributionPackageHeader.GetCopyright()],
                    ['License', DistributionPackageHeader.GetLicense()],
                    ['Abstract', DistributionPackageHeader.GetAbstract()],
                    ['Description', \
                     DistributionPackageHeader.GetDescription()],
                    ['Signature', DistributionPackageHeader.Signature],
                    ['XmlSpecification', \
                     DistributionPackageHeader.XmlSpecification],
                    ]
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #3
0
ファイル: PcdXml.py プロジェクト: gus33000/mu_basecore
    def ToXml(self, PcdError, Key):
        if self.Expression:
            pass
        AttributeList = []
        NodeList = []
        if PcdError.GetValidValue():
            Element1 = \
            CreateXmlElement('ValidValueList', PcdError.GetValidValue(), [], \
                             [['Lang', PcdError.GetValidValueLang()]])
            NodeList.append(Element1)
        if PcdError.GetValidValueRange():
            TansferedRangeStr = self.TransferValidRange2Expr(
                PcdError.GetTokenSpaceGuidCName(), PcdError.GetCName(),
                PcdError.GetValidValueRange())
            Element1 = \
            CreateXmlElement('ValidValueRange', \
                             TansferedRangeStr, [], [])
            NodeList.append(Element1)
        if PcdError.GetExpression():
            NodeList.append(['Expression', PcdError.GetExpression()])
        if PcdError.GetErrorNumber():
            NodeList.append(['ErrorNumber', PcdError.GetErrorNumber()])
        for Item in PcdError.GetErrorMessageList():
            Element = \
            CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]])
            NodeList.append(Element)
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #4
0
 def ToXml(self, Dict, Key):
     if self.UserExtensionSource:
         pass
     SourcesNodeList = []
     for Item in Dict:
         ValueList = Dict[Item]
         (FileName, Family, FeatureFlag, SupArchStr) = Item
         SourceFileNodeList = []
         SourceFileNodeList.append(["FileName", FileName])
         SourceFileNodeList.append(["Family", Family])
         SourceFileNodeList.append(["FeatureFlag", FeatureFlag])
         SourceFileNodeList.append(["SupArchList", SupArchStr])
         for (TagName, ToolCode, Comment) in ValueList:
             ValueNodeList = []
             if not (TagName or ToolCode or Comment):
                 TagName = ' '
                 ToolCode = ' '
                 Comment = ' '
             ValueNodeList.append(["TagName", TagName])
             ValueNodeList.append(["ToolCode", ToolCode])
             ValueNodeList.append(["Comment", Comment])
             ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \
                                             ValueNodeList, [])
             SourceFileNodeList.append(ValueNodeXml)
         SourceFileNodeXml = CreateXmlElement('SourceFile', '', \
                                              SourceFileNodeList, [])
         SourcesNodeList.append(SourceFileNodeXml)
     Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])
     return Root
コード例 #5
0
 def ToXml(self, Dict, Key):
     if self.UserExtensionBinary:
         pass
     BinariesNodeList = []
     for Item in Dict:
         ValueList = Dict[Item]
         (FileName, FileType, FeatureFlag, SupArch) = Item
         FileNodeList = []
         FileNodeList.append(["FileName", FileName])
         FileNodeList.append(["FileType", FileType])
         FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])
         FileNodeList.append(["SupArchList", SupArch])
         for (Target, Family, TagName, Comment) in ValueList:
             ValueNodeList = []
             if not (Target or Family or TagName or Comment):
                 Target = ' '
                 Family = ' '
                 TagName = ' '
                 Comment = ' '
             ValueNodeList.append(["Target", Target])
             ValueNodeList.append(["Family", Family])
             ValueNodeList.append(["TagName", TagName])
             ValueNodeList.append(["Comment", Comment])
             ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \
                                             ValueNodeList, [])
             FileNodeList.append(ValueNodeXml)
         FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])
         BinariesNodeList.append(FileNodeXml)
     Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])
     return Root
コード例 #6
0
ファイル: IniToXml.py プロジェクト: 380121850/qemu-5.1.0
def CreateToolsXml(Map, Root, Tag):
    #
    # Check if all elements in this section are empty
    #
    for Key in Map:
        if len(Map[Key]) > 0:
            break
    else:
        return

    NodeList = [['Name', Map['Name']],
                ['Copyright', Map['Copyright']],
                ['License', Map['License']],
                ['Abstract', Map['Abstract']],
                ['Description', Map['Description']],
               ]
    HeaderNode = CreateXmlElement('Header', '', NodeList, [])
    NodeList = [HeaderNode]

    for File in Map['FileList']:
        AttrList = []
        for Key in File[1]:
            AttrList.append([Key, File[1][Key]])
        NodeList.append(CreateXmlElement('Filename', File[0], [], AttrList))
    Root.appendChild(CreateXmlElement(Tag, '', NodeList, []))
コード例 #7
0
 def ToXml(self, ClonedFrom, Key):
     if self.GUID:
         pass
     Element1 = CreateXmlElement('GUID', ClonedFrom.GetPackageGuid(), [],
                                 [['Version', ClonedFrom.GetPackageVersion()]])
     AttributeList = []
     NodeList = [Element1]
     Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
     return Root
コード例 #8
0
    def ToXml(self, BinaryFile, Key):
        if self.FileNames:
            pass
        NodeList = []
        FilenameList = BinaryFile.GetFileNameList()
        SupportArch = None
        for Filename in FilenameList:
            Tmp = FilenameXml()
            NodeList.append(Tmp.ToXml(Filename, 'Filename'))
            SupportArch = Filename.SupArchList

        AsBuildList = BinaryFile.GetAsBuiltList()
        PatchPcdValueList = AsBuildList.GetPatchPcdList()
        PcdExList = AsBuildList.GetPcdExList()
        LibGuidVerList = AsBuildList.GetLibraryInstancesList()
        BuildFlagList = AsBuildList.GetBuildFlagsList()

        AsBuiltNodeList = []

        for Pcd in PatchPcdValueList:
            if IsMatchArch(Pcd.SupArchList, SupportArch):
                Tmp = PcdEntryXml()
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))

        for Pcd in PcdExList:
            if IsMatchArch(Pcd.SupArchList, SupportArch):
                Tmp = PcdEntryXml()
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))

        GuiVerElemList = []
        for LibGuidVer in LibGuidVerList:
            if LibGuidVer.GetLibGuid() and IsMatchArch(
                    LibGuidVer.GetSupArchList(), SupportArch):
                GuiVerElem = \
                CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
                GuiVerElemList.append(GuiVerElem)
        if len(GuiVerElemList) > 0:
            LibGuidVerElem = CreateXmlElement('LibraryInstances', '',
                                              GuiVerElemList, [])
            AsBuiltNodeList.append(LibGuidVerElem)

        for BuildFlag in BuildFlagList:
            if IsMatchArch(BuildFlag.GetSupArchList(), SupportArch):
                for Item in BuildFlag.GetAsBuildList():
                    Tmp = BuildFlagXml()
                    Elem = CreateXmlElement('BuildFlags', ''.join(Item), [],
                                            [])
                    AsBuiltNodeList.append(Elem)

        if len(AsBuiltNodeList) > 0:
            Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
            NodeList.append(Element)

        Root = CreateXmlElement('%s' % Key, '', NodeList, [])

        return Root
コード例 #9
0
    def ToXml(self, PackageDependency, Key):
        if self.Guid:
            pass
        AttributeList = [['SupArchList', GetStringOfList(PackageDependency.GetSupArchList())],
                         ['FeatureFlag', ConvertNEToNOTEQ(PackageDependency.GetFeatureFlag())], ]
        Element1 = CreateXmlElement('GUID', PackageDependency.GetGuid(), [],
                                    [['Version', PackageDependency.GetVersion()]])
        NodeList = [['Description', PackageDependency.GetPackage()], Element1, ]
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #10
0
    def ToXml(self, BinaryFile, Key):
        if self.FileNames:
            pass
        NodeList = []
        FilenameList = BinaryFile.GetFileNameList()
        for Filename in FilenameList:
            Tmp = FilenameXml()
            NodeList.append(Tmp.ToXml(Filename, 'Filename'))

        if GlobalData.gIS_BINARY_INF:
            AsBuildList = BinaryFile.GetAsBuiltList()
            PatchPcdValueList = AsBuildList.GetPatchPcdList()
            PcdExList = AsBuildList.GetPcdExList()
            LibGuidVerList = AsBuildList.GetLibraryInstancesList()
            BuildFlagList = AsBuildList.GetBuildFlagsList()

            AsBuiltNodeList = []

            for Pcd in PatchPcdValueList:
                Tmp = PcdEntryXml()
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))

            for Pcd in PcdExList:
                Tmp = PcdEntryXml()
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))

            GuiVerElemList = []
            for LibGuidVer in LibGuidVerList:
                GuiVerElem = \
                CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
                GuiVerElemList.append(GuiVerElem)
            if len(GuiVerElemList) > 0:
                LibGuidVerElem = CreateXmlElement('LibraryInstances', '',
                                                  GuiVerElemList, [])
                AsBuiltNodeList.append(LibGuidVerElem)

            for BuildFlag in BuildFlagList:
                Tmp = BuildFlagXml()
                Elem = CreateXmlElement('BuildFlags', ''.join(BuildFlag), [],
                                        [])
                AsBuiltNodeList.append(Elem)

            if len(AsBuiltNodeList) > 0:
                Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
                NodeList.append(Element)

        Root = CreateXmlElement('%s' % Key, '', NodeList, [])

        return Root
コード例 #11
0
ファイル: PcdXml.py プロジェクト: gus33000/mu_basecore
    def ToXml4(self, PcdEntry, Key):
        if self.PcdCName:
            pass

        DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())

        AttributeList = []

        NodeList = [['TokenSpaceGuidValue',
                     PcdEntry.GetTokenSpaceGuidValue()],
                    ['PcdCName', PcdEntry.GetCName()],
                    ['Token', PcdEntry.GetToken()],
                    ['DatumType', PcdEntry.GetDatumType()],
                    ['MaxDatumSize',
                     PcdEntry.GetMaxDatumSize()], ['Value', DefaultValue],
                    ['Offset', PcdEntry.GetOffset()]]

        for Item in PcdEntry.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item))
        for Item in PcdEntry.GetPcdErrorsList():
            Tmp = PcdErrorXml()
            NodeList.append(Tmp.ToXml(Item, 'PcdError'))

        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #12
0
    def ToXml(self, Header, Key):
        if self.GUID:
            pass
        Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])
        Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])
        AttributeList = []
        NodeList = [Element1,
                    Element2,
                    ['Copyright', Header.GetCopyright()],
                    ['License', Header.GetLicense()],
                    ['Abstract', Header.GetAbstract()],
                    ['Description', Header.GetDescription()],
                    ]
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #13
0
    def ToXml(self, PackageIncludeHeader, Key):
        if self.HeaderFile:
            pass
        AttributeList = [['SupArchList', GetStringOfList(PackageIncludeHeader.GetSupArchList())], \
                         ['SupModList', GetStringOfList(PackageIncludeHeader.GetSupModuleList())], ]

        HeaderFileNode = CreateXmlElement('HeaderFile', PackageIncludeHeader.FilePath, [], AttributeList)

        NodeList = [HeaderFileNode]
        for Item in PackageIncludeHeader.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item))

        Root = CreateXmlElement('%s' % Key, '', NodeList, [])

        return Root
コード例 #14
0
 def ToXml(self, MiscFile, Key):
     if self.Header:
         pass
     if MiscFile:
         if MiscFile.GetAbstract():
             DPAbstract = MiscFile.GetAbstract()[0][1]
         else:
             DPAbstract = ''
         if MiscFile.GetDescription():
             DPDescription = MiscFile.GetDescription()[0][1]
         else:
             DPDescription = ''
         if MiscFile.GetCopyright():
             DPCopyright = MiscFile.GetCopyright()[0][1]
         else:
             DPCopyright = ''
         if MiscFile.GetLicense():
             DPLicense = MiscFile.GetLicense()[0][1]
         else:
             DPLicense = ''
         NodeList = [
             ['Copyright', DPCopyright],
             ['License', DPLicense],
             ['Abstract', DPAbstract],
             ['Description', DPDescription],
         ]
         for File in MiscFile.GetFileList():
             NodeList.append\
             (CreateXmlElement\
              ('Filename', File.GetURI(), [], \
               [['Executable', str(File.GetExecutable()).lower()]]))
         Root = CreateXmlElement('%s' % Key, '', NodeList, [])
         return Root
コード例 #15
0
ファイル: PcdXml.py プロジェクト: gus33000/mu_basecore
    def ToXml3(self, PcdEntry, Key):
        if self.PcdCName:
            pass

        DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())

        AttributeList = \
        [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
         ['PcdUsage', PcdEntry.GetValidUsage()], \
         ['PcdItemType', PcdEntry.GetItemType()], \
         ['FeatureFlag', ConvertNEToNOTEQ(PcdEntry.GetFeatureFlag())],
        ]
        NodeList = [
            ['CName', PcdEntry.GetCName()],
            ['TokenSpaceGuidCName',
             PcdEntry.GetTokenSpaceGuidCName()],
            ['DefaultValue', DefaultValue],
        ]

        for Item in PcdEntry.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item))
        for Item in PcdEntry.GetPcdErrorsList():
            Tmp = PcdErrorXml()
            NodeList.append(Tmp.ToXml(Item, 'PcdError'))

        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #16
0
 def ToXml(self, GuidProtocolPpi, Key):
     if self.Mode == 'Package':
         AttributeList = \
         [['SupArchList', \
           GetStringOfList(GuidProtocolPpi.GetSupArchList())], 
         ]
         NodeList = [['CName', GuidProtocolPpi.GetCName()], 
                     ['GuidValue', GuidProtocolPpi.GetGuid()],
                    ]
     else:
         AttributeList = \
         [['Usage', GetStringOfList(GuidProtocolPpi.GetUsage())], \
          ['Notify', str(GuidProtocolPpi.GetNotify()).lower()], \
          ['SupArchList', \
           GetStringOfList(GuidProtocolPpi.GetSupArchList())], \
           ['FeatureFlag', ConvertNEToNOTEQ(GuidProtocolPpi.GetFeatureFlag())]
         ]
         NodeList = [['CName', GuidProtocolPpi.GetCName()], 
                    ]
     
     for Item in GuidProtocolPpi.GetHelpTextList():
         Tmp = HelpTextXml()
         NodeList.append(Tmp.ToXml(Item))
     Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
     return Root
コード例 #17
0
    def ToXml(self, IndustryStandardHeader, Key):
        if self.HeaderFile:
            pass
        AttributeList = []
        NodeList = [['HeaderFile', IndustryStandardHeader.GetFilePath()]]
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #18
0
 def ToXml(self, SourceFile, Key):
     if self.SourceFile:
         pass
     FeatureFlag = ConvertNEToNOTEQ(SourceFile.GetFeatureFlag())
     AttributeList = [['SupArchList', GetStringOfList(SourceFile.GetSupArchList())],
                      ['Family', SourceFile.GetFamily()],
                      ['FeatureFlag', FeatureFlag], ]
     Root = CreateXmlElement('%s' % Key, SourceFile.GetSourceFile(), [], AttributeList)
     return Root
コード例 #19
0
    def ToXml(self, BuildFlag, Key):
        if self.Target:
            pass
        AttributeList = []
        NodeList = []
        NodeList.append(['BuildFlags', BuildFlag])

        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
        return Root
コード例 #20
0
    def ToXml(self, PackageObject2, Key):
        if self.PackagePath:
            pass
        Element1 = CreateXmlElement('Name', PackageObject2.GetName(), [], \
                         [['BaseName', PackageObject2.GetBaseName()]])
        Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
                                    [['Version', PackageObject2.GetVersion()]])
        NodeList = [Element1, Element2]

        UNIPackageAbrstractList = []
        UNIPackageDescriptionList = []
        # Get Abstract and Description from Uni File
        # if the Uni File exists
        if PackageObject2.UniFileClassObject is not None:
            UniStrDict = PackageObject2.UniFileClassObject.OrderedStringList
            for Lang in UniStrDict:
                for StringDefClassObject in UniStrDict[Lang]:
                    if not StringDefClassObject.StringValue:
                        continue
                    if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_ABSTRACT:
                        UNIPackageAbrstractList.append(
                            (GetLanguageCode1766(Lang),
                             ConvertSpecialUnicodes(
                                 StringDefClassObject.StringValue)))

                    if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_DESCRIPTION:
                        UNIPackageDescriptionList.append(
                            (GetLanguageCode1766(Lang),
                             ConvertSpecialUnicodes(
                                 StringDefClassObject.StringValue)))

        # Get Abstract and Description from DEC File Header
        for (Lang, Value) in PackageObject2.GetCopyright():
            if Value:
                NodeList.append(
                    CreateXmlElement(DataType.TAB_HEADER_COPYRIGHT, Value, [],
                                     []))
        for (Lang, Value) in PackageObject2.GetLicense():
            if Value:
                NodeList.append(
                    CreateXmlElement(DataType.TAB_HEADER_LICENSE, Value, [],
                                     []))
        for (Lang,
             Value) in PackageObject2.GetAbstract() + UNIPackageAbrstractList:
            if Value:
                NodeList.append(
                    CreateXmlElement(DataType.TAB_HEADER_ABSTRACT, Value, [],
                                     [['Lang', Lang]]))
        for (Lang, Value
             ) in PackageObject2.GetDescription() + UNIPackageDescriptionList:
            if Value:
                NodeList.append(
                    CreateXmlElement(DataType.TAB_HEADER_DESCRIPTION, Value,
                                     [], [['Lang', Lang]]))

        NodeList.append(['PackagePath', PackageObject2.GetPackagePath()])
        AttributeList = []
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
        return Root
コード例 #21
0
ファイル: IniToXml.py プロジェクト: 380121850/qemu-5.1.0
def CreateHeaderXml(DistMap, Root):
    Element1 = CreateXmlElement('Name', DistMap['Name'],
                                [], [['BaseName', DistMap['BaseName']]])
    Element2 = CreateXmlElement('GUID', DistMap['GUID'],
                                [], [['Version', DistMap['Version']]])
    AttributeList = [['ReadOnly', DistMap['ReadOnly']],
                     ['RePackage', DistMap['RePackage']]]
    NodeList = [Element1,
                Element2,
                ['Vendor', DistMap['Vendor']],
                ['Date', DistMap['Date']],
                ['Copyright', DistMap['Copyright']],
                ['License', DistMap['License']],
                ['Abstract', DistMap['Abstract']],
                ['Description', DistMap['Description']],
                ['Signature', DistMap['Signature']],
                ['XmlSpecification', DistMap['XmlSpecification']],
                ]
    Root.appendChild(CreateXmlElement('DistributionHeader', '',
                                      NodeList, AttributeList))
コード例 #22
0
    def ToXml(self, PackageObject2, Key):
        if self.PackagePath:
            pass
        Element1 = \
        CreateXmlElement('Name', PackageObject2.GetName(), [], \
                         [['BaseName', PackageObject2.GetBaseName()]])
        Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
                                    [['Version', PackageObject2.GetVersion()]])
        AttributeList = []
        NodeList = [Element1,
                    Element2,
                    ['Copyright', PackageObject2.GetCopyright()],
                    ['License', PackageObject2.GetLicense()],
                    ['Abstract', PackageObject2.GetAbstract()],
                    ['Description', PackageObject2.GetDescription()],
                    ['PackagePath', PackageObject2.GetPackagePath()],
                    ]
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #23
0
    def ToXml(self, Filename, Key):
        if self.Filename:
            pass
        AttributeList = [['SupArchList', \
                          GetStringOfList(Filename.GetSupArchList())],
                         ['FileType', Filename.GetFileType()],
                         ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
                        ]
        Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)

        return Root
コード例 #24
0
    def ToXml(self, BootMode, Key):
        if self.HelpText:
            pass
        AttributeList = [['Usage', BootMode.GetUsage()], ]
        NodeList = [['SupportedBootModes', BootMode.GetSupportedBootModes()]]
        for Item in BootMode.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #25
0
    def ToXml(self, Header, Key):
        if self.GUID:
            pass
        Element1 = CreateXmlElement(
            'Name', Header.GetName(), [],
            [['BaseName', Header.GetBaseName()]])
        Element2 = CreateXmlElement(
            'GUID', Header.GetGuid(), [],
            [['Version', Header.GetVersion()]])
        NodeList = [
            Element1,
            Element2,
        ]

        UNIInfAbstractList = []
        UNIInfDescriptionList = []
        # Get Abstract and Description from Uni File
        # if the Uni File exists
        if Header.UniFileClassObject is not None:
            UniStrDict = Header.UniFileClassObject.OrderedStringList
            for Lang in UniStrDict:
                for StringDefClassObject in UniStrDict[Lang]:
                    if not StringDefClassObject.StringValue:
                        continue
                    if StringDefClassObject.StringName == DataType.TAB_INF_ABSTRACT:
                        UNIInfAbstractList.append(
                            (GetLanguageCode1766(Lang),
                             ConvertSpecialUnicodes(
                                 StringDefClassObject.StringValue)))

                    if StringDefClassObject.StringName == DataType.TAB_INF_DESCRIPTION:
                        UNIInfDescriptionList.append(
                            (GetLanguageCode1766(Lang),
                             ConvertSpecialUnicodes(
                                 StringDefClassObject.StringValue)))

        # Get Abstract and Description from INF File Header
        for (Lang, Value) in Header.GetCopyright():
            if Value:
                NodeList.append(CreateXmlElement('Copyright', Value, [], []))
        for (Lang, Value) in Header.GetLicense():
            if Value:
                NodeList.append(CreateXmlElement('License', Value, [], []))
        for (Lang, Value) in Header.GetAbstract() + UNIInfAbstractList:
            if Value:
                NodeList.append(
                    CreateXmlElement('Abstract', Value, [], [['Lang', Lang]]))
        for (Lang, Value) in Header.GetDescription() + UNIInfDescriptionList:
            if Value:
                NodeList.append(
                    CreateXmlElement('Description', Value, [],
                                     [['Lang', Lang]]))

        AttributeList = []
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
        return Root
コード例 #26
0
ファイル: IniToXml.py プロジェクト: etiago/vbox
def CreateXml(DistMap, ToolsMap, MiscMap, IniFile):    
    Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'],
             ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
            ]
    Root = CreateXmlElement('DistributionPackage', '', [], Attrs)
    CreateHeaderXml(DistMap, Root)
    CreateToolsXml(ToolsMap, Root, 'Tools')
    CreateToolsXml(MiscMap, Root, 'MiscellaneousFiles')

    FileAndExt = IniFile.rsplit('.', 1)
    if len(FileAndExt) > 1:
        FileName = FileAndExt[0] + '.xml'
    else:
        FileName = IniFile + '.xml'
    File = open(FileName, 'w')
    
    try:
        File.write(Root.toprettyxml(indent = '  '))
    finally:
        File.close()
    return FileName
コード例 #27
0
    def ToXml(self, Depex, Key):
        if self.HelpText:
            pass
        AttributeList = [['SupArchList', GetStringOfList(Depex.GetSupArchList())],
                         ['SupModList', Depex.GetModuleType()]]
        NodeList = [['Expression', Depex.GetDepex()]]
        if Depex.GetHelpText():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Depex.GetHelpText(), 'HelpText'))

        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
        return Root
コード例 #28
0
ファイル: IniToXml.py プロジェクト: 380121850/qemu-5.1.0
def CreateXml(DistMap, ToolsMap, MiscMap, IniFile):
    Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'],
             ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
            ]
    Root = CreateXmlElement('DistributionPackage', '', [], Attrs)
    CreateHeaderXml(DistMap, Root)
    CreateToolsXml(ToolsMap, Root, 'Tools')
    CreateToolsXml(MiscMap, Root, 'MiscellaneousFiles')

    FileAndExt = IniFile.rsplit('.', 1)
    if len(FileAndExt) > 1:
        FileName = FileAndExt[0] + '.xml'
    else:
        FileName = IniFile + '.xml'
    File = open(FileName, 'w')

    try:
        File.write(Root.toprettyxml(indent = '  '))
    finally:
        File.close()
    return FileName
コード例 #29
0
    def ToXml(self, Event, Key):
        if self.HelpText:
            pass
        AttributeList = [['EventType', Event.GetEventType()],
                         ['Usage', Event.GetUsage()],
                        ]
        NodeList = []
        for Item in Event.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #30
0
    def ToXml(self, Hob, Key):
        if self.Name:
            pass
        AttributeList = [['HobType', Hob.GetHobType()],
                         ['Usage', Hob.GetUsage()],
                         ['SupArchList', GetStringOfList(Hob.GetSupArchList())], ]
        NodeList = []
        for Item in Hob.GetHelpTextList():
            Tmp = HelpTextXml()
            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)

        return Root
コード例 #31
0
    def ToXml2(self, MiscFile, Key):
        if self.Header:
            pass
        if MiscFile:
            NodeList = [['Name', MiscFile.GetName()],
                        ['Copyright', MiscFile.GetCopyright()],
                        ['License', MiscFile.GetLicense()],
                        ['Abstract', MiscFile.GetAbstract()],
                        ['Description', MiscFile.GetDescription()],
                       ]
            HeaderNode = CreateXmlElement('Header', '', NodeList, [])
            NodeList = [HeaderNode]

            for File in MiscFile.GetFileList():
                NodeList.append\
                (CreateXmlElement\
                 ('Filename', File.GetURI(), [], \
                  [['Executable', str(File.GetExecutable()).lower()], \
                   ['OS', File.GetOS()]]))
            Root = CreateXmlElement('%s' % Key, '', NodeList, [])

            return Root
コード例 #32
0
ファイル: CommonXml.py プロジェクト: binsys/VisualUefi
 def ToXml(self, UserExtension, Key):
     if self.UserId:
         pass
     AttributeList = [['UserId', str(UserExtension.GetUserID())],
                      ['Identifier', str(UserExtension.GetIdentifier())],
                      ['SupArchList', \
                       GetStringOfList(UserExtension.GetSupArchList())],
                     ]
     Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
                                 AttributeList)
     if UserExtension.GetIdentifier() == DataType.TAB_BINARY_HEADER_IDENTIFIER and \
     UserExtension.GetUserID() == DataType.TAB_BINARY_HEADER_USERID:
         for (Lang, Value) in UserExtension.GetBinaryAbstract():
             if Value:
                 ChildElement = CreateXmlElement('BinaryAbstract', Value, [], [['Lang', Lang]])
                 Root.appendChild(ChildElement)
         for (Lang, Value) in UserExtension.GetBinaryDescription():
             if Value:
                 ChildElement = CreateXmlElement('BinaryDescription', Value, [], [['Lang', Lang]])
                 Root.appendChild(ChildElement)
         for (Lang, Value) in UserExtension.GetBinaryCopyright():
             if Value:
                 ChildElement = CreateXmlElement('BinaryCopyright', Value, [], [])
                 Root.appendChild(ChildElement)
         for (Lang, Value) in UserExtension.GetBinaryLicense():
             if Value:
                 ChildElement = CreateXmlElement('BinaryLicense', Value, [], [])
                 Root.appendChild(ChildElement)
                 
     NodeList = []
     DefineDict = UserExtension.GetDefinesDict()
     if DefineDict:
         for Item in DefineDict.keys():
             NodeList.append(CreateXmlElement\
                             ('Statement', Item, [], []))
         DefineElement = CreateXmlElement('Define', '', NodeList, [])
         Root.appendChild(DefineElement)
     NodeList = []
     BuildOptionDict = UserExtension.GetBuildOptionDict()
     if BuildOptionDict:
         for Item in BuildOptionDict.keys():
             NodeList.append(CreateXmlElement\
                             ('Statement', BuildOptionDict[Item], [], \
                              [['SupArchList', Item]]))
         BuildOptionElement = \
         CreateXmlElement('BuildOption', '', NodeList, [])
         Root.appendChild(BuildOptionElement)
     NodeList = []
     IncludesDict = UserExtension.GetIncludesDict()
     if IncludesDict:
         for Item in IncludesDict.keys():
             NodeList.append(CreateXmlElement\
                             ('Statement', Item, [], \
                              [['SupArchList', IncludesDict[Item]]]))
         IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
         Root.appendChild(IncludesElement)
     NodeList = []
     SourcesDict = UserExtension.GetSourcesDict()
     if SourcesDict:
         Tmp = UserExtensionSourceXml()
         Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))
     NodeList = []
     BinariesDict = UserExtension.GetBinariesDict()
     if BinariesDict:
         Tmp = UserExtensionBinaryXml()
         Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))
     return Root
コード例 #33
0
ファイル: ModuleSurfaceAreaXml.py プロジェクト: MattDevo/edk2
    def ToXml(self, Module):
        if self.Package:
            pass
        #
        # Create root node of module surface area
        #
        DomModule = minidom.Document().createElement('ModuleSurfaceArea')
        if Module.GetBinaryModule():
            DomModule.setAttribute('BinaryModule', 'true')

        #
        # Header
        #
        Tmp = HeaderXml()
        DomModule.appendChild(Tmp.ToXml(Module, 'Header'))
        #
        # ModuleProperties
        #
        Tmp = ModulePropertyXml()
        DomModule.appendChild(Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), \
                                        'ModuleProperties'))
        #
        # ClonedFrom
        #
        Tmp = ClonedFromXml()
        if Module.GetClonedFrom():
            DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), 'ClonedFrom'))
        #
        # LibraryClass
        #
        LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
        for LibraryClass in Module.GetLibraryClassList():
            Tmp = LibraryClassXml()
            LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, 'LibraryClass'))
        DomModule.appendChild(LibraryClassNode)
        #
        # SourceFile
        #
        SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
        for SourceFile in Module.GetSourceFileList():
            Tmp = SourceFileXml()
            SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename'))
        DomModule.appendChild(SourceFileNode)
        #
        # BinaryFile
        #
        BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
        for BinaryFile in Module.GetBinaryFileList():
            Tmp = BinaryFileXml()
            BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile'))
        DomModule.appendChild(BinaryFileNode)
        #
        # PackageDependencies
        #
        PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
        for PackageDependency in Module.GetPackageDependencyList():
            Tmp = PackageXml()
            PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package'))
        DomModule.appendChild(PackageDependencyNode)

        #
        # Guid
        #
        GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
        for GuidProtocolPpi in Module.GetGuidList():
            Tmp = GuidXml('Module')
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName'))
        DomModule.appendChild(GuidProtocolPpiNode)

        #
        # Protocol
        #
        GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
        for GuidProtocolPpi in Module.GetProtocolList():
            Tmp = ProtocolXml('Module')
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol'))
        DomModule.appendChild(GuidProtocolPpiNode)

        #
        # Ppi
        #
        GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
        for GuidProtocolPpi in Module.GetPpiList():
            Tmp = PpiXml('Module')
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi'))
        DomModule.appendChild(GuidProtocolPpiNode)
        #
        # Extern
        #
        ExternNode = CreateXmlElement('Externs', '', [], [])
        for Extern in Module.GetExternList():
            Tmp = ExternXml()
            ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern'))
        DomModule.appendChild(ExternNode)
        #
        # PcdCoded
        #
        PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
        for PcdEntry in Module.GetPcdList():
            Tmp = PcdEntryXml()
            PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, 'PcdEntry'))
        DomModule.appendChild(PcdEntryNode)

        #
        # PeiDepex
        #
        if Module.GetPeiDepex():
            for Item in Module.GetPeiDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, 'PeiDepex'))

        #
        # DxeDepex
        #
        if Module.GetDxeDepex():
            for Item in Module.GetDxeDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, 'DxeDepex'))

        #
        # SmmDepex
        #
        if Module.GetSmmDepex():
            for Item in Module.GetSmmDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, 'SmmDepex'))

        #
        # MiscellaneousFile
        #
        if Module.GetMiscFileList():
            Tmp = MiscellaneousFileXml()
            DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], 'MiscellaneousFiles'))
        #
        # UserExtensions
        #
        if Module.GetUserExtensionList():
            for UserExtension in Module.GetUserExtensionList():
                Tmp = UserExtensionsXml()
                DomModule.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))

        return DomModule
コード例 #34
0
    def ToXml(self, Module):
        if self.Package:
            pass
        #
        # Create root node of module surface area
        #
        DomModule = minidom.Document().createElement("ModuleSurfaceArea")
        if Module.GetBinaryModule():
            DomModule.setAttribute("BinaryModule", "true")

        #
        # Header
        #
        Tmp = HeaderXml()
        DomModule.appendChild(Tmp.ToXml(Module, "Header"))
        #
        # ModuleProperties
        #
        Tmp = ModulePropertyXml()
        DomModule.appendChild(
            Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), "ModuleProperties")
        )
        #
        # ClonedFrom
        #
        Tmp = ClonedFromXml()
        if Module.GetClonedFrom():
            DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), "ClonedFrom"))
        #
        # LibraryClass
        #
        LibraryClassNode = CreateXmlElement("LibraryClassDefinitions", "", [], [])
        for LibraryClass in Module.GetLibraryClassList():
            Tmp = LibraryClassXml()
            LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, "LibraryClass"))
        DomModule.appendChild(LibraryClassNode)
        #
        # SourceFile
        #
        SourceFileNode = CreateXmlElement("SourceFiles", "", [], [])
        for SourceFile in Module.GetSourceFileList():
            Tmp = SourceFileXml()
            SourceFileNode.appendChild(Tmp.ToXml(SourceFile, "Filename"))
        DomModule.appendChild(SourceFileNode)
        #
        # BinaryFile
        #
        BinaryFileNode = CreateXmlElement("BinaryFiles", "", [], [])
        for BinaryFile in Module.GetBinaryFileList():
            Tmp = BinaryFileXml()
            BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, "BinaryFile"))
        DomModule.appendChild(BinaryFileNode)
        #
        # PackageDependencies
        #
        PackageDependencyNode = CreateXmlElement("PackageDependencies", "", [], [])
        for PackageDependency in Module.GetPackageDependencyList():
            Tmp = PackageXml()
            PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, "Package"))
        DomModule.appendChild(PackageDependencyNode)

        #
        # Guid
        #
        GuidProtocolPpiNode = CreateXmlElement("Guids", "", [], [])
        for GuidProtocolPpi in Module.GetGuidList():
            Tmp = GuidXml("Module")
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, "GuidCName"))
        DomModule.appendChild(GuidProtocolPpiNode)

        #
        # Protocol
        #
        GuidProtocolPpiNode = CreateXmlElement("Protocols", "", [], [])
        for GuidProtocolPpi in Module.GetProtocolList():
            Tmp = ProtocolXml("Module")
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, "Protocol"))
        DomModule.appendChild(GuidProtocolPpiNode)

        #
        # Ppi
        #
        GuidProtocolPpiNode = CreateXmlElement("PPIs", "", [], [])
        for GuidProtocolPpi in Module.GetPpiList():
            Tmp = PpiXml("Module")
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, "Ppi"))
        DomModule.appendChild(GuidProtocolPpiNode)
        #
        # Extern
        #
        ExternNode = CreateXmlElement("Externs", "", [], [])
        for Extern in Module.GetExternList():
            Tmp = ExternXml()
            ExternNode.appendChild(Tmp.ToXml(Extern, "Extern"))
        DomModule.appendChild(ExternNode)
        #
        # PcdCoded
        #
        PcdEntryNode = CreateXmlElement("PcdCoded", "", [], [])
        for PcdEntry in Module.GetPcdList():
            Tmp = PcdEntryXml()
            PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, "PcdEntry"))
        DomModule.appendChild(PcdEntryNode)

        #
        # PeiDepex
        #
        if Module.GetPeiDepex():
            for Item in Module.GetPeiDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, "PeiDepex"))

        #
        # DxeDepex
        #
        if Module.GetDxeDepex():
            for Item in Module.GetDxeDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, "DxeDepex"))

        #
        # SmmDepex
        #
        if Module.GetSmmDepex():
            for Item in Module.GetSmmDepex():
                Tmp = DepexXml()
                DomModule.appendChild(Tmp.ToXml(Item, "SmmDepex"))

        #
        # MiscellaneousFile
        #
        if Module.GetMiscFileList():
            Tmp = MiscellaneousFileXml()
            DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], "MiscellaneousFiles"))
        #
        # UserExtensions
        #
        if Module.GetUserExtensionList():
            for UserExtension in Module.GetUserExtensionList():
                Tmp = UserExtensionsXml()
                DomModule.appendChild(Tmp.ToXml(UserExtension, "UserExtensions"))

        return DomModule
コード例 #35
0
    def ToXml(self, UserExtension, Key):
        if self.UserId:
            pass

        AttributeList = [['UserId', str(UserExtension.GetUserID())],
                         ['Identifier', str(UserExtension.GetIdentifier())],
                         ['SupArchList', \
                          GetStringOfList(UserExtension.GetSupArchList())],
                        ]

        Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
                                AttributeList)

        NodeList = []
        DefineDict = UserExtension.GetDefinesDict()
        if DefineDict:
            for Item in DefineDict.keys():
                NodeList.append(CreateXmlElement\
                                ('Statement', Item, [], []))
            DefineElement = CreateXmlElement('Define', '', NodeList, [])
            Root.appendChild(DefineElement)

        NodeList = []
        BuildOptionDict = UserExtension.GetBuildOptionDict()
        if BuildOptionDict:
            for Item in BuildOptionDict.keys():
                NodeList.append(CreateXmlElement\
                                ('Statement', BuildOptionDict[Item], [], \
                                 [['SupArchList', Item]]))
            BuildOptionElement = \
            CreateXmlElement('BuildOption', '', NodeList, [])
            Root.appendChild(BuildOptionElement)

        NodeList = []
        IncludesDict = UserExtension.GetIncludesDict()
        if IncludesDict:
            for Item in IncludesDict.keys():
                NodeList.append(CreateXmlElement\
                                ('Statement', Item, [], \
                                 [['SupArchList', IncludesDict[Item]]]))
            IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
            Root.appendChild(IncludesElement)

        NodeList = []
        SourcesDict = UserExtension.GetSourcesDict()
        if SourcesDict:
            Tmp = UserExtensionSourceXml()
            Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))

        NodeList = []
        BinariesDict = UserExtension.GetBinariesDict()
        if BinariesDict:
            Tmp = UserExtensionBinaryXml()
            Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))

        return Root
コード例 #36
0
    def ToXml(self, Package):
        if self.Package:
            pass
        #
        # Create PackageSurfaceArea node
        #
        DomPackage = minidom.Document().createElement('PackageSurfaceArea')
        #
        # Header
        #
        Tmp = PackageHeaderXml()
        DomPackage.appendChild(Tmp.ToXml(Package, 'Header'))
        #
        # ClonedFrom
        #
        Tmp = ClonedFromXml()
        if Package.GetClonedFromList() != []:
            DomPackage.appendChild(Tmp.ToXml(Package.GetClonedFromList[0], 'ClonedFrom'))
        #
        # LibraryClass
        #
        LibraryClassNode = CreateXmlElement('LibraryClassDeclarations', '', [], [])
        for LibraryClass in Package.GetLibraryClassList():
            Tmp = LibraryClassXml()
            LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass'))
        DomPackage.appendChild(LibraryClassNode)
        #
        # IndustryStandardHeader
        #
        IndustryStandardHeaderNode = CreateXmlElement('IndustryStandardIncludes', '', [], [])
        for Include in Package.GetStandardIncludeFileList():
            Tmp = IndustryStandardHeaderXml()
            IndustryStandardHeaderNode.appendChild(Tmp.ToXml(Include, 'IndustryStandardHeader'))
        DomPackage.appendChild(IndustryStandardHeaderNode)
        #
        # PackageHeader
        #
        PackageIncludeHeaderNode = CreateXmlElement('PackageIncludes', '', [], [])
        for Include in Package.GetPackageIncludeFileList():
            Tmp = PackageIncludeHeaderXml()
            PackageIncludeHeaderNode.appendChild(Tmp.ToXml(Include, 'PackageHeader'))
        DomPackage.appendChild(PackageIncludeHeaderNode)
        ModuleNode = CreateXmlElement('Modules', '', [], [])
        for Module in Package.GetModuleDict().values():
            Tmp = ModuleSurfaceAreaXml()
            ModuleNode.appendChild(Tmp.ToXml(Module))
        DomPackage.appendChild(ModuleNode)
        #
        # Guid
        #
        GuidProtocolPpiNode = CreateXmlElement('GuidDeclarations', '', [], [])
        for GuidProtocolPpi in Package.GetGuidList():
            Tmp = GuidXml('Package')
            GuidProtocolPpiNode.appendChild(Tmp.ToXml\
                                            (GuidProtocolPpi, 'Entry'))
        DomPackage.appendChild(GuidProtocolPpiNode)
        #
        # Protocol
        #
        GuidProtocolPpiNode = \
        CreateXmlElement('ProtocolDeclarations', '', [], [])
        for GuidProtocolPpi in Package.GetProtocolList():
            Tmp = ProtocolXml('Package')
            GuidProtocolPpiNode.appendChild\
            (Tmp.ToXml(GuidProtocolPpi, 'Entry'))
        DomPackage.appendChild(GuidProtocolPpiNode)
        #
        # Ppi
        #
        GuidProtocolPpiNode = CreateXmlElement('PpiDeclarations', '', [], [])
        for GuidProtocolPpi in Package.GetPpiList():
            Tmp = PpiXml('Package')
            GuidProtocolPpiNode.appendChild\
            (Tmp.ToXml(GuidProtocolPpi, 'Entry'))
        DomPackage.appendChild(GuidProtocolPpiNode)
        #
        # PcdEntry
        #
        PcdEntryNode = CreateXmlElement('PcdDeclarations', '', [], [])
        for PcdEntry in Package.GetPcdList():
            Tmp = PcdEntryXml()
            PcdEntryNode.appendChild(Tmp.ToXml2(PcdEntry, 'PcdEntry'))
        DomPackage.appendChild(PcdEntryNode)

        #
        # MiscellaneousFile
        #
        Tmp = MiscellaneousFileXml()
        if Package.GetMiscFileList():
            DomPackage.appendChild(Tmp.ToXml(Package.GetMiscFileList()[0], 'MiscellaneousFiles'))

        #
        # UserExtensions
        #
        if Package.GetUserExtensionList():
            for UserExtension in Package.GetUserExtensionList():
                Tmp = UserExtensionsXml()
                DomPackage.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))

        return DomPackage
コード例 #37
0
ファイル: XmlParser.py プロジェクト: MattDevo/edk2
    def ToXml(self, DistP):
        if self.DistP:
            pass
        if DistP is not None:
            #
            # Parse DistributionPackageHeader
            #
            Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'],
                     ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
                     ]
            Root = CreateXmlElement('DistributionPackage', '', [], Attrs)

            Tmp = DistributionPackageHeaderXml()
            Root.appendChild(Tmp.ToXml(DistP.Header, 'DistributionHeader'))
            #
            # Parse each PackageSurfaceArea
            #
            for Package in DistP.PackageSurfaceArea.values():
                Psa = PackageSurfaceAreaXml()
                DomPackage = Psa.ToXml(Package)
                Root.appendChild(DomPackage)
            #
            # Parse each ModuleSurfaceArea
            #
            for Module in DistP.ModuleSurfaceArea.values():
                Msa = ModuleSurfaceAreaXml()
                DomModule = Msa.ToXml(Module)
                Root.appendChild(DomModule)
            #
            # Parse Tools
            #
            Tmp = MiscellaneousFileXml()
            ToolNode = Tmp.ToXml2(DistP.Tools, 'Tools')
            if ToolNode is not None:
                Root.appendChild(ToolNode)
            #
            # Parse MiscFiles
            #
            Tmp = MiscellaneousFileXml()
            MiscFileNode = Tmp.ToXml2(DistP.MiscellaneousFiles,
                                      'MiscellaneousFiles')
            if MiscFileNode is not None:
                Root.appendChild(MiscFileNode)

            XmlContent = Root.toprettyxml(indent='  ')


            #
            # Remove empty element
            #
            XmlContent = re.sub(r'[\s\r\n]*<[^<>=]*/>', '', XmlContent)

            #
            # Remove empty help text element
            #
            XmlContent = re.sub(r'[\s\r\n]*<HelpText Lang="en-US"/>', '',
                                XmlContent)

            #
            # Remove SupArchList="COMMON" or "common"
            #
            XmlContent = \
            re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON'
            '[\s\r\n]*"', '', XmlContent)
            XmlContent = \
            re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common'
            '[\s\r\n]*"', '', XmlContent)
            #
            # Remove <SupArchList> COMMON </SupArchList>
            #
            XmlContent = \
            re.sub(r'[\s\r\n]*<SupArchList>[\s\r\n]*COMMON[\s\r\n]*'
            '</SupArchList>[\s\r\n]*', '', XmlContent)

            #
            # Remove <SupArchList> common </SupArchList>
            #
            XmlContent = \
            re.sub(r'[\s\r\n]*<SupArchList>[\s\r\n]*'
            'common[\s\r\n]*</SupArchList>[\s\r\n]*', '', XmlContent)

            #
            # Remove SupModList="COMMON" or "common"
            #
            XmlContent = \
            re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON'
            '[\s\r\n]*"', '', XmlContent)
            XmlContent = \
            re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common'
            '[\s\r\n]*"', '', XmlContent)

            return XmlContent

        return ''