Change GenBuildLogger format.

[mirror_edk2.git] / Tools / Source / GenBuild / org / tianocore / build / global / GlobalData.java

/** @file\r
  GlobalData class.\r
\r
  GlobalData provide initializing, instoring, querying and update global data.\r
  It is a bridge to intercommunicate between multiple component, such as AutoGen,\r
  PCD and so on.\r
\r
Copyright (c) 2006, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
**/\r
package org.tianocore.build.global;\r
\r
import java.io.File;\r
import java.util.HashMap;\r
import java.util.HashSet;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Set;\r
\r
import org.apache.tools.ant.BuildException;\r
import org.apache.xmlbeans.XmlObject;\r
\r
import org.tianocore.common.exception.EdkException;\r
import org.tianocore.common.logger.EdkLog;\r
import org.tianocore.pcd.entity.MemoryDatabaseManager;\r
import org.tianocore.DbPathAndFilename;\r
import org.tianocore.FrameworkDatabaseDocument;\r
import org.tianocore.ModuleSurfaceAreaDocument;\r
import org.tianocore.ModuleSurfaceAreaDocument.ModuleSurfaceArea;\r
import org.tianocore.build.id.FpdModuleIdentification;\r
import org.tianocore.build.id.ModuleIdentification;\r
import org.tianocore.build.id.PackageIdentification;\r
import org.tianocore.build.id.PlatformIdentification;\r
import org.tianocore.build.toolchain.ToolChainAttribute;\r
import org.tianocore.build.toolchain.ToolChainConfig;\r
import org.tianocore.build.toolchain.ToolChainElement;\r
import org.tianocore.build.toolchain.ToolChainInfo;\r
import org.tianocore.build.toolchain.ToolChainKey;\r
import org.tianocore.build.toolchain.ToolChainMap;\r
\r
/**\r
  GlobalData provide initializing, instoring, querying and update global data.\r
  It is a bridge to intercommunicate between multiple component, such as AutoGen,\r
  PCD and so on.\r
\r
  <p>Note that all global information are initialized incrementally. All data will\r
  parse and record only of necessary during build time. </p>\r
\r
  @since GenBuild 1.0\r
**/\r
public class GlobalData {\r
    ///\r
    /// Record current WORKSPACE Directory\r
    ///\r
    private static String workspaceDir = "";\r
\r
    ///\r
    /// Be used to ensure Global data will be initialized only once.\r
    ///\r
    private static boolean globalFlag = false;\r
\r
    ///\r
    /// Framework Database information: package list and platform list\r
    ///\r
    private static Set<PackageIdentification> packageList = new HashSet<PackageIdentification>();\r
\r
    private static Set<PlatformIdentification> platformList = new HashSet<PlatformIdentification>();\r
\r
    ///\r
    /// Every detail SPD informations: Module list, Library class definition,\r
    ///   Package header file, GUID/PPI/Protocol definitions\r
    ///\r
    private static final Map<PackageIdentification, Spd> spdTable = new HashMap<PackageIdentification, Spd>();\r
\r
    ///\r
    /// Build informations are divided into three parts:\r
    /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA\r
    ///\r
    private static Map<ModuleIdentification, Map<String, XmlObject>> nativeMsa = new HashMap<ModuleIdentification, Map<String, XmlObject>>();\r
\r
    private static Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleSA= new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();\r
\r
    private static Map<String, XmlObject> fpdBuildOptionsMap = new HashMap<String, XmlObject>();\r
    \r
    private static XmlObject fpdBuildOptions;\r
\r
    private static XmlObject fpdDynamicPcds;\r
\r
    ///\r
    /// Parsed modules list\r
    ///\r
    private static Map<FpdModuleIdentification, Map<String, XmlObject>> parsedModules = new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();\r
\r
    ///\r
    /// built modules list with ARCH, TARGET, TOOLCHAIN\r
    ///\r
    private static Set<FpdModuleIdentification> builtModules = new HashSet<FpdModuleIdentification>();\r
\r
    ///\r
    /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.\r
    ///\r
    private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();\r
\r
    ///\r
    /// build target + tool chain family/tag name + arch + command types + command options\r
    ///\r
    ///\r
    /// Tool Chain Data\r
    /// toolsDef - build tool program information\r
    /// fpdBuildOption - all modules's build options for tool tag or tool chain families\r
    /// moduleSaBuildOption - build options for a specific module\r
    ///\r
    private static ToolChainConfig toolsDef;\r
\r
    private static ToolChainInfo toolChainInfo;\r
    private static ToolChainInfo toolChainEnvInfo;\r
    private static ToolChainInfo toolChainPlatformInfo;\r
\r
    private static ToolChainMap platformToolChainOption;\r
    private static ToolChainMap platformToolChainFamilyOption;\r
\r
    private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainOption = new HashMap<FpdModuleIdentification, ToolChainMap>();\r
    private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainFamilyOption = new HashMap<FpdModuleIdentification, ToolChainMap>();\r
\r
    /**\r
      Parse framework database (DB) and all SPD files listed in DB to initialize\r
      the environment for next build. This method will only be executed only once\r
      in the whole build process.\r
\r
      @param workspaceDatabaseFile the file name of framework database\r
      @param workspaceDir current workspace directory path\r
      @throws BuildException\r
            Framework Dababase or SPD or MSA file is not valid\r
    **/\r
    public synchronized static void initInfo(String workspaceDatabaseFile, String workspaceDir, String toolsDefFilename ) throws BuildException {\r
        //\r
        // ensure this method will be revoked only once\r
        //\r
        if (globalFlag) {\r
            return;\r
        }\r
        globalFlag = true;\r
\r
		//\r
        // Backup workspace directory. It will be used by other method\r
        //\r
        GlobalData.workspaceDir = workspaceDir.replaceAll("(\\\\)", "/");\r
\r
        //\r
        // Parse tools definition file\r
        //\r
        //\r
        // If ToolChain has been set up before, do nothing.\r
        // CONF dir + tools definition file name\r
        //\r
        File toolsDefFile = new File(workspaceDir + File.separatorChar + toolsDefFilename);\r
        EdkLog.log("Init", "Using tool definiton file [" + toolsDefFile.getPath() + "].");\r
        try {\r
            toolsDef = new ToolChainConfig(toolsDefFile);\r
        } catch (Exception e) {\r
            throw new BuildException(e.getMessage());\r
        }\r
\r
        //\r
        // Parse Framework Database\r
        //\r
        File dbFile = new File(workspaceDir + File.separatorChar + workspaceDatabaseFile);\r
        try {\r
            FrameworkDatabaseDocument db = (FrameworkDatabaseDocument) XmlObject.Factory.parse(dbFile);\r
            //\r
            // validate FrameworkDatabaseFile\r
            //\r
            if (!db.validate()) {\r
                throw new BuildException("Framework Database file [" + dbFile.getPath() + "] format is invalid!");\r
            }\r
            //\r
            // Get package list\r
            //\r
            if (db.getFrameworkDatabase().getPackageList() != null ) {\r
                List<DbPathAndFilename> packages = db.getFrameworkDatabase().getPackageList().getFilenameList();\r
                Iterator<DbPathAndFilename> iter = packages.iterator();\r
                while (iter.hasNext()) {\r
                    String fileName = iter.next().getStringValue().trim();\r
                    Spd spd = new Spd(new File(workspaceDir + File.separatorChar + fileName));\r
                    packageList.add(spd.getPackageId());\r
                    spdTable.put(spd.getPackageId(), spd);\r
                }\r
            }\r
\r
            //\r
            // Get platform list\r
            //\r
            if (db.getFrameworkDatabase().getPlatformList() != null) {\r
                List<DbPathAndFilename> platforms = db.getFrameworkDatabase().getPlatformList().getFilenameList();\r
                Iterator<DbPathAndFilename> iter = platforms.iterator();\r
                while (iter.hasNext()) {\r
                    String fileName = iter.next().getStringValue().trim();\r
                    File fpdFile = new File(workspaceDir + File.separatorChar + fileName);\r
                    if ( !fpdFile.exists() ) {\r
                        throw new BuildException("Platform file [" + fpdFile.getPath() + "] not exists. ");\r
                    }\r
                    XmlObject fpdDoc = XmlObject.Factory.parse(fpdFile);\r
                    //\r
                    // Verify FPD file, if is invalid, throw Exception\r
                    //\r
                    if (!fpdDoc.validate()) {\r
                        throw new BuildException("Framework Platform Surface Area file [" + fpdFile.getPath() + "] format is invalid!");\r
                    }\r
                    //\r
                    // We can change Map to XmlObject\r
                    //\r
                    //\r
                    // TBD check SPD or FPD is existed in FS\r
                    //\r
                    Map<String, XmlObject> fpdDocMap = new HashMap<String, XmlObject>();\r
                    fpdDocMap.put("PlatformSurfaceArea", fpdDoc);\r
                    SurfaceAreaQuery saq = new SurfaceAreaQuery(fpdDocMap);\r
                    PlatformIdentification platformId = saq.getFpdHeader();\r
                    platformId.setFpdFile(fpdFile);\r
                    platformList.add(platformId);\r
                }\r
            }\r
        } catch (Exception e) {\r
            throw new BuildException("Parse WORKSPACE Database file [" + dbFile.getPath() + "] Error.\n" + e.getMessage());\r
        }\r
    }\r
\r
    /**\r
      Get the current WORKSPACE Directory.\r
\r
      @return current workspace directory\r
    **/\r
    public synchronized static String getWorkspacePath() {\r
        return workspaceDir;\r
    }\r
\r
\r
    /**\r
      Get the MSA file name with absolute path\r
     */\r
    public synchronized static File getMsaFile(ModuleIdentification moduleId) throws BuildException {\r
        File msaFile = null;\r
        //\r
        // TBD. Do only when package is null.\r
        //\r
        Iterator iter = packageList.iterator();\r
        while (iter.hasNext()) {\r
            PackageIdentification packageId = (PackageIdentification)iter.next();\r
            Spd spd = spdTable.get(packageId);\r
            msaFile = spd.getModuleFile(moduleId);\r
            if (msaFile != null ) {\r
                break ;\r
            }\r
        }\r
        if (msaFile == null){\r
            throw new BuildException("Can't find Module [" + moduleId.getName() + "] in any SPD package!");\r
        } else {\r
            return msaFile;\r
        }\r
    }\r
\r
    public synchronized static PackageIdentification getPackageForModule(ModuleIdentification moduleId) {\r
        //\r
        // If package already defined in module\r
        //\r
        if (moduleId.getPackage() != null) {\r
            return moduleId.getPackage();\r
        }\r
\r
        PackageIdentification packageId = null;\r
        Iterator iter = packageList.iterator();\r
        while (iter.hasNext()) {\r
            packageId = (PackageIdentification)iter.next();\r
            moduleId.setPackage(packageId);\r
            Spd spd = spdTable.get(packageId);\r
            if (spd.getModuleFile(moduleId) != null ) {\r
                break ;\r
            }\r
        }\r
        if (packageId == null){\r
            throw new BuildException("Can't find Module [" + moduleId.getName() + "] in any SPD package!");\r
        } else {\r
            return packageId;\r
        }\r
    }\r
\r
    /**\r
      Difference between build and parse: ToolChain and Target\r
    **/\r
    public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId) {\r
        return builtModules.contains(moduleId);\r
    }\r
