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
.build
.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
>();
133 private static final MemoryDatabaseManager pcdDbManager
= new MemoryDatabaseManager();
136 Parse framework database (DB) and all SPD files listed in DB to initialize
137 the environment for next build. This method will only be executed only once
138 in the whole build process.
140 @param workspaceDatabaseFile the file name of framework database
141 @param workspaceDir current workspace directory path
142 @throws BuildException
143 Framework Dababase or SPD or MSA file is not valid
145 public synchronized static void initInfo(String workspaceDatabaseFile
, String workspaceDir
, String toolsDefFilename
) throws BuildException
{
147 // ensure this method will be revoked only once
155 // Backup workspace directory. It will be used by other method
157 GlobalData
.workspaceDir
= workspaceDir
.replaceAll("(\\\\)", "/");
160 // Parse tools definition file
163 // If ToolChain has been set up before, do nothing.
164 // CONF dir + tools definition file name
166 File toolsDefFile
= new File(workspaceDir
+ File
.separatorChar
+ toolsDefFilename
);
167 System
.out
.println("Using file [" + toolsDefFile
.getPath() + "] as tools definition file. ");
168 toolsDef
= new ToolChainConfig(toolsDefFile
);
171 // Parse Framework Database
173 File dbFile
= new File(workspaceDir
+ File
.separatorChar
+ workspaceDatabaseFile
);
175 FrameworkDatabaseDocument db
= (FrameworkDatabaseDocument
) XmlObject
.Factory
.parse(dbFile
);
177 // validate FrameworkDatabaseFile
179 if (! db
.validate()) {
180 throw new BuildException("Framework Database file [" + dbFile
.getPath() + "] is invalid.");
185 if (db
.getFrameworkDatabase().getPackageList() != null ) {
186 List
<DbPathAndFilename
> packages
= db
.getFrameworkDatabase().getPackageList().getFilenameList();
187 Iterator
<DbPathAndFilename
> iter
= packages
.iterator();
188 while (iter
.hasNext()) {
189 String fileName
= iter
.next().getStringValue();
190 Spd spd
= new Spd(new File(workspaceDir
+ File
.separatorChar
+ fileName
));
191 packageList
.add(spd
.getPackageId());
192 spdTable
.put(spd
.getPackageId(), spd
);
199 if (db
.getFrameworkDatabase().getPlatformList() != null) {
200 List
<DbPathAndFilename
> platforms
= db
.getFrameworkDatabase().getPlatformList().getFilenameList();
201 Iterator
<DbPathAndFilename
> iter
= platforms
.iterator();
202 while (iter
.hasNext()) {
203 String fileName
= iter
.next().getStringValue();
204 File fpdFile
= new File(workspaceDir
+ File
.separatorChar
+ fileName
);
205 if ( ! fpdFile
.exists() ) {
206 throw new BuildException("Platform file [" + fpdFile
.getPath() + "] not exists. ");
208 XmlObject fpdDoc
= XmlObject
.Factory
.parse(fpdFile
);
210 // Verify FPD file, if is invalid, throw Exception
212 if (! fpdDoc
.validate()) {
213 throw new BuildException("Framework Platform Surface Area file [" + fpdFile
.getPath() + "] is invalid. ");
216 // We can change Map to XmlObject
219 // TBD check SPD or FPD is existed in FS
221 Map
<String
, XmlObject
> fpdDocMap
= new HashMap
<String
, XmlObject
>();
222 fpdDocMap
.put("PlatformSurfaceArea", fpdDoc
);
223 SurfaceAreaQuery
.setDoc(fpdDocMap
);
224 PlatformIdentification platformId
= SurfaceAreaQuery
.getFpdHeader();
225 platformId
.setFpdFile(fpdFile
);
226 platformList
.add(platformId
);
229 } catch (Exception e
) {
230 throw new BuildException("Parse workspace Database [" + dbFile
.getPath() + "] Error.\n" + e
.getMessage());
235 Get the current WORKSPACE Directory.
237 @return current workspace directory
239 public synchronized static String
getWorkspacePath() {
245 Get the MSA file name with absolute path
247 public synchronized static File
getMsaFile(ModuleIdentification moduleId
) throws BuildException
{
250 // TBD. Do only when package is null.
252 Iterator iter
= packageList
.iterator();
253 while (iter
.hasNext()) {
254 PackageIdentification packageId
= (PackageIdentification
)iter
.next();
255 Spd spd
= spdTable
.get(packageId
);
256 msaFile
= spd
.getModuleFile(moduleId
);
257 if (msaFile
!= null ) {
261 if (msaFile
== null){
262 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
269 public synchronized static PackageIdentification
getPackageForModule(ModuleIdentification moduleId
) {
271 // If package already defined in module
273 if (moduleId
.getPackage() != null) {
274 return moduleId
.getPackage();
277 PackageIdentification packageId
= null;
278 Iterator iter
= packageList
.iterator();
279 while (iter
.hasNext()) {
280 packageId
= (PackageIdentification
)iter
.next();
281 moduleId
.setPackage(packageId
);
282 Spd spd
= spdTable
.get(packageId
);
283 if (spd
.getModuleFile(moduleId
) != null ) {
287 if (packageId
== null){
288 throw new BuildException("Can't find Module [" + moduleId
.getName() + "] in all packages. ");
296 Difference between build and parse: ToolChain and Target
298 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId
) {
299 return builtModules
.contains(moduleId
);
302 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId
) {
303 builtModules
.add(fpdModuleId
);
307 public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId
, Map
<String
, XmlObject
> doc
) {
308 Map
<String
, XmlObject
> result
= new HashMap
<String
, XmlObject
>();
309 Set keySet
= doc
.keySet();
310 Iterator iter
= keySet
.iterator();
311 while (iter
.hasNext()){
312 String key
= (String
)iter
.next();
313 XmlObject item
= cloneXmlObject(doc
.get(key
), true);
314 result
.put(key
, item
);
316 fpdModuleSA
.put(fpdModuleId
, result
);
319 public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId
) {
320 return fpdModuleSA
.containsKey(fpdModuleId
);
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
.putAll(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));
416 msaMap
.put("PcdCoded", cloneXmlObject(msa
.getPcdCoded(), true));
419 catch (Exception ex
){
420 throw new BuildException(ex
.getMessage());
424 public static Map
<String
, XmlObject
> getFpdBuildOptions() {
425 Map
<String
, XmlObject
> map
= new HashMap
<String
, XmlObject
>();
426 map
.put("BuildOptions", fpdBuildOptions
);
430 public static void setFpdBuildOptions(XmlObject fpdBuildOptions
) {
431 GlobalData
.fpdBuildOptions
= cloneXmlObject(fpdBuildOptions
, true);
434 public static XmlObject
getFpdDynamicPcds() {
435 return fpdDynamicPcds
;
438 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds
) {
439 GlobalData
.fpdDynamicPcds
= fpdDynamicPcds
;
442 //////////////////////////////////////////////
443 //////////////////////////////////////////////
445 public static Set
<ModuleIdentification
> getModules(PackageIdentification packageId
){
446 Spd spd
= spdTable
.get(packageId
);
448 Set
<ModuleIdentification
> dummy
= new HashSet
<ModuleIdentification
>();
452 return spd
.getModules();
457 * The header file path is relative to workspace dir
459 public static String
[] getLibraryClassHeaderFiles(
460 PackageIdentification
[] packages
, String name
)
461 throws BuildException
{
462 if (packages
== null) {
463 // throw Exception or not????
464 return new String
[0];
466 String
[] result
= null;
467 for (int i
= 0; i
< packages
.length
; i
++) {
468 Spd spd
= spdTable
.get(packages
[i
]);
470 // If find one package defined the library class
472 if ((result
= spd
.getLibClassIncluder(name
)) != null) {
477 // If can't find library class declaration in every package
479 throw new BuildException("Can not find library class [" + name
480 + "] declaration in every packages. ");
484 * The header file path is relative to workspace dir
486 public static String
getPackageHeaderFiles(PackageIdentification packages
,
487 String moduleType
) throws BuildException
{
488 if (packages
== null) {
489 return new String("");
491 Spd spd
= spdTable
.get(packages
);
493 // If can't find package header file, skip it
497 if ((temp
= spd
.getPackageIncluder(moduleType
)) != null) {
509 * return two values: {cName, GuidValue}
511 public static String
[] getGuid(List
<PackageIdentification
> packages
, String name
)
512 throws BuildException
{
513 if (packages
== null) {
514 // throw Exception or not????
515 return new String
[0];
517 String
[] result
= null;
518 Iterator item
= packages
.iterator();
519 while (item
.hasNext()){
520 Spd spd
= spdTable
.get(item
.next());
522 // If find one package defined the GUID
524 if ((result
= spd
.getGuid(name
)) != null) {
533 * return two values: {cName, GuidValue}
535 public static String
[] getPpiGuid(List
<PackageIdentification
> packages
,
536 String name
) throws BuildException
{
537 if (packages
== null) {
538 return new String
[0];
540 String
[] result
= null;
541 Iterator item
= packages
.iterator();
542 while (item
.hasNext()){
543 Spd spd
= spdTable
.get(item
.next());
545 // If find one package defined the Ppi GUID
547 if ((result
= spd
.getPpi(name
)) != null) {
556 * return two values: {cName, GuidValue}
558 public static String
[] getProtocolGuid(List
<PackageIdentification
> packages
,
559 String name
) throws BuildException
{
560 if (packages
== null) {
561 return new String
[0];
563 String
[] result
= null;
564 Iterator item
= packages
.iterator();
565 while (item
.hasNext()){
566 Spd spd
= spdTable
.get(item
.next());
568 // If find one package defined the protocol GUID
570 if ((result
= spd
.getProtocol(name
))!= null){
578 public synchronized static PlatformIdentification
getPlatformByName(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
)) {
586 throw new BuildException("Can't find platform [" + name
+ "] in current workspace database. ");
589 public synchronized static PlatformIdentification
getPlatform(String filename
) throws BuildException
{
590 File file
= new File(workspaceDir
+ File
.separatorChar
+ filename
);
591 Iterator iter
= platformList
.iterator();
592 while(iter
.hasNext()){
593 PlatformIdentification platformId
= (PlatformIdentification
)iter
.next();
594 if (platformId
.getFpdFile().getPath().equalsIgnoreCase(file
.getPath())) {
598 throw new BuildException("Can't find platform file [" + filename
+ "] in current workspace database. ");
601 public synchronized static PackageIdentification
refreshPackageIdentification(PackageIdentification packageId
) throws BuildException
{
602 Iterator iter
= packageList
.iterator();
603 while(iter
.hasNext()){
604 PackageIdentification packageItem
= (PackageIdentification
)iter
.next();
605 if (packageItem
.equals(packageId
)) {
606 packageId
.setName(packageItem
.getName());
607 packageId
.setSpdFile(packageItem
.getSpdFile());
611 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
614 public synchronized static ModuleIdentification
refreshModuleIdentification(ModuleIdentification moduleId
) throws BuildException
{
615 // System.out.println("1");
616 // System.out.println("##" + moduleId.getGuid());
617 PackageIdentification packageId
= getPackageForModule(moduleId
);
618 // System.out.println("" + packageId.getGuid());
619 moduleId
.setPackage(packageId
);
620 Spd spd
= spdTable
.get(packageId
);
622 throw new BuildException("Can't find package GUID value " + packageId
.getGuid() + " under current workspace. ");
624 Set
<ModuleIdentification
> modules
= spd
.getModules();
625 Iterator
<ModuleIdentification
> iter
= modules
.iterator();
626 while (iter
.hasNext()) {
627 ModuleIdentification item
= iter
.next();
628 if (item
.equals(moduleId
)) {
629 moduleId
.setName(item
.getName());
630 moduleId
.setModuleType(item
.getModuleType());
631 moduleId
.setMsaFile(item
.getMsaFile());
635 throw new BuildException("Can't find module GUID value " + moduleId
.getGuid() + " in " + packageId
+ " under current workspace. ");
638 public synchronized static Set
<PackageIdentification
> getPackageList(){
642 private static XmlObject
cloneXmlObject(XmlObject object
, boolean deep
) throws BuildException
{
643 if ( object
== null) {
646 XmlObject result
= null;
648 result
= XmlObject
.Factory
.parse(object
.getDomNode()
650 } catch (Exception ex
) {
651 throw new BuildException(ex
.getMessage());
656 ////// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
658 public static ToolChainInfo
getToolChainInfo() {
659 // GlobalData.log.info(toolsDef.getConfigInfo() + "" + toolChainEnvInfo + toolChainPlatformInfo);
660 if (toolChainInfo
== null) {
661 toolChainInfo
= toolsDef
.getConfigInfo().intersection(toolChainEnvInfo
);
662 if (toolChainPlatformInfo
!= null) {
663 toolChainInfo
= toolChainInfo
.intersection(toolChainPlatformInfo
);
665 toolChainInfo
.addCommands(toolsDef
.getConfigInfo().getCommands());
666 toolChainInfo
.normalize();
667 GlobalData
.log
.info(toolChainInfo
+ "");
669 return toolChainInfo
;
674 public static void setPlatformToolChainFamilyOption(ToolChainMap map
) {
675 platformToolChainFamilyOption
= map
;
678 public static void setPlatformToolChainOption(ToolChainMap map
) {
679 platformToolChainOption
= map
;
682 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId
,
683 ToolChainMap toolChainOption
) {
684 moduleToolChainOption
.put(fpdModuleId
, toolChainOption
);
687 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId
,
688 ToolChainMap toolChainOption
) {
689 moduleToolChainFamilyOption
.put(fpdModuleId
, toolChainOption
);
692 public static boolean isCommandSet(String target
, String toolchain
, String arch
) {
693 String
[] commands
= getToolChainInfo().getCommands();
695 for (int i
= 0; i
< commands
.length
; ++i
) {
696 String cmdName
= toolsDef
.getConfig().get(new String
[] {target
, toolchain
, arch
, commands
[i
], ToolChainAttribute
.NAME
.toString()});
697 if (cmdName
!= null && cmdName
.length() != 0) {
705 public static String
getCommandSetting(String
[] commandDescription
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
706 ToolChainKey toolChainKey
= new ToolChainKey(commandDescription
);
707 ToolChainMap toolChainConfig
= toolsDef
.getConfig();
708 String setting
= null;
710 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
711 setting
= toolChainConfig
.get(toolChainKey
);
712 if (setting
== null) {
719 // get module specific options, if any
722 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
723 ToolChainKey toolChainFamilyKey
= null;
725 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
727 // then tool chain family
729 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
730 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
731 String family
= toolChainConfig
.get(toolChainFamilyKey
);
732 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
733 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
735 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
736 if (option
!= null) {
737 setting
= option
.get(toolChainFamilyKey
);
742 // get platform options, if any
744 if (setting
== null) {
746 if (platformToolChainOption
== null || (setting
= platformToolChainOption
.get(toolChainKey
)) == null) {
747 // then tool chain family
748 if (toolChainFamilyKey
== null) {
749 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
750 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
751 String family
= toolChainConfig
.get(toolChainFamilyKey
);
752 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
753 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
756 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
760 if (setting
== null) {
767 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
768 toolChainEnvInfo
= envInfo
;
770 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
771 toolChainPlatformInfo
= platformInfo
;
777 public synchronized static MemoryDatabaseManager
getPCDMemoryDBManager() {
782 // For PCD get tokenSpaceGUid
784 public synchronized static String
[] getGuidInfoFromCname(String cName
){
785 String cNameGuid
[] = null;
787 Set set
= spdTable
.keySet();
788 Iterator iter
= set
.iterator();
794 while (iter
.hasNext()){
795 Spd spd
= (Spd
) spdTable
.get(iter
.next());
796 guid
= spd
.getGuidFromCname(cName
);
798 cNameGuid
= new String
[2];
799 cNameGuid
[0] = cName
;
810 public synchronized static Map
<FpdModuleIdentification
, XmlObject
>
811 getFpdModuleSaXmlObject(String xmlObjectName
) {
812 Set
<FpdModuleIdentification
> fpdModuleSASet
= fpdModuleSA
.keySet();
813 Iterator item
= fpdModuleSASet
.iterator();
816 Map
<FpdModuleIdentification
, XmlObject
> SAPcdBuildDef
= new HashMap
<FpdModuleIdentification
, XmlObject
>();
817 Map
<String
, XmlObject
> SANode
= new HashMap
<String
, XmlObject
>();
818 FpdModuleIdentification moduleId
;
819 while (item
.hasNext()) {
821 moduleId
= (FpdModuleIdentification
) item
.next();
822 SANode
= fpdModuleSA
.get(moduleId
);
824 if (SANode
.get(xmlObjectName
)!= null){
825 SAPcdBuildDef
.put(moduleId
,
826 (XmlObject
) SANode
.get(xmlObjectName
));
829 } catch (Exception e
){
830 EdkLog
.log(EdkLog
.EDK_INFO
, e
.getMessage());
833 return SAPcdBuildDef
;
836 public synchronized static Map
<FpdModuleIdentification
,XmlObject
> getFpdPcdBuildDefinitions() {
837 Map
<FpdModuleIdentification
,XmlObject
> pcdBuildDef
= getFpdModuleSaXmlObject ("PcdBuildDefinition");