mirror of https://github.com/acidanthera/audk.git
766 lines
33 KiB
Python
766 lines
33 KiB
Python
|
## @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
|