\r
    public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId) {\r
        builtModules.add(fpdModuleId);\r
    }\r
\r
\r
    public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId, Map<String, XmlObject> doc) {\r
        Map<String, XmlObject> result = new HashMap<String, XmlObject>();\r
        Set keySet = doc.keySet();\r
        Iterator iter = keySet.iterator();\r
        while (iter.hasNext()){\r
            String key = (String)iter.next();\r
            XmlObject item = cloneXmlObject(doc.get(key), true);\r
            result.put(key, item);\r
        }\r
        fpdModuleSA.put(fpdModuleId, result);\r
    }\r
\r
    public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId) {\r
        return fpdModuleSA.containsKey(fpdModuleId);\r
    }\r
\r
    /**\r
      Query module surface area information.\r
\r
      <p>Note that surface area parsing is incremental. That means the method will\r
      only parse the MSA files if necessary. </p>\r
    \r
      @param fpdModuleId Module ID with arch\r
      @return ModuleSA info and MSA info for fpdModuleId\r
      @throws BuildException Can't find MSA\r
    **/\r
    public synchronized static Map<String, XmlObject> getDoc(FpdModuleIdentification fpdModuleId) throws BuildException {\r
        if (parsedModules.containsKey(fpdModuleId)) {\r
            return parsedModules.get(fpdModuleId);\r
        }\r
        Map<String, XmlObject> doc = new HashMap<String, XmlObject>();\r
        ModuleIdentification moduleId = fpdModuleId.getModule();\r
        //\r
        // First part: get the MSA files info\r
        //\r
        doc.putAll(getNativeMsa(moduleId));\r
\r
        //\r
        // Second part: put build options\r
        //\r
        doc.put("BuildOptions", fpdBuildOptions);\r
\r
        //\r
        // Third part: get Module info from FPD, such as Library instances, PCDs\r
        //\r
        if (fpdModuleSA.containsKey(fpdModuleId)){\r
            //\r
            // merge module info in FPD to final Doc\r
            // For Library Module, do nothing here\r
            //\r
            doc.putAll(fpdModuleSA.get(fpdModuleId));\r
        }\r
        parsedModules.put(fpdModuleId, doc);\r
        return doc;\r
    }\r
