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