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