\r
    public synchronized static Map<String, XmlObject> getDoc(ModuleIdentification moduleId, String arch) throws BuildException {\r
        FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, arch);\r
        return getDoc(fpdModuleId);\r
    }\r
    /**\r
      Query the native MSA information with module base name.\r
\r
      <p>Note that MSA parsing is incremental. That means the method will\r
      only to parse the MSA files when never parsed before. </p>\r
\r
      @param moduleName the base name of the module\r
      @return the native MSA information\r
      @throws BuildException\r
              MSA file is not valid\r
    **/\r
    public synchronized static Map<String, XmlObject> getNativeMsa(ModuleIdentification moduleId) throws BuildException {\r
        if (nativeMsa.containsKey(moduleId)) {\r
            return nativeMsa.get(moduleId);\r
        }\r
        File msaFile = getMsaFile(moduleId);\r
        Map<String, XmlObject> msaMap = getNativeMsa(msaFile);\r
        nativeMsa.put(moduleId, msaMap);\r
        return msaMap;\r
    }\r
\r
    public synchronized static Map<String, XmlObject> getNativeMsa(File msaFile) throws BuildException {\r
        if (!msaFile.exists()) {\r
            throw new BuildException("Module Surface Area file [" + msaFile.getPath() + "] can't be found!");\r
        }\r
        try {\r
            ModuleSurfaceAreaDocument doc = (ModuleSurfaceAreaDocument)XmlObject.Factory.parse(msaFile);\r
            //\r
            // Validate File if they accord with XML Schema\r
            //\r
            if ( !doc.validate()){\r
                throw new BuildException("Module Surface Area file [" + msaFile.getPath() + "] format is invalid!");\r
            }\r
            //\r
            // parse MSA file\r
            //\r
            ModuleSurfaceArea msa= doc.getModuleSurfaceArea();\r
            Map<String, XmlObject> msaMap = new HashMap<String, XmlObject>();\r
            msaMap.put("MsaHeader", cloneXmlObject(msa.getMsaHeader(), true));\r
            msaMap.put("ModuleDefinitions", cloneXmlObject(msa.getModuleDefinitions(), true));\r
            msaMap.put("LibraryClassDefinitions", cloneXmlObject(msa.getLibraryClassDefinitions(), true));\r
            msaMap.put("SourceFiles", cloneXmlObject(msa.getSourceFiles(), true));\r
            msaMap.put("PackageDependencies", cloneXmlObject(msa.getPackageDependencies(), true));\r
            msaMap.put("Protocols", cloneXmlObject(msa.getProtocols(), true));\r
            msaMap.put("PPIs", cloneXmlObject(msa.getPPIs(), true));\r
            msaMap.put("Guids", cloneXmlObject(msa.getGuids(), true));\r
            msaMap.put("Externs", cloneXmlObject(msa.getExterns(), true));\r
            msaMap.put("PcdCoded", cloneXmlObject(msa.getPcdCoded(), true));\r
            return msaMap;\r
        }\r
        catch (Exception ex){\r
            throw new BuildException("Parsing MSA file [" + msaFile.getPath() + "] error. \n" + ex.getMessage() );\r
        }\r
    }\r
