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