4 GlobalData provide initializing, instoring, querying and update global data.
5 It is a bridge to intercommunicate between multiple component, such as AutoGen,
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
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.
17 package org
.tianocore
.build
.global
;
19 import org
.apache
.tools
.ant
.BuildException
;
20 import org
.apache
.xmlbeans
.XmlObject
;
21 import org
.tianocore
.DbPathAndFilename
;
22 import org
.tianocore
.FrameworkDatabaseDocument
;
23 import org
.tianocore
.ModuleSurfaceAreaDocument
;
24 import org
.tianocore
.ModuleSurfaceAreaDocument
.ModuleSurfaceArea
;
25 import org
.tianocore
.build
.exception
.EdkException
;
26 import org
.tianocore
.build
.id
.FpdModuleIdentification
;
27 import org
.tianocore
.build
.id
.ModuleIdentification
;
28 import org
.tianocore
.build
.id
.PackageIdentification
;
29 import org
.tianocore
.build
.id
.PlatformIdentification
;
30 import org
.tianocore
.build
.toolchain
.ToolChainAttribute
;
31 import org
.tianocore
.build
.toolchain
.ToolChainConfig
;
32 import org
.tianocore
.build
.toolchain
.ToolChainElement
;
33 import org
.tianocore
.build
.toolchain
.ToolChainInfo
;
34 import org
.tianocore
.build
.toolchain
.ToolChainKey
;
35 import org
.tianocore
.build
.toolchain
.ToolChainMap
;
36 //import org.tianocore.build.pcd.entity.MemoryDatabaseManager;
37 //import org.tianocore.logger.EdkLog;
40 import java
.util
.HashMap
;
41 import java
.util
.HashSet
;
42 import java
.util
.Iterator
;
43 import java
.util
.List
;
46 import java
.util
.logging
.Logger
;
49 GlobalData provide initializing, instoring, querying and update global data.
50 It is a bridge to intercommunicate between multiple component, such as AutoGen,
53 <p>Note that all global information are initialized incrementally. All data will
54 parse and record only of necessary during build time. </p>
58 public class GlobalData
{
60 public static Logger log
= Logger
.getAnonymousLogger();
63 /// Record current WORKSPACE Directory
65 private static String workspaceDir
= "";
68 /// Be used to ensure Global data will be initialized only once.
70 private static boolean globalFlag
= false;
73 /// Framework Database information: package list and platform list
75 private static Set
<PackageIdentification
> packageList
= new HashSet
<PackageIdentification
>();
77 private static Set
<PlatformIdentification
> platformList
= new HashSet
<PlatformIdentification
>();
80 /// Every detail SPD informations: Module list, Library class definition,
81 /// Package header file, GUID/PPI/Protocol definitions
83 private static final Map
<PackageIdentification
, Spd
> spdTable
= new HashMap
<PackageIdentification
, Spd
>();
86 /// Build informations are divided into three parts:
87 /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
89 private static Map
<ModuleIdentification
, Map
<String
, XmlObject
>> nativeMsa
= new HashMap
<ModuleIdentification
, Map
<String
, XmlObject
>>();
91 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> fpdModuleSA
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
93 private static XmlObject fpdBuildOptions
;
95 private static XmlObject fpdDynamicPcds
;
98 /// Parsed modules list
100 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> parsedModules
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
103 /// built modules list with ARCH, TARGET, TOOLCHAIN
105 private static Set
<FpdModuleIdentification
> builtModules
= new HashSet
<FpdModuleIdentification
>();
108 /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.
110 // private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();
113 /// build target + tool chain family/tag name + arch + command types + command options
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
121 private static ToolChainConfig toolsDef
;
123 private static ToolChainInfo toolChainInfo
;
124 private static ToolChainInfo toolChainEnvInfo
;
125 private static ToolChainInfo toolChainPlatformInfo
;
127 private static ToolChainMap platformToolChainOption
;
128 private static ToolChainMap platformToolChainFamilyOption
;
130 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
131 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainFamilyOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
133 // private static final MemoryDatabasseManager pcdDbManager = new MemoryDatabaseManager();
138 Parse framework database (DB) and all SPD files listed in DB to initialize
139 the environment for next build. This method will only be executed only once
140 in the whole build process.
142 @param workspaceDatabaseFile the file name of framework database
143 @param workspaceDir current workspace directory path
144 @throws BuildException
145 Framework Dababase or SPD or MSA file is not valid
147 public synchronized static void initInfo(String workspaceDatabaseFile
, String workspaceDir
, String toolsDefFilename
) throws BuildException
{
149 // ensure this method will be revoked only once
157 // Backup workspace directory. It will be used by other method
159 GlobalData
.workspaceDir
= workspaceDir
.replaceAll("(\\\\)", "/");
162 // Parse tools definition file
165 // If ToolChain has been set up before, do nothing.
166 // CONF dir + tools definition file name
168 String confDir
= GlobalData
.workspaceDir
+ File
.separatorChar
+ "Tools" + File
.separatorChar
+ "Conf";
169 File toolsDefFile
= new File(confDir
+ File
.separatorChar
+ toolsDefFilename
);
170 System
.out
.println("Using file [" + toolsDefFile
.getPath() + "] as tools definition file. ");
171 toolsDef
= new ToolChainConfig(toolsDefFile
);
174 // Parse Framework Database
176 File dbFile
= new File(workspaceDir
+ File
.separatorChar
+ workspaceDatabaseFile
);
178 FrameworkDatabaseDocument db
= (FrameworkDatabaseDocument
) XmlObject
.Factory
.parse(dbFile
);
180 // validate FrameworkDatabaseFile
182 if (! db
.validate()) {
183 throw new BuildException("Framework Database file [" + dbFile
.getPath() + "] is invalid.");
188 if (db
.getFrameworkDatabase().getPackageList() != null ) {
189 List
<DbPathAndFilename
> packages
= db
.getFrameworkDatabase().getPackageList().getFilenameList();
190 Iterator
<DbPathAndFilename
> iter
= packages
.iterator();
191 while (iter
.hasNext()) {
192 String fileName
= iter
.next().getStringValue();
193 Spd spd
= new Spd(new File(workspaceDir
+ File
.separatorChar
+ fileName
));
194 packageList
.add(spd
.getPackageId());
195 spdTable
.put(spd
.getPackageId(), spd
);
202 if (db
.getFrameworkDatabase().getPlatformList() != null) {
203 List
<DbPathAndFilename
> platforms
= db
.getFrameworkDatabase().getPlatformList().getFilenameList();
204 Iterator
<DbPathAndFilename
> iter
= platforms
.iterator();
205 while (iter
.hasNext()) {
206 String fileName
= iter
.next().getStringValue();
207 File fpdFile
= new File(workspaceDir
+ File
.separatorChar
+ fileName
);
208 if ( ! fpdFile
.exists() ) {
209 throw new BuildException("Platform file [" + fpdFile
.getPath() + "] not exists. ");
211 XmlObject fpdDoc
= XmlObject
.Factory
.parse(fpdFile
);
213 // Verify FPD file, if is invalid, throw Exception
215 if (! fpdDoc
.validate()) {
216 throw new BuildException("Framework Platform Surface Area file [" + fpdFile
.getPath() + "] is invalid. ");
219 // We can change Map to XmlObject
222 // TBD check SPD or FPD is existed in FS
224 Map
<String
, XmlObject
> fpdDocMap
= new HashMap
<String
, XmlObject
>();
225 fpdDocMap
.put("PlatformSurfaceArea", fpdDoc
);
226 SurfaceAreaQuery
.setDoc(fpdDocMap
);
227 PlatformIdentification platformId
= SurfaceAreaQuery
.getFpdHeader();
228 platformId
.setFpdFile(fpdFile
);
229 platformList
.add(platformId
);
232 } catch (Exception e
) {
234 throw new BuildException("Parse workspace Database [" + dbFile
.getPath() + "] Error.\n" + e
.getMessage());
239 Get the current WORKSPACE Directory.
241 @return current workspace directory
243 public synchronized static String
getWorkspacePath() {
249 Get the MSA file name with absolute path
251 public synchronized static File
getMsaFile(ModuleIdentification moduleId
) throws BuildException
{
254 // TBD. Do only when package is null.
256 Iterator iter
= packageList
.iterator();
257 while (iter
.hasNext()) {
258 PackageIdentification packageId
= (PackageIdentification
)iter
.next();
259 Spd spd
= spdTable
.get(packageId
);
260 msaFile
= spd
.getModuleFile(moduleId
);
261 if (msaFile
!= null ) {
265 if (msaFile
== null){
266 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
273 public synchronized static PackageIdentification
getPackageForModule(ModuleIdentification moduleId
) {
275 // If package already defined in module
277 if (moduleId
.getPackage() != null) {
278 return moduleId
.getPackage();
281 PackageIdentification packageId
= null;
282 Iterator iter
= packageList
.iterator();
283 while (iter
.hasNext()) {
284 packageId
= (PackageIdentification
)iter
.next();
285 moduleId
.setPackage(packageId
);
286 Spd spd
= spdTable
.get(packageId
);
287 if (spd
.getModuleFile(moduleId
) != null ) {
291 if (packageId
== null){
292 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
300 Difference between build and parse: ToolChain and Target
302 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId
) {
303 return builtModules
.contains(moduleId
);
306 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId
) {
307 builtModules
.add(fpdModuleId
);
311 public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId
, Map
<String
, XmlObject
> doc
) {
312 Map
<String
, XmlObject
> result
= new HashMap
<String
, XmlObject
>();
313 Set keySet
= doc
.keySet();
314 Iterator iter
= keySet
.iterator();
315 while (iter
.hasNext()){
316 String key
= (String
)iter
.next();
317 XmlObject item
= cloneXmlObject(doc
.get(key
), true);
318 result
.put(key
, item
);
320 fpdModuleSA
.put(fpdModuleId
, result
);
324 Query overrided module surface area information. If current is Package
325 or Platform build, also include the information from FPD file.
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>
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
335 public synchronized static Map
<String
, XmlObject
> getDoc(FpdModuleIdentification fpdModuleId
) throws BuildException
{
336 if (parsedModules
.containsKey(fpdModuleId
)) {
337 return parsedModules
.get(fpdModuleId
);
339 Map
<String
, XmlObject
> doc
= new HashMap
<String
, XmlObject
>();
340 ModuleIdentification moduleId
= fpdModuleId
.getModule();
342 // First part: get the MSA files info
344 doc
= getNativeMsa(moduleId
);
347 // Second part: put build options
349 doc
.put("BuildOptions", fpdBuildOptions
);
352 // Third part: get Module info from FPD, such as Library instances, PCDs
354 if (fpdModuleSA
.containsKey(fpdModuleId
)){
356 // merge module info in FPD to final Doc
357 // For Library Module, do nothing here
359 doc
.putAll(fpdModuleSA
.get(fpdModuleId
));
361 parsedModules
.put(fpdModuleId
, doc
);
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
);
370 Query the native MSA information with module base name.
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>
375 @param moduleName the base name of the module
376 @return the native MSA information
377 @throws BuildException
378 MSA file is not valid
380 public synchronized static Map
<String
, XmlObject
> getNativeMsa(ModuleIdentification moduleId
) throws BuildException
{
381 if (nativeMsa
.containsKey(moduleId
)) {
382 return nativeMsa
.get(moduleId
);
384 File msaFile
= getMsaFile(moduleId
);
385 Map
<String
, XmlObject
> msaMap
= getNativeMsa(msaFile
);
386 nativeMsa
.put(moduleId
, msaMap
);
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.");
395 ModuleSurfaceAreaDocument doc
= (ModuleSurfaceAreaDocument
)XmlObject
.Factory
.parse(msaFile
);
397 // Validate File if they accord with XML Schema
399 if ( ! doc
.validate()){
400 throw new BuildException("Module Surface Area file [" + msaFile
.getPath() + "] is invalid.");
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));
418 catch (Exception ex
){
419 throw new BuildException(ex
.getMessage());
423 public static Map
<String
, XmlObject
> getFpdBuildOptions() {
424 Map
<String
, XmlObject
> map
= new HashMap
<String
, XmlObject
>();
425 map
.put("BuildOptions", fpdBuildOptions
);
429 public static void setFpdBuildOptions(XmlObject fpdBuildOptions
) {
430 GlobalData
.fpdBuildOptions
= cloneXmlObject(fpdBuildOptions
, true);
433 public static XmlObject
getFpdDynamicPcds() {
434 return fpdDynamicPcds
;
437 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds
) {
438 GlobalData
.fpdDynamicPcds
= fpdDynamicPcds
;
441 //////////////////////////////////////////////
442 //////////////////////////////////////////////
444 public static Set
<ModuleIdentification
> getModules(PackageIdentification packageId
){
445 Spd spd
= spdTable
.get(packageId
);
447 Set
<ModuleIdentification
> dummy
= new HashSet
<ModuleIdentification
>();
451 return spd
.getModules();
456 * The header file path is relative to workspace dir
458 public static String
[] getLibraryClassHeaderFiles(
459 PackageIdentification
[] packages
, String name
)
460 throws BuildException
{
461 if (packages
== null) {
462 // throw Exception or not????
463 return new String
[0];
465 String
[] result
= null;
466 for (int i
= 0; i
< packages
.length
; i
++) {
467 Spd spd
= spdTable
.get(packages
[i
]);
469 // If find one package defined the library class
471 if ((result
= spd
.getLibClassIncluder(name
)) != null) {
476 // If can't find library class declaration in every package
478 throw new BuildException("Can not find library class [" + name
479 + "] declaration in every packages. ");
483 * The header file path is relative to workspace dir
485 public static String
getPackageHeaderFiles(PackageIdentification packages
,
486 String moduleType
) throws BuildException
{
487 if (packages
== null) {
488 return new String("");
490 Spd spd
= spdTable
.get(packages
);
492 // If can't find package header file, skip it
496 if ((temp
= spd
.getPackageIncluder(moduleType
)) != null) {
508 * return two values: {cName, GuidValue}
510 public static String
[] getGuid(PackageIdentification
[] packages
, String name
)
511 throws BuildException
{
512 if (packages
== null) {
513 // throw Exception or not????
514 return new String
[0];
516 String
[] result
= null;
517 for (int i
= 0; i
< packages
.length
; i
++) {
518 Spd spd
= spdTable
.get(packages
[i
]);
520 // If find one package defined the GUID
522 if ((result
= spd
.getGuid(name
)) != null) {
530 * return two values: {cName, GuidValue}
532 public static String
[] getPpiGuid(PackageIdentification
[] packages
,
533 String name
) throws BuildException
{
534 if (packages
== null) {
535 return new String
[0];
537 String
[] result
= null;
538 for (int i
= 0; i
< packages
.length
; i
++) {
539 Spd spd
= spdTable
.get(packages
[i
]);
541 // If find one package defined the Ppi GUID
543 if ((result
= spd
.getPpi(name
)) != null) {
552 * return two values: {cName, GuidValue}
554 public static String
[] getProtocolGuid(PackageIdentification
[] packages
,
555 String name
) throws BuildException
{
556 if (packages
== null) {
557 return new String
[0];
559 String
[] result
= null;
560 for (int i
= 0; i
< packages
.length
; i
++) {
561 Spd spd
= spdTable
.get(packages
[i
]);
563 // If find one package defined the protocol GUID
565 if ((result
= spd
.getProtocol(name
)) != null) {
573 /////////////////////////// Update!! Update!! Update!!
574 // public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {
575 // return pcdDbManager;
577 ///////////////////////////
578 public synchronized static PlatformIdentification
getPlatform(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 // GlobalData.log.info("Platform: " + platformId + platformId.getFpdFile());
587 throw new BuildException("Can't find platform [" + name
+ "] in current workspace. ");
590 public synchronized static PackageIdentification
refreshPackageIdentification(PackageIdentification packageId
) throws BuildException
{
591 Iterator iter
= packageList
.iterator();
592 while(iter
.hasNext()){
593 PackageIdentification packageItem
= (PackageIdentification
)iter
.next();
594 if (packageItem
.equals(packageId
)) {
595 packageId
.setName(packageItem
.getName());
596 packageId
.setSpdFile(packageItem
.getSpdFile());
600 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
603 public synchronized static ModuleIdentification
refreshModuleIdentification(ModuleIdentification moduleId
) throws BuildException
{
604 // System.out.println("1");
605 // System.out.println("##" + moduleId.getGuid());
606 PackageIdentification packageId
= getPackageForModule(moduleId
);
607 // System.out.println("" + packageId.getGuid());
608 moduleId
.setPackage(packageId
);
609 Spd spd
= spdTable
.get(packageId
);
611 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
613 Set
<ModuleIdentification
> modules
= spd
.getModules();
614 Iterator
<ModuleIdentification
> iter
= modules
.iterator();
615 while (iter
.hasNext()) {
616 ModuleIdentification item
= iter
.next();
617 if (item
.equals(moduleId
)) {
618 moduleId
.setName(item
.getName());
619 moduleId
.setModuleType(item
.getModuleType());
620 moduleId
.setMsaFile(item
.getMsaFile());
624 throw new BuildException("Can't find module GUID value " + moduleId
.getGuid() + " in " + packageId
+ " under current workspace. ");
627 public synchronized static Set
<PackageIdentification
> getPackageList(){
631 private static XmlObject
cloneXmlObject(XmlObject object
, boolean deep
) throws BuildException
{
632 if ( object
== null) {
635 XmlObject result
= null;
637 result
= XmlObject
.Factory
.parse(object
.getDomNode()
639 } catch (Exception ex
) {
640 throw new BuildException(ex
.getMessage());
645 ////// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
647 public static ToolChainInfo
getToolChainInfo() {
648 // GlobalData.log.info(toolsDef.getConfigInfo() + "" + toolChainEnvInfo + toolChainPlatformInfo);
649 if (toolChainInfo
== null) {
650 toolChainInfo
= toolsDef
.getConfigInfo().intersection(toolChainEnvInfo
);
651 if (toolChainPlatformInfo
!= null) {
652 toolChainInfo
= toolChainInfo
.intersection(toolChainPlatformInfo
);
654 toolChainInfo
.addCommands(toolsDef
.getConfigInfo().getCommands());
655 toolChainInfo
.normalize();
656 GlobalData
.log
.info(toolChainInfo
+ "");
658 return toolChainInfo
;
663 public static void setPlatformToolChainFamilyOption(ToolChainMap map
) {
664 platformToolChainFamilyOption
= map
;
667 public static void setPlatformToolChainOption(ToolChainMap map
) {
668 platformToolChainOption
= map
;
671 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId
,
672 ToolChainMap toolChainOption
) {
673 moduleToolChainOption
.put(fpdModuleId
, toolChainOption
);
676 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId
,
677 ToolChainMap toolChainOption
) {
678 moduleToolChainFamilyOption
.put(fpdModuleId
, toolChainOption
);
681 public static String
getCommandSetting(String
[] commandDescription
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
682 ToolChainKey toolChainKey
= new ToolChainKey(commandDescription
);
683 ToolChainMap toolChainConfig
= toolsDef
.getConfig();
684 String setting
= null;
686 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
687 setting
= toolChainConfig
.get(toolChainKey
);
688 if (setting
== null) {
695 // get module specific options, if any
698 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
699 ToolChainKey toolChainFamilyKey
= null;
701 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
703 // then tool chain family
705 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
706 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
707 String family
= toolChainConfig
.get(toolChainFamilyKey
);
708 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
709 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
711 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
712 if (option
!= null) {
713 setting
= option
.get(toolChainFamilyKey
);
718 // get platform options, if any
720 if (setting
== null) {
722 if (platformToolChainOption
== null || (setting
= platformToolChainOption
.get(toolChainKey
)) == null) {
723 // then tool chain family
724 if (toolChainFamilyKey
== null) {
725 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
726 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
727 String family
= toolChainConfig
.get(toolChainFamilyKey
);
728 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
729 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
732 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
736 if (setting
== null) {
743 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
744 toolChainEnvInfo
= envInfo
;
746 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
747 toolChainPlatformInfo
= platformInfo
;
753 // public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {
754 // return pcdDbManager;
765 // public synchronized static String[] getGuidInfoGuid(String guidName) {
766 // String[] cNameGuid = null;
767 // Set set = spdTable.keySet();
768 // Iterator iter = set.iterator();
770 // while (iter.hasNext()) {
771 // Spd spd = (Spd) spdTable.get(iter.next());
772 // cNameGuid = spd.getGuidNameArray(guidName);
773 // if (cNameGuid != null) {
783 // public synchronized static Map<FpdModuleIdentification, XmlObject> getFpdModuleSaXmlObject(
784 // String xmlObjectName) {
785 // Set<FpdModuleIdentification> fpdModuleSASet = fpdModuleSA.keySet();
786 // Iterator item = fpdModuleSASet.iterator();
788 // Map<FpdModuleIdentification, XmlObject> SAPcdBuildDef = new HashMap<FpdModuleIdentification, XmlObject>();
789 // Map<String, XmlObject> SANode = new HashMap<String, XmlObject>();
790 // FpdModuleIdentification moduleId;
791 // while (item.hasNext()) {
792 // moduleId = (FpdModuleIdentification) item.next();
793 // SANode = fpdModuleSA.get(item.next());
794 // SAPcdBuildDef.put(moduleId,
795 // (PcdBuildDefinitionDocument.PcdBuildDefinition) SANode
796 // .get(xmlObjectName));
798 // return SAPcdBuildDef;