\r
    public static Map<String, XmlObject> getFpdBuildOptionsMap() {\r
        return fpdBuildOptionsMap;\r
    }\r
\r
    public static void setFpdBuildOptions(XmlObject fpdBuildOptions) {\r
        GlobalData.fpdBuildOptions = cloneXmlObject(fpdBuildOptions, true);\r
        fpdBuildOptionsMap.put("BuildOptions", GlobalData.fpdBuildOptions);\r
    }\r
\r
    public static XmlObject getFpdDynamicPcds() {\r
        return fpdDynamicPcds;\r
    }\r
\r
    public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds) {\r
        GlobalData.fpdDynamicPcds = fpdDynamicPcds;\r
    }\r
\r
    public static Set<ModuleIdentification> getModules(PackageIdentification packageId){\r
        Spd spd = spdTable.get(packageId);\r
        if (spd == null ) {\r
            Set<ModuleIdentification> dummy = new HashSet<ModuleIdentification>();\r
            return dummy;\r
        } else {\r
            return spd.getModules();\r
        }\r
    }\r
\r
    /**\r
     * The header file path is relative to workspace dir\r
     */\r
    public static String[] getLibraryClassHeaderFiles(\r
            PackageIdentification[] packages, String name)\r
            throws BuildException {\r
        if (packages == null) {\r
            // throw Exception or not????\r
            return new String[0];\r
        }\r
        String[] result = null;\r
        for (int i = 0; i < packages.length; i++) {\r
            Spd spd = spdTable.get(packages[i]);\r
            //\r
            // If find one package defined the library class\r
            //\r
            if ((result = spd.getLibClassIncluder(name)) != null) {\r
                return result;\r
            }\r
        }\r
        //\r
        // If can't find library class declaration in every package\r
        //\r
        throw new BuildException("Can not find library class [" + name\r
                + "] declaration in any SPD package!");\r
    }\r
