mirror of
https://github.com/acidanthera/audk.git
synced 2025-10-27 01:03:45 +01:00
fb0f8067ea
Update UPT to refer MultipleWorkspace class to convert the file path from WORKSPACE and PACKAGES_PATH. Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Hesheng Chen <hesheng.chen@intel.com> Reviewed-by: Liming Gao <liming.gao@intel.com> git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@18580 6f19259b-4bc3-4df7-8a09-765794883524
1082 lines
48 KiB
Python
1082 lines
48 KiB
Python
## @file InfPomAlignment.py
|
|
# This file contained the adapter for convert INF parser object to POM Object
|
|
#
|
|
# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# This program and the accompanying materials are licensed and made available
|
|
# under the terms and conditions of the BSD License which accompanies this
|
|
# distribution. The full text of the license may be found at
|
|
# http://opensource.org/licenses/bsd-license.php
|
|
#
|
|
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
#
|
|
'''
|
|
InfPomAlignment
|
|
'''
|
|
##
|
|
# Import modules
|
|
#
|
|
import os.path
|
|
from Logger import StringTable as ST
|
|
import Logger.Log as Logger
|
|
from Library.String import FORMAT_INVALID
|
|
from Library.String import PARSER_ERROR
|
|
from Library.String import NormPath
|
|
from Library.String import GetSplitValueList
|
|
from Library.Misc import ConvertVersionToDecimal
|
|
from Library.Misc import GetHelpStringByRemoveHashKey
|
|
from Library.Misc import ConvertArchList
|
|
from Library.Misc import GetRelativePath
|
|
from Library.Misc import PathClass
|
|
from Library.Parsing import GetPkgInfoFromDec
|
|
from Library.UniClassObject import UniFileClassObject
|
|
from Library.UniClassObject import ConvertSpecialUnicodes
|
|
from Library.UniClassObject import GetLanguageCode1766
|
|
from Library import DataType as DT
|
|
from Library import GlobalData
|
|
from Library.ParserValidate import IsValidPath
|
|
from Object.POM import CommonObject
|
|
from Object.POM.ModuleObject import ModuleObject
|
|
from Object.POM.ModuleObject import ExternObject
|
|
from Object.POM.ModuleObject import HobObject
|
|
from Object.POM.ModuleObject import EventObject
|
|
from Object.POM.ModuleObject import BootModeObject
|
|
from Object.POM.ModuleObject import PackageDependencyObject
|
|
from Object.POM.ModuleObject import SourceFileObject
|
|
from Object.POM.ModuleObject import DepexObject
|
|
from Object.POM.ModuleObject import AsBuildLibraryClassObject
|
|
from Object.POM.ModuleObject import AsBuiltObject
|
|
from PomAdapter.InfPomAlignmentMisc import GenModuleHeaderUserExt
|
|
from PomAdapter.InfPomAlignmentMisc import GenBinaryData
|
|
from Parser import InfParser
|
|
from PomAdapter.DecPomAlignment import DecPomAlignment
|
|
from Common.MultipleWorkspace import MultipleWorkspace as mws
|
|
|
|
## InfPomAlignment
|
|
#
|
|
# Inherit from ModuleObject
|
|
#
|
|
class InfPomAlignment(ModuleObject):
|
|
## Construct of InfPomAlignment
|
|
# Skip means that UPT don't care the syntax of INF, this may be the not
|
|
# distributed INF files during creation or the INF files checked for
|
|
# dependency rule during remove.
|
|
#
|
|
def __init__(self, FileName, WorkSpace=None, PackagePath='', Skip=False):
|
|
ModuleObject.__init__(self)
|
|
self.Parser = None
|
|
self.FileName = FileName
|
|
self.WorkSpace = WorkSpace
|
|
self.CombinePath = ''
|
|
self.LibModuleTypeList = []
|
|
self.FullPath = ''
|
|
self.ModulePath = ''
|
|
self.WorkspaceDir = " "
|
|
self.CustomMakefile = []
|
|
self.UniFileClassObject = None
|
|
self.SetPackagePath(PackagePath)
|
|
#
|
|
# Call GenInfPomObjects function to fill POM object.
|
|
#
|
|
if Skip:
|
|
OrigConfig = Logger.SUPRESS_ERROR
|
|
Logger.SUPRESS_ERROR = True
|
|
try:
|
|
self._GenInfPomObjects(Skip)
|
|
finally:
|
|
Logger.SUPRESS_ERROR = OrigConfig
|
|
else:
|
|
self._GenInfPomObjects(Skip)
|
|
|
|
##
|
|
# Generate all POM objects, the original input comes
|
|
# from INF parser's output
|
|
#
|
|
def _GenInfPomObjects(self, Skip):
|
|
#
|
|
# Call INF Parser to get information from INF file
|
|
#
|
|
self.Parser = InfParser.InfParser(self.FileName, self.WorkSpace)
|
|
self.FullPath = self.Parser.FullPath
|
|
self.GetFullPath()
|
|
self._GenModuleHeader()
|
|
#
|
|
# Call GenBinaries after Module Header for Binary INF consideration.
|
|
#
|
|
self._GenBinaries()
|
|
self._GenBuildOptions()
|
|
self._GenLibraryClasses()
|
|
self._GenPackages(Skip)
|
|
self._GenPcds()
|
|
self._GenSources()
|
|
self._GenUserExtensions()
|
|
self._GenGuidProtocolPpis(DT.TAB_GUIDS)
|
|
self._GenGuidProtocolPpis(DT.TAB_PROTOCOLS)
|
|
self._GenGuidProtocolPpis(DT.TAB_PPIS)
|
|
self._GenDepexes()
|
|
|
|
## Convert [Defines] section content to InfDefObject
|
|
#
|
|
# Convert [Defines] section content to InfDefObject
|
|
#
|
|
# @param Defines The content under [Defines] section
|
|
# @param ModuleHeader An object of ModuleHeaderClass
|
|
# @param Arch The supported ARCH
|
|
#
|
|
def _GenModuleHeader(self):
|
|
Logger.Debug(2, "Generate ModuleHeader ...")
|
|
#
|
|
# Get all defines information form InfParser Object
|
|
#
|
|
RecordSet = self.Parser.InfDefSection.Defines
|
|
#
|
|
# Should only have one ArchString Item.
|
|
#
|
|
ArchString = RecordSet.keys()[0]
|
|
ArchList = GetSplitValueList(ArchString, ' ')
|
|
ArchList = ConvertArchList(ArchList)
|
|
HasCalledFlag = False
|
|
#
|
|
# Get data from Sdict()
|
|
#
|
|
ValueList = RecordSet[ArchString]
|
|
self.SetFileName(self.FileName)
|
|
self.SetFullPath(self.FullPath)
|
|
#
|
|
# The INF's filename (without the directory path or the extension)
|
|
# must be used for the value of the
|
|
# ModuleSurfaceArea.Header.Name element
|
|
#
|
|
self.SetName(os.path.splitext(os.path.basename(self.FileName))[0])
|
|
self.WorkspaceDir = " "
|
|
#
|
|
# CombinePath and ModulePath
|
|
#
|
|
CombinePath = GetRelativePath(self.FullPath, self.WorkSpace)
|
|
self.SetCombinePath(CombinePath)
|
|
ModulePath = os.path.split(CombinePath)[0]
|
|
ModuleRelativePath = ModulePath
|
|
if self.GetPackagePath() != '':
|
|
ModuleRelativePath = GetRelativePath(ModulePath, self.GetPackagePath())
|
|
self.SetModulePath(ModuleRelativePath)
|
|
#
|
|
# For Define Seciton Items.
|
|
#
|
|
DefineObj = ValueList
|
|
#
|
|
# Convert UEFI/PI version to decimal number
|
|
#
|
|
if DefineObj.GetUefiSpecificationVersion() != None:
|
|
__UefiVersion = DefineObj.GetUefiSpecificationVersion().GetValue()
|
|
__UefiVersion = ConvertVersionToDecimal(__UefiVersion)
|
|
self.SetUefiSpecificationVersion(str(__UefiVersion))
|
|
if DefineObj.GetPiSpecificationVersion() != None:
|
|
__PiVersion = DefineObj.GetPiSpecificationVersion().GetValue()
|
|
__PiVersion = ConvertVersionToDecimal(__PiVersion)
|
|
|
|
self.SetPiSpecificationVersion(str(__PiVersion))
|
|
SpecList = DefineObj.GetSpecification()
|
|
NewSpecList = []
|
|
for SpecItem in SpecList:
|
|
NewSpecList.append((SpecItem[0], ConvertVersionToDecimal(SpecItem[1])))
|
|
self.SetSpecList(NewSpecList)
|
|
|
|
#
|
|
# must exist items in INF define section
|
|
# MODULE_TYPE/BASE_NAME/INF_VERSION/FILE_GUID/VERSION_STRING
|
|
#
|
|
if DefineObj.GetModuleType() == None:
|
|
Logger.Error("InfParser", FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("MODULE_TYPE"), File=self.FullPath)
|
|
else:
|
|
self.SetModuleType(DefineObj.GetModuleType().GetValue())
|
|
ModuleType = DefineObj.GetModuleType().GetValue()
|
|
if ModuleType:
|
|
#
|
|
# Drivers and applications are not allowed to have a MODULE_TYPE of "BASE". Only
|
|
# libraries are permitted to a have a MODULE_TYPE of "BASE".
|
|
#
|
|
if len(DefineObj.LibraryClass) == 0 and ModuleType == 'BASE':
|
|
Logger.Error("InfParser",
|
|
FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_MODULETYPE_INVALID,
|
|
File=self.FullPath,
|
|
Line=DefineObj.ModuleType.CurrentLine.LineNo,
|
|
ExtraData=DefineObj.ModuleType.CurrentLine.LineString)
|
|
self.LibModuleTypeList.append(ModuleType)
|
|
if DefineObj.GetBaseName() == None:
|
|
Logger.Error("InfParser", FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("BASE_NAME"), File=self.FullPath)
|
|
else:
|
|
self.SetBaseName(DefineObj.GetBaseName().GetValue())
|
|
if DefineObj.GetModuleUniFileName():
|
|
self.UniFileClassObject = UniFileClassObject([PathClass(DefineObj.GetModuleUniFileName())])
|
|
else:
|
|
self.UniFileClassObject = None
|
|
if DefineObj.GetInfVersion() == None:
|
|
Logger.Error("InfParser", FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("INF_VERSION"), File=self.FullPath)
|
|
else:
|
|
self.SetVersion(DefineObj.GetInfVersion().GetValue())
|
|
if DefineObj.GetFileGuid() == None:
|
|
Logger.Error("InfParser", FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("FILE_GUID"), File=self.FullPath)
|
|
else:
|
|
self.SetGuid(DefineObj.GetFileGuid().GetValue())
|
|
if DefineObj.GetVersionString() == None:
|
|
#
|
|
# VERSION_STRING is missing from the [Defines] section, tools must assume that the module's version is 0.
|
|
#
|
|
self.SetVersion('0')
|
|
else:
|
|
#
|
|
# Get version of INF
|
|
#
|
|
if DefineObj.GetVersionString().GetValue() != "":
|
|
#
|
|
# EDK2 inf
|
|
#
|
|
VersionString = DefineObj.GetVersionString().GetValue()
|
|
if len(VersionString) > 0:
|
|
VersionString = ConvertVersionToDecimal(VersionString)
|
|
self.SetVersion(VersionString)
|
|
else:
|
|
#
|
|
# EDK1 inf
|
|
#
|
|
Logger.Error("Parser", PARSER_ERROR, ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF, ExtraData=self.FullPath,
|
|
RaiseError=Logger.IS_RAISE_ERROR)
|
|
#
|
|
# if there is Shadow, Should judge the MODULE_TYPE in
|
|
# SEC, PEI_CORE and PEIM
|
|
#
|
|
if DefineObj.GetShadow():
|
|
ModuleTypeValue = DefineObj.GetModuleType().GetValue()
|
|
if not (ModuleTypeValue == 'SEC' or ModuleTypeValue == 'PEI_CORE' or ModuleTypeValue == 'PEIM'):
|
|
Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_SHADOW_INVALID, File=self.FullPath)
|
|
|
|
if DefineObj.GetPcdIsDriver() != None:
|
|
self.SetPcdIsDriver(DefineObj.GetPcdIsDriver().GetValue())
|
|
#
|
|
# LIBRARY_CLASS
|
|
#
|
|
self._GenModuleHeaderLibClass(DefineObj, ArchList)
|
|
#
|
|
# CUSTOM_MAKEFILE
|
|
#
|
|
self.CustomMakefile = DefineObj.GetCustomMakefile()
|
|
#
|
|
# Externs in Defines section
|
|
# Only one define section, so just call once.
|
|
#
|
|
if not HasCalledFlag:
|
|
self._GenModuleHeaderExterns(DefineObj)
|
|
HasCalledFlag = True
|
|
#
|
|
# each module has only one module header
|
|
#
|
|
self.SetSupArchList(ArchList)
|
|
#
|
|
# Get Hob/BootMode/EventList information
|
|
#
|
|
self._GenSpecialComments()
|
|
#
|
|
# put all define statement into user-extension sections
|
|
#
|
|
DefinesDictNew = GenModuleHeaderUserExt(DefineObj, ArchString)
|
|
if DefinesDictNew:
|
|
UserExtension = CommonObject.UserExtensionObject()
|
|
UserExtension.SetDefinesDict(DefinesDictNew)
|
|
UserExtension.SetIdentifier('DefineModifiers')
|
|
UserExtension.SetUserID('EDK2')
|
|
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
|
|
#
|
|
# Get all meta-file header information
|
|
# the record is list of items formated:
|
|
# [LineValue, Arch, StartLine, ID, Third]
|
|
#
|
|
InfHeaderObj = self.Parser.InfHeader
|
|
#
|
|
# Put header information into POM object
|
|
#
|
|
if self.UniFileClassObject:
|
|
Lang = DT.TAB_LANGUAGE_EN_X
|
|
else:
|
|
Lang = DT.TAB_LANGUAGE_EN_US
|
|
if InfHeaderObj.GetAbstract():
|
|
self.SetAbstract((Lang, InfHeaderObj.GetAbstract()))
|
|
if InfHeaderObj.GetDescription():
|
|
self.SetDescription((Lang, InfHeaderObj.GetDescription()))
|
|
if InfHeaderObj.GetCopyright():
|
|
self.SetCopyright(('', InfHeaderObj.GetCopyright()))
|
|
if InfHeaderObj.GetLicense():
|
|
self.SetLicense(('', InfHeaderObj.GetLicense()))
|
|
#
|
|
# Put Binary header information into POM object
|
|
#
|
|
InfBinaryHeaderObj = self.Parser.InfBinaryHeader
|
|
if InfBinaryHeaderObj.GetAbstract():
|
|
self.SetBinaryHeaderAbstract((Lang, InfBinaryHeaderObj.GetAbstract()))
|
|
if InfBinaryHeaderObj.GetDescription():
|
|
self.SetBinaryHeaderDescription((Lang, InfBinaryHeaderObj.GetDescription()))
|
|
if InfBinaryHeaderObj.GetCopyright():
|
|
self.SetBinaryHeaderCopyright(('', InfBinaryHeaderObj.GetCopyright()))
|
|
if InfBinaryHeaderObj.GetLicense():
|
|
self.SetBinaryHeaderLicense(('', InfBinaryHeaderObj.GetLicense()))
|
|
|
|
## GenModuleHeaderLibClass
|
|
#
|
|
#
|
|
def _GenModuleHeaderLibClass(self, DefineObj, ArchList):
|
|
LibraryList = DefineObj.GetLibraryClass()
|
|
for LibraryItem in LibraryList:
|
|
Lib = CommonObject.LibraryClassObject()
|
|
Lib.SetLibraryClass(LibraryItem.GetLibraryName())
|
|
Lib.SetUsage(DT.USAGE_ITEM_PRODUCES)
|
|
SupModuleList = LibraryItem.GetTypes()
|
|
self.LibModuleTypeList += SupModuleList
|
|
Lib.SetSupModuleList(SupModuleList)
|
|
Lib.SetSupArchList(ArchList)
|
|
self.SetLibraryClassList(self.GetLibraryClassList() + [Lib])
|
|
self.SetIsLibrary(True)
|
|
self.SetIsLibraryModList(self.GetIsLibraryModList() + SupModuleList)
|
|
|
|
## GenModuleHeaderExterns
|
|
#
|
|
#
|
|
def _GenModuleHeaderExterns(self, DefineObj):
|
|
EntryPointList = DefineObj.GetEntryPoint()
|
|
for EntryPoint in EntryPointList:
|
|
Image = ExternObject()
|
|
Image.SetEntryPoint(EntryPoint.GetCName())
|
|
#
|
|
# Future enhancement
|
|
#
|
|
self.SetExternList(self.GetExternList() + [Image])
|
|
#
|
|
# UNLOAD_IMAGE
|
|
#
|
|
UnloadImageList = DefineObj.GetUnloadImages()
|
|
for UnloadImage in UnloadImageList:
|
|
Image = ExternObject()
|
|
#
|
|
# Future enhancement
|
|
#
|
|
Image.SetUnloadImage(UnloadImage.GetCName())
|
|
self.SetExternList(self.GetExternList() + [Image])
|
|
#
|
|
# CONSTRUCTOR
|
|
#
|
|
ConstructorList = DefineObj.GetConstructor()
|
|
for ConstructorItem in ConstructorList:
|
|
Image = ExternObject()
|
|
#
|
|
# Future enhancement
|
|
#
|
|
Image.SetConstructor(ConstructorItem.GetCName())
|
|
self.SetExternList(self.GetExternList() + [Image])
|
|
#
|
|
# DESTRUCTOR
|
|
#
|
|
DestructorList = DefineObj.GetDestructor()
|
|
for DestructorItem in DestructorList:
|
|
Image = ExternObject()
|
|
#
|
|
# Future enhancement
|
|
#
|
|
Image.SetDestructor(DestructorItem.GetCName())
|
|
self.SetExternList(self.GetExternList() + [Image])
|
|
|
|
## GenModuleHeaderExterns
|
|
# BootMode/HOB/Event
|
|
#
|
|
def _GenSpecialComments(self):
|
|
SpecialCommentsList = self.Parser.InfSpecialCommentSection.GetSpecialComments()
|
|
for Key in SpecialCommentsList:
|
|
if Key == DT.TYPE_HOB_SECTION:
|
|
HobList = []
|
|
for Item in SpecialCommentsList[Key]:
|
|
Hob = HobObject()
|
|
Hob.SetHobType(Item.GetHobType())
|
|
Hob.SetUsage(Item.GetUsage())
|
|
Hob.SetSupArchList(Item.GetSupArchList())
|
|
if Item.GetHelpString():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(Item.GetHelpString())
|
|
Hob.SetHelpTextList([HelpTextObj])
|
|
HobList.append(Hob)
|
|
self.SetHobList(HobList)
|
|
elif Key == DT.TYPE_EVENT_SECTION:
|
|
EventList = []
|
|
for Item in SpecialCommentsList[Key]:
|
|
Event = EventObject()
|
|
Event.SetEventType(Item.GetEventType())
|
|
Event.SetUsage(Item.GetUsage())
|
|
if Item.GetHelpString():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(Item.GetHelpString())
|
|
Event.SetHelpTextList([HelpTextObj])
|
|
EventList.append(Event)
|
|
self.SetEventList(EventList)
|
|
elif Key == DT.TYPE_BOOTMODE_SECTION:
|
|
BootModeList = []
|
|
for Item in SpecialCommentsList[Key]:
|
|
BootMode = BootModeObject()
|
|
BootMode.SetSupportedBootModes(Item.GetSupportedBootModes())
|
|
BootMode.SetUsage(Item.GetUsage())
|
|
if Item.GetHelpString():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(Item.GetHelpString())
|
|
BootMode.SetHelpTextList([HelpTextObj])
|
|
BootModeList.append(BootMode)
|
|
self.SetBootModeList(BootModeList)
|
|
|
|
## GenBuildOptions
|
|
#
|
|
# Gen BuildOptions of Inf
|
|
# [<Family>:]<ToolFlag>=Flag
|
|
#
|
|
#
|
|
def _GenBuildOptions(self):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_BUILD_OPTIONS)
|
|
#
|
|
# Get all BuildOptions
|
|
#
|
|
BuildOptionsList = self.Parser.InfBuildOptionSection.GetBuildOptions()
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
BuildOptionDict = {}
|
|
for BuildOptionObj in BuildOptionsList:
|
|
ArchList = BuildOptionObj.GetSupArchList()
|
|
ArchList = ConvertArchList(ArchList)
|
|
BuildOptionsContent = BuildOptionObj.GetContent()
|
|
ArchString = ' '.join(ArchList)
|
|
if not BuildOptionsContent:
|
|
continue
|
|
BuildOptionDict[ArchString] = BuildOptionsContent
|
|
if not BuildOptionDict:
|
|
return
|
|
UserExtension = CommonObject.UserExtensionObject()
|
|
UserExtension.SetBuildOptionDict(BuildOptionDict)
|
|
UserExtension.SetIdentifier('BuildOptionModifiers')
|
|
UserExtension.SetUserID('EDK2')
|
|
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
|
|
else:
|
|
#
|
|
# Not process this information, will be processed in GenBinaries()
|
|
#
|
|
pass
|
|
|
|
## GenLibraryClasses
|
|
#
|
|
# Get LibraryClass of Inf
|
|
# <LibraryClassKeyWord>|<LibraryInstance>
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenLibraryClasses(self):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_LIBRARY_CLASSES)
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
#
|
|
# Get all LibraryClasses
|
|
#
|
|
LibClassObj = self.Parser.InfLibraryClassSection.LibraryClasses
|
|
Keys = LibClassObj.keys()
|
|
for Key in Keys:
|
|
LibraryClassData = LibClassObj[Key]
|
|
for Item in LibraryClassData:
|
|
LibraryClass = CommonObject.LibraryClassObject()
|
|
LibraryClass.SetUsage(DT.USAGE_ITEM_CONSUMES)
|
|
LibraryClass.SetLibraryClass(Item.GetLibName())
|
|
LibraryClass.SetRecommendedInstance(None)
|
|
LibraryClass.SetFeatureFlag(Item.GetFeatureFlagExp())
|
|
LibraryClass.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
|
|
LibraryClass.SetSupModuleList(Item.GetSupModuleList())
|
|
HelpStringObj = Item.GetHelpString()
|
|
if HelpStringObj != None:
|
|
CommentString = GetHelpStringByRemoveHashKey(HelpStringObj.HeaderComments +
|
|
HelpStringObj.TailComments)
|
|
HelpTextHeaderObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextHeaderObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextHeaderObj.SetString(CommentString)
|
|
LibraryClass.SetHelpTextList([HelpTextHeaderObj])
|
|
self.SetLibraryClassList(self.GetLibraryClassList() + [LibraryClass])
|
|
|
|
## GenPackages
|
|
#
|
|
# Gen Packages of Inf
|
|
#
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenPackages(self, Skip):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_PACKAGES)
|
|
#
|
|
# Get all Packages
|
|
#
|
|
PackageObj = self.Parser.InfPackageSection.Packages
|
|
#
|
|
# Go through each arch
|
|
#
|
|
for PackageItemObj in PackageObj:
|
|
#
|
|
# Need package information for dependency check usage
|
|
#
|
|
PackageDependency = PackageDependencyObject()
|
|
PackageDependency.SetPackageFilePath(NormPath(PackageItemObj.GetPackageName()))
|
|
PackageDependency.SetSupArchList(ConvertArchList(PackageItemObj.GetSupArchList()))
|
|
PackageDependency.SetFeatureFlag(PackageItemObj.GetFeatureFlagExp())
|
|
|
|
PkgInfo = GetPkgInfoFromDec(mws.join(self.WorkSpace, NormPath(PackageItemObj.GetPackageName())))
|
|
if PkgInfo[1] and PkgInfo[2]:
|
|
PackageDependency.SetGuid(PkgInfo[1])
|
|
PackageDependency.SetVersion(PkgInfo[2])
|
|
elif Skip:
|
|
continue
|
|
else:
|
|
Logger.Error("\nUPT", PARSER_ERROR,
|
|
ST.ERR_INF_GET_PKG_DEPENDENCY_FAIL % PackageItemObj.GetPackageName(), File=self.FullPath)
|
|
|
|
PackageDependencyList = self.GetPackageDependencyList()
|
|
PackageDependencyList.append(PackageDependency)
|
|
self.SetPackageDependencyList(PackageDependencyList)
|
|
|
|
## GenPcds
|
|
#
|
|
# Gen Pcds of Inf
|
|
# <TokenSpaceGuidCName>.<PcdCName>[|<Value> [|<FFE>]]
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenPcds(self):
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_PCDS)
|
|
#
|
|
# Get all Pcds
|
|
#
|
|
PcdObj = self.Parser.InfPcdSection.Pcds
|
|
KeysList = PcdObj.keys()
|
|
#
|
|
# Go through each arch
|
|
#
|
|
for (PcdType, PcdKey) in KeysList:
|
|
PcdData = PcdObj[PcdType, PcdKey]
|
|
for PcdItemObj in PcdData:
|
|
CommentList = PcdItemObj.GetHelpStringList()
|
|
if CommentList:
|
|
for CommentItem in CommentList:
|
|
Pcd = CommonObject.PcdObject()
|
|
Pcd.SetCName(PcdItemObj.GetCName())
|
|
Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())
|
|
Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
|
|
Pcd.SetItemType(PcdType)
|
|
Pcd.SetValidUsage(CommentItem.GetUsageItem())
|
|
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
|
|
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(CommentItem.GetHelpStringItem())
|
|
Pcd.SetHelpTextList([HelpTextObj])
|
|
PcdList = self.GetPcdList()
|
|
PcdList.append(Pcd)
|
|
self.SetPcdList(PcdList)
|
|
|
|
## GenSources
|
|
#
|
|
# Gen Sources of Inf
|
|
# <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenSources(self):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_SOURCES)
|
|
|
|
#
|
|
# Get all SourceFiles
|
|
#
|
|
SourceObj = self.Parser.InfSourcesSection.Sources
|
|
DataList = SourceObj.keys()
|
|
#
|
|
# Go through each arch
|
|
#
|
|
SourceList = []
|
|
for Key in DataList:
|
|
SourceData = SourceObj[Key]
|
|
for Item in SourceData:
|
|
SourceFile = Item.GetSourceFileName()
|
|
Family = Item.GetFamily()
|
|
FeatureFlag = Item.GetFeatureFlagExp()
|
|
SupArchList = ConvertArchList(Item.GetSupArchList())
|
|
SupArchList.sort()
|
|
Source = SourceFileObject()
|
|
Source.SetSourceFile(SourceFile)
|
|
Source.SetFamily(Family)
|
|
Source.SetFeatureFlag(FeatureFlag)
|
|
Source.SetSupArchList(SupArchList)
|
|
SourceList.append(Source)
|
|
|
|
self.SetSourceFileList(self.GetSourceFileList() + SourceList)
|
|
|
|
|
|
## GenUserExtensions
|
|
#
|
|
# Gen UserExtensions of Inf
|
|
#
|
|
def _GenUserExtensions(self):
|
|
#
|
|
# UserExtensions
|
|
#
|
|
UserExtensionObj = self.Parser.InfUserExtensionSection.UserExtension
|
|
Keys = UserExtensionObj.keys()
|
|
|
|
for Key in Keys:
|
|
UserExtensionData = UserExtensionObj[Key]
|
|
for UserExtensionDataObj in UserExtensionData:
|
|
UserExtension = CommonObject.UserExtensionObject()
|
|
UserId = UserExtensionDataObj.GetUserId()
|
|
if UserId.startswith('"') and UserId.endswith('"'):
|
|
UserId = UserId[1:-1]
|
|
UserExtension.SetUserID(UserId)
|
|
Identifier = UserExtensionDataObj.GetIdString()
|
|
if Identifier.startswith('"') and Identifier.endswith('"'):
|
|
Identifier = Identifier[1:-1]
|
|
#
|
|
# Generate miscellaneous files on INF file
|
|
#
|
|
if UserId == 'TianoCore' and Identifier == 'ExtraFiles':
|
|
self._GenMiscFiles(UserExtensionDataObj.GetContent())
|
|
UserExtension.SetIdentifier(Identifier)
|
|
UserExtension.SetStatement(UserExtensionDataObj.GetContent())
|
|
UserExtension.SetSupArchList(ConvertArchList(UserExtensionDataObj.GetSupArchList()))
|
|
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
|
|
|
|
#
|
|
# Gen UserExtensions of TianoCore."BinaryHeader"
|
|
#
|
|
|
|
#Get Binary header from INF file
|
|
BinaryAbstractList = self.BinaryHeaderAbstractList
|
|
BinaryDescriptionList = self.BinaryHeaderDescriptionList
|
|
BinaryCopyrightList = self.BinaryHeaderCopyrightList
|
|
BinaryLicenseList = self.BinaryHeaderLicenseList
|
|
#Get Binary header from UNI file
|
|
# Initialize UniStrDict, the top keys are language codes
|
|
UniStrDict = {}
|
|
if self.UniFileClassObject:
|
|
UniStrDict = self.UniFileClassObject.OrderedStringList
|
|
for Lang in UniStrDict:
|
|
for StringDefClassObject in UniStrDict[Lang]:
|
|
Lang = GetLanguageCode1766(Lang)
|
|
if StringDefClassObject.StringName == DT.TAB_INF_BINARY_ABSTRACT:
|
|
BinaryAbstractList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
|
|
if StringDefClassObject.StringName == DT.TAB_INF_BINARY_DESCRIPTION:
|
|
BinaryDescriptionList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
|
|
if BinaryAbstractList or BinaryDescriptionList or BinaryCopyrightList or BinaryLicenseList:
|
|
BinaryUserExtension = CommonObject.UserExtensionObject()
|
|
BinaryUserExtension.SetBinaryAbstract(BinaryAbstractList)
|
|
BinaryUserExtension.SetBinaryDescription(BinaryDescriptionList)
|
|
BinaryUserExtension.SetBinaryCopyright(BinaryCopyrightList)
|
|
BinaryUserExtension.SetBinaryLicense(BinaryLicenseList)
|
|
BinaryUserExtension.SetIdentifier(DT.TAB_BINARY_HEADER_IDENTIFIER)
|
|
BinaryUserExtension.SetUserID(DT.TAB_BINARY_HEADER_USERID)
|
|
self.SetUserExtensionList(self.GetUserExtensionList() + [BinaryUserExtension])
|
|
|
|
def _GenDepexesList(self, SmmDepexList, DxeDepexList, PeiDepexList):
|
|
if SmmDepexList:
|
|
self.SetSmmDepex(SmmDepexList)
|
|
if DxeDepexList:
|
|
self.SetDxeDepex(DxeDepexList)
|
|
if PeiDepexList:
|
|
self.SetPeiDepex(PeiDepexList)
|
|
|
|
## GenDepexes
|
|
#
|
|
# Gen Depex of Inf
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenDepexes(self):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_DEPEX)
|
|
|
|
PEI_LIST = [DT.SUP_MODULE_PEIM]
|
|
SMM_LIST = [DT.SUP_MODULE_DXE_SMM_DRIVER]
|
|
DXE_LIST = [DT.SUP_MODULE_DXE_DRIVER, DT.SUP_MODULE_DXE_SAL_DRIVER,
|
|
DT.SUP_MODULE_DXE_RUNTIME_DRIVER]
|
|
|
|
IsLibraryClass = self.GetIsLibrary()
|
|
#
|
|
# Get all Depexes
|
|
#
|
|
DepexData = self.Parser.InfDepexSection.GetDepex()
|
|
SmmDepexList = []
|
|
DxeDepexList = []
|
|
PeiDepexList = []
|
|
for Depex in DepexData:
|
|
ModuleType = Depex.GetModuleType()
|
|
ModuleTypeList = []
|
|
if IsLibraryClass:
|
|
if self.GetModuleType() == 'BASE' and not ModuleType:
|
|
Logger.Error("\nMkPkg", PARSER_ERROR,
|
|
ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_BASE_LIBRARY_CLASS,
|
|
self.GetFullPath(), RaiseError=True)
|
|
if self.GetModuleType() != 'BASE' and not self.GetIsLibraryModList():
|
|
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_LIBRARY_CLASS,
|
|
self.GetFullPath(), RaiseError=True)
|
|
if self.GetModuleType() != 'BASE' and ModuleType and ModuleType not in self.GetIsLibraryModList():
|
|
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
|
|
self.GetFullPath(), RaiseError=True)
|
|
if ModuleType:
|
|
ModuleTypeList = [ModuleType]
|
|
else:
|
|
for ModuleTypeInList in self.GetIsLibraryModList():
|
|
if ModuleTypeInList in DT.VALID_DEPEX_MODULE_TYPE_LIST:
|
|
ModuleTypeList.append(ModuleTypeInList)
|
|
if not ModuleTypeList:
|
|
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
|
|
self.GetFullPath(), RaiseError=True)
|
|
else:
|
|
if not ModuleType:
|
|
ModuleType = self.ModuleType
|
|
if ModuleType not in DT.VALID_DEPEX_MODULE_TYPE_LIST:
|
|
Logger.Error("\nMkPkg", PARSER_ERROR,
|
|
ST.ERR_INF_PARSER_DEPEX_SECTION_MODULE_TYPE_ERROR % (ModuleType),
|
|
self.GetFullPath(), RaiseError=True)
|
|
if ModuleType != self.ModuleType:
|
|
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,
|
|
self.GetFullPath(), RaiseError=True)
|
|
ModuleTypeList = [ModuleType]
|
|
for ModuleType in ModuleTypeList:
|
|
DepexIns = DepexObject()
|
|
DepexIns.SetDepex(Depex.GetDepexContent())
|
|
if IsLibraryClass:
|
|
DepexIns.SetModuleType(ModuleType)
|
|
else:
|
|
if Depex.GetModuleType():
|
|
DepexIns.SetModuleType(Depex.GetModuleType())
|
|
DepexIns.SetSupArchList(ConvertArchList([Depex.GetSupArch()]))
|
|
DepexIns.SetFeatureFlag(Depex.GetFeatureFlagExp())
|
|
if Depex.HelpString:
|
|
HelpIns = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpIns.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpIns.SetString(GetHelpStringByRemoveHashKey(Depex.HelpString))
|
|
DepexIns.SetHelpText(HelpIns)
|
|
|
|
if ModuleType in SMM_LIST:
|
|
SmmDepexList.append(DepexIns)
|
|
if ModuleType in DXE_LIST:
|
|
DxeDepexList.append(DepexIns)
|
|
if ModuleType in PEI_LIST:
|
|
PeiDepexList.append(DepexIns)
|
|
if ModuleType == DT.SUP_MODULE_UEFI_DRIVER:
|
|
if IsLibraryClass:
|
|
DxeDepexList.append(DepexIns)
|
|
else:
|
|
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_DRIVER,
|
|
self.GetFullPath(), RaiseError=True)
|
|
|
|
#End of for ModuleType in ModuleTypeList
|
|
self._GenDepexesList(SmmDepexList, DxeDepexList, PeiDepexList)
|
|
#End of for Depex in DepexData
|
|
|
|
## GenBinaries
|
|
#
|
|
# Gen Binary of Inf, must be called after Pcd/Library is generated
|
|
# <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenBinaries(self):
|
|
Logger.Debug(2, "Generate %s ..." % DT.TAB_BINARIES)
|
|
BinariesDict = {}
|
|
|
|
#
|
|
# Get all Binary data
|
|
#
|
|
BinaryObj = self.Parser.InfBinariesSection.GetBinary()
|
|
|
|
BinaryData = BinaryObj.keys()
|
|
|
|
#
|
|
# If the INF file does not contain a [Sources] section, and the INF file does contain a [Binaries] section,
|
|
# then the ModuleSurfaceArea.BinaryModule attribute must be set to true. Otherwise, do not use the attribute
|
|
#
|
|
if BinaryObj and not self.Parser.InfSourcesSection.GetSources():
|
|
self.BinaryModule = True
|
|
else:
|
|
self.BinaryModule = False
|
|
|
|
BinaryFileObjectList = []
|
|
AsBuildLibraryClassList = []
|
|
AsBuildBuildOptionList = []
|
|
AsBuildIns = AsBuiltObject()
|
|
#
|
|
# Library AsBuild Info
|
|
#
|
|
for LibItem in self.Parser.InfLibraryClassSection.GetLibraryClasses():
|
|
AsBuildLibIns = AsBuildLibraryClassObject()
|
|
AsBuildLibIns.SetLibGuid(LibItem.GetFileGuid())
|
|
AsBuildLibIns.SetLibVersion(LibItem.GetVersion())
|
|
AsBuildLibIns.SetSupArchList(LibItem.GetSupArchList())
|
|
AsBuildLibraryClassList.append(AsBuildLibIns)
|
|
AsBuildIns.SetLibraryInstancesList(AsBuildLibraryClassList)
|
|
|
|
#
|
|
# BuildOption AsBuild Info
|
|
#
|
|
for BuildOptionItem in self.Parser.InfBuildOptionSection.GetBuildOptions():
|
|
AsBuildBuildOptionList.append(BuildOptionItem)
|
|
AsBuildIns.SetBuildFlagsList(AsBuildBuildOptionList)
|
|
|
|
#
|
|
# PatchPcd and PcdEx
|
|
#
|
|
AsBuildIns = self._GenAsBuiltPcds(self.Parser.InfPcdSection.GetPcds(), AsBuildIns)
|
|
|
|
#
|
|
# Parse the DEC file that contains the GUID value of the GUID CName which is used by
|
|
# SUBTYPE_GUID type binary file in the Binaries section in the INF file
|
|
#
|
|
DecObjList = []
|
|
if not self.PackagePath:
|
|
WorkSpace = os.path.normpath(self.WorkSpace)
|
|
TempPath = ModulePath = os.path.normpath(self.ModulePath)
|
|
while ModulePath:
|
|
TempPath = ModulePath
|
|
ModulePath = os.path.dirname(ModulePath)
|
|
PackageName = TempPath
|
|
DecFilePath = os.path.normpath(os.path.join(WorkSpace, PackageName))
|
|
if DecFilePath:
|
|
for File in os.listdir(DecFilePath):
|
|
if File.upper().endswith('.DEC'):
|
|
DecFileFullPath = os.path.normpath(os.path.join(DecFilePath, File))
|
|
DecObjList.append(DecPomAlignment(DecFileFullPath, self.WorkSpace))
|
|
|
|
|
|
BinariesDict, AsBuildIns, BinaryFileObjectList = GenBinaryData(BinaryData, BinaryObj,
|
|
BinariesDict,
|
|
AsBuildIns,
|
|
BinaryFileObjectList,
|
|
self.GetSupArchList(),
|
|
self.BinaryModule,
|
|
DecObjList)
|
|
|
|
BinariesDict2 = {}
|
|
for Key in BinariesDict:
|
|
ValueList = BinariesDict[Key]
|
|
if len(ValueList) > 1:
|
|
BinariesDict2[Key] = ValueList
|
|
else:
|
|
#
|
|
# if there is no TagName, ToolCode, HelpStr,
|
|
# then do not need to put them into userextension
|
|
#
|
|
(Target, Family, TagName, HelpStr) = ValueList[0]
|
|
if not (Target or Family or TagName or HelpStr):
|
|
continue
|
|
else:
|
|
BinariesDict2[Key] = ValueList
|
|
|
|
self.SetBinaryFileList(self.GetBinaryFileList() + BinaryFileObjectList)
|
|
|
|
if BinariesDict2:
|
|
UserExtension = CommonObject.UserExtensionObject()
|
|
UserExtension.SetBinariesDict(BinariesDict2)
|
|
UserExtension.SetIdentifier('BinaryFileModifiers')
|
|
UserExtension.SetUserID('EDK2')
|
|
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])
|
|
|
|
## GenAsBuiltPcds
|
|
#
|
|
#
|
|
def _GenAsBuiltPcds(self, PcdList, AsBuildIns):
|
|
AsBuildPatchPcdList = []
|
|
AsBuildPcdExList = []
|
|
#
|
|
# Pcd AsBuild Info
|
|
#
|
|
for PcdItem in PcdList:
|
|
if PcdItem[0].upper() == DT.TAB_INF_PATCH_PCD.upper():
|
|
PcdItemObj = PcdItem[1]
|
|
Pcd = CommonObject.PcdObject()
|
|
Pcd.SetCName(PcdItemObj.GetCName())
|
|
Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())
|
|
if PcdItemObj.GetTokenSpaceGuidValue() == '' and self.BinaryModule:
|
|
Logger.Error("\nMkPkg",
|
|
PARSER_ERROR,
|
|
ST.ERR_ASBUILD_PCD_TOKENSPACE_GUID_VALUE_MISS % \
|
|
(PcdItemObj.GetTokenSpaceGuidCName()),
|
|
self.GetFullPath(), RaiseError=True)
|
|
else:
|
|
Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())
|
|
if (PcdItemObj.GetToken() == '' or PcdItemObj.GetDatumType() == '') and self.BinaryModule:
|
|
Logger.Error("\nMkPkg",
|
|
PARSER_ERROR,
|
|
ST.ERR_ASBUILD_PCD_DECLARITION_MISS % \
|
|
(PcdItemObj.GetTokenSpaceGuidCName() + '.' + PcdItemObj.GetCName()),
|
|
self.GetFullPath(), RaiseError=True)
|
|
Pcd.SetToken(PcdItemObj.GetToken())
|
|
Pcd.SetDatumType(PcdItemObj.GetDatumType())
|
|
Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())
|
|
Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
|
|
Pcd.SetOffset(PcdItemObj.GetOffset())
|
|
Pcd.SetItemType(PcdItem[0])
|
|
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
|
|
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
|
|
Pcd.SetValidUsage(PcdItemObj.GetValidUsage())
|
|
for CommentItem in PcdItemObj.GetHelpStringList():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(CommentItem.GetHelpStringItem())
|
|
Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])
|
|
AsBuildPatchPcdList.append(Pcd)
|
|
elif PcdItem[0].upper() == DT.TAB_INF_PCD_EX.upper():
|
|
PcdItemObj = PcdItem[1]
|
|
Pcd = CommonObject.PcdObject()
|
|
Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())
|
|
Pcd.SetToken(PcdItemObj.GetToken())
|
|
Pcd.SetDatumType(PcdItemObj.GetDatumType())
|
|
Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())
|
|
Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())
|
|
Pcd.SetItemType(PcdItem[0])
|
|
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())
|
|
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))
|
|
Pcd.SetValidUsage(PcdItemObj.GetValidUsage())
|
|
for CommentItem in PcdItemObj.GetHelpStringList():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(CommentItem.GetHelpStringItem())
|
|
Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])
|
|
AsBuildPcdExList.append(Pcd)
|
|
AsBuildIns.SetPatchPcdList(AsBuildPatchPcdList)
|
|
AsBuildIns.SetPcdExList(AsBuildPcdExList)
|
|
|
|
return AsBuildIns
|
|
|
|
## GenGuidProtocolPpis
|
|
#
|
|
# Gen Guids/Protocol/Ppis of INF
|
|
# <CName>=<GuidValue>
|
|
#
|
|
def _GenGuidProtocolPpis(self, Type):
|
|
Logger.Debug(2, "Generate %s ..." % Type)
|
|
#
|
|
# Get all Guid/Protocol/Ppis data
|
|
#
|
|
GuidObj = self.Parser.InfGuidSection.GetGuid()
|
|
ProtocolObj = self.Parser.InfProtocolSection.GetProtocol()
|
|
PpisObj = self.Parser.InfPpiSection.GetPpi()
|
|
|
|
GuidProtocolPpiList = []
|
|
|
|
if Type == DT.TAB_GUIDS:
|
|
GuidData = GuidObj.keys()
|
|
for Item in GuidData:
|
|
CommentList = Item.GetCommentList()
|
|
#
|
|
# Depend on CommentList content
|
|
# generate muti-guid-obj
|
|
#
|
|
if CommentList:
|
|
for GuidComentItem in CommentList:
|
|
ListObject = CommonObject.GuidObject()
|
|
ListObject.SetGuidTypeList([GuidComentItem.GetGuidTypeItem()])
|
|
ListObject.SetVariableName(GuidComentItem.GetVariableNameItem())
|
|
ListObject.SetUsage(GuidComentItem.GetUsageItem())
|
|
ListObject.SetName(Item.GetName())
|
|
ListObject.SetCName(Item.GetName())
|
|
ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
|
|
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
|
|
HelpString = GuidComentItem.GetHelpStringItem()
|
|
if HelpString.strip():
|
|
HelpTxtTailObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTxtTailObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTxtTailObj.SetString(HelpString)
|
|
ListObject.SetHelpTextList([HelpTxtTailObj])
|
|
|
|
GuidProtocolPpiList.append(ListObject)
|
|
elif Type == DT.TAB_PROTOCOLS:
|
|
ProtocolData = ProtocolObj.keys()
|
|
for Item in ProtocolData:
|
|
CommentList = Item.GetCommentList()
|
|
for CommentItem in CommentList:
|
|
ListObject = CommonObject.ProtocolObject()
|
|
ListObject.SetCName(Item.GetName())
|
|
ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
|
|
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
|
|
ListObject.SetNotify(CommentItem.GetNotify())
|
|
ListObject.SetUsage(CommentItem.GetUsageItem())
|
|
HelpString = CommentItem.GetHelpStringItem()
|
|
if HelpString.strip():
|
|
HelpTxtObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTxtObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTxtObj.SetString(HelpString)
|
|
ListObject.SetHelpTextList([HelpTxtObj])
|
|
GuidProtocolPpiList.append(ListObject)
|
|
elif Type == DT.TAB_PPIS:
|
|
PpiData = PpisObj.keys()
|
|
for Item in PpiData:
|
|
CommentList = Item.GetCommentList()
|
|
for CommentItem in CommentList:
|
|
ListObject = CommonObject.PpiObject()
|
|
ListObject.SetCName(Item.GetName())
|
|
ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))
|
|
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())
|
|
ListObject.SetNotify(CommentItem.GetNotify())
|
|
ListObject.SetUsage(CommentItem.GetUsage())
|
|
HelpString = CommentItem.GetHelpStringItem()
|
|
if HelpString.strip():
|
|
HelpTextObj = CommonObject.TextObject()
|
|
if self.UniFileClassObject:
|
|
HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)
|
|
HelpTextObj.SetString(HelpString)
|
|
ListObject.SetHelpTextList([HelpTextObj])
|
|
GuidProtocolPpiList.append(ListObject)
|
|
|
|
if Type == DT.TAB_GUIDS:
|
|
self.SetGuidList(self.GetGuidList() + GuidProtocolPpiList)
|
|
elif Type == DT.TAB_PROTOCOLS:
|
|
self.SetProtocolList(self.GetProtocolList() + GuidProtocolPpiList)
|
|
elif Type == DT.TAB_PPIS:
|
|
self.SetPpiList(self.GetPpiList() + GuidProtocolPpiList)
|
|
|
|
## GenMiscFiles
|
|
#
|
|
# Gen MiscellaneousFiles of Inf
|
|
#
|
|
# @param ContainerFile: The Inf file full path
|
|
#
|
|
def _GenMiscFiles(self, Content):
|
|
MiscFileObj = CommonObject.MiscFileObject()
|
|
for Line in Content.splitlines():
|
|
FileName = ''
|
|
if '#' in Line:
|
|
FileName = Line[:Line.find('#')]
|
|
else:
|
|
FileName = Line
|
|
if FileName:
|
|
if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):
|
|
FileObj = CommonObject.FileObject()
|
|
FileObj.SetURI(FileName)
|
|
MiscFileObj.SetFileList(MiscFileObj.GetFileList()+[FileObj])
|
|
else:
|
|
Logger.Error("InfParser",
|
|
FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Line),
|
|
File=GlobalData.gINF_MODULE_NAME,
|
|
ExtraData=Line)
|
|
self.SetMiscFileList(self.GetMiscFileList()+[MiscFileObj])
|
|
|