From 30fdf1140b8d1ce93f3821d986fa165552023440 Mon Sep 17 00:00:00 2001 From: lgao4 Date: Fri, 17 Jul 2009 09:10:31 +0000 Subject: 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 --- BaseTools/Source/Python/fpd2dsc/StoreDsc.py | 765 ++++++++++++++++++++++++++++ 1 file changed, 765 insertions(+) create mode 100644 BaseTools/Source/Python/fpd2dsc/StoreDsc.py (limited to 'BaseTools/Source/Python/fpd2dsc/StoreDsc.py') diff --git a/BaseTools/Source/Python/fpd2dsc/StoreDsc.py b/BaseTools/Source/Python/fpd2dsc/StoreDsc.py new file mode 100644 index 0000000000..8d07ab9c5b --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/StoreDsc.py @@ -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("") + 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("") + List.append(" " + "\n ".join(Section.get(ItemType,[]))) + ItemType = "FEATURE_FLAG" + if Section.get(ItemType, []) != []: + List.append("") + List.append(" " + "\n ".join(Section.get(ItemType,[]))) + ItemType = "PATCHABLE_IN_MODULE" + if Section.get(ItemType, []) != []: + List.append("") + List.append(" " + "\n ".join(Section.get(ItemType,[]))) + ItemType = "DYNAMIC" + if Section.get(ItemType, []) != []: + List.append("") + List.append(" " + "\n ".join(Section.get(ItemType,[]))) + + ListOption = [] + SectionOption = "" + ListBuildOptions = Component.BuildOptions # a list + if ListBuildOptions != []: + SectionOption += "\n \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 -- cgit v1.2.3