\r
    /**\r
     * The header file path is relative to workspace dir\r
     */\r
    public static String getPackageHeaderFiles(PackageIdentification packages,\r
            String moduleType) throws BuildException {\r
        if (packages == null) {\r
            return new String("");\r
        }\r
        Spd spd = spdTable.get(packages);\r
        //\r
        // If can't find package header file, skip it\r
        //\r
        String temp = null;\r
        if (spd != null) {\r
            if ((temp = spd.getPackageIncluder(moduleType)) != null) {\r
                return temp;\r
            } else {\r
                temp = "";\r
                return temp;\r
            }\r
        } else {\r
            return null;\r
        }\r
    }\r
\r
    /**\r
     * return two values: {cName, GuidValue}\r
     */\r
    public static String[] getGuid(List<PackageIdentification> packages, String name)\r
            throws BuildException {\r
        if (packages == null) {\r
            // throw Exception or not????\r
            return new String[0];\r
        }\r
        String[] result = null;\r
        Iterator item = packages.iterator();\r
        while (item.hasNext()){\r
            Spd spd = spdTable.get(item.next());\r
            //\r
            // If find one package defined the GUID\r
            //\r
            if ((result = spd.getGuid(name)) != null) {\r
                return result;\r
            }\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     * return two values: {cName, GuidValue}\r
     */\r
    public static String[] getPpiGuid(List<PackageIdentification> packages,\r
            String name) throws BuildException {\r
        if (packages == null) {\r
            return new String[0];\r
        }\r
        String[] result = null;\r
        Iterator item = packages.iterator();\r
        while (item.hasNext()){\r
            Spd spd = spdTable.get(item.next());\r
            //\r
            // If find one package defined the Ppi GUID\r
            //\r
            if ((result = spd.getPpi(name)) != null) {\r
                return result;\r
            }\r
        }\r
        return null;\r
    }\r
\r
    /**\r
     * return two values: {cName, GuidValue}\r
     */\r
    public static String[] getProtocolGuid(List<PackageIdentification> packages,\r
            String name) throws BuildException {\r
        if (packages == null) {\r
            return new String[0];\r
        }\r
        String[] result = null;\r
        Iterator item = packages.iterator();\r
        while (item.hasNext()){\r
            Spd spd = spdTable.get(item.next());\r
            //\r
            // If find one package defined the protocol GUID\r
            //\r
            if ((result = spd.getProtocol(name))!= null){\r
                return result;\r
            }\r
        }\r
        return null;\r
\r
    }\r
\r
    public synchronized static PlatformIdentification getPlatformByName(String name) throws BuildException {\r
        Iterator iter = platformList.iterator();\r
        while(iter.hasNext()){\r
            PlatformIdentification platformId = (PlatformIdentification)iter.next();\r
            if (platformId.getName().equalsIgnoreCase(name)) {\r
                return platformId;\r
            }\r
        }\r
        throw new BuildException("Can't find platform [" + name + "] in the current WORKSPACE database!");\r
    }\r
\r
    public synchronized static PlatformIdentification getPlatform(String filename) throws BuildException {\r
        File file = new File(workspaceDir + File.separatorChar + filename);\r
        Iterator iter = platformList.iterator();\r
        while(iter.hasNext()){\r
            PlatformIdentification platformId = (PlatformIdentification)iter.next();\r
            if (platformId.getFpdFile().getPath().equalsIgnoreCase(file.getPath())) {\r
                return platformId;\r
            }\r
        }\r
        throw new BuildException("Can't find platform file [" + filename + "] in the current WORKSPACE database!");\r
    }\r
\r
    public synchronized static PackageIdentification refreshPackageIdentification(PackageIdentification packageId) throws BuildException {\r
        Iterator iter = packageList.iterator();\r
        while(iter.hasNext()){\r
            PackageIdentification packageItem = (PackageIdentification)iter.next();\r
            if (packageItem.equals(packageId)) {\r
                packageId.setName(packageItem.getName());\r
                packageId.setSpdFile(packageItem.getSpdFile());\r
                return packageId;\r
            }\r
        }\r
        throw new BuildException("Can't find package GUID value " + packageId.toGuidString() + " in the current workspace!");\r
    }\r
\r
    public synchronized static ModuleIdentification refreshModuleIdentification(ModuleIdentification moduleId) throws BuildException {\r
        PackageIdentification packageId = getPackageForModule(moduleId);\r
        moduleId.setPackage(packageId);\r
        Spd spd = spdTable.get(packageId);\r
        if (spd == null) {\r
            throw new BuildException("Can't find package GUID value " + packageId.toGuidString() + " in the current workspace!");\r
        }\r
        Set<ModuleIdentification> modules = spd.getModules();\r
        Iterator<ModuleIdentification> iter = modules.iterator();\r
        while (iter.hasNext()) {\r
            ModuleIdentification item = iter.next();\r
            if (item.equals(moduleId)) {\r
                moduleId.setName(item.getName());\r
                moduleId.setModuleType(item.getModuleType());\r
                moduleId.setMsaFile(item.getMsaFile());\r
                return moduleId;\r
            }\r
        }\r
        throw new BuildException("Can't find module GUID value " + moduleId.toGuidString() + " in " + packageId + " under the current workspace!");\r
    }\r
\r
    public synchronized static Set<PackageIdentification> getPackageList(){\r
        return packageList;\r
    }\r
\r
    /**\r
      BUGBUG: It is a walk around method. If do not clone, can't query info with\r
      XPath correctly. \r
      \r
      @param object XmlObject\r
      @param deep flag for deep clone\r
      @return XmlObject after clone\r
      @throws BuildException parse original XmlObject error. \r
    **/\r
    private static XmlObject cloneXmlObject(XmlObject object, boolean deep) throws BuildException {\r
        if ( object == null) {\r
            return null;\r
        }\r
        XmlObject result = null;\r
        try {\r
            result = XmlObject.Factory.parse(object.getDomNode()\r
                            .cloneNode(deep));\r
        } catch (Exception ex) {\r
            throw new BuildException(ex.getMessage());\r
        }\r
        return result;\r
    }\r
\r
    ///\r
    /// Tool Chain Related, try to refine and put some logic process to ToolChainFactory\r
    ///\r
    public static ToolChainInfo getToolChainInfo() {\r
        if (toolChainInfo == null) {\r
            toolChainInfo = toolsDef.getConfigInfo().intersection(toolChainEnvInfo);\r
            if (toolChainPlatformInfo != null) {\r
                toolChainInfo = toolChainInfo.intersection(toolChainPlatformInfo);\r
            }\r
            toolChainInfo.addCommands(toolsDef.getConfigInfo().getCommands());\r
            toolChainInfo.normalize();\r
            EdkLog.log("Init", "Current build tool chain information summary: ");\r
            EdkLog.log("Init", toolChainInfo + "");\r
        }\r
        return toolChainInfo;\r
    }\r
\r
    public static void setPlatformToolChainFamilyOption(ToolChainMap map) {\r
        platformToolChainFamilyOption = map;\r
    }\r
\r
    public static void setPlatformToolChainOption(ToolChainMap map) {\r
        platformToolChainOption = map;\r
    }\r
\r
    public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId,\r
        ToolChainMap toolChainOption) {\r
        moduleToolChainOption.put(fpdModuleId, toolChainOption);\r
    }\r
\r
    public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId,\r
        ToolChainMap toolChainOption) {\r
        moduleToolChainFamilyOption.put(fpdModuleId, toolChainOption);\r
    }\r
