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

   1 ## @file
   2 # This file is used to parse a Package 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 PackageSurfaceAreaXml
  17 '''
  18 from xml.dom import minidom
  19
  20 from Library.String import GetStringOfList
  21 from Library.Xml.XmlRoutines import XmlElement
  22 from Library.Xml.XmlRoutines import XmlNode
  23 from Library.Xml.XmlRoutines import XmlList
  24 from Library.Xml.XmlRoutines import CreateXmlElement
  25 from Object.POM.CommonObject import IncludeObject
  26 from Object.POM.CommonObject import TextObject
  27 from Object.POM.PackageObject import PackageObject
  28 from Xml.CommonXml import ClonedFromXml
  29 from Xml.CommonXml import PackageHeaderXml
  30 from Xml.CommonXml import HelpTextXml
  31 from Xml.CommonXml import CommonDefinesXml
  32 from Xml.CommonXml import LibraryClassXml
  33 from Xml.CommonXml import UserExtensionsXml
  34 from Xml.CommonXml import MiscellaneousFileXml
  35 from Xml.GuidProtocolPpiXml import GuidXml
  36 from Xml.GuidProtocolPpiXml import ProtocolXml
  37 from Xml.GuidProtocolPpiXml import PpiXml
  38 from Xml.ModuleSurfaceAreaXml import ModuleSurfaceAreaXml
  39 from Xml.PcdXml import PcdEntryXml
  40
  41 ##
  42 # IndustryStandardHeaderXml
  43 #
  44 class IndustryStandardHeaderXml(object):
  45     def __init__(self):
  46         self.HeaderFile = ''
  47         self.HelpText = []
  48
  49     def FromXml(self, Item, Key):
  50         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
  51         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
  52             HelpTextObj = HelpTextXml()
  53             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
  54             self.HelpText.append(HelpTextObj)
  55
  56         Include = IncludeObject()
  57         Include.SetFilePath(self.HeaderFile)
  58         HelpTxt = TextObject()
  59         HelpTxt.SetString(self.HelpText)
  60         Include.SetHelpText(HelpTxt)
  61
  62         return Include
  63
  64     def ToXml(self, IndustryStandardHeader, Key):
  65         if self.HeaderFile:
  66             pass
  67         AttributeList = []
  68         NodeList = [['HeaderFile', IndustryStandardHeader.GetFilePath()]]
  69         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
  70
  71         return Root
  72
  73     def __str__(self):
  74         Str = "HeaderFile = %s" % (self.HeaderFile)
  75         for Item in self.HelpText:
  76             Str = Str + "\n\t" + str(Item)
  77         return Str
  78 ##
  79 # PackageIncludeHeaderXml
  80 #
  81 class PackageIncludeHeaderXml(object):
  82     def __init__(self):
  83         self.HeaderFile = ''
  84         self.CommonDefines = CommonDefinesXml()
  85         self.HelpText = []
  86
  87     def FromXml(self, Item, Key):
  88         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
  89         self.CommonDefines.FromXml(XmlNode(Item, '%s/HeaderFile' % Key), 'HeaderFile')
  90         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
  91             HelpTextObj = HelpTextXml()
  92             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
  93             self.HelpText.append(HelpTextObj)
  94
  95         Include = IncludeObject()
  96         Include.SetFilePath(self.HeaderFile)
  97         Include.SetSupArchList(self.CommonDefines.SupArchList)
  98         HelpTxt = TextObject()
  99         HelpTxt.SetString(self.HelpText)
 100         Include.SetHelpText(HelpTxt)
 101
 102         return Include
 103
 104     def ToXml(self, PackageIncludeHeader, Key):
 105         if self.HeaderFile:
 106             pass
 107         AttributeList = [['SupArchList', GetStringOfList(PackageIncludeHeader.GetSupArchList())], \
 108                          ['SupModList', GetStringOfList(PackageIncludeHeader.GetSupModuleList())], ]
 109
 110         HeaderFileNode = CreateXmlElement('HeaderFile', PackageIncludeHeader.FilePath, [], AttributeList)
 111
 112         NodeList = [HeaderFileNode]
 113         for Item in PackageIncludeHeader.GetHelpTextList():
 114             Tmp = HelpTextXml()
 115             NodeList.append(Tmp.ToXml(Item))
 116
 117         Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 118
 119         return Root
 120
 121     def __str__(self):
 122         Str = "HeaderFile = %s\n\t%s" % (self.HeaderFile, self.CommonDefines)
 123         for Item in self.HelpText:
 124             Str = Str + "\n\t" + str(Item)
 125         return Str
 126
 127 ##
 128 # PcdCheckXml
 129 #
 130 class PcdCheckXml(object):
 131     def __init__(self):
 132         self.PcdCheck = ''
 133
 134     def FromXml(self, Item, Key):
 135         if Key:
 136             pass
 137         self.PcdCheck = XmlElement(Item, 'PcdCheck')
 138
 139         return self.PcdCheck
 140
 141     def ToXml(self, PcdCheck, Key):
 142         if self.PcdCheck:
 143             pass
 144         Root = CreateXmlElement('%s' % Key, PcdCheck, [], [])
 145         return Root
 146
 147     def __str__(self):
 148         return "PcdCheck = %s" % (self.PcdCheck)
 149
 150 ##
 151 # PackageSurfaceAreaXml
 152 #
 153 class PackageSurfaceAreaXml(object):
 154     def __init__(self):
 155         self.Package = None
 156
 157     def FromXml(self, Item, Key):
 158         if Key:
 159             pass
 160         #
 161         # Create a package object
 162         #
 163         Package = PackageObject()
 164         #
 165         # Header
 166         #
 167         Tmp = PackageHeaderXml()
 168         Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/Header'), 'Header', Package)
 169         #
 170         # ClonedFrom
 171         #
 172         Tmp = ClonedFromXml()
 173         if XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'):
 174             ClonedFrom = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'), 'ClonedFrom')
 175             Package.SetClonedFromList([ClonedFrom])
 176         #
 177         # LibraryClass
 178         #
 179
 180         for SubItem in XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'):
 181             Tmp = LibraryClassXml()
 182             LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')
 183             Package.SetLibraryClassList(Package.GetLibraryClassList() + [LibraryClass])
 184
 185         if XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations') and \
 186            not XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'):
 187             Package.SetLibraryClassList([None])
 188
 189         #
 190         # IndustryStandardHeader
 191         #
 192         for SubItem in XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'):
 193             Tmp = IndustryStandardHeaderXml()
 194             Include = Tmp.FromXml(SubItem, 'IndustryStandardHeader')
 195             Package.SetStandardIncludeFileList(Package.GetStandardIncludeFileList() + [Include])
 196
 197         if XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes') and \
 198         not XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'):
 199             Package.SetStandardIncludeFileList([None])
 200
 201
 202         #
 203         # PackageHeader
 204         #
 205         for SubItem in XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'):
 206             Tmp = PackageIncludeHeaderXml()
 207             Include = Tmp.FromXml(SubItem, 'PackageHeader')
 208             Package.SetPackageIncludeFileList(Package.GetPackageIncludeFileList() + [Include])
 209
 210         if XmlList(Item, '/PackageSurfaceArea/PackageIncludes') and not \
 211            XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'):
 212             Package.SetPackageIncludeFileList([None])
 213
 214         #
 215         # Guid
 216         #
 217         for SubItem in XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'):
 218             Tmp = GuidXml('Package')
 219             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
 220             Package.SetGuidList(Package.GetGuidList() + [GuidProtocolPpi])
 221
 222         if XmlList(Item, '/PackageSurfaceArea/GuidDeclarations') and not \
 223            XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'):
 224             Package.SetGuidList([None])
 225
 226         #
 227         # Protocol
 228         #
 229         for SubItem in XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'):
 230             Tmp = ProtocolXml('Package')
 231             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
 232             Package.SetProtocolList(Package.GetProtocolList() + [GuidProtocolPpi])
 233
 234         if XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations') and not \
 235            XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'):
 236             Package.SetProtocolList([None])
 237
 238         #
 239         # Ppi
 240         #
 241         for SubItem in XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'):
 242             Tmp = PpiXml('Package')
 243             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
 244             Package.SetPpiList(Package.GetPpiList() + [GuidProtocolPpi])
 245
 246         if XmlList(Item, '/PackageSurfaceArea/PpiDeclarations') and not \
 247            XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'):
 248             Package.SetPpiList([None])
 249
 250         #
 251         # PcdEntry
 252         #
 253         for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'):
 254             Tmp = PcdEntryXml()
 255             PcdEntry = Tmp.FromXml2(SubItem, 'PcdEntry')
 256             Package.SetPcdList(Package.GetPcdList() + [PcdEntry])
 257
 258         if XmlList(Item, '/PackageSurfaceArea/PcdDeclarations') and not \
 259            XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'):
 260             Package.SetPcdList([None])
 261
 262         #
 263         # PcdCheck
 264         #
 265         for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdRelationshipChecks/PcdCheck'):
 266             Tmp = PcdCheckXml()
 267             PcdCheck = Tmp.FromXml(SubItem, 'PcdCheck')
 268             Package.PcdChecks.append(PcdCheck)
 269
 270         #
 271         # Modules
 272         #
 273         for SubItem in XmlList(Item, '/PackageSurfaceArea/Modules/ModuleSurfaceArea'):
 274             Tmp = ModuleSurfaceAreaXml()
 275             Module = Tmp.FromXml(SubItem, 'ModuleSurfaceArea')
 276             Package.ModuleDict[(Module.GetGuid(), Module.GetVersion(), Module.GetModulePath())] = Module
 277         #
 278         # MiscellaneousFile
 279         #
 280         Tmp = MiscellaneousFileXml()
 281         MiscFileList = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
 282         if MiscFileList:
 283             Package.SetMiscFileList([MiscFileList])
 284         else:
 285             Package.SetMiscFileList([])
 286
 287         #
 288         # UserExtensions
 289         #
 290         for Item in XmlList(Item, '/PackageSurfaceArea/UserExtensions'):
 291             Tmp = UserExtensionsXml()
 292             UserExtension = Tmp.FromXml(Item, 'UserExtensions')
 293             Package.UserExtensionList.append(UserExtension)
 294
 295         self.Package = Package
 296         return self.Package
 297
 298     def ToXml(self, Package):
 299         if self.Package:
 300             pass
 301         #
 302         # Create PackageSurfaceArea node
 303         #
 304         DomPackage = minidom.Document().createElement('PackageSurfaceArea')
 305         #
 306         # Header
 307         #
 308         Tmp = PackageHeaderXml()
 309         DomPackage.appendChild(Tmp.ToXml(Package, 'Header'))
 310         #
 311         # ClonedFrom
 312         #
 313         Tmp = ClonedFromXml()
 314         if Package.GetClonedFromList() != []:
 315             DomPackage.appendChild(Tmp.ToXml(Package.GetClonedFromList[0], 'ClonedFrom'))
 316         #
 317         # LibraryClass
 318         #
 319         LibraryClassNode = CreateXmlElement('LibraryClassDeclarations', '', [], [])
 320         for LibraryClass in Package.GetLibraryClassList():
 321             Tmp = LibraryClassXml()
 322             LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass'))
 323         DomPackage.appendChild(LibraryClassNode)
 324         #
 325         # IndustryStandardHeader
 326         #
 327         IndustryStandardHeaderNode = CreateXmlElement('IndustryStandardIncludes', '', [], [])
 328         for Include in Package.GetStandardIncludeFileList():
 329             Tmp = IndustryStandardHeaderXml()
 330             IndustryStandardHeaderNode.appendChild(Tmp.ToXml(Include, 'IndustryStandardHeader'))
 331         DomPackage.appendChild(IndustryStandardHeaderNode)
 332         #
 333         # PackageHeader
 334         #
 335         PackageIncludeHeaderNode = CreateXmlElement('PackageIncludes', '', [], [])
 336         for Include in Package.GetPackageIncludeFileList():
 337             Tmp = PackageIncludeHeaderXml()
 338             PackageIncludeHeaderNode.appendChild(Tmp.ToXml(Include, 'PackageHeader'))
 339         DomPackage.appendChild(PackageIncludeHeaderNode)
 340         ModuleNode = CreateXmlElement('Modules', '', [], [])
 341         for Module in Package.GetModuleDict().values():
 342             Tmp = ModuleSurfaceAreaXml()
 343             ModuleNode.appendChild(Tmp.ToXml(Module))
 344         DomPackage.appendChild(ModuleNode)
 345         #
 346         # Guid
 347         #
 348         GuidProtocolPpiNode = CreateXmlElement('GuidDeclarations', '', [], [])
 349         for GuidProtocolPpi in Package.GetGuidList():
 350             Tmp = GuidXml('Package')
 351             GuidProtocolPpiNode.appendChild(Tmp.ToXml\
 352                                             (GuidProtocolPpi, 'Entry'))
 353         DomPackage.appendChild(GuidProtocolPpiNode)
 354         #
 355         # Protocol
 356         #
 357         GuidProtocolPpiNode = \
 358         CreateXmlElement('ProtocolDeclarations', '', [], [])
 359         for GuidProtocolPpi in Package.GetProtocolList():
 360             Tmp = ProtocolXml('Package')
 361             GuidProtocolPpiNode.appendChild\
 362             (Tmp.ToXml(GuidProtocolPpi, 'Entry'))
 363         DomPackage.appendChild(GuidProtocolPpiNode)
 364         #
 365         # Ppi
 366         #
 367         GuidProtocolPpiNode = CreateXmlElement('PpiDeclarations', '', [], [])
 368         for GuidProtocolPpi in Package.GetPpiList():
 369             Tmp = PpiXml('Package')
 370             GuidProtocolPpiNode.appendChild\
 371             (Tmp.ToXml(GuidProtocolPpi, 'Entry'))
 372         DomPackage.appendChild(GuidProtocolPpiNode)
 373         #
 374         # PcdEntry
 375         #
 376         PcdEntryNode = CreateXmlElement('PcdDeclarations', '', [], [])
 377         for PcdEntry in Package.GetPcdList():
 378             Tmp = PcdEntryXml()
 379             PcdEntryNode.appendChild(Tmp.ToXml2(PcdEntry, 'PcdEntry'))
 380         DomPackage.appendChild(PcdEntryNode)
 381
 382         #
 383         # MiscellaneousFile
 384         #
 385         Tmp = MiscellaneousFileXml()
 386         if Package.GetMiscFileList():
 387             DomPackage.appendChild(Tmp.ToXml(Package.GetMiscFileList()[0], 'MiscellaneousFiles'))
 388
 389         #
 390         # UserExtensions
 391         #
 392         if Package.GetUserExtensionList():
 393             for UserExtension in Package.GetUserExtensionList():
 394                 Tmp = UserExtensionsXml()
 395                 DomPackage.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))
 396
 397         return DomPackage