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