diff options
Diffstat (limited to 'BaseTools/Source/Python/fpd2dsc')
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/EdkIIWorkspaceGuidsInfo.py | 327 | ||||
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/LoadFpd.py | 1039 | ||||
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/MigrationUtilities.py | 563 | ||||
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/StoreDsc.py | 765 | ||||
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/__init__.py | 0 | ||||
-rw-r--r-- | BaseTools/Source/Python/fpd2dsc/fpd2dsc.py | 116 |
6 files changed, 2810 insertions, 0 deletions
diff --git a/BaseTools/Source/Python/fpd2dsc/EdkIIWorkspaceGuidsInfo.py b/BaseTools/Source/Python/fpd2dsc/EdkIIWorkspaceGuidsInfo.py new file mode 100644 index 0000000000..528dbf3ddb --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/EdkIIWorkspaceGuidsInfo.py @@ -0,0 +1,327 @@ +## @file
+# Collects the Guid Information in current workspace.
+#
+# Copyright (c) 2007, 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
+#
+import os
+import fnmatch
+from Common.EdkIIWorkspace import EdkIIWorkspace
+from Common.MigrationUtilities import *
+
+## A class for EdkII work space to resolve Guids
+#
+# This class inherits from EdkIIWorkspace and collects the Guids information
+# in current workspace. The Guids information is important to translate the
+# package Guids and recommended library instances Guids to relative file path
+# (to workspace directory) in MSA files.
+#
+class EdkIIWorkspaceGuidsInfo(EdkIIWorkspace):
+
+ ## The classconstructor
+ #
+ # The constructor initialize workspace directory. It does not collect
+ # pakage and module Guids info at initialization; instead, it collects them
+ # on the fly.
+ #
+ # @param self The object pointer
+ #
+ def __init__(self):
+ # Initialize parent class.
+ EdkIIWorkspace.__init__(self)
+ # The internal map from Guid to FilePath.
+ self.__GuidToFilePath = {}
+ # The internal package directory list.
+ self.__PackageDirList = []
+ # The internal flag to indicate whether package Guids info has been initialized
+ # to avoid re-collection collected.
+ self.__PackageGuidInitialized = False
+ # The internal flag to indicate whether module Guids info has been initialized
+ # to avoid re-collection collected.
+ self.__ModuleGuidInitialized = False
+
+ ## Add Guid, Version and FilePath to Guids database
+ #
+ # Add Guid, Version and FilePath to Guids database. It constructs a map
+ # table from Guid, Version to FilePath internally. If also detects possible
+ # Guid collision. For now, the version information is simply ignored and
+ # Guid value itself acts as master key.
+ #
+ # @param self The object pointer
+ # @param Guid The Guid Value
+ # @param Version The version information
+ # @param FilePath The Guid related file path
+ #
+ # @retval True The Guid value is successfully added to map table
+ # @retval False The Guid is an empty string or the map table
+ # already contains a same Guid
+ #
+ def __AddGuidToFilePath(self, Guid, Version, FilePath):
+ if Guid == "":
+ EdkLogger.info("Cannot find Guid in file %s" % FilePath)
+ return False
+ #Add the Guid value to map table to ensure case insensitive comparison.
+ OldFilePath = self.__GuidToFilePath.setdefault(Guid.lower(), FilePath)
+ if OldFilePath == FilePath:
+ EdkLogger.verbose("File %s has new Guid '%s'" % (FilePath, Guid))
+ return True
+ else:
+ EdkLogger.info("File %s has duplicate Guid with & %s" % (FilePath, OldFilePath))
+ return False
+
+
+ ## Gets file information from a module description file
+ #
+ # Extracts Module Name, File Guid and Version number from INF, MSA and NMSA
+ # file. It supports to exact such information from text based INF file or
+ # XML based (N)MSA file.
+ #
+ # @param self The object pointer
+ # @param FileName The input module file name
+ #
+ # @retval True This module file represents a new module discovered
+ # in current workspace
+ # @retval False This module file is not regarded as a valid module
+ # The File Guid cannot be extracted or the another
+ # file with the same Guid already exists
+ #
+ def __GetModuleFileInfo(self, FileName):
+ if fnmatch.fnmatch(FileName, "*.inf"):
+ TagTuple = ("BASE_NAME", "FILE_GUID", "VERSION_STRING")
+ (Name, Guid, Version) = GetTextFileInfo(FileName, TagTuple)
+ else :
+ XmlTag1 = "ModuleSurfaceArea/MsaHeader/ModuleName"
+ XmlTag2 = "ModuleSurfaceArea/MsaHeader/GuidValue"
+ XmlTag3 = "ModuleSurfaceArea/MsaHeader/Version"
+ TagTuple = (XmlTag1, XmlTag2, XmlTag3)
+ (Name, Guid, Version) = GetXmlFileInfo(FileName, TagTuple)
+
+ return self.__AddGuidToFilePath(Guid, Version, FileName)
+
+
+ ## Gets file information from a package description file
+ #
+ # Extracts Package Name, File Guid and Version number from INF, SPD and NSPD
+ # file. It supports to exact such information from text based DEC file or
+ # XML based (N)SPD file. EDK Compatibility Package is hardcoded to be
+ # ignored since no EDKII INF file depends on that package.
+ #
+ # @param self The object pointer
+ # @param FileName The input package file name
+ #
+ # @retval True This package file represents a new package
+ # discovered in current workspace
+ # @retval False This package is not regarded as a valid package
+ # The File Guid cannot be extracted or the another
+ # file with the same Guid already exists
+ #
+ def __GetPackageFileInfo(self, FileName):
+ if fnmatch.fnmatch(FileName, "*.dec"):
+ TagTuple = ("PACKAGE_NAME", "PACKAGE_GUID", "PACKAGE_VERSION")
+ (Name, Guid, Version) = GetTextFileInfo(FileName, TagTuple)
+ else:
+ XmlTag1 = "PackageSurfaceArea/SpdHeader/PackageName"
+ XmlTag2 = "PackageSurfaceArea/SpdHeader/GuidValue"
+ XmlTag3 = "PackageSurfaceArea/SpdHeader/Version"
+ TagTuple = (XmlTag1, XmlTag2, XmlTag3)
+ (Name, Guid, Version) = GetXmlFileInfo(FileName, TagTuple)
+
+ if Name == "EdkCompatibilityPkg":
+ # Do not scan EDK compatibitilty package to avoid Guid collision
+ # with those in EDK Glue Library.
+ EdkLogger.verbose("Bypass EDK Compatibility Pkg")
+ return False
+
+ return self.__AddGuidToFilePath(Guid, Version, FileName)
+
+ ## Iterate on all package files listed in framework database file
+ #
+ # Yields all package description files listed in framework database files.
+ # The framework database file describes the packages current workspace
+ # includes.
+ #
+ # @param self The object pointer
+ #
+ def __FrameworkDatabasePackageFiles(self):
+ XmlFrameworkDb = XmlParseFile(self.WorkspaceFile)
+ XmlTag = "FrameworkDatabase/PackageList/Filename"
+ for PackageFile in XmlElementList(XmlFrameworkDb, XmlTag):
+ yield os.path.join(self.WorkspaceDir, PackageFile)
+
+
+ ## Iterate on all package files in current workspace directory
+ #
+ # Yields all package description files listed in current workspace
+ # directory. This happens when no framework database file exists.
+ #
+ # @param self The object pointer
+ #
+ def __TraverseAllPackageFiles(self):
+ for Path, Dirs, Files in os.walk(self.WorkspaceDir):
+ # Ignore svn version control directory.
+ if ".svn" in Dirs:
+ Dirs.remove(".svn")
+ if "Build" in Dirs:
+ Dirs.remove("Build")
+ # Assume priority from high to low: DEC, NSPD, SPD.
+ PackageFiles = fnmatch.filter(Files, "*.dec")
+ if len(PackageFiles) == 0:
+ PackageFiles = fnmatch.filter(Files, "*.nspd")
+ if len(PackageFiles) == 0:
+ PackageFiles = fnmatch.filter(Files, "*.spd")
+
+ for File in PackageFiles:
+ # Assume no more package decription file in sub-directory.
+ del Dirs[:]
+ yield os.path.join(Path, File)
+
+ ## Iterate on all module files in current package directory
+ #
+ # Yields all module description files listed in current package
+ # directory.
+ #
+ # @param self The object pointer
+ #
+ def __TraverseAllModuleFiles(self):
+ for PackageDir in self.__PackageDirList:
+ for Path, Dirs, Files in os.walk(PackageDir):
+ # Ignore svn version control directory.
+ if ".svn" in Dirs:
+ Dirs.remove(".svn")
+ # Assume priority from high to low: INF, NMSA, MSA.
+ ModuleFiles = fnmatch.filter(Files, "*.inf")
+ if len(ModuleFiles) == 0:
+ ModuleFiles = fnmatch.filter(Files, "*.nmsa")
+ if len(ModuleFiles) == 0:
+ ModuleFiles = fnmatch.filter(Files, "*.msa")
+
+ for File in ModuleFiles:
+ yield os.path.join(Path, File)
+
+ ## Initialize package Guids info mapping table
+ #
+ # Collects all package guids map to package decription file path. This
+ # function is invokes on demand to avoid unnecessary directory scan.
+ #
+ # @param self The object pointer
+ #
+ def __InitializePackageGuidInfo(self):
+ if self.__PackageGuidInitialized:
+ return
+
+ EdkLogger.verbose("Start to collect Package Guids Info.")
+
+ WorkspaceFile = os.path.join("Conf", "FrameworkDatabase.db")
+ self.WorkspaceFile = os.path.join(self.WorkspaceDir, WorkspaceFile)
+
+ # Try to find the frameworkdatabase file to discover package lists
+ if os.path.exists(self.WorkspaceFile):
+ TraversePackage = self.__FrameworkDatabasePackageFiles
+ EdkLogger.verbose("Package list bases on: %s" % self.WorkspaceFile)
+ else:
+ TraversePackage = self.__TraverseAllPackageFiles
+ EdkLogger.verbose("Package list in: %s" % self.WorkspaceDir)
+
+ for FileName in TraversePackage():
+ if self.__GetPackageFileInfo(FileName):
+ PackageDir = os.path.dirname(FileName)
+ EdkLogger.verbose("Find new package directory %s" % PackageDir)
+ self.__PackageDirList.append(PackageDir)
+
+ self.__PackageGuidInitialized = True
+
+ ## Initialize module Guids info mapping table
+ #
+ # Collects all module guids map to module decription file path. This
+ # function is invokes on demand to avoid unnecessary directory scan.
+ #
+ # @param self The object pointer
+ #
+ def __InitializeModuleGuidInfo(self):
+ if self.__ModuleGuidInitialized:
+ return
+ EdkLogger.verbose("Start to collect Module Guids Info")
+
+ self.__InitializePackageGuidInfo()
+ for FileName in self.__TraverseAllModuleFiles():
+ if self.__GetModuleFileInfo(FileName):
+ EdkLogger.verbose("Find new module %s" % FileName)
+
+ self.__ModuleGuidInitialized = True
+
+ ## Get Package file path by Package Guid and Version
+ #
+ # Translates the Package Guid and Version to a file path relative
+ # to workspace directory. If no package in current workspace match the
+ # input Guid, an empty file path is returned. For now, the version
+ # value is simply ignored.
+ #
+ # @param self The object pointer
+ # @param Guid The Package Guid value to look for
+ # @param Version The Package Version value to look for
+ #
+ def ResolvePackageFilePath(self, Guid, Version = ""):
+ self.__InitializePackageGuidInfo()
+
+ EdkLogger.verbose("Resolve Package Guid '%s'" % Guid)
+ FileName = self.__GuidToFilePath.get(Guid.lower(), "")
+ if FileName == "":
+ EdkLogger.info("Cannot resolve Package Guid '%s'" % Guid)
+ else:
+ FileName = self.WorkspaceRelativePath(FileName)
+ FileName = os.path.splitext(FileName)[0] + ".dec"
+ FileName = FileName.replace("\\", "/")
+ return FileName
+
+ ## Get Module file path by Module Guid and Version
+ #
+ # Translates the Module Guid and Version to a file path relative
+ # to workspace directory. If no module in current workspace match the
+ # input Guid, an empty file path is returned. For now, the version
+ # value is simply ignored.
+ #
+ # @param self The object pointer
+ # @param Guid The Module Guid value to look for
+ # @param Version The Module Version value to look for
+ #
+ def ResolveModuleFilePath(self, Guid, Version = ""):
+ self.__InitializeModuleGuidInfo()
+
+ EdkLogger.verbose("Resolve Module Guid '%s'" % Guid)
+ FileName = self.__GuidToFilePath.get(Guid.lower(), "")
+ if FileName == "":
+ EdkLogger.info("Cannot resolve Module Guid '%s'" % Guid)
+ else:
+ FileName = self.WorkspaceRelativePath(FileName)
+ FileName = os.path.splitext(FileName)[0] + ".inf"
+ FileName = FileName.replace("\\", "/")
+ return FileName
+
+# A global class object of EdkIIWorkspaceGuidsInfo for external reference.
+gEdkIIWorkspaceGuidsInfo = EdkIIWorkspaceGuidsInfo()
+
+# This acts like the main() function for the script, unless it is 'import'ed
+# into another script.
+if __name__ == '__main__':
+ # Test the translation of package Guid.
+# MdePkgGuid = "1E73767F-8F52-4603-AEB4-F29B510B6766"
+# OldMdePkgGuid = "5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"
+# print gEdkIIWorkspaceGuidsInfo.ResolveModuleFilePath(MdePkgGuid)
+# print gEdkIIWorkspaceGuidsInfo.ResolveModuleFilePath(OldMdePkgGuid)
+
+ # Test the translation of module Guid.
+# UefiLibGuid = "3a004ba5-efe0-4a61-9f1a-267a46ae5ba9"
+# UefiDriverModelLibGuid = "52af22ae-9901-4484-8cdc-622dd5838b09"
+# print gEdkIIWorkspaceGuidsInfo.ResolvePlatformFilePath(UefiLibGuid)
+# print gEdkIIWorkspaceGuidsInfo.ResolvePlatformFilePath(UefiDriverModelLibGuid)
+ pass
\ No newline at end of file diff --git a/BaseTools/Source/Python/fpd2dsc/LoadFpd.py b/BaseTools/Source/Python/fpd2dsc/LoadFpd.py new file mode 100644 index 0000000000..cc97ec5521 --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/LoadFpd.py @@ -0,0 +1,1039 @@ +## @file
+# Open an FPD file and load all its contents to a PlatformClass object.
+#
+# Copyright (c) 2007, 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
+#
+import os
+from CommonDataClass.PlatformClass import *
+from CommonDataClass.FdfClass import *
+from Common.XmlRoutines import *
+from Common.MigrationUtilities import *
+from EdkIIWorkspaceGuidsInfo import gEdkIIWorkspaceGuidsInfo
+
+## Load Platform Header
+#
+# Read an input Platform XML DOM object and return Platform Header class object
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+# @param FpdFileName The file path of FPD File
+#
+# @retvel PlatformHeader A new Platform Header object loaded from XmlFpd
+#
+def LoadPlatformHeader(XmlFpd, FpdFileName):
+ PlatformHeader = PlatformHeaderClass()
+
+ XmlTag = "PlatformSurfaceArea/PlatformHeader"
+ FpdHeader = XmlNode(XmlFpd, XmlTag)
+
+ SetIdentification(PlatformHeader, FpdHeader, "PlatformName", FpdFileName)
+ SetCommonHeader(PlatformHeader, FpdHeader)
+
+ XmlTag = "PlatformSurfaceArea/PlatformHeader/Specification"
+ List = XmlElement(XmlFpd, XmlTag).split()
+ SpecificationName = List[0]
+ SpecificationValue = List[1]
+ PlatformHeader.Specification = {SpecificationName:SpecificationValue}
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/SupportedArchitectures"
+ PlatformHeader.SupArchList = XmlElement(XmlFpd, XmlTag).split()
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/BuildTargets"
+ PlatformHeader.BuildTargets = XmlElement(XmlFpd, XmlTag).split()
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/IntermediateDirectories"
+ PlatformHeader.IntermediateDirectories = XmlElement(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/OutputDirectory"
+ PlatformHeader.OutputDirectory = XmlElement(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/SkuInfo"
+ List = map(LoadSkuId, XmlList(XmlFpd, XmlTag))
+ if List != []:
+ PlatformHeader.SkuIdName = List[0]
+
+ return PlatformHeader
+
+## Load a Platform SkuId
+#
+# Read an input Platform XML DOM object and return a list of Platform SkuId
+# contained in the DOM object.
+#
+# @param XmlPlatformSkuInfo An XML DOM object read from FPD file
+#
+# @retvel PlatformSkuInfo A SkuInfo loaded from XmlFpd
+#
+def LoadPlatformSkuInfo(XmlPlatformSkuInfo):
+ XmlTag = "SkuInfo/SkuId"
+ SkuInfo = []
+ SkuId = XmlElement(XmlPlatformSkuInfo, XmlTag)
+ SkuInfo.append(SkuId)
+
+ XmlTag = "SkuInfo/Value"
+ Value = XmlElement(XmlPlatformSkuInfo, XmlTag)
+ SkuInfo.append(Value)
+ return SkuInfo
+
+## Load a Platform SkuId
+#
+# Read an input Platform XML DOM object and return a list of Platform SkuId
+# contained in the DOM object.
+#
+# @param XmlSkuInfo An XML DOM object read from FPD file
+#
+# @retvel List A list of SkuId and SkuValue loaded from XmlFpd
+#
+def LoadSkuId(XmlSkuInfo):
+ XmlTag = "SkuInfo/UiSkuName"
+ SkuValue = XmlElement(XmlSkuInfo, XmlTag)
+
+ XmlTag = "SkuInfo/UiSkuName"
+ List = map(LoadSkuID, XmlList(XmlSkuInfo, XmlTag))
+ if List != []:
+ SkuID = List[0]
+ #SkuID = XmlAttribute(XmlSkuInfo, XmlTag)
+ List = []
+ List.append(SkuID)
+ List.append(SkuValue)
+ return List
+
+def LoadSkuID(XmlUiSkuName):
+ XmlTag = "SkuID"
+ SkuID = XmlAttribute(XmlUiSkuName, XmlTag)
+ return SkuID
+
+## Load a list of Platform SkuIds
+#
+# Read an input Platform XML DOM object and return a list of Platform SkuId
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PlatformSkuIds A platform SkuIds object loaded from XmlFpd
+#
+def LoadPlatformSkuInfos(XmlFpd):
+ PlatformSkuIds = SkuInfoListClass()
+
+ SkuInfoList = []
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/SkuInfo"
+ List = map(LoadSkuId, XmlList(XmlFpd, XmlTag))
+ SkuInfoList = List
+
+ XmlTag = "PlatformSurfaceArea/PlatformDefinitions/SkuInfo/UiSkuName"
+ Value = XmlElement(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/DynamicPcdBuildDefinitions/PcdBuildData/SkuInfo"
+ # here return a List
+ List = map(LoadPlatformSkuInfo, XmlList(XmlFpd, XmlTag))
+
+ for SkuInfo in List:
+ SkuId = SkuInfo[0]
+ Value = SkuInfo[1]
+
+ SkuInfoList.append(SkuInfo)
+
+ PlatformSkuIds.SkuInfoList = SkuInfoList
+
+ return PlatformSkuIds
+
+## Load Platform Module Build Option
+#
+# Read an input Platform XML DOM object and return Platform Module Build Option class object
+# contained in the DOM object.
+#
+# @param XmlModuleBuildOption An XML DOM object read from FPD file
+#
+# @retvel PlatformBuildOption A Platform Build Option object loaded from XmlFpd
+#
+def LoadModuleBuildOption(XmlModuleBuildOption):
+ PlatformBuildOption = PlatformBuildOptionClass()
+ PlatformBuildOption.UserDefinedAntTasks = {}
+
+ XmlTag = "BuildOptions/Options/Option"
+ PlatformBuildOption.Options = map(LoadBuildOption, XmlList(XmlModuleBuildOption, XmlTag))
+
+ PlatformBuildOption.UserExtensions = {}
+ PlatformBuildOption.FfsKeyList = {}
+ return PlatformBuildOption
+
+## Load Platform Module Extern
+#
+# Read an input Platform XML DOM object and return Platform Module Extern class object
+# contained in the DOM object.
+#
+# @param XmlModuleExtern An XML DOM object read from FPD file
+#
+# @retvel PlatformModuleExtern A Platform Module Extern object loaded from XmlFpd
+#
+def LoadModuleExtern(XmlModuleExtern):
+ PlatformModuleExtern = []
+
+ XmlTag = "Externs/PcdIsDriver"
+ PcdIsDriver = XmlElement(XmlModuleExtern, XmlTag)
+ PlatformModuleExtern.append(PcdIsDriver)
+
+ XmlTag = "Externs/Specification"
+ Specification = XmlElement(XmlModuleExtern, XmlTag)
+ PlatformModuleExtern.append(Specification)
+
+ XmlTag = "Externs/Extern"
+
+ return PlatformModuleExtern
+
+## Load Platform ModuleSaBuildOptions
+#
+# Read an input Platform XML DOM object and return Platform ModuleSaBuildOptions class object
+# contained in the DOM object.
+#
+# @param XmlModuleSaBuildOptions An XML DOM object read from FPD file
+#
+# @retvel PlatformBuildOptions A list of Platform ModuleSaBuildOption object loaded from XmlFpd
+#
+def LoadPlatformModuleSaBuildOption(XmlModuleSA):
+ PlatformModuleSaBuildOption = PlatformBuildOptionClasses()
+
+ XmlTag = "ModuleSA/ModuleSaBuildOptions/FvBinding"
+ PlatformModuleSaBuildOption.FvBinding = XmlElement(XmlModuleSA, XmlTag)
+
+ XmlTag = "ModuleSA/ModuleSaBuildOptions/FfsFormatKey"
+ PlatformModuleSaBuildOption.FfsFormatKey = XmlElement(XmlModuleSA, XmlTag)
+
+ XmlTag = "ModuleSA/ModuleSaBuildOptions/FfsFileNameGuid"
+ PlatformModuleSaBuildOption.FfsFileNameGuid = XmlElement(XmlModuleSA, XmlTag)
+
+ XmlTag = "ModuleSA/ModuleSaBuildOptions/Options/Option"
+ PlatformModuleSaBuildOption.BuildOptionList = map(LoadBuildOption, XmlList(XmlModuleSA, XmlTag))
+
+ return PlatformModuleSaBuildOption
+
+## Load a list of Platform Library Classes
+#
+# Read an input Platform XML DOM object and return a list of Library Classes
+# contained in the DOM object.
+#
+# @param XmlLibraryInstance An XML DOM object read from FPD file
+#
+# @retvel LibraryInstance A Library Instance loaded from XmlFpd
+#
+def LoadPlatformModuleLibraryInstance(XmlLibraryInstance):
+ LibraryInstance = []
+
+ XmlTag = "ModuleGuid"
+ ModuleGuid = XmlAttribute(XmlLibraryInstance, XmlTag)
+
+ ModulePath = gEdkIIWorkspaceGuidsInfo.ResolveModuleFilePath(ModuleGuid)
+ ModuleMSAFile = ModulePath.replace('.inf', '.msa')
+ WorkSpace = os.getenv('WORKSPACE')
+ ModuleMSAFileName = os.path.join(WorkSpace, ModuleMSAFile)
+ XmlMsa = XmlParseFile(ModuleMSAFileName)
+
+ XmlTag = "ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass/Keyword"
+ Name = XmlElement(XmlMsa, XmlTag)
+ LibraryInstance.append(Name)
+ LibraryInstance.append(ModulePath)
+
+ #XmlTag = "PackageGuid"
+ #PackageGuid = XmlAttribute(XmlLibraryInstance, XmlTag)
+ #LibraryInstance.append(PackageGuid)
+ return LibraryInstance
+
+## Load a Library Class
+#
+# Read an input Platform XML DOM object and return a library class object
+# contained in the DOM object.
+#
+# @param XmlLibraryClass An XML DOM object read from FPD file
+#
+# @retvel SupModuleList A Library Class Supported Module List object loaded from XmlFpd
+#
+def LoadLibraryClassSupModuleList(XmlLibraryClass):
+ XmlTag = "Usage"
+ Usage = XmlAttribute(XmlLibraryClass, XmlTag)
+ if Usage == "ALWAYS_PRODUCED":
+ XmlTag = "SupModuleList"
+ SupModuleList = XmlAttribute(XmlLibraryClass, XmlTag).split()
+ return SupModuleList
+
+## Load Platform Library Class
+#
+# Read an input Platform XML DOM object and return Platform module class object
+# contained in the DOM object.
+#
+# @param XmlLibraries An XML DOM object read from FPD file
+#
+# @retvel PlatformLibraryClass A Platform Library Class object loaded from XmlFpd
+#
+def LoadPlatformLibraryClass(XmlPlatformLibraryClass):
+ PlatformLibraryInstance = PlatformLibraryClass()
+
+ XmlTag = "ModuleGuid"
+ LibraryInstanceModuleGuid = XmlAttribute(XmlPlatformLibraryClass, XmlTag)
+
+ XmlTag = "PackageGuid"
+ LibraryInstancePackageGuid = XmlAttribute(XmlPlatformLibraryClass, XmlTag)
+
+ LibraryInstancePath = gEdkIIWorkspaceGuidsInfo.ResolveModuleFilePath(LibraryInstanceModuleGuid)
+
+ if LibraryInstancePath != "": # if LibraryInstancePath == "" that's because the module guid cannot be resolved
+ PlatformLibraryInstance.FilePath = LibraryInstancePath
+ # replace *.inf to *.msa
+ LibraryInstanceMSAName = LibraryInstancePath.replace('.inf', '.msa')
+ WorkSpace = os.getenv('WORKSPACE')
+ LibraryInstanceMSAPath = os.path.join(WorkSpace, LibraryInstanceMSAName)
+
+ PlatformLibraryInstance.FilePath = LibraryInstancePath
+
+ XmlMsa = XmlParseFile(LibraryInstanceMSAPath)
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/ModuleName"
+ PlatformLibraryInstance.Name = XmlElement(XmlMsa, XmlTag)
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/ModuleType"
+ PlatformLibraryInstance.ModuleType = XmlElement(XmlMsa, XmlTag)
+
+ if PlatformLibraryInstance.ModuleType != "BASE":
+ XmlTag = "ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass"
+ List = map(LoadLibraryClassSupModuleList, XmlList(XmlMsa, XmlTag))
+ if List != []:
+ PlatformLibraryInstance.SupModuleList = List[0]
+ XmlTag = "ModuleSurfaceArea/ModuleDefinitions/SupportedArchitectures"
+ PlatformLibraryInstance.SupArchList = XmlElement(XmlMsa, XmlTag).split()
+
+ PlatformLibraryInstance.ModuleGuid = LibraryInstanceModuleGuid
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/Version"
+ PlatformLibraryInstance.ModuleVersion = XmlElement(XmlMsa, XmlTag)
+
+ PlatformLibraryInstance.PackageGuid = LibraryInstancePackageGuid
+ PlatformLibraryInstance.PackageVersion = ''
+
+ return PlatformLibraryInstance
+
+## Load Platform Library Classes
+#
+# Read an input Platform XML DOM object and return Platform module class object
+# contained in the DOM object.
+#
+# @param XmlLibraries An XML DOM object read from FPD file
+#
+# @retvel PlatformLibraryClasses A list of Platform Library Class object loaded from XmlFpd
+#
+def LoadPlatformLibraryClasses(XmlFpd):
+ PlatformLibraryInstances = PlatformLibraryClasses()
+ PlatformLibraryInstances.LibraryList = []
+
+ List = []
+ XmlTag = "PlatformSurfaceArea/FrameworkModules/ModuleSA/Libraries/Instance"
+ List = map(LoadPlatformLibraryClass, XmlList(XmlFpd, XmlTag))
+ #List.sort()
+ if List == []:
+ print "Error"
+ else:
+ PlatformLibraryInstances.LibraryList = List
+
+ return PlatformLibraryInstances
+
+## Load Platform module
+#
+# Read an input Platform XML DOM object and return Platform module class object
+# contained in the DOM object.
+#
+# @param XmlModuleSA An XML DOM object read from FPD file
+#
+# @retvel PlatformModule A Platform module object loaded from XmlFpd
+#
+def LoadModuleSA(XmlModuleSA):
+ PlatformModule = PlatformModuleClass()
+
+ # three parts: Libraries instances, PcdBuildDefinition, ModuleSaBuildOptions
+ XmlTag = "ModuleSA/Libraries/Instance"
+
+ PlatformModule.LibraryClasses = map(LoadPlatformModuleLibraryInstance, XmlList(XmlModuleSA, XmlTag))
+
+ XmlTag = "ModuleSA/PcdBuildDefinition/PcdData"
+ PlatformModule.PcdBuildDefinitions = map(LoadPlatformPcdData, XmlList(XmlModuleSA, XmlTag))
+
+ XmlTag = "ModuleSA/ModuleSaBuildOptions"
+ PlatformModule.ModuleSaBuildOption = LoadPlatformModuleSaBuildOption(XmlModuleSA)
+
+ XmlTag = "ModuleSA/BuildOptions"
+ PlatformModule.BuildOptions = map(LoadModuleBuildOption, XmlList(XmlModuleSA, XmlTag)) #bugbug fix me
+
+ XmlTag = "ModuleSA/Externs"
+ PlatformModule.Externs = map(LoadModuleExtern, XmlList(XmlModuleSA, XmlTag)) #bugbug fix me
+
+ XmlTag = "SupArchList"
+ PlatformModule.SupArchList = XmlAttribute(XmlModuleSA, XmlTag).split()
+
+ # the package guid which the module depends on, do not care for now
+ XmlTag = "PackageGuid"
+ PlatformModule.PackageGuid = XmlAttribute(XmlModuleSA, XmlTag)
+
+ # the module guid, use this guid to get the module *.msa file and convert it to *.inf file with path
+ XmlTag = "ModuleGuid"
+ PlatformModule.ModuleGuid = XmlAttribute(XmlModuleSA, XmlTag)
+ # use this guid to find the *.msa file path or FilePath $(WORKSPACE)/EdkModulePkg/Core/Dxe/DxeMain.msa
+ # then convert $(WORKSPACE)/EdkModulePkg/Core/Dxe/DxeMain.msa to $(WORKSPACE)/EdkModulePkg/Core/Dxe/DxeMain.inf, it's FilePath
+ PlatformModulePath = gEdkIIWorkspaceGuidsInfo.ResolveModuleFilePath(PlatformModule.ModuleGuid)
+
+ PlatformModule.FilePath = PlatformModulePath # *.inf file path
+ # *.inf back to *.msa
+ ModuleMSAFileName = PlatformModulePath.replace('.inf', '.msa')
+ WorkSpace = os.getenv('WORKSPACE')
+ ModuleMSAFileName = os.path.join(WorkSpace, ModuleMSAFileName)
+ # Open this module
+ #ModuleMSA = open(ModuleMSAFileName, "r")
+ XmlMsa = XmlParseFile(ModuleMSAFileName)
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/ModuleName"
+ PlatformModule.Name = XmlElement(XmlMsa, XmlTag) # ModuleName
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/ModuleType"
+ PlatformModule.ModuleType = XmlElement(XmlMsa, XmlTag)
+
+ # IA32, X64, IPF and EBC which the module support arch
+ #XmlTag = "ModuleSurfaceArea/ModuleDefinitions/SupportedArchitectures"
+ #PlatformModule.SupArchList = XmlElement(XmlMsa, XmlTag).split()
+
+ #XmlTag = "ModuleSurfaceArea/MsaHeader/"
+ PlatformModule.Type = '' #LIBRARY | LIBRARY_CLASS | MODULE, used by dsc. New in DSC spec
+
+ PlatformModule.ExecFilePath = '' # New in DSC spec
+
+ XmlTag = "ModuleSurfaceArea/MsaHeader/Specification"
+ PlatformModule.Specifications = XmlElement(XmlMsa, XmlTag).split()
+
+ return PlatformModule
+
+## Load Platform modules
+#
+# Read an input Platform XML DOM object and return a list of Platform modules class object
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PlatformModules A list of Platform modules object loaded from XmlFpd
+#
+def LoadPlatformModules(XmlFpd):
+ PlatformModules = PlatformModuleClasses()
+
+ XmlTag = "PlatformSurfaceArea/FrameworkModules/ModuleSA"
+ PlatformModules.ModuleList = map(LoadModuleSA, XmlList(XmlFpd, XmlTag))
+
+ return PlatformModules
+
+## Load Platform Flash Definition File
+#
+# Read an input Platform XML DOM object and return Platform Flash Definition File class object
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+# @param FpdFileName The file path of FPD File
+#
+# @retvel PlatformFlashDefinitionFile A new Platform Flash Definition File object loaded from XmlFpd
+#
+def LoadPlatformFlashDefinitionFile(XmlFpd, FpdFileName):
+ PlatformFlashDefinitionFile = PlatformFlashDefinitionFileClass()
+
+ XmlTag = "PlatformSurfaceArea/Flash/FlashDefinitionFile"
+ PlatformFlashDefinitionFile.FilePath = XmlElement(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/Flash/FlashDefinitionFile/Id"
+ PlatformFlashDefinitionFile.Id = XmlAttribute(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/Flash/FlashDefinitionFile/UiName"
+ PlatformFlashDefinitionFile.UiName = XmlAttribute(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/Flash/FlashDefinitionFile/Preferred"
+ PlatformFlashDefinitionFile.Preferred = XmlAttribute(XmlFpd, XmlTag)
+
+ return PlatformFlashDefinitionFile
+
+## Load Platform User Defined Ant Tasks
+#
+# Read an input Platform XML DOM object and return platform
+# User Defined Ant Tasks contained in the DOM object.
+#
+# @param XmlUserDefinedAntTasks An XML DOM object read from FPD file
+#
+# @retvel AntTask An Ant Task loaded from XmlFpd
+#
+def LoadUserDefinedAntTasks(XmlFpd):
+ Dict = {}
+ AntTask = PlatformAntTaskClass()
+
+ XmlTag = "PlatformSurfaceArea/BuildOptions/UserDefinedAntTasks/AntTask/Id"
+ AntTask.Id = XmlAttribute(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/BuildOptions/UserDefinedAntTasks/AntTask/AntCmdOptions"
+ AntTask.AntCmdOptions = XmlElement(XmlFpd, XmlTag)
+
+ XmlTag = "PlatformSurfaceArea/BuildOptions/UserDefinedAntTasks/AntTask/Filename"
+ AntTask.FilePath = XmlElement(XmlFpd, XmlTag)
+
+ Dict[AntTask.Id] = AntTask
+ return Dict
+
+## Load Platform Build Options
+#
+# Read an input Platform XML DOM object and return a list of platform
+# Build Option contained in the DOM object.
+#
+# @param XmlBuildOptions An XML DOM object read from FPD file
+#
+# @retvel PlatformBuildOptions A list of platform Build Options loaded from XmlFpd
+#
+def LoadBuildOptions(XmlBuildOptions):
+ XmlTag = "Option"
+ return map(LoadBuildOption, XmlList(XmlBuildOptions, XmlTag)) # LoadBuildOption is a method in MigrationUtilities.py
+
+## Load Platform Build Option
+#
+# Read an input Platform XML DOM object and return a Build Option
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PlatformBuildOption A Build Options loaded from XmlFpd
+#
+def LoadPlatformBuildOption(XmlBuildOptions):
+ PlatformBuildOption = PlatformBuildOptionClass()
+
+ # handle UserDefinedAntTasks
+ XmlTag = "BuildOptions/UserDefinedAntTasks/AntTask"
+ PlatformBuildOption.UserDefinedAntTasks = LoadUserDefinedAntTasks(XmlTag)
+
+ # handle Options
+ XmlTag = "BuildOptions/Options/Option"
+ PlatformBuildOption.Options = map(LoadBuildOption, XmlList(XmlBuildOptions, XmlTag))
+
+ # handle UserExtensions
+ XmlTag = "BuildOptions/UserExtensions"
+ PlatformBuildOption.UserExtensions = LoadUserExtensions(XmlTag) # from MigrationUtilities.py LoadUserExtensions
+
+ # handle Ffs
+ XmlTag = "BuildOptions/Ffs/FfsKey"
+ PlatformBuildOption.FfsKeyList = map(LoadPlatformFfs, XmlList(XmlBuildOptions, XmlTag))
+
+ return PlatformBuildOption
+
+## Load Platform Ffs Dictionary
+#
+# Read an input Platform XML DOM object and return a platform Ffs Dictionary
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel Dict A platform Ffs Dict loaded from XmlFpd
+#
+def LoadPlatformFfsDict(XmlFpd):
+ Dict = {}
+ XmlTag = "PlatformSurfaceArea/BuildOptions/Ffs"
+ List = map(LoadPlatformFfs, XmlList(XmlFpd, XmlTag))
+ if List != []:
+ for Ffs in List:
+ Dict[Ffs.Key] = Ffs
+ return Dict
+
+## Load Platform Ffs Section
+#
+# Read an input Platform XML DOM object and return a platform Ffs Section
+# contained in the DOM object.
+#
+# @param XmlFfs An XML DOM object read from FPD file
+#
+# @retvel PlatformFfsSection A platform Ffs Section loaded from XmlFpd
+#
+def LoadPlatformFfsSection(XmlFfsSection):
+ PlatformFfsSection = PlatformFfsSectionClass()
+
+ XmlTag = ""
+ PlatformFfsSection.BindingOrder = ''
+
+ XmlTag = ""
+ PlatformFfsSection.Compressible = ''
+
+ XmlTag = "SectionType"
+ PlatformFfsSection.SectionType = XmlAttribute(XmlFfsSection, XmlTag)
+
+ XmlTag = ""
+ PlatformFfsSection.EncapsulationType = ''
+
+ XmlTag = ""
+ PlatformFfsSection.ToolName = ''
+
+ XmlTag = ""
+ PlatformFfsSection.Filenames = []
+
+ XmlTag = ""
+ PlatformFfsSection.Args = ''
+
+ XmlTag = ""
+ PlatformFfsSection.OutFile = ''
+
+ XmlTag = ""
+ PlatformFfsSection.OutputFileExtension = ''
+
+ XmlTag = ""
+ PlatformFfsSection.ToolNameElement = ''
+
+ return PlatformFfsSection
+
+## Load Platform Ffs Sections
+#
+# Read an input Platform XML DOM object and return a platform Ffs Sections
+# contained in the DOM object.
+#
+# @param XmlFfs An XML DOM object read from FPD file
+#
+# @retvel PlatformFfsSections A platform Ffs Sections loaded from XmlFpd
+#
+def LoadFfsSections():
+ PlatformFfsSections = PlatformFfsSectionsClass()
+ PlatformFfsSections.BindingOrder = ''
+ PlatformFfsSections.Compressible = ''
+ PlatformFfsSections.SectionType = ''
+ PlatformFfsSections.EncapsulationType = ''
+ PlatformFfsSections.ToolName = ''
+ PlatformFfsSections.Section = []
+ PlatformFfsSections.Sections = []
+
+ return PlatformFfsSections
+
+## Load Platform Ffs Sections
+#
+# Read an input Platform XML DOM object and return a platform Ffs Sections
+# contained in the DOM object.
+#
+# @param XmlFfs An XML DOM object read from FPD file
+#
+# @retvel PlatformFfsSections A platform Ffs Sections loaded from XmlFpd
+#
+def LoadPlatformFfsSections(XmlFfsSections):
+ PlatformFfsSections = PlatformFfsSectionsClass()
+
+ XmlTag = ""
+ PlatformFfsSections.BindingOrder = ''
+
+ XmlTag = ""
+ Compressible = ''
+
+ XmlTag = ""
+ SectionType = ''
+
+ XmlTag = "EncapsulationType"
+ EncapsulationType = XmlAttribute(XmlFfsSections, XmlTag)
+
+ XmlTag = ""
+ ToolName = ''
+
+ XmlTag = "Sections/Section"
+ Section = [] #[ PlatformFfsSectionClass, ... ]
+ Section = map(LoadPlatformFfsSection, XmlList(XmlFfsSections, XmlTag))
+
+
+ XmlTag = "Sections/Sections"
+ Sections = map(LoadFfsSections, XmlList(XmlFfsSections, XmlTag)) #[ PlatformFfsSectionsClass, ...]
+
+ return PlatformFfsSections
+
+## Load Platform Ffs Attribute
+#
+# Read an input Platform XML DOM object and return a platform Ffs Attribute
+# contained in the DOM object.
+#
+# @param XmlFfs An XML DOM object read from FPD file
+#
+# @retvel List A platform Ffs Attribute loaded from XmlFpd
+#
+def LoadFfsAttribute(XmlFfs):
+ List = []
+ XmlTag = "Ffs/Attribute"
+ for XmlAttr in XmlList(XmlFfs, XmlTag):
+ XmlTag = "Name"
+ Name = XmlAttribute(XmlAttr, XmlTag)
+ XmlTag = "Value"
+ Value = XmlAttribute(XmlAttr, XmlTag)
+ List.append([Name,Value])
+ return List
+
+## Load a list of Platform Build Options
+#
+# Read an input Platform XML DOM object and return a list of Build Options
+# contained in the DOM object.
+#
+# @param XmlFfs An XML DOM object read from FPD file
+#
+# @retvel PlatformFfsKey A platform Ffs key loaded from XmlFpd
+#
+def LoadPlatformFfs(XmlFfs):
+ PlatformFfs = PlatformFfsClass()
+
+ PlatformFfs.Attribute = {}
+ Dict = {}
+
+ List = LoadFfsAttribute(XmlFfs)
+
+ XmlTag = "Ffs/Sections/Sections"
+ PlatformFfs.Sections = map(LoadPlatformFfsSections, XmlList(XmlFfs, XmlTag)) #[PlatformFfsSectionsClass, ...]
+
+ for Item in List:
+ Name = Item[0]
+ Value = Item[1]
+ for Item in PlatformFfs.Sections:
+ Dict[(Name, Item)] = Value
+ PlatformFfs.Attribute = Dict
+
+ XmlTag = "Ffs/FfsKey"
+ PlatformFfs.Key = XmlAttribute(XmlFfs, XmlTag)
+
+ return PlatformFfs
+
+## Load a list of Platform Build Options
+#
+# Read an input Platform XML DOM object and return a list of Build Options
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PlatformBuildOptions A list of Build Options loaded from XmlFpd
+#
+def LoadPlatformBuildOptions(XmlFpd):
+ PlatformBuildOptions = PlatformBuildOptionClass()
+
+ PlatformBuildOptions.UserDefinedAntTasks = LoadUserDefinedAntTasks(XmlFpd)
+
+ XmlTag = "PlatformSurfaceArea/BuildOptions/Options/Option"
+ PlatformBuildOptions.Options = map(LoadBuildOption, XmlList(XmlFpd, XmlTag))
+
+ PlatformBuildOptions.UserExtensions = LoadPlatformUserExtension(XmlFpd)
+
+ PlatformBuildOptions.FfsKeyList = LoadPlatformFfsDict(XmlFpd)
+
+ return PlatformBuildOptions
+
+## Load Platform Pcd Data
+#
+# Read an input Platform XML DOM object and return Platform module class object
+# contained in the DOM object.
+#
+# @param XmlPcd An XML DOM object read from FPD file
+#
+# @retvel PlatformPcdData A Platform Pcd object loaded from XmlFpd
+#
+def LoadPlatformPcdData(XmlPcdData):
+ PcdData = PcdClass() # defined in CommonDataClass.CommonClass.py
+
+ XmlTag = "ItemType"
+ PcdData.ItemType = XmlAttribute(XmlPcdData, XmlTag) #DYNAMIC
+
+ XmlTag = "PcdData/C_Name"
+ PcdData.C_NAME = XmlElement(XmlPcdData, XmlTag)
+
+ XmlTag = "PcdData/Token"
+ PcdData.Token = XmlElement(XmlPcdData, XmlTag)
+
+ XmlTag = "PcdData/TokenSpaceGuidCName"
+ PcdData.TokenSpaceGuidCName = XmlElement(XmlPcdData, XmlTag)
+
+ XmlTag = "PcdData/DatumType"
+ PcdData.DatumType = XmlElement(XmlPcdData, XmlTag)
+
+ XmlTag = "PcdData/MaxDatumSize"
+ PcdData.MaxDatumSize = XmlElement(XmlPcdData, XmlTag)
+
+ XmlTag = "PcdData/Value"
+ PcdData.Value = XmlElement(XmlPcdData, XmlTag)
+
+ return PcdData
+
+## Load a Platform Pcd Build Data
+#
+# Read an input Platform XML DOM object and return a list of Pcd Dynamic
+# contained in the DOM object.
+#
+# @param XmlPcdBuildData An XML DOM object read from FPD file
+#
+# @retvel PcdBuildData A Platform Pcd Build Data loaded from XmlFpd
+#
+def LoadPlatformPcdBuildData(XmlPcdBuildData):
+ PcdBuildData = PcdClass() # defined in CommonDataClass.CommonClass.py
+
+ XmlTag = "ItemType"
+ PcdBuildData.ItemType = XmlAttribute(XmlPcdBuildData, XmlTag) #DYNAMIC
+
+ XmlTag = "PcdBuildData/C_Name"
+ PcdBuildData.C_NAME = XmlElement(XmlPcdBuildData, XmlTag)
+
+ XmlTag = "PcdBuildData/Token"
+ PcdBuildData.Token = XmlElement(XmlPcdBuildData, XmlTag)
+
+ XmlTag = "PcdBuildData/TokenSpaceGuidCName"
+ PcdBuildData.TokenSpaceGuidCName = XmlElement(XmlPcdBuildData, XmlTag)
+
+ XmlTag = "PcdBuildData/DatumType"
+ PcdBuildData.DatumType = XmlElement(XmlPcdBuildData, XmlTag)
+
+ XmlTag = "PcdBuildData/MaxDatumSize"
+ PcdBuildData.MaxDatumSize = XmlElement(XmlPcdBuildData, XmlTag)
+
+ #XmlTag = "PcdBuildData/Value"
+ #PcdBuildData.Value = XmlElement(XmlPcdBuildData, XmlTag)
+
+ return PcdBuildData
+
+## Load a list of Platform Pcd Dynamic
+#
+# Read an input Platform XML DOM object and return a list of Pcd Dynamic
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PcdDynamic A list of Pcd Dynamic loaded from XmlFpd
+#
+def LoadDynamicPcdBuildDefinitions(XmlFpd):
+ DynamicPcdBuildDefinitions = []
+ XmlTag = "PlatformSurfaceArea/DynamicPcdBuildDefinitions/PcdBuildData"
+ return map(LoadPlatformPcdBuildData, XmlList(XmlFpd, XmlTag))
+
+## Load a Platform NameValue object
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlNameValue An XML DOM object read from FPD file
+#
+# @retvel NameValue A Platform NameValue object
+#
+def LoadNameValue(XmlNameValue):
+ NameValue = []
+
+ XmlTag = "Name"
+ Name = XmlAttribute(XmlNameValue, XmlTag)
+ NameValue.append(Name)
+
+ XmlTag = "Value"
+ Value = XmlAttribute(XmlNameValue, XmlTag)
+ NameValue.append(Value)
+
+ return NameValue
+
+## Load a Platform Fv Image Name object
+#
+# Read an input Platform XML DOM object and return a platform Fv Image
+# Name contained in the DOM object.
+#
+# @param XmlFvImageNames An XML DOM object read from FPD file
+#
+# @retvel FvImageNames A Platform Fv Image Name object
+#
+def LoadFvImageNames(XmlFvImageNames):
+ XmlTag = "FvImageNames"
+ FvImageNames = XmlElement(XmlFvImageNames, XmlTag)
+ return FvImageNames
+
+## Load a Platform Fv Image option object
+#
+# Read an input Platform XML DOM object and return a platform Fv Image
+# Option contained in the DOM object.
+#
+# @param XmlFvImageOptions An XML DOM object read from FPD file
+#
+# @retvel PlatformFvImageOption A Platform Fv Image Option object
+#
+def LoadFvImageOptions(XmlFvImageOptions):
+ PlatformFvImageOption = PlatformFvImageOptionClass()
+
+ XmlTag = ""
+ PlatformFvImageOption.FvImageOptionName = ''
+
+ XmlTag = ""
+ PlatformFvImageOption.FvImageOptionValues = []
+
+ XmlTag = "FvImageOptions/NameValue"
+ List = map(LoadNameValue, XmlList(XmlFvImageOptions, XmlTag))
+
+ return PlatformFvImageOption
+
+## Load a Platform Fv Image object
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlFvImage An XML DOM object read from Fpd file
+#
+# @retvel PlatformFvImage A Platform Fv Image object
+#
+def LoadPlatformFvImage(XmlFvImage):
+ PlatformFvImage = PlatformFvImageClass()
+
+ XmlTag = "Name"
+ PlatformFvImage.Name = XmlAttribute(XmlFvImage, XmlTag)
+
+ XmlTag = "Value"
+ PlatformFvImage.Value = XmlAttribute(XmlFvImage, XmlTag)
+
+ XmlTag = "Type"
+ PlatformFvImage.Type = XmlAttribute(XmlFvImage, XmlTag)
+
+ XmlTag = "FvImage/FvImageNames"
+ PlatformFvImage.FvImageNames = map(LoadFvImageNames, XmlList(XmlFvImage, XmlTag))
+
+ XmlTag = "FvImage/FvImageOptions"
+ PlatformFvImage.FvImageOptions = map(LoadFvImageOptions, XmlList(XmlFvImage, XmlTag))
+
+ return PlatformFvImage
+
+## Load a Platform fdf object
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlFvImages An XML DOM object read from FPD file
+#
+# @retvel PlatformFdf A Platform fdf object
+#
+def LoadPlatformFvImages(XmlFvImages):
+ List = []
+
+ XmlTag = "FvImages/NameValue"
+ NameValues = map(LoadNameValue, XmlList(XmlFvImages, XmlTag))
+ List.append(NameValues)
+
+ XmlTag = "FvImages/FvImage"
+ FvImages = map(LoadPlatformFvImage, XmlList(XmlFvImages, XmlTag))
+ List.append(FvImages)
+
+ XmlTag = "FvImages/FvImageName"
+ FvImageNames = map(LoadPlatformFvImageName, XmlList(XmlFvImages, XmlTag))
+ List.append(FvImageNames)
+
+ return List
+
+## Load a Platform Fv Image Name object
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlFvImageName An XML DOM object read from FPD file
+#
+# @retvel PlatformFvImageName A Platform Fv Image Name object
+#
+def LoadPlatformFvImageName(XmlFvImageName):
+ PlatformFvImageName = PlatformFvImageNameClass()
+
+ XmlTag = "Name"
+ PlatformFvImageName.Name = XmlAttribute(XmlFvImageName, XmlTag)
+
+ XmlTag = "Type"
+ PlatformFvImageName.Type = XmlAttribute(XmlFvImageName, XmlTag)
+
+ XmlTag = "FvImageOptions"
+ PlatformFvImageName.FvImageOptions = map(LoadFvImageOptions, XmlList(XmlFvImageName, XmlTag))
+
+ return PlatformFvImageName
+
+## Load a list of Platform fdf objects
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel PlatformFdfs A list of Platform fdf object
+#
+def LoadPlatformFdfs(XmlFpd):
+ PlatformFvImages = PlatformFvImagesClass()
+
+ XmlTag = "PlatformSurfaceArea/Flash/FvImages"
+ PlatformFvImages.FvImages = map(LoadPlatformFvImages, XmlList(XmlFpd, XmlTag))
+
+ return PlatformFvImages
+
+## Load a Platform User Extensions
+#
+# Read an input Platform XML DOM object and return an User Extension
+# contained in the DOM object.
+#
+# @param XmlUserExtension An XML DOM object read from FPD file
+#
+# @retvel PlatformUserExtensions A platform User Extension loaded from XmlFpd
+#
+def LoadPlatformUserExtension(XmlFpd):
+ Dict = {}
+
+ PlatformUserExtensions = UserExtensionsClass()
+
+ XmlTag = "PlatformSurfaceArea/BuildOptions/UserExtensions"
+ List = map(LoadUserExtensions, XmlList(XmlFpd, XmlTag))
+ if List != []:
+ for Item in List:
+ UserID = Item.UserID
+ Identifier = Item.Identifier
+ Dict[(UserID, Identifier)] = Item
+ #XmlTag = "PlatformSurfaceArea/BuildOptions/UserExtensions/UserID"
+ #PlatformUserExtensions.UserID = XmlAttribute(XmlFpd, XmlTag)
+
+ #XmlTag = "PlatformSurfaceArea/BuildOptions/UserExtensions/Identifier"
+ #PlatformUserExtensions.Identifier = XmlAttribute(XmlFpd, XmlTag)
+
+ #PlatformUserExtensions.Content = XmlElementData(XmlFpd)
+ #Dict[(PlatformUserExtensions.UserID,PlatformUserExtensions.Identifier)] = PlatformUserExtensions
+ #return PlatformUserExtensions
+ return Dict
+
+## Load a list of Platform User Extensions
+#
+# Read an input Platform XML DOM object and return a list of User Extensions
+# contained in the DOM object.
+#
+# @param XmlFpd An XML DOM object read from FPD file
+#
+# @retvel UserExtensions A list of platform User Extensions loaded from XmlFpd
+#
+def LoadPlatformUserExtensions(XmlFpd):
+ XmlTag = "PlatformSurfaceArea/UserExtensions"
+ return map(LoadUserExtensions, XmlList(XmlFpd, XmlTag)) # from MigrationUtilities.py LoadUserExtensions
+
+## Load a new Platform class object
+#
+# Read an input FPD File and return a new Platform class Object.
+#
+# @param FpdFileName An XML DOM object read from FPD file
+#
+# @retvel Platform A new Platform class object loaded from FPD File
+#
+def LoadFpd(FpdFileName):
+ XmlFpd = XmlParseFile(FpdFileName)
+ EdkLogger.verbose("Load FPD File: %s" % FpdFileName)
+
+ Platform = PlatformClass()
+ Platform.Header = LoadPlatformHeader(XmlFpd, FpdFileName)
+ Platform.SkuInfos = LoadPlatformSkuInfos(XmlFpd)
+ Platform.Libraries = [] #New in dsc spec, do not handle for now
+ Platform.LibraryClasses = LoadPlatformLibraryClasses(XmlFpd)
+ Platform.Modules = LoadPlatformModules(XmlFpd)
+ Platform.FlashDefinitionFile = LoadPlatformFlashDefinitionFile(XmlFpd, FpdFileName)
+ Platform.BuildOptions = LoadPlatformBuildOptions(XmlFpd)
+ Platform.DynamicPcdBuildDefinitions = LoadDynamicPcdBuildDefinitions(XmlFpd)
+ Platform.Fdf = LoadPlatformFdfs(XmlFpd)
+ Platform.UserExtensions = LoadPlatformUserExtensions(XmlFpd)
+
+ return Platform
+
+# This acts like the main() function for the script, unless it is 'import'ed
+# into another script.
+if __name__ == '__main__':
+ pass
\ No newline at end of file diff --git a/BaseTools/Source/Python/fpd2dsc/MigrationUtilities.py b/BaseTools/Source/Python/fpd2dsc/MigrationUtilities.py new file mode 100644 index 0000000000..d3c724832c --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/MigrationUtilities.py @@ -0,0 +1,563 @@ +## @file
+# Contains several utilitities shared by migration tools.
+#
+# Copyright (c) 2007, 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
+#
+import os
+import re
+import EdkLogger
+from optparse import OptionParser
+from Common.BuildToolError import *
+from XmlRoutines import *
+from CommonDataClass.CommonClass import *
+
+## Set all fields of CommonClass object.
+#
+# Set all attributes of CommonClass object from XML Dom object of XmlCommon.
+#
+# @param Common The destine CommonClass object.
+# @param XmlCommon The source XML Dom object.
+#
+def SetCommon(Common, XmlCommon):
+ XmlTag = "Usage"
+ Common.Usage = XmlAttribute(XmlCommon, XmlTag).split()
+
+ XmlTag = "FeatureFlag"
+ Common.FeatureFlag = XmlAttribute(XmlCommon, XmlTag)
+
+ XmlTag = "SupArchList"
+ Common.SupArchList = XmlAttribute(XmlCommon, XmlTag).split()
+
+ XmlTag = XmlNodeName(XmlCommon) + "/" + "HelpText"
+ Common.HelpText = XmlElement(XmlCommon, XmlTag)
+
+
+## Set some fields of CommonHeaderClass object.
+#
+# Set Name, Guid, FileName and FullPath fields of CommonHeaderClass object from
+# XML Dom object of XmlCommonHeader, NameTag and FileName.
+#
+# @param CommonHeader The destine CommonClass object.
+# @param XmlCommonHeader The source XML Dom object.
+# @param NameTag The name tag in XML Dom object.
+# @param FileName The file name of the XML file.
+#
+def SetIdentification(CommonHeader, XmlCommonHeader, NameTag, FileName):
+ XmlParentTag = XmlNodeName(XmlCommonHeader)
+
+ XmlTag = XmlParentTag + "/" + NameTag
+ CommonHeader.Name = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParentTag + "/" + "GuidValue"
+ CommonHeader.Guid = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParentTag + "/" + "Version"
+ CommonHeader.Version = XmlElement(XmlCommonHeader, XmlTag)
+
+ CommonHeader.FileName = os.path.basename(FileName)
+ CommonHeader.FullPath = os.path.abspath(FileName)
+
+
+## Regular expression to match specification and value.
+mReSpecification = re.compile(r"(?P<Specification>\w+)\s+(?P<Value>\w*)")
+
+## Add specification to specification dictionary.
+#
+# Abstract specification name, value pair from Specification String and add them
+# to specification dictionary.
+#
+# @param SpecificationDict The destine Specification dictionary.
+# @param SpecificationString The source Specification String from which the
+# specification name and value pair is abstracted.
+#
+def AddToSpecificationDict(SpecificationDict, SpecificationString):
+ """Abstract specification name, value pair from Specification String"""
+ for SpecificationMatch in mReSpecification.finditer(SpecificationString):
+ Specification = SpecificationMatch.group("Specification")
+ Value = SpecificationMatch.group("Value")
+ SpecificationDict[Specification] = Value
+
+## Set all fields of CommonHeaderClass object.
+#
+# Set all attributes of CommonHeaderClass object from XML Dom object of
+# XmlCommonHeader, NameTag and FileName.
+#
+# @param CommonHeader The destine CommonClass object.
+# @param XmlCommonHeader The source XML Dom object.
+# @param NameTag The name tag in XML Dom object.
+# @param FileName The file name of the XML file.
+#
+def SetCommonHeader(CommonHeader, XmlCommonHeader):
+ """Set all attributes of CommonHeaderClass object from XmlCommonHeader"""
+ XmlParent = XmlNodeName(XmlCommonHeader)
+
+ XmlTag = XmlParent + "/" + "Abstract"
+ CommonHeader.Abstract = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParent + "/" + "Description"
+ CommonHeader.Description = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParent + "/" + "Copyright"
+ CommonHeader.Copyright = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParent + "/" + "License"
+ CommonHeader.License = XmlElement(XmlCommonHeader, XmlTag)
+
+ XmlTag = XmlParent + "/" + "Specification"
+ Specification = XmlElement(XmlCommonHeader, XmlTag)
+
+ AddToSpecificationDict(CommonHeader.Specification, Specification)
+
+ XmlTag = XmlParent + "/" + "ModuleType"
+ CommonHeader.ModuleType = XmlElement(XmlCommonHeader, XmlTag)
+
+
+## Load a new Cloned Record class object.
+#
+# Read an input XML ClonedRecord DOM object and return an object of Cloned Record
+# contained in the DOM object.
+#
+# @param XmlCloned A child XML DOM object in a Common XML DOM.
+#
+# @retvel ClonedRecord A new Cloned Record object created by XmlCloned.
+#
+def LoadClonedRecord(XmlCloned):
+ ClonedRecord = ClonedRecordClass()
+
+ XmlTag = "Id"
+ ClonedRecord.Id = int(XmlAttribute(XmlCloned, XmlTag))
+
+ XmlTag = "FarGuid"
+ ClonedRecord.FarGuid = XmlAttribute(XmlCloned, XmlTag)
+
+ XmlTag = "Cloned/PackageGuid"
+ ClonedRecord.PackageGuid = XmlElement(XmlCloned, XmlTag)
+
+ XmlTag = "Cloned/PackageVersion"
+ ClonedRecord.PackageVersion = XmlElement(XmlCloned, XmlTag)
+
+ XmlTag = "Cloned/ModuleGuid"
+ ClonedRecord.ModuleGuid = XmlElement(XmlCloned, XmlTag)
+
+ XmlTag = "Cloned/ModuleVersion"
+ ClonedRecord.ModuleVersion = XmlElement(XmlCloned, XmlTag)
+
+ return ClonedRecord
+
+
+## Load a new Guid/Protocol/Ppi common class object.
+#
+# Read an input XML Guid/Protocol/Ppi DOM object and return an object of
+# Guid/Protocol/Ppi contained in the DOM object.
+#
+# @param XmlGuidProtocolPpiCommon A child XML DOM object in a Common XML DOM.
+#
+# @retvel GuidProtocolPpiCommon A new GuidProtocolPpiCommon class object
+# created by XmlGuidProtocolPpiCommon.
+#
+def LoadGuidProtocolPpiCommon(XmlGuidProtocolPpiCommon):
+ GuidProtocolPpiCommon = GuidProtocolPpiCommonClass()
+
+ XmlTag = "Name"
+ GuidProtocolPpiCommon.Name = XmlAttribute(XmlGuidProtocolPpiCommon, XmlTag)
+
+ XmlParent = XmlNodeName(XmlGuidProtocolPpiCommon)
+ if XmlParent == "Entry":
+ XmlTag = "%s/C_Name" % XmlParent
+ elif XmlParent == "GuidCNames":
+ XmlTag = "%s/GuidCName" % XmlParent
+ else:
+ XmlTag = "%s/%sCName" % (XmlParent, XmlParent)
+
+ GuidProtocolPpiCommon.CName = XmlElement(XmlGuidProtocolPpiCommon, XmlTag)
+
+ XmlTag = XmlParent + "/" + "GuidValue"
+ GuidProtocolPpiCommon.Guid = XmlElement(XmlGuidProtocolPpiCommon, XmlTag)
+
+ if XmlParent.endswith("Notify"):
+ GuidProtocolPpiCommon.Notify = True
+
+ XmlTag = "GuidTypeList"
+ GuidTypes = XmlAttribute(XmlGuidProtocolPpiCommon, XmlTag)
+ GuidProtocolPpiCommon.GuidTypeList = GuidTypes.split()
+
+ XmlTag = "SupModuleList"
+ SupModules = XmlAttribute(XmlGuidProtocolPpiCommon, XmlTag)
+ GuidProtocolPpiCommon.SupModuleList = SupModules.split()
+
+ SetCommon(GuidProtocolPpiCommon, XmlGuidProtocolPpiCommon)
+
+ return GuidProtocolPpiCommon
+
+
+## Load a new Pcd class object.
+#
+# Read an input XML Pcd DOM object and return an object of Pcd
+# contained in the DOM object.
+#
+# @param XmlPcd A child XML DOM object in a Common XML DOM.
+#
+# @retvel Pcd A new Pcd object created by XmlPcd.
+#
+def LoadPcd(XmlPcd):
+ """Return a new PcdClass object equivalent to XmlPcd"""
+ Pcd = PcdClass()
+
+ XmlTag = "PcdEntry/C_Name"
+ Pcd.CName = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/Token"
+ Pcd.Token = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/TokenSpaceGuidCName"
+ Pcd.TokenSpaceGuidCName = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/DatumType"
+ Pcd.DatumType = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/MaxDatumSize"
+ Pcd.MaxDatumSize = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/DefaultValue"
+ Pcd.DefaultValue = XmlElement(XmlPcd, XmlTag)
+
+ XmlTag = "PcdItemType"
+ Pcd.ItemType = XmlAttribute(XmlPcd, XmlTag)
+
+ XmlTag = "PcdEntry/ValidUsage"
+ Pcd.ValidUsage = XmlElement(XmlPcd, XmlTag).split()
+
+ XmlTag = "SupModuleList"
+ Pcd.SupModuleList = XmlAttribute(XmlPcd, XmlTag).split()
+
+ SetCommon(Pcd, XmlPcd)
+
+ return Pcd
+
+
+## Load a new LibraryClass class object.
+#
+# Read an input XML LibraryClass DOM object and return an object of LibraryClass
+# contained in the DOM object.
+#
+# @param XmlLibraryClass A child XML DOM object in a Common XML DOM.
+#
+# @retvel LibraryClass A new LibraryClass object created by XmlLibraryClass.
+#
+def LoadLibraryClass(XmlLibraryClass):
+ LibraryClass = LibraryClassClass()
+
+ XmlTag = "LibraryClass/Keyword"
+ LibraryClass.LibraryClass = XmlElement(XmlLibraryClass, XmlTag)
+ if LibraryClass.LibraryClass == "":
+ XmlTag = "Name"
+ LibraryClass.LibraryClass = XmlAttribute(XmlLibraryClass, XmlTag)
+
+ XmlTag = "LibraryClass/IncludeHeader"
+ LibraryClass.IncludeHeader = XmlElement(XmlLibraryClass, XmlTag)
+
+ XmlTag = "RecommendedInstanceVersion"
+ RecommendedInstanceVersion = XmlAttribute(XmlLibraryClass, XmlTag)
+ LibraryClass.RecommendedInstanceVersion = RecommendedInstanceVersion
+
+ XmlTag = "RecommendedInstanceGuid"
+ RecommendedInstanceGuid = XmlAttribute(XmlLibraryClass, XmlTag)
+ LibraryClass.RecommendedInstanceGuid = RecommendedInstanceGuid
+
+ XmlTag = "SupModuleList"
+ SupModules = XmlAttribute(XmlLibraryClass, XmlTag)
+ LibraryClass.SupModuleList = SupModules.split()
+
+ SetCommon(LibraryClass, XmlLibraryClass)
+
+ return LibraryClass
+
+
+## Load a new Build Option class object.
+#
+# Read an input XML BuildOption DOM object and return an object of Build Option
+# contained in the DOM object.
+#
+# @param XmlBuildOption A child XML DOM object in a Common XML DOM.
+#
+# @retvel BuildOption A new Build Option object created by XmlBuildOption.
+#
+def LoadBuildOption(XmlBuildOption):
+ """Return a new BuildOptionClass object equivalent to XmlBuildOption"""
+ BuildOption = BuildOptionClass()
+
+ BuildOption.Option = XmlElementData(XmlBuildOption)
+
+ XmlTag = "BuildTargets"
+ BuildOption.BuildTargetList = XmlAttribute(XmlBuildOption, XmlTag).split()
+
+ XmlTag = "ToolChainFamily"
+ BuildOption.ToolChainFamily = XmlAttribute(XmlBuildOption, XmlTag)
+
+ XmlTag = "TagName"
+ BuildOption.TagName = XmlAttribute(XmlBuildOption, XmlTag)
+
+ XmlTag = "ToolCode"
+ BuildOption.ToolCode = XmlAttribute(XmlBuildOption, XmlTag)
+
+ XmlTag = "SupArchList"
+ BuildOption.SupArchList = XmlAttribute(XmlBuildOption, XmlTag).split()
+
+ return BuildOption
+
+
+## Load a new User Extensions class object.
+#
+# Read an input XML UserExtensions DOM object and return an object of User
+# Extensions contained in the DOM object.
+#
+# @param XmlUserExtensions A child XML DOM object in a Common XML DOM.
+#
+# @retvel UserExtensions A new User Extensions object created by
+# XmlUserExtensions.
+#
+def LoadUserExtensions(XmlUserExtensions):
+ UserExtensions = UserExtensionsClass()
+
+ XmlTag = "UserId"
+ UserExtensions.UserID = XmlAttribute(XmlUserExtensions, XmlTag)
+
+ XmlTag = "Identifier"
+ UserExtensions.Identifier = XmlAttribute(XmlUserExtensions, XmlTag)
+
+ UserExtensions.Content = XmlElementData(XmlUserExtensions)
+
+ return UserExtensions
+
+
+## Store content to a text file object.
+#
+# Write some text file content to a text file object. The contents may echo
+# in screen in a verbose way.
+#
+# @param TextFile The text file object.
+# @param Content The string object to be written to a text file.
+#
+def StoreTextFile(TextFile, Content):
+ EdkLogger.verbose(Content)
+ TextFile.write(Content)
+
+
+## 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:
+ Item = Method(Object)
+ if Item == "":
+ continue
+ Item = " %s" % Item
+ Arches = Object.SupArchList
+ if len(Arches) == 0:
+ 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
+
+
+## Store file header to a text file.
+#
+# Write standard file header to a text file. The content includes copyright,
+# abstract, description and license extracted from CommonHeader class object.
+#
+# @param TextFile The text file object.
+# @param CommonHeader The source CommonHeader class object.
+#
+def StoreHeader(TextFile, CommonHeader):
+ CopyRight = CommonHeader.Copyright
+ Abstract = CommonHeader.Abstract
+ Description = CommonHeader.Description
+ License = CommonHeader.License
+
+ Header = "#/** @file\n#\n"
+ Header += "# " + Abstract + "\n#\n"
+ Header += "# " + Description.strip().replace("\n", "\n# ") + "\n"
+ Header += "# " + CopyRight + "\n#\n"
+ Header += "# " + License.replace("\n", "\n# ").replace(" ", " ")
+ Header += "\n#\n#**/\n\n"
+
+ StoreTextFile(TextFile, Header)
+
+## Store file header to a text file.
+#
+# Write Defines section to a text file. DefinesTupleList determines the content.
+#
+# @param TextFile The text file object.
+# @param DefinesTupleList The list of (Tag, Value) to be added as one item.
+#
+def StoreDefinesSection(TextFile, DefinesTupleList):
+ Section = "[Defines]\n"
+ for DefineItem in DefinesTupleList:
+ Section += " %-30s = %s\n" % DefineItem
+
+ Section += "\n\n"
+ StoreTextFile(TextFile, Section)
+
+
+## Add item to PCD dictionary.
+#
+# Add an PcdClass object to PCD dictionary. The key is generated from
+# PcdItemType.
+#
+# @param PcdDict PCD dictionary indexed by Pcd Item Type.
+# @param Arch CPU architecture: Ia32, X64, Ipf, Ebc or Common.
+# @param Item The Item to be added to section dictionary.
+#
+def AddToPcdsDict(PcdDict, PcdItemType, PcdCode):
+ PcdSectionName = PcdItemType
+ PcdSectionName = PcdSectionName.title()
+ PcdSectionName = PcdSectionName.replace("_", "")
+ PcdSectionName = "Pcds" + PcdSectionName
+ PcdDict.setdefault(PcdSectionName, []).append(PcdCode)
+
+## Regular expression to match an equation.
+mReEquation = re.compile(r"\s*(\S+)\s*=\s*(\S*)\s*")
+
+## Return a value tuple matching information in a text fle.
+#
+# Parse the text file and return a value tuple corresponding to an input tag
+# tuple. In case of any error, an tuple of empty strings is returned.
+#
+# @param FileName The file name of the text file.
+# @param TagTuple A tuple of tags as the key to the value.
+#
+# @param ValueTupe The returned tuple corresponding to the tag tuple.
+#
+def GetTextFileInfo(FileName, TagTuple):
+ ValueTuple = [""] * len(TagTuple)
+ try:
+ for Line in open(FileName):
+ Line = Line.split("#", 1)[0]
+ MatchEquation = mReEquation.match(Line)
+ if MatchEquation:
+ Tag = MatchEquation.group(1).upper()
+ Value = MatchEquation.group(2)
+ for Index in range(len(TagTuple)):
+ if TagTuple[Index] == Tag:
+ ValueTuple[Index] = Value
+ except:
+ EdkLogger.info("IO Error in reading file %s" % FileName)
+
+ return ValueTuple
+
+## Return a value tuple matching information in an XML fle.
+#
+# Parse the XML file and return a value tuple corresponding to an input tag
+# tuple. In case of any error, an tuple of empty strings is returned.
+#
+# @param FileName The file name of the XML file.
+# @param TagTuple A tuple of tags as the key to the value.
+#
+# @param ValueTupe The returned tuple corresponding to the tag tuple.
+#
+def GetXmlFileInfo(FileName, TagTuple):
+ XmlDom = XmlParseFile(FileName)
+ return tuple([XmlElement(XmlDom, XmlTag) for XmlTag in TagTuple])
+
+# Version and Copyright
+__version_number__ = "1.0"
+__version__ = "%prog Version " + __version_number__
+__copyright__ = "Copyright (c) 2007, Intel Corporation. All rights reserved."
+
+## Parse migration command line options
+#
+# Use standard Python module optparse to parse command line option of this tool.
+#
+# @param Source The source file type.
+# @param Destinate The destinate file type.
+#
+# @retval Options A optparse object containing the parsed options.
+# @retval InputFile Path of an source file to be migrated.
+#
+def MigrationOptionParser(Source, Destinate):
+ # use clearer usage to override default usage message
+ UsageString = "%prog [-a] [-o <output_file>] <input_file>"
+
+ Parser = OptionParser(description=__copyright__, version=__version__, usage=UsageString)
+
+ HelpText = "The name of the %s file to be created." % Destinate
+ Parser.add_option("-o", "--output", dest="OutputFile", help=HelpText)
+
+ HelpText = "Automatically create the %s file using the name of the %s file and replacing file extension" % (Source, Destinate)
+ Parser.add_option("-a", "--auto", dest="AutoWrite", action="store_true", default=False, help=HelpText)
+
+ Options, Args = Parser.parse_args()
+
+ # error check
+ if len(Args) == 0:
+ raise MigrationError(OPTION_MISSING, name="Input file", usage=Parser.get_usage())
+ if len(Args) > 1:
+ raise MigrationError(OPTION_NOT_SUPPORTED, name="Too many input files", usage=Parser.get_usage())
+
+ InputFile = Args[0]
+ if not os.path.exists(InputFile):
+ raise MigrationError(FILE_NOT_FOUND, name=InputFile)
+
+ if Options.OutputFile:
+ if Options.AutoWrite:
+ raise MigrationError(OPTION_CONFLICT, arg1="-o", arg2="-a", usage=Parser.get_usage())
+ else:
+ if Options.AutoWrite:
+ Options.OutputFile = os.path.splitext(InputFile)[0] + "." + Destinate.lower()
+ else:
+ raise MigrationError(OPTION_MISSING, name="-o", usage=Parser.get_usage())
+
+ return Options, InputFile
+
+# This acts like the main() function for the script, unless it is 'import'ed
+# into another script.
+if __name__ == '__main__':
+ pass
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("<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
diff --git a/BaseTools/Source/Python/fpd2dsc/__init__.py b/BaseTools/Source/Python/fpd2dsc/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/__init__.py diff --git a/BaseTools/Source/Python/fpd2dsc/fpd2dsc.py b/BaseTools/Source/Python/fpd2dsc/fpd2dsc.py new file mode 100644 index 0000000000..a22ff5a685 --- /dev/null +++ b/BaseTools/Source/Python/fpd2dsc/fpd2dsc.py @@ -0,0 +1,116 @@ +## @file
+# Convert an XML-based FPD file to a text-based DSC file.
+#
+# Copyright (c) 2007, 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
+#
+import os, re, sys, xml.dom.minidom #XmlRoutines, EdkIIWorkspace
+from LoadFpd import LoadFpd
+from StoreDsc import StoreDsc
+from optparse import OptionParser
+
+# Version and Copyright
+__version_number__ = "1.0"
+__version__ = "%prog Version " + __version_number__
+__copyright__ = "Copyright (c) 2007, Intel Corporation All rights reserved."
+
+## Parse command line options
+#
+# Using standard Python module optparse to parse command line option of this tool.
+#
+# @retval Options A optparse.Values object containing the parsed options
+# @retval Args All the arguments got from the command line
+#
+def MyOptionParser():
+ """ Argument Parser """
+ usage = "%prog [options] input_filename"
+ parser = OptionParser(usage=usage,description=__copyright__,version="%prog " + str(__version_number__))
+ parser.add_option("-o", "--output", dest="outfile", help="Specific Name of the DSC file to create, otherwise it is the FPD filename with the extension repalced.")
+ parser.add_option("-a", "--auto", action="store_true", dest="autowrite", default=False, help="Automatically create output files and write the DSC file")
+ parser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbose", help="Do not print any messages, just return either 0 for succes or 1 for failure")
+ parser.add_option("-v", "--verbose", action="count", dest="verbose", help="Do not print any messages, just return either 0 for succes or 1 for failure")
+ parser.add_option("-d", "--debug", action="store_true", dest="debug", default=False, help="Enable printing of debug messages.")
+ parser.add_option("-w", "--workspace", dest="workspace", default=str(os.environ.get('WORKSPACE')), help="Specify workspace directory.")
+ (options, args) = parser.parse_args(sys.argv[1:])
+
+ return options,args
+
+## Entrance method
+#
+# This method mainly dispatch specific methods per the command line options.
+# If no error found, return zero value so the caller of this tool can know
+# if it's executed successfully or not.
+#
+# @retval 0 Tool was successful
+# @retval 1 Tool failed
+#
+def Main():
+ global Options
+ global Args
+ global WorkSpace
+ Options,Args = MyOptionParser()
+
+ WorkSpace = ""
+ #print Options.workspace
+ if (Options.workspace == None):
+ print "ERROR: E0000: WORKSPACE not defined.\n Please set the WORKSPACE environment variable to the location of the EDK II install directory."
+ sys.exit(1)
+ else:
+ WorkSpace = Options.workspace
+ if (Options.debug):
+ print "Using Workspace:", WorkSpace
+ try:
+ Options.verbose +=1
+ except:
+ Options.verbose = 1
+ pass
+
+ InputFile = ""
+ if Args == []:
+ print "usage:" "%prog [options] input_filename"
+ else:
+ InputFile = Args[0]
+ #print InputFile
+ if InputFile != "":
+ FileName = InputFile
+ if ((Options.verbose > 1) | (Options.autowrite)):
+ print "FileName:",InputFile
+ else:
+ print "ERROR: E0001 - You must specify an input filename"
+ sys.exit(1)
+
+ if (Options.outfile):
+ OutputFile = Options.outfile
+ else:
+ OutputFile = FileName.replace('.fpd', '.dsc')
+
+ if ((Options.verbose > 2) or (Options.debug)):
+ print "Output Filename:", OutputFile
+
+ try:
+ Platform = LoadFpd(FileName)
+ StoreDsc(OutputFile, Platform)
+ return 0
+ except Exception, e:
+ print e
+ return 1
+
+if __name__ == '__main__':
+ sys.exit(Main())
+ #pass
+ #global Options
+ #global Args
+ #Options,Args = MyOptionParser()
+
+ #Main()
+ #sys.exit(0)
\ No newline at end of file |