\r
    public static boolean isCommandSet(String target, String toolchain, String arch) {\r
        String[] commands = getToolChainInfo().getCommands();\r
\r
        for (int i = 0; i < commands.length; ++i) {\r
            String cmdName = toolsDef.getConfig().get(new String[] {target, toolchain, arch, commands[i], ToolChainAttribute.NAME.toString()});\r
            if (cmdName != null && cmdName.length() != 0) {\r
                return true;\r
            }\r
        }\r
\r
        return false;\r
    }\r
\r
    public static String getCommandSetting(String[] commandDescription, FpdModuleIdentification fpdModuleId) throws EdkException {\r
        ToolChainKey toolChainKey = new ToolChainKey(commandDescription);\r
        ToolChainMap toolChainConfig = toolsDef.getConfig();\r
        String setting = null;\r
\r
        if (!commandDescription[ToolChainElement.ATTRIBUTE.value].equals(ToolChainAttribute.FLAGS.toString())) {\r
            setting = toolChainConfig.get(toolChainKey);\r
            if (setting == null) {\r
                setting = "";\r
            }\r
            return setting;\r
        }\r
\r
        //\r
        // get module specific options, if any\r
        //\r
        // tool tag first\r
        ToolChainMap option = moduleToolChainOption.get(fpdModuleId);\r
        ToolChainKey toolChainFamilyKey = null;\r
\r
        if ((option == null) || (option != null && (setting = option.get(toolChainKey)) == null)) {\r
            //\r
            // then tool chain family\r
            //\r
            toolChainFamilyKey = new ToolChainKey(commandDescription);\r
            toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);\r
            String family = toolChainConfig.get(toolChainFamilyKey);\r
            toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);\r
            toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);\r
