diff options
Diffstat (limited to 'src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py')
| -rwxr-xr-x | src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py | 1071 |
1 files changed, 1071 insertions, 0 deletions
diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py new file mode 100755 index 00000000..184c36c6 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/PomAdapter/InfPomAlignment.py @@ -0,0 +1,1071 @@ +## @file InfPomAlignment.py +# This file contained the adapter for convert INF parser object to POM Object +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR> +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +''' +InfPomAlignment +''' +## +# Import modules +# +import os.path +from Logger import StringTable as ST +import Logger.Log as Logger +from Library.StringUtils import FORMAT_INVALID +from Library.StringUtils import PARSER_ERROR +from Library.StringUtils import NormPath +from Library.StringUtils 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 = list(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() is not None: + __UefiVersion = DefineObj.GetUefiSpecificationVersion().GetValue() + __UefiVersion = ConvertVersionToDecimal(__UefiVersion) + self.SetUefiSpecificationVersion(str(__UefiVersion)) + if DefineObj.GetPiSpecificationVersion() is not 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() is 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() is 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() is 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() is 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() is 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() is not 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 formatted: + # [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 + # + for LibraryClassData in self.Parser.InfLibraryClassSection.LibraryClasses.values(): + 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 is not 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 = sorted(ConvertArchList(Item.GetSupArchList())) + 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]) + |