mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-12 14:36:56 +01:00
998 lines
43 KiB
Python
998 lines
43 KiB
Python
## @file
|
|
# This file is used to parse a PCD file of .PKG file
|
|
#
|
|
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
'''
|
|
CommonXml
|
|
'''
|
|
|
|
##
|
|
# Import Modules
|
|
#
|
|
|
|
from Core.DistributionPackageClass import DistributionPackageHeaderObject
|
|
from Library.StringUtils import ConvertNEToNOTEQ
|
|
from Library.StringUtils import ConvertNOTEQToNE
|
|
from Library.StringUtils import GetSplitValueList
|
|
from Library.StringUtils import GetStringOfList
|
|
from Library.Xml.XmlRoutines import XmlElement
|
|
from Library.Xml.XmlRoutines import XmlElement2
|
|
from Library.Xml.XmlRoutines import XmlAttribute
|
|
from Library.Xml.XmlRoutines import XmlNode
|
|
from Library.Xml.XmlRoutines import XmlList
|
|
from Library.Xml.XmlRoutines import CreateXmlElement
|
|
from Library.UniClassObject import ConvertSpecialUnicodes
|
|
from Library.UniClassObject import GetLanguageCode1766
|
|
from Object.POM.CommonObject import FileObject
|
|
from Object.POM.CommonObject import MiscFileObject
|
|
from Object.POM.CommonObject import UserExtensionObject
|
|
from Object.POM.CommonObject import ClonedRecordObject
|
|
from Object.POM.CommonObject import LibraryClassObject
|
|
from Object.POM.CommonObject import FileNameObject
|
|
from Object.POM.ModuleObject import ModuleObject
|
|
from Xml.XmlParserMisc import IsRequiredItemListNull
|
|
from Xml.XmlParserMisc import GetHelpTextList
|
|
import Library.DataType as DataType
|
|
|
|
##
|
|
# ClonedFromXml
|
|
#
|
|
class ClonedFromXml(object):
|
|
def __init__(self):
|
|
self.GUID = ''
|
|
self.Version = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
self.GUID = XmlElement(Item, '%s/GUID' % Key)
|
|
self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
|
|
if self.GUID == '' and self.Version == '':
|
|
return None
|
|
ClonedFrom = ClonedRecordObject()
|
|
ClonedFrom.SetPackageGuid(self.GUID)
|
|
ClonedFrom.SetPackageVersion(self.Version)
|
|
return ClonedFrom
|
|
|
|
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
|
|
|
|
def __str__(self):
|
|
return "GUID = %s Version = %s" % (self.GUID, self.Version)
|
|
|
|
|
|
##
|
|
# CommonDefinesXml
|
|
#
|
|
class CommonDefinesXml(object):
|
|
def __init__(self):
|
|
self.Usage = ''
|
|
self.SupArchList = []
|
|
self.SupModList = []
|
|
self.FeatureFlag = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if Key:
|
|
pass
|
|
self.Usage = XmlAttribute(Item, 'Usage')
|
|
self.SupArchList = \
|
|
[Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch]
|
|
self.SupModList = \
|
|
[Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod]
|
|
self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))
|
|
|
|
def ToXml(self):
|
|
pass
|
|
|
|
def __str__(self):
|
|
return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \
|
|
% (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)
|
|
|
|
##
|
|
# PromptXml
|
|
#
|
|
class PromptXml(object):
|
|
def __init__(self):
|
|
self.Prompt = ''
|
|
self.Lang = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if Key:
|
|
pass
|
|
self.Prompt = XmlElement2(Item, 'Prompt')
|
|
self.Lang = XmlAttribute(Item, 'Lang')
|
|
|
|
def ToXml(self, Prompt, Key='Prompt'):
|
|
if self.Prompt:
|
|
pass
|
|
return CreateXmlElement('%s' % Key, Prompt.GetString(), [], [['Lang', Prompt.GetLang()]])
|
|
def __str__(self):
|
|
return "Prompt = %s Lang = %s" % (self.Prompt, self.Lang)
|
|
|
|
##
|
|
# HelpTextXml
|
|
#
|
|
class HelpTextXml(object):
|
|
def __init__(self):
|
|
self.HelpText = ''
|
|
self.Lang = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if Key:
|
|
pass
|
|
self.HelpText = XmlElement2(Item, 'HelpText')
|
|
self.Lang = XmlAttribute(Item, 'Lang')
|
|
|
|
def ToXml(self, HelpText, Key='HelpText'):
|
|
if self.HelpText:
|
|
pass
|
|
return CreateXmlElement('%s' % Key, HelpText.GetString(), [], [['Lang', HelpText.GetLang()]])
|
|
def __str__(self):
|
|
return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang)
|
|
|
|
##
|
|
# HeaderXml
|
|
#
|
|
class HeaderXml(object):
|
|
def __init__(self):
|
|
self.Name = ''
|
|
self.BaseName = ''
|
|
self.GUID = ''
|
|
self.Version = ''
|
|
self.CopyrightList = []
|
|
self.LicenseList = []
|
|
self.AbstractList = []
|
|
self.DescriptionList = []
|
|
|
|
def FromXml(self, Item, Key, IsRequiredCheck=False, IsStandAlongModule=False):
|
|
if not Item and IsRequiredCheck:
|
|
XmlTreeLevel = []
|
|
if IsStandAlongModule:
|
|
XmlTreeLevel = ['DistributionPackage', 'ModuleSurfaceArea']
|
|
else:
|
|
XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea']
|
|
CheckDict = {'Header':''}
|
|
IsRequiredItemListNull(CheckDict, XmlTreeLevel)
|
|
self.Name = XmlElement(Item, '%s/Name' % Key)
|
|
self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName')
|
|
self.GUID = XmlElement(Item, '%s/GUID' % Key)
|
|
self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
|
|
|
|
for SubItem in XmlList(Item, '%s/Abstract' % Key):
|
|
HeaderAbstractLang = XmlAttribute(SubItem, 'Lang')
|
|
self.AbstractList.append((HeaderAbstractLang, XmlElement(SubItem, '%s/Abstract' % Key)))
|
|
for SubItem in XmlList(Item, '%s/Description' % Key):
|
|
HeaderDescriptionLang = XmlAttribute(SubItem, 'Lang')
|
|
self.DescriptionList.append((HeaderDescriptionLang, XmlElement(SubItem, '%s/Description' % Key)))
|
|
for SubItem in XmlList(Item, '%s/Copyright' % Key):
|
|
HeaderCopyrightLang = XmlAttribute(SubItem, 'Lang')
|
|
self.CopyrightList.append((HeaderCopyrightLang, XmlElement(SubItem, '%s/Copyright' % Key)))
|
|
for SubItem in XmlList(Item, '%s/License' % Key):
|
|
HeaderLicenseLang = XmlAttribute(SubItem, 'Lang')
|
|
self.LicenseList.append((HeaderLicenseLang, XmlElement(SubItem, '%s/License' % Key)))
|
|
ModuleHeader = ModuleObject()
|
|
ModuleHeader.SetName(self.Name)
|
|
ModuleHeader.SetBaseName(self.BaseName)
|
|
ModuleHeader.SetGuid(self.GUID)
|
|
ModuleHeader.SetVersion(self.Version)
|
|
ModuleHeader.SetCopyright(self.CopyrightList)
|
|
ModuleHeader.SetLicense(self.LicenseList)
|
|
ModuleHeader.SetAbstract(self.AbstractList)
|
|
ModuleHeader.SetDescription(self.DescriptionList)
|
|
return ModuleHeader
|
|
|
|
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
|
|
|
|
def __str__(self):
|
|
return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \
|
|
License = %s Abstract = %s Description = %s" % \
|
|
(self.Name, self.BaseName, self.GUID, self.Version, self.CopyrightList, \
|
|
self.LicenseList, self.AbstractList, self.DescriptionList)
|
|
##
|
|
# DistributionPackageHeaderXml
|
|
#
|
|
class DistributionPackageHeaderXml(object):
|
|
def __init__(self):
|
|
self.Header = HeaderXml()
|
|
self.ReadOnly = ''
|
|
self.RePackage = ''
|
|
self.Vendor = ''
|
|
self.Date = ''
|
|
self.Signature = ''
|
|
self.XmlSpecification = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if not Item:
|
|
return None
|
|
self.ReadOnly = XmlAttribute(XmlNode(Item, '%s' % Key), 'ReadOnly')
|
|
self.RePackage = XmlAttribute(XmlNode(Item, '%s' % Key), 'RePackage')
|
|
self.Vendor = XmlElement(Item, '%s/Vendor' % Key)
|
|
self.Date = XmlElement(Item, '%s/Date' % Key)
|
|
self.Signature = XmlElement(Item, '%s/Signature' % Key)
|
|
self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key)
|
|
self.Header.FromXml(Item, Key)
|
|
DistributionPackageHeader = DistributionPackageHeaderObject()
|
|
if self.ReadOnly.upper() == 'TRUE':
|
|
DistributionPackageHeader.ReadOnly = True
|
|
elif self.ReadOnly.upper() == 'FALSE':
|
|
DistributionPackageHeader.ReadOnly = False
|
|
if self.RePackage.upper() == 'TRUE':
|
|
DistributionPackageHeader.RePackage = True
|
|
elif self.RePackage.upper() == 'FALSE':
|
|
DistributionPackageHeader.RePackage = False
|
|
DistributionPackageHeader.Vendor = self.Vendor
|
|
DistributionPackageHeader.Date = self.Date
|
|
DistributionPackageHeader.Signature = self.Signature
|
|
DistributionPackageHeader.XmlSpecification = self.XmlSpecification
|
|
DistributionPackageHeader.SetName(self.Header.Name)
|
|
DistributionPackageHeader.SetBaseName(self.Header.BaseName)
|
|
DistributionPackageHeader.SetGuid(self.Header.GUID)
|
|
DistributionPackageHeader.SetVersion(self.Header.Version)
|
|
DistributionPackageHeader.SetCopyright(self.Header.CopyrightList)
|
|
DistributionPackageHeader.SetLicense(self.Header.LicenseList)
|
|
DistributionPackageHeader.SetAbstract(self.Header.AbstractList)
|
|
DistributionPackageHeader.SetDescription(self.Header.DescriptionList)
|
|
return DistributionPackageHeader
|
|
|
|
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()])
|
|
if DistributionPackageHeader.GetAbstract():
|
|
DPAbstract = DistributionPackageHeader.GetAbstract()[0][1]
|
|
else:
|
|
DPAbstract = ''
|
|
if DistributionPackageHeader.GetDescription():
|
|
DPDescription = DistributionPackageHeader.GetDescription()[0][1]
|
|
else:
|
|
DPDescription = ''
|
|
if DistributionPackageHeader.GetCopyright():
|
|
DPCopyright = DistributionPackageHeader.GetCopyright()[0][1]
|
|
else:
|
|
DPCopyright = ''
|
|
if DistributionPackageHeader.GetLicense():
|
|
DPLicense = DistributionPackageHeader.GetLicense()[0][1]
|
|
else:
|
|
DPLicense = ''
|
|
NodeList = [Element1,
|
|
Element2,
|
|
['Vendor', DistributionPackageHeader.Vendor],
|
|
['Date', DistributionPackageHeader.Date],
|
|
['Copyright', DPCopyright],
|
|
['License', DPLicense],
|
|
['Abstract', DPAbstract],
|
|
['Description', DPDescription],
|
|
['Signature', DistributionPackageHeader.Signature],
|
|
['XmlSpecification', \
|
|
DistributionPackageHeader.XmlSpecification],
|
|
]
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
return Root
|
|
|
|
def __str__(self):
|
|
return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s \
|
|
Signature = %s XmlSpecification = %s %s" % \
|
|
(self.ReadOnly, self.RePackage, self.Vendor, self.Date, \
|
|
self.Signature, self.XmlSpecification, self.Header)
|
|
##
|
|
# PackageHeaderXml
|
|
#
|
|
class PackageHeaderXml(object):
|
|
def __init__(self):
|
|
self.Header = HeaderXml()
|
|
self.PackagePath = ''
|
|
|
|
def FromXml(self, Item, Key, PackageObject2):
|
|
if not Item:
|
|
XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea']
|
|
CheckDict = {'PackageHeader': None, }
|
|
IsRequiredItemListNull(CheckDict, XmlTreeLevel)
|
|
self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)
|
|
self.Header.FromXml(Item, Key)
|
|
PackageObject2.SetName(self.Header.Name)
|
|
PackageObject2.SetBaseName(self.Header.BaseName)
|
|
PackageObject2.SetGuid(self.Header.GUID)
|
|
PackageObject2.SetVersion(self.Header.Version)
|
|
PackageObject2.SetCopyright(self.Header.CopyrightList)
|
|
PackageObject2.SetLicense(self.Header.LicenseList)
|
|
PackageObject2.SetAbstract(self.Header.AbstractList)
|
|
PackageObject2.SetDescription(self.Header.DescriptionList)
|
|
PackageObject2.SetPackagePath(self.PackagePath)
|
|
|
|
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
|
|
|
|
def __str__(self):
|
|
return "PackagePath = %s %s" \
|
|
% (self.PackagePath, self.Header)
|
|
|
|
##
|
|
# MiscellaneousFileXml
|
|
#
|
|
class MiscellaneousFileXml(object):
|
|
def __init__(self):
|
|
self.Header = HeaderXml()
|
|
self.Files = []
|
|
##
|
|
# This API is used for Package or Module's MiscellaneousFile section
|
|
#
|
|
def FromXml(self, Item, Key):
|
|
if not Item:
|
|
return None
|
|
self.Header.FromXml(Item, Key)
|
|
NewItem = XmlNode(Item, '%s/Header' % Key)
|
|
self.Header.FromXml(NewItem, 'Header')
|
|
for SubItem in XmlList(Item, '%s/Filename' % Key):
|
|
Filename = XmlElement(SubItem, '%s/Filename' % Key)
|
|
Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
|
|
if Executable.upper() == "TRUE":
|
|
Executable = True
|
|
elif Executable.upper() == "FALSE":
|
|
Executable = False
|
|
else:
|
|
Executable = ''
|
|
self.Files.append([Filename, Executable])
|
|
MiscFile = MiscFileObject()
|
|
MiscFile.SetCopyright(self.Header.CopyrightList)
|
|
MiscFile.SetLicense(self.Header.LicenseList)
|
|
MiscFile.SetAbstract(self.Header.AbstractList)
|
|
MiscFile.SetDescription(self.Header.DescriptionList)
|
|
MiscFileList = []
|
|
for File in self.Files:
|
|
FileObj = FileObject()
|
|
FileObj.SetURI(File[0])
|
|
FileObj.SetExecutable(File[1])
|
|
MiscFileList.append(FileObj)
|
|
MiscFile.SetFileList(MiscFileList)
|
|
return MiscFile
|
|
##
|
|
# This API is used for DistP's tool section
|
|
#
|
|
def FromXml2(self, Item, Key):
|
|
if Item is None:
|
|
return None
|
|
NewItem = XmlNode(Item, '%s/Header' % Key)
|
|
self.Header.FromXml(NewItem, 'Header')
|
|
for SubItem in XmlList(Item, '%s/Filename' % Key):
|
|
Filename = XmlElement(SubItem, '%s/Filename' % Key)
|
|
Executable = \
|
|
XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
|
|
OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')
|
|
if Executable.upper() == "TRUE":
|
|
Executable = True
|
|
elif Executable.upper() == "FALSE":
|
|
Executable = False
|
|
else:
|
|
Executable = ''
|
|
self.Files.append([Filename, Executable, OsType])
|
|
MiscFile = MiscFileObject()
|
|
MiscFile.SetName(self.Header.Name)
|
|
MiscFile.SetCopyright(self.Header.CopyrightList)
|
|
MiscFile.SetLicense(self.Header.LicenseList)
|
|
MiscFile.SetAbstract(self.Header.AbstractList)
|
|
MiscFile.SetDescription(self.Header.DescriptionList)
|
|
MiscFileList = []
|
|
for File in self.Files:
|
|
FileObj = FileObject()
|
|
FileObj.SetURI(File[0])
|
|
FileObj.SetExecutable(File[1])
|
|
FileObj.SetOS(File[2])
|
|
MiscFileList.append(FileObj)
|
|
MiscFile.SetFileList(MiscFileList)
|
|
return MiscFile
|
|
|
|
##
|
|
# This API is used for Package or Module's MiscellaneousFile section
|
|
#
|
|
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
|
|
##
|
|
# This API is used for DistP's tool section
|
|
#
|
|
def ToXml2(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 = [['Name', MiscFile.GetName()],
|
|
['Copyright', DPCopyright],
|
|
['License', DPLicense],
|
|
['Abstract', DPAbstract],
|
|
['Description', DPDescription],
|
|
]
|
|
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
|
|
|
|
def __str__(self):
|
|
Str = str(self.Header)
|
|
for Item in self.Files:
|
|
Str = Str + '\n\tFilename:' + str(Item)
|
|
return Str
|
|
##
|
|
# UserExtensionsXml
|
|
#
|
|
class UserExtensionsXml(object):
|
|
def __init__(self):
|
|
self.UserId = ''
|
|
self.Identifier = ''
|
|
self.BinaryAbstractList = []
|
|
self.BinaryDescriptionList = []
|
|
self.BinaryCopyrightList = []
|
|
self.BinaryLicenseList = []
|
|
self.LangDefsList = []
|
|
self.DefineDict = {}
|
|
self.BuildOptionDict = {}
|
|
self.IncludesDict = {}
|
|
self.SourcesDict = {}
|
|
self.BinariesDict = {}
|
|
self.SupArchList = []
|
|
self.Statement = ''
|
|
self.Defines = ''
|
|
self.BuildOptions = ''
|
|
|
|
def FromXml2(self, Item, Key):
|
|
self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
|
|
self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
|
|
UserExtension = UserExtensionObject()
|
|
UserExtension.SetUserID(self.UserId)
|
|
UserExtension.SetIdentifier(self.Identifier)
|
|
return UserExtension
|
|
|
|
def FromXml(self, Item, Key):
|
|
self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
|
|
self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
|
|
if self.UserId == DataType.TAB_BINARY_HEADER_USERID \
|
|
and self.Identifier == DataType.TAB_BINARY_HEADER_IDENTIFIER:
|
|
for SubItem in XmlList(Item, '%s/BinaryAbstract' % Key):
|
|
BinaryAbstractLang = XmlAttribute(SubItem, 'Lang')
|
|
self.BinaryAbstractList.append((BinaryAbstractLang, XmlElement(SubItem, '%s/BinaryAbstract' % Key)))
|
|
for SubItem in XmlList(Item, '%s/BinaryDescription' % Key):
|
|
BinaryDescriptionLang = XmlAttribute(SubItem, 'Lang')
|
|
self.BinaryDescriptionList.append((BinaryDescriptionLang,
|
|
XmlElement(SubItem, '%s/BinaryDescription' % Key)))
|
|
for SubItem in XmlList(Item, '%s/BinaryCopyright' % Key):
|
|
BinaryCopyrightLang = XmlAttribute(SubItem, 'Lang')
|
|
self.BinaryCopyrightList.append((BinaryCopyrightLang,
|
|
XmlElement(SubItem, '%s/BinaryCopyright' % Key)))
|
|
for SubItem in XmlList(Item, '%s/BinaryLicense' % Key):
|
|
BinaryLicenseLang = XmlAttribute(SubItem, 'Lang')
|
|
self.BinaryLicenseList.append((BinaryLicenseLang,
|
|
XmlElement(SubItem, '%s/BinaryLicense' % Key)))
|
|
|
|
DefineItem = XmlNode(Item, '%s/Define' % Key)
|
|
for SubItem in XmlList(DefineItem, 'Define/Statement'):
|
|
Statement = XmlElement(SubItem, '%s/Statement' % Key)
|
|
self.DefineDict[Statement] = ""
|
|
BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)
|
|
for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):
|
|
Statement = XmlElement(SubItem, '%s/Statement' % Key)
|
|
Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
|
|
self.BuildOptionDict[Arch] = Statement
|
|
IncludesItem = XmlNode(Item, '%s/Includes' % Key)
|
|
for SubItem in XmlList(IncludesItem, 'Includes/Statement'):
|
|
Statement = XmlElement(SubItem, '%s/Statement' % Key)
|
|
Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
|
|
self.IncludesDict[Statement] = Arch
|
|
SourcesItem = XmlNode(Item, '%s/Sources' % Key)
|
|
Tmp = UserExtensionSourceXml()
|
|
SourceDict = Tmp.FromXml(SourcesItem, 'Sources')
|
|
self.SourcesDict = SourceDict
|
|
BinariesItem = XmlNode(Item, '%s/Binaries' % Key)
|
|
Tmp = UserExtensionBinaryXml()
|
|
BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')
|
|
self.BinariesDict = BinariesDict
|
|
self.Statement = XmlElement(Item, 'UserExtensions')
|
|
SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')
|
|
self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]
|
|
UserExtension = UserExtensionObject()
|
|
UserExtension.SetUserID(self.UserId)
|
|
UserExtension.SetIdentifier(self.Identifier)
|
|
UserExtension.SetBinaryAbstract(self.BinaryAbstractList)
|
|
UserExtension.SetBinaryDescription(self.BinaryDescriptionList)
|
|
UserExtension.SetBinaryCopyright(self.BinaryCopyrightList)
|
|
UserExtension.SetBinaryLicense(self.BinaryLicenseList)
|
|
UserExtension.SetStatement(self.Statement)
|
|
UserExtension.SetSupArchList(self.SupArchList)
|
|
UserExtension.SetDefinesDict(self.DefineDict)
|
|
UserExtension.SetBuildOptionDict(self.BuildOptionDict)
|
|
UserExtension.SetIncludesDict(self.IncludesDict)
|
|
UserExtension.SetSourcesDict(self.SourcesDict)
|
|
UserExtension.SetBinariesDict(self.BinariesDict)
|
|
return UserExtension
|
|
|
|
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
|
|
|
|
def __str__(self):
|
|
Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier)
|
|
Str = Str + '\n\tDefines:' + str(self.Defines)
|
|
Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions)
|
|
return Str
|
|
|
|
##
|
|
# UserExtensionSourceXml
|
|
#
|
|
class UserExtensionSourceXml(object):
|
|
def __init__(self):
|
|
self.UserExtensionSource = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if Key:
|
|
pass
|
|
if self.UserExtensionSource:
|
|
pass
|
|
Dict = {}
|
|
#SourcesItem = XmlNode(Item, '%s/Sources' % Key)
|
|
for SubItem in XmlList(Item, 'Sources/SourceFile'):
|
|
FileName = XmlElement(SubItem, 'SourceFile/FileName')
|
|
Family = XmlElement(SubItem, 'SourceFile/Family')
|
|
FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')
|
|
SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')
|
|
DictKey = (FileName, Family, FeatureFlag, SupArchStr)
|
|
ValueList = []
|
|
for ValueNodeItem in XmlList(SubItem, \
|
|
'SourceFile/SourceFileOtherAttr'):
|
|
TagName = XmlElement(ValueNodeItem, \
|
|
'SourceFileOtherAttr/TagName')
|
|
ToolCode = XmlElement(ValueNodeItem, \
|
|
'SourceFileOtherAttr/ToolCode')
|
|
Comment = XmlElement(ValueNodeItem, \
|
|
'SourceFileOtherAttr/Comment')
|
|
if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '):
|
|
TagName = ''
|
|
ToolCode = ''
|
|
Comment = ''
|
|
ValueList.append((TagName, ToolCode, Comment))
|
|
Dict[DictKey] = ValueList
|
|
return Dict
|
|
|
|
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
|
|
|
|
##
|
|
# UserExtensionBinaryXml
|
|
#
|
|
class UserExtensionBinaryXml(object):
|
|
def __init__(self):
|
|
self.UserExtensionBinary = ''
|
|
|
|
def FromXml(self, Item, Key):
|
|
if Key:
|
|
pass
|
|
if self.UserExtensionBinary:
|
|
pass
|
|
Dict = {}
|
|
for SubItem in XmlList(Item, 'Binaries/Binary'):
|
|
FileName = XmlElement(SubItem, 'Binary/FileName')
|
|
FileType = XmlElement(SubItem, 'Binary/FileType')
|
|
FFE = XmlElement(SubItem, 'Binary/FeatureFlag')
|
|
SupArch = XmlElement(SubItem, 'Binary/SupArchList')
|
|
DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)
|
|
ValueList = []
|
|
for ValueNodeItem in XmlList(SubItem, \
|
|
'Binary/BinaryFileOtherAttr'):
|
|
Target = XmlElement(ValueNodeItem, \
|
|
'BinaryFileOtherAttr/Target')
|
|
Family = XmlElement(ValueNodeItem, \
|
|
'BinaryFileOtherAttr/Family')
|
|
TagName = XmlElement(ValueNodeItem, \
|
|
'BinaryFileOtherAttr/TagName')
|
|
Comment = XmlElement(ValueNodeItem, \
|
|
'BinaryFileOtherAttr/Comment')
|
|
if (Target == ' ') and (Family == ' ') and \
|
|
(TagName == ' ') and (Comment == ' '):
|
|
Target = ''
|
|
Family = ''
|
|
TagName = ''
|
|
Comment = ''
|
|
|
|
ValueList.append((Target, Family, TagName, Comment))
|
|
Dict[DictKey] = ValueList
|
|
return Dict
|
|
|
|
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
|
|
|
|
##
|
|
# LibraryClassXml
|
|
#
|
|
class LibraryClassXml(object):
|
|
def __init__(self):
|
|
self.Keyword = ''
|
|
self.HeaderFile = ''
|
|
self.RecommendedInstanceGuid = ''
|
|
self.RecommendedInstanceVersion = ''
|
|
self.CommonDefines = CommonDefinesXml()
|
|
self.HelpText = []
|
|
|
|
def FromXml(self, Item, Key):
|
|
self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword')
|
|
if self.Keyword == '':
|
|
self.Keyword = XmlElement(Item, '%s/Keyword' % Key)
|
|
self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
|
|
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
|
|
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
|
|
HelpTextObj = HelpTextXml()
|
|
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
|
|
self.HelpText.append(HelpTextObj)
|
|
LibraryClass = LibraryClassObject()
|
|
LibraryClass.SetLibraryClass(self.Keyword)
|
|
LibraryClass.SetIncludeHeader(self.HeaderFile)
|
|
if self.CommonDefines.Usage:
|
|
LibraryClass.SetUsage(self.CommonDefines.Usage)
|
|
LibraryClass.SetSupArchList(self.CommonDefines.SupArchList)
|
|
LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)
|
|
LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
|
|
LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))
|
|
return LibraryClass
|
|
|
|
def ToXml(self, LibraryClass, Key):
|
|
if self.HeaderFile:
|
|
pass
|
|
AttributeList = \
|
|
[['Keyword', LibraryClass.GetLibraryClass()],
|
|
['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())],
|
|
['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())]
|
|
]
|
|
NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]]
|
|
for Item in LibraryClass.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
return Root
|
|
|
|
def ToXml2(self, LibraryClass, Key):
|
|
if self.HeaderFile:
|
|
pass
|
|
FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())
|
|
AttributeList = \
|
|
[['Usage', LibraryClass.GetUsage()], \
|
|
['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \
|
|
['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \
|
|
['FeatureFlag', FeatureFlag]
|
|
]
|
|
NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ]
|
|
for Item in LibraryClass.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
return Root
|
|
|
|
def __str__(self):
|
|
Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
|
|
(self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \
|
|
self.CommonDefines)
|
|
for Item in self.HelpText:
|
|
Str = Str + "\n\t" + str(Item)
|
|
return Str
|
|
|
|
##
|
|
# FilenameXml
|
|
#
|
|
class FilenameXml(object):
|
|
def __init__(self):
|
|
self.FileType = ''
|
|
self.Filename = ''
|
|
self.CommonDefines = CommonDefinesXml()
|
|
|
|
def FromXml(self, Item, Key):
|
|
self.FileType = XmlAttribute(Item, 'FileType')
|
|
Guid = XmlAttribute(Item, 'GUID')
|
|
self.Filename = XmlElement(Item, 'Filename')
|
|
self.CommonDefines.FromXml(Item, Key)
|
|
FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
|
|
Filename = FileNameObject()
|
|
#
|
|
# Convert File Type
|
|
#
|
|
if self.FileType == 'UEFI_IMAGE':
|
|
self.FileType = 'PE32'
|
|
|
|
Filename.SetGuidValue(Guid)
|
|
Filename.SetFileType(self.FileType)
|
|
Filename.SetFilename(self.Filename)
|
|
Filename.SetSupArchList(self.CommonDefines.SupArchList)
|
|
Filename.SetFeatureFlag(FeatureFlag)
|
|
|
|
return Filename
|
|
|
|
def ToXml(self, Filename, Key):
|
|
if self.Filename:
|
|
pass
|
|
AttributeList = [['SupArchList', \
|
|
GetStringOfList(Filename.GetSupArchList())],
|
|
['FileType', Filename.GetFileType()],
|
|
['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
|
|
['GUID', Filename.GetGuidValue()]
|
|
]
|
|
Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)
|
|
|
|
return Root
|
|
|
|
def __str__(self):
|
|
return "FileType = %s Filename = %s %s" \
|
|
% (self.FileType, self.Filename, self.CommonDefines)
|