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
.io
.IOException
;
21 import java
.util
.HashMap
;
22 import java
.util
.HashSet
;
23 import java
.util
.Iterator
;
24 import java
.util
.List
;
28 import org
.apache
.xmlbeans
.XmlException
;
29 import org
.apache
.xmlbeans
.XmlObject
;
31 import org
.tianocore
.common
.exception
.EdkException
;
32 import org
.tianocore
.common
.logger
.EdkLog
;
33 import org
.tianocore
.pcd
.entity
.MemoryDatabaseManager
;
34 import org
.tianocore
.DbPathAndFilename
;
35 import org
.tianocore
.FrameworkDatabaseDocument
;
36 import org
.tianocore
.ModuleSurfaceAreaDocument
;
37 import org
.tianocore
.ModuleSurfaceAreaDocument
.ModuleSurfaceArea
;
38 import org
.tianocore
.build
.id
.FpdModuleIdentification
;
39 import org
.tianocore
.build
.id
.ModuleIdentification
;
40 import org
.tianocore
.build
.id
.PackageIdentification
;
41 import org
.tianocore
.build
.id
.PlatformIdentification
;
42 import org
.tianocore
.build
.toolchain
.ToolChainAttribute
;
43 import org
.tianocore
.build
.toolchain
.ToolChainConfig
;
44 import org
.tianocore
.build
.toolchain
.ToolChainElement
;
45 import org
.tianocore
.build
.toolchain
.ToolChainInfo
;
46 import org
.tianocore
.build
.toolchain
.ToolChainKey
;
47 import org
.tianocore
.build
.toolchain
.ToolChainMap
;
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 /// Record current WORKSPACE Directory
63 private static String workspaceDir
= "";
66 /// Be used to ensure Global data will be initialized only once.
68 private static boolean globalFlag
= false;
71 /// Framework Database information: package list and platform list
73 private static Set
<PackageIdentification
> packageList
= new HashSet
<PackageIdentification
>();
75 private static Set
<PlatformIdentification
> platformList
= new HashSet
<PlatformIdentification
>();
78 /// Every detail SPD informations: Module list, Library class definition,
79 /// Package header file, GUID/PPI/Protocol definitions
81 private static final Map
<PackageIdentification
, Spd
> spdTable
= new HashMap
<PackageIdentification
, Spd
>();
84 /// Build informations are divided into three parts:
85 /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
87 private static Map
<ModuleIdentification
, Map
<String
, XmlObject
>> nativeMsa
= new HashMap
<ModuleIdentification
, Map
<String
, XmlObject
>>();
89 private static Map
<FpdModuleIdentification
, Map
<String
, XmlObject
>> fpdModuleSA
= new HashMap
<FpdModuleIdentification
, Map
<String
, XmlObject
>>();
91 private static Map
<String
, XmlObject
> fpdBuildOptionsMap
= new HashMap
<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 EdkException
{
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 EdkLog
.log("Init", EdkLog
.EDK_ALWAYS
, "Using tool definition file [" + toolsDefFile
.getPath() + "].");
166 toolsDef
= new ToolChainConfig(toolsDefFile
);
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 EdkException("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().trim();
189 Spd spd
= new Spd(new File(workspaceDir
+ File
.separatorChar
+ fileName
));
190 packageList
.add(spd
.getPackageId());
192 // Report warning if existing two packages with same GUID and Version
194 if (spdTable
.containsKey(spd
.getPackageId())) {
198 EdkLog
.log("Init", EdkLog
.EDK_WARNING
, "Warning: Existing two packages with same GUID and Version. They are ... " + spd
.getPackageId().getSpdFile().getPath());
200 spdTable
.put(spd
.getPackageId(), spd
);
207 if (db
.getFrameworkDatabase().getPlatformList() != null) {
208 List
<DbPathAndFilename
> platforms
= db
.getFrameworkDatabase().getPlatformList().getFilenameList();
209 Iterator
<DbPathAndFilename
> iter
= platforms
.iterator();
210 while (iter
.hasNext()) {
211 String fileName
= iter
.next().getStringValue().trim();
212 File fpdFile
= new File(workspaceDir
+ File
.separatorChar
+ fileName
);
213 if ( !fpdFile
.exists() ) {
214 throw new EdkException("Platform file [" + fpdFile
.getPath() + "] not exists. ");
216 XmlObject fpdDoc
= XmlObject
.Factory
.parse(fpdFile
);
218 // Verify FPD file, if is invalid, throw Exception
220 if (!fpdDoc
.validate()) {
221 throw new EdkException("Framework Platform Surface Area file [" + fpdFile
.getPath() + "] format is invalid!");
224 // We can change Map to XmlObject
226 Map
<String
, XmlObject
> fpdDocMap
= new HashMap
<String
, XmlObject
>();
227 fpdDocMap
.put("PlatformSurfaceArea", fpdDoc
);
228 SurfaceAreaQuery saq
= new SurfaceAreaQuery(fpdDocMap
);
229 PlatformIdentification platformId
= saq
.getFpdHeader();
230 platformId
.setFpdFile(fpdFile
);
232 // Report warning if existing two platfrom with same GUID and Version
234 if (platformList
.contains(platformId
)) {
238 EdkLog
.log("Init", EdkLog
.EDK_WARNING
, "Warning: Existing two platforms with same GUID and Version. They are ... " + fpdFile
.getPath());
240 platformList
.add(platformId
);
243 } catch(IOException ex
) {
244 EdkException edkException
= new EdkException("Parse WORKSPACE Database file [" + dbFile
.getPath() + "] Error.\n" + ex
.getMessage());
245 edkException
.setStackTrace(ex
.getStackTrace());
247 } catch(XmlException ex
) {
248 EdkException edkException
= new EdkException("Parse WORKSPACE Database file [" + dbFile
.getPath() + "] Error.\n" + ex
.getMessage());
249 edkException
.setStackTrace(ex
.getStackTrace());
255 Get the current WORKSPACE Directory.
257 @return current workspace directory
259 public synchronized static String
getWorkspacePath() {
265 Get the MSA file name with absolute path
267 public synchronized static File
getMsaFile(ModuleIdentification moduleId
) throws EdkException
{
270 // TBD. Do only when package is null.
272 Iterator iter
= packageList
.iterator();
273 while (iter
.hasNext()) {
274 PackageIdentification packageId
= (PackageIdentification
)iter
.next();
275 Spd spd
= spdTable
.get(packageId
);
276 msaFile
= spd
.getModuleFile(moduleId
);
277 if (msaFile
!= null ) {
281 if (msaFile
== null){
282 throw new EdkException("Can't find Module [" + moduleId
.getName() + "] in any SPD package!");
288 public synchronized static PackageIdentification
getPackageForModule(ModuleIdentification moduleId
) throws EdkException
{
290 // If package already defined in module
292 if (moduleId
.getPackage() != null) {
293 return moduleId
.getPackage();
296 PackageIdentification packageId
= null;
297 Iterator iter
= packageList
.iterator();
298 while (iter
.hasNext()) {
299 packageId
= (PackageIdentification
)iter
.next();
300 moduleId
.setPackage(packageId
);
301 Spd spd
= spdTable
.get(packageId
);
302 if (spd
.getModuleFile(moduleId
) != null ) {
306 if (packageId
== null){
307 throw new EdkException("Can't find Module [" + moduleId
.getName() + "] in any SPD package!");
314 Difference between build and parse: ToolChain and Target
316 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId
) {
317 return builtModules
.contains(moduleId
);
320 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId
) {
321 builtModules
.add(fpdModuleId
);
325 public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId
, Map
<String
, XmlObject
> doc
) throws EdkException
{
326 Map
<String
, XmlObject
> result
= new HashMap
<String
, XmlObject
>();
327 Set keySet
= doc
.keySet();
328 Iterator iter
= keySet
.iterator();
329 while (iter
.hasNext()){
330 String key
= (String
)iter
.next();
331 XmlObject item
= cloneXmlObject(doc
.get(key
), true);
332 result
.put(key
, item
);
334 fpdModuleSA
.put(fpdModuleId
, result
);
337 public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId
) {
338 return fpdModuleSA
.containsKey(fpdModuleId
);
342 Query module surface area information.
344 <p>Note that surface area parsing is incremental. That means the method will
345 only parse the MSA files if necessary. </p>
347 @param fpdModuleId Module ID with arch
348 @return ModuleSA info and MSA info for fpdModuleId
349 @throws BuildException Can't find MSA
351 public synchronized static Map
<String
, XmlObject
> getDoc(FpdModuleIdentification fpdModuleId
) throws EdkException
{
352 if (parsedModules
.containsKey(fpdModuleId
)) {
353 return parsedModules
.get(fpdModuleId
);
355 Map
<String
, XmlObject
> doc
= new HashMap
<String
, XmlObject
>();
356 ModuleIdentification moduleId
= fpdModuleId
.getModule();
358 // First part: get the MSA files info
360 doc
.putAll(getNativeMsa(moduleId
));
363 // Second part: put build options
365 doc
.put("BuildOptions", fpdBuildOptions
);
368 // Third part: get Module info from FPD, such as Library instances, PCDs
370 if (fpdModuleSA
.containsKey(fpdModuleId
)){
372 // merge module info in FPD to final Doc
373 // For Library Module, do nothing here
375 doc
.putAll(fpdModuleSA
.get(fpdModuleId
));
377 parsedModules
.put(fpdModuleId
, doc
);
381 public synchronized static Map
<String
, XmlObject
> getDoc(ModuleIdentification moduleId
, String arch
) throws EdkException
{
382 FpdModuleIdentification fpdModuleId
= new FpdModuleIdentification(moduleId
, arch
);
383 return getDoc(fpdModuleId
);
387 Query the native MSA information with module base name.
389 <p>Note that MSA parsing is incremental. That means the method will
390 only to parse the MSA files when never parsed before. </p>
392 @param moduleName the base name of the module
393 @return the native MSA information
394 @throws BuildException
395 MSA file is not valid
397 public synchronized static Map
<String
, XmlObject
> getNativeMsa(ModuleIdentification moduleId
) throws EdkException
{
398 if (nativeMsa
.containsKey(moduleId
)) {
399 return nativeMsa
.get(moduleId
);
401 File msaFile
= getMsaFile(moduleId
);
402 Map
<String
, XmlObject
> msaMap
= getNativeMsa(msaFile
);
403 nativeMsa
.put(moduleId
, msaMap
);
407 public synchronized static Map
<String
, XmlObject
> getNativeMsa(File msaFile
) throws EdkException
{
408 if (!msaFile
.exists()) {
409 throw new EdkException("Module Surface Area file [" + msaFile
.getPath() + "] can't be found!");
412 ModuleSurfaceAreaDocument doc
= (ModuleSurfaceAreaDocument
)XmlObject
.Factory
.parse(msaFile
);
414 // Validate File if they accord with XML Schema
416 if ( !doc
.validate()){
417 throw new EdkException("Module Surface Area file [" + msaFile
.getPath() + "] format is invalid!");
422 ModuleSurfaceArea msa
= doc
.getModuleSurfaceArea();
423 Map
<String
, XmlObject
> msaMap
= new HashMap
<String
, XmlObject
>();
424 msaMap
.put("MsaHeader", cloneXmlObject(msa
.getMsaHeader(), true));
425 msaMap
.put("ModuleDefinitions", cloneXmlObject(msa
.getModuleDefinitions(), true));
426 msaMap
.put("LibraryClassDefinitions", cloneXmlObject(msa
.getLibraryClassDefinitions(), true));
427 msaMap
.put("SourceFiles", cloneXmlObject(msa
.getSourceFiles(), true));
428 msaMap
.put("PackageDependencies", cloneXmlObject(msa
.getPackageDependencies(), true));
429 msaMap
.put("Protocols", cloneXmlObject(msa
.getProtocols(), true));
430 msaMap
.put("PPIs", cloneXmlObject(msa
.getPPIs(), true));
431 msaMap
.put("Guids", cloneXmlObject(msa
.getGuids(), true));
432 msaMap
.put("Externs", cloneXmlObject(msa
.getExterns(), true));
433 msaMap
.put("PcdCoded", cloneXmlObject(msa
.getPcdCoded(), true));
435 } catch(IOException ex
) {
436 EdkException edkException
= new EdkException("Parsing MSA file [" + msaFile
.getPath() + "] error. \n" + ex
.getMessage());
437 edkException
.setStackTrace(ex
.getStackTrace());
439 } catch(XmlException ex
) {
440 EdkException edkException
= new EdkException("Parsing MSA file [" + msaFile
.getPath() + "] error. \n" + ex
.getMessage());
441 edkException
.setStackTrace(ex
.getStackTrace());
446 public static Map
<String
, XmlObject
> getFpdBuildOptionsMap() {
447 return fpdBuildOptionsMap
;
450 public static void setFpdBuildOptions(XmlObject fpdBuildOptions
) throws EdkException
{
451 GlobalData
.fpdBuildOptions
= cloneXmlObject(fpdBuildOptions
, true);
452 fpdBuildOptionsMap
.put("BuildOptions", GlobalData
.fpdBuildOptions
);
455 public static XmlObject
getFpdDynamicPcds() {
456 return fpdDynamicPcds
;
459 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds
) {
460 GlobalData
.fpdDynamicPcds
= fpdDynamicPcds
;
463 public static Set
<ModuleIdentification
> getModules(PackageIdentification packageId
){
464 Spd spd
= spdTable
.get(packageId
);
466 Set
<ModuleIdentification
> dummy
= new HashSet
<ModuleIdentification
>();
469 return spd
.getModules();
474 * The header file path is relative to workspace dir
476 public static String
[] getLibraryClassHeaderFiles(
477 PackageIdentification
[] packages
, String name
) throws EdkException
{
478 if (packages
== null) {
479 // throw Exception or not????
480 return new String
[0];
482 String
[] result
= null;
483 for (int i
= 0; i
< packages
.length
; i
++) {
484 Spd spd
= spdTable
.get(packages
[i
]);
486 // If find one package defined the library class
488 if ((result
= spd
.getLibClassIncluder(name
)) != null) {
493 // If can't find library class declaration in every package
495 throw new EdkException("Can not find library class [" + name
496 + "] declaration in any SPD package!");
500 * The header file path is relative to workspace dir
502 public static String
getPackageHeaderFiles(PackageIdentification packages
,
504 if (packages
== null) {
505 return new String("");
507 Spd spd
= spdTable
.get(packages
);
509 // If can't find package header file, skip it
513 if ((temp
= spd
.getPackageIncluder(moduleType
)) != null) {
525 * return two values: {cName, GuidValue}
527 public static String
[] getGuid(List
<PackageIdentification
> packages
, String name
) {
528 if (packages
== null) {
529 // throw Exception or not????
530 return new String
[0];
532 String
[] result
= null;
533 Iterator item
= packages
.iterator();
534 while (item
.hasNext()){
535 Spd spd
= spdTable
.get(item
.next());
537 // If find one package defined the GUID
539 if ((result
= spd
.getGuid(name
)) != null) {
548 * return two values: {cName, GuidValue}
550 public static String
[] getPpiGuid(List
<PackageIdentification
> packages
,
552 if (packages
== null) {
553 return new String
[0];
555 String
[] result
= null;
556 Iterator item
= packages
.iterator();
557 while (item
.hasNext()){
558 Spd spd
= spdTable
.get(item
.next());
560 // If find one package defined the Ppi GUID
562 if ((result
= spd
.getPpi(name
)) != null) {
570 * return two values: {cName, GuidValue}
572 public static String
[] getProtocolGuid(List
<PackageIdentification
> packages
,
574 if (packages
== null) {
575 return new String
[0];
577 String
[] result
= null;
578 Iterator item
= packages
.iterator();
579 while (item
.hasNext()){
580 Spd spd
= spdTable
.get(item
.next());
582 // If find one package defined the protocol GUID
584 if ((result
= spd
.getProtocol(name
))!= null){
592 public synchronized static PlatformIdentification
getPlatformByName(String name
) throws EdkException
{
593 Iterator iter
= platformList
.iterator();
594 while(iter
.hasNext()){
595 PlatformIdentification platformId
= (PlatformIdentification
)iter
.next();
596 if (platformId
.getName().equalsIgnoreCase(name
)) {
600 throw new EdkException("Can't find platform [" + name
+ "] in the current WORKSPACE database!");
603 public synchronized static PlatformIdentification
getPlatform(String filename
) throws EdkException
{
604 File file
= new File(workspaceDir
+ File
.separatorChar
+ filename
);
605 Iterator iter
= platformList
.iterator();
606 while(iter
.hasNext()){
607 PlatformIdentification platformId
= (PlatformIdentification
)iter
.next();
608 if (platformId
.getFpdFile().getPath().equalsIgnoreCase(file
.getPath())) {
612 throw new EdkException("Can't find platform file [" + filename
+ "] in the current WORKSPACE database!");
615 public synchronized static PackageIdentification
refreshPackageIdentification(PackageIdentification packageId
) throws EdkException
{
616 Iterator iter
= packageList
.iterator();
617 while(iter
.hasNext()){
618 PackageIdentification packageItem
= (PackageIdentification
)iter
.next();
619 if (packageItem
.equals(packageId
)) {
620 packageId
.setName(packageItem
.getName());
621 packageId
.setSpdFile(packageItem
.getSpdFile());
625 throw new EdkException("Can't find package GUID value " + packageId
.toGuidString() + " in the current workspace!");
628 public synchronized static ModuleIdentification
refreshModuleIdentification(ModuleIdentification moduleId
) throws EdkException
{
629 PackageIdentification packageId
= getPackageForModule(moduleId
);
630 moduleId
.setPackage(packageId
);
631 Spd spd
= spdTable
.get(packageId
);
633 throw new EdkException("Can't find package GUID value " + packageId
.toGuidString() + " in the current workspace!");
635 Set
<ModuleIdentification
> modules
= spd
.getModules();
636 Iterator
<ModuleIdentification
> iter
= modules
.iterator();
637 while (iter
.hasNext()) {
638 ModuleIdentification item
= iter
.next();
639 if (item
.equals(moduleId
)) {
640 moduleId
.setName(item
.getName());
641 moduleId
.setModuleType(item
.getModuleType());
642 moduleId
.setMsaFile(item
.getMsaFile());
646 throw new EdkException("Can't find module GUID value " + moduleId
.toGuidString() + " in " + packageId
+ " under the current workspace!");
649 public synchronized static Set
<PackageIdentification
> getPackageList(){
654 BUGBUG: It is a walk around method. If do not clone, can't query info with
657 @param object XmlObject
658 @param deep flag for deep clone
659 @return XmlObject after clone
660 @throws BuildException parse original XmlObject error.
662 private static XmlObject
cloneXmlObject(XmlObject object
, boolean deep
) throws EdkException
{
663 if ( object
== null) {
666 XmlObject result
= null;
668 result
= XmlObject
.Factory
.parse(object
.getDomNode()
670 } catch (XmlException ex
) {
671 EdkException edkException
= new EdkException(ex
.getMessage());
672 edkException
.setStackTrace(ex
.getStackTrace());
679 /// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
681 public static ToolChainInfo
getToolChainInfo() {
682 if (toolChainInfo
== null) {
683 toolChainInfo
= toolsDef
.getConfigInfo().intersection(toolChainEnvInfo
);
684 if (toolChainPlatformInfo
!= null) {
685 toolChainInfo
= toolChainInfo
.intersection(toolChainPlatformInfo
);
687 toolChainInfo
.addCommands(toolsDef
.getConfigInfo().getCommands());
688 toolChainInfo
.normalize();
689 EdkLog
.log("Init", EdkLog
.EDK_ALWAYS
, "Current build tool chain information summary: ");
690 EdkLog
.log("Init", EdkLog
.EDK_ALWAYS
, toolChainInfo
+ "");
692 return toolChainInfo
;
695 public static void setPlatformToolChainFamilyOption(ToolChainMap map
) {
696 platformToolChainFamilyOption
= map
;
699 public static void setPlatformToolChainOption(ToolChainMap map
) {
700 platformToolChainOption
= map
;
703 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId
,
704 ToolChainMap toolChainOption
) {
705 moduleToolChainOption
.put(fpdModuleId
, toolChainOption
);
708 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId
,
709 ToolChainMap toolChainOption
) {
710 moduleToolChainFamilyOption
.put(fpdModuleId
, toolChainOption
);
713 public static boolean isCommandSet(String target
, String toolchain
, String arch
) {
714 String
[] commands
= getToolChainInfo().getCommands();
716 for (int i
= 0; i
< commands
.length
; ++i
) {
717 String cmdName
= toolsDef
.getConfig().get(new String
[] {target
, toolchain
, arch
, commands
[i
], ToolChainAttribute
.NAME
.toString()});
718 if (cmdName
!= null && cmdName
.length() != 0) {
726 public static String
getCommandSetting(String
[] commandDescription
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
727 ToolChainKey toolChainKey
= new ToolChainKey(commandDescription
);
728 ToolChainMap toolChainConfig
= toolsDef
.getConfig();
729 String setting
= null;
731 if (!commandDescription
[ToolChainElement
.ATTRIBUTE
.value
].equals(ToolChainAttribute
.FLAGS
.toString())) {
732 setting
= toolChainConfig
.get(toolChainKey
);
733 if (setting
== null) {
740 // get module specific options, if any
743 ToolChainMap option
= moduleToolChainOption
.get(fpdModuleId
);
744 ToolChainKey toolChainFamilyKey
= null;
746 if ((option
== null) || (option
!= null && (setting
= option
.get(toolChainKey
)) == null)) {
748 // then tool chain family
750 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
751 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
752 String family
= toolChainConfig
.get(toolChainFamilyKey
);
753 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
754 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
756 option
= moduleToolChainFamilyOption
.get(fpdModuleId
);
757 if (option
!= null) {
758 setting
= option
.get(toolChainFamilyKey
);
763 // get platform options, if any
765 if (setting
== null) {
767 if (platformToolChainOption
== null || (setting
= platformToolChainOption
.get(toolChainKey
)) == null) {
768 // then tool chain family
769 if (toolChainFamilyKey
== null) {
770 toolChainFamilyKey
= new ToolChainKey(commandDescription
);
771 toolChainFamilyKey
.setKey(ToolChainAttribute
.FAMILY
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
772 String family
= toolChainConfig
.get(toolChainFamilyKey
);
773 toolChainFamilyKey
.setKey(family
, ToolChainElement
.TOOLCHAIN
.value
);
774 toolChainFamilyKey
.setKey(ToolChainAttribute
.FLAGS
.toString(), ToolChainElement
.ATTRIBUTE
.value
);
777 setting
= platformToolChainFamilyOption
.get(toolChainFamilyKey
);
781 if (setting
== null) {
788 public static void setToolChainEnvInfo(ToolChainInfo envInfo
) {
789 toolChainEnvInfo
= envInfo
;
791 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo
) {
792 toolChainPlatformInfo
= platformInfo
;
798 public synchronized static MemoryDatabaseManager
getPCDMemoryDBManager() {
803 // For PCD get tokenSpaceGUid
805 public synchronized static String
getGuidInfoFromCname(String cName
){
806 String cNameGuid
= null;
808 Set set
= spdTable
.keySet();
809 Iterator iter
= set
.iterator();
815 while (iter
.hasNext()){
816 Spd spd
= (Spd
) spdTable
.get(iter
.next());
817 guid
= spd
.getGuidFromCname(cName
);
829 public synchronized static Map
<FpdModuleIdentification
, XmlObject
>
830 getFpdModuleSaXmlObject(String xmlObjectName
) {
831 Set
<FpdModuleIdentification
> fpdModuleSASet
= fpdModuleSA
.keySet();
832 Iterator item
= fpdModuleSASet
.iterator();
835 Map
<FpdModuleIdentification
, XmlObject
> SAPcdBuildDef
= new HashMap
<FpdModuleIdentification
, XmlObject
>();
836 Map
<String
, XmlObject
> SANode
= new HashMap
<String
, XmlObject
>();
837 FpdModuleIdentification moduleId
;
838 while (item
.hasNext()) {
840 moduleId
= (FpdModuleIdentification
) item
.next();
841 SANode
= fpdModuleSA
.get(moduleId
);
843 if (SANode
.get(xmlObjectName
)!= null){
844 SAPcdBuildDef
.put(moduleId
,
845 (XmlObject
) SANode
.get(xmlObjectName
));
848 } catch (Exception e
){
849 EdkLog
.log(EdkLog
.EDK_INFO
, e
.getMessage());
852 return SAPcdBuildDef
;
855 public synchronized static Map
<FpdModuleIdentification
,XmlObject
> getFpdPcdBuildDefinitions() {
856 Map
<FpdModuleIdentification
,XmlObject
> pcdBuildDef
= getFpdModuleSaXmlObject ("PcdBuildDefinition");