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