sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
b410d6e4ce58c177569d42b51772f7bb239a24a3
system76-edk2/BaseTools/Source/Python/fpd2dsc/StoreDsc.py
lgao4 40d841f6a8 Sync EDKII BaseTools to BaseTools project r1971 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@10502 6f19259b-4bc3-4df7-8a09-765794883524
2010-05-18 05:04:32 +00:00

766 lines
33 KiB
Python
Raw Blame History

## @file
# Store a Platform class object to an INF file.
#
# Copyright (c) 2007 - 2009, 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.
#
##
# 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 View Git Blame Copy Permalink