Tools/Source/GenBuild/org/tianocore/build/global/GlobalData.java

   1 /** @file
   2   GlobalData class.
   3
   4   GlobalData provide initializing, instoring, querying and update global data.
   5   It is a bridge to intercommunicate between multiple component, such as AutoGen,
   6   PCD and so on.
   7
   8 Copyright (c) 2006, Intel Corporation
   9 All rights reserved. This program and the accompanying materials
  10 are licensed and made available under the terms and conditions of the BSD License
  11 which accompanies this distribution.  The full text of the license may be found at
  12 http://opensource.org/licenses/bsd-license.php
  13
  14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16 **/
  17 package org.tianocore.build.global;
  18
  19 import java.io.File;
  20 import java.util.HashMap;
  21 import java.util.HashSet;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.logging.Logger;
  27
  28 import org.apache.tools.ant.BuildException;
  29 import org.apache.xmlbeans.XmlObject;
  30 import org.tianocore.DbPathAndFilename;
  31 import org.tianocore.FrameworkDatabaseDocument;
  32 import org.tianocore.ModuleSurfaceAreaDocument;
  33 import org.tianocore.ModuleSurfaceAreaDocument.ModuleSurfaceArea;
  34 import org.tianocore.build.id.FpdModuleIdentification;
  35 import org.tianocore.build.id.ModuleIdentification;
  36 import org.tianocore.build.id.PackageIdentification;
  37 import org.tianocore.build.id.PlatformIdentification;
  38 import org.tianocore.build.pcd.entity.MemoryDatabaseManager;
  39 import org.tianocore.build.toolchain.ToolChainAttribute;
  40 import org.tianocore.build.toolchain.ToolChainConfig;
  41 import org.tianocore.build.toolchain.ToolChainElement;
  42 import org.tianocore.build.toolchain.ToolChainInfo;
  43 import org.tianocore.build.toolchain.ToolChainKey;
  44 import org.tianocore.build.toolchain.ToolChainMap;
  45 import org.tianocore.exception.EdkException;
  46 import org.tianocore.logger.EdkLog;
  47
  48 /**
  49   GlobalData provide initializing, instoring, querying and update global data.
  50   It is a bridge to intercommunicate between multiple component, such as AutoGen,
  51   PCD and so on.
  52
  53   <p>Note that all global information are initialized incrementally. All data will
  54   parse and record only of necessary during build time. </p>
  55
  56   @since GenBuild 1.0
  57 **/
  58 public class GlobalData {
  59
  60     public static Logger log = Logger.getAnonymousLogger();
  61
  62     ///
  63     /// Record current WORKSPACE Directory
  64     ///
  65     private static String workspaceDir = "";
  66
  67     ///
  68     /// Be used to ensure Global data will be initialized only once.
  69     ///
  70     private static boolean globalFlag = false;
  71
  72     ///
  73     /// Framework Database information: package list and platform list
  74     ///
  75     private static Set<PackageIdentification> packageList = new HashSet<PackageIdentification>();
  76
  77     private static Set<PlatformIdentification> platformList = new HashSet<PlatformIdentification>();
  78
  79     ///
  80     /// Every detail SPD informations: Module list, Library class definition,
  81     ///   Package header file, GUID/PPI/Protocol definitions
  82     ///
  83     private static final Map<PackageIdentification, Spd> spdTable = new HashMap<PackageIdentification, Spd>();
  84
  85     ///
  86     /// Build informations are divided into three parts:
  87     /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
  88     ///
  89     private static Map<ModuleIdentification, Map<String, XmlObject>> nativeMsa = new HashMap<ModuleIdentification, Map<String, XmlObject>>();
  90
  91     private static Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleSA= new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();
  92
  93     private static XmlObject fpdBuildOptions;
  94
  95     private static XmlObject fpdDynamicPcds;
  96
  97     ///
  98     /// Parsed modules list
  99     ///
 100     private static Map<FpdModuleIdentification, Map<String, XmlObject>> parsedModules = new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();
 101
 102     ///
 103     /// built modules list with ARCH, TARGET, TOOLCHAIN
 104     ///
 105     private static Set<FpdModuleIdentification> builtModules = new HashSet<FpdModuleIdentification>();
 106
 107     ///
 108     /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.
 109     ///
 110 //    private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();
 111
 112     ///
 113     /// build target + tool chain family/tag name + arch + command types + command options
 114     ///
 115     ///
 116     /// Tool Chain Data
 117     /// toolsDef - build tool program information
 118     /// fpdBuildOption - all modules's build options for tool tag or tool chain families
 119     /// moduleSaBuildOption - build options for a specific module
 120     ///
 121     private static ToolChainConfig toolsDef;
 122
 123     private static ToolChainInfo toolChainInfo;
 124     private static ToolChainInfo toolChainEnvInfo;
 125     private static ToolChainInfo toolChainPlatformInfo;
 126
 127     private static ToolChainMap platformToolChainOption;
 128     private static ToolChainMap platformToolChainFamilyOption;
 129
 130     private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainOption = new HashMap<FpdModuleIdentification, ToolChainMap>();
 131     private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainFamilyOption = new HashMap<FpdModuleIdentification, ToolChainMap>();
 132
 133     private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();
 134
 135     /**
 136       Parse framework database (DB) and all SPD files listed in DB to initialize
 137       the environment for next build. This method will only be executed only once
 138       in the whole build process.
 139
 140       @param workspaceDatabaseFile the file name of framework database
 141       @param workspaceDir current workspace directory path
 142       @throws BuildException
 143             Framework Dababase or SPD or MSA file is not valid
 144     **/
 145     public synchronized static void initInfo(String workspaceDatabaseFile, String workspaceDir, String toolsDefFilename ) throws BuildException {
 146         //
 147         // ensure this method will be revoked only once
 148         //
 149         if (globalFlag) {
 150             return;
 151         }
 152         globalFlag = true;
 153
 154                 //
 155         // Backup workspace directory. It will be used by other method
 156         //
 157         GlobalData.workspaceDir = workspaceDir.replaceAll("(\\\\)", "/");
 158
 159         //
 160         // Parse tools definition file
 161         //
 162         //
 163         // If ToolChain has been set up before, do nothing.
 164         // CONF dir + tools definition file name
 165         //
 166         File toolsDefFile = new File(workspaceDir + File.separatorChar + toolsDefFilename);
 167         System.out.println("Using file [" + toolsDefFile.getPath() + "] as tools definition file. ");
 168         toolsDef = new ToolChainConfig(toolsDefFile);
 169
 170         //
 171         // Parse Framework Database
 172         //
 173         File dbFile = new File(workspaceDir + File.separatorChar + workspaceDatabaseFile);
 174         try {
 175             FrameworkDatabaseDocument db = (FrameworkDatabaseDocument) XmlObject.Factory.parse(dbFile);
 176             //
 177             // validate FrameworkDatabaseFile
 178             //
 179             if (! db.validate()) {
 180                 throw new BuildException("Framework Database file [" + dbFile.getPath() + "] is invalid.");
 181             }
 182             //
 183             // Get package list
 184             //
 185             if (db.getFrameworkDatabase().getPackageList() != null ) {
 186                 List<DbPathAndFilename> packages = db.getFrameworkDatabase().getPackageList().getFilenameList();
 187                 Iterator<DbPathAndFilename> iter = packages.iterator();
 188                 while (iter.hasNext()) {
 189                     String fileName = iter.next().getStringValue();
 190                     Spd spd = new Spd(new File(workspaceDir + File.separatorChar + fileName));
 191                     packageList.add(spd.getPackageId());
 192                     spdTable.put(spd.getPackageId(), spd);
 193                 }
 194             }
 195
 196             //
 197             // Get platform list
 198             //
 199             if (db.getFrameworkDatabase().getPlatformList() != null) {
 200                 List<DbPathAndFilename> platforms = db.getFrameworkDatabase().getPlatformList().getFilenameList();
 201                 Iterator<DbPathAndFilename> iter = platforms.iterator();
 202                 while (iter.hasNext()) {
 203                     String fileName = iter.next().getStringValue();
 204                     File fpdFile = new File(workspaceDir + File.separatorChar + fileName);
 205                     if ( ! fpdFile.exists() ) {
 206                         throw new BuildException("Platform file [" + fpdFile.getPath() + "] not exists. ");
 207                     }
 208                     XmlObject fpdDoc = XmlObject.Factory.parse(fpdFile);
 209                     //
 210                     // Verify FPD file, if is invalid, throw Exception
 211                     //
 212                     if (! fpdDoc.validate()) {
 213                         throw new BuildException("Framework Platform Surface Area file [" + fpdFile.getPath() + "] is invalid. ");
 214                     }
 215                     //
 216                     // We can change Map to XmlObject
 217                     //
 218                     //
 219                     // TBD check SPD or FPD is existed in FS
 220                     //
 221                     Map<String, XmlObject> fpdDocMap = new HashMap<String, XmlObject>();
 222                     fpdDocMap.put("PlatformSurfaceArea", fpdDoc);
 223                     SurfaceAreaQuery.setDoc(fpdDocMap);
 224                     PlatformIdentification platformId = SurfaceAreaQuery.getFpdHeader();
 225                     platformId.setFpdFile(fpdFile);
 226                     platformList.add(platformId);
 227                 }
 228             }
 229         } catch (Exception e) {
 230             throw new BuildException("Parse workspace Database [" + dbFile.getPath() + "] Error.\n" + e.getMessage());
 231         }
 232     }
 233
 234     /**
 235       Get the current WORKSPACE Directory.
 236
 237       @return current workspace directory
 238     **/
 239     public synchronized static String getWorkspacePath() {
 240         return workspaceDir;
 241     }
 242
 243
 244     /**
 245       Get the MSA file name with absolute path
 246      */
 247     public synchronized static File getMsaFile(ModuleIdentification moduleId) throws BuildException {
 248         File msaFile = null;
 249         //
 250         // TBD. Do only when package is null.
 251         //
 252         Iterator iter = packageList.iterator();
 253         while (iter.hasNext()) {
 254             PackageIdentification packageId = (PackageIdentification)iter.next();
 255             Spd spd = spdTable.get(packageId);
 256             msaFile = spd.getModuleFile(moduleId);
 257             if (msaFile != null ) {
 258                 break ;
 259             }
 260         }
 261         if (msaFile == null){
 262             throw new BuildException("Can't find Module [" + moduleId.getName() + "] in all packages. ");
 263         }
 264         else {
 265             return msaFile;
 266         }
 267     }
 268
 269     public synchronized static PackageIdentification getPackageForModule(ModuleIdentification moduleId) {
 270         //
 271         // If package already defined in module
 272         //
 273         if (moduleId.getPackage() != null) {
 274             return moduleId.getPackage();
 275         }
 276
 277         PackageIdentification packageId = null;
 278         Iterator iter = packageList.iterator();
 279         while (iter.hasNext()) {
 280             packageId = (PackageIdentification)iter.next();
 281             moduleId.setPackage(packageId);
 282             Spd spd = spdTable.get(packageId);
 283             if (spd.getModuleFile(moduleId) != null ) {
 284                 break ;
 285             }
 286         }
 287         if (packageId == null){
 288             throw new BuildException("Can't find Module [" + moduleId.getName() + "] in all packages. ");
 289         }
 290         else {
 291             return packageId;
 292         }
 293     }
 294
 295     /**
 296       Difference between build and parse: ToolChain and Target
 297     **/
 298     public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId) {
 299         return builtModules.contains(moduleId);
 300     }
 301
 302     public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId) {
 303         builtModules.add(fpdModuleId);
 304     }
 305
 306
 307     public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId, Map<String, XmlObject> doc) {
 308         Map<String, XmlObject> result = new HashMap<String, XmlObject>();
 309         Set keySet = doc.keySet();
 310         Iterator iter = keySet.iterator();
 311         while (iter.hasNext()){
 312             String key = (String)iter.next();
 313             XmlObject item = cloneXmlObject(doc.get(key), true);
 314             result.put(key, item);
 315         }
 316         fpdModuleSA.put(fpdModuleId, result);
 317     }
 318
 319     public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId) {
 320         return fpdModuleSA.containsKey(fpdModuleId);
 321     }
 322
 323     /**
 324       Query overrided module surface area information. If current is Package
 325       or Platform build, also include the information from FPD file.
 326
 327       <p>Note that surface area parsing is incremental. That means the method will
 328       only parse the MSA and MBD files if necessary. </p>
 329
 330       @param moduleName the base name of the module
 331       @return the overrided module surface area information
 332       @throws BuildException
 333               MSA or MBD is not valid
 334     **/
 335     public synchronized static Map<String, XmlObject> getDoc(FpdModuleIdentification fpdModuleId) throws BuildException {
 336         if (parsedModules.containsKey(fpdModuleId)) {
 337             return parsedModules.get(fpdModuleId);
 338         }
 339         Map<String, XmlObject> doc = new HashMap<String, XmlObject>();
 340         ModuleIdentification moduleId = fpdModuleId.getModule();
 341         //
 342         // First part: get the MSA files info
 343         //
 344         doc.putAll(getNativeMsa(moduleId));
 345
 346         //
 347         // Second part: put build options
 348         //
 349         doc.put("BuildOptions", fpdBuildOptions);
 350
 351         //
 352         // Third part: get Module info from FPD, such as Library instances, PCDs
 353         //
 354         if (fpdModuleSA.containsKey(fpdModuleId)){
 355             //
 356             // merge module info in FPD to final Doc
 357             // For Library Module, do nothing here
 358             //
 359             doc.putAll(fpdModuleSA.get(fpdModuleId));
 360         }
 361         parsedModules.put(fpdModuleId, doc);
 362         return doc;
 363     }
 364
 365     public synchronized static Map<String, XmlObject> getDoc(ModuleIdentification moduleId, String arch) throws BuildException {
 366         FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, arch);
 367         return getDoc(fpdModuleId);
 368     }
 369     /**
 370       Query the native MSA information with module base name.
 371
 372       <p>Note that MSA parsing is incremental. That means the method will
 373       only to parse the MSA files when never parsed before. </p>
 374
 375       @param moduleName the base name of the module
 376       @return the native MSA information
 377       @throws BuildException
 378               MSA file is not valid
 379     **/
 380     public synchronized static Map<String, XmlObject> getNativeMsa(ModuleIdentification moduleId) throws BuildException {
 381         if (nativeMsa.containsKey(moduleId)) {
 382             return nativeMsa.get(moduleId);
 383         }
 384         File msaFile = getMsaFile(moduleId);
 385         Map<String, XmlObject> msaMap = getNativeMsa(msaFile);
 386         nativeMsa.put(moduleId, msaMap);
 387         return msaMap;
 388     }
 389
 390     public synchronized static Map<String, XmlObject> getNativeMsa(File msaFile) throws BuildException {
 391         if (! msaFile.exists()) {
 392             throw new BuildException("Surface Area file [" + msaFile.getPath() + "] can't found.");
 393         }
 394         try {
 395             ModuleSurfaceAreaDocument doc = (ModuleSurfaceAreaDocument)XmlObject.Factory.parse(msaFile);
 396             //
 397             // Validate File if they accord with XML Schema
 398             //
 399             if ( ! doc.validate()){
 400                 throw new BuildException("Module Surface Area file [" + msaFile.getPath() + "] is invalid.");
 401             }
 402             //
 403             // parse MSA file
 404             //
 405             ModuleSurfaceArea msa= doc.getModuleSurfaceArea();
 406             Map<String, XmlObject> msaMap = new HashMap<String, XmlObject>();
 407             msaMap.put("MsaHeader", cloneXmlObject(msa.getMsaHeader(), true));
 408             msaMap.put("ModuleDefinitions", cloneXmlObject(msa.getModuleDefinitions(), true));
 409             msaMap.put("LibraryClassDefinitions", cloneXmlObject(msa.getLibraryClassDefinitions(), true));
 410             msaMap.put("SourceFiles", cloneXmlObject(msa.getSourceFiles(), true));
 411             msaMap.put("PackageDependencies", cloneXmlObject(msa.getPackageDependencies(), true));
 412             msaMap.put("Protocols", cloneXmlObject(msa.getProtocols(), true));
 413             msaMap.put("PPIs", cloneXmlObject(msa.getPPIs(), true));
 414             msaMap.put("Guids", cloneXmlObject(msa.getGuids(), true));
 415             msaMap.put("Externs", cloneXmlObject(msa.getExterns(), true));
 416             msaMap.put("PcdCoded", cloneXmlObject(msa.getPcdCoded(), true));
 417             return msaMap;
 418         }
 419         catch (Exception ex){
 420             throw new BuildException(ex.getMessage());
 421         }
 422     }
 423
 424     public static Map<String, XmlObject> getFpdBuildOptions() {
 425         Map<String, XmlObject> map = new HashMap<String, XmlObject>();
 426         map.put("BuildOptions", fpdBuildOptions);
 427         return map;
 428     }
 429
 430     public static void setFpdBuildOptions(XmlObject fpdBuildOptions) {
 431         GlobalData.fpdBuildOptions = cloneXmlObject(fpdBuildOptions, true);
 432     }
 433
 434     public static XmlObject getFpdDynamicPcds() {
 435         return fpdDynamicPcds;
 436     }
 437
 438     public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds) {
 439         GlobalData.fpdDynamicPcds = fpdDynamicPcds;
 440     }
 441
 442     //////////////////////////////////////////////
 443     //////////////////////////////////////////////
 444
 445     public static Set<ModuleIdentification> getModules(PackageIdentification packageId){
 446         Spd spd = spdTable.get(packageId);
 447         if (spd == null ) {
 448             Set<ModuleIdentification> dummy = new HashSet<ModuleIdentification>();
 449             return dummy;
 450         }
 451         else {
 452             return spd.getModules();
 453         }
 454     }
 455
 456     /**
 457      * The header file path is relative to workspace dir
 458      */
 459     public static String[] getLibraryClassHeaderFiles(
 460             PackageIdentification[] packages, String name)
 461             throws BuildException {
 462         if (packages == null) {
 463             // throw Exception or not????
 464             return new String[0];
 465         }
 466         String[] result = null;
 467         for (int i = 0; i < packages.length; i++) {
 468             Spd spd = spdTable.get(packages[i]);
 469             //
 470             // If find one package defined the library class
 471             //
 472             if ((result = spd.getLibClassIncluder(name)) != null) {
 473                 return result;
 474             }
 475         }
 476         //
 477         // If can't find library class declaration in every package
 478         //
 479         throw new BuildException("Can not find library class [" + name
 480                 + "] declaration in every packages. ");
 481     }
 482
 483     /**
 484      * The header file path is relative to workspace dir
 485      */
 486     public static String getPackageHeaderFiles(PackageIdentification packages,
 487             String moduleType) throws BuildException {
 488         if (packages == null) {
 489             return new String("");
 490         }
 491         Spd spd = spdTable.get(packages);
 492         //
 493         // If can't find package header file, skip it
 494         //
 495         String temp = null;
 496         if (spd != null) {
 497             if ((temp = spd.getPackageIncluder(moduleType)) != null) {
 498                 return temp;
 499             } else {
 500                 temp = "";
 501                 return temp;
 502             }
 503         } else {
 504             return null;
 505         }
 506     }
 507
 508     /**
 509      * return two values: {cName, GuidValue}
 510      */
 511     public static String[] getGuid(List<PackageIdentification> packages, String name)
 512             throws BuildException {
 513         if (packages == null) {
 514             // throw Exception or not????
 515             return new String[0];
 516         }
 517         String[] result = null;
 518         Iterator item = packages.iterator();
 519         while (item.hasNext()){
 520             Spd spd = spdTable.get(item.next());
 521             //
 522             // If find one package defined the GUID
 523             //
 524             if ((result = spd.getGuid(name)) != null) {
 525                 return result;
 526             }
 527         }
 528
 529         return null;
 530     }
 531
 532     /**
 533      * return two values: {cName, GuidValue}
 534      */
 535     public static String[] getPpiGuid(List<PackageIdentification> packages,
 536             String name) throws BuildException {
 537         if (packages == null) {
 538             return new String[0];
 539         }
 540         String[] result = null;
 541         Iterator item = packages.iterator();
 542         while (item.hasNext()){
 543             Spd spd = spdTable.get(item.next());
 544             //
 545             // If find one package defined the Ppi GUID
 546             //
 547             if ((result = spd.getPpi(name)) != null) {
 548                 return result;
 549             }
 550         }
 551         return null;
 552
 553     }
 554
 555     /**
 556      * return two values: {cName, GuidValue}
 557      */
 558     public static String[] getProtocolGuid(List<PackageIdentification> packages,
 559             String name) throws BuildException {
 560         if (packages == null) {
 561             return new String[0];
 562         }
 563         String[] result = null;
 564         Iterator item = packages.iterator();
 565         while (item.hasNext()){
 566             Spd spd = spdTable.get(item.next());
 567             //
 568             // If find one package defined the protocol GUID
 569             //
 570             if ((result = spd.getProtocol(name))!= null){
 571                 return result;
 572             }
 573         }
 574         return null;
 575
 576     }
 577
 578     public synchronized static PlatformIdentification getPlatformByName(String name) throws BuildException {
 579         Iterator iter = platformList.iterator();
 580         while(iter.hasNext()){
 581             PlatformIdentification platformId = (PlatformIdentification)iter.next();
 582             if (platformId.getName().equalsIgnoreCase(name)) {
 583                 return platformId;
 584             }
 585         }
 586         throw new BuildException("Can't find platform [" + name + "] in current workspace database. ");
 587     }
 588
 589     public synchronized static PlatformIdentification getPlatform(String filename) throws BuildException {
 590         File file = new File(workspaceDir + File.separatorChar + filename);
 591         Iterator iter = platformList.iterator();
 592         while(iter.hasNext()){
 593             PlatformIdentification platformId = (PlatformIdentification)iter.next();
 594             if (platformId.getFpdFile().getPath().equalsIgnoreCase(file.getPath())) {
 595                 return platformId;
 596             }
 597         }
 598         throw new BuildException("Can't find platform file [" + filename + "] in current workspace database. ");
 599     }
 600
 601     public synchronized static PackageIdentification refreshPackageIdentification(PackageIdentification packageId) throws BuildException {
 602         Iterator iter = packageList.iterator();
 603         while(iter.hasNext()){
 604             PackageIdentification packageItem = (PackageIdentification)iter.next();
 605             if (packageItem.equals(packageId)) {
 606                 packageId.setName(packageItem.getName());
 607                 packageId.setSpdFile(packageItem.getSpdFile());
 608                 return packageId;
 609             }
 610         }
 611         throw new BuildException("Can't find package GUID value " + packageId.getGuid() + " under current workspace. ");
 612     }
 613
 614     public synchronized static ModuleIdentification refreshModuleIdentification(ModuleIdentification moduleId) throws BuildException {
 615 //        System.out.println("1");
 616 //        System.out.println("##" + moduleId.getGuid());
 617         PackageIdentification packageId = getPackageForModule(moduleId);
 618 //        System.out.println("" + packageId.getGuid());
 619         moduleId.setPackage(packageId);
 620         Spd spd = spdTable.get(packageId);
 621         if (spd == null) {
 622             throw new BuildException("Can't find package GUID value " + packageId.getGuid() + " under current workspace. ");
 623         }
 624         Set<ModuleIdentification> modules = spd.getModules();
 625         Iterator<ModuleIdentification> iter = modules.iterator();
 626         while (iter.hasNext()) {
 627             ModuleIdentification item = iter.next();
 628             if (item.equals(moduleId)) {
 629                 moduleId.setName(item.getName());
 630                 moduleId.setModuleType(item.getModuleType());
 631                 moduleId.setMsaFile(item.getMsaFile());
 632                 return moduleId;
 633             }
 634         }
 635         throw new BuildException("Can't find module GUID value " + moduleId.getGuid() + " in " + packageId + " under current workspace. ");
 636     }
 637
 638     public synchronized static Set<PackageIdentification> getPackageList(){
 639         return packageList;
 640     }
 641     ///// remove!!
 642     private static XmlObject cloneXmlObject(XmlObject object, boolean deep) throws BuildException {
 643         if ( object == null) {
 644             return null;
 645         }
 646         XmlObject result = null;
 647         try {
 648             result = XmlObject.Factory.parse(object.getDomNode()
 649                             .cloneNode(deep));
 650         } catch (Exception ex) {
 651             throw new BuildException(ex.getMessage());
 652         }
 653         return result;
 654     }
 655
 656     ////// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
 657
 658     public static ToolChainInfo getToolChainInfo() {
 659 //        GlobalData.log.info(toolsDef.getConfigInfo() + "" + toolChainEnvInfo + toolChainPlatformInfo);
 660         if (toolChainInfo == null) {
 661             toolChainInfo = toolsDef.getConfigInfo().intersection(toolChainEnvInfo);
 662             if (toolChainPlatformInfo != null) {
 663                 toolChainInfo = toolChainInfo.intersection(toolChainPlatformInfo);
 664             }
 665             toolChainInfo.addCommands(toolsDef.getConfigInfo().getCommands());
 666             toolChainInfo.normalize();
 667             GlobalData.log.info(toolChainInfo + "");
 668         }
 669         return toolChainInfo;
 670     }
 671
 672
 673
 674     public static void setPlatformToolChainFamilyOption(ToolChainMap map) {
 675         platformToolChainFamilyOption = map;
 676     }
 677
 678     public static void setPlatformToolChainOption(ToolChainMap map) {
 679         platformToolChainOption = map;
 680     }
 681
 682     public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId,
 683         ToolChainMap toolChainOption) {
 684         moduleToolChainOption.put(fpdModuleId, toolChainOption);
 685     }
 686
 687     public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId,
 688         ToolChainMap toolChainOption) {
 689         moduleToolChainFamilyOption.put(fpdModuleId, toolChainOption);
 690     }
 691
 692     public static boolean isCommandSet(String target, String toolchain, String arch) {
 693         String[] commands = getToolChainInfo().getCommands();
 694
 695         for (int i = 0; i < commands.length; ++i) {
 696             String cmdName = toolsDef.getConfig().get(new String[] {target, toolchain, arch, commands[i], ToolChainAttribute.NAME.toString()});
 697             if (cmdName != null && cmdName.length() != 0) {
 698                 return true;
 699             }
 700         }
 701
 702         return false;
 703     }
 704
 705     public static String getCommandSetting(String[] commandDescription, FpdModuleIdentification fpdModuleId) throws EdkException {
 706         ToolChainKey toolChainKey = new ToolChainKey(commandDescription);
 707         ToolChainMap toolChainConfig = toolsDef.getConfig();
 708         String setting = null;
 709
 710         if (!commandDescription[ToolChainElement.ATTRIBUTE.value].equals(ToolChainAttribute.FLAGS.toString())) {
 711             setting = toolChainConfig.get(toolChainKey);
 712             if (setting == null) {
 713                 setting = "";
 714             }
 715             return setting;
 716         }
 717
 718         //
 719         // get module specific options, if any
 720         //
 721         // tool tag first
 722         ToolChainMap option = moduleToolChainOption.get(fpdModuleId);
 723         ToolChainKey toolChainFamilyKey = null;
 724
 725         if ((option == null) || (option != null && (setting = option.get(toolChainKey)) == null)) {
 726             //
 727             // then tool chain family
 728             //
 729             toolChainFamilyKey = new ToolChainKey(commandDescription);
 730             toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);
 731             String family = toolChainConfig.get(toolChainFamilyKey);
 732             toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);
 733             toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);
 734
 735             option = moduleToolChainFamilyOption.get(fpdModuleId);
 736             if (option != null) {
 737                 setting = option.get(toolChainFamilyKey);
 738             }
 739         }
 740
 741         //
 742         // get platform options, if any
 743         //
 744         if (setting == null) {
 745             // tool tag first
 746             if (platformToolChainOption == null || (setting = platformToolChainOption.get(toolChainKey)) == null) {
 747                 // then tool chain family
 748                 if (toolChainFamilyKey == null) {
 749                     toolChainFamilyKey = new ToolChainKey(commandDescription);
 750                     toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);
 751                     String family = toolChainConfig.get(toolChainFamilyKey);
 752                     toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);
 753                     toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);
 754                 }
 755
 756                 setting = platformToolChainFamilyOption.get(toolChainFamilyKey);
 757             }
 758         }
 759
 760         if (setting == null) {
 761             setting = "";
 762         }
 763
 764         return setting;
 765     }
 766
 767     public static void setToolChainEnvInfo(ToolChainInfo envInfo) {
 768         toolChainEnvInfo = envInfo;
 769     }
 770     public static void setToolChainPlatformInfo(ToolChainInfo platformInfo) {
 771         toolChainPlatformInfo = platformInfo;
 772     }
 773
 774     //
 775     // for PCD
 776     //
 777     public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {
 778         return pcdDbManager;
 779     }
 780
 781     //
 782     // For PCD get tokenSpaceGUid
 783     //
 784     public synchronized static String[] getGuidInfoFromCname(String cName){
 785         String cNameGuid[] = null;
 786         String guid = null;
 787         Set set = spdTable.keySet();
 788         Iterator iter = set.iterator();
 789
 790         if (iter == null) {
 791             return null;
 792         }
 793
 794         while (iter.hasNext()){
 795             Spd spd = (Spd) spdTable.get(iter.next());
 796             guid = spd.getGuidFromCname(cName);
 797             if (guid != null){
 798                 cNameGuid = new String[2];
 799                 cNameGuid[0] = cName;
 800                 cNameGuid[1] = guid;
 801                 break;
 802             }
 803         }
 804         return cNameGuid;
 805     }
 806
 807     //
 808     // For PCD
 809     //
 810     public synchronized static Map<FpdModuleIdentification, XmlObject> getFpdModuleSaXmlObject(
 811             String xmlObjectName) {
 812         Set<FpdModuleIdentification> fpdModuleSASet = fpdModuleSA.keySet();
 813         Iterator item = fpdModuleSASet.iterator();
 814
 815
 816         Map<FpdModuleIdentification, XmlObject> SAPcdBuildDef = new HashMap<FpdModuleIdentification, XmlObject>();
 817         Map<String, XmlObject> SANode = new HashMap<String, XmlObject>();
 818         FpdModuleIdentification moduleId;
 819         while (item.hasNext()) {
 820
 821             moduleId = (FpdModuleIdentification) item.next();
 822             SANode = fpdModuleSA.get(moduleId);
 823             try{
 824                 if (SANode.get(xmlObjectName)!= null){
 825                     SAPcdBuildDef.put(moduleId,
 826                             (XmlObject) SANode
 827                                     .get(xmlObjectName));
 828
 829                 }
 830
 831
 832             } catch (Exception e){
 833                 EdkLog.log(EdkLog.EDK_INFO, e.getMessage());
 834             }
 835             }
 836         return SAPcdBuildDef;
 837     }
 838 }
 839