fb0b35e05f
Various typo in BaseTools. Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Coeur <coeur@gmx.fr> Reviewed-by: Liming Gao <liming.gao@intel.com>
1129 lines
45 KiB
Python
1129 lines
45 KiB
Python
## @file GenInfFile.py
|
|
#
|
|
# This file contained the logical of transfer package object to INF files.
|
|
#
|
|
# Copyright (c) 2011 - 2018, 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.
|
|
#
|
|
'''
|
|
GenInf
|
|
'''
|
|
import os
|
|
import stat
|
|
import codecs
|
|
from hashlib import md5
|
|
from Core.FileHook import __FileHookOpen__
|
|
from Library.StringUtils import GetSplitValueList
|
|
from Library.Parsing import GenSection
|
|
from Library.Parsing import GetWorkspacePackage
|
|
from Library.Parsing import ConvertArchForInstall
|
|
from Library.Misc import SaveFileOnChange
|
|
from Library.Misc import IsAllModuleList
|
|
from Library.Misc import Sdict
|
|
from Library.Misc import ConvertPath
|
|
from Library.Misc import ConvertSpec
|
|
from Library.Misc import GetRelativePath
|
|
from Library.Misc import GetLocalValue
|
|
from Library.CommentGenerating import GenHeaderCommentSection
|
|
from Library.CommentGenerating import GenGenericCommentF
|
|
from Library.CommentGenerating import _GetHelpStr
|
|
from Library import GlobalData
|
|
from Logger import StringTable as ST
|
|
from Logger import ToolError
|
|
import Logger.Log as Logger
|
|
from Library import DataType as DT
|
|
from GenMetaFile import GenMetaFileMisc
|
|
from Library.UniClassObject import FormatUniEntry
|
|
from Library.StringUtils import GetUniFileName
|
|
|
|
|
|
## Transfer Module Object to Inf files
|
|
#
|
|
# Transfer all contents of a standard Module Object to an Inf file
|
|
# @param ModuleObject: A Module Object
|
|
#
|
|
def ModuleToInf(ModuleObject, PackageObject=None, DistHeader=None):
|
|
if not GlobalData.gWSPKG_LIST:
|
|
GlobalData.gWSPKG_LIST = GetWorkspacePackage()
|
|
#
|
|
# Init global information for the file
|
|
#
|
|
ContainerFile = ModuleObject.GetFullPath()
|
|
|
|
Content = ''
|
|
#
|
|
# Generate file header, If any Abstract, Description, Copyright or License XML elements are missing,
|
|
# should 1) use the Abstract, Description, Copyright or License from the PackageSurfaceArea.Header elements
|
|
# that the module belongs to, or 2) if this is a stand-alone module that is not included in a PackageSurfaceArea,
|
|
# use the abstract, description, copyright or license from the DistributionPackage.Header elements.
|
|
#
|
|
ModuleAbstract = GetLocalValue(ModuleObject.GetAbstract())
|
|
if not ModuleAbstract and PackageObject:
|
|
ModuleAbstract = GetLocalValue(PackageObject.GetAbstract())
|
|
if not ModuleAbstract and DistHeader:
|
|
ModuleAbstract = GetLocalValue(DistHeader.GetAbstract())
|
|
ModuleDescription = GetLocalValue(ModuleObject.GetDescription())
|
|
if not ModuleDescription and PackageObject:
|
|
ModuleDescription = GetLocalValue(PackageObject.GetDescription())
|
|
if not ModuleDescription and DistHeader:
|
|
ModuleDescription = GetLocalValue(DistHeader.GetDescription())
|
|
ModuleCopyright = ''
|
|
for (Lang, Copyright) in ModuleObject.GetCopyright():
|
|
if Lang:
|
|
pass
|
|
ModuleCopyright = Copyright
|
|
if not ModuleCopyright and PackageObject:
|
|
for (Lang, Copyright) in PackageObject.GetCopyright():
|
|
if Lang:
|
|
pass
|
|
ModuleCopyright = Copyright
|
|
if not ModuleCopyright and DistHeader:
|
|
for (Lang, Copyright) in DistHeader.GetCopyright():
|
|
if Lang:
|
|
pass
|
|
ModuleCopyright = Copyright
|
|
ModuleLicense = ''
|
|
for (Lang, License) in ModuleObject.GetLicense():
|
|
if Lang:
|
|
pass
|
|
ModuleLicense = License
|
|
if not ModuleLicense and PackageObject:
|
|
for (Lang, License) in PackageObject.GetLicense():
|
|
if Lang:
|
|
pass
|
|
ModuleLicense = License
|
|
if not ModuleLicense and DistHeader:
|
|
for (Lang, License) in DistHeader.GetLicense():
|
|
if Lang:
|
|
pass
|
|
ModuleLicense = License
|
|
|
|
#
|
|
# Generate header comment section of INF file
|
|
#
|
|
Content += GenHeaderCommentSection(ModuleAbstract,
|
|
ModuleDescription,
|
|
ModuleCopyright,
|
|
ModuleLicense).replace('\r\n', '\n')
|
|
|
|
#
|
|
# Generate Binary Header
|
|
#
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID \
|
|
and UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:
|
|
ModuleBinaryAbstract = GetLocalValue(UserExtension.GetBinaryAbstract())
|
|
ModuleBinaryDescription = GetLocalValue(UserExtension.GetBinaryDescription())
|
|
ModuleBinaryCopyright = ''
|
|
ModuleBinaryLicense = ''
|
|
for (Lang, Copyright) in UserExtension.GetBinaryCopyright():
|
|
ModuleBinaryCopyright = Copyright
|
|
for (Lang, License) in UserExtension.GetBinaryLicense():
|
|
ModuleBinaryLicense = License
|
|
if ModuleBinaryAbstract and ModuleBinaryDescription and \
|
|
ModuleBinaryCopyright and ModuleBinaryLicense:
|
|
Content += GenHeaderCommentSection(ModuleBinaryAbstract,
|
|
ModuleBinaryDescription,
|
|
ModuleBinaryCopyright,
|
|
ModuleBinaryLicense,
|
|
True)
|
|
|
|
#
|
|
# Generate MODULE_UNI_FILE for module
|
|
#
|
|
FileHeader = GenHeaderCommentSection(ModuleAbstract, ModuleDescription, ModuleCopyright, ModuleLicense, False, \
|
|
DT.TAB_COMMENT_EDK1_SPLIT)
|
|
ModuleUniFile = GenModuleUNIEncodeFile(ModuleObject, FileHeader)
|
|
if ModuleUniFile:
|
|
ModuleObject.SetModuleUniFile(os.path.basename(ModuleUniFile))
|
|
|
|
#
|
|
# Judge whether the INF file is an AsBuild INF.
|
|
#
|
|
if ModuleObject.BinaryModule:
|
|
GlobalData.gIS_BINARY_INF = True
|
|
else:
|
|
GlobalData.gIS_BINARY_INF = False
|
|
#
|
|
# for each section, maintain a dict, sorted arch will be its key,
|
|
# statement list will be its data
|
|
# { 'Arch1 Arch2 Arch3': [statement1, statement2],
|
|
# 'Arch1' : [statement1, statement3]
|
|
# }
|
|
#
|
|
# Gen section contents
|
|
#
|
|
Content += GenDefines(ModuleObject)
|
|
Content += GenBuildOptions(ModuleObject)
|
|
Content += GenLibraryClasses(ModuleObject)
|
|
Content += GenPackages(ModuleObject)
|
|
Content += GenPcdSections(ModuleObject)
|
|
Content += GenSources(ModuleObject)
|
|
Content += GenProtocolPPiSections(ModuleObject.GetProtocolList(), True)
|
|
Content += GenProtocolPPiSections(ModuleObject.GetPpiList(), False)
|
|
Content += GenGuidSections(ModuleObject.GetGuidList())
|
|
Content += GenBinaries(ModuleObject)
|
|
Content += GenDepex(ModuleObject)
|
|
__UserExtensionsContent = GenUserExtensions(ModuleObject)
|
|
Content += __UserExtensionsContent
|
|
if ModuleObject.GetEventList() or ModuleObject.GetBootModeList() or ModuleObject.GetHobList():
|
|
Content += '\n'
|
|
#
|
|
# generate [Event], [BootMode], [Hob] section
|
|
#
|
|
Content += GenSpecialSections(ModuleObject.GetEventList(), 'Event', __UserExtensionsContent)
|
|
Content += GenSpecialSections(ModuleObject.GetBootModeList(), 'BootMode', __UserExtensionsContent)
|
|
Content += GenSpecialSections(ModuleObject.GetHobList(), 'Hob', __UserExtensionsContent)
|
|
SaveFileOnChange(ContainerFile, Content, False)
|
|
if DistHeader.ReadOnly:
|
|
os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)
|
|
else:
|
|
os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH|stat.S_IWUSR|stat.S_IWGRP|stat.S_IWOTH)
|
|
return ContainerFile
|
|
|
|
## GenModuleUNIEncodeFile
|
|
# GenModuleUNIEncodeFile, default is a UCS-2LE encode file
|
|
#
|
|
def GenModuleUNIEncodeFile(ModuleObject, UniFileHeader='', Encoding=DT.TAB_ENCODING_UTF16LE):
|
|
GenUNIFlag = False
|
|
OnlyLANGUAGE_EN_X = True
|
|
BinaryAbstract = []
|
|
BinaryDescription = []
|
|
#
|
|
# If more than one language code is used for any element that would be present in the MODULE_UNI_FILE,
|
|
# then the MODULE_UNI_FILE must be created.
|
|
#
|
|
for (Key, Value) in ModuleObject.GetAbstract() + ModuleObject.GetDescription():
|
|
if Key == DT.TAB_LANGUAGE_EN_X:
|
|
GenUNIFlag = True
|
|
else:
|
|
OnlyLANGUAGE_EN_X = False
|
|
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID \
|
|
and UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:
|
|
for (Key, Value) in UserExtension.GetBinaryAbstract():
|
|
if Key == DT.TAB_LANGUAGE_EN_X:
|
|
GenUNIFlag = True
|
|
else:
|
|
OnlyLANGUAGE_EN_X = False
|
|
BinaryAbstract.append((Key, Value))
|
|
for (Key, Value) in UserExtension.GetBinaryDescription():
|
|
if Key == DT.TAB_LANGUAGE_EN_X:
|
|
GenUNIFlag = True
|
|
else:
|
|
OnlyLANGUAGE_EN_X = False
|
|
BinaryDescription.append((Key, Value))
|
|
|
|
|
|
if not GenUNIFlag:
|
|
return
|
|
elif OnlyLANGUAGE_EN_X:
|
|
return
|
|
else:
|
|
ModuleObject.UNIFlag = True
|
|
ContainerFile = GetUniFileName(os.path.dirname(ModuleObject.GetFullPath()), ModuleObject.GetBaseName())
|
|
|
|
if not os.path.exists(os.path.dirname(ModuleObject.GetFullPath())):
|
|
os.makedirs(os.path.dirname(ModuleObject.GetFullPath()))
|
|
|
|
Content = UniFileHeader + '\r\n'
|
|
Content += '\r\n'
|
|
|
|
Content += FormatUniEntry('#string ' + DT.TAB_INF_ABSTRACT, ModuleObject.GetAbstract(), ContainerFile) + '\r\n'
|
|
|
|
Content += FormatUniEntry('#string ' + DT.TAB_INF_DESCRIPTION, ModuleObject.GetDescription(), ContainerFile) \
|
|
+ '\r\n'
|
|
|
|
BinaryAbstractString = FormatUniEntry('#string ' + DT.TAB_INF_BINARY_ABSTRACT, BinaryAbstract, ContainerFile)
|
|
if BinaryAbstractString:
|
|
Content += BinaryAbstractString + '\r\n'
|
|
|
|
BinaryDescriptionString = FormatUniEntry('#string ' + DT.TAB_INF_BINARY_DESCRIPTION, BinaryDescription, \
|
|
ContainerFile)
|
|
if BinaryDescriptionString:
|
|
Content += BinaryDescriptionString + '\r\n'
|
|
|
|
if not os.path.exists(ContainerFile):
|
|
File = codecs.open(ContainerFile, 'wb', Encoding)
|
|
File.write(u'\uFEFF' + Content)
|
|
File.stream.close()
|
|
Md5Signature = md5(__FileHookOpen__(str(ContainerFile), 'rb').read())
|
|
Md5Sum = Md5Signature.hexdigest()
|
|
if (ContainerFile, Md5Sum) not in ModuleObject.FileList:
|
|
ModuleObject.FileList.append((ContainerFile, Md5Sum))
|
|
|
|
return ContainerFile
|
|
def GenDefines(ModuleObject):
|
|
#
|
|
# generate [Defines] section
|
|
#
|
|
LeftOffset = 31
|
|
Content = ''
|
|
NewSectionDict = {}
|
|
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
DefinesDict = UserExtension.GetDefinesDict()
|
|
if not DefinesDict:
|
|
continue
|
|
for Statement in DefinesDict:
|
|
if len(Statement.split(DT.TAB_EQUAL_SPLIT)) > 1:
|
|
Statement = (u'%s ' % Statement.split(DT.TAB_EQUAL_SPLIT, 1)[0]).ljust(LeftOffset) \
|
|
+ u'= %s' % Statement.split(DT.TAB_EQUAL_SPLIT, 1)[1].lstrip()
|
|
SortedArch = DT.TAB_ARCH_COMMON
|
|
if Statement.strip().startswith(DT.TAB_INF_DEFINES_CUSTOM_MAKEFILE):
|
|
pos = Statement.find(DT.TAB_VALUE_SPLIT)
|
|
if pos == -1:
|
|
pos = Statement.find(DT.TAB_EQUAL_SPLIT)
|
|
Makefile = ConvertPath(Statement[pos + 1:].strip())
|
|
Statement = Statement[:pos + 1] + ' ' + Makefile
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]
|
|
else:
|
|
NewSectionDict[SortedArch] = [Statement]
|
|
SpecialStatementList = []
|
|
|
|
# TAB_INF_DEFINES_INF_VERSION
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_INF_VERSION).ljust(LeftOffset) + u'= %s' % '0x00010017'
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# BaseName
|
|
BaseName = ModuleObject.GetBaseName()
|
|
if BaseName.startswith('.') or BaseName.startswith('-'):
|
|
BaseName = '_' + BaseName
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_BASE_NAME).ljust(LeftOffset) + u'= %s' % BaseName
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_FILE_GUID
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_FILE_GUID).ljust(LeftOffset) + u'= %s' % ModuleObject.GetGuid()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_VERSION_STRING
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_VERSION_STRING).ljust(LeftOffset) + u'= %s' % ModuleObject.GetVersion()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_VERSION_STRING
|
|
if ModuleObject.UNIFlag:
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_MODULE_UNI_FILE).ljust(LeftOffset) + \
|
|
u'= %s' % ModuleObject.GetModuleUniFile()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_MODULE_TYPE
|
|
if ModuleObject.GetModuleType():
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_MODULE_TYPE).ljust(LeftOffset) + u'= %s' % ModuleObject.GetModuleType()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_PCD_IS_DRIVER
|
|
if ModuleObject.GetPcdIsDriver():
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_PCD_IS_DRIVER).ljust(LeftOffset) + \
|
|
u'= %s' % ModuleObject.GetPcdIsDriver()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION
|
|
if ModuleObject.GetUefiSpecificationVersion():
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION).ljust(LeftOffset) + \
|
|
u'= %s' % ModuleObject.GetUefiSpecificationVersion()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# TAB_INF_DEFINES_PI_SPECIFICATION_VERSION
|
|
if ModuleObject.GetPiSpecificationVersion():
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION).ljust(LeftOffset) + \
|
|
u'= %s' % ModuleObject.GetPiSpecificationVersion()
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# LibraryClass
|
|
for LibraryClass in ModuleObject.GetLibraryClassList():
|
|
if LibraryClass.GetUsage() == DT.USAGE_ITEM_PRODUCES or \
|
|
LibraryClass.GetUsage() == DT.USAGE_ITEM_SOMETIMES_PRODUCES:
|
|
Statement = (u'%s ' % DT.TAB_INF_DEFINES_LIBRARY_CLASS).ljust(LeftOffset) + \
|
|
u'= %s' % LibraryClass.GetLibraryClass()
|
|
if LibraryClass.GetSupModuleList():
|
|
Statement += '|' + DT.TAB_SPACE_SPLIT.join(l for l in LibraryClass.GetSupModuleList())
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# Spec Item
|
|
for SpecItem in ModuleObject.GetSpecList():
|
|
Spec, Version = SpecItem
|
|
Spec = ConvertSpec(Spec)
|
|
Statement = '%s %s = %s' % (DT.TAB_INF_DEFINES_SPEC, Spec, Version)
|
|
SpecialStatementList.append(Statement)
|
|
|
|
# Extern
|
|
ExternList = []
|
|
for Extern in ModuleObject.GetExternList():
|
|
ArchList = Extern.GetSupArchList()
|
|
EntryPoint = Extern.GetEntryPoint()
|
|
UnloadImage = Extern.GetUnloadImage()
|
|
Constructor = Extern.GetConstructor()
|
|
Destructor = Extern.GetDestructor()
|
|
HelpStringList = Extern.GetHelpTextList()
|
|
FFE = Extern.GetFeatureFlag()
|
|
ExternList.append([ArchList, EntryPoint, UnloadImage, Constructor, Destructor, FFE, HelpStringList])
|
|
#
|
|
# Add VALID_ARCHITECTURES information
|
|
#
|
|
ValidArchStatement = None
|
|
if ModuleObject.SupArchList:
|
|
ValidArchStatement = '\n' + '# ' + '\n'
|
|
ValidArchStatement += '# The following information is for reference only and not required by the build tools.\n'
|
|
ValidArchStatement += '# ' + '\n'
|
|
ValidArchStatement += '# VALID_ARCHITECTURES = %s' % (' '.join(ModuleObject.SupArchList)) + '\n'
|
|
ValidArchStatement += '# '
|
|
if DT.TAB_ARCH_COMMON not in NewSectionDict:
|
|
NewSectionDict[DT.TAB_ARCH_COMMON] = []
|
|
NewSectionDict[DT.TAB_ARCH_COMMON] = NewSectionDict[DT.TAB_ARCH_COMMON] + SpecialStatementList
|
|
GenMetaFileMisc.AddExternToDefineSec(NewSectionDict, DT.TAB_ARCH_COMMON, ExternList)
|
|
if ValidArchStatement is not None:
|
|
NewSectionDict[DT.TAB_ARCH_COMMON] = NewSectionDict[DT.TAB_ARCH_COMMON] + [ValidArchStatement]
|
|
Content += GenSection('Defines', NewSectionDict)
|
|
return Content
|
|
|
|
def GenLibraryClasses(ModuleObject):
|
|
#
|
|
# generate [LibraryClasses] section
|
|
#
|
|
Content = ''
|
|
NewSectionDict = {}
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
for LibraryClass in ModuleObject.GetLibraryClassList():
|
|
if LibraryClass.GetUsage() == DT.USAGE_ITEM_PRODUCES:
|
|
continue
|
|
#
|
|
# Generate generic comment
|
|
#
|
|
HelpTextList = LibraryClass.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
CommentStr = GenGenericCommentF(HelpStr)
|
|
Statement = CommentStr
|
|
Name = LibraryClass.GetLibraryClass()
|
|
FFE = LibraryClass.GetFeatureFlag()
|
|
Statement += Name
|
|
if FFE:
|
|
Statement += '|' + FFE
|
|
ModuleList = LibraryClass.GetSupModuleList()
|
|
ArchList = LibraryClass.GetSupArchList()
|
|
for Index in range(0, len(ArchList)):
|
|
ArchList[Index] = ConvertArchForInstall(ArchList[Index])
|
|
ArchList.sort()
|
|
SortedArch = ' '.join(ArchList)
|
|
KeyList = []
|
|
if not ModuleList or IsAllModuleList(ModuleList):
|
|
KeyList = [SortedArch]
|
|
else:
|
|
ModuleString = DT.TAB_VALUE_SPLIT.join(l for l in ModuleList)
|
|
if not ArchList:
|
|
SortedArch = DT.TAB_ARCH_COMMON
|
|
KeyList = [SortedArch + '.' + ModuleString]
|
|
else:
|
|
KeyList = [Arch + '.' + ModuleString for Arch in ArchList]
|
|
for Key in KeyList:
|
|
if Key in NewSectionDict:
|
|
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]
|
|
else:
|
|
NewSectionDict[Key] = [Statement]
|
|
Content += GenSection('LibraryClasses', NewSectionDict)
|
|
else:
|
|
LibraryClassDict = {}
|
|
for BinaryFile in ModuleObject.GetBinaryFileList():
|
|
if not BinaryFile.AsBuiltList:
|
|
continue
|
|
for LibraryItem in BinaryFile.AsBuiltList[0].LibraryInstancesList:
|
|
Statement = '# Guid: ' + LibraryItem.Guid + ' Version: ' + LibraryItem.Version
|
|
|
|
if len(BinaryFile.SupArchList) == 0:
|
|
if 'COMMON' in LibraryClassDict and Statement not in LibraryClassDict['COMMON']:
|
|
LibraryClassDict['COMMON'].append(Statement)
|
|
else:
|
|
LibraryClassDict['COMMON'] = ['## @LIB_INSTANCES']
|
|
LibraryClassDict['COMMON'].append(Statement)
|
|
else:
|
|
for Arch in BinaryFile.SupArchList:
|
|
if Arch in LibraryClassDict:
|
|
if Statement not in LibraryClassDict[Arch]:
|
|
LibraryClassDict[Arch].append(Statement)
|
|
else:
|
|
continue
|
|
else:
|
|
LibraryClassDict[Arch] = ['## @LIB_INSTANCES']
|
|
LibraryClassDict[Arch].append(Statement)
|
|
Content += GenSection('LibraryClasses', LibraryClassDict)
|
|
|
|
return Content
|
|
|
|
def GenPackages(ModuleObject):
|
|
Content = ''
|
|
#
|
|
# generate [Packages] section
|
|
#
|
|
NewSectionDict = Sdict()
|
|
WorkspaceDir = GlobalData.gWORKSPACE
|
|
for PackageDependency in ModuleObject.GetPackageDependencyList():
|
|
#
|
|
# Generate generic comment
|
|
#
|
|
CommentStr = ''
|
|
HelpText = PackageDependency.GetHelpText()
|
|
if HelpText:
|
|
HelpStr = HelpText.GetString()
|
|
CommentStr = GenGenericCommentF(HelpStr)
|
|
Statement = CommentStr
|
|
Guid = PackageDependency.GetGuid()
|
|
Version = PackageDependency.GetVersion()
|
|
FFE = PackageDependency.GetFeatureFlag()
|
|
Path = ''
|
|
#
|
|
# find package path/name
|
|
#
|
|
for PkgInfo in GlobalData.gWSPKG_LIST:
|
|
if Guid == PkgInfo[1]:
|
|
if (not Version) or (Version == PkgInfo[2]):
|
|
Path = PkgInfo[3]
|
|
break
|
|
#
|
|
# get relative path
|
|
#
|
|
RelaPath = GetRelativePath(Path, WorkspaceDir)
|
|
Statement += RelaPath.replace('\\', '/')
|
|
if FFE:
|
|
Statement += '|' + FFE
|
|
ArchList = sorted(PackageDependency.GetSupArchList())
|
|
SortedArch = ' '.join(ArchList)
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]
|
|
else:
|
|
NewSectionDict[SortedArch] = [Statement]
|
|
Content += GenSection('Packages', NewSectionDict)
|
|
return Content
|
|
|
|
def GenSources(ModuleObject):
|
|
#
|
|
# generate [Sources] section
|
|
#
|
|
Content = ''
|
|
NewSectionDict = {}
|
|
for Source in ModuleObject.GetSourceFileList():
|
|
SourceFile = Source.GetSourceFile()
|
|
Family = Source.GetFamily()
|
|
FeatureFlag = Source.GetFeatureFlag()
|
|
SupArchList = sorted(Source.GetSupArchList())
|
|
SortedArch = ' '.join(SupArchList)
|
|
Statement = GenSourceStatement(ConvertPath(SourceFile), Family, FeatureFlag)
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]
|
|
else:
|
|
NewSectionDict[SortedArch] = [Statement]
|
|
Content += GenSection('Sources', NewSectionDict)
|
|
|
|
return Content
|
|
|
|
def GenDepex(ModuleObject):
|
|
#
|
|
# generate [Depex] section
|
|
#
|
|
NewSectionDict = Sdict()
|
|
Content = ''
|
|
for Depex in ModuleObject.GetPeiDepex() + ModuleObject.GetDxeDepex() + ModuleObject.GetSmmDepex():
|
|
HelpTextList = Depex.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
CommentStr = GenGenericCommentF(HelpStr)
|
|
SupArchList = Depex.GetSupArchList()
|
|
SupModList = Depex.GetModuleType()
|
|
Expression = Depex.GetDepex()
|
|
Statement = CommentStr + Expression
|
|
SupArchList.sort()
|
|
KeyList = []
|
|
if not SupArchList:
|
|
SupArchList.append(DT.TAB_ARCH_COMMON.lower())
|
|
if not SupModList:
|
|
KeyList = SupArchList
|
|
else:
|
|
for ModuleType in SupModList:
|
|
for Arch in SupArchList:
|
|
KeyList.append(ConvertArchForInstall(Arch) + '.' + ModuleType)
|
|
for Key in KeyList:
|
|
if Key in NewSectionDict:
|
|
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]
|
|
else:
|
|
NewSectionDict[Key] = [Statement]
|
|
Content += GenSection('Depex', NewSectionDict, False)
|
|
|
|
return Content
|
|
## GenUserExtensions
|
|
#
|
|
# GenUserExtensions
|
|
#
|
|
def GenUserExtensions(ModuleObject):
|
|
NewSectionDict = {}
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID and \
|
|
UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:
|
|
continue
|
|
if UserExtension.GetIdentifier() == 'Depex':
|
|
continue
|
|
Statement = UserExtension.GetStatement()
|
|
# Comment the code to support user extension without any statement just the section header in []
|
|
# if not Statement:
|
|
# continue
|
|
ArchList = UserExtension.GetSupArchList()
|
|
for Index in range(0, len(ArchList)):
|
|
ArchList[Index] = ConvertArchForInstall(ArchList[Index])
|
|
ArchList.sort()
|
|
KeyList = []
|
|
CommonPreFix = ''
|
|
if UserExtension.GetUserID():
|
|
CommonPreFix = UserExtension.GetUserID()
|
|
if CommonPreFix.find('.') > -1:
|
|
CommonPreFix = '"' + CommonPreFix + '"'
|
|
if UserExtension.GetIdentifier():
|
|
CommonPreFix += '.' + '"' + UserExtension.GetIdentifier() + '"'
|
|
if ArchList:
|
|
KeyList = [CommonPreFix + '.' + Arch for Arch in ArchList]
|
|
else:
|
|
KeyList = [CommonPreFix]
|
|
for Key in KeyList:
|
|
if Key in NewSectionDict:
|
|
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]
|
|
else:
|
|
NewSectionDict[Key] = [Statement]
|
|
Content = GenSection('UserExtensions', NewSectionDict, False)
|
|
|
|
return Content
|
|
|
|
# GenSourceStatement
|
|
#
|
|
# @param SourceFile: string of source file path/name
|
|
# @param Family: string of source file family field
|
|
# @param FeatureFlag: string of source file FeatureFlag field
|
|
# @param TagName: string of source file TagName field
|
|
# @param ToolCode: string of source file ToolCode field
|
|
# @param HelpStr: string of source file HelpStr field
|
|
#
|
|
# @retval Statement: The generated statement for source
|
|
#
|
|
def GenSourceStatement(SourceFile, Family, FeatureFlag, TagName=None,
|
|
ToolCode=None, HelpStr=None):
|
|
Statement = ''
|
|
if HelpStr:
|
|
Statement += GenGenericCommentF(HelpStr)
|
|
#
|
|
# format of SourceFile|Family|TagName|ToolCode|FeatureFlag
|
|
#
|
|
Statement += SourceFile
|
|
if TagName is None:
|
|
TagName = ''
|
|
if ToolCode is None:
|
|
ToolCode = ''
|
|
if HelpStr is None:
|
|
HelpStr = ''
|
|
if FeatureFlag:
|
|
Statement += '|' + Family + '|' + TagName + '|' + ToolCode + '|' + FeatureFlag
|
|
elif ToolCode:
|
|
Statement += '|' + Family + '|' + TagName + '|' + ToolCode
|
|
elif TagName:
|
|
Statement += '|' + Family + '|' + TagName
|
|
elif Family:
|
|
Statement += '|' + Family
|
|
return Statement
|
|
|
|
# GenBinaryStatement
|
|
#
|
|
# @param Key: (FileName, FileType, FFE, SortedArch)
|
|
# @param Value: (Target, Family, TagName, Comment)
|
|
#
|
|
#
|
|
def GenBinaryStatement(Key, Value, SubTypeGuidValue=None):
|
|
(FileName, FileType, FFE, SortedArch) = Key
|
|
if SortedArch:
|
|
pass
|
|
if Value:
|
|
(Target, Family, TagName, Comment) = Value
|
|
else:
|
|
Target = ''
|
|
Family = ''
|
|
TagName = ''
|
|
Comment = ''
|
|
if Comment:
|
|
Statement = GenGenericCommentF(Comment)
|
|
else:
|
|
Statement = ''
|
|
if FileType == 'SUBTYPE_GUID' and SubTypeGuidValue:
|
|
Statement += FileType + '|' + SubTypeGuidValue + '|' + FileName
|
|
else:
|
|
Statement += FileType + '|' + FileName
|
|
if FileType in DT.BINARY_FILE_TYPE_UI_LIST + DT.BINARY_FILE_TYPE_VER_LIST:
|
|
if FFE:
|
|
Statement += '|' + Target + '|' + FFE
|
|
elif Target:
|
|
Statement += '|' + Target
|
|
else:
|
|
if FFE:
|
|
Statement += '|' + Target + '|' + Family + '|' + TagName + '|' + FFE
|
|
elif TagName:
|
|
Statement += '|' + Target + '|' + Family + '|' + TagName
|
|
elif Family:
|
|
Statement += '|' + Target + '|' + Family
|
|
elif Target:
|
|
Statement += '|' + Target
|
|
return Statement
|
|
## GenGuidSections
|
|
#
|
|
# @param GuidObjList: List of GuidObject
|
|
# @retVal Content: The generated section contents
|
|
#
|
|
def GenGuidSections(GuidObjList):
|
|
#
|
|
# generate [Guids] section
|
|
#
|
|
Content = ''
|
|
GuidDict = Sdict()
|
|
for Guid in GuidObjList:
|
|
HelpTextList = Guid.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
CName = Guid.GetCName()
|
|
FFE = Guid.GetFeatureFlag()
|
|
Statement = CName
|
|
if FFE:
|
|
Statement += '|' + FFE
|
|
Usage = Guid.GetUsage()
|
|
GuidType = Guid.GetGuidTypeList()[0]
|
|
VariableName = Guid.GetVariableName()
|
|
#
|
|
# Differentiate the generic comment and usage comment as multiple generic comment need to be put at first
|
|
#
|
|
if Usage == DT.ITEM_UNDEFINED and GuidType == DT.ITEM_UNDEFINED:
|
|
# generate list of generic comment
|
|
Comment = GenGenericCommentF(HelpStr)
|
|
else:
|
|
# generate list of other comment
|
|
Comment = HelpStr.replace('\n', ' ')
|
|
Comment = Comment.strip()
|
|
if Comment:
|
|
Comment = ' # ' + Comment
|
|
else:
|
|
Comment = ''
|
|
if Usage != DT.ITEM_UNDEFINED and GuidType == DT.ITEM_UNDEFINED:
|
|
Comment = '## ' + Usage + Comment
|
|
elif GuidType == 'Variable':
|
|
Comment = '## ' + Usage + ' ## ' + GuidType + ':' + VariableName + Comment
|
|
else:
|
|
Comment = '## ' + Usage + ' ## ' + GuidType + Comment
|
|
|
|
if Comment:
|
|
Comment += '\n'
|
|
#
|
|
# merge duplicate items
|
|
#
|
|
ArchList = sorted(Guid.GetSupArchList())
|
|
SortedArch = ' '.join(ArchList)
|
|
if (Statement, SortedArch) in GuidDict:
|
|
PreviousComment = GuidDict[Statement, SortedArch]
|
|
Comment = PreviousComment + Comment
|
|
GuidDict[Statement, SortedArch] = Comment
|
|
NewSectionDict = GenMetaFileMisc.TransferDict(GuidDict, 'INF_GUID')
|
|
#
|
|
# generate the section contents
|
|
#
|
|
if NewSectionDict:
|
|
Content = GenSection('Guids', NewSectionDict)
|
|
|
|
return Content
|
|
|
|
## GenProtocolPPiSections
|
|
#
|
|
# @param ObjList: List of ProtocolObject or Ppi Object
|
|
# @retVal Content: The generated section contents
|
|
#
|
|
def GenProtocolPPiSections(ObjList, IsProtocol):
|
|
Content = ''
|
|
Dict = Sdict()
|
|
for Object in ObjList:
|
|
HelpTextList = Object.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
CName = Object.GetCName()
|
|
FFE = Object.GetFeatureFlag()
|
|
Statement = CName
|
|
if FFE:
|
|
Statement += '|' + FFE
|
|
Usage = Object.GetUsage()
|
|
Notify = Object.GetNotify()
|
|
#
|
|
# Differentiate the generic comment and usage comment as consecutive generic comment need to be put together
|
|
#
|
|
if Usage == DT.ITEM_UNDEFINED and Notify == '':
|
|
# generate list of generic comment
|
|
Comment = GenGenericCommentF(HelpStr)
|
|
else:
|
|
# generate list of other comment
|
|
Comment = HelpStr.replace('\n', ' ')
|
|
Comment = Comment.strip()
|
|
if Comment:
|
|
Comment = ' # ' + Comment
|
|
else:
|
|
Comment = ''
|
|
if Usage == DT.ITEM_UNDEFINED and not Comment and Notify == '':
|
|
Comment = ''
|
|
else:
|
|
if Notify:
|
|
Comment = '## ' + Usage + ' ## ' + 'NOTIFY' + Comment
|
|
else:
|
|
Comment = '## ' + Usage + Comment
|
|
if Comment:
|
|
Comment += '\n'
|
|
#
|
|
# merge duplicate items
|
|
#
|
|
ArchList = sorted(Object.GetSupArchList())
|
|
SortedArch = ' '.join(ArchList)
|
|
if (Statement, SortedArch) in Dict:
|
|
PreviousComment = Dict[Statement, SortedArch]
|
|
Comment = PreviousComment + Comment
|
|
Dict[Statement, SortedArch] = Comment
|
|
NewSectionDict = GenMetaFileMisc.TransferDict(Dict, 'INF_PPI_PROTOCOL')
|
|
#
|
|
# generate the section contents
|
|
#
|
|
if NewSectionDict:
|
|
if IsProtocol:
|
|
Content = GenSection('Protocols', NewSectionDict)
|
|
else:
|
|
Content = GenSection('Ppis', NewSectionDict)
|
|
|
|
return Content
|
|
|
|
## GenPcdSections
|
|
#
|
|
#
|
|
def GenPcdSections(ModuleObject):
|
|
Content = ''
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
#
|
|
# for each Pcd Itemtype, maintain a dict so the same type will be grouped
|
|
# together
|
|
#
|
|
ItemTypeDict = {}
|
|
for Pcd in ModuleObject.GetPcdList():
|
|
HelpTextList = Pcd.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
Statement = ''
|
|
CName = Pcd.GetCName()
|
|
TokenSpaceGuidCName = Pcd.GetTokenSpaceGuidCName()
|
|
DefaultValue = Pcd.GetDefaultValue()
|
|
ItemType = Pcd.GetItemType()
|
|
if ItemType in ItemTypeDict:
|
|
Dict = ItemTypeDict[ItemType]
|
|
else:
|
|
Dict = Sdict()
|
|
ItemTypeDict[ItemType] = Dict
|
|
FFE = Pcd.GetFeatureFlag()
|
|
Statement += TokenSpaceGuidCName + '.' + CName
|
|
if DefaultValue:
|
|
Statement += '|' + DefaultValue
|
|
if FFE:
|
|
Statement += '|' + FFE
|
|
elif FFE:
|
|
Statement += '||' + FFE
|
|
#
|
|
# Generate comment
|
|
#
|
|
Usage = Pcd.GetValidUsage()
|
|
# if FeatureFlag Pcd, then assume all Usage is CONSUMES
|
|
if ItemType == DT.TAB_INF_FEATURE_PCD:
|
|
Usage = DT.USAGE_ITEM_CONSUMES
|
|
if Usage == DT.ITEM_UNDEFINED:
|
|
# generate list of generic comment
|
|
Comment = GenGenericCommentF(HelpStr)
|
|
else:
|
|
# generate list of other comment
|
|
Comment = HelpStr.replace('\n', ' ')
|
|
Comment = Comment.strip()
|
|
if Comment:
|
|
Comment = ' # ' + Comment
|
|
else:
|
|
Comment = ''
|
|
Comment = '## ' + Usage + Comment
|
|
if Comment:
|
|
Comment += '\n'
|
|
#
|
|
# Merge duplicate entries
|
|
#
|
|
ArchList = sorted(Pcd.GetSupArchList())
|
|
SortedArch = ' '.join(ArchList)
|
|
if (Statement, SortedArch) in Dict:
|
|
PreviousComment = Dict[Statement, SortedArch]
|
|
Comment = PreviousComment + Comment
|
|
Dict[Statement, SortedArch] = Comment
|
|
for ItemType in ItemTypeDict:
|
|
# First we need to transfer the Dict to use SortedArch as key
|
|
Dict = ItemTypeDict[ItemType]
|
|
NewSectionDict = GenMetaFileMisc.TransferDict(Dict, 'INF_PCD')
|
|
if NewSectionDict:
|
|
Content += GenSection(ItemType, NewSectionDict)
|
|
#
|
|
# For AsBuild INF files
|
|
#
|
|
else:
|
|
Content += GenAsBuiltPacthPcdSections(ModuleObject)
|
|
Content += GenAsBuiltPcdExSections(ModuleObject)
|
|
|
|
return Content
|
|
|
|
## GenPcdSections
|
|
#
|
|
#
|
|
def GenAsBuiltPacthPcdSections(ModuleObject):
|
|
PatchPcdDict = {}
|
|
for BinaryFile in ModuleObject.GetBinaryFileList():
|
|
if not BinaryFile.AsBuiltList:
|
|
continue
|
|
for PatchPcd in BinaryFile.AsBuiltList[0].PatchPcdList:
|
|
TokenSpaceName = ''
|
|
PcdCName = PatchPcd.CName
|
|
PcdValue = PatchPcd.DefaultValue
|
|
PcdOffset = PatchPcd.Offset
|
|
TokenSpaceGuidValue = PatchPcd.TokenSpaceGuidValue
|
|
Token = PatchPcd.Token
|
|
HelpTextList = PatchPcd.HelpTextList
|
|
HelpString = ''
|
|
for HelpStringItem in HelpTextList:
|
|
for HelpLine in GetSplitValueList(HelpStringItem.String, '\n'):
|
|
HelpString += '## ' + HelpLine + '\n'
|
|
TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList,
|
|
TokenSpaceGuidValue,
|
|
Token)
|
|
if TokenSpaceName == '' or PcdCName == '':
|
|
Logger.Error("Upt",
|
|
ToolError.RESOURCE_NOT_AVAILABLE,
|
|
ST.ERR_INSTALL_FILE_DEC_FILE_ERROR % (TokenSpaceGuidValue, Token),
|
|
File=ModuleObject.GetFullPath())
|
|
Statement = HelpString + TokenSpaceName + '.' + PcdCName + ' | ' + PcdValue + ' | ' + \
|
|
PcdOffset + DT.TAB_SPACE_SPLIT
|
|
#
|
|
# Use binary file's Arch to be Pcd's Arch
|
|
#
|
|
ArchList = []
|
|
FileNameObjList = BinaryFile.GetFileNameList()
|
|
if FileNameObjList:
|
|
ArchList = FileNameObjList[0].GetSupArchList()
|
|
if len(ArchList) == 0:
|
|
if DT.TAB_ARCH_COMMON in PatchPcdDict:
|
|
if Statement not in PatchPcdDict[DT.TAB_ARCH_COMMON]:
|
|
PatchPcdDict[DT.TAB_ARCH_COMMON].append(Statement)
|
|
else:
|
|
PatchPcdDict[DT.TAB_ARCH_COMMON] = [Statement]
|
|
else:
|
|
for Arch in ArchList:
|
|
if Arch in PatchPcdDict:
|
|
if Statement not in PatchPcdDict[Arch]:
|
|
PatchPcdDict[Arch].append(Statement)
|
|
else:
|
|
PatchPcdDict[Arch] = [Statement]
|
|
return GenSection(DT.TAB_INF_PATCH_PCD, PatchPcdDict)
|
|
## GenPcdSections
|
|
#
|
|
#
|
|
def GenAsBuiltPcdExSections(ModuleObject):
|
|
PcdExDict = {}
|
|
for BinaryFile in ModuleObject.GetBinaryFileList():
|
|
if not BinaryFile.AsBuiltList:
|
|
continue
|
|
for PcdExItem in BinaryFile.AsBuiltList[0].PcdExValueList:
|
|
TokenSpaceName = ''
|
|
PcdCName = PcdExItem.CName
|
|
TokenSpaceGuidValue = PcdExItem.TokenSpaceGuidValue
|
|
Token = PcdExItem.Token
|
|
HelpTextList = PcdExItem.HelpTextList
|
|
HelpString = ''
|
|
for HelpStringItem in HelpTextList:
|
|
for HelpLine in GetSplitValueList(HelpStringItem.String, '\n'):
|
|
HelpString += '## ' + HelpLine + '\n'
|
|
TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList,
|
|
TokenSpaceGuidValue, Token)
|
|
if TokenSpaceName == '' or PcdCName == '':
|
|
Logger.Error("Upt",
|
|
ToolError.RESOURCE_NOT_AVAILABLE,
|
|
ST.ERR_INSTALL_FILE_DEC_FILE_ERROR % (TokenSpaceGuidValue, Token),
|
|
File=ModuleObject.GetFullPath())
|
|
|
|
Statement = HelpString + TokenSpaceName + DT.TAB_SPLIT + PcdCName + DT.TAB_SPACE_SPLIT
|
|
|
|
#
|
|
# Use binary file's Arch to be Pcd's Arch
|
|
#
|
|
ArchList = []
|
|
FileNameObjList = BinaryFile.GetFileNameList()
|
|
if FileNameObjList:
|
|
ArchList = FileNameObjList[0].GetSupArchList()
|
|
|
|
if len(ArchList) == 0:
|
|
if 'COMMON' in PcdExDict:
|
|
PcdExDict['COMMON'].append(Statement)
|
|
else:
|
|
PcdExDict['COMMON'] = [Statement]
|
|
else:
|
|
for Arch in ArchList:
|
|
if Arch in PcdExDict:
|
|
if Statement not in PcdExDict[Arch]:
|
|
PcdExDict[Arch].append(Statement)
|
|
else:
|
|
PcdExDict[Arch] = [Statement]
|
|
return GenSection('PcdEx', PcdExDict)
|
|
|
|
## GenSpecialSections
|
|
# generate special sections for Event/BootMode/Hob
|
|
#
|
|
def GenSpecialSections(ObjectList, SectionName, UserExtensionsContent=''):
|
|
#
|
|
# generate section
|
|
#
|
|
Content = ''
|
|
NewSectionDict = {}
|
|
for Obj in ObjectList:
|
|
#
|
|
# Generate comment
|
|
#
|
|
CommentStr = ''
|
|
HelpTextList = Obj.GetHelpTextList()
|
|
HelpStr = _GetHelpStr(HelpTextList)
|
|
CommentStr = GenGenericCommentF(HelpStr)
|
|
if SectionName == 'Hob':
|
|
Type = Obj.GetHobType()
|
|
elif SectionName == 'Event':
|
|
Type = Obj.GetEventType()
|
|
elif SectionName == 'BootMode':
|
|
Type = Obj.GetSupportedBootModes()
|
|
else:
|
|
assert(SectionName)
|
|
Usage = Obj.GetUsage()
|
|
|
|
# If the content already in UserExtensionsContent then ignore
|
|
if '[%s]' % SectionName in UserExtensionsContent and Type in UserExtensionsContent:
|
|
return ''
|
|
|
|
Statement = ' ' + Type + ' ## ' + Usage
|
|
if CommentStr in ['#\n', '#\n#\n']:
|
|
CommentStr = '#\n#\n#\n'
|
|
#
|
|
# the first head comment line should start with '##\n', if it starts with '#\n', then add one '#'
|
|
# else add '##\n' to meet the format defined in INF spec
|
|
#
|
|
if CommentStr.startswith('#\n'):
|
|
CommentStr = '#' + CommentStr
|
|
elif CommentStr:
|
|
CommentStr = '##\n' + CommentStr
|
|
if CommentStr and not CommentStr.endswith('\n#\n'):
|
|
CommentStr = CommentStr + '#\n'
|
|
NewStateMent = CommentStr + Statement
|
|
SupArch = sorted(Obj.GetSupArchList())
|
|
SortedArch = ' '.join(SupArch)
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [NewStateMent]
|
|
else:
|
|
NewSectionDict[SortedArch] = [NewStateMent]
|
|
SectionContent = GenSection(SectionName, NewSectionDict)
|
|
SectionContent = SectionContent.strip()
|
|
if SectionContent:
|
|
Content = '# ' + ('\n' + '# ').join(GetSplitValueList(SectionContent, '\n'))
|
|
Content = Content.lstrip()
|
|
#
|
|
# add a return to differentiate it between other possible sections
|
|
#
|
|
if Content:
|
|
Content += '\n'
|
|
return Content
|
|
## GenBuildOptions
|
|
#
|
|
#
|
|
def GenBuildOptions(ModuleObject):
|
|
Content = ''
|
|
if not ModuleObject.BinaryModule:
|
|
#
|
|
# generate [BuildOptions] section
|
|
#
|
|
NewSectionDict = {}
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
BuildOptionDict = UserExtension.GetBuildOptionDict()
|
|
if not BuildOptionDict:
|
|
continue
|
|
for Arch in BuildOptionDict:
|
|
if Arch in NewSectionDict:
|
|
NewSectionDict[Arch] = NewSectionDict[Arch] + [BuildOptionDict[Arch]]
|
|
else:
|
|
NewSectionDict[Arch] = [BuildOptionDict[Arch]]
|
|
Content = GenSection('BuildOptions', NewSectionDict)
|
|
else:
|
|
BuildOptionDict = {}
|
|
for BinaryFile in ModuleObject.GetBinaryFileList():
|
|
if not BinaryFile.AsBuiltList:
|
|
continue
|
|
for BuilOptionItem in BinaryFile.AsBuiltList[0].BinaryBuildFlagList:
|
|
Statement = '#' + BuilOptionItem.AsBuiltOptionFlags
|
|
if len(BinaryFile.SupArchList) == 0:
|
|
if 'COMMON' in BuildOptionDict:
|
|
if Statement not in BuildOptionDict['COMMON']:
|
|
BuildOptionDict['COMMON'].append(Statement)
|
|
else:
|
|
BuildOptionDict['COMMON'] = ['## @AsBuilt']
|
|
BuildOptionDict['COMMON'].append(Statement)
|
|
else:
|
|
for Arch in BinaryFile.SupArchList:
|
|
if Arch in BuildOptionDict:
|
|
if Statement not in BuildOptionDict[Arch]:
|
|
BuildOptionDict[Arch].append(Statement)
|
|
else:
|
|
BuildOptionDict[Arch] = ['## @AsBuilt']
|
|
BuildOptionDict[Arch].append(Statement)
|
|
Content = GenSection('BuildOptions', BuildOptionDict)
|
|
|
|
return Content
|
|
## GenBinaries
|
|
#
|
|
#
|
|
def GenBinaries(ModuleObject):
|
|
NewSectionDict = {}
|
|
BinariesDict = []
|
|
for UserExtension in ModuleObject.GetUserExtensionList():
|
|
BinariesDict = UserExtension.GetBinariesDict()
|
|
if BinariesDict:
|
|
break
|
|
for BinaryFile in ModuleObject.GetBinaryFileList():
|
|
FileNameObjList = BinaryFile.GetFileNameList()
|
|
for FileNameObj in FileNameObjList:
|
|
FileName = ConvertPath(FileNameObj.GetFilename())
|
|
FileType = FileNameObj.GetFileType()
|
|
FFE = FileNameObj.GetFeatureFlag()
|
|
ArchList = sorted(FileNameObj.GetSupArchList())
|
|
SortedArch = ' '.join(ArchList)
|
|
Key = (FileName, FileType, FFE, SortedArch)
|
|
if Key in BinariesDict:
|
|
ValueList = BinariesDict[Key]
|
|
for ValueItem in ValueList:
|
|
Statement = GenBinaryStatement(Key, ValueItem)
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]
|
|
else:
|
|
NewSectionDict[SortedArch] = [Statement]
|
|
#
|
|
# as we already generated statement for this DictKey here set the Valuelist to be empty
|
|
# to avoid generate duplicate entries as the DictKey may have multiple entries
|
|
#
|
|
BinariesDict[Key] = []
|
|
else:
|
|
if FileType == 'SUBTYPE_GUID' and FileNameObj.GetGuidValue():
|
|
Statement = GenBinaryStatement(Key, None, FileNameObj.GetGuidValue())
|
|
else:
|
|
Statement = GenBinaryStatement(Key, None)
|
|
if SortedArch in NewSectionDict:
|
|
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]
|
|
else:
|
|
NewSectionDict[SortedArch] = [Statement]
|
|
Content = GenSection('Binaries', NewSectionDict)
|
|
|
|
return Content
|