BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py

   1 ## @file
   2 # This file is used to parse a Module file of .PKG file
   3 #
   4 # Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
   5 #
   6 # This program and the accompanying materials are licensed and made available
   7 # under the terms and conditions of the BSD License which accompanies this
   8 # distribution. The full text of the license may be found at
   9 # http://opensource.org/licenses/bsd-license.php
  10 #
  11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 '''
  16 ModuleSurfaceAreaXml
  17 '''
  18 from xml.dom import minidom
  19
  20 from Library.String import ConvertNEToNOTEQ
  21 from Library.String import ConvertNOTEQToNE
  22 from Library.String import GetStringOfList
  23 from Library.String import IsMatchArch
  24 from Library.Xml.XmlRoutines import XmlElement
  25 from Library.Xml.XmlRoutines import XmlAttribute
  26 from Library.Xml.XmlRoutines import XmlNode
  27 from Library.Xml.XmlRoutines import XmlList
  28 from Library.Xml.XmlRoutines import CreateXmlElement
  29 from Object.POM.CommonObject import GuidVersionObject
  30 from Object.POM.ModuleObject import BootModeObject
  31 from Object.POM.ModuleObject import DepexObject
  32 from Object.POM.ModuleObject import ModuleObject
  33 from Object.POM.ModuleObject import EventObject
  34 from Object.POM.ModuleObject import HobObject
  35 from Object.POM.ModuleObject import SourceFileObject
  36 from Object.POM.ModuleObject import PackageDependencyObject
  37 from Object.POM.ModuleObject import ExternObject
  38 from Object.POM.ModuleObject import BinaryFileObject
  39 from Object.POM.ModuleObject import AsBuiltObject
  40 from Object.POM.ModuleObject import BinaryBuildFlagObject
  41 from Xml.CommonXml import ClonedFromXml
  42 from Xml.CommonXml import HeaderXml
  43 from Xml.CommonXml import HelpTextXml
  44 from Xml.CommonXml import CommonDefinesXml
  45 from Xml.CommonXml import LibraryClassXml
  46 from Xml.CommonXml import UserExtensionsXml
  47 from Xml.CommonXml import MiscellaneousFileXml
  48 from Xml.CommonXml import FilenameXml
  49 from Xml.GuidProtocolPpiXml import GuidXml
  50 from Xml.GuidProtocolPpiXml import ProtocolXml
  51 from Xml.GuidProtocolPpiXml import PpiXml
  52 from Xml.PcdXml import PcdEntryXml
  53 from Xml.XmlParserMisc import GetHelpTextList
  54 from Library import GlobalData
  55 from Library.Misc import GetSplitValueList
  56
  57 ##   BinaryFileXml
  58 #
  59 #    represent the following XML item
  60 #
  61 #    <BinaryFile>
  62 #    <Filename
  63 #    FileType=" FileType " {1}
  64 #    SupArchList=" ArchListType " {0,1}
  65 #    FeatureFlag=" FeatureFlagExpression " {0,1} >
  66 #    xs:anyURI
  67 #    </Filename> {1,}
  68 #    <AsBuilt> ... </AsBuilt> {0,}
  69 #    </BinaryFile> {1,}
  70 #
  71 class BinaryFileXml(object):
  72     def __init__(self):
  73         self.FileNames = []
  74         self.AsBuiltList = []
  75         self.PatchPcdValues = ''
  76         self.PcdExValues = ''
  77         self.LibraryInstances = ''
  78         self.BuildFlags = ''
  79
  80     def FromXml(self, Item, Key):
  81         if self.FileNames:
  82             pass
  83         BinaryFile = BinaryFileObject()
  84         FilenameList = []
  85         SupArchList = ['COMMON']
  86         for SubItem in XmlList(Item, '%s/Filename' % Key):
  87             Axml = FilenameXml()
  88             Bxml = Axml.FromXml(SubItem, 'Filename')
  89             FilenameList.append(Bxml)
  90         BinaryFile.SetFileNameList(FilenameList)
  91         for FileName in FilenameList:
  92             if FileName.GetSupArchList():
  93                 SupArchList = FileName.GetSupArchList()
  94         BinaryFile.SetSupArchList(SupArchList)
  95         if GlobalData.gIS_BINARY_INF:
  96             AsBuiltList = []
  97             for AsBuiltItem in XmlList(Item, '%s/AsBuilt' % Key):
  98                 AsBuilt = AsBuiltObject()
  99
 100                 PatchPcdValueList = []
 101                 for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PatchPcdValue'):
 102                     Axml = PcdEntryXml()
 103                     Bxml = Axml.FromXml(SubItem, 'PatchPcdValue')
 104                     PatchPcdValueList.append(Bxml)
 105                 AsBuilt.SetPatchPcdList(PatchPcdValueList)
 106                 PcdExValueList = []
 107                 for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PcdExValue'):
 108                     Axml = PcdEntryXml()
 109                     Bxml = Axml.FromXml(SubItem, 'PcdExValue')
 110                     PcdExValueList.append(Bxml)
 111                 AsBuilt.SetPcdExList(PcdExValueList)
 112                 LibraryList = []
 113                 for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key):
 114                     GuidVerObj = GuidVersionObject()
 115                     GUID = XmlElement(SubItem, 'GUID')
 116                     Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version')
 117                     GuidVerObj.SetGuid(GUID)
 118                     GuidVerObj.SetVersion(Version)
 119                     LibraryList.append(GuidVerObj)
 120                 if XmlList(Item, '%s/AsBuilt/LibraryInstances' % Key) and not LibraryList:
 121                     LibraryList = [None]
 122                 AsBuilt.SetLibraryInstancesList(LibraryList)
 123                 BuildFlagList = []
 124                 for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key):
 125                     BuildFlag = BuildFlagXml()
 126                     BuildFlagList.append(BuildFlag.FromXml2(SubItem, 'BuildFlags'))
 127                 AsBuilt.SetBuildFlagsList(BuildFlagList)
 128                 AsBuiltList.append(AsBuilt)
 129             BinaryFile.SetAsBuiltList(AsBuiltList)
 130         return BinaryFile
 131
 132     def ToXml(self, BinaryFile, Key):
 133         if self.FileNames:
 134             pass
 135         NodeList = []
 136         FilenameList = BinaryFile.GetFileNameList()
 137         SupportArch = None
 138         for Filename in FilenameList:
 139             Tmp = FilenameXml()
 140             NodeList.append(Tmp.ToXml(Filename, 'Filename'))
 141             SupportArch = Filename.SupArchList
 142
 143         AsBuildList = BinaryFile.GetAsBuiltList()
 144         PatchPcdValueList = AsBuildList.GetPatchPcdList()
 145         PcdExList = AsBuildList.GetPcdExList()
 146         LibGuidVerList = AsBuildList.GetLibraryInstancesList()
 147         BuildFlagList = AsBuildList.GetBuildFlagsList()
 148
 149         AsBuiltNodeList = []
 150
 151         for Pcd in PatchPcdValueList:
 152             if IsMatchArch(Pcd.SupArchList, SupportArch):
 153                 Tmp = PcdEntryXml()
 154                 AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))
 155
 156         for Pcd in PcdExList:
 157             if IsMatchArch(Pcd.SupArchList, SupportArch):
 158                 Tmp = PcdEntryXml()
 159                 AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))
 160
 161         GuiVerElemList = []
 162         for LibGuidVer in LibGuidVerList:
 163             if LibGuidVer.GetLibGuid() and IsMatchArch(LibGuidVer.GetSupArchList(), SupportArch):
 164                 GuiVerElem = \
 165                 CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
 166                 GuiVerElemList.append(GuiVerElem)
 167         if len(GuiVerElemList) > 0:
 168             LibGuidVerElem = CreateXmlElement('LibraryInstances', '', GuiVerElemList, [])
 169             AsBuiltNodeList.append(LibGuidVerElem)
 170
 171         for BuildFlag in BuildFlagList:
 172             if IsMatchArch(BuildFlag.GetSupArchList(), SupportArch):
 173                 for Item in BuildFlag.GetAsBuildList():
 174                     Tmp = BuildFlagXml()
 175                     Elem = CreateXmlElement('BuildFlags', ''.join(Item), [], [])
 176                     AsBuiltNodeList.append(Elem)
 177
 178         if len(AsBuiltNodeList) > 0:
 179             Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
 180             NodeList.append(Element)
 181
 182         Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 183
 184         return Root
 185
 186     def __str__(self):
 187         Str = "BinaryFiles:"
 188         for Item in self.FileNames:
 189             Str = Str + '\n\t' + str(Item)
 190         for Item in self.PatchPcdValues:
 191             Str = Str + '\n\t' + str(Item)
 192         for Item in self.PcdExValues:
 193             Str = Str + '\n\t' + str(Item)
 194         for Item in self.LibraryInstances:
 195             Str = Str + '\n\t' + str(Item)
 196         for Item in self.BuildFlags:
 197             Str = Str + '\n\t' + str(Item)
 198         return Str
 199
 200 ##
 201 # PackageXml
 202 #
 203 class PackageXml(object):
 204     def __init__(self):
 205         self.Description = ''
 206         self.Guid = ''
 207         self.Version = ''
 208         self.CommonDefines = CommonDefinesXml()
 209
 210     def FromXml(self, Item, Key):
 211         self.Description = XmlElement(Item, '%s/Description' % Key)
 212         self.Guid = XmlElement(Item, '%s/GUID' % Key)
 213         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
 214         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 215
 216         PackageDependency = PackageDependencyObject()
 217         PackageDependency.SetPackage(self.Description)
 218         PackageDependency.SetGuid(self.Guid)
 219         PackageDependency.SetVersion(self.Version)
 220         PackageDependency.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 221         PackageDependency.SetSupArchList(self.CommonDefines.SupArchList)
 222
 223         return PackageDependency
 224
 225     def ToXml(self, PackageDependency, Key):
 226         if self.Guid:
 227             pass
 228         AttributeList = [['SupArchList', GetStringOfList(PackageDependency.GetSupArchList())],
 229                          ['FeatureFlag', ConvertNEToNOTEQ(PackageDependency.GetFeatureFlag())], ]
 230         Element1 = CreateXmlElement('GUID', PackageDependency.GetGuid(), [],
 231                                     [['Version', PackageDependency.GetVersion()]])
 232         NodeList = [['Description', PackageDependency.GetPackage()], Element1, ]
 233         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 234
 235         return Root
 236
 237     def __str__(self):
 238         Str = "Description = %s Guid = %s Version = %s %s" \
 239               % (self.Description, self.Guid, self.Version, self.CommonDefines)
 240         return Str
 241 ##
 242 # ExternXml
 243 #
 244 class ExternXml(object):
 245     def __init__(self):
 246         self.CommonDefines = CommonDefinesXml()
 247         self.EntryPoint = ''
 248         self.UnloadImage = ''
 249         self.Constructor = ''
 250         self.Destructor = ''
 251         self.SupModList = ''
 252         self.SupArchList = ''
 253         self.HelpText = []
 254
 255     def FromXml(self, Item, Key):
 256         self.CommonDefines.FromXml(Item, Key)
 257         self.EntryPoint = XmlElement(Item, '%s/EntryPoint' % Key)
 258         self.UnloadImage = XmlElement(Item, '%s/UnloadImage' % Key)
 259         self.Constructor = XmlElement(Item, '%s/Constructor' % Key)
 260         self.Destructor = XmlElement(Item, '%s/Destructor' % Key)
 261
 262         Extern = ExternObject()
 263         Extern.SetEntryPoint(self.EntryPoint)
 264         Extern.SetUnloadImage(self.UnloadImage)
 265         Extern.SetConstructor(self.Constructor)
 266         Extern.SetDestructor(self.Destructor)
 267         if self.CommonDefines.SupModList:
 268             Extern.SetSupModList(self.CommonDefines.SupModList)
 269         if self.CommonDefines.SupArchList:
 270             Extern.SetSupArchList(self.CommonDefines.SupArchList)
 271         return Extern
 272
 273     def ToXml(self, Extern, Key):
 274         if self.HelpText:
 275             pass
 276
 277         NodeList = []
 278         if Extern.GetEntryPoint():
 279             NodeList.append(['EntryPoint', Extern.GetEntryPoint()])
 280         if Extern.GetUnloadImage():
 281             NodeList.append(['UnloadImage', Extern.GetUnloadImage()])
 282         if Extern.GetConstructor():
 283             NodeList.append(['Constructor', Extern.GetConstructor()])
 284         if Extern.GetDestructor():
 285             NodeList.append(['Destructor', Extern.GetDestructor()])
 286         Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 287
 288         return Root
 289
 290     def __str__(self):
 291         Str = "EntryPoint = %s UnloadImage = %s Constructor = %s Destructor = %s %s" \
 292               % (self.EntryPoint, self.UnloadImage, self.Constructor, self.Destructor, self.CommonDefines)
 293         for Item in self.HelpText:
 294             Str = Str + '\n\t' + str(Item)
 295         return Str
 296 ##
 297 # DepexXml
 298 #
 299 class DepexXml(object):
 300     def __init__(self):
 301         self.CommonDefines = CommonDefinesXml()
 302         self.Expression = None
 303         self.HelpText = []
 304
 305     def FromXml(self, Item, Key):
 306         if not Item:
 307             return None
 308         self.CommonDefines.FromXml(Item, Key)
 309         self.Expression = XmlElement(Item, '%s/Expression' % Key)
 310         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 311             HelpTextObj = HelpTextXml()
 312             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 313             self.HelpText.append(HelpTextObj)
 314
 315         Depex = DepexObject()
 316         Depex.SetDepex(self.Expression)
 317         Depex.SetModuleType(self.CommonDefines.SupModList)
 318         Depex.SetSupArchList(self.CommonDefines.SupArchList)
 319         Depex.SetFeatureFlag(self.CommonDefines.FeatureFlag)
 320         Depex.SetHelpTextList(GetHelpTextList(self.HelpText))
 321
 322         return Depex
 323
 324     def ToXml(self, Depex, Key):
 325         if self.HelpText:
 326             pass
 327         AttributeList = [['SupArchList', GetStringOfList(Depex.GetSupArchList())],
 328                          ['SupModList', Depex.GetModuleType()]]
 329         NodeList = [['Expression', Depex.GetDepex()]]
 330         if Depex.GetHelpText():
 331             Tmp = HelpTextXml()
 332             NodeList.append(Tmp.ToXml(Depex.GetHelpText(), 'HelpText'))
 333
 334         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 335         return Root
 336
 337     def __str__(self):
 338         Str = "Expression = %s" % (self.Expression)
 339         for Item in self.HelpText:
 340             Str = Str + '\n\t' + str(Item)
 341         return Str
 342
 343 ##
 344 # BootModeXml
 345 #
 346 class BootModeXml(object):
 347     def __init__(self):
 348         self.SupportedBootModes = ''
 349         self.CommonDefines = CommonDefinesXml()
 350         self.HelpText = []
 351
 352     def FromXml(self, Item, Key):
 353         self.SupportedBootModes = \
 354         XmlElement(Item, '%s/SupportedBootModes' % Key)
 355         self.CommonDefines.FromXml(Item, Key)
 356         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 357             HelpTextObj = HelpTextXml()
 358             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 359             self.HelpText.append(HelpTextObj)
 360
 361         BootMode = BootModeObject()
 362         BootMode.SetSupportedBootModes(self.SupportedBootModes)
 363         BootMode.SetUsage(self.CommonDefines.Usage)
 364         BootMode.SetHelpTextList(GetHelpTextList(self.HelpText))
 365
 366         return BootMode
 367
 368     def ToXml(self, BootMode, Key):
 369         if self.HelpText:
 370             pass
 371         AttributeList = [['Usage', BootMode.GetUsage()], ]
 372         NodeList = [['SupportedBootModes', BootMode.GetSupportedBootModes()]]
 373         for Item in BootMode.GetHelpTextList():
 374             Tmp = HelpTextXml()
 375             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 376         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 377
 378         return Root
 379
 380     def __str__(self):
 381         Str = "SupportedBootModes = %s %s" % (self.SupportedBootModes, self.CommonDefines)
 382         for Item in self.HelpText:
 383             Str = Str + '\n\t' + str(Item)
 384         return Str
 385 ##
 386 # EventXml
 387 #
 388 class EventXml(object):
 389     def __init__(self):
 390         self.EventType = ''
 391         self.Name = ''
 392         self.CommonDefines = CommonDefinesXml()
 393         self.HelpText = []
 394
 395     def FromXml(self, Item, Key):
 396         self.EventType = XmlAttribute(XmlNode(Item, '%s' % Key), 'EventType')
 397         self.Name = XmlElement(Item, '%s' % Key)
 398         self.CommonDefines.FromXml(Item, Key)
 399         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 400             HelpTextObj = HelpTextXml()
 401             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 402             self.HelpText.append(HelpTextObj)
 403
 404         Event = EventObject()
 405         Event.SetEventType(self.EventType)
 406         Event.SetUsage(self.CommonDefines.Usage)
 407         Event.SetHelpTextList(GetHelpTextList(self.HelpText))
 408
 409         return Event
 410
 411     def ToXml(self, Event, Key):
 412         if self.HelpText:
 413             pass
 414         AttributeList = [['EventType', Event.GetEventType()],
 415                          ['Usage', Event.GetUsage()],
 416                         ]
 417         NodeList = []
 418         for Item in Event.GetHelpTextList():
 419             Tmp = HelpTextXml()
 420             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 421         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 422
 423         return Root
 424
 425     def __str__(self):
 426         Str = "EventType = %s %s" % (self.EventType, self.CommonDefines)
 427         for Item in self.HelpText:
 428             Str = Str + '\n\t' + str(Item)
 429         return Str
 430 ##
 431 # HobXml
 432 #
 433 class HobXml(object):
 434     def __init__(self):
 435         self.HobType = ''
 436         self.Name = ''
 437         self.CommonDefines = CommonDefinesXml()
 438         self.HelpText = []
 439
 440     def FromXml(self, Item, Key):
 441         self.HobType = XmlAttribute(XmlNode(Item, '%s' % Key), 'HobType')
 442         self.Name = XmlElement(Item, '%s' % Key)
 443         self.CommonDefines.FromXml(Item, Key)
 444         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 445             HelpTextObj = HelpTextXml()
 446             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 447             self.HelpText.append(HelpTextObj)
 448
 449         Hob = HobObject()
 450         Hob.SetHobType(self.HobType)
 451         Hob.SetSupArchList(self.CommonDefines.SupArchList)
 452         Hob.SetUsage(self.CommonDefines.Usage)
 453         Hob.SetHelpTextList(GetHelpTextList(self.HelpText))
 454
 455         return Hob
 456
 457     def ToXml(self, Hob, Key):
 458         if self.Name:
 459             pass
 460         AttributeList = [['HobType', Hob.GetHobType()],
 461                          ['Usage', Hob.GetUsage()],
 462                          ['SupArchList', GetStringOfList(Hob.GetSupArchList())], ]
 463         NodeList = []
 464         for Item in Hob.GetHelpTextList():
 465             Tmp = HelpTextXml()
 466             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 467         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 468
 469         return Root
 470
 471     def __str__(self):
 472         Str = "HobType = %s %s" % (self.HobType, self.CommonDefines)
 473         for Item in self.HelpText:
 474             Str = Str + '\n\t' + str(Item)
 475         return Str
 476
 477 ##
 478 # SourceFileXml
 479 #
 480 class SourceFileXml(object):
 481     def __init__(self):
 482         self.SourceFile = ''
 483         self.ToolChainFamily = ''
 484         self.FileType = ''
 485         self.CommonDefines = CommonDefinesXml()
 486
 487     def FromXml(self, Item, Key):
 488         self.ToolChainFamily = XmlAttribute(Item, 'Family')
 489         self.SourceFile = XmlElement(Item, 'Filename')
 490         self.CommonDefines.FromXml(Item, Key)
 491
 492         self.CommonDefines.FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
 493
 494         SourceFile = SourceFileObject()
 495         SourceFile.SetSourceFile(self.SourceFile)
 496         SourceFile.SetFamily(self.ToolChainFamily)
 497         SourceFile.SetSupArchList(self.CommonDefines.SupArchList)
 498         SourceFile.SetFeatureFlag(self.CommonDefines.FeatureFlag)
 499
 500         return SourceFile
 501
 502     def ToXml(self, SourceFile, Key):
 503         if self.SourceFile:
 504             pass
 505         FeatureFlag = ConvertNEToNOTEQ(SourceFile.GetFeatureFlag())
 506         AttributeList = [['SupArchList', GetStringOfList(SourceFile.GetSupArchList())],
 507                          ['Family', SourceFile.GetFamily()],
 508                          ['FeatureFlag', FeatureFlag], ]
 509         Root = CreateXmlElement('%s' % Key, SourceFile.GetSourceFile(), [], AttributeList)
 510         return Root
 511
 512 ##
 513 # ModulePropertyXml
 514 #
 515 class ModulePropertyXml(object):
 516     def __init__(self):
 517         self.CommonDefines = CommonDefinesXml()
 518         self.ModuleType = ''
 519         self.Path = ''
 520         self.PcdIsDriver = ''
 521         self.UefiSpecificationVersion = ''
 522         self.PiSpecificationVersion = ''
 523         self.SpecificationList = []
 524         self.SpecificationVersion = ''
 525         self.BootModes = []
 526         self.Events = []
 527         self.HOBs = []
 528
 529     def FromXml(self, Item, Key, Header=None):
 530         self.CommonDefines.FromXml(Item, Key)
 531         self.ModuleType = XmlElement(Item, '%s/ModuleType' % Key)
 532         self.Path = XmlElement(Item, '%s/Path' % Key)
 533         self.PcdIsDriver = XmlElement(Item, '%s/PcdIsDriver' % Key)
 534         self.UefiSpecificationVersion = XmlElement(Item, '%s/UefiSpecificationVersion' % Key)
 535         self.PiSpecificationVersion = XmlElement(Item, '%s/PiSpecificationVersion' % Key)
 536         for SubItem in XmlList(Item, '%s/Specification' % Key):
 537             Specification = XmlElement(SubItem, '/Specification')
 538             Version = XmlAttribute(XmlNode(SubItem, '/Specification'), 'Version')
 539             self.SpecificationList.append((Specification, Version))
 540         for SubItem in XmlList(Item, '%s/BootMode' % Key):
 541             Axml = BootModeXml()
 542             BootMode = Axml.FromXml(SubItem, 'BootMode')
 543             self.BootModes.append(BootMode)
 544         for SubItem in XmlList(Item, '%s/Event' % Key):
 545             Axml = EventXml()
 546             Event = Axml.FromXml(SubItem, 'Event')
 547             self.Events.append(Event)
 548         for SubItem in XmlList(Item, '%s/HOB' % Key):
 549             Axml = HobXml()
 550             Hob = Axml.FromXml(SubItem, 'HOB')
 551             self.HOBs.append(Hob)
 552
 553         if Header is None:
 554             Header = ModuleObject()
 555
 556         Header.SetModuleType(self.ModuleType)
 557         Header.SetSupArchList(self.CommonDefines.SupArchList)
 558         Header.SetModulePath(self.Path)
 559
 560         Header.SetPcdIsDriver(self.PcdIsDriver)
 561         Header.SetUefiSpecificationVersion(self.UefiSpecificationVersion)
 562         Header.SetPiSpecificationVersion(self.PiSpecificationVersion)
 563         Header.SetSpecList(self.SpecificationList)
 564
 565         return Header, self.BootModes, self.Events, self.HOBs
 566
 567
 568     def ToXml(self, Header, BootModes, Events, Hobs, Key):
 569         if self.ModuleType:
 570             pass
 571         AttributeList = [['SupArchList', GetStringOfList(Header.GetSupArchList())], ]
 572
 573         NodeList = [['ModuleType', Header.GetModuleType()],
 574                     ['Path', Header.GetModulePath()],
 575                     ['PcdIsDriver', Header.GetPcdIsDriver()],
 576                     ['UefiSpecificationVersion', Header.GetUefiSpecificationVersion()],
 577                     ['PiSpecificationVersion', Header.GetPiSpecificationVersion()],
 578                    ]
 579         for Item in Header.GetSpecList():
 580             Spec, Version = Item
 581             SpecElem = CreateXmlElement('Specification', Spec, [], [['Version', Version]])
 582             NodeList.append(SpecElem)
 583
 584         for Item in BootModes:
 585             Tmp = BootModeXml()
 586             NodeList.append(Tmp.ToXml(Item, 'BootMode'))
 587         for Item in Events:
 588             Tmp = EventXml()
 589             NodeList.append(Tmp.ToXml(Item, 'Event'))
 590         for Item in Hobs:
 591             Tmp = HobXml()
 592             NodeList.append(Tmp.ToXml(Item, 'HOB'))
 593         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 594
 595         return Root
 596
 597     def __str__(self):
 598         Str = "ModuleType = %s Path = %s PcdIsDriver = %s UefiSpecificationVersion = %s PiSpecificationVersion = %s \
 599                Specification = %s SpecificationVersion = %s %s" % \
 600         (self.ModuleType, self.Path, self.PcdIsDriver, \
 601          self.UefiSpecificationVersion, self.PiSpecificationVersion, \
 602          self.SpecificationList, self.SpecificationVersion, self.CommonDefines)
 603         for Item in self.BootModes:
 604             Str = Str + '\n\t' + str(Item)
 605         for Item in self.Events:
 606             Str = Str + '\n\t' + str(Item)
 607         for Item in self.HOBs:
 608             Str = Str + '\n\t' + str(Item)
 609         return Str
 610
 611 ##
 612 # ModuleXml
 613 #
 614 class ModuleSurfaceAreaXml(object):
 615     def __init__(self, Package=''):
 616         self.Module = None
 617         #
 618         # indicate the package that this module resides in
 619         #
 620         self.Package = Package
 621
 622     def FromXml2(self, Item, Module):
 623         if self.Module:
 624             pass
 625         #
 626         # PeiDepex
 627         #
 628         PeiDepexList = []
 629         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PeiDepex'):
 630             Tmp = DepexXml()
 631             Depex = Tmp.FromXml(XmlNode(SubItem, 'PeiDepex'), 'PeiDepex')
 632             PeiDepexList.append(Depex)
 633         Module.SetPeiDepex(PeiDepexList)
 634
 635         #
 636         # DxeDepex
 637         #
 638         DxeDepexList = []
 639         for SubItem in XmlList(Item, '/ModuleSurfaceArea/DxeDepex'):
 640             Tmp = DepexXml()
 641             Depex = Tmp.FromXml(XmlNode(SubItem, 'DxeDepex'), 'DxeDepex')
 642             DxeDepexList.append(Depex)
 643         Module.SetDxeDepex(DxeDepexList)
 644
 645         #
 646         # SmmDepex
 647         #
 648         SmmDepexList = []
 649         for SubItem in XmlList(Item, '/ModuleSurfaceArea/SmmDepex'):
 650             Tmp = DepexXml()
 651             Depex = Tmp.FromXml(XmlNode(SubItem, 'SmmDepex'), 'SmmDepex')
 652             SmmDepexList.append(Depex)
 653         Module.SetSmmDepex(SmmDepexList)
 654
 655         #
 656         # MiscellaneousFile
 657         Tmp = MiscellaneousFileXml()
 658         MiscFileList = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
 659         if MiscFileList:
 660             Module.SetMiscFileList([MiscFileList])
 661         else:
 662             Module.SetMiscFileList([])
 663
 664         #
 665         # UserExtensions
 666         #
 667         for Item in XmlList(Item, '/ModuleSurfaceArea/UserExtensions'):
 668             Tmp = UserExtensionsXml()
 669             UserExtension = Tmp.FromXml(Item, 'UserExtensions')
 670             Module.SetUserExtensionList(Module.GetUserExtensionList() + [UserExtension])
 671
 672         return Module
 673
 674     def FromXml(self, Item, Key, IsStandAlongModule=False):
 675         IsBinaryModule = XmlAttribute(Item, 'BinaryModule')
 676         #
 677         # Header
 678         #
 679         Tmp = HeaderXml()
 680         Module = Tmp.FromXml(XmlNode(Item, '/%s/Header' % Key), 'Header', True, IsStandAlongModule)
 681         Module.SetBinaryModule(IsBinaryModule)
 682
 683         if IsBinaryModule:
 684             GlobalData.gIS_BINARY_INF = True
 685
 686         #
 687         # ModuleProperties
 688         #
 689         Tmp = ModulePropertyXml()
 690         (Module, BootModes, Events, HOBs) = \
 691         Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', Module)
 692         Module.SetBootModeList(BootModes)
 693         Module.SetEventList(Events)
 694         Module.SetHobList(HOBs)
 695         #
 696         # ClonedFrom
 697         #
 698         Tmp = ClonedFromXml()
 699         ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom')
 700         if ClonedFrom:
 701             Module.SetClonedFrom(ClonedFrom)
 702
 703         #
 704         # LibraryClass
 705         #
 706         for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
 707             Tmp = LibraryClassXml()
 708             LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')
 709             Module.SetLibraryClassList(Module.GetLibraryClassList() + [LibraryClass])
 710
 711         if XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions') and \
 712            not XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
 713             Module.SetLibraryClassList([None])
 714
 715         #
 716         # SourceFiles
 717         #
 718         for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'):
 719             Tmp = SourceFileXml()
 720             SourceFile = Tmp.FromXml(SubItem, 'Filename')
 721             Module.SetSourceFileList(Module.GetSourceFileList() + [SourceFile])
 722
 723         if XmlList(Item, '/ModuleSurfaceArea/SourceFiles') and \
 724            not XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename') :
 725             Module.SetSourceFileList([None])
 726
 727         #
 728         # BinaryFile
 729         #
 730         for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'):
 731             Tmp = BinaryFileXml()
 732             BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile')
 733             Module.SetBinaryFileList(Module.GetBinaryFileList() + [BinaryFile])
 734
 735         if XmlList(Item, '/ModuleSurfaceArea/BinaryFiles') and \
 736            not XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile') :
 737             Module.SetBinaryFileList([None])
 738         #
 739         # PackageDependencies
 740         #
 741         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):
 742             Tmp = PackageXml()
 743             PackageDependency = Tmp.FromXml(SubItem, 'Package')
 744             Module.SetPackageDependencyList(Module.GetPackageDependencyList() + [PackageDependency])
 745
 746         if XmlList(Item, '/ModuleSurfaceArea/PackageDependencies') and \
 747            not XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):
 748             Module.SetPackageDependencyList([None])
 749
 750         #
 751         # Guid
 752         #
 753         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):
 754             Tmp = GuidXml('Module')
 755             GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName')
 756             Module.SetGuidList(Module.GetGuidList() + [GuidProtocolPpi])
 757
 758         if XmlList(Item, '/ModuleSurfaceArea/Guids') and not XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):
 759             Module.SetGuidList([None])
 760
 761         #
 762         # Protocol
 763         #
 764         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):
 765             Tmp = ProtocolXml('Module')
 766             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol')
 767             Module.SetProtocolList(Module.GetProtocolList() + [GuidProtocolPpi])
 768
 769         if XmlList(Item, '/ModuleSurfaceArea/Protocols') and not XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):
 770             Module.SetProtocolList([None])
 771
 772         #
 773         # Ppi
 774         #
 775         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):
 776             Tmp = PpiXml('Module')
 777             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi')
 778             Module.SetPpiList(Module.GetPpiList() + [GuidProtocolPpi])
 779
 780         if XmlList(Item, '/ModuleSurfaceArea/PPIs') and not XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):
 781             Module.SetPpiList([None])
 782
 783         #
 784         # Extern
 785         #
 786         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):
 787             Tmp = ExternXml()
 788             Extern = Tmp.FromXml(SubItem, 'Extern')
 789             Module.SetExternList(Module.GetExternList() + [Extern])
 790
 791         if XmlList(Item, '/ModuleSurfaceArea/Externs') and not XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):
 792             Module.SetExternList([None])
 793
 794         if not Module.GetBinaryModule():
 795             #
 796             # PcdCoded
 797             #
 798             for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
 799                 Tmp = PcdEntryXml()
 800                 PcdEntry = Tmp.FromXml3(SubItem, 'PcdEntry')
 801                 Module.SetPcdList(Module.GetPcdList() + [PcdEntry])
 802
 803             if XmlList(Item, '/ModuleSurfaceArea/PcdCoded') and \
 804                 not XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
 805                 Module.SetPcdList([None])
 806
 807         Module = self.FromXml2(Item, Module)
 808         #
 809         # return the module object
 810         #
 811         self.Module = Module
 812         return self.Module
 813
 814     def ToXml(self, Module):
 815         if self.Package:
 816             pass
 817         #
 818         # Create root node of module surface area
 819         #
 820         DomModule = minidom.Document().createElement('ModuleSurfaceArea')
 821         if Module.GetBinaryModule():
 822             DomModule.setAttribute('BinaryModule', 'true')
 823
 824         #
 825         # Header
 826         #
 827         Tmp = HeaderXml()
 828         DomModule.appendChild(Tmp.ToXml(Module, 'Header'))
 829         #
 830         # ModuleProperties
 831         #
 832         Tmp = ModulePropertyXml()
 833         DomModule.appendChild(Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), \
 834                                         'ModuleProperties'))
 835         #
 836         # ClonedFrom
 837         #
 838         Tmp = ClonedFromXml()
 839         if Module.GetClonedFrom():
 840             DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), 'ClonedFrom'))
 841         #
 842         # LibraryClass
 843         #
 844         LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
 845         for LibraryClass in Module.GetLibraryClassList():
 846             Tmp = LibraryClassXml()
 847             LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, 'LibraryClass'))
 848         DomModule.appendChild(LibraryClassNode)
 849         #
 850         # SourceFile
 851         #
 852         SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
 853         for SourceFile in Module.GetSourceFileList():
 854             Tmp = SourceFileXml()
 855             SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename'))
 856         DomModule.appendChild(SourceFileNode)
 857         #
 858         # BinaryFile
 859         #
 860         BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
 861         for BinaryFile in Module.GetBinaryFileList():
 862             Tmp = BinaryFileXml()
 863             BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile'))
 864         DomModule.appendChild(BinaryFileNode)
 865         #
 866         # PackageDependencies
 867         #
 868         PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
 869         for PackageDependency in Module.GetPackageDependencyList():
 870             Tmp = PackageXml()
 871             PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package'))
 872         DomModule.appendChild(PackageDependencyNode)
 873
 874         #
 875         # Guid
 876         #
 877         GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
 878         for GuidProtocolPpi in Module.GetGuidList():
 879             Tmp = GuidXml('Module')
 880             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName'))
 881         DomModule.appendChild(GuidProtocolPpiNode)
 882
 883         #
 884         # Protocol
 885         #
 886         GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
 887         for GuidProtocolPpi in Module.GetProtocolList():
 888             Tmp = ProtocolXml('Module')
 889             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol'))
 890         DomModule.appendChild(GuidProtocolPpiNode)
 891
 892         #
 893         # Ppi
 894         #
 895         GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
 896         for GuidProtocolPpi in Module.GetPpiList():
 897             Tmp = PpiXml('Module')
 898             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi'))
 899         DomModule.appendChild(GuidProtocolPpiNode)
 900         #
 901         # Extern
 902         #
 903         ExternNode = CreateXmlElement('Externs', '', [], [])
 904         for Extern in Module.GetExternList():
 905             Tmp = ExternXml()
 906             ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern'))
 907         DomModule.appendChild(ExternNode)
 908         #
 909         # PcdCoded
 910         #
 911         PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
 912         for PcdEntry in Module.GetPcdList():
 913             Tmp = PcdEntryXml()
 914             PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, 'PcdEntry'))
 915         DomModule.appendChild(PcdEntryNode)
 916
 917         #
 918         # PeiDepex
 919         #
 920         if Module.GetPeiDepex():
 921             for Item in Module.GetPeiDepex():
 922                 Tmp = DepexXml()
 923                 DomModule.appendChild(Tmp.ToXml(Item, 'PeiDepex'))
 924
 925         #
 926         # DxeDepex
 927         #
 928         if Module.GetDxeDepex():
 929             for Item in Module.GetDxeDepex():
 930                 Tmp = DepexXml()
 931                 DomModule.appendChild(Tmp.ToXml(Item, 'DxeDepex'))
 932
 933         #
 934         # SmmDepex
 935         #
 936         if Module.GetSmmDepex():
 937             for Item in Module.GetSmmDepex():
 938                 Tmp = DepexXml()
 939                 DomModule.appendChild(Tmp.ToXml(Item, 'SmmDepex'))
 940
 941         #
 942         # MiscellaneousFile
 943         #
 944         if Module.GetMiscFileList():
 945             Tmp = MiscellaneousFileXml()
 946             DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], 'MiscellaneousFiles'))
 947         #
 948         # UserExtensions
 949         #
 950         if Module.GetUserExtensionList():
 951             for UserExtension in Module.GetUserExtensionList():
 952                 Tmp = UserExtensionsXml()
 953                 DomModule.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))
 954
 955         return DomModule
 956
 957 ##
 958 # BuildFlagXml used to generate BuildFlag for <AsBuilt>
 959 #
 960 class BuildFlagXml(object):
 961     def __init__(self):
 962         self.Target = ''
 963         self.TagName = ''
 964         self.Family = ''
 965         self.AsBuiltFlags = ''
 966
 967     def FromXml(self, Item, Key):
 968         self.Target = XmlElement(Item, '%s/Target' % Key)
 969         self.TagName = XmlElement(Item, '%s/TagName' % Key)
 970         self.Family = XmlElement(Item, '%s/Family' % Key)
 971
 972         BuildFlag = BinaryBuildFlagObject()
 973
 974         BuildFlag.SetTarget(self.Target)
 975         BuildFlag.SetTagName(self.TagName)
 976         BuildFlag.SetFamily(self.Family)
 977
 978         return BuildFlag
 979
 980     #
 981     # For AsBuild INF usage
 982     #
 983     def FromXml2(self, Item, Key):
 984         self.AsBuiltFlags = XmlElement(Item, '%s' % Key)
 985
 986         LineList = GetSplitValueList(self.AsBuiltFlags, '\n')
 987         ReturnLine = ''
 988         Count = 0
 989         for Line in LineList:
 990             if Count == 0:
 991                 ReturnLine = "# " + Line
 992             else:
 993                 ReturnLine = ReturnLine + '\n' + '# ' + Line
 994             Count += 1
 995
 996         BuildFlag = BinaryBuildFlagObject()
 997         BuildFlag.SetAsBuiltOptionFlags(ReturnLine)
 998
 999         return BuildFlag
1000
1001     def ToXml(self, BuildFlag, Key):
1002         if self.Target:
1003             pass
1004         AttributeList = []
1005         NodeList = []
1006         NodeList.append(['BuildFlags', BuildFlag])
1007
1008         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1009         return Root