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

   1 ## @file
   2 # This file is used to parse a xml 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 XmlParser
  17 '''
  18
  19 ##
  20 # Import Modules
  21 #
  22 import re
  23
  24 from Library.Xml.XmlRoutines import XmlNode
  25 from Library.Xml.XmlRoutines import CreateXmlElement
  26 from Library.Xml.XmlRoutines import XmlList
  27 from Library.Xml.XmlRoutines import XmlParseFile
  28 from Core.DistributionPackageClass import DistributionPackageClass
  29 from Object.POM.ModuleObject import DepexObject
  30 from Library.ParserValidate import IsValidInfMoudleType
  31 from Library.ParserValidate import IsValidInstallPath
  32 from Library.Misc import IsEqualList
  33 from Library.Misc import Sdict
  34
  35 from Logger.StringTable import ERR_XML_INVALID_VARIABLENAME
  36 from Logger.StringTable import ERR_XML_INVALID_LIB_SUPMODLIST
  37 from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPARCHLIST
  38 from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST
  39 from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST_NOT_LIB
  40 from Logger.StringTable import ERR_FILE_NAME_INVALIDE
  41 from Logger.StringTable import ERR_XML_INVALID_BINARY_FILE_TYPE
  42 from Logger.ToolError import PARSER_ERROR
  43 from Logger.ToolError import FORMAT_INVALID
  44
  45 from Xml.CommonXml import DistributionPackageHeaderXml
  46 from Xml.CommonXml import MiscellaneousFileXml
  47 from Xml.CommonXml import UserExtensionsXml
  48 from Xml.XmlParserMisc import ConvertVariableName
  49 from Xml.XmlParserMisc import IsRequiredItemListNull
  50 from Xml.ModuleSurfaceAreaXml import ModuleSurfaceAreaXml
  51 from Xml.PackageSurfaceAreaXml import PackageSurfaceAreaXml
  52
  53 import Logger.Log as Logger
  54
  55 ##
  56 # DistributionPackageXml
  57 #
  58 class DistributionPackageXml(object):
  59     def __init__(self):
  60         self.DistP = DistributionPackageClass()
  61         self.Pkg = ''
  62
  63     ## ValidateDistributionPackage
  64     #
  65     # Check if any required item is missing in DistributionPackage
  66     #
  67     def ValidateDistributionPackage(self):
  68         XmlTreeLevel = ['DistributionPackage']
  69         if self.DistP:
  70             #
  71             # Check DistributionPackage -> DistributionHeader
  72             #
  73             XmlTreeLevel = ['DistributionPackage', '']
  74             CheckDict = {'DistributionHeader':self.DistP.Header }
  75             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
  76
  77             if self.DistP.Header:
  78                 DpHeader = self.DistP.Header
  79                 XmlTreeLevel = ['DistributionPackage', 'DistributionHeader']
  80                 CheckDict = Sdict()
  81                 CheckDict['Name'] = DpHeader.GetName()
  82                 CheckDict['GUID'] = DpHeader.GetGuid()
  83                 CheckDict['Version'] = DpHeader.GetVersion()
  84                 CheckDict['Copyright'] = DpHeader.GetCopyright()
  85                 CheckDict['License'] = DpHeader.GetLicense()
  86                 CheckDict['Abstract'] = DpHeader.GetAbstract()
  87                 CheckDict['Vendor'] = DpHeader.GetVendor()
  88                 CheckDict['Date'] = DpHeader.GetDate()
  89                 CheckDict['XmlSpecification'] = DpHeader.GetXmlSpecification()
  90
  91                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
  92             else:
  93                 XmlTreeLevel = ['DistributionPackage', 'DistributionHeader']
  94                 CheckDict = CheckDict = {'DistributionHeader':'', }
  95                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
  96
  97             #
  98             # Check Each Package
  99             #
 100             for Key in self.DistP.PackageSurfaceArea:
 101                 ValidatePackageSurfaceArea(self.DistP.PackageSurfaceArea[Key])
 102
 103             #
 104             # Check Each Module
 105             #
 106             for Key in self.DistP.ModuleSurfaceArea:
 107                 ValidateMS(self.DistP.ModuleSurfaceArea[Key], ['DistributionPackage', 'ModuleSurfaceArea'])
 108
 109             #
 110             # Check Each Tool
 111             #
 112             if self.DistP.Tools:
 113                 XmlTreeLevel = ['DistributionPackage', 'Tools', 'Header']
 114                 CheckDict = {'Name':self.DistP.Tools.GetName(), }
 115                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 116
 117                 if not self.DistP.Tools.GetFileList():
 118                     XmlTreeLevel = ['DistributionPackage', 'Tools']
 119                     CheckDict = {'FileName':None, }
 120                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 121                 for Item in self.DistP.Tools.GetFileList():
 122                     XmlTreeLevel = ['DistributionPackage', 'Tools']
 123                     CheckDict = {'FileName':Item.GetURI(), }
 124                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 125
 126             #
 127             # Check Each Misc File
 128             #
 129             if self.DistP.MiscellaneousFiles:
 130                 XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles', 'Header']
 131                 CheckDict = {'Name':self.DistP.MiscellaneousFiles.GetName(), }
 132                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 133
 134                 if not self.DistP.MiscellaneousFiles.GetFileList():
 135                     XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles']
 136                     CheckDict = {'FileName':None, }
 137                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 138                 for Item in self.DistP.MiscellaneousFiles.GetFileList():
 139                     XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles']
 140                     CheckDict = {'FileName':Item.GetURI(), }
 141                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 142
 143             #
 144             # Check Each Distribution Level User Extension
 145             #
 146             for Item in self.DistP.UserExtensions:
 147                 XmlTreeLevel = ['DistributionPackage', 'UserExtensions']
 148                 CheckDict = {'UserId':Item.GetUserID(), }
 149                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 150
 151
 152     def FromXml(self, Filename=None):
 153         if Filename != None:
 154             self.DistP = DistributionPackageClass()
 155             #
 156             # Load to XML
 157             #
 158             self.Pkg = XmlParseFile(Filename)
 159
 160             #
 161             # Parse Header information
 162             #
 163             Tmp = DistributionPackageHeaderXml()
 164             DistributionPackageHeader = \
 165             Tmp.FromXml(XmlNode(self.Pkg, '/DistributionPackage/DistributionHeader'), 'DistributionHeader')
 166             self.DistP.Header = DistributionPackageHeader
 167             #
 168             # Parse each PackageSurfaceArea
 169             #
 170             for Item in XmlList(self.Pkg, '/DistributionPackage/PackageSurfaceArea'):
 171                 Psa = PackageSurfaceAreaXml()
 172                 Package = Psa.FromXml(Item, 'PackageSurfaceArea')
 173                 self.DistP.PackageSurfaceArea[(Package.GetGuid(), \
 174                                                Package.GetVersion(), \
 175                                                Package.GetPackagePath())] = \
 176                                                Package
 177             #
 178             # Parse each ModuleSurfaceArea
 179             #
 180             for Item in XmlList(self.Pkg, '/DistributionPackage/ModuleSurfaceArea'):
 181                 Msa = ModuleSurfaceAreaXml()
 182                 Module = Msa.FromXml(Item, 'ModuleSurfaceArea', True)
 183                 self.DistP.ModuleSurfaceArea[(Module.GetGuid(), Module.GetVersion(), Module.GetModulePath())] = Module
 184             #
 185             # Parse Tools
 186             #
 187             Tmp = MiscellaneousFileXml()
 188             self.DistP.Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools')
 189
 190             #
 191             # Parse MiscFiles
 192             #
 193             Tmp = MiscellaneousFileXml()
 194             self.DistP.MiscellaneousFiles = \
 195             Tmp.FromXml2(XmlNode(self.Pkg, \
 196                                  '/DistributionPackage/MiscellaneousFiles'), \
 197                                  'MiscellaneousFiles')
 198
 199             #
 200             # Parse UserExtensions
 201             #
 202             for Item in XmlList(self.Pkg, '/DistributionPackage/UserExtensions'):
 203                 Tmp = UserExtensionsXml()
 204                 self.DistP.UserExtensions.append(Tmp.FromXml2(Item, 'UserExtensions'))
 205
 206             #
 207             # Check Required Items for XML
 208             #
 209             self.ValidateDistributionPackage()
 210
 211             return self.DistP
 212
 213     def ToXml(self, DistP):
 214         if self.DistP:
 215             pass
 216         if DistP != None:
 217             #
 218             # Parse DistributionPackageHeader
 219             #
 220             Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'],
 221                      ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
 222                      ]
 223             Root = CreateXmlElement('DistributionPackage', '', [], Attrs)
 224
 225             Tmp = DistributionPackageHeaderXml()
 226             Root.appendChild(Tmp.ToXml(DistP.Header, 'DistributionHeader'))
 227             #
 228             # Parse each PackageSurfaceArea
 229             #
 230             for Package in DistP.PackageSurfaceArea.values():
 231                 Psa = PackageSurfaceAreaXml()
 232                 DomPackage = Psa.ToXml(Package)
 233                 Root.appendChild(DomPackage)
 234             #
 235             # Parse each ModuleSurfaceArea
 236             #
 237             for Module in DistP.ModuleSurfaceArea.values():
 238                 Msa = ModuleSurfaceAreaXml()
 239                 DomModule = Msa.ToXml(Module)
 240                 Root.appendChild(DomModule)
 241             #
 242             # Parse Tools
 243             #
 244             Tmp = MiscellaneousFileXml()
 245             ToolNode = Tmp.ToXml2(DistP.Tools, 'Tools')
 246             if ToolNode is not None:
 247                 Root.appendChild(ToolNode)
 248             #
 249             # Parse MiscFiles
 250             #
 251             Tmp = MiscellaneousFileXml()
 252             MiscFileNode = Tmp.ToXml2(DistP.MiscellaneousFiles,
 253                                       'MiscellaneousFiles')
 254             if MiscFileNode is not None:
 255                 Root.appendChild(MiscFileNode)
 256
 257             XmlContent = Root.toprettyxml(indent='  ')
 258
 259
 260             #
 261             # Remove empty element
 262             #
 263             XmlContent = re.sub(r'[\s\r\n]*<[^<>=]*/>', '', XmlContent)
 264
 265             #
 266             # Remove empty help text element
 267             #
 268             XmlContent = re.sub(r'[\s\r\n]*<HelpText Lang="en-US"/>', '',
 269                                 XmlContent)
 270
 271             #
 272             # Remove SupArchList="COMMON" or "common"
 273             #
 274             XmlContent = \
 275             re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON'
 276             '[\s\r\n]*"', '', XmlContent)
 277             XmlContent = \
 278             re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common'
 279             '[\s\r\n]*"', '', XmlContent)
 280             #
 281             # Remove <SupArchList> COMMON </SupArchList>
 282             #
 283             XmlContent = \
 284             re.sub(r'[\s\r\n]*<SupArchList>[\s\r\n]*COMMON[\s\r\n]*'
 285             '</SupArchList>[\s\r\n]*', '', XmlContent)
 286
 287             #
 288             # Remove <SupArchList> common </SupArchList>
 289             #
 290             XmlContent = \
 291             re.sub(r'[\s\r\n]*<SupArchList>[\s\r\n]*'
 292             'common[\s\r\n]*</SupArchList>[\s\r\n]*', '', XmlContent)
 293
 294             #
 295             # Remove SupModList="COMMON" or "common"
 296             #
 297             XmlContent = \
 298             re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON'
 299             '[\s\r\n]*"', '', XmlContent)
 300             XmlContent = \
 301             re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common'
 302             '[\s\r\n]*"', '', XmlContent)
 303
 304             return XmlContent
 305
 306         return ''
 307
 308 ## ValidateMS
 309 #
 310 # Check if any required item is missing in ModuleSurfaceArea
 311 #
 312 # @param Module: The ModuleSurfaceArea to be checked
 313 # @param XmlTreeLevel: The top level of Module
 314 #
 315 def ValidateMS(Module, TopXmlTreeLevel):
 316     ValidateMS1(Module, TopXmlTreeLevel)
 317     ValidateMS2(Module, TopXmlTreeLevel)
 318     ValidateMS3(Module, TopXmlTreeLevel)
 319
 320 ## ValidateMS1
 321 #
 322 # Check if any required item is missing in ModuleSurfaceArea
 323 #
 324 # @param Module: The ModuleSurfaceArea to be checked
 325 # @param XmlTreeLevel: The top level of Module
 326 #
 327 def ValidateMS1(Module, TopXmlTreeLevel):
 328     #
 329     # Check Guids -> GuidCName
 330     #
 331     XmlTreeLevel = TopXmlTreeLevel + ['Guids']
 332     for Item in Module.GetGuidList():
 333         if Item == None:
 334             CheckDict = {'GuidCName':''}
 335             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 336
 337     XmlTreeLevel = TopXmlTreeLevel + ['Guids', 'GuidCName']
 338     for Item in Module.GetGuidList():
 339         CheckDict = {'CName':Item.GetCName(),
 340                      'GuidType':Item.GetGuidTypeList(),
 341                      'Usage':Item.GetUsage()}
 342         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 343
 344         if Item.GetVariableName():
 345             Result = ConvertVariableName(Item.GetVariableName())
 346             if Result is None:
 347                 Msg = "->".join(Node for Node in XmlTreeLevel)
 348                 ErrorMsg = ERR_XML_INVALID_VARIABLENAME % (Item.GetVariableName(), Item.GetCName(), Msg)
 349                 Logger.Error('\nUPT', PARSER_ERROR, ErrorMsg, RaiseError=True)
 350             else:
 351                 Item.SetVariableName(Result)
 352
 353     #
 354     # Check Protocols -> Protocol
 355     #
 356     XmlTreeLevel = TopXmlTreeLevel + ['Protocols']
 357     for Item in Module.GetProtocolList():
 358         if Item == None:
 359             CheckDict = {'Protocol':''}
 360             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 361
 362     XmlTreeLevel = TopXmlTreeLevel + ['Protocols', 'Protocol']
 363     for Item in Module.GetProtocolList():
 364         CheckDict = {'CName':Item.GetCName(),
 365                      'Usage':Item.GetUsage()}
 366         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 367
 368     #
 369     # Check PPIs -> Ppi
 370     #
 371     XmlTreeLevel = TopXmlTreeLevel + ['PPIs']
 372     for Item in Module.GetPpiList():
 373         if Item == None:
 374             CheckDict = {'Ppi':''}
 375             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 376
 377     XmlTreeLevel = TopXmlTreeLevel + ['PPIs', 'Ppi']
 378     for Item in Module.GetPpiList():
 379         CheckDict = {'CName':Item.GetCName(),
 380                      'Usage':Item.GetUsage()}
 381         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 382
 383     #
 384     # Check PcdCoded -> Entry
 385     #
 386     XmlTreeLevel = TopXmlTreeLevel + ['PcdCoded']
 387     for Item in Module.GetPcdList():
 388         if Item == None:
 389             CheckDict = {'PcdEntry':''}
 390             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 391
 392     XmlTreeLevel = TopXmlTreeLevel + ['PcdCoded', 'PcdEntry']
 393     for Item in Module.GetPcdList():
 394         CheckDict = {'TokenSpaceGuidCname':Item.GetTokenSpaceGuidCName(),
 395                      'CName':Item.GetCName(),
 396                      'PcdUsage':Item.GetValidUsage(),
 397                      'PcdItemType':Item.GetItemType()}
 398         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 399
 400     #
 401     # Check Externs -> Extern
 402     #
 403     XmlTreeLevel = TopXmlTreeLevel + ['Externs']
 404     for Item in Module.GetExternList():
 405         if Item == None:
 406             CheckDict = {'Extern':''}
 407             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 408
 409     #
 410     # If SupArchList is used to identify different EntryPoint, UnloadImage, Constructor/Destructor elements and
 411     # that SupArchList does not match ModuleSurfaceArea.ModuleProperties:SupArchList, the tool must exit gracefully,
 412     # informing the user that the EDK II Build system does not support different EntryPoint, UnloadImage,
 413     # Constructor or Destructor elements based on Architecture type.  Two SupArchList attributes are considered
 414     # identical if it lists the same CPU architectures in any order.
 415     #
 416     for Item in Module.GetExternList():
 417         if len(Item.SupArchList) > 0:
 418             if not IsEqualList(Item.SupArchList, Module.SupArchList):
 419                 Logger.Error('\nUPT',
 420                              PARSER_ERROR,
 421                              ERR_XML_INVALID_EXTERN_SUPARCHLIST % (str(Item.SupArchList), str(Module.SupArchList)),
 422                              RaiseError=True)
 423
 424     #
 425     # Check DistributionPackage -> ModuleSurfaceArea -> UserExtensions
 426     #
 427     XmlTreeLevel = TopXmlTreeLevel + ['UserExtensions']
 428     for Item in Module.GetUserExtensionList():
 429         CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()}
 430         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 431
 432     #
 433     # Check DistributionPackage -> PackageSurfaceArea -> MiscellaneousFiles -> Filename
 434     #
 435     XmlTreeLevel = TopXmlTreeLevel + ['MiscellaneousFiles']
 436     for Item in Module.GetMiscFileList():
 437         if not Item.GetFileList():
 438             CheckDict = {'Filename':'', }
 439             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 440         for File in Item.GetFileList():
 441             CheckDict = {'Filename':File.GetURI(), }
 442
 443 ## ValidateMS2
 444 #
 445 # Check if any required item is missing in ModuleSurfaceArea
 446 #
 447 # @param Module: The ModuleSurfaceArea to be checked
 448 # @param XmlTreeLevel: The top level of Module
 449 #
 450 def ValidateMS2(Module, TopXmlTreeLevel):
 451     #
 452     # Check Header
 453     #
 454     XmlTreeLevel = TopXmlTreeLevel + ['Header']
 455     CheckDict = Sdict()
 456     CheckDict['Name'] = Module.GetName()
 457     CheckDict['BaseName'] = Module.GetBaseName()
 458     CheckDict['GUID'] = Module.GetGuid()
 459     CheckDict['Version'] = Module.GetVersion()
 460     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 461
 462     #
 463     # Check ModuleProperties
 464     #
 465     XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties']
 466     CheckDict = {'ModuleType':Module.GetModuleType(),
 467                  'Path':Module.GetModulePath()}
 468     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 469
 470     if not IsValidInstallPath(Module.GetModulePath()):
 471         Logger.Error("UPT", FORMAT_INVALID, ERR_FILE_NAME_INVALIDE % Module.GetModulePath())
 472
 473     #
 474     # Check ModuleProperties->BootMode
 475     #
 476     XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['BootMode']
 477     for Item in Module.GetBootModeList():
 478         CheckDict = {'Usage':Item.GetUsage(),
 479                      'SupportedBootModes':Item.GetSupportedBootModes()}
 480         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 481
 482     #
 483     # Check ModuleProperties->Event
 484     #
 485     XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['Event']
 486     for Item in Module.GetEventList():
 487         CheckDict = {'Usage':Item.GetUsage(),
 488                      'EventType':Item.GetEventType()}
 489         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 490
 491     #
 492     # Check ModuleProperties->Hob
 493     #
 494     XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['HOB']
 495     for Item in Module.GetHobList():
 496         CheckDict = {'Usage':Item.GetUsage(),
 497                      'HobType':Item.GetHobType()}
 498         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 499
 500     #
 501     # The UDP Specification supports the module type of UEFI_RUNTIME_DRIVER, which is not present in the EDK II INF
 502     # File Specification v. 1.23, so UPT must perform the following translation that include the generation of a
 503     # [Depex] section.
 504     #
 505     if Module.ModuleType == "UEFI_RUNTIME_DRIVER":
 506         Module.ModuleType = "DXE_RUNTIME_DRIVER"
 507         DxeObj = DepexObject()
 508         DxeObj.SetDepex("gEfiBdsArchProtocolGuid AND \ngEfiCpuArchProtocolGuid AND\n" + \
 509                         "gEfiMetronomeArchProtocolGuid AND \ngEfiMonotonicCounterArchProtocolGuid AND\n" + \
 510                         "gEfiRealTimeClockArchProtocolGuid AND \ngEfiResetArchProtocolGuid AND\n" + \
 511                         "gEfiRuntimeArchProtocolGuid AND \ngEfiSecurityArchProtocolGuid AND\n" + \
 512                         "gEfiTimerArchProtocolGuid AND \ngEfiVariableWriteArchProtocolGuid AND\n" + \
 513                         "gEfiVariableArchProtocolGuid AND \ngEfiWatchdogTimerArchProtocolGuid")
 514         DxeObj.SetModuleType(['DXE_RUNTIME_DRIVER'])
 515         Module.PeiDepex = []
 516         Module.DxeDepex = []
 517         Module.SmmDepex = []
 518         Module.DxeDepex.append(DxeObj)
 519
 520     #
 521     # Check LibraryClassDefinitions -> LibraryClass
 522     #
 523     XmlTreeLevel = TopXmlTreeLevel + ['LibraryClassDefinitions']
 524     for Item in Module.GetLibraryClassList():
 525         if Item == None:
 526             CheckDict = {'LibraryClass':''}
 527             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 528
 529     XmlTreeLevel = TopXmlTreeLevel + ['LibraryClassDefinitions', 'LibraryClass']
 530
 531     IsLibraryModule = False
 532     LibrarySupModList = []
 533     for Item in Module.GetLibraryClassList():
 534         CheckDict = {'Keyword':Item.GetLibraryClass(),
 535                      'Usage':Item.GetUsage()}
 536         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 537         #
 538         # If the LibraryClass:SupModList is not "UNDEFINED" the LIBRARY_CLASS entry must have the list
 539         # appended using the format:
 540         # LIBRARY_CLASS = <ClassName> ["|" <Edk2ModuleTypeList>]
 541         #
 542         # Edk2ModuleTypeList ::= <ModuleType> [" " <ModuleType>]{0,}
 543         # <ModuleTypes>      ::= {"BASE"} {"SEC"} {"PEI_CORE"} {"PEIM"}
 544         #                       {"DXE_CORE"} {"DXE_DRIVER"} {"SMM_CORE"}
 545         #                       {"DXE_SMM_DRIVER"} {"DXE_RUNTIME_DRIVER"}
 546         #                       {"DXE_SAL_DRIVER"} {"UEFI_DRIVER"}
 547         #                       {"UEFI_APPLICATION"} {"USER_DEFINED"}
 548         #
 549         if len(Item.SupModuleList) > 0:
 550             for SupModule in Item.SupModuleList:
 551                 if not IsValidInfMoudleType(SupModule):
 552                     Logger.Error('\nUPT',
 553                                  PARSER_ERROR,
 554                                  ERR_XML_INVALID_LIB_SUPMODLIST % (Item.LibraryClass, str(SupModule)),
 555                                  RaiseError=True)
 556
 557         if Item.Usage == 'PRODUCES' or Item.Usage == 'SOMETIMES_PRODUCES':
 558             IsLibraryModule = True
 559             LibrarySupModList = Item.SupModuleList
 560
 561
 562     #
 563     # For Library modules (indicated by a LIBRARY_CLASS statement in the [Defines] section)
 564     # If the SupModList attribute of the CONSTRUCTOR or DESTRUCTOR element does not match the Supported Module
 565     # Types listed after "LIBRARY_CLASS = <Keyword> |", the tool should gracefully exit with an error message
 566     # stating that there is a conflict in the module types the CONSTRUCTOR/DESTRUCTOR is to be used with and
 567     # the Module types this Library supports.
 568     #
 569     if IsLibraryModule:
 570         for Item in Module.GetExternList():
 571             if Item.Constructor or Item.Destructor:
 572                 if hasattr(Item, 'SupModList') and len(Item.SupModList) > 0 and \
 573                    not IsEqualList(Item.SupModList, LibrarySupModList):
 574                     Logger.Error('\nUPT',
 575                          PARSER_ERROR,
 576                          ERR_XML_INVALID_EXTERN_SUPMODLIST % (str(Item.SupModList), str(LibrarySupModList)),
 577                          RaiseError=True)
 578
 579     #
 580     # If the module is not a library module, the MODULE_TYPE listed in the ModuleSurfaceArea.Header must match the
 581     # SupModList attribute.  If these conditions cannot be met, the tool must exit gracefully, informing the user
 582     # that the EDK II Build system does not currently support the features required by this Module.
 583     #
 584     if not IsLibraryModule:
 585         for Item in Module.GetExternList():
 586             if hasattr(Item, 'SupModList') and len(Item.SupModList) > 0 and \
 587                not IsEqualList(Item.SupModList, [Module.ModuleType]):
 588                 Logger.Error('\nUPT',
 589                      PARSER_ERROR,
 590                      ERR_XML_INVALID_EXTERN_SUPMODLIST_NOT_LIB % (str(Module.ModuleType), str(Item.SupModList)),
 591                      RaiseError=True)
 592     #
 593     # Check SourceFiles
 594     #
 595     XmlTreeLevel = TopXmlTreeLevel + ['SourceFiles']
 596     for Item in Module.GetSourceFileList():
 597         if Item == None:
 598             CheckDict = {'Filename':''}
 599             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 600
 601     XmlTreeLevel = TopXmlTreeLevel + ['SourceFiles']
 602     for Item in Module.GetSourceFileList():
 603         CheckDict = {'Filename':Item.GetSourceFile()}
 604         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 605
 606     for ItemCount in range(len(Module.GetBinaryFileList())):
 607         Item = Module.GetBinaryFileList()[ItemCount]
 608         if Item and len(Item.FileNamList) > 0 and Item.FileNamList[0].FileType == 'FREEFORM':
 609             Item.FileNamList[0].FileType = 'SUBTYPE_GUID'
 610             Module.GetBinaryFileList()[ItemCount] = Item
 611         if Item and len(Item.FileNamList) > 0 and Item.FileNamList[0].FileType == 'DISPOSABLE':
 612             Logger.Error('\nUPT',
 613                  PARSER_ERROR,
 614                  ERR_XML_INVALID_BINARY_FILE_TYPE % ('DISPOSABLE'),
 615                  RaiseError=True)
 616
 617 ## ValidateMS3
 618 #
 619 # Check if any required item is missing in ModuleSurfaceArea
 620 #
 621 # @param Module: The ModuleSurfaceArea to be checked
 622 # @param XmlTreeLevel: The top level of Module
 623 #
 624 def ValidateMS3(Module, TopXmlTreeLevel):
 625     #
 626     # Check PackageDependencies -> Package
 627     #
 628     XmlTreeLevel = TopXmlTreeLevel + ['PackageDependencies']
 629     for Item in Module.GetPackageDependencyList():
 630         if Item == None:
 631             CheckDict = {'Package':''}
 632             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 633
 634     XmlTreeLevel = TopXmlTreeLevel + ['PackageDependencies', 'Package']
 635     for Item in Module.GetPackageDependencyList():
 636         CheckDict = {'GUID':Item.GetGuid()}
 637         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 638
 639     #
 640     # Check BinaryFiles -> BinaryFile
 641     #
 642     for Item in Module.GetBinaryFileList():
 643         if Item == None:
 644             XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles']
 645             CheckDict = {'BinaryFile':''}
 646             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 647         if not Item.GetFileNameList():
 648             XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile']
 649             CheckDict = {'Filename':''}
 650             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 651
 652         XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile']
 653         for File in Item.GetFileNameList():
 654             CheckDict = {'Filename':File.GetFilename(),
 655                          'FileType':File.GetFileType()}
 656             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 657         for AsBuilt in Item.GetAsBuiltList():
 658             #
 659             # Check LibInstance
 660             #
 661             if len(AsBuilt.LibraryInstancesList) == 1 and not AsBuilt.LibraryInstancesList[0]:
 662                 CheckDict = {'GUID':''}
 663                 XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'LibraryInstances']
 664                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 665
 666             for LibItem in AsBuilt.LibraryInstancesList:
 667                 CheckDict = {'Guid':LibItem.Guid,
 668                              'Version':LibItem.Version}
 669                 XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'LibraryInstances']
 670                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 671
 672             #
 673             # Check PatchPcd
 674             #
 675             for PatchPcdItem in AsBuilt.PatchPcdList:
 676                 CheckDict = {'TokenSpaceGuidValue':PatchPcdItem.TokenSpaceGuidValue,
 677                              'PcdCName':PatchPcdItem.PcdCName,
 678                              'Token':PatchPcdItem.Token,
 679                              'DatumType':PatchPcdItem.DatumType,
 680                              'Value':PatchPcdItem.DefaultValue,
 681                              'Offset':PatchPcdItem.Offset}
 682                 XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'PatchPcdValue']
 683                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 684                 #
 685                 # Check PcdError
 686                 #
 687                 for PcdErrorItem in PatchPcdItem.PcdErrorsList:
 688                     CheckDict = {'ErrorNumber':PcdErrorItem.ErrorNumber}
 689                     XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt',
 690                                                       'PatchPcdValue', 'PcdError']
 691                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 692             #
 693             # Check PcdEx
 694             #
 695             for PcdExItem in AsBuilt.PcdExValueList:
 696                 CheckDict = {'TokenSpaceGuidValue':PcdExItem.TokenSpaceGuidValue,
 697                              'Token':PcdExItem.Token,
 698                              'DatumType':PcdExItem.DatumType,
 699                              'Value':PcdExItem.DefaultValue}
 700                 XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'PcdExValue']
 701                 IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 702                 #
 703                 # Check PcdError
 704                 #
 705                 for PcdErrorItem in PcdExItem.PcdErrorsList:
 706                     CheckDict = {'ErrorNumber':PcdErrorItem.ErrorNumber}
 707                     XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt',
 708                                                       'PcdExValue', 'PcdError']
 709                     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 710     #
 711     # Check SmmDepex
 712     #
 713     XmlTreeLevel = TopXmlTreeLevel + ['SmmDepex']
 714     for Item in Module.GetSmmDepex():
 715         CheckDict = {'Expression':Item.GetDepex()}
 716         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 717
 718     #
 719     # Check PeiDepex
 720     #
 721     XmlTreeLevel = TopXmlTreeLevel + ['PeiDepex']
 722     for Item in Module.GetPeiDepex():
 723         CheckDict = {'Expression':Item.GetDepex()}
 724         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 725
 726     #
 727     # Check DxeDepex
 728     #
 729     XmlTreeLevel = TopXmlTreeLevel + ['DxeDepex']
 730     for Item in Module.GetDxeDepex():
 731         CheckDict = {'Expression':Item.GetDepex()}
 732         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 733
 734     #
 735     # Check <UserExtensions>
 736     #
 737     XmlTreeLevel = TopXmlTreeLevel + ['UserExtensions']
 738     for Item in Module.GetUserExtensionList():
 739         CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()}
 740         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 741
 742 ## ValidatePS1
 743 #
 744 # ValidatePS1
 745 #
 746 def ValidatePS1(Package):
 747     #
 748     # Check DistributionPackage -> PackageSurfaceArea -> Header
 749     #
 750     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'Header']
 751     CheckDict = Sdict()
 752     CheckDict['Name'] = Package.GetName()
 753     CheckDict['BaseName'] = Package.GetBaseName()
 754     CheckDict['GUID'] = Package.GetGuid()
 755     CheckDict['Version'] = Package.GetVersion()
 756     CheckDict['PackagePath'] = Package.GetPackagePath()
 757
 758     IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 759     if not IsValidInstallPath(Package.GetPackagePath()):
 760         Logger.Error("UPT", FORMAT_INVALID, ERR_FILE_NAME_INVALIDE % Package.GetPackagePath())
 761
 762     #
 763     # Check DistributionPackage -> PackageSurfaceArea -> ClonedFrom
 764     #
 765     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ClonedFrom']
 766     for Item in Package.GetClonedFromList():
 767         if Item == None:
 768             CheckDict = Sdict()
 769             CheckDict['GUID'] = ''
 770             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 771         CheckDict = Sdict()
 772         CheckDict['GUID'] = Item.GetPackageGuid()
 773         CheckDict['Version'] = Item.GetPackageVersion()
 774
 775         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 776
 777     #
 778     # Check DistributionPackage -> PackageSurfaceArea -> LibraryClassDeclarations -> LibraryClass
 779     #
 780     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'LibraryClassDeclarations']
 781     for Item in Package.GetLibraryClassList():
 782         if Item == None:
 783             CheckDict = {'LibraryClass':''}
 784             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 785
 786     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'LibraryClassDeclarations', 'LibraryClass']
 787     for Item in Package.GetLibraryClassList():
 788         CheckDict = {'Keyword':Item.GetLibraryClass(),
 789                      'HeaderFile':Item.GetIncludeHeader()}
 790         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 791
 792     #
 793     # Check DistributionPackage -> PackageSurfaceArea -> IndustryStandardIncludes -> IndustryStandardHeader
 794     #
 795     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'IndustryStandardIncludes']
 796     for Item in Package.GetStandardIncludeFileList():
 797         if Item == None:
 798             CheckDict = {'IndustryStandardHeader':''}
 799             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 800
 801     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'IndustryStandardIncludes', 'IndustryStandardHeader']
 802     for Item in Package.GetStandardIncludeFileList():
 803         CheckDict = {'HeaderFile':Item.GetFilePath()}
 804         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 805
 806     #
 807     # Check DistributionPackage -> PackageSurfaceArea -> PackageIncludes -> PackageHeader
 808     #
 809     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PackageIncludes']
 810     for Item in Package.GetPackageIncludeFileList():
 811         if Item == None:
 812             CheckDict = {'PackageHeader':''}
 813             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 814
 815     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PackageIncludes', 'PackageHeader']
 816     for Item in Package.GetPackageIncludeFileList():
 817         CheckDict = {'HeaderFile':Item.GetFilePath()}
 818         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 819
 820 ## ValidatePS2
 821 #
 822 # ValidatePS2
 823 #
 824 def ValidatePS2(Package):
 825     #
 826     # Check DistributionPackage -> PackageSurfaceArea -> Modules -> ModuleSurfaceArea
 827     #
 828     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'Modules', 'ModuleSurfaceArea']
 829     for Item in Package.GetModuleDict().values():
 830         ValidateMS(Item, XmlTreeLevel)
 831
 832     #
 833     # Check DistributionPackage -> PackageSurfaceArea -> GuidDeclarations Entry
 834     #
 835     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'GuidDeclarations']
 836     for Item in Package.GetGuidList():
 837         if Item == None:
 838             CheckDict = {'Entry':''}
 839             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 840
 841     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'GuidDeclarations', 'Entry']
 842     for Item in Package.GetGuidList():
 843         CheckDict = {'CName':Item.GetCName(),
 844                      'GuidValue':Item.GetGuid()}
 845         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 846
 847     #
 848     # Check DistributionPackage -> PackageSurfaceArea -> ProtocolDeclarations -> Entry
 849     #
 850     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ProtocolDeclarations']
 851     for Item in Package.GetProtocolList():
 852         if Item == None:
 853             CheckDict = {'Entry':''}
 854             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 855
 856     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ProtocolDeclarations', 'Entry']
 857     for Item in Package.GetProtocolList():
 858         CheckDict = {'CName':Item.GetCName(),
 859                      'GuidValue':Item.GetGuid()}
 860         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 861
 862     #
 863     # Check DistributionPackage -> PackageSurfaceArea -> PpiDeclarations -> Entry
 864     #
 865     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PpiDeclarations']
 866     for Item in Package.GetPpiList():
 867         if Item == None:
 868             CheckDict = {'Entry':''}
 869             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 870
 871     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PpiDeclarations', 'Entry']
 872     for Item in Package.GetPpiList():
 873         CheckDict = {'CName':Item.GetCName(),
 874                      'GuidValue':Item.GetGuid()}
 875         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 876
 877     #
 878     # Check DistributionPackage -> PackageSurfaceArea -> PcdDeclarations -> Entry
 879     #
 880     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PcdDeclarations']
 881     for Item in Package.GetPcdList():
 882         if Item == None:
 883             CheckDict = {'PcdEntry':''}
 884             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 885
 886     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PcdDeclarations', 'PcdEntry']
 887     for Item in Package.GetPcdList():
 888         CheckDict = {'TokenSpaceGuidCname':Item.GetTokenSpaceGuidCName(),
 889                      'Token':Item.GetToken(),
 890                      'CName':Item.GetCName(),
 891                      'DatumType':Item.GetDatumType(),
 892                      'ValidUsage':Item.GetValidUsage(),
 893                      'DefaultValue':Item.GetDefaultValue()}
 894         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 895
 896     #
 897     # Check DistributionPackage -> PackageSurfaceArea -> UserExtensions
 898     #
 899     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'UserExtensions']
 900     for Item in Package.GetUserExtensionList():
 901         CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()}
 902         IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 903
 904     #
 905     # Check DistributionPackage -> PackageSurfaceArea -> MiscellaneousFiles -> Filename
 906     #
 907     XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'MiscellaneousFiles']
 908     for Item in Package.GetMiscFileList():
 909         if not Item.GetFileList():
 910             CheckDict = {'Filename':'', }
 911             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 912         for File in Item.GetFileList():
 913             CheckDict = {'Filename':File.GetURI(), }
 914             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 915
 916 ## ValidatePackageSurfaceArea
 917 #
 918 # Check if any required item is missing in  PackageSurfaceArea
 919 #
 920 # @param Package: The PackageSurfaceArea to be checked
 921 #
 922 def ValidatePackageSurfaceArea(Package):
 923     ValidatePS1(Package)
 924     ValidatePS2(Package)