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
;
20 import java
.util
.HashMap
;
21 import java
.util
.HashSet
;
22 import java
.util
.Iterator
;
23 import java
.util
.List
;
26 import java
.util
.logging
.Logger
;
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
;
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
>();
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.
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
143 public synchronized static void initInfo(String workspaceDatabaseFile
, String workspaceDir
, String toolsDefFilename
) throws BuildException
{
145 // ensure this method will be revoked only once
153 // Backup workspace directory. It will be used by other method
155 GlobalData
.workspaceDir
= workspaceDir
.replaceAll("(\\\\)", "/");
158 // Parse tools definition file
161 // If ToolChain has been set up before, do nothing.
162 // CONF dir + tools definition file name
164 File toolsDefFile
= new File(workspaceDir
+ File
.separatorChar
+ toolsDefFilename
);
165 System
.out
.println("Using file [" + toolsDefFile
.getPath() + "] as tools definition file. ");
166 toolsDef
= new ToolChainConfig(toolsDefFile
);
169 // Parse Framework Database
171 File dbFile
= new File(workspaceDir
+ File
.separatorChar
+ workspaceDatabaseFile
);
173 FrameworkDatabaseDocument db
= (FrameworkDatabaseDocument
) XmlObject
.Factory
.parse(dbFile
);
175 // validate FrameworkDatabaseFile
177 if (! db
.validate()) {
178 throw new BuildException("Framework Database file [" + dbFile
.getPath() + "] is invalid.");
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
);
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. ");
206 XmlObject fpdDoc
= XmlObject
.Factory
.parse(fpdFile
);
208 // Verify FPD file, if is invalid, throw Exception
210 if (! fpdDoc
.validate()) {
211 throw new BuildException("Framework Platform Surface Area file [" + fpdFile
.getPath() + "] is invalid. ");
214 // We can change Map to XmlObject
217 // TBD check SPD or FPD is existed in FS
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
);
227 } catch (Exception e
) {
228 throw new BuildException("Parse workspace Database [" + dbFile
.getPath() + "] Error.\n" + e
.getMessage());
233 Get the current WORKSPACE Directory.
235 @return current workspace directory
237 public synchronized static String
getWorkspacePath() {
243 Get the MSA file name with absolute path
245 public synchronized static File
getMsaFile(ModuleIdentification moduleId
) throws BuildException
{
248 // TBD. Do only when package is null.
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 ) {
259 if (msaFile
== null){
260 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
267 public synchronized static PackageIdentification
getPackageForModule(ModuleIdentification moduleId
) {
269 // If package already defined in module
271 if (moduleId
.getPackage() != null) {
272 return moduleId
.getPackage();
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 ) {
285 if (packageId
== null){
286 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
294 Difference between build and parse: ToolChain and Target
296 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId
) {
297 return builtModules
.contains(moduleId
);
300 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId
) {
301 builtModules
.add(fpdModuleId
);
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
);
314 fpdModuleSA
.put(fpdModuleId
, result
);
317 public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId
) {
318 return fpdModuleSA
.containsKey(fpdModuleId
);
322 Query overrided module surface area information. If current is Package
323 or Platform build, also include the information from FPD file.
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>
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
333 public synchronized static Map
<String
, XmlObject
> getDoc(FpdModuleIdentification fpdModuleId
) throws BuildException
{
334 if (parsedModules
.containsKey(fpdModuleId
)) {
335 return parsedModules
.get(fpdModuleId
);
337 Map
<String
, XmlObject
> doc
= new HashMap
<String
, XmlObject
>();
338 ModuleIdentification moduleId
= fpdModuleId
.getModule();
340 // First part: get the MSA files info
342 doc
.putAll(getNativeMsa(moduleId
));
345 // Second part: put build options
347 doc
.put("BuildOptions", fpdBuildOptions
);
350 // Third part: get Module info from FPD, such as Library instances, PCDs
352 if (fpdModuleSA
.containsKey(fpdModuleId
)){
354 // merge module info in FPD to final Doc
355 // For Library Module, do nothing here
357 doc
.putAll(fpdModuleSA
.get(fpdModuleId
));
359 parsedModules
.put(fpdModuleId
, doc
);
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
);
368 Query the native MSA information with module base name.
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>
373 @param moduleName the base name of the module
374 @return the native MSA information
375 @throws BuildException
376 MSA file is not valid
378 public synchronized static Map
<String
, XmlObject
> getNativeMsa(ModuleIdentification moduleId
) throws BuildException
{
379 if (nativeMsa
.containsKey(moduleId
)) {
380 return nativeMsa
.get(moduleId
);
382 File msaFile
= getMsaFile(moduleId
);
383 Map
<String
, XmlObject
> msaMap
= getNativeMsa(msaFile
);
384 nativeMsa
.put(moduleId
, msaMap
);
388 public synchronized static Map
<String
, XmlObject
> getNativeMsa(File msaFile
) throws BuildException
{
389 if (! msaFile
.exists()) {
390 throw new BuildException("Surface Area file [" + msaFile
.getPath() + "] can't found.");
393 ModuleSurfaceAreaDocument doc
= (ModuleSurfaceAreaDocument
)XmlObject
.Factory
.parse(msaFile
);
395 // Validate File if they accord with XML Schema
397 if ( ! doc
.validate()){
398 throw new BuildException("Module Surface Area file [" + msaFile
.getPath() + "] is invalid.");
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));
417 catch (Exception ex
){
418 throw new BuildException(ex
.getMessage());
422 public static Map
<String
, XmlObject
> getFpdBuildOptions() {
423 Map
<String
, XmlObject
> map
= new HashMap
<String
, XmlObject
>();
424 map
.put("BuildOptions", fpdBuildOptions
);
428 public static void setFpdBuildOptions(XmlObject fpdBuildOptions
) {
429 GlobalData
.fpdBuildOptions
= cloneXmlObject(fpdBuildOptions
, true);
432 public static XmlObject
getFpdDynamicPcds() {
433 return fpdDynamicPcds
;
436 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds
) {
437 GlobalData
.fpdDynamicPcds
= fpdDynamicPcds
;
440 //////////////////////////////////////////////
441 //////////////////////////////////////////////
443 public static Set
<ModuleIdentification
> getModules(PackageIdentification packageId
){
444 Spd spd
= spdTable
.get(packageId
);
446 Set
<ModuleIdentification
> dummy
= new HashSet
<ModuleIdentification
>();
450 return spd
.getModules();
455 * The header file path is relative to workspace dir
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];
464 String
[] result
= null;
465 for (int i
= 0; i
< packages
.length
; i
++) {
466 Spd spd
= spdTable
.get(packages
[i
]);
468 // If find one package defined the library class
470 if ((result
= spd
.getLibClassIncluder(name
)) != null) {
475 // If can't find library class declaration in every package
477 throw new BuildException("Can not find library class [" + name
478 + "] declaration in every packages. ");
482 * The header file path is relative to workspace dir
484 public static String
getPackageHeaderFiles(PackageIdentification packages
,
485 String moduleType
) throws BuildException
{
486 if (packages
== null) {
487 return new String("");
489 Spd spd
= spdTable
.get(packages
);
491 // If can't find package header file, skip it
495 if ((temp
= spd
.getPackageIncluder(moduleType
)) != null) {
507 * return two values: {cName, GuidValue}
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];
515 String
[] result
= null;
516 Iterator item
= packages
.iterator();
517 while (item
.hasNext()){
518 Spd spd
= spdTable
.get(item
.next());
520 // If find one package defined the GUID
522 if ((result
= spd
.getGuid(name
)) != null) {
531 * return two values: {cName, GuidValue}
533 public static String
[] getPpiGuid(List
<PackageIdentification
> packages
,
534 String name
) throws BuildException
{
535 if (packages
== null) {
536 return new String
[0];
538 String
[] result
= null;
539 Iterator item
= packages
.iterator();
540 while (item
.hasNext()){
541 Spd spd
= spdTable
.get(item
.next());
543 // If find one package defined the Ppi GUID
545 if ((result
= spd
.getPpi(name
)) != null) {
554 * return two values: {cName, GuidValue}
556 public static String
[] getProtocolGuid(List
<PackageIdentification
> packages
,
557 String name
) throws BuildException
{
558 if (packages
== null) {
559 return new String
[0];
561 String
[] result
= null;
562 Iterator item
= packages
.iterator();
563 while (item
.hasNext()){
564 Spd spd
= spdTable
.get(item
.next());
566 // If find one package defined the protocol GUID
568 if ((result
= spd
.getProtocol(name
))!= null){
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
)) {
584 throw new BuildException("Can't find platform [" + name
+ "] in current workspace database. ");
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())) {
596 throw new BuildException("Can't find platform file [" + filename
+ "] in current workspace database. ");
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());
609 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
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
);
620 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
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());
633 throw new BuildException("Can't find module GUID value " + moduleId
.getGuid() + " in " + packageId
+ " under current workspace. ");
636 public synchronized static Set
<PackageIdentification
> getPackageList(){
640 private static XmlObject
cloneXmlObject(XmlObject object
, boolean deep
) throws BuildException
{
641 if ( object
== null) {
644 XmlObject result
= null;
646 result
= XmlObject
.Factory
.parse(object
.getDomNode()
648 } catch (Exception ex
) {
649 throw new BuildException(ex
.getMessage());
654 ////// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
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
);
663 toolChainInfo
.addCommands(toolsDef
.getConfigInfo().getCommands());
664 toolChainInfo
.normalize();
665 GlobalData
.log
.info(toolChainInfo
+ "");
667 return toolChainInfo
;
672 public static void setPlatformToolChainFamilyOption(ToolChainMap map
) {
673 platformToolChainFamilyOption
= map
;
676 public static void setPlatformToolChainOption(ToolChainMap map
) {
677 platformToolChainOption
= map
;
680 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId
,
681 ToolChainMap toolChainOption
) {
682 moduleToolChainOption
.put(fpdModuleId
, toolChainOption
);
685 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId
,
686 ToolChainMap toolChainOption
) {
687 moduleToolChainFamilyOption
.put(fpdModuleId
, toolChainOption
);
690 public static boolean isCommandSet(String target
, String toolchain
, String arch
) {
691 String
[] commands
= getToolChainInfo().getCommands();
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) {
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;
708 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
709 setting
= toolChainConfig
.get(toolChainKey
);
710 if (setting
== null) {
717 // get module specific options, if any
720 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
721 ToolChainKey toolChainFamilyKey
= null;
723 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
725 // then tool chain family
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
);
733 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
734 if (option
!= null) {
735 setting
= option
.get(toolChainFamilyKey
);
740 // get platform options, if any
742 if (setting
== null) {
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
);
754 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
758 if (setting
== null) {
765 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
766 toolChainEnvInfo
= envInfo
;
768 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
769 toolChainPlatformInfo
= platformInfo
;
775 public synchronized static MemoryDatabaseManager
getPCDMemoryDBManager() {
780 // For PCD get tokenSpaceGUid
782 public synchronized static String
getGuidInfoFromCname(String cName
){
783 String cNameGuid
= null;
785 Set set
= spdTable
.keySet();
786 Iterator iter
= set
.iterator();
792 while (iter
.hasNext()){
793 Spd spd
= (Spd
) spdTable
.get(iter
.next());
794 guid
= spd
.getGuidFromCname(cName
);
806 public synchronized static Map
<FpdModuleIdentification
, XmlObject
>
807 getFpdModuleSaXmlObject(String xmlObjectName
) {
808 Set
<FpdModuleIdentification
> fpdModuleSASet
= fpdModuleSA
.keySet();
809 Iterator item
= fpdModuleSASet
.iterator();
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()) {
817 moduleId
= (FpdModuleIdentification
) item
.next();
818 SANode
= fpdModuleSA
.get(moduleId
);
820 if (SANode
.get(xmlObjectName
)!= null){
821 SAPcdBuildDef
.put(moduleId
,
822 (XmlObject
) SANode
.get(xmlObjectName
));
825 } catch (Exception e
){
826 EdkLog
.log(EdkLog
.EDK_INFO
, e
.getMessage());
829 return SAPcdBuildDef
;
832 public synchronized static Map
<FpdModuleIdentification
,XmlObject
> getFpdPcdBuildDefinitions() {
833 Map
<FpdModuleIdentification
,XmlObject
> pcdBuildDef
= getFpdModuleSaXmlObject ("PcdBuildDefinition");