\r
            option = moduleToolChainFamilyOption.get(fpdModuleId);\r
            if (option != null) {\r
                setting = option.get(toolChainFamilyKey);\r
            }\r
        }\r
\r
        //\r
        // get platform options, if any\r
        //\r
        if (setting == null) {\r
            // tool tag first\r
            if (platformToolChainOption == null || (setting = platformToolChainOption.get(toolChainKey)) == null) {\r
                // then tool chain family\r
                if (toolChainFamilyKey == null) {\r
                    toolChainFamilyKey = new ToolChainKey(commandDescription);\r
                    toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);\r
                    String family = toolChainConfig.get(toolChainFamilyKey);\r
                    toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);\r
                    toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);\r
                }\r
\r
                setting = platformToolChainFamilyOption.get(toolChainFamilyKey);\r
            }\r
        }\r
\r
        if (setting == null) {\r
            setting = "";\r
        }\r
\r
        return setting;\r
    }\r
\r
    public static void setToolChainEnvInfo(ToolChainInfo envInfo) {\r
        toolChainEnvInfo = envInfo;\r
    }\r
    public static void setToolChainPlatformInfo(ToolChainInfo platformInfo) {\r
        toolChainPlatformInfo = platformInfo;\r
    }\r
\r
    //\r
    // for PCD\r
    //\r
    public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {\r
        return pcdDbManager;\r
    }\r
