Check In tool source code based on Build tool project revision r1655.
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lgao4
765
BaseTools/Source/Python/fpd2dsc/StoreDsc.py
Normal file
765
BaseTools/Source/Python/fpd2dsc/StoreDsc.py
Normal file
@ -0,0 +1,765 @@
|
||||
## @file
|
||||
# Store a Platform class object to an INF file.
|
||||
#
|
||||
# Copyright (c) 2007 - 2009, Intel Corporation
|
||||
# All rights reserved. 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.
|
||||
#
|
||||
|
||||
##
|
||||
# Import Modules
|
||||
#
|
||||
from LoadFpd import LoadFpd
|
||||
from CommonDataClass.PlatformClass import *
|
||||
from CommonDataClass.FdfClass import *
|
||||
from Common.MigrationUtilities import *
|
||||
from Common.ToolDefClassObject import *
|
||||
from Common.TargetTxtClassObject import *
|
||||
|
||||
## Store Defines section
|
||||
#
|
||||
# Write [Defines] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Defines section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformDefinesSection(DscFile, Platform):
|
||||
PlatformHeader = Platform.Header
|
||||
|
||||
DefinesTupleList = []
|
||||
|
||||
if PlatformHeader.Name != "":
|
||||
DefinesTupleList.append(("PLATFORM_NAME", PlatformHeader.Name))
|
||||
|
||||
if PlatformHeader.Guid != "":
|
||||
DefinesTupleList.append(("PLATFORM_GUID", PlatformHeader.Guid))
|
||||
|
||||
if PlatformHeader.Version != "":
|
||||
DefinesTupleList.append(("PLATFORM_VERSION", PlatformHeader.Version))
|
||||
for key in PlatformHeader.Specification.keys():
|
||||
SpecificationValue = PlatformHeader.Specification.get(key)
|
||||
DefinesTupleList.append(("DSC_ SPECIFICATION", SpecificationValue))
|
||||
|
||||
if PlatformHeader.OutputDirectory != "":
|
||||
DefinesTupleList.append(("OUTPUT_DIRECTORY", PlatformHeader.OutputDirectory))
|
||||
|
||||
if PlatformHeader.SupArchList != "":
|
||||
String = "|".join(PlatformHeader.SupArchList)
|
||||
DefinesTupleList.append(("SUPPORTED_ARCHITECTURES", String))
|
||||
|
||||
if PlatformHeader.BuildTargets != "":
|
||||
String = "|".join(PlatformHeader.BuildTargets)
|
||||
DefinesTupleList.append(("BUILD_TARGETS", String))
|
||||
|
||||
if PlatformHeader.SkuIdName != "":
|
||||
#DefinesTupleList.append(("SKUID_IDENTIFIER", PlatformHeader.SkuIdName))
|
||||
String = "|".join(PlatformHeader.SkuIdName)
|
||||
if String != "":
|
||||
DefinesTupleList.append(("SKUID_IDENTIFIER", String))
|
||||
|
||||
String = Platform.FlashDefinitionFile.FilePath
|
||||
if String != "":
|
||||
DefinesTupleList.append(("FLASH_DEFINITION", String))
|
||||
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Defines Section - statements that will be processed to create a Makefile.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
Section = "\n".join(List)
|
||||
Section += "\n"
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
StoreDefinesSection(DscFile, DefinesTupleList)
|
||||
|
||||
## Store SkuIds section
|
||||
#
|
||||
# Write [SkuIds] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Library Classes section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformSkuIdsSection(DscFile, Platform):
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# SKU Identification section - list of all SKU IDs supported by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
Section = "\n".join(List)
|
||||
Section += "\n"
|
||||
|
||||
Section += "[SkuIds]" + '\n'
|
||||
|
||||
List = Platform.SkuInfos.SkuInfoList
|
||||
for Item in List:
|
||||
Section = Section + "%s" % Item[0] + '|' + "%s" % Item[1] + '\n'
|
||||
Section = Section + '\n'
|
||||
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Store Build Options section
|
||||
#
|
||||
# Write [BuildOptions] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Build Options section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformBuildOptionsSection(DscFile, Platform):
|
||||
# which is from tools_def.txt
|
||||
StandardBuildTargets = ["DEBUG", "RELEASE"]
|
||||
SupportedArches = ["COMMON", "IA32", "X64", "IPF", "EBC", "ARM"]
|
||||
Target = TargetTxtClassObject()
|
||||
WorkSpace = os.getenv('WORKSPACE')
|
||||
Target.LoadTargetTxtFile(WorkSpace + '\\Conf\\target.txt')
|
||||
ToolDef = ToolDefClassObject()
|
||||
ToolDef.LoadToolDefFile(WorkSpace + '\\' + Target.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF])
|
||||
# Now we have got ToolDef object
|
||||
#ToolDef.ToolsDefTxtDictionary
|
||||
Dict = ToolDef.ToolsDefTxtDatabase
|
||||
|
||||
Dict1 = ToolDef.ToolsDefTxtDictionary # we care the info in this Dict
|
||||
#
|
||||
# We only support *(DEBUG/RELEASE) and *(All Arch: IA32, X64, IPF and EBC) for now
|
||||
#
|
||||
SectionWINDDK = ''
|
||||
SectionVS2003 = ''
|
||||
SectionVS2005EXP = ''
|
||||
SectionVS2005STD = ''
|
||||
SectionVS2005PRO = ''
|
||||
SectionVS2005TEAMSUITE = ''
|
||||
SectionUNIXGCC = ''
|
||||
SectionCYGWINGCC = ''
|
||||
SectionELFGCC = ''
|
||||
SectionICC = ''
|
||||
SectionMYTOOLS = ''
|
||||
for key in Dict1.keys():
|
||||
if key.find("_CC_FLAGS") != -1:
|
||||
if key.find('WINDDK3790x1830') != -1:
|
||||
SectionWINDDK = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('VS2003') != -1:
|
||||
SectionVS2003 = " = " + Dict1.get(key)+ "\n"
|
||||
elif key.find('VS2005EXP') != -1:
|
||||
SectionVS2005EXP = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('VS2005STD') != -1:
|
||||
SectionVS2005STD = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('VS2005PRO') != -1:
|
||||
SectionVS2005PRO = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('VS2005TEAMSUITE') != -1:
|
||||
SectionVS2005TEAMSUITE = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('UNIXGCC') != -1:
|
||||
SectionUNIXGCC = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('CYGWINGCC') != -1:
|
||||
SectionCYGWINGCC = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('ELFGCC') != -1:
|
||||
SectionELFGCC = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('ICC') != -1:
|
||||
SectionICC = " = " + Dict1.get(key) + "\n"
|
||||
elif key.find('MYTOOLS') != -1:
|
||||
SectionMYTOOLS = " = " + Dict1.get(key) + "\n"
|
||||
else:
|
||||
print "Error!"
|
||||
|
||||
#
|
||||
# First need to check which arch
|
||||
#
|
||||
Archs = Platform.Header.SupArchList
|
||||
BuildTargets = Platform.Header.BuildTargets
|
||||
#if BuildTargets == StandardBuildTargets:
|
||||
#print "Debug and Release both support" # skip debug/release string search
|
||||
#else:
|
||||
#print "need to search debug/release string"
|
||||
|
||||
if len(Archs) == 4:
|
||||
Arch = "*"
|
||||
SectionName = "[BuildOptions.Common]\n"
|
||||
else:
|
||||
for Arch in Archs:
|
||||
if Arch == 'IA32':
|
||||
SectionName = "[BuildOptions.IA32]\n"
|
||||
elif Arch == 'X64':
|
||||
SectionName = "[BuildOptions.X64]\n"
|
||||
elif Arch == 'IPF':
|
||||
SectionName = "[BuildOptions.IPF]\n"
|
||||
elif Arch == 'EBC':
|
||||
SectionName = "[BuildOptions.EBC]\n"
|
||||
else:
|
||||
print 'Error!'
|
||||
Section = ""
|
||||
if SectionWINDDK != "":
|
||||
SectionWINDDK = "*_WINDDK3790x1830_" + Arch + "_CC_FLAGS" + SectionWINDDK
|
||||
Section += SectionWINDDK
|
||||
if SectionVS2003 != "":
|
||||
SectionVS2003 = "*_VS2003_" + Arch + "_CC_FLAGS" + SectionVS2003
|
||||
Section += SectionVS2003
|
||||
if SectionVS2005EXP != "":
|
||||
SectionVS2005EXP = "*_VS2005EXP_" + Arch + "_CC_FLAGS" + SectionVS2005EXP
|
||||
Section += SectionVS2005EXP
|
||||
if SectionVS2005STD != "":
|
||||
SectionVS2005STD = "*_VS2005STD_" + Arch + "_CC_FLAGS" + SectionVS2005STD
|
||||
Section += SectionVS2005STD
|
||||
if SectionVS2005PRO != "":
|
||||
SectionVS2005PRO = "*_VS2005PRO_" + Arch + "_CC_FLAGS" + SectionVS2005PRO
|
||||
Section += SectionVS2005PRO
|
||||
if SectionVS2005TEAMSUITE != "":
|
||||
SectionVS2005TEAMSUITE = "*_VS2005TEAMSUITE_" + Arch + "_CC_FLAGS" + SectionVS2005TEAMSUITE
|
||||
Section += SectionVS2005TEAMSUITE
|
||||
if SectionUNIXGCC != "":
|
||||
SectionUNIXGCC = "*_UNIXGCC_" + Arch + "_CC_FLAGS" + SectionUNIXGCC
|
||||
Section += SectionUNIXGCC
|
||||
if SectionCYGWINGCC != "":
|
||||
SectionCYGWINGCC = "*_CYGWINGCC_" + Arch + "_CC_FLAGS" + SectionCYGWINGCC
|
||||
Section += SectionCYGWINGCC
|
||||
if SectionELFGCC != "":
|
||||
SectionELFGCC = "*_ELFGCC_" + Arch + "_CC_FLAGS" + SectionELFGCC
|
||||
Section += SectionELFGCC
|
||||
if SectionICC != "":
|
||||
SectionICC = "*_ICC_" + Arch + "_CC_FLAGS" + SectionICC
|
||||
Section += SectionICC
|
||||
if SectionMYTOOLS != "":
|
||||
SectionMYTOOLS = "*_MYTOOLS_" + Arch + "_CC_FLAGS" + SectionMYTOOLS
|
||||
Section += SectionMYTOOLS
|
||||
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Build Options section - list of all Build Options supported by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
|
||||
Section = SectionHeader + SectionName + Section
|
||||
Section += "\n"
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Store Libraries section
|
||||
#
|
||||
# Write [Libraries] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Library Classes section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformLibrariesSection(DscFile,Platform):
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Libraries section - list of all Libraries needed by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
|
||||
Section = SectionHeader + '[Libraries]\n\n'
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Return a Platform Library Class Item
|
||||
#
|
||||
# Read the input LibraryClass class object and return one line of Library Class Item.
|
||||
#
|
||||
# @param LibraryClass An input LibraryClass class object
|
||||
#
|
||||
# @retval LibraryClassItem A Module Library Class Item
|
||||
#
|
||||
def GetPlatformLibraryClassItem(LibraryClass):
|
||||
LibraryClassList = []
|
||||
LibraryClassList.append(LibraryClass.Name)
|
||||
LibraryClassList.append(LibraryClass.FilePath)
|
||||
|
||||
return "|$(WORKSPACE)/".join(LibraryClassList).rstrip("|")
|
||||
|
||||
## Add item to a LibraryClass section
|
||||
#
|
||||
# Add an Item with specific Module Type to section dictionary.
|
||||
# The possible duplication is ensured to be removed.
|
||||
#
|
||||
# @param Section Section dictionary indexed by CPU architecture
|
||||
# @param SupModuleList LibraryClass SupModuleList: BASE, SEC, PEI_CORE, PEIM, etc
|
||||
# @param Item The Item to be added to section dictionary
|
||||
#
|
||||
def AddToLibraryClassSection(Section, SupModuleList, Item):
|
||||
for ModuleType in SupModuleList:
|
||||
SectionModule = Section.get(ModuleType, [])
|
||||
if Item not in SectionModule:
|
||||
SectionModule.append(Item)
|
||||
Section[ModuleType] = SectionModule
|
||||
|
||||
## Get Library Classes section contents
|
||||
#
|
||||
# Return the content of section named SectionName.
|
||||
# the contents is based on Methods and ObjectLists.
|
||||
#
|
||||
# @param SectionName The name of the section
|
||||
# @param Method A function returning a string item of an object
|
||||
# @param ObjectList The list of object
|
||||
#
|
||||
# @retval Section The string content of a section
|
||||
#
|
||||
def GetLibraryClassesSection(SectionName, Method, ObjectList):
|
||||
SupportedArches = ["COMMON", "IA32", "X64", "IPF", "EBC"]
|
||||
ModuleTypes = ["BASE","SEC","PEI_CORE","PEIM","DXE_CORE","DXE_DRIVER","DXE_SMM_DRIVER","DXE_SAL_DRIVER","DXE_RUNTIME_DRIVER","UEFI_DRIVER","UEFI_APPLICATION"]
|
||||
SectionCommonDict = {}
|
||||
SectionIA32Dict = {}
|
||||
SectionX64Dict = {}
|
||||
SectionIPFDict = {}
|
||||
SectionEBCDict = {}
|
||||
#ObjectList = list(set(ObjectList)) # delete the same element in the list
|
||||
for Object in ObjectList:
|
||||
if Object == None:
|
||||
continue
|
||||
Item = Method(Object)
|
||||
if Item == "":
|
||||
continue
|
||||
Item = " %s" % Item
|
||||
Arches = Object.SupArchList
|
||||
if len(Arches) == 4:
|
||||
ModuleType = Object.ModuleType
|
||||
# [LibraryClasses.Common.ModuleType]
|
||||
if ModuleType == "BASE":
|
||||
SupModuleList = ["BASE"]
|
||||
AddToLibraryClassSection(SectionCommonDict, SupModuleList, Item)
|
||||
else:
|
||||
#
|
||||
SupModuleList = Object.SupModuleList
|
||||
#AddToSection(SectionDict, "|".join(SupModuleList), Item)
|
||||
AddToLibraryClassSection(SectionCommonDict, SupModuleList, Item)
|
||||
else:
|
||||
# Arch
|
||||
for Arch in SupportedArches:
|
||||
if Arch.upper() in Arches:
|
||||
if Arch == "IA32":
|
||||
# [LibraryClasses.IA32.ModuleType]
|
||||
ModuleType = Object.ModuleType
|
||||
if ModuleType == "BASE":
|
||||
SupModuleList = ["BASE"]
|
||||
AddToLibraryClassSection(SectionIA32Dict, SupModuleList, Item)
|
||||
else:
|
||||
SupModuleList = Object.SupModuleList
|
||||
AddToLibraryClassSection(SectionIA32Dict, SupModuleList, Item)
|
||||
elif Arch == "X64":
|
||||
# [LibraryClasses.X64.ModuleType]
|
||||
ModuleType = Object.ModuleType
|
||||
if ModuleType == "BASE":
|
||||
SupModuleList = ["BASE"]
|
||||
AddToLibraryClassSection(SectionX64Dict, SupModuleList, Item)
|
||||
else:
|
||||
SupModuleList = Object.SupModuleList
|
||||
AddToLibraryClassSection(SectionX64Dict, SupModuleList, Item)
|
||||
elif Arch == "IPF":
|
||||
# [LibraryClasses.IPF.ModuleType]
|
||||
ModuleType = Object.ModuleType
|
||||
if ModuleType == "BASE":
|
||||
SupModuleList = ["BASE"]
|
||||
AddToLibraryClassSection(SectionIPFDict, SupModuleList, Item)
|
||||
else:
|
||||
SupModuleList = Object.SupModuleList
|
||||
AddToLibraryClassSection(SectionIPFDict, SupModuleList, Item)
|
||||
elif Arch == "EBC":
|
||||
# [LibraryClasses.EBC.ModuleType]
|
||||
ModuleType = Object.ModuleType
|
||||
if ModuleType == "BASE":
|
||||
SupModuleList = ["BASE"]
|
||||
AddToLibraryClassSection(SectionEBCDict, SupModuleList, Item)
|
||||
else:
|
||||
SupModuleList = Object.SupModuleList
|
||||
AddToLibraryClassSection(SectionEBCDict, SupModuleList, Item)
|
||||
|
||||
Section = ""
|
||||
for ModuleType in ModuleTypes:
|
||||
SectionCommonModule = "\n".join(SectionCommonDict.get(ModuleType, []))
|
||||
if SectionCommonModule != "":
|
||||
Section += "[%s.Common.%s]\n%s\n" % (SectionName, ModuleType, SectionCommonModule)
|
||||
Section += "\n"
|
||||
for ModuleType in ModuleTypes:
|
||||
ListIA32 = SectionIA32Dict.get(ModuleType, [])
|
||||
if ListIA32 != []:
|
||||
SectionIA32Module = "\n".join(SectionIA32Dict.get(ModuleType, []))
|
||||
if SectionIA32Module != "":
|
||||
Section += "[%s.IA32.%s]\n%s\n" % (SectionName, ModuleType, SectionIA32Module)
|
||||
Section += "\n"
|
||||
ListX64 = SectionX64Dict.get(ModuleType, [])
|
||||
if ListX64 != []:
|
||||
SectionX64Module = "\n".join(SectionX64Dict.get(ModuleType, []))
|
||||
if SectionX64Module != "":
|
||||
Section += "[%s.X64.%s]\n%s\n" % (SectionName, ModuleType, SectionX64Module)
|
||||
Section += "\n"
|
||||
ListIPF = SectionIPFDict.get(ModuleType, [])
|
||||
if ListIPF != []:
|
||||
SectionIPFModule = "\n".join(SectionIPFDict.get(ModuleType, []))
|
||||
if SectionIPFModule != "":
|
||||
Section += "[%s.IPF.%s]\n%s\n" % (SectionName, ModuleType, SectionIPFModule)
|
||||
Section += "\n"
|
||||
ListEBC = SectionEBCDict.get(ModuleType, [])
|
||||
if ListEBC != []:
|
||||
SectionEBCModule = "\n".join(SectionEBCDict.get(ModuleType, []))
|
||||
if SectionEBCModule != "":
|
||||
Section += "[%s.EBC.%s]\n%s\n" % (SectionName, ModuleType, SectionEBCModule)
|
||||
Section += "\n"
|
||||
|
||||
if Section != "":
|
||||
Section += "\n"
|
||||
return Section
|
||||
|
||||
## Store Library Classes section
|
||||
#
|
||||
# Write [LibraryClasses] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Library Classes section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformLibraryClassesSection(DscFile, Platform):
|
||||
Section = GetLibraryClassesSection("LibraryClasses", GetPlatformLibraryClassItem, Platform.LibraryClasses.LibraryList)
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Library Class section - list of all Library Classes needed by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
Section = SectionHeader + Section
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Store Pcd section
|
||||
#
|
||||
# Write [Pcd] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Build Options section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformPcdSection(DscFile, Platform):
|
||||
# {PcdsFixedAtBuild:String1, PcdsFixedAtBuild:String2, PcdsPatchableInModule:String3}
|
||||
SectionDict = {}
|
||||
#
|
||||
# [PcdsFixedAtBuild], [PcdsPatchableInModule] and [PcdsFeatureFlag] are from platform.modules
|
||||
# [PcdsDynamic] is from platform.DynamicPcdBuildDefinitions
|
||||
#
|
||||
Modules = Platform.Modules.ModuleList # it's a list of modules
|
||||
for Module in Modules:
|
||||
PcdBuildDefinitions = Module.PcdBuildDefinitions # it's a list of PcdData
|
||||
for PcdData in PcdBuildDefinitions:
|
||||
if PcdData.ItemType == "FEATURE_FLAG":
|
||||
List = []
|
||||
List.append(PcdData.TokenSpaceGuidCName + "." + PcdData.C_NAME)
|
||||
List.append(PcdData.Value)
|
||||
String = "|".join(List)
|
||||
ItemType = PcdData.ItemType
|
||||
SectionPcdsFeatureFlag = SectionDict.get(ItemType, [])
|
||||
if String not in SectionPcdsFeatureFlag:
|
||||
SectionPcdsFeatureFlag.append(String)
|
||||
SectionDict[ItemType] = SectionPcdsFeatureFlag
|
||||
else:
|
||||
List = []
|
||||
List.append(PcdData.TokenSpaceGuidCName + "." + PcdData.C_NAME)
|
||||
List.append(PcdData.Value)
|
||||
List.append(PcdData.Token)
|
||||
List.append(PcdData.DatumType)
|
||||
List.append(PcdData.MaxDatumSize)
|
||||
String = "|".join(List)
|
||||
ItemType = PcdData.ItemType
|
||||
if PcdData.ItemType == "FIXED_AT_BUILD":
|
||||
SectionPcdsFixedAtBuild = SectionDict.get(ItemType, [])
|
||||
if String not in SectionPcdsFixedAtBuild:
|
||||
SectionPcdsFixedAtBuild.append(String)
|
||||
SectionDict[ItemType] = SectionPcdsFixedAtBuild
|
||||
#elif PcdData.ItemType == "FEATURE_FLAG":
|
||||
#SectionPcdsFeatureFlag = SectionDict.get(ItemType, [])
|
||||
#if String not in SectionPcdsFeatureFlag:
|
||||
#SectionPcdsFeatureFlag.append(String)
|
||||
#SectionDict[ItemType] = SectionPcdsFeatureFlag
|
||||
elif PcdData.ItemType == "PATCHABLE_IN_MODULE":
|
||||
SectionPcdsPatchableInModule = SectionDict.get(ItemType, [])
|
||||
if String not in SectionPcdsPatchableInModule:
|
||||
SectionPcdsPatchableInModule.append(String)
|
||||
SectionDict[ItemType] = SectionPcdsPatchableInModule
|
||||
elif PcdData.ItemType == "DYNAMIC":
|
||||
SectionPcdsDynamic = SectionDict.get(ItemType, [])
|
||||
if String not in SectionPcdsDynamic:
|
||||
SectionPcdsDynamic.append(String)
|
||||
SectionDict[ItemType] = SectionPcdsDynamic
|
||||
|
||||
DynamicPcdBuildDefinitions = Platform.DynamicPcdBuildDefinitions # It's a list
|
||||
for PcdBuildData in DynamicPcdBuildDefinitions:
|
||||
List = []
|
||||
List.append(PcdData.TokenSpaceGuidCName + "." + PcdData.C_NAME)
|
||||
List.append(PcdData.Token)
|
||||
List.append(PcdData.DatumType)
|
||||
List.append(PcdData.MaxDatumSize)
|
||||
String = "|".join(List)
|
||||
if PcdBuildData.ItemType == "DYNAMIC":
|
||||
ItemType = PcdBuildData.ItemType
|
||||
SectionPcdsDynamic = SectionDict.get(ItemType, [])
|
||||
if String not in SectionPcdsDynamic:
|
||||
SectionPcdsDynamic.append(String)
|
||||
SectionDict[ItemType] = SectionPcdsDynamic
|
||||
ItemType = "FIXED_AT_BUILD"
|
||||
Section = "[PcdsFixedAtBuild]\n " + "\n ".join(SectionDict.get(ItemType, []))
|
||||
ItemType = "FEATURE_FLAG"
|
||||
Section += "\n\n[PcdsFeatureFlag]\n " + "\n ".join(SectionDict.get(ItemType, []))
|
||||
ItemType = "PATCHABLE_IN_MODULE"
|
||||
Section += "\n\n[PcdsPatchableInModule]\n " + "\n ".join(SectionDict.get(ItemType, []))
|
||||
Section += "\n\n"
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Pcd Dynamic Section - list of all EDK II PCD Entries defined by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
String = "\n".join(List)
|
||||
Section += String
|
||||
ItemType = "DYNAMIC"
|
||||
Section += "\n\n[PcdsDynamic]\n " + "\n ".join(SectionDict.get(ItemType, []))
|
||||
Section += "\n\n"
|
||||
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Pcd Section - list of all EDK II PCD Entries defined by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
Section = SectionHeader + Section
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Add item to a section
|
||||
#
|
||||
# Add an Item with specific CPU architecture to section dictionary.
|
||||
# The possible duplication is ensured to be removed.
|
||||
#
|
||||
# @param Section Section dictionary indexed by CPU architecture
|
||||
# @param Arch CPU architecture: Ia32, X64, Ipf, Ebc or Common
|
||||
# @param Item The Item to be added to section dictionary
|
||||
#
|
||||
def AddToSection(Section, Arch, Item):
|
||||
SectionArch = Section.get(Arch, [])
|
||||
if Item not in SectionArch:
|
||||
SectionArch.append(Item)
|
||||
Section[Arch] = SectionArch
|
||||
|
||||
## Get section contents
|
||||
#
|
||||
# Return the content of section named SectionName.
|
||||
# the contents is based on Methods and ObjectLists.
|
||||
#
|
||||
# @param SectionName The name of the section
|
||||
# @param Method A function returning a string item of an object
|
||||
# @param ObjectList The list of object
|
||||
#
|
||||
# @retval Section The string content of a section
|
||||
#
|
||||
def GetSection(SectionName, Method, ObjectList):
|
||||
SupportedArches = ["COMMON", "IA32", "X64", "IPF", "EBC"]
|
||||
SectionDict = {}
|
||||
for Object in ObjectList:
|
||||
if Object.FilePath == "":
|
||||
continue
|
||||
Item = Method(Object)
|
||||
if Item == "":
|
||||
continue
|
||||
Item = " %s" % Item
|
||||
Arches = Object.SupArchList
|
||||
if len(Arches) == 4:
|
||||
AddToSection(SectionDict, "common", Item)
|
||||
else:
|
||||
for Arch in SupportedArches:
|
||||
if Arch.upper() in Arches:
|
||||
AddToSection(SectionDict, Arch, Item)
|
||||
|
||||
Section = ""
|
||||
for Arch in SupportedArches:
|
||||
SectionArch = "\n".join(SectionDict.get(Arch, []))
|
||||
if SectionArch != "":
|
||||
Section += "[%s.%s]\n%s\n" % (SectionName, Arch, SectionArch)
|
||||
Section += "\n"
|
||||
if Section != "":
|
||||
Section += "\n"
|
||||
return Section
|
||||
|
||||
## Return a Platform Component Item
|
||||
#
|
||||
# Read the input Platform Component object and return one line of Platform Component Item.
|
||||
#
|
||||
# @param Component An input Platform Component class object
|
||||
#
|
||||
# @retval ComponentItem A Platform Component Item
|
||||
#
|
||||
def GetPlatformComponentItem(Component):
|
||||
List = []
|
||||
Section = {}
|
||||
|
||||
List.append("$(WORKSPACE)/" + Component.FilePath)
|
||||
|
||||
LibraryClasses = Component.LibraryClasses
|
||||
if LibraryClasses != []:
|
||||
List = []
|
||||
List.append("$(WORKSPACE)/" + Component.FilePath + " {")
|
||||
List.append("<LibraryClasses>")
|
||||
for LibraryClass in LibraryClasses:
|
||||
if LibraryClass == ["", ""]:
|
||||
continue
|
||||
List.append(" " + LibraryClass[0] + "|$(WORKSPACE)/" + LibraryClass[1])
|
||||
|
||||
PcdBuildDefinitions = Component.PcdBuildDefinitions
|
||||
for PcdData in PcdBuildDefinitions:
|
||||
if PcdData.ItemType == "FEATURE_FLAG":
|
||||
List1 = []
|
||||
List1.append(PcdData.TokenSpaceGuidCName + "." + PcdData.C_NAME)
|
||||
List1.append(PcdData.Value)
|
||||
String = "|".join(List1)
|
||||
ItemType = PcdData.ItemType
|
||||
SectionPcd = Section.get(ItemType, [])
|
||||
if String not in SectionPcd:
|
||||
SectionPcd.append(String)
|
||||
Section[ItemType] = SectionPcd
|
||||
else:
|
||||
List1 = []
|
||||
List1.append(PcdData.TokenSpaceGuidCName + "." + PcdData.C_NAME)
|
||||
List1.append(PcdData.Value)
|
||||
List1.append(PcdData.Token)
|
||||
List1.append(PcdData.DatumType)
|
||||
List1.append(PcdData.MaxDatumSize)
|
||||
String = "|".join(List1)
|
||||
ItemType = PcdData.ItemType
|
||||
if ItemType == "FIXED_AT_BUILD":
|
||||
SectionPcd = Section.get(ItemType, [])
|
||||
if String not in SectionPcd:
|
||||
SectionPcd.append(String)
|
||||
Section[ItemType] = SectionPcd
|
||||
#elif ItemType == "FEATURE_FLAG":
|
||||
#SectionPcd = Section.get(ItemType, [])
|
||||
#if String not in SectionPcd:
|
||||
#SectionPcd.append(String)
|
||||
#Section[ItemType] = SectionPcd
|
||||
elif ItemType == "PATCHABLE_IN_MODULE":
|
||||
SectionPcd = Section.get(ItemType, [])
|
||||
if String not in SectionPcd:
|
||||
SectionPcd.append(String)
|
||||
Section[ItemType] = SectionPcd
|
||||
elif ItemType == "DYNAMIC":
|
||||
SectionPcd = Section.get(ItemType, [])
|
||||
if String not in SectionPcd:
|
||||
SectionPcd.append(String)
|
||||
Section[ItemType] = SectionPcd
|
||||
|
||||
ItemType = "FIXED_AT_BUILD"
|
||||
if Section.get(ItemType, []) != []:
|
||||
List.append("<PcdsFixedAtBuild>")
|
||||
List.append(" " + "\n ".join(Section.get(ItemType,[])))
|
||||
ItemType = "FEATURE_FLAG"
|
||||
if Section.get(ItemType, []) != []:
|
||||
List.append("<PcdsFeatureFlag>")
|
||||
List.append(" " + "\n ".join(Section.get(ItemType,[])))
|
||||
ItemType = "PATCHABLE_IN_MODULE"
|
||||
if Section.get(ItemType, []) != []:
|
||||
List.append("<PcdsPatchableInModule>")
|
||||
List.append(" " + "\n ".join(Section.get(ItemType,[])))
|
||||
ItemType = "DYNAMIC"
|
||||
if Section.get(ItemType, []) != []:
|
||||
List.append("<PcdsDynamic>")
|
||||
List.append(" " + "\n ".join(Section.get(ItemType,[])))
|
||||
|
||||
ListOption = []
|
||||
SectionOption = ""
|
||||
ListBuildOptions = Component.BuildOptions # a list
|
||||
if ListBuildOptions != []:
|
||||
SectionOption += "\n <BuildOptions>\n"
|
||||
for BuildOptions in ListBuildOptions:
|
||||
Options = BuildOptions.Options
|
||||
for Option in Options:
|
||||
for Item in Option.BuildTargetList:
|
||||
ListOption.append(Item)
|
||||
List.append(Option.ToolChainFamily)
|
||||
for Item in Option.SupArchList:
|
||||
ListOption.append(Item)
|
||||
ListOption.append(Option.ToolCode)
|
||||
ListOption.append("FLAGS")
|
||||
#print ListOption
|
||||
SectionOption += " " + "_".join(List) + " = " + Option.Option + "\n"
|
||||
ListOption = []
|
||||
if SectionOption != "":
|
||||
List.append(SectionOption)
|
||||
if List != ["$(WORKSPACE)/" + Component.FilePath]:
|
||||
List.append("}\n")
|
||||
|
||||
return "\n ".join(List)
|
||||
|
||||
## Store Components section.
|
||||
#
|
||||
# Write [Components] section to the DscFile based on Platform class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the Components section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformComponentsSection(DscFile, Platform):
|
||||
Section = GetSection("Components", GetPlatformComponentItem, Platform.Modules.ModuleList)
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# Components Section - list of all EDK II Modules needed by this Platform.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
Section = SectionHeader + Section
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Store User Extensions section.
|
||||
#
|
||||
# Write [UserExtensions] section to the InfFile based on Module class object.
|
||||
# Different CPU architectures are specified in the subsection if possible.
|
||||
#
|
||||
# @param DscFile The output DSC file to store the User Extensions section
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StorePlatformUserExtensionsSection(DscFile, Platform):
|
||||
Section = "".join(map(GetUserExtensions, Platform.UserExtensions))
|
||||
List = []
|
||||
List.append("################################################################################")
|
||||
List.append("#")
|
||||
List.append("# User Extensions Section - list of all User Extensions specified by user.")
|
||||
List.append("#")
|
||||
List.append("################################################################################")
|
||||
SectionHeader = "\n".join(List)
|
||||
SectionHeader += "\n"
|
||||
Section = SectionHeader + Section
|
||||
StoreTextFile(DscFile, Section)
|
||||
|
||||
## Store a Platform class object to a new DSC file.
|
||||
#
|
||||
# Read an input Platform class object and save the contents to a new DSC file.
|
||||
#
|
||||
# @param DSCFileName The output DSC file
|
||||
# @param Platform An input Platform class object
|
||||
#
|
||||
def StoreDsc(DscFileName, Platform):
|
||||
DscFile = open(DscFileName, "w+")
|
||||
EdkLogger.info("Save file to %s" % DscFileName)
|
||||
|
||||
StoreHeader(DscFile, Platform.Header)
|
||||
StorePlatformDefinesSection(DscFile, Platform)
|
||||
StorePlatformBuildOptionsSection(DscFile,Platform)
|
||||
StorePlatformSkuIdsSection(DscFile,Platform)
|
||||
StorePlatformLibrariesSection(DscFile,Platform) # new in dsc, Edk I components, list of INF files
|
||||
StorePlatformLibraryClassesSection(DscFile, Platform) # LibraryClasses are from Modules
|
||||
StorePlatformPcdSection(DscFile, Platform)
|
||||
#StorePlatformPcdDynamicSection(DscFile, Platform)
|
||||
StorePlatformComponentsSection(DscFile,Platform)
|
||||
StorePlatformUserExtensionsSection(DscFile,Platform)
|
||||
DscFile.close()
|
||||
|
||||
if __name__ == '__main__':
|
||||
pass
|
||||
Reference in New Issue
Block a user