BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py

   1 ## @file InfPomAlignment.py
   2 # This file contained the adapter for convert INF parser object to POM Object
   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 InfPomAlignment
  16 '''
  17 ##
  18 # Import modules
  19 #
  20 import os.path
  21
  22 from Logger import StringTable as ST
  23 import Logger.Log as Logger
  24
  25 from Library.String import FORMAT_INVALID
  26 from Library.String import PARSER_ERROR
  27 from Library.String import NormPath
  28 from Library.String import GetSplitValueList
  29 from Library.Misc import ConvertVersionToDecimal
  30 from Library.Misc import GetHelpStringByRemoveHashKey
  31 from Library.Misc import ConvertArchList
  32 from Library.Parsing import GetPkgInfoFromDec
  33 from Library import DataType as DT
  34 from Library import GlobalData
  35
  36 from Object.POM import CommonObject
  37 from Object.POM.ModuleObject import ModuleObject
  38 from Object.POM.ModuleObject import ExternObject
  39 from Object.POM.ModuleObject import HobObject
  40 from Object.POM.ModuleObject import EventObject
  41 from Object.POM.ModuleObject import BootModeObject
  42 from Object.POM.ModuleObject import PackageDependencyObject
  43 from Object.POM.ModuleObject import SourceFileObject
  44 from Object.POM.ModuleObject import DepexObject
  45 from Object.POM.ModuleObject import AsBuildLibraryClassObject
  46 from Object.POM.ModuleObject import AsBuiltObject
  47 from PomAdapter.InfPomAlignmentMisc import GenModuleHeaderUserExt
  48 from PomAdapter.InfPomAlignmentMisc import GenBinaryData
  49 from Parser import InfParser
  50
  51
  52
  53 ## InfPomAlignment
  54 #
  55 # Inherit from ModuleObject
  56 #
  57 class InfPomAlignment(ModuleObject):
  58     ## Construct of InfPomAlignment
  59     # Skip means that UPT don't care the syntax of INF, this may be the not
  60     # distributed INF files during creation or the INF files checked for
  61     # dependency rule during remove.
  62     #
  63     def __init__(self, FileName, WorkSpace=None, PackagePath='', Skip=False):
  64         ModuleObject.__init__(self)
  65
  66         self.Parser = None
  67         self.FileName = FileName
  68         self.WorkSpace = WorkSpace
  69         self.CombinePath = ''
  70         self.LibModuleTypeList = []
  71         self.FullPath = ''
  72         self.ModulePath = ''
  73         self.WorkspaceDir = " "
  74         self.CustomMakefile = []
  75
  76         self.SetPackagePath(PackagePath)
  77         #
  78         # Call GenInfPomObjects function to fill POM object.
  79         #
  80         if Skip:
  81             OrigConfig = Logger.SUPRESS_ERROR
  82             Logger.SUPRESS_ERROR = True
  83             self._GenInfPomObjects(Skip)
  84             Logger.SUPRESS_ERROR = OrigConfig
  85         else:
  86             self._GenInfPomObjects(Skip)
  87
  88     ##
  89     # Generate all POM objects, the original input comes
  90     # from INF parser's output
  91     #
  92     def _GenInfPomObjects(self, Skip):
  93         #
  94         # Call INF Parser to get information from INF file
  95         #
  96         self.Parser = InfParser.InfParser(self.FileName, self.WorkSpace)
  97         self.FullPath = self.Parser.FullPath
  98         self.GetFullPath()
  99         self._GenModuleHeader()
 100         #
 101         # Call GenBinaries after Module Header for Binary INF consideration.
 102         #
 103         self._GenBinaries()
 104         self._GenBuildOptions()
 105         self._GenLibraryClasses()
 106         self._GenPackages(Skip)
 107         self._GenPcds()
 108         self._GenSources()
 109         self._GenUserExtensions()
 110         self._GenGuidProtocolPpis(DT.TAB_GUIDS)
 111         self._GenGuidProtocolPpis(DT.TAB_PROTOCOLS)
 112         self._GenGuidProtocolPpis(DT.TAB_PPIS)
 113         self._GenDepexes()
 114         self._GenMiscFiles(self.FullPath, Skip)
 115
 116     ## Convert [Defines] section content to InfDefObject
 117     #
 118     # Convert [Defines] section content to InfDefObject
 119     #
 120     # @param Defines        The content under [Defines] section
 121     # @param ModuleHeader   An object of ModuleHeaderClass
 122     # @param Arch           The supported ARCH
 123     #
 124     def _GenModuleHeader(self):
 125         Logger.Debug(2, "Generate ModuleHeader ...")
 126         #
 127         # Get all defines information form InfParser Object
 128         #
 129         RecordSet = self.Parser.InfDefSection.Defines
 130         #
 131         # Should only have one ArchString Item.
 132         #
 133         ArchString = RecordSet.keys()[0]
 134         ArchList = GetSplitValueList(ArchString, ' ')
 135         ArchList = ConvertArchList(ArchList)
 136         HasCalledFlag = False
 137
 138         #
 139         # Get data from Sdict()
 140         #
 141         ValueList = RecordSet[ArchString]
 142         self.SetFileName(self.FileName)
 143         self.SetFullPath(self.FullPath)
 144         #
 145         # The INF's filename (without the directory path or the extension)
 146         # must be used for the value of the
 147         # ModuleSurfaceArea.Header.Name element
 148         #
 149         self.SetName(os.path.splitext(os.path.basename(self.FileName))[0])
 150
 151         self.WorkspaceDir = " "
 152         #
 153         # CombinePath and ModulePath
 154         #
 155         PathCount = self.FullPath.upper().find(self.WorkSpace.upper()) + len(self.WorkSpace) + 1
 156         CombinePath = self.FullPath[PathCount:]
 157         self.SetCombinePath(CombinePath)
 158
 159         ModulePath = os.path.split(CombinePath)[0]
 160         ModuleRelativePath = ModulePath
 161         if self.GetPackagePath() != '':
 162             ModuleRelativePath = ModulePath[ModulePath.find(self.GetPackagePath()) + len(self.GetPackagePath()) + 1:]
 163         self.SetModulePath(ModuleRelativePath)
 164
 165         #
 166         # For Define Seciton Items.
 167         #
 168         DefineObj = ValueList
 169
 170         #
 171         # Convert UEFI/PI version to decimal number
 172         #
 173         if DefineObj.GetUefiSpecificationVersion() != None:
 174             __UefiVersion = DefineObj.GetUefiSpecificationVersion().GetValue()
 175             __UefiVersion = ConvertVersionToDecimal(__UefiVersion)
 176             self.SetUefiSpecificationVersion(str(__UefiVersion))
 177         if DefineObj.GetPiSpecificationVersion() != None:
 178             __PiVersion = DefineObj.GetPiSpecificationVersion().GetValue()
 179             __PiVersion = ConvertVersionToDecimal(__PiVersion)
 180
 181             self.SetPiSpecificationVersion(str(__PiVersion))
 182
 183         SpecList = DefineObj.GetSpecification()
 184         NewSpecList = []
 185         for SpecItem in SpecList:
 186             NewSpecList.append((SpecItem[0], ConvertVersionToDecimal(SpecItem[1])))
 187         self.SetSpecList(NewSpecList)
 188
 189         #
 190         # must exist items in INF define section
 191         # MODULE_TYPE/BASE_NAME/INF_VERSION/FILE_GUID/VERSION_STRING
 192         #
 193         if DefineObj.GetModuleType() == None:
 194             Logger.Error("InfParser", FORMAT_INVALID,
 195                          ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("MODULE_TYPE"), File=self.FullPath)
 196         else:
 197             self.SetModuleType(DefineObj.GetModuleType().GetValue())
 198             ModuleType = DefineObj.GetModuleType().GetValue()
 199             if ModuleType:
 200                 #
 201                 # Drivers and applications are not allowed to have a MODULE_TYPE of "BASE". Only
 202                 # libraries are permitted to a have a MODULE_TYPE of "BASE".
 203                 #
 204                 if len(DefineObj.LibraryClass) == 0 and ModuleType == 'BASE':
 205                     Logger.Error("InfParser",
 206                                  FORMAT_INVALID,
 207                                  ST.ERR_INF_PARSER_MODULETYPE_INVALID,
 208                                  File=self.FullPath,
 209                                  Line=DefineObj.ModuleType.CurrentLine.LineNo,
 210                                  ExtraData=DefineObj.ModuleType.CurrentLine.LineString)
 211                 self.LibModuleTypeList.append(ModuleType)
 212         if DefineObj.GetBaseName() == None:
 213             Logger.Error("InfParser", FORMAT_INVALID,
 214                          ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("BASE_NAME"), File=self.FullPath)
 215         else:
 216             self.SetBaseName(DefineObj.GetBaseName().GetValue())
 217         if DefineObj.GetInfVersion() == None:
 218             Logger.Error("InfParser", FORMAT_INVALID,
 219                          ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("INF_VERSION"), File=self.FullPath)
 220         else:
 221             self.SetVersion(DefineObj.GetInfVersion().GetValue())
 222         if DefineObj.GetFileGuid() == None:
 223             Logger.Error("InfParser", FORMAT_INVALID,
 224                          ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("FILE_GUID"), File=self.FullPath)
 225         else:
 226             self.SetGuid(DefineObj.GetFileGuid().GetValue())
 227         if DefineObj.GetVersionString() == None:
 228             #
 229             # VERSION_STRING is missing from the [Defines] section, tools must assume that the module's version is 0.
 230             #
 231             self.SetVersion('0')
 232         else:
 233             #
 234             # Get version of INF
 235             #
 236             if DefineObj.GetVersionString().GetValue() != "":
 237                 #
 238                 # EDK2 inf
 239                 #
 240                 VersionString = DefineObj.GetVersionString().GetValue()
 241                 if len(VersionString) > 0:
 242                     VersionString = ConvertVersionToDecimal(VersionString)
 243                     self.SetVersion(VersionString)
 244             else:
 245                 #
 246                 # EDK1 inf
 247                 #
 248                 Logger.Error("Parser", PARSER_ERROR, ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF, ExtraData=self.FullPath,
 249                              RaiseError=Logger.IS_RAISE_ERROR)
 250
 251         #
 252         # if there is Shadow, Should judge the MODULE_TYPE in
 253         # SEC, PEI_CORE and PEIM
 254         #
 255         if DefineObj.GetShadow():
 256             ModuleTypeValue = DefineObj.GetModuleType().GetValue()
 257             if not (ModuleTypeValue == 'SEC' or ModuleTypeValue == 'PEI_CORE' or ModuleTypeValue == 'PEIM'):
 258                 Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_SHADOW_INVALID, File=self.FullPath)
 259
 260         if DefineObj.GetPcdIsDriver() != None:
 261             self.SetPcdIsDriver(DefineObj.GetPcdIsDriver().GetValue())
 262
 263         #
 264         # LIBRARY_CLASS
 265         #
 266         self._GenModuleHeaderLibClass(DefineObj, ArchList)
 267
 268         #
 269         # CUSTOM_MAKEFILE
 270         #
 271         self.CustomMakefile = DefineObj.GetCustomMakefile()
 272         #
 273         # Externs in Defines section
 274         # Only one define section, so just call once.
 275         #
 276         if not HasCalledFlag:
 277             self._GenModuleHeaderExterns(DefineObj)
 278             HasCalledFlag = True
 279
 280         #
 281         # each module has only one module header
 282         #
 283         self.SetSupArchList(ArchList)
 284         #
 285         # Get Hob/BootMode/EventList information
 286         #
 287         self._GenSpecialComments()
 288         #
 289         # put all define statement into user-extension sections
 290         #
 291         DefinesDictNew = GenModuleHeaderUserExt(DefineObj, ArchString)
 292
 293         if DefinesDictNew:
 294             UserExtension = CommonObject.UserExtensionObject()
 295             UserExtension.SetDefinesDict(DefinesDictNew)
 296             UserExtension.SetIdentifier('DefineModifiers')
 297             UserExtension.SetUserID('EDK2')
 298             self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
 299
 300         #
 301         # Get all meta-file header information
 302         # the record is list of items formated:
 303         # [LineValue, Arch, StartLine, ID, Third]
 304         #
 305
 306         InfHeaderObj = self.Parser.InfHeader
 307         #
 308         # Put header information into POM object
 309         #
 310         self.SetAbstract(InfHeaderObj.GetAbstract())
 311         self.SetDescription(InfHeaderObj.GetDescription())
 312         self.SetCopyright(InfHeaderObj.GetCopyright())
 313         self.SetLicense(InfHeaderObj.GetLicense())
 314
 315     ## GenModuleHeaderLibClass
 316     #
 317     #
 318     def _GenModuleHeaderLibClass(self, DefineObj, ArchList):
 319         LibraryList = DefineObj.GetLibraryClass()
 320         for LibraryItem in LibraryList:
 321             Lib = CommonObject.LibraryClassObject()
 322             Lib.SetLibraryClass(LibraryItem.GetLibraryName())
 323             Lib.SetUsage(DT.USAGE_ITEM_PRODUCES)
 324             SupModuleList = LibraryItem.GetTypes()
 325             self.LibModuleTypeList += SupModuleList
 326             Lib.SetSupModuleList(SupModuleList)
 327             Lib.SetSupArchList(ArchList)
 328             self.SetLibraryClassList(self.GetLibraryClassList() + [Lib])
 329             self.SetIsLibrary(True)
 330             self.SetIsLibraryModList(self.GetIsLibraryModList() + SupModuleList)
 331
 332     ## GenModuleHeaderExterns
 333     #
 334     #
 335     def _GenModuleHeaderExterns(self, DefineObj):
 336         EntryPointList = DefineObj.GetEntryPoint()
 337         for EntryPoint in EntryPointList:
 338             Image = ExternObject()
 339             Image.SetEntryPoint(EntryPoint.GetCName())
 340             #
 341             # Future enhancement
 342             #
 343             self.SetExternList(self.GetExternList() + [Image])
 344         #
 345         # UNLOAD_IMAGE
 346         #
 347         UnloadImageList = DefineObj.GetUnloadImages()
 348         for UnloadImage in UnloadImageList:
 349             Image = ExternObject()
 350             #
 351             # Future enhancement
 352             #
 353             Image.SetUnloadImage(UnloadImage.GetCName())
 354             self.SetExternList(self.GetExternList() + [Image])
 355         #
 356         # CONSTRUCTOR
 357         #
 358         ConstructorList = DefineObj.GetConstructor()
 359         for ConstructorItem in ConstructorList:
 360             Image = ExternObject()
 361             #
 362             # Future enhancement
 363             #
 364             Image.SetConstructor(ConstructorItem.GetCName())
 365             self.SetExternList(self.GetExternList() + [Image])
 366         #
 367         # DESTRUCTOR
 368         #
 369         DestructorList = DefineObj.GetDestructor()
 370         for DestructorItem in DestructorList:
 371             Image = ExternObject()
 372             #
 373             # Future enhancement
 374             #
 375             Image.SetDestructor(DestructorItem.GetCName())
 376             self.SetExternList(self.GetExternList() + [Image])
 377
 378     ## GenModuleHeaderExterns
 379     # BootMode/HOB/Event
 380     #
 381     def _GenSpecialComments(self):
 382         SpecialCommentsList = self.Parser.InfSpecialCommentSection.GetSpecialComments()
 383         for Key in SpecialCommentsList:
 384             if Key == DT.TYPE_HOB_SECTION:
 385                 HobList = []
 386                 for Item in SpecialCommentsList[Key]:
 387                     Hob = HobObject()
 388                     Hob.SetHobType(Item.GetHobType())
 389                     Hob.SetUsage(Item.GetUsage())
 390                     Hob.SetSupArchList(Item.GetSupArchList())
 391                     if Item.GetHelpString():
 392                         HelpTextObj = CommonObject.TextObject()
 393                         HelpTextObj.SetString(Item.GetHelpString())
 394                         Hob.SetHelpTextList([HelpTextObj])
 395                     HobList.append(Hob)
 396                 self.SetHobList(HobList)
 397             elif Key == DT.TYPE_EVENT_SECTION:
 398                 EventList = []
 399                 for Item in SpecialCommentsList[Key]:
 400                     Event = EventObject()
 401                     Event.SetEventType(Item.GetEventType())
 402                     Event.SetUsage(Item.GetUsage())
 403                     if Item.GetHelpString():
 404                         HelpTextObj = CommonObject.TextObject()
 405                         HelpTextObj.SetString(Item.GetHelpString())
 406                         Event.SetHelpTextList([HelpTextObj])
 407                     EventList.append(Event)
 408                 self.SetEventList(EventList)
 409             elif Key == DT.TYPE_BOOTMODE_SECTION:
 410                 BootModeList = []
 411                 for Item in SpecialCommentsList[Key]:
 412                     BootMode = BootModeObject()
 413                     BootMode.SetSupportedBootModes(Item.GetSupportedBootModes())
 414                     BootMode.SetUsage(Item.GetUsage())
 415                     if Item.GetHelpString():
 416                         HelpTextObj = CommonObject.TextObject()
 417                         HelpTextObj.SetString(Item.GetHelpString())
 418                         BootMode.SetHelpTextList([HelpTextObj])
 419                     BootModeList.append(BootMode)
 420                 self.SetBootModeList(BootModeList)
 421
 422     ## GenBuildOptions
 423     #
 424     # Gen BuildOptions of Inf
 425     # [<Family>:]<ToolFlag>=Flag
 426     #
 427     #
 428     def _GenBuildOptions(self):
 429         Logger.Debug(2, "Generate %s ..." % DT.TAB_BUILD_OPTIONS)
 430         #
 431         # Get all BuildOptions
 432         #
 433         BuildOptionsList = self.Parser.InfBuildOptionSection.GetBuildOptions()
 434         if not GlobalData.gIS_BINARY_INF:
 435             BuildOptionDict = {}
 436
 437             for BuildOptionObj in BuildOptionsList:
 438                 ArchList = BuildOptionObj.GetSupArchList()
 439                 ArchList = ConvertArchList(ArchList)
 440                 BuildOptionsContent = BuildOptionObj.GetContent()
 441                 ArchString = ' '.join(ArchList)
 442
 443                 if not BuildOptionsContent:
 444                     continue
 445
 446                 BuildOptionDict[ArchString] = BuildOptionsContent
 447
 448             if not BuildOptionDict:
 449                 return
 450             UserExtension = CommonObject.UserExtensionObject()
 451             UserExtension.SetBuildOptionDict(BuildOptionDict)
 452             UserExtension.SetIdentifier('BuildOptionModifiers')
 453             UserExtension.SetUserID('EDK2')
 454             self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
 455         else:
 456             #
 457             # Not process this information, will be processed in GenBinaries()
 458             #
 459             pass
 460
 461     ## GenLibraryClasses
 462     #
 463     # Get LibraryClass of Inf
 464     # <LibraryClassKeyWord>|<LibraryInstance>
 465     #
 466     # @param ContainerFile: The Inf file full path
 467     #
 468     def _GenLibraryClasses(self):
 469         Logger.Debug(2, "Generate %s ..." % DT.TAB_LIBRARY_CLASSES)
 470         if not GlobalData.gIS_BINARY_INF:
 471             #
 472             # Get all LibraryClasses
 473             #
 474             LibClassObj = self.Parser.InfLibraryClassSection.LibraryClasses
 475             Keys = LibClassObj.keys()
 476
 477             for Key in Keys:
 478                 LibraryClassData = LibClassObj[Key]
 479                 for Item in LibraryClassData:
 480                     LibraryClass = CommonObject.LibraryClassObject()
 481                     LibraryClass.SetUsage(DT.USAGE_ITEM_CONSUMES)
 482                     LibraryClass.SetLibraryClass(Item.GetLibName())
 483                     LibraryClass.SetRecommendedInstance(None)
 484                     LibraryClass.SetFeatureFlag(Item.GetFeatureFlagExp())
 485                     LibraryClass.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
 486                     LibraryClass.SetSupModuleList(Item.GetSupModuleList())
 487                     HelpStringObj = Item.GetHelpString()
 488
 489                     if HelpStringObj != None:
 490                         CommentString = GetHelpStringByRemoveHashKey(HelpStringObj.HeaderComments +
 491                                                                      HelpStringObj.TailComments)
 492                         HelpTextHeaderObj = CommonObject.TextObject()
 493                         HelpTextHeaderObj.SetString(CommentString)
 494                         LibraryClass.SetHelpTextList([HelpTextHeaderObj])
 495
 496                     self.SetLibraryClassList(self.GetLibraryClassList() + [LibraryClass])
 497
 498     ## GenPackages
 499     #
 500     # Gen Packages of Inf
 501     #
 502     #
 503     # @param ContainerFile: The Inf file full path
 504     #
 505     def _GenPackages(self, Skip):
 506         Logger.Debug(2, "Generate %s ..." % DT.TAB_PACKAGES)
 507         #
 508         # Get all Packages
 509         #
 510         PackageObj = self.Parser.InfPackageSection.Packages
 511
 512         #
 513         # Go through each arch
 514         #
 515         for PackageItemObj in PackageObj:
 516             #
 517             # Need package information for dependency check usage
 518             #
 519             PackageDependency = PackageDependencyObject()
 520             PackageDependency.SetPackageFilePath(NormPath(PackageItemObj.GetPackageName()))
 521             PackageDependency.SetSupArchList(ConvertArchList(PackageItemObj.GetSupArchList()))
 522             PackageDependency.SetFeatureFlag(PackageItemObj.GetFeatureFlagExp())
 523
 524             PkgInfo = GetPkgInfoFromDec(os.path.normpath(os.path.join(self.WorkSpace,
 525                                                                       NormPath(PackageItemObj.GetPackageName()))))
 526             if PkgInfo[1] and PkgInfo[2]:
 527                 PackageDependency.SetGuid(PkgInfo[1])
 528                 PackageDependency.SetVersion(PkgInfo[2])
 529             elif Skip:
 530                 continue
 531             else:
 532                 Logger.Error("\nUPT", PARSER_ERROR,
 533                              ST.ERR_INF_GET_PKG_DEPENDENCY_FAIL % PackageItemObj.GetPackageName(), File=self.FullPath)
 534
 535             PackageDependencyList = self.GetPackageDependencyList()
 536             PackageDependencyList.append(PackageDependency)
 537             self.SetPackageDependencyList(PackageDependencyList)
 538
 539     ## GenPcds
 540     #
 541     # Gen Pcds of Inf
 542     # <TokenSpaceGuidCName>.<PcdCName>[|<Value> [|<FFE>]]
 543     #
 544     # @param ContainerFile: The Inf file full path
 545     #
 546     def _GenPcds(self):
 547         if not GlobalData.gIS_BINARY_INF:
 548             Logger.Debug(2, "Generate %s ..." % DT.TAB_PCDS)
 549
 550             #
 551             # Get all Pcds
 552             #
 553             PcdObj = self.Parser.InfPcdSection.Pcds
 554             KeysList = PcdObj.keys()
 555
 556             #
 557             # Go through each arch
 558             #
 559             for (PcdType, PcdKey) in KeysList:
 560                 PcdData = PcdObj[PcdType, PcdKey]
 561                 for PcdItemObj in PcdData:
 562                     CommentList = PcdItemObj.GetHelpStringList()
 563                     if CommentList:
 564                         for CommentItem in CommentList:
 565                             Pcd = CommonObject.PcdObject()
 566                             Pcd.SetCName(PcdItemObj.GetCName())
 567                             Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())
 568                             Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
 569                             Pcd.SetItemType(PcdType)
 570                             Pcd.SetValidUsage(CommentItem.GetUsageItem())
 571                             Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
 572                             Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
 573                             HelpTextObj = CommonObject.TextObject()
 574                             HelpTextObj.SetString(CommentItem.GetHelpStringItem())
 575                             Pcd.SetHelpTextList([HelpTextObj])
 576                             PcdList = self.GetPcdList()
 577                             PcdList.append(Pcd)
 578                 self.SetPcdList(PcdList)
 579
 580     ## GenSources
 581     #
 582     # Gen Sources of Inf
 583     # <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]
 584     #
 585     # @param ContainerFile: The Inf file full path
 586     #
 587     def _GenSources(self):
 588         Logger.Debug(2, "Generate %s ..." % DT.TAB_SOURCES)
 589
 590         #
 591         # Get all SourceFiles
 592         #
 593         SourceObj = self.Parser.InfSourcesSection.Sources
 594         DataList = SourceObj.keys()
 595         #
 596         # Go through each arch
 597         #
 598         SourceList = []
 599         for Key in DataList:
 600             SourceData = SourceObj[Key]
 601             for Item in SourceData:
 602                 SourceFile = Item.GetSourceFileName()
 603                 Family = Item.GetFamily()
 604                 FeatureFlag = Item.GetFeatureFlagExp()
 605                 SupArchList = ConvertArchList(Item.GetSupArchList())
 606                 SupArchList.sort()
 607                 Source = SourceFileObject()
 608                 Source.SetSourceFile(SourceFile)
 609                 Source.SetFamily(Family)
 610                 Source.SetFeatureFlag(FeatureFlag)
 611                 Source.SetSupArchList(SupArchList)
 612                 SourceList.append(Source)
 613
 614         self.SetSourceFileList(self.GetSourceFileList() + SourceList)
 615
 616
 617     ## GenUserExtensions
 618     #
 619     # Gen UserExtensions of Inf
 620     #
 621     def _GenUserExtensions(self):
 622         #
 623         # UserExtensions
 624         #
 625         UserExtensionObj = self.Parser.InfUserExtensionSection.UserExtension
 626         Keys = UserExtensionObj.keys()
 627
 628         for Key in Keys:
 629             UserExtensionData = UserExtensionObj[Key]
 630             for UserExtensionDataObj in UserExtensionData:
 631                 UserExtension = CommonObject.UserExtensionObject()
 632                 UserId = UserExtensionDataObj.GetUserId()
 633                 if UserId.startswith('"') and UserId.endswith('"'):
 634                     UserId = UserId[1:-1]
 635                 UserExtension.SetUserID(UserId)
 636                 Identifier = UserExtensionDataObj.GetIdString()
 637                 if Identifier.startswith('"') and Identifier.endswith('"'):
 638                     Identifier = Identifier[1:-1]
 639                 UserExtension.SetIdentifier(Identifier)
 640                 UserExtension.SetStatement(UserExtensionDataObj.GetContent())
 641                 UserExtension.SetSupArchList(ConvertArchList(UserExtensionDataObj.GetSupArchList()))
 642                 self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
 643
 644     def _GenDepexesList(self, SmmDepexList, DxeDepexList, PeiDepexList):
 645         if SmmDepexList:
 646             self.SetSmmDepex(SmmDepexList)
 647         if DxeDepexList:
 648             self.SetDxeDepex(DxeDepexList)
 649         if PeiDepexList:
 650             self.SetPeiDepex(PeiDepexList)
 651
 652     ## GenDepexes
 653     #
 654     # Gen Depex of Inf
 655     #
 656     # @param ContainerFile: The Inf file full path
 657     #
 658     def _GenDepexes(self):
 659         Logger.Debug(2, "Generate %s ..." % DT.TAB_DEPEX)
 660
 661         PEI_LIST = [DT.SUP_MODULE_PEIM]
 662         SMM_LIST = [DT.SUP_MODULE_DXE_SMM_DRIVER]
 663         DXE_LIST = [DT.SUP_MODULE_DXE_DRIVER, DT.SUP_MODULE_DXE_SAL_DRIVER,
 664                     DT.SUP_MODULE_DXE_RUNTIME_DRIVER]
 665
 666         IsLibraryClass = self.GetIsLibrary()
 667         #
 668         # Get all Depexes
 669         #
 670         DepexData = self.Parser.InfDepexSection.GetDepex()
 671         SmmDepexList = []
 672         DxeDepexList = []
 673         PeiDepexList = []
 674         for Depex in DepexData:
 675             ModuleType = Depex.GetModuleType()
 676             ModuleTypeList = []
 677             if IsLibraryClass:
 678                 if not self.GetIsLibraryModList():
 679                     Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_LIBRARY_CLASS,
 680                                  self.GetFullPath(), RaiseError=True)
 681                 if ModuleType and ModuleType not in self.GetIsLibraryModList():
 682                     Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
 683                                  self.GetFullPath(), RaiseError=True)
 684                 if ModuleType:
 685                     ModuleTypeList = [ModuleType]
 686                 else:
 687                     for ModuleTypeInList in self.GetIsLibraryModList():
 688                         if ModuleTypeInList in DT.VALID_DEPEX_MODULE_TYPE_LIST:
 689                             ModuleTypeList.append(ModuleTypeInList)
 690                 if not ModuleTypeList:
 691                     Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
 692                                  self.GetFullPath(), RaiseError=True)
 693             else:
 694                 if not ModuleType:
 695                     ModuleType = self.ModuleType
 696                 if ModuleType not in DT.VALID_DEPEX_MODULE_TYPE_LIST:
 697                     Logger.Error("\nMkPkg", PARSER_ERROR,
 698                                  ST.ERR_INF_PARSER_DEPEX_SECTION_MODULE_TYPE_ERROR % (ModuleType),
 699                                  self.GetFullPath(), RaiseError=True)
 700                 if ModuleType != self.ModuleType:
 701                     Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
 702                                  self.GetFullPath(), RaiseError=True)
 703                 ModuleTypeList = [ModuleType]
 704             for ModuleType in ModuleTypeList:
 705                 DepexIns = DepexObject()
 706                 DepexIns.SetDepex(Depex.GetDepexContent())
 707                 if IsLibraryClass:
 708                     DepexIns.SetModuleType(ModuleType)
 709                 else:
 710                     if Depex.GetModuleType():
 711                         DepexIns.SetModuleType(Depex.GetModuleType())
 712                 DepexIns.SetSupArchList(ConvertArchList([Depex.GetSupArch()]))
 713                 DepexIns.SetFeatureFlag(Depex.GetFeatureFlagExp())
 714                 if Depex.HelpString:
 715                     HelpIns = CommonObject.TextObject()
 716                     HelpIns.SetString(GetHelpStringByRemoveHashKey(Depex.HelpString))
 717                     DepexIns.SetHelpText(HelpIns)
 718
 719                 if ModuleType in SMM_LIST:
 720                     SmmDepexList.append(DepexIns)
 721                 if ModuleType in DXE_LIST:
 722                     DxeDepexList.append(DepexIns)
 723                 if ModuleType in PEI_LIST:
 724                     PeiDepexList.append(DepexIns)
 725                 if ModuleType == DT.SUP_MODULE_UEFI_DRIVER:
 726                     if IsLibraryClass:
 727                         DxeDepexList.append(DepexIns)
 728                     else:
 729                         Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_DRIVER,
 730                                      self.GetFullPath(), RaiseError=True)
 731
 732             #End of for ModuleType in ModuleTypeList
 733             self._GenDepexesList(SmmDepexList, DxeDepexList, PeiDepexList)
 734         #End of for Depex in DepexData
 735
 736     ## GenBinaries
 737     #
 738     # Gen Binary of Inf, must be called after Pcd/Library is generated
 739     # <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]
 740     #
 741     # @param ContainerFile: The Inf file full path
 742     #
 743     def _GenBinaries(self):
 744         Logger.Debug(2, "Generate %s ..." % DT.TAB_BINARIES)
 745         BinariesDict = {}
 746
 747         #
 748         # Get all Binary data
 749         #
 750         BinaryObj = self.Parser.InfBinariesSection.GetBinary()
 751
 752         BinaryData = BinaryObj.keys()
 753
 754         #
 755         # If the INF file does not contain a [Sources] section, and the INF file does contain a [Binaries] section,
 756         # then the ModuleSurfaceArea.BinaryModule attribute must be set to true. Otherwise, do not use the attribute
 757         #
 758         if BinaryObj and not self.Parser.InfSourcesSection.GetSources():
 759             self.BinaryModule = True
 760         else:
 761             self.BinaryModule = False
 762
 763         BinaryFileObjectList = []
 764         AsBuildLibraryClassList = []
 765         AsBuildBuildOptionList = []
 766         AsBuildIns = AsBuiltObject()
 767         #
 768         # Library AsBuild Info
 769         #
 770         for LibItem in self.Parser.InfLibraryClassSection.GetLibraryClasses():
 771             AsBuildLibIns = AsBuildLibraryClassObject()
 772             AsBuildLibIns.SetLibGuid(LibItem.GetFileGuid())
 773             AsBuildLibIns.SetLibVersion(LibItem.GetVersion())
 774             AsBuildLibraryClassList.append(AsBuildLibIns)
 775         AsBuildIns.SetLibraryInstancesList(AsBuildLibraryClassList)
 776
 777         #
 778         # BuildOption AsBuild Info
 779         #
 780         for BuildOptionItem in self.Parser.InfBuildOptionSection.GetBuildOptions():
 781             AsBuildBuildOptionList += BuildOptionItem.GetAsBuildList()
 782         AsBuildIns.SetBuildFlagsList(AsBuildBuildOptionList)
 783
 784         #
 785         # PatchPcd and PcdEx
 786         #
 787         AsBuildIns = self._GenAsBuiltPcds(self.Parser.InfPcdSection.GetPcds(), AsBuildIns)
 788
 789         BinariesDict, AsBuildIns, BinaryFileObjectList = GenBinaryData(BinaryData, BinaryObj,
 790                                                                        BinariesDict,
 791                                                                        AsBuildIns,
 792                                                                        BinaryFileObjectList,
 793                                                                        self.GetSupArchList(),
 794                                                                        self.BinaryModule)
 795
 796         BinariesDict2 = {}
 797         for Key in BinariesDict:
 798             ValueList = BinariesDict[Key]
 799             if len(ValueList) > 1:
 800                 BinariesDict2[Key] = ValueList
 801             else:
 802                 #
 803                 # if there is no TagName, ToolCode, HelpStr,
 804                 # then do not need to put them into userextension
 805                 #
 806                 (Target, Family, TagName, HelpStr) = ValueList[0]
 807                 if not (Target or Family or TagName or HelpStr):
 808                     continue
 809                 else:
 810                     BinariesDict2[Key] = ValueList
 811
 812         self.SetBinaryFileList(self.GetBinaryFileList() + BinaryFileObjectList)
 813
 814         if BinariesDict2:
 815             UserExtension = CommonObject.UserExtensionObject()
 816             UserExtension.SetBinariesDict(BinariesDict2)
 817             UserExtension.SetIdentifier('BinaryFileModifiers')
 818             UserExtension.SetUserID('EDK2')
 819             self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
 820
 821     ## GenAsBuiltPcds
 822     #
 823     #
 824     def _GenAsBuiltPcds(self, PcdList, AsBuildIns):
 825         AsBuildPatchPcdList = []
 826         AsBuildPcdExList = []
 827         #
 828         # Pcd AsBuild Info
 829         #
 830         for PcdItem in PcdList:
 831             if PcdItem[0].upper() == DT.TAB_INF_PATCH_PCD.upper():
 832                 PcdItemObj = PcdItem[1]
 833                 Pcd = CommonObject.PcdObject()
 834                 Pcd.SetCName(PcdItemObj.GetCName())
 835                 Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())
 836                 if PcdItemObj.GetTokenSpaceGuidValue() == '' and self.BinaryModule:
 837                     Logger.Error("\nMkPkg",
 838                                  PARSER_ERROR,
 839                                  ST.ERR_ASBUILD_PCD_TOKENSPACE_GUID_VALUE_MISS % \
 840                                  (PcdItemObj.GetTokenSpaceGuidCName()),
 841                                  self.GetFullPath(), RaiseError=True)
 842                 else:
 843                     Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())
 844                 if (PcdItemObj.GetToken() == '' or PcdItemObj.GetDatumType() == '') and self.BinaryModule:
 845                     Logger.Error("\nMkPkg",
 846                                  PARSER_ERROR,
 847                                  ST.ERR_ASBUILD_PCD_DECLARITION_MISS % \
 848                                  (PcdItemObj.GetTokenSpaceGuidCName() + '.' + PcdItemObj.GetCName()),
 849                                  self.GetFullPath(), RaiseError=True)
 850                 Pcd.SetToken(PcdItemObj.GetToken())
 851                 Pcd.SetDatumType(PcdItemObj.GetDatumType())
 852                 Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())
 853                 Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
 854                 Pcd.SetOffset(PcdItemObj.GetOffset())
 855                 Pcd.SetItemType(PcdItem[0])
 856                 Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
 857                 Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
 858                 HelpTextObj = CommonObject.TextObject()
 859                 HelpTextObj.SetString(PcdItemObj.GetHelpStringList())
 860                 Pcd.SetHelpTextList([HelpTextObj])
 861                 AsBuildPatchPcdList.append(Pcd)
 862             else:
 863                 PcdItemObj = PcdItem[1]
 864                 Pcd = CommonObject.PcdObject()
 865                 Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())
 866                 Pcd.SetToken(PcdItemObj.GetToken())
 867                 Pcd.SetDatumType(PcdItemObj.GetDatumType())
 868                 Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())
 869                 Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
 870                 Pcd.SetItemType(PcdItem[0])
 871                 Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
 872                 Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
 873                 HelpTextObj = CommonObject.TextObject()
 874                 HelpTextObj.SetString(PcdItemObj.GetHelpStringList())
 875                 Pcd.SetHelpTextList([HelpTextObj])
 876                 AsBuildPcdExList.append(Pcd)
 877         AsBuildIns.SetPatchPcdList(AsBuildPatchPcdList)
 878         AsBuildIns.SetPcdExList(AsBuildPcdExList)
 879
 880         return AsBuildIns
 881
 882     ## GenGuidProtocolPpis
 883     #
 884     # Gen Guids/Protocol/Ppis of INF
 885     # <CName>=<GuidValue>
 886     #
 887     def _GenGuidProtocolPpis(self, Type):
 888         Logger.Debug(2, "Generate %s ..." % Type)
 889         #
 890         # Get all Guid/Protocol/Ppis data
 891         #
 892         GuidObj = self.Parser.InfGuidSection.GetGuid()
 893         ProtocolObj = self.Parser.InfProtocolSection.GetProtocol()
 894         PpisObj = self.Parser.InfPpiSection.GetPpi()
 895
 896         GuidProtocolPpiList = []
 897
 898         if Type == DT.TAB_GUIDS:
 899             GuidData = GuidObj.keys()
 900             for Item in GuidData:
 901                 CommentList = Item.GetCommentList()
 902                 #
 903                 # Depend on CommentList content
 904                 # generate muti-guid-obj
 905                 #
 906                 if CommentList:
 907                     for GuidComentItem in CommentList:
 908                         ListObject = CommonObject.GuidObject()
 909                         ListObject.SetGuidTypeList([GuidComentItem.GetGuidTypeItem()])
 910                         ListObject.SetVariableName(GuidComentItem.GetVariableNameItem())
 911                         ListObject.SetUsage(GuidComentItem.GetUsageItem())
 912                         ListObject.SetName(Item.GetName())
 913                         ListObject.SetCName(Item.GetName())
 914                         ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
 915                         ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
 916                         HelpString = GuidComentItem.GetHelpStringItem()
 917                         HelpTxtTailObj = CommonObject.TextObject()
 918                         HelpTxtTailObj.SetString(HelpString)
 919
 920                         ListObject.SetHelpTextList([HelpTxtTailObj])
 921
 922                         GuidProtocolPpiList.append(ListObject)
 923         elif Type == DT.TAB_PROTOCOLS:
 924             ProtocolData = ProtocolObj.keys()
 925             for Item in ProtocolData:
 926                 CommentList = Item.GetCommentList()
 927                 for CommentItem in CommentList:
 928                     ListObject = CommonObject.ProtocolObject()
 929                     ListObject.SetCName(Item.GetName())
 930                     ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
 931                     ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
 932                     ListObject.SetNotify(CommentItem.GetNotify())
 933                     ListObject.SetUsage(CommentItem.GetUsageItem())
 934                     HelpTxtObj = CommonObject.TextObject()
 935                     HelpString = CommentItem.GetHelpStringItem()
 936                     HelpTxtObj.SetString(HelpString)
 937                     ListObject.SetHelpTextList([HelpTxtObj])
 938                     GuidProtocolPpiList.append(ListObject)
 939         elif Type == DT.TAB_PPIS:
 940             PpiData = PpisObj.keys()
 941             for Item in PpiData:
 942                 CommentList = Item.GetCommentList()
 943                 for CommentItem in CommentList:
 944                     ListObject = CommonObject.PpiObject()
 945                     ListObject.SetCName(Item.GetName())
 946                     ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
 947                     ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
 948                     ListObject.SetNotify(CommentItem.GetNotify())
 949                     ListObject.SetUsage(CommentItem.GetUsage())
 950                     HelpTextObj = CommonObject.TextObject()
 951                     HelpString = CommentItem.GetHelpStringItem()
 952                     HelpTextObj.SetString(HelpString)
 953                     ListObject.SetHelpTextList([HelpTextObj])
 954                     GuidProtocolPpiList.append(ListObject)
 955
 956         if Type == DT.TAB_GUIDS:
 957             self.SetGuidList(self.GetGuidList() + GuidProtocolPpiList)
 958         elif Type == DT.TAB_PROTOCOLS:
 959             self.SetProtocolList(self.GetProtocolList() + GuidProtocolPpiList)
 960         elif Type == DT.TAB_PPIS:
 961             self.SetPpiList(self.GetPpiList() + GuidProtocolPpiList)
 962
 963     ## GenMiscFiles
 964     #
 965     # Gen MiscellaneousFiles of Inf
 966     #
 967     # @param ContainerFile: The Inf file full path
 968     #
 969     def _GenMiscFiles(self, ContainerFile, Skip):
 970         pass
 971