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