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
.PcdBuildDefinitionDocument
;
25 import org
.tianocore
.ModuleSurfaceAreaDocument
.ModuleSurfaceArea
;
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
.pcd
.entity
.MemoryDatabaseManager
;
31 import org
.tianocore
.build
.toolchain
.ToolChainAttribute
;
32 import org
.tianocore
.build
.toolchain
.ToolChainConfig
;
33 import org
.tianocore
.build
.toolchain
.ToolChainElement
;
34 import org
.tianocore
.build
.toolchain
.ToolChainInfo
;
35 import org
.tianocore
.build
.toolchain
.ToolChainKey
;
36 import org
.tianocore
.build
.toolchain
.ToolChainMap
;
37 import org
.tianocore
.exception
.EdkException
;
38 import org
.tianocore
.logger
.EdkLog
;
41 import java
.util
.HashMap
;
42 import java
.util
.HashSet
;
43 import java
.util
.Iterator
;
44 import java
.util
.List
;
47 import java
.util
.logging
.Logger
;
50 GlobalData provide initializing, instoring, querying and update global data.
51 It is a bridge to intercommunicate between multiple component, such as AutoGen,
54 <p>Note that all global information are initialized incrementally. All data will
55 parse and record only of necessary during build time. </p>
59 public class GlobalData
{
61 public static Logger log
= Logger
.getAnonymousLogger();
64 /// Record current WORKSPACE Directory
66 private static String workspaceDir
= "";
69 /// Be used to ensure Global data will be initialized only once.
71 private static boolean globalFlag
= false;
74 /// Framework Database information: package list and platform list
76 private static Set
<PackageIdentification
> packageList
= new HashSet
<PackageIdentification
>();
78 private static Set
<PlatformIdentification
> platformList
= new HashSet
<PlatformIdentification
>();
81 /// Every detail SPD informations: Module list, Library class definition,
82 /// Package header file, GUID/PPI/Protocol definitions
84 private static final Map
<PackageIdentification
, Spd
> spdTable
= new HashMap
<PackageIdentification
, Spd
>();
87 /// Build informations are divided into three parts:
88 /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
90 private static Map
<ModuleIdentification
, Map
<String
, XmlObject
>> nativeMsa
= new HashMap
<ModuleIdentification
, Map
<String
, XmlObject
>>();
92 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> fpdModuleSA
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
94 private static XmlObject fpdBuildOptions
;
96 private static XmlObject fpdDynamicPcds
;
99 /// Parsed modules list
101 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> parsedModules
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
104 /// built modules list with ARCH, TARGET, TOOLCHAIN
106 private static Set
<FpdModuleIdentification
> builtModules
= new HashSet
<FpdModuleIdentification
>();
109 /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.
111 // private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();
114 /// build target + tool chain family/tag name + arch + command types + command options
118 /// toolsDef - build tool program information
119 /// fpdBuildOption - all modules's build options for tool tag or tool chain families
120 /// moduleSaBuildOption - build options for a specific module
122 private static ToolChainConfig toolsDef
;
124 private static ToolChainInfo toolChainInfo
;
125 private static ToolChainInfo toolChainEnvInfo
;
126 private static ToolChainInfo toolChainPlatformInfo
;
128 private static ToolChainMap platformToolChainOption
;
129 private static ToolChainMap platformToolChainFamilyOption
;
131 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
132 private static Map
<FpdModuleIdentification
, ToolChainMap
> moduleToolChainFamilyOption
= new HashMap
<FpdModuleIdentification
, ToolChainMap
>();
134 private static final MemoryDatabaseManager pcdDbManager
= new MemoryDatabaseManager();
139 Parse framework database (DB) and all SPD files listed in DB to initialize
140 the environment for next build. This method will only be executed only once
141 in the whole build process.
143 @param workspaceDatabaseFile the file name of framework database
144 @param workspaceDir current workspace directory path
145 @throws BuildException
146 Framework Dababase or SPD or MSA file is not valid
148 public synchronized static void initInfo(String workspaceDatabaseFile
, String workspaceDir
, String toolsDefFilename
) throws BuildException
{
150 // ensure this method will be revoked only once
158 // Backup workspace directory. It will be used by other method
160 GlobalData
.workspaceDir
= workspaceDir
.replaceAll("(\\\\)", "/");
163 // Parse tools definition file
166 // If ToolChain has been set up before, do nothing.
167 // CONF dir + tools definition file name
169 File toolsDefFile
= new File(workspaceDir
+ 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
.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 String
getCommandSetting(String
[] commandDescription
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
693 ToolChainKey toolChainKey
= new ToolChainKey(commandDescription
);
694 ToolChainMap toolChainConfig
= toolsDef
.getConfig();
695 String setting
= null;
697 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
698 setting
= toolChainConfig
.get(toolChainKey
);
699 if (setting
== null) {
706 // get module specific options, if any
709 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
710 ToolChainKey toolChainFamilyKey
= null;
712 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
714 // then tool chain family
716 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
717 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
718 String family
= toolChainConfig
.get(toolChainFamilyKey
);
719 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
720 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
722 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
723 if (option
!= null) {
724 setting
= option
.get(toolChainFamilyKey
);
729 // get platform options, if any
731 if (setting
== null) {
733 if (platformToolChainOption
== null || (setting
= platformToolChainOption
.get(toolChainKey
)) == null) {
734 // then tool chain family
735 if (toolChainFamilyKey
== null) {
736 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
737 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
738 String family
= toolChainConfig
.get(toolChainFamilyKey
);
739 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
740 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
743 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
747 if (setting
== null) {
754 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
755 toolChainEnvInfo
= envInfo
;
757 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
758 toolChainPlatformInfo
= platformInfo
;
764 public synchronized static MemoryDatabaseManager
getPCDMemoryDBManager() {
769 // For PCD get tokenSpaceGUid
771 public synchronized static String
[] getGuidInfoFromCname(String cName
){
772 String cNameGuid
[] = null;
774 Set set
= spdTable
.keySet();
775 Iterator iter
= set
.iterator();
781 while (iter
.hasNext()){
782 Spd spd
= (Spd
) spdTable
.get(iter
.next());
783 guid
= spd
.getGuidFromCname(cName
);
785 cNameGuid
= new String
[2];
786 cNameGuid
[0] = cName
;
797 public synchronized static Map
<FpdModuleIdentification
, XmlObject
> getFpdModuleSaXmlObject(
798 String xmlObjectName
) {
799 Set
<FpdModuleIdentification
> fpdModuleSASet
= fpdModuleSA
.keySet();
800 Iterator item
= fpdModuleSASet
.iterator();
803 Map
<FpdModuleIdentification
, XmlObject
> SAPcdBuildDef
= new HashMap
<FpdModuleIdentification
, XmlObject
>();
804 Map
<String
, XmlObject
> SANode
= new HashMap
<String
, XmlObject
>();
805 FpdModuleIdentification moduleId
;
806 while (item
.hasNext()) {
808 moduleId
= (FpdModuleIdentification
) item
.next();
809 SANode
= fpdModuleSA
.get(moduleId
);
811 if (SANode
.get(xmlObjectName
)!= null){
812 SAPcdBuildDef
.put(moduleId
,
814 .get(xmlObjectName
));
819 } catch (Exception e
){
820 EdkLog
.log(EdkLog
.EDK_INFO
, e
.getMessage());
823 return SAPcdBuildDef
;