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
;
27 import org
.apache
.tools
.ant
.BuildException
;
28 import org
.apache
.xmlbeans
.XmlObject
;
30 import org
.tianocore
.common
.exception
.EdkException
;
31 import org
.tianocore
.common
.logger
.EdkLog
;
32 import org
.tianocore
.pcd
.entity
.MemoryDatabaseManager
;
33 import org
.tianocore
.DbPathAndFilename
;
34 import org
.tianocore
.FrameworkDatabaseDocument
;
35 import org
.tianocore
.ModuleSurfaceAreaDocument
;
36 import org
.tianocore
.ModuleSurfaceAreaDocument
.ModuleSurfaceArea
;
37 import org
.tianocore
.build
.id
.FpdModuleIdentification
;
38 import org
.tianocore
.build
.id
.ModuleIdentification
;
39 import org
.tianocore
.build
.id
.PackageIdentification
;
40 import org
.tianocore
.build
.id
.PlatformIdentification
;
41 import org
.tianocore
.build
.toolchain
.ToolChainAttribute
;
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
;
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 /// Record current WORKSPACE Directory
62 private static String workspaceDir
= "";
65 /// Be used to ensure Global data will be initialized only once.
67 private static boolean globalFlag
= false;
70 /// Framework Database information: package list and platform list
72 private static Set
<PackageIdentification
> packageList
= new HashSet
<PackageIdentification
>();
74 private static Set
<PlatformIdentification
> platformList
= new HashSet
<PlatformIdentification
>();
77 /// Every detail SPD informations: Module list, Library class definition,
78 /// Package header file, GUID/PPI/Protocol definitions
80 private static final Map
<PackageIdentification
, Spd
> spdTable
= new HashMap
<PackageIdentification
, Spd
>();
83 /// Build informations are divided into three parts:
84 /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
86 private static Map
<ModuleIdentification
, Map
<String
, XmlObject
>> nativeMsa
= new HashMap
<ModuleIdentification
, Map
<String
, XmlObject
>>();
88 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> fpdModuleSA
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
90 private static XmlObject fpdBuildOptions
;
92 private static XmlObject fpdDynamicPcds
;
95 /// Parsed modules list
97 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> parsedModules
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
100 /// built modules list with ARCH, TARGET, TOOLCHAIN
102 private static Set
<FpdModuleIdentification
> builtModules
= new HashSet
<FpdModuleIdentification
>();
105 /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.
107 private static final MemoryDatabaseManager pcdDbManager
= new MemoryDatabaseManager();
110 /// build target + tool chain family/tag name + arch + command types + command options
114 /// toolsDef - build tool program information
115 /// fpdBuildOption - all modules's build options for tool tag or tool chain families
116 /// moduleSaBuildOption - build options for a specific module
118 private static ToolChainConfig toolsDef
;
120 private static ToolChainInfo toolChainInfo
;
121 private static ToolChainInfo toolChainEnvInfo
;
122 private static ToolChainInfo toolChainPlatformInfo
;
124 private static ToolChainMap platformToolChainOption
;
125 private static ToolChainMap platformToolChainFamilyOption
;
127 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
128 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainFamilyOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
131 Parse framework database (DB) and all SPD files listed in DB to initialize
132 the environment for next build. This method will only be executed only once
133 in the whole build process.
135 @param workspaceDatabaseFile the file name of framework database
136 @param workspaceDir current workspace directory path
137 @throws BuildException
138 Framework Dababase or SPD or MSA file is not valid
140 public synchronized static void initInfo(String workspaceDatabaseFile
, String workspaceDir
, String toolsDefFilename
) throws BuildException
{
142 // ensure this method will be revoked only once
150 // Backup workspace directory. It will be used by other method
152 GlobalData
.workspaceDir
= workspaceDir
.replaceAll("(\\\\)", "/");
155 // Parse tools definition file
158 // If ToolChain has been set up before, do nothing.
159 // CONF dir + tools definition file name
161 File toolsDefFile
= new File(workspaceDir
+ File
.separatorChar
+ toolsDefFilename
);
162 System
.out
.println("Using tool definiton file [" + toolsDefFile
.getPath() + "].");
164 toolsDef
= new ToolChainConfig(toolsDefFile
);
165 } catch (Exception e
) {
166 throw new BuildException(e
.getMessage());
170 // Parse Framework Database
172 File dbFile
= new File(workspaceDir
+ File
.separatorChar
+ workspaceDatabaseFile
);
174 FrameworkDatabaseDocument db
= (FrameworkDatabaseDocument
) XmlObject
.Factory
.parse(dbFile
);
176 // validate FrameworkDatabaseFile
178 if (!db
.validate()) {
179 throw new BuildException("Framework Database file [" + dbFile
.getPath() + "] format is invalid!");
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();
189 Spd spd
= new Spd(new File(workspaceDir
+ File
.separatorChar
+ fileName
));
190 packageList
.add(spd
.getPackageId());
191 spdTable
.put(spd
.getPackageId(), spd
);
198 if (db
.getFrameworkDatabase().getPlatformList() != null) {
199 List
<DbPathAndFilename
> platforms
= db
.getFrameworkDatabase().getPlatformList().getFilenameList();
200 Iterator
<DbPathAndFilename
> iter
= platforms
.iterator();
201 while (iter
.hasNext()) {
202 String fileName
= iter
.next().getStringValue();
203 File fpdFile
= new File(workspaceDir
+ File
.separatorChar
+ fileName
);
204 if ( !fpdFile
.exists() ) {
205 throw new BuildException("Platform file [" + fpdFile
.getPath() + "] not exists. ");
207 XmlObject fpdDoc
= XmlObject
.Factory
.parse(fpdFile
);
209 // Verify FPD file, if is invalid, throw Exception
211 if (!fpdDoc
.validate()) {
212 throw new BuildException("Framework Platform Surface Area file [" + fpdFile
.getPath() + "] format is invalid!");
215 // We can change Map to XmlObject
218 // TBD check SPD or FPD is existed in FS
220 Map
<String
, XmlObject
> fpdDocMap
= new HashMap
<String
, XmlObject
>();
221 fpdDocMap
.put("PlatformSurfaceArea", fpdDoc
);
222 SurfaceAreaQuery
.setDoc(fpdDocMap
);
223 PlatformIdentification platformId
= SurfaceAreaQuery
.getFpdHeader();
224 platformId
.setFpdFile(fpdFile
);
225 platformList
.add(platformId
);
228 } catch (Exception e
) {
229 throw new BuildException("Parse WORKSPACE Database file [" + dbFile
.getPath() + "] Error.\n" + e
.getMessage());
234 Get the current WORKSPACE Directory.
236 @return current workspace directory
238 public synchronized static String
getWorkspacePath() {
244 Get the MSA file name with absolute path
246 public synchronized static File
getMsaFile(ModuleIdentification moduleId
) throws BuildException
{
249 // TBD. Do only when package is null.
251 Iterator iter
= packageList
.iterator();
252 while (iter
.hasNext()) {
253 PackageIdentification packageId
= (PackageIdentification
)iter
.next();
254 Spd spd
= spdTable
.get(packageId
);
255 msaFile
= spd
.getModuleFile(moduleId
);
256 if (msaFile
!= null ) {
260 if (msaFile
== null){
261 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in any SPD package!");
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 any SPD package!");
293 Difference between build and parse: ToolChain and Target
295 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId
) {
296 return builtModules
.contains(moduleId
);
299 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId
) {
300 builtModules
.add(fpdModuleId
);
304 public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId
, Map
<String
, XmlObject
> doc
) {
305 Map
<String
, XmlObject
> result
= new HashMap
<String
, XmlObject
>();
306 Set keySet
= doc
.keySet();
307 Iterator iter
= keySet
.iterator();
308 while (iter
.hasNext()){
309 String key
= (String
)iter
.next();
310 XmlObject item
= cloneXmlObject(doc
.get(key
), true);
311 result
.put(key
, item
);
313 fpdModuleSA
.put(fpdModuleId
, result
);
316 public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId
) {
317 return fpdModuleSA
.containsKey(fpdModuleId
);
321 Query module surface area information.
323 <p>Note that surface area parsing is incremental. That means the method will
324 only parse the MSA files if necessary. </p>
326 @param fpdModuleId Module ID with arch
327 @return ModuleSA info and MSA info for fpdModuleId
328 @throws BuildException Can't find MSA
330 public synchronized static Map
<String
, XmlObject
> getDoc(FpdModuleIdentification fpdModuleId
) throws BuildException
{
331 if (parsedModules
.containsKey(fpdModuleId
)) {
332 return parsedModules
.get(fpdModuleId
);
334 Map
<String
, XmlObject
> doc
= new HashMap
<String
, XmlObject
>();
335 ModuleIdentification moduleId
= fpdModuleId
.getModule();
337 // First part: get the MSA files info
339 doc
.putAll(getNativeMsa(moduleId
));
342 // Second part: put build options
344 doc
.put("BuildOptions", fpdBuildOptions
);
347 // Third part: get Module info from FPD, such as Library instances, PCDs
349 if (fpdModuleSA
.containsKey(fpdModuleId
)){
351 // merge module info in FPD to final Doc
352 // For Library Module, do nothing here
354 doc
.putAll(fpdModuleSA
.get(fpdModuleId
));
356 parsedModules
.put(fpdModuleId
, doc
);
360 public synchronized static Map
<String
, XmlObject
> getDoc(ModuleIdentification moduleId
, String arch
) throws BuildException
{
361 FpdModuleIdentification fpdModuleId
= new FpdModuleIdentification(moduleId
, arch
);
362 return getDoc(fpdModuleId
);
365 Query the native MSA information with module base name.
367 <p>Note that MSA parsing is incremental. That means the method will
368 only to parse the MSA files when never parsed before. </p>
370 @param moduleName the base name of the module
371 @return the native MSA information
372 @throws BuildException
373 MSA file is not valid
375 public synchronized static Map
<String
, XmlObject
> getNativeMsa(ModuleIdentification moduleId
) throws BuildException
{
376 if (nativeMsa
.containsKey(moduleId
)) {
377 return nativeMsa
.get(moduleId
);
379 File msaFile
= getMsaFile(moduleId
);
380 Map
<String
, XmlObject
> msaMap
= getNativeMsa(msaFile
);
381 nativeMsa
.put(moduleId
, msaMap
);
385 public synchronized static Map
<String
, XmlObject
> getNativeMsa(File msaFile
) throws BuildException
{
386 if (!msaFile
.exists()) {
387 throw new BuildException("Module Surface Area file [" + msaFile
.getPath() + "] can't be found!");
390 ModuleSurfaceAreaDocument doc
= (ModuleSurfaceAreaDocument
)XmlObject
.Factory
.parse(msaFile
);
392 // Validate File if they accord with XML Schema
394 if ( !doc
.validate()){
395 throw new BuildException("Module Surface Area file [" + msaFile
.getPath() + "] format is invalid!");
400 ModuleSurfaceArea msa
= doc
.getModuleSurfaceArea();
401 Map
<String
, XmlObject
> msaMap
= new HashMap
<String
, XmlObject
>();
402 msaMap
.put("MsaHeader", cloneXmlObject(msa
.getMsaHeader(), true));
403 msaMap
.put("ModuleDefinitions", cloneXmlObject(msa
.getModuleDefinitions(), true));
404 msaMap
.put("LibraryClassDefinitions", cloneXmlObject(msa
.getLibraryClassDefinitions(), true));
405 msaMap
.put("SourceFiles", cloneXmlObject(msa
.getSourceFiles(), true));
406 msaMap
.put("PackageDependencies", cloneXmlObject(msa
.getPackageDependencies(), true));
407 msaMap
.put("Protocols", cloneXmlObject(msa
.getProtocols(), true));
408 msaMap
.put("PPIs", cloneXmlObject(msa
.getPPIs(), true));
409 msaMap
.put("Guids", cloneXmlObject(msa
.getGuids(), true));
410 msaMap
.put("Externs", cloneXmlObject(msa
.getExterns(), true));
411 msaMap
.put("PcdCoded", cloneXmlObject(msa
.getPcdCoded(), true));
414 catch (Exception ex
){
415 throw new BuildException(ex
.getMessage());
419 public static Map
<String
, XmlObject
> getFpdBuildOptions() {
420 Map
<String
, XmlObject
> map
= new HashMap
<String
, XmlObject
>();
421 map
.put("BuildOptions", fpdBuildOptions
);
425 public static void setFpdBuildOptions(XmlObject fpdBuildOptions
) {
426 GlobalData
.fpdBuildOptions
= cloneXmlObject(fpdBuildOptions
, true);
429 public static XmlObject
getFpdDynamicPcds() {
430 return fpdDynamicPcds
;
433 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds
) {
434 GlobalData
.fpdDynamicPcds
= fpdDynamicPcds
;
437 public static Set
<ModuleIdentification
> getModules(PackageIdentification packageId
){
438 Spd spd
= spdTable
.get(packageId
);
440 Set
<ModuleIdentification
> dummy
= new HashSet
<ModuleIdentification
>();
443 return spd
.getModules();
448 * The header file path is relative to workspace dir
450 public static String
[] getLibraryClassHeaderFiles(
451 PackageIdentification
[] packages
, String name
)
452 throws BuildException
{
453 if (packages
== null) {
454 // throw Exception or not????
455 return new String
[0];
457 String
[] result
= null;
458 for (int i
= 0; i
< packages
.length
; i
++) {
459 Spd spd
= spdTable
.get(packages
[i
]);
461 // If find one package defined the library class
463 if ((result
= spd
.getLibClassIncluder(name
)) != null) {
468 // If can't find library class declaration in every package
470 throw new BuildException("Can not find library class [" + name
471 + "] declaration in any SPD package!");
475 * The header file path is relative to workspace dir
477 public static String
getPackageHeaderFiles(PackageIdentification packages
,
478 String moduleType
) throws BuildException
{
479 if (packages
== null) {
480 return new String("");
482 Spd spd
= spdTable
.get(packages
);
484 // If can't find package header file, skip it
488 if ((temp
= spd
.getPackageIncluder(moduleType
)) != null) {
500 * return two values: {cName, GuidValue}
502 public static String
[] getGuid(List
<PackageIdentification
> packages
, String name
)
503 throws BuildException
{
504 if (packages
== null) {
505 // throw Exception or not????
506 return new String
[0];
508 String
[] result
= null;
509 Iterator item
= packages
.iterator();
510 while (item
.hasNext()){
511 Spd spd
= spdTable
.get(item
.next());
513 // If find one package defined the GUID
515 if ((result
= spd
.getGuid(name
)) != null) {
524 * return two values: {cName, GuidValue}
526 public static String
[] getPpiGuid(List
<PackageIdentification
> packages
,
527 String name
) throws BuildException
{
528 if (packages
== null) {
529 return new String
[0];
531 String
[] result
= null;
532 Iterator item
= packages
.iterator();
533 while (item
.hasNext()){
534 Spd spd
= spdTable
.get(item
.next());
536 // If find one package defined the Ppi GUID
538 if ((result
= spd
.getPpi(name
)) != null) {
547 * return two values: {cName, GuidValue}
549 public static String
[] getProtocolGuid(List
<PackageIdentification
> packages
,
550 String name
) throws BuildException
{
551 if (packages
== null) {
552 return new String
[0];
554 String
[] result
= null;
555 Iterator item
= packages
.iterator();
556 while (item
.hasNext()){
557 Spd spd
= spdTable
.get(item
.next());
559 // If find one package defined the protocol GUID
561 if ((result
= spd
.getProtocol(name
))!= null){
569 public synchronized static PlatformIdentification
getPlatformByName(String name
) throws BuildException
{
570 Iterator iter
= platformList
.iterator();
571 while(iter
.hasNext()){
572 PlatformIdentification platformId
= (PlatformIdentification
)iter
.next();
573 if (platformId
.getName().equalsIgnoreCase(name
)) {
577 throw new BuildException("Can't find platform [" + name
+ "] in the current WORKSPACE database!");
580 public synchronized static PlatformIdentification
getPlatform(String filename
) throws BuildException
{
581 File file
= new File(workspaceDir
+ File
.separatorChar
+ filename
);
582 Iterator iter
= platformList
.iterator();
583 while(iter
.hasNext()){
584 PlatformIdentification platformId
= (PlatformIdentification
)iter
.next();
585 if (platformId
.getFpdFile().getPath().equalsIgnoreCase(file
.getPath())) {
589 throw new BuildException("Can't find platform file [" + filename
+ "] in the current WORKSPACE database!");
592 public synchronized static PackageIdentification
refreshPackageIdentification(PackageIdentification packageId
) throws BuildException
{
593 Iterator iter
= packageList
.iterator();
594 while(iter
.hasNext()){
595 PackageIdentification packageItem
= (PackageIdentification
)iter
.next();
596 if (packageItem
.equals(packageId
)) {
597 packageId
.setName(packageItem
.getName());
598 packageId
.setSpdFile(packageItem
.getSpdFile());
602 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " in the current workspace!");
605 public synchronized static ModuleIdentification
refreshModuleIdentification(ModuleIdentification moduleId
) throws BuildException
{
606 PackageIdentification packageId
= getPackageForModule(moduleId
);
607 moduleId
.setPackage(packageId
);
608 Spd spd
= spdTable
.get(packageId
);
610 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " in the current workspace!");
612 Set
<ModuleIdentification
> modules
= spd
.getModules();
613 Iterator
<ModuleIdentification
> iter
= modules
.iterator();
614 while (iter
.hasNext()) {
615 ModuleIdentification item
= iter
.next();
616 if (item
.equals(moduleId
)) {
617 moduleId
.setName(item
.getName());
618 moduleId
.setModuleType(item
.getModuleType());
619 moduleId
.setMsaFile(item
.getMsaFile());
623 throw new BuildException("Can't find module GUID value " + moduleId
.getGuid() + " in package, " + packageId
+ ", in the current workspace!");
626 public synchronized static Set
<PackageIdentification
> getPackageList(){
631 BUGBUG: It is a walk around method. If do not clone, can't query info with
634 @param object XmlObject
635 @param deep flag for deep clone
636 @return XmlObject after clone
637 @throws BuildException parse original XmlObject error.
639 private static XmlObject
cloneXmlObject(XmlObject object
, boolean deep
) throws BuildException
{
640 if ( object
== null) {
643 XmlObject result
= null;
645 result
= XmlObject
.Factory
.parse(object
.getDomNode()
647 } catch (Exception ex
) {
648 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 if (toolChainInfo
== null) {
658 toolChainInfo
= toolsDef
.getConfigInfo().intersection(toolChainEnvInfo
);
659 if (toolChainPlatformInfo
!= null) {
660 toolChainInfo
= toolChainInfo
.intersection(toolChainPlatformInfo
);
662 toolChainInfo
.addCommands(toolsDef
.getConfigInfo().getCommands());
663 toolChainInfo
.normalize();
664 System
.out
.println("Current build tool chain information summary: ");
665 System
.out
.println(toolChainInfo
+ "");
667 return toolChainInfo
;
670 public static void setPlatformToolChainFamilyOption(ToolChainMap map
) {
671 platformToolChainFamilyOption
= map
;
674 public static void setPlatformToolChainOption(ToolChainMap map
) {
675 platformToolChainOption
= map
;
678 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId
,
679 ToolChainMap toolChainOption
) {
680 moduleToolChainOption
.put(fpdModuleId
, toolChainOption
);
683 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId
,
684 ToolChainMap toolChainOption
) {
685 moduleToolChainFamilyOption
.put(fpdModuleId
, toolChainOption
);
688 public static boolean isCommandSet(String target
, String toolchain
, String arch
) {
689 String
[] commands
= getToolChainInfo().getCommands();
691 for (int i
= 0; i
< commands
.length
; ++i
) {
692 String cmdName
= toolsDef
.getConfig().get(new String
[] {target
, toolchain
, arch
, commands
[i
], ToolChainAttribute
.NAME
.toString()});
693 if (cmdName
!= null && cmdName
.length() != 0) {
701 public static String
getCommandSetting(String
[] commandDescription
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
702 ToolChainKey toolChainKey
= new ToolChainKey(commandDescription
);
703 ToolChainMap toolChainConfig
= toolsDef
.getConfig();
704 String setting
= null;
706 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
707 setting
= toolChainConfig
.get(toolChainKey
);
708 if (setting
== null) {
715 // get module specific options, if any
718 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
719 ToolChainKey toolChainFamilyKey
= null;
721 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
723 // then tool chain family
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
);
731 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
732 if (option
!= null) {
733 setting
= option
.get(toolChainFamilyKey
);
738 // get platform options, if any
740 if (setting
== null) {
742 if (platformToolChainOption
== null || (setting
= platformToolChainOption
.get(toolChainKey
)) == null) {
743 // then tool chain family
744 if (toolChainFamilyKey
== null) {
745 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
746 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
747 String family
= toolChainConfig
.get(toolChainFamilyKey
);
748 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
749 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
752 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
756 if (setting
== null) {
763 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
764 toolChainEnvInfo
= envInfo
;
766 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
767 toolChainPlatformInfo
= platformInfo
;
773 public synchronized static MemoryDatabaseManager
getPCDMemoryDBManager() {
778 // For PCD get tokenSpaceGUid
780 public synchronized static String
getGuidInfoFromCname(String cName
){
781 String cNameGuid
= null;
783 Set set
= spdTable
.keySet();
784 Iterator iter
= set
.iterator();
790 while (iter
.hasNext()){
791 Spd spd
= (Spd
) spdTable
.get(iter
.next());
792 guid
= spd
.getGuidFromCname(cName
);
804 public synchronized static Map
<FpdModuleIdentification
, XmlObject
>
805 getFpdModuleSaXmlObject(String xmlObjectName
) {
806 Set
<FpdModuleIdentification
> fpdModuleSASet
= fpdModuleSA
.keySet();
807 Iterator item
= fpdModuleSASet
.iterator();
810 Map
<FpdModuleIdentification
, XmlObject
> SAPcdBuildDef
= new HashMap
<FpdModuleIdentification
, XmlObject
>();
811 Map
<String
, XmlObject
> SANode
= new HashMap
<String
, XmlObject
>();
812 FpdModuleIdentification moduleId
;
813 while (item
.hasNext()) {
815 moduleId
= (FpdModuleIdentification
) item
.next();
816 SANode
= fpdModuleSA
.get(moduleId
);
818 if (SANode
.get(xmlObjectName
)!= null){
819 SAPcdBuildDef
.put(moduleId
,
820 (XmlObject
) SANode
.get(xmlObjectName
));
823 } catch (Exception e
){
824 EdkLog
.log(EdkLog
.EDK_INFO
, e
.getMessage());
827 return SAPcdBuildDef
;
830 public synchronized static Map
<FpdModuleIdentification
,XmlObject
> getFpdPcdBuildDefinitions() {
831 Map
<FpdModuleIdentification
,XmlObject
> pcdBuildDef
= getFpdModuleSaXmlObject ("PcdBuildDefinition");