\r
    //\r
    // For PCD get tokenSpaceGUid\r
    //\r
    public synchronized static String getGuidInfoFromCname(String cName){\r
        String cNameGuid = null;\r
        String guid = null;\r
        Set set = spdTable.keySet();\r
        Iterator iter = set.iterator();\r
\r
        if (iter == null) {\r
            return null;\r
        }\r
\r
        while (iter.hasNext()){\r
            Spd spd = (Spd) spdTable.get(iter.next());\r
            guid = spd.getGuidFromCname(cName);\r
            if (guid != null){\r
                cNameGuid = guid;\r
                break;\r
            }\r
        }\r
        return cNameGuid;\r
    }\r
\r
    //\r
    // For PCD\r
    //\r
    public synchronized static Map<FpdModuleIdentification, XmlObject>\r
                               getFpdModuleSaXmlObject(String xmlObjectName) {\r
        Set<FpdModuleIdentification> fpdModuleSASet = fpdModuleSA.keySet();\r
        Iterator item = fpdModuleSASet.iterator();\r
\r
\r
        Map<FpdModuleIdentification, XmlObject> SAPcdBuildDef = new HashMap<FpdModuleIdentification, XmlObject>();\r
        Map<String, XmlObject> SANode = new HashMap<String, XmlObject>();\r
        FpdModuleIdentification moduleId;\r
        while (item.hasNext()) {\r
\r
            moduleId = (FpdModuleIdentification) item.next();\r
            SANode = fpdModuleSA.get(moduleId);\r
            try{\r
                if (SANode.get(xmlObjectName)!= null){\r
                    SAPcdBuildDef.put(moduleId,\r
                            (XmlObject) SANode.get(xmlObjectName));\r
\r
                }\r
            } catch (Exception e){\r
                EdkLog.log(EdkLog.EDK_INFO, e.getMessage());\r
            }\r
        }\r
        return SAPcdBuildDef;\r
    }\r
\r
    public synchronized static Map<FpdModuleIdentification,XmlObject> getFpdPcdBuildDefinitions() {\r
        Map<FpdModuleIdentification,XmlObject> pcdBuildDef = getFpdModuleSaXmlObject ("PcdBuildDefinition");\r
\r
        return pcdBuildDef;\r
    }\r
}\r
\r