Check In tool source code based on Build tool project revision r1655.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524
author: lgao4 <lgao4@6f19259b-4bc3-4df7-8a09-765794883524> 2009-07-17 09:10:31 +0000
committer: lgao4 <lgao4@6f19259b-4bc3-4df7-8a09-765794883524> 2009-07-17 09:10:31 +0000
commit: 30fdf1140b8d1ce93f3821d986fa165552023440 (patch)
tree: c45c336a8955b1d03ea56d6c915a0e68a43b4ee9 /BaseTools/Source/Python/fpd2dsc
parent: 577e30cdb473e4af8e65fd6f75236691d0c8dfb3 (diff)
download: edk2-platforms-30fdf1140b8d1ce93f3821d986fa165552023440.tar.xz
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
author	lgao4 <lgao4@6f19259b-4bc3-4df7-8a09-765794883524>	2009-07-17 09:10:31 +0000
committer	lgao4 <lgao4@6f19259b-4bc3-4df7-8a09-765794883524>	2009-07-17 09:10:31 +0000
commit	30fdf1140b8d1ce93f3821d986fa165552023440 (patch)
tree	c45c336a8955b1d03ea56d6c915a0e68a43b4ee9 /BaseTools/Source/Python/fpd2dsc
parent	577e30cdb473e4af8e65fd6f75236691d0c8dfb3 (diff)
download	edk2-platforms-30fdf1140b8d1ce93f3821d986fa165552023440.tar.xz