Fixed grammar in messages.
[mirror_edk2.git] / Tools / Source / GenBuild / org / tianocore / build / global / GlobalData.java
1 /** @file
2 GlobalData class.
3
4 GlobalData provide initializing, instoring, querying and update global data.
5 It is a bridge to intercommunicate between multiple component, such as AutoGen,
6 PCD and so on.
7
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
13
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.
16 **/
17 package org.tianocore.build.global;
18
19 import java.io.File;
20 import java.util.HashMap;
21 import java.util.HashSet;
22 import java.util.Iterator;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Set;
26 import java.util.logging.Logger;
27
28 import org.apache.tools.ant.BuildException;
29 import org.apache.xmlbeans.XmlObject;
30 import org.tianocore.DbPathAndFilename;
31 import org.tianocore.FrameworkDatabaseDocument;
32 import org.tianocore.ModuleSurfaceAreaDocument;
33 import org.tianocore.ModuleSurfaceAreaDocument.ModuleSurfaceArea;
34 import org.tianocore.build.id.FpdModuleIdentification;
35 import org.tianocore.build.id.ModuleIdentification;
36 import org.tianocore.build.id.PackageIdentification;
37 import org.tianocore.build.id.PlatformIdentification;
38 import org.tianocore.pcd.entity.MemoryDatabaseManager;
39 import org.tianocore.build.toolchain.ToolChainAttribute;
40 import org.tianocore.build.toolchain.ToolChainConfig;
41 import org.tianocore.build.toolchain.ToolChainElement;
42 import org.tianocore.build.toolchain.ToolChainInfo;
43 import org.tianocore.build.toolchain.ToolChainKey;
44 import org.tianocore.build.toolchain.ToolChainMap;
45 import org.tianocore.exception.EdkException;
46 import org.tianocore.logger.EdkLog;
47
48 /**
49 GlobalData provide initializing, instoring, querying and update global data.
50 It is a bridge to intercommunicate between multiple component, such as AutoGen,
51 PCD and so on.
52
53 <p>Note that all global information are initialized incrementally. All data will
54 parse and record only of necessary during build time. </p>
55
56 @since GenBuild 1.0
57 **/
58 public class GlobalData {
59
60 public static Logger log = Logger.getAnonymousLogger();
61
62 ///
63 /// Record current WORKSPACE Directory
64 ///
65 private static String workspaceDir = "";
66
67 ///
68 /// Be used to ensure Global data will be initialized only once.
69 ///
70 private static boolean globalFlag = false;
71
72 ///
73 /// Framework Database information: package list and platform list
74 ///
75 private static Set<PackageIdentification> packageList = new HashSet<PackageIdentification>();
76
77 private static Set<PlatformIdentification> platformList = new HashSet<PlatformIdentification>();
78
79 ///
80 /// Every detail SPD informations: Module list, Library class definition,
81 /// Package header file, GUID/PPI/Protocol definitions
82 ///
83 private static final Map<PackageIdentification, Spd> spdTable = new HashMap<PackageIdentification, Spd>();
84
85 ///
86 /// Build informations are divided into three parts:
87 /// 1. From MSA 2. From FPD 3. From FPD' ModuleSA
88 ///
89 private static Map<ModuleIdentification, Map<String, XmlObject>> nativeMsa = new HashMap<ModuleIdentification, Map<String, XmlObject>>();
90
91 private static Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleSA= new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();
92
93 private static XmlObject fpdBuildOptions;
94
95 private static XmlObject fpdDynamicPcds;
96
97 ///
98 /// Parsed modules list
99 ///
100 private static Map<FpdModuleIdentification, Map<String, XmlObject>> parsedModules = new HashMap<FpdModuleIdentification, Map<String, XmlObject>>();
101
102 ///
103 /// built modules list with ARCH, TARGET, TOOLCHAIN
104 ///
105 private static Set<FpdModuleIdentification> builtModules = new HashSet<FpdModuleIdentification>();
106
107 ///
108 /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.
109 ///
110 private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();
111
112 ///
113 /// build target + tool chain family/tag name + arch + command types + command options
114 ///
115 ///
116 /// Tool Chain Data
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
120 ///
121 private static ToolChainConfig toolsDef;
122
123 private static ToolChainInfo toolChainInfo;
124 private static ToolChainInfo toolChainEnvInfo;
125 private static ToolChainInfo toolChainPlatformInfo;
126
127 private static ToolChainMap platformToolChainOption;
128 private static ToolChainMap platformToolChainFamilyOption;
129
130 private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainOption = new HashMap<FpdModuleIdentification, ToolChainMap>();
131 private static Map<FpdModuleIdentification, ToolChainMap> moduleToolChainFamilyOption = new HashMap<FpdModuleIdentification, ToolChainMap>();
132
133 /**
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.
137
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
142 **/
143 public synchronized static void initInfo(String workspaceDatabaseFile, String workspaceDir, String toolsDefFilename ) throws BuildException {
144 //
145 // ensure this method will be revoked only once
146 //
147 if (globalFlag) {
148 return;
149 }
150 globalFlag = true;
151
152 //
153 // Backup workspace directory. It will be used by other method
154 //
155 GlobalData.workspaceDir = workspaceDir.replaceAll("(\\\\)", "/");
156
157 //
158 // Parse tools definition file
159 //
160 //
161 // If ToolChain has been set up before, do nothing.
162 // CONF dir + tools definition file name
163 //
164 File toolsDefFile = new File(workspaceDir + File.separatorChar + toolsDefFilename);
165 System.out.println("Using file [" + toolsDefFile.getPath() + "] as tools definition file. ");
166 toolsDef = new ToolChainConfig(toolsDefFile);
167
168 //
169 // Parse Framework Database
170 //
171 File dbFile = new File(workspaceDir + File.separatorChar + workspaceDatabaseFile);
172 try {
173 FrameworkDatabaseDocument db = (FrameworkDatabaseDocument) XmlObject.Factory.parse(dbFile);
174 //
175 // validate FrameworkDatabaseFile
176 //
177 if (! db.validate()) {
178 throw new BuildException("Framework Database file [" + dbFile.getPath() + "] is invalid.");
179 }
180 //
181 // Get package list
182 //
183 if (db.getFrameworkDatabase().getPackageList() != null ) {
184 List<DbPathAndFilename> packages = db.getFrameworkDatabase().getPackageList().getFilenameList();
185 Iterator<DbPathAndFilename> iter = packages.iterator();
186 while (iter.hasNext()) {
187 String fileName = iter.next().getStringValue();
188 Spd spd = new Spd(new File(workspaceDir + File.separatorChar + fileName));
189 packageList.add(spd.getPackageId());
190 spdTable.put(spd.getPackageId(), spd);
191 }
192 }
193
194 //
195 // Get platform list
196 //
197 if (db.getFrameworkDatabase().getPlatformList() != null) {
198 List<DbPathAndFilename> platforms = db.getFrameworkDatabase().getPlatformList().getFilenameList();
199 Iterator<DbPathAndFilename> iter = platforms.iterator();
200 while (iter.hasNext()) {
201 String fileName = iter.next().getStringValue();
202 File fpdFile = new File(workspaceDir + File.separatorChar + fileName);
203 if ( ! fpdFile.exists() ) {
204 throw new BuildException("Platform file [" + fpdFile.getPath() + "] not exists. ");
205 }
206 XmlObject fpdDoc = XmlObject.Factory.parse(fpdFile);
207 //
208 // Verify FPD file, if is invalid, throw Exception
209 //
210 if (! fpdDoc.validate()) {
211 throw new BuildException("Framework Platform Surface Area file [" + fpdFile.getPath() + "] is invalid. ");
212 }
213 //
214 // We can change Map to XmlObject
215 //
216 //
217 // TBD check SPD or FPD is existed in FS
218 //
219 Map<String, XmlObject> fpdDocMap = new HashMap<String, XmlObject>();
220 fpdDocMap.put("PlatformSurfaceArea", fpdDoc);
221 SurfaceAreaQuery.setDoc(fpdDocMap);
222 PlatformIdentification platformId = SurfaceAreaQuery.getFpdHeader();
223 platformId.setFpdFile(fpdFile);
224 platformList.add(platformId);
225 }
226 }
227 } catch (Exception e) {
228 throw new BuildException("Parse workspace Database [" + dbFile.getPath() + "] Error.\n" + e.getMessage());
229 }
230 }
231
232 /**
233 Get the current WORKSPACE Directory.
234
235 @return current workspace directory
236 **/
237 public synchronized static String getWorkspacePath() {
238 return workspaceDir;
239 }
240
241
242 /**
243 Get the MSA file name with absolute path
244 */
245 public synchronized static File getMsaFile(ModuleIdentification moduleId) throws BuildException {
246 File msaFile = null;
247 //
248 // TBD. Do only when package is null.
249 //
250 Iterator iter = packageList.iterator();
251 while (iter.hasNext()) {
252 PackageIdentification packageId = (PackageIdentification)iter.next();
253 Spd spd = spdTable.get(packageId);
254 msaFile = spd.getModuleFile(moduleId);
255 if (msaFile != null ) {
256 break ;
257 }
258 }
259 if (msaFile == null){
260 throw new BuildException("Can't find Module [" + moduleId.getName() + "] in all packages. ");
261 }
262 else {
263 return msaFile;
264 }
265 }
266
267 public synchronized static PackageIdentification getPackageForModule(ModuleIdentification moduleId) {
268 //
269 // If package already defined in module
270 //
271 if (moduleId.getPackage() != null) {
272 return moduleId.getPackage();
273 }
274
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 ) {
282 break ;
283 }
284 }
285 if (packageId == null){
286 throw new BuildException("Can't find Module [" + moduleId.getName() + "] in all packages. ");
287 }
288 else {
289 return packageId;
290 }
291 }
292
293 /**
294 Difference between build and parse: ToolChain and Target
295 **/
296 public synchronized static boolean isModuleBuilt(FpdModuleIdentification moduleId) {
297 return builtModules.contains(moduleId);
298 }
299
300 public synchronized static void registerBuiltModule(FpdModuleIdentification fpdModuleId) {
301 builtModules.add(fpdModuleId);
302 }
303
304
305 public synchronized static void registerFpdModuleSA(FpdModuleIdentification fpdModuleId, Map<String, XmlObject> doc) {
306 Map<String, XmlObject> result = new HashMap<String, XmlObject>();
307 Set keySet = doc.keySet();
308 Iterator iter = keySet.iterator();
309 while (iter.hasNext()){
310 String key = (String)iter.next();
311 XmlObject item = cloneXmlObject(doc.get(key), true);
312 result.put(key, item);
313 }
314 fpdModuleSA.put(fpdModuleId, result);
315 }
316
317 public synchronized static boolean hasFpdModuleSA(FpdModuleIdentification fpdModuleId) {
318 return fpdModuleSA.containsKey(fpdModuleId);
319 }
320
321 /**
322 Query overrided module surface area information. If current is Package
323 or Platform build, also include the information from FPD file.
324
325 <p>Note that surface area parsing is incremental. That means the method will
326 only parse the MSA and MBD files if necessary. </p>
327
328 @param moduleName the base name of the module
329 @return the overrided module surface area information
330 @throws BuildException
331 MSA or MBD is not valid
332 **/
333 public synchronized static Map<String, XmlObject> getDoc(FpdModuleIdentification fpdModuleId) throws BuildException {
334 if (parsedModules.containsKey(fpdModuleId)) {
335 return parsedModules.get(fpdModuleId);
336 }
337 Map<String, XmlObject> doc = new HashMap<String, XmlObject>();
338 ModuleIdentification moduleId = fpdModuleId.getModule();
339 //
340 // First part: get the MSA files info
341 //
342 doc.putAll(getNativeMsa(moduleId));
343
344 //
345 // Second part: put build options
346 //
347 doc.put("BuildOptions", fpdBuildOptions);
348
349 //
350 // Third part: get Module info from FPD, such as Library instances, PCDs
351 //
352 if (fpdModuleSA.containsKey(fpdModuleId)){
353 //
354 // merge module info in FPD to final Doc
355 // For Library Module, do nothing here
356 //
357 doc.putAll(fpdModuleSA.get(fpdModuleId));
358 }
359 parsedModules.put(fpdModuleId, doc);
360 return doc;
361 }
362
363 public synchronized static Map<String, XmlObject> getDoc(ModuleIdentification moduleId, String arch) throws BuildException {
364 FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, arch);
365 return getDoc(fpdModuleId);
366 }
367 /**
368 Query the native MSA information with module base name.
369
370 <p>Note that MSA parsing is incremental. That means the method will
371 only to parse the MSA files when never parsed before. </p>
372
373 @param moduleName the base name of the module
374 @return the native MSA information
375 @throws BuildException
376 MSA file is not valid
377 **/
378 public synchronized static Map<String, XmlObject> getNativeMsa(ModuleIdentification moduleId) throws BuildException {
379 if (nativeMsa.containsKey(moduleId)) {
380 return nativeMsa.get(moduleId);
381 }
382 File msaFile = getMsaFile(moduleId);
383 Map<String, XmlObject> msaMap = getNativeMsa(msaFile);
384 nativeMsa.put(moduleId, msaMap);
385 return msaMap;
386 }
387
388 public synchronized static Map<String, XmlObject> getNativeMsa(File msaFile) throws BuildException {
389 if (! msaFile.exists()) {
390 throw new BuildException("Surface Area file [" + msaFile.getPath() + "] can't found.");
391 }
392 try {
393 ModuleSurfaceAreaDocument doc = (ModuleSurfaceAreaDocument)XmlObject.Factory.parse(msaFile);
394 //
395 // Validate File if they accord with XML Schema
396 //
397 if ( ! doc.validate()){
398 throw new BuildException("Module Surface Area file [" + msaFile.getPath() + "] is invalid.");
399 }
400 //
401 // parse MSA file
402 //
403 ModuleSurfaceArea msa= doc.getModuleSurfaceArea();
404 Map<String, XmlObject> msaMap = new HashMap<String, XmlObject>();
405 msaMap.put("MsaHeader", cloneXmlObject(msa.getMsaHeader(), true));
406 msaMap.put("ModuleDefinitions", cloneXmlObject(msa.getModuleDefinitions(), true));
407 msaMap.put("LibraryClassDefinitions", cloneXmlObject(msa.getLibraryClassDefinitions(), true));
408 msaMap.put("SourceFiles", cloneXmlObject(msa.getSourceFiles(), true));
409 msaMap.put("PackageDependencies", cloneXmlObject(msa.getPackageDependencies(), true));
410 msaMap.put("Protocols", cloneXmlObject(msa.getProtocols(), true));
411 msaMap.put("PPIs", cloneXmlObject(msa.getPPIs(), true));
412 msaMap.put("Guids", cloneXmlObject(msa.getGuids(), true));
413 msaMap.put("Externs", cloneXmlObject(msa.getExterns(), true));
414 msaMap.put("PcdCoded", cloneXmlObject(msa.getPcdCoded(), true));
415 return msaMap;
416 }
417 catch (Exception ex){
418 throw new BuildException(ex.getMessage());
419 }
420 }
421
422 public static Map<String, XmlObject> getFpdBuildOptions() {
423 Map<String, XmlObject> map = new HashMap<String, XmlObject>();
424 map.put("BuildOptions", fpdBuildOptions);
425 return map;
426 }
427
428 public static void setFpdBuildOptions(XmlObject fpdBuildOptions) {
429 GlobalData.fpdBuildOptions = cloneXmlObject(fpdBuildOptions, true);
430 }
431
432 public static XmlObject getFpdDynamicPcds() {
433 return fpdDynamicPcds;
434 }
435
436 public static void setFpdDynamicPcds(XmlObject fpdDynamicPcds) {
437 GlobalData.fpdDynamicPcds = fpdDynamicPcds;
438 }
439
440 //////////////////////////////////////////////
441 //////////////////////////////////////////////
442
443 public static Set<ModuleIdentification> getModules(PackageIdentification packageId){
444 Spd spd = spdTable.get(packageId);
445 if (spd == null ) {
446 Set<ModuleIdentification> dummy = new HashSet<ModuleIdentification>();
447 return dummy;
448 }
449 else {
450 return spd.getModules();
451 }
452 }
453
454 /**
455 * The header file path is relative to workspace dir
456 */
457 public static String[] getLibraryClassHeaderFiles(
458 PackageIdentification[] packages, String name)
459 throws BuildException {
460 if (packages == null) {
461 // throw Exception or not????
462 return new String[0];
463 }
464 String[] result = null;
465 for (int i = 0; i < packages.length; i++) {
466 Spd spd = spdTable.get(packages[i]);
467 //
468 // If find one package defined the library class
469 //
470 if ((result = spd.getLibClassIncluder(name)) != null) {
471 return result;
472 }
473 }
474 //
475 // If can't find library class declaration in every package
476 //
477 throw new BuildException("Can not find library class [" + name
478 + "] declaration in every packages. ");
479 }
480
481 /**
482 * The header file path is relative to workspace dir
483 */
484 public static String getPackageHeaderFiles(PackageIdentification packages,
485 String moduleType) throws BuildException {
486 if (packages == null) {
487 return new String("");
488 }
489 Spd spd = spdTable.get(packages);
490 //
491 // If can't find package header file, skip it
492 //
493 String temp = null;
494 if (spd != null) {
495 if ((temp = spd.getPackageIncluder(moduleType)) != null) {
496 return temp;
497 } else {
498 temp = "";
499 return temp;
500 }
501 } else {
502 return null;
503 }
504 }
505
506 /**
507 * return two values: {cName, GuidValue}
508 */
509 public static String[] getGuid(List<PackageIdentification> packages, String name)
510 throws BuildException {
511 if (packages == null) {
512 // throw Exception or not????
513 return new String[0];
514 }
515 String[] result = null;
516 Iterator item = packages.iterator();
517 while (item.hasNext()){
518 Spd spd = spdTable.get(item.next());
519 //
520 // If find one package defined the GUID
521 //
522 if ((result = spd.getGuid(name)) != null) {
523 return result;
524 }
525 }
526
527 return null;
528 }
529
530 /**
531 * return two values: {cName, GuidValue}
532 */
533 public static String[] getPpiGuid(List<PackageIdentification> packages,
534 String name) throws BuildException {
535 if (packages == null) {
536 return new String[0];
537 }
538 String[] result = null;
539 Iterator item = packages.iterator();
540 while (item.hasNext()){
541 Spd spd = spdTable.get(item.next());
542 //
543 // If find one package defined the Ppi GUID
544 //
545 if ((result = spd.getPpi(name)) != null) {
546 return result;
547 }
548 }
549 return null;
550
551 }
552
553 /**
554 * return two values: {cName, GuidValue}
555 */
556 public static String[] getProtocolGuid(List<PackageIdentification> packages,
557 String name) throws BuildException {
558 if (packages == null) {
559 return new String[0];
560 }
561 String[] result = null;
562 Iterator item = packages.iterator();
563 while (item.hasNext()){
564 Spd spd = spdTable.get(item.next());
565 //
566 // If find one package defined the protocol GUID
567 //
568 if ((result = spd.getProtocol(name))!= null){
569 return result;
570 }
571 }
572 return null;
573
574 }
575
576 public synchronized static PlatformIdentification getPlatformByName(String name) throws BuildException {
577 Iterator iter = platformList.iterator();
578 while(iter.hasNext()){
579 PlatformIdentification platformId = (PlatformIdentification)iter.next();
580 if (platformId.getName().equalsIgnoreCase(name)) {
581 return platformId;
582 }
583 }
584 throw new BuildException("Can't find platform [" + name + "] in current workspace database. ");
585 }
586
587 public synchronized static PlatformIdentification getPlatform(String filename) throws BuildException {
588 File file = new File(workspaceDir + File.separatorChar + filename);
589 Iterator iter = platformList.iterator();
590 while(iter.hasNext()){
591 PlatformIdentification platformId = (PlatformIdentification)iter.next();
592 if (platformId.getFpdFile().getPath().equalsIgnoreCase(file.getPath())) {
593 return platformId;
594 }
595 }
596 throw new BuildException("Can't find platform file [" + filename + "] in current workspace database. ");
597 }
598
599 public synchronized static PackageIdentification refreshPackageIdentification(PackageIdentification packageId) throws BuildException {
600 Iterator iter = packageList.iterator();
601 while(iter.hasNext()){
602 PackageIdentification packageItem = (PackageIdentification)iter.next();
603 if (packageItem.equals(packageId)) {
604 packageId.setName(packageItem.getName());
605 packageId.setSpdFile(packageItem.getSpdFile());
606 return packageId;
607 }
608 }
609 throw new BuildException("Can't find package GUID value " + packageId.getGuid() + " under current workspace. ");
610 }
611
612 public synchronized static ModuleIdentification refreshModuleIdentification(ModuleIdentification moduleId) throws BuildException {
613 // System.out.println("1");
614 // System.out.println("##" + moduleId.getGuid());
615 PackageIdentification packageId = getPackageForModule(moduleId);
616 // System.out.println("" + packageId.getGuid());
617 moduleId.setPackage(packageId);
618 Spd spd = spdTable.get(packageId);
619 if (spd == null) {
620 throw new BuildException("Can't find package GUID value " + packageId.getGuid() + " under current workspace. ");
621 }
622 Set<ModuleIdentification> modules = spd.getModules();
623 Iterator<ModuleIdentification> iter = modules.iterator();
624 while (iter.hasNext()) {
625 ModuleIdentification item = iter.next();
626 if (item.equals(moduleId)) {
627 moduleId.setName(item.getName());
628 moduleId.setModuleType(item.getModuleType());
629 moduleId.setMsaFile(item.getMsaFile());
630 return moduleId;
631 }
632 }
633 throw new BuildException("Can't find module GUID value " + moduleId.getGuid() + " in " + packageId + " under current workspace. ");
634 }
635
636 public synchronized static Set<PackageIdentification> getPackageList(){
637 return packageList;
638 }
639 ///// remove!!
640 private static XmlObject cloneXmlObject(XmlObject object, boolean deep) throws BuildException {
641 if ( object == null) {
642 return null;
643 }
644 XmlObject result = null;
645 try {
646 result = XmlObject.Factory.parse(object.getDomNode()
647 .cloneNode(deep));
648 } catch (Exception ex) {
649 throw new BuildException(ex.getMessage());
650 }
651 return result;
652 }
653
654 ////// Tool Chain Related, try to refine and put some logic process to ToolChainFactory
655
656 public static ToolChainInfo getToolChainInfo() {
657 // GlobalData.log.info(toolsDef.getConfigInfo() + "" + toolChainEnvInfo + toolChainPlatformInfo);
658 if (toolChainInfo == null) {
659 toolChainInfo = toolsDef.getConfigInfo().intersection(toolChainEnvInfo);
660 if (toolChainPlatformInfo != null) {
661 toolChainInfo = toolChainInfo.intersection(toolChainPlatformInfo);
662 }
663 toolChainInfo.addCommands(toolsDef.getConfigInfo().getCommands());
664 toolChainInfo.normalize();
665 GlobalData.log.info(toolChainInfo + "");
666 }
667 return toolChainInfo;
668 }
669
670
671
672 public static void setPlatformToolChainFamilyOption(ToolChainMap map) {
673 platformToolChainFamilyOption = map;
674 }
675
676 public static void setPlatformToolChainOption(ToolChainMap map) {
677 platformToolChainOption = map;
678 }
679
680 public static void addModuleToolChainOption(FpdModuleIdentification fpdModuleId,
681 ToolChainMap toolChainOption) {
682 moduleToolChainOption.put(fpdModuleId, toolChainOption);
683 }
684
685 public static void addModuleToolChainFamilyOption(FpdModuleIdentification fpdModuleId,
686 ToolChainMap toolChainOption) {
687 moduleToolChainFamilyOption.put(fpdModuleId, toolChainOption);
688 }
689
690 public static boolean isCommandSet(String target, String toolchain, String arch) {
691 String[] commands = getToolChainInfo().getCommands();
692
693 for (int i = 0; i < commands.length; ++i) {
694 String cmdName = toolsDef.getConfig().get(new String[] {target, toolchain, arch, commands[i], ToolChainAttribute.NAME.toString()});
695 if (cmdName != null && cmdName.length() != 0) {
696 return true;
697 }
698 }
699
700 return false;
701 }
702
703 public static String getCommandSetting(String[] commandDescription, FpdModuleIdentification fpdModuleId) throws EdkException {
704 ToolChainKey toolChainKey = new ToolChainKey(commandDescription);
705 ToolChainMap toolChainConfig = toolsDef.getConfig();
706 String setting = null;
707
708 if (!commandDescription[ToolChainElement.ATTRIBUTE.value].equals(ToolChainAttribute.FLAGS.toString())) {
709 setting = toolChainConfig.get(toolChainKey);
710 if (setting == null) {
711 setting = "";
712 }
713 return setting;
714 }
715
716 //
717 // get module specific options, if any
718 //
719 // tool tag first
720 ToolChainMap option = moduleToolChainOption.get(fpdModuleId);
721 ToolChainKey toolChainFamilyKey = null;
722
723 if ((option == null) || (option != null && (setting = option.get(toolChainKey)) == null)) {
724 //
725 // then tool chain family
726 //
727 toolChainFamilyKey = new ToolChainKey(commandDescription);
728 toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);
729 String family = toolChainConfig.get(toolChainFamilyKey);
730 toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);
731 toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);
732
733 option = moduleToolChainFamilyOption.get(fpdModuleId);
734 if (option != null) {
735 setting = option.get(toolChainFamilyKey);
736 }
737 }
738
739 //
740 // get platform options, if any
741 //
742 if (setting == null) {
743 // tool tag first
744 if (platformToolChainOption == null || (setting = platformToolChainOption.get(toolChainKey)) == null) {
745 // then tool chain family
746 if (toolChainFamilyKey == null) {
747 toolChainFamilyKey = new ToolChainKey(commandDescription);
748 toolChainFamilyKey.setKey(ToolChainAttribute.FAMILY.toString(), ToolChainElement.ATTRIBUTE.value);
749 String family = toolChainConfig.get(toolChainFamilyKey);
750 toolChainFamilyKey.setKey(family, ToolChainElement.TOOLCHAIN.value);
751 toolChainFamilyKey.setKey(ToolChainAttribute.FLAGS.toString(), ToolChainElement.ATTRIBUTE.value);
752 }
753
754 setting = platformToolChainFamilyOption.get(toolChainFamilyKey);
755 }
756 }
757
758 if (setting == null) {
759 setting = "";
760 }
761
762 return setting;
763 }
764
765 public static void setToolChainEnvInfo(ToolChainInfo envInfo) {
766 toolChainEnvInfo = envInfo;
767 }
768 public static void setToolChainPlatformInfo(ToolChainInfo platformInfo) {
769 toolChainPlatformInfo = platformInfo;
770 }
771
772 //
773 // for PCD
774 //
775 public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {
776 return pcdDbManager;
777 }
778
779 //
780 // For PCD get tokenSpaceGUid
781 //
782 public synchronized static String getGuidInfoFromCname(String cName){
783 String cNameGuid = null;
784 String guid = null;
785 Set set = spdTable.keySet();
786 Iterator iter = set.iterator();
787
788 if (iter == null) {
789 return null;
790 }
791
792 while (iter.hasNext()){
793 Spd spd = (Spd) spdTable.get(iter.next());
794 guid = spd.getGuidFromCname(cName);
795 if (guid != null){
796 cNameGuid = guid;
797 break;
798 }
799 }
800 return cNameGuid;
801 }
802
803 //
804 // For PCD
805 //
806 public synchronized static Map<FpdModuleIdentification, XmlObject>
807 getFpdModuleSaXmlObject(String xmlObjectName) {
808 Set<FpdModuleIdentification> fpdModuleSASet = fpdModuleSA.keySet();
809 Iterator item = fpdModuleSASet.iterator();
810
811
812 Map<FpdModuleIdentification, XmlObject> SAPcdBuildDef = new HashMap<FpdModuleIdentification, XmlObject>();
813 Map<String, XmlObject> SANode = new HashMap<String, XmlObject>();
814 FpdModuleIdentification moduleId;
815 while (item.hasNext()) {
816
817 moduleId = (FpdModuleIdentification) item.next();
818 SANode = fpdModuleSA.get(moduleId);
819 try{
820 if (SANode.get(xmlObjectName)!= null){
821 SAPcdBuildDef.put(moduleId,
822 (XmlObject) SANode.get(xmlObjectName));
823
824 }
825 } catch (Exception e){
826 EdkLog.log(EdkLog.EDK_INFO, e.getMessage());
827 }
828 }
829 return SAPcdBuildDef;
830 }
831
832 public synchronized static Map<FpdModuleIdentification,XmlObject> getFpdPcdBuildDefinitions() {
833 Map<FpdModuleIdentification,XmlObject> pcdBuildDef = getFpdModuleSaXmlObject ("PcdBuildDefinition");
834
835 return pcdBuildDef;
836 }
837 }
838