Add one more judgement for modulelist specified but empty.
[mirror_edk2.git] / Tools / Source / GenBuild / org / tianocore / build / fpd / FpdParserTask.java
1 /** @file
2 This file is ANT task FpdParserTask.
3
4 FpdParserTask is used to parse FPD (Framework Platform Description) and generate
5 build.out.xml. It is for Package or Platform build use.
6
7 Copyright (c) 2006, Intel Corporation
8 All rights reserved. This program and the accompanying materials
9 are licensed and made available under the terms and conditions of the BSD License
10 which accompanies this distribution. The full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php
12
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 **/
16 package org.tianocore.build.fpd;
17
18 import java.io.BufferedWriter;
19 import java.io.File;
20 import java.io.FileWriter;
21 import java.io.IOException;
22 import java.util.HashMap;
23 import java.util.Iterator;
24 import java.util.LinkedHashMap;
25 import java.util.LinkedHashSet;
26 import java.util.Map;
27 import java.util.Set;
28 import java.util.Vector;
29
30 import org.apache.tools.ant.BuildException;
31 import org.apache.tools.ant.Task;
32 import org.apache.tools.ant.taskdefs.Ant;
33 import org.apache.tools.ant.taskdefs.Property;
34 import org.apache.xmlbeans.XmlException;
35 import org.apache.xmlbeans.XmlObject;
36
37 import org.tianocore.common.definitions.EdkDefinitions;
38 import org.tianocore.common.exception.EdkException;
39 import org.tianocore.common.logger.EdkLog;
40 import org.tianocore.pcd.action.ActionMessage;
41 import org.tianocore.build.FrameworkBuildTask;
42 import org.tianocore.build.global.GlobalData;
43 import org.tianocore.build.global.OutputManager;
44 import org.tianocore.build.global.SurfaceAreaQuery;
45 import org.tianocore.build.id.FpdModuleIdentification;
46 import org.tianocore.build.id.ModuleIdentification;
47 import org.tianocore.build.id.PackageIdentification;
48 import org.tianocore.build.id.PlatformIdentification;
49 import org.tianocore.build.pcd.action.PlatformPcdPreprocessActionForBuilding;
50 import org.tianocore.build.toolchain.ToolChainAttribute;
51 import org.tianocore.build.toolchain.ToolChainElement;
52 import org.tianocore.build.toolchain.ToolChainMap;
53 import org.w3c.dom.NamedNodeMap;
54 import org.w3c.dom.Node;
55 import org.w3c.dom.NodeList;
56
57 /**
58 <code>FpdParserTask</code> is an ANT task. The main function is parsing Framework
59 Platform Descritpion (FPD) XML file and generating its ANT build script for
60 corresponding platform.
61
62 <p>The task sets global properties PLATFORM, PLATFORM_DIR, PLATFORM_RELATIVE_DIR
63 and BUILD_DIR. </p>
64
65 <p>The task generates ${PLATFORM}_build.xml file which will be called by top level
66 build.xml. The task also generate Fv.inf files (File is for Tool GenFvImage). </p>
67
68 <p>FpdParserTask task stores all FPD information to GlobalData. And parse
69 tools definition file to set up compiler options for different Target and
70 different ToolChainTag. </p>
71
72 <p>The method parseFpdFile is also prepared for single module build. </p>
73
74 @since GenBuild 1.0
75 **/
76 public class FpdParserTask extends Task {
77
78 private File fpdFile = null;
79
80 PlatformIdentification platformId;
81
82 private String type;
83
84 ///
85 /// Mapping from modules identification to out put file name
86 ///
87 Map<FpdModuleIdentification, String> outfiles = new LinkedHashMap<FpdModuleIdentification, String>();
88
89 ///
90 /// Mapping from FV name to its modules
91 ///
92 Map<String, Set<FpdModuleIdentification>> fvs = new HashMap<String, Set<FpdModuleIdentification>>();
93
94 ///
95 /// FpdParserTask can specify some ANT properties.
96 ///
97 private Vector<Property> properties = new Vector<Property>();
98
99 SurfaceAreaQuery saq = null;
100
101 boolean isUnified = true;
102
103 /**
104 Public construct method. It is necessary for ANT task.
105 **/
106 public FpdParserTask() {
107 }
108
109 /**
110 ANT task's entry method. The main steps is described as following:
111
112 <ul>
113 <li>Initialize global information (Framework DB, SPD files and all MSA files
114 listed in SPD). This step will execute only once in whole build process;</li>
115 <li>Parse specified FPD file; </li>
116 <li>Generate FV.inf files; </li>
117 <li>Generate PlatformName_build.xml file for Flatform build; </li>
118 <li>Collect PCD information. </li>
119 </ul>
120
121 @throws BuildException
122 Surface area is not valid.
123 **/
124 public void execute() throws BuildException {
125 this.setTaskName("FpdParser");
126
127 //
128 // Parse FPD file
129 //
130 parseFpdFile();
131
132 //
133 // Prepare BUILD_DIR
134 //
135 isUnified = OutputManager.getInstance().prepareBuildDir(getProject());
136
137 String buildDir = getProject().getProperty("BUILD_DIR");
138 //
139 // For every Target and ToolChain
140 //
141 String[] targetList = GlobalData.getToolChainInfo().getTargets();
142 for (int i = 0; i < targetList.length; i++) {
143 String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
144 for(int j = 0; j < toolchainList.length; j++) {
145 //
146 // Prepare FV_DIR
147 //
148 String ffsCommonDir = buildDir + File.separatorChar
149 + targetList[i] + "_"
150 + toolchainList[j];
151 File fvDir = new File(ffsCommonDir + File.separatorChar + "FV");
152 fvDir.mkdirs();
153 getProject().setProperty("FV_DIR", fvDir.getPath().replaceAll("(\\\\)", "/"));
154
155 //
156 // Gen Fv.inf files
157 //
158 genFvInfFiles(ffsCommonDir);
159 }
160 }
161
162 //
163 // Gen build.xml
164 //
165 String platformBuildFile = buildDir + File.separatorChar + platformId.getName() + "_build.xml";
166 PlatformBuildFileGenerator fileGenerator = new PlatformBuildFileGenerator(getProject(), outfiles, fvs, isUnified, saq, platformBuildFile);
167 fileGenerator.genBuildFile();
168
169 //
170 // Ant call ${PLATFORM}_build.xml
171 //
172 Ant ant = new Ant();
173 ant.setProject(getProject());
174 ant.setAntfile(platformBuildFile);
175 ant.setTarget(type);
176 ant.setInheritAll(true);
177 ant.init();
178 ant.execute();
179 }
180
181 /**
182 Generate Fv.inf files. The Fv.inf file is composed with four
183 parts: Options, Attributes, Components and Files. The Fv.inf files
184 will be under FV_DIR.
185
186 @throws BuildException
187 File write FV.inf files error.
188 **/
189 void genFvInfFiles(String ffsCommonDir) throws BuildException {
190 String[] validFv = saq.getFpdValidImageNames();
191 for (int i = 0; i < validFv.length; i++) {
192 //
193 // Get all global variables from FPD and set them to properties
194 //
195 String[][] globalVariables = saq.getFpdGlobalVariable();
196 for (int j = 0; j < globalVariables.length; j++) {
197 getProject().setProperty(globalVariables[j][0], globalVariables[j][1]);
198 }
199
200 getProject().setProperty("FV_FILENAME", validFv[i]);
201
202 File fvFile = new File(getProject().replaceProperties( getProject().getProperty("FV_DIR") + File.separatorChar + validFv[i] + ".inf"));
203 if (fvFile.exists() && (fvFile.lastModified() >= fpdFile.lastModified())) {
204 //
205 // don't re-generate FV.inf if fpd has not been changed
206 //
207 continue;
208 }
209 fvFile.getParentFile().mkdirs();
210
211 try {
212 FileWriter fw = new FileWriter(fvFile);
213 BufferedWriter bw = new BufferedWriter(fw);
214
215 //
216 // Options
217 //
218 String[][] options = saq.getFpdOptions(validFv[i]);
219 if (options.length > 0) {
220 bw.write("[options]");
221 bw.newLine();
222 for (int j = 0; j < options.length; j++) {
223 StringBuffer str = new StringBuffer(100);
224 str.append(options[j][0]);
225 while (str.length() < 40) {
226 str.append(' ');
227 }
228 str.append("= ");
229 str.append(options[j][1]);
230 bw.write(getProject().replaceProperties(str.toString()));
231 bw.newLine();
232 }
233 bw.newLine();
234 }
235
236 //
237 // Attributes;
238 //
239 String[][] attributes = saq.getFpdAttributes(validFv[i]);
240 if (attributes.length > 0) {
241 bw.write("[attributes]");
242 bw.newLine();
243 for (int j = 0; j < attributes.length; j++) {
244 StringBuffer str = new StringBuffer(100);
245 str.append(attributes[j][0]);
246 while (str.length() < 40) {
247 str.append(' ');
248 }
249 str.append("= ");
250 str.append(attributes[j][1]);
251 bw.write(getProject().replaceProperties(str.toString()));
252 bw.newLine();
253 }
254 bw.newLine();
255 }
256
257 //
258 // Components
259 //
260 String[][] components = saq.getFpdComponents(validFv[i]);
261 if (components.length > 0) {
262 bw.write("[components]");
263 bw.newLine();
264 for (int j = 0; j < components.length; j++) {
265 StringBuffer str = new StringBuffer(100);
266 str.append(components[j][0]);
267 while (str.length() < 40) {
268 str.append(' ');
269 }
270 str.append("= ");
271 str.append(components[j][1]);
272 bw.write(getProject().replaceProperties(str.toString()));
273 bw.newLine();
274 }
275 bw.newLine();
276 }
277
278 //
279 // Files
280 //
281 Set<FpdModuleIdentification> moduleSeqSet = getModuleSequenceForFv(validFv[i]);
282
283 Set<FpdModuleIdentification> filesSet = fvs.get(validFv[i]);
284
285 FpdModuleIdentification[] files = null;
286
287 if (moduleSeqSet == null) {
288 if (filesSet != null) {
289 files = filesSet.toArray(new FpdModuleIdentification[filesSet.size()]);
290 }
291 } else if (filesSet == null) {
292 if (moduleSeqSet.size() != 0) {
293 throw new BuildException("Can not find any modules belongs to FV[" + validFv[i] + "], but listed some in BuildOptions.UserExtensions[@UserID='IMAGES' @Identifier='1']");
294 }
295 } else {
296 //
297 // if moduleSeqSet and filesSet is inconsistent, report error
298 //
299 if(moduleSeqSet.size() != filesSet.size()){
300 throw new BuildException("Modules for FV[" + validFv[i] + "] defined in FrameworkModules and in BuildOptions.UserExtensions[@UserID='IMAGES' @Identifier='1'] are inconsistent. ");
301 } else {
302 //
303 // whether all modules in moduleSeqSet listed in filesSet
304 //
305 Iterator<FpdModuleIdentification> iter = moduleSeqSet.iterator();
306 while (iter.hasNext()) {
307 FpdModuleIdentification item = iter.next();
308 if (!filesSet.contains(item)) {
309 throw new BuildException("Can not find " + item + " belongs to FV[" + validFv[i] + "]");
310 }
311 }
312 }
313
314 files = moduleSeqSet.toArray(new FpdModuleIdentification[moduleSeqSet.size()]);
315 }
316
317
318 if (files != null) {
319 bw.write("[files]");
320 bw.newLine();
321 for (int j = 0; j < files.length; j++) {
322 String str = ffsCommonDir + File.separatorChar + outfiles.get(files[j]);
323 bw.write(getProject().replaceProperties("EFI_FILE_NAME = " + str));
324 bw.newLine();
325 }
326 }
327 bw.flush();
328 bw.close();
329 fw.close();
330 } catch (IOException ex) {
331 BuildException buildException = new BuildException("Generation of the FV file [" + fvFile.getPath() + "] failed!\n" + ex.getMessage());
332 buildException.setStackTrace(ex.getStackTrace());
333 throw buildException;
334 } catch (EdkException ex) {
335 BuildException buildException = new BuildException("Generation of the FV file [" + fvFile.getPath() + "] failed!\n" + ex.getMessage());
336 buildException.setStackTrace(ex.getStackTrace());
337 throw buildException;
338 }
339 }
340 }
341 /**
342 This method is used for Single Module Build.
343
344
345 @throws BuildException
346 FPD file is not valid.
347 **/
348 public void parseFpdFile(File fpdFile) throws BuildException, EdkException {
349 this.fpdFile = fpdFile;
350 parseFpdFile();
351
352 //
353 // Call Platform_build.xml prebuild firstly in stand-alone build
354 // Prepare BUILD_DIR
355 //
356 isUnified = OutputManager.getInstance().prepareBuildDir(getProject());
357
358 String buildDir = getProject().getProperty("BUILD_DIR");
359 //
360 // For every Target and ToolChain
361 //
362 String[] targetList = GlobalData.getToolChainInfo().getTargets();
363 for (int i = 0; i < targetList.length; i++) {
364 String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
365 for(int j = 0; j < toolchainList.length; j++) {
366 //
367 // Prepare FV_DIR
368 //
369 String ffsCommonDir = buildDir + File.separatorChar
370 + targetList[i] + "_"
371 + toolchainList[j];
372 File fvDir = new File(ffsCommonDir + File.separatorChar + "FV");
373 fvDir.mkdirs();
374 }
375 }
376
377 String platformBuildFile = buildDir + File.separatorChar + platformId.getName() + "_build.xml";
378 PlatformBuildFileGenerator fileGenerator = new PlatformBuildFileGenerator(getProject(), outfiles, fvs, isUnified, saq, platformBuildFile);
379 fileGenerator.genBuildFile();
380
381 Ant ant = new Ant();
382 ant.setProject(getProject());
383 ant.setAntfile(platformBuildFile);
384 ant.setTarget("prebuild");
385 ant.setInheritAll(true);
386 ant.init();
387 ant.execute();
388 }
389
390 /**
391 Parse FPD file.
392
393 @throws BuildException
394 FPD file is not valid.
395 **/
396 void parseFpdFile() throws BuildException {
397 try {
398 XmlObject doc = XmlObject.Factory.parse(fpdFile);
399
400 if (!doc.validate()) {
401 throw new BuildException("Platform Surface Area file [" + fpdFile.getPath() + "] format is invalid!");
402 }
403
404 Map<String, XmlObject> map = new HashMap<String, XmlObject>();
405 map.put("PlatformSurfaceArea", doc);
406 saq = new SurfaceAreaQuery(map);
407
408 //
409 // Initialize
410 //
411 platformId = saq.getFpdHeader();
412 platformId.setFpdFile(fpdFile);
413 getProject().setProperty("PLATFORM", platformId.getName());
414 getProject().setProperty("PLATFORM_FILE", platformId.getRelativeFpdFile().replaceAll("(\\\\)", "/"));
415 getProject().setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
416 getProject().setProperty("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
417
418 if( !FrameworkBuildTask.multithread) {
419 FrameworkBuildTask.originalProperties.put("PLATFORM", platformId.getName());
420 FrameworkBuildTask.originalProperties.put("PLATFORM_FILE", platformId.getRelativeFpdFile().replaceAll("(\\\\)", "/"));
421 FrameworkBuildTask.originalProperties.put("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
422 FrameworkBuildTask.originalProperties.put("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
423 }
424
425 //
426 // Build mode. User-defined output dir.
427 //
428 String buildMode = saq.getFpdIntermediateDirectories();
429 String userDefinedOutputDir = saq.getFpdOutputDirectory();
430
431 OutputManager.getInstance().setup(userDefinedOutputDir, buildMode);
432
433 //
434 // TBD. Deal PCD and BuildOption related Info
435 //
436 GlobalData.setFpdBuildOptions(saq.getFpdBuildOptions());
437
438 GlobalData.setToolChainPlatformInfo(saq.getFpdToolChainInfo());
439
440 //
441 // Parse all list modules SA
442 //
443 parseModuleSAFiles();
444
445 //
446 // TBD. Deal PCD and BuildOption related Info
447 //
448 parseToolChainFamilyOptions();
449 parseToolChainOptions();
450
451 saq.push(map);
452
453 //
454 // Pcd Collection. Call CollectPCDAction to collect pcd info.
455 //
456 PlatformPcdPreprocessActionForBuilding ca = new PlatformPcdPreprocessActionForBuilding();
457 ca.perform(platformId.getFpdFile().getPath(), ActionMessage.NULL_MESSAGE_LEVEL);
458 } catch (IOException ex) {
459 BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
460 buildException.setStackTrace(ex.getStackTrace());
461 throw buildException;
462 } catch (XmlException ex) {
463 BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
464 buildException.setStackTrace(ex.getStackTrace());
465 throw buildException;
466 } catch (EdkException ex) {
467 BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
468 buildException.setStackTrace(ex.getStackTrace());
469 throw buildException;
470 }
471 }
472
473 /**
474 Parse all modules listed in FPD file.
475 **/
476 void parseModuleSAFiles() throws EdkException{
477 Map<FpdModuleIdentification, Map<String, XmlObject>> moduleSAs = saq.getFpdModules();
478
479 //
480 // For every Module lists in FPD file.
481 //
482 Set<FpdModuleIdentification> keys = moduleSAs.keySet();
483 Iterator iter = keys.iterator();
484 while (iter.hasNext()) {
485 FpdModuleIdentification fpdModuleId = (FpdModuleIdentification) iter.next();
486
487 //
488 // Judge if Module is existed?
489 // TBD
490 GlobalData.registerFpdModuleSA(fpdModuleId, moduleSAs.get(fpdModuleId));
491
492 //
493 // Put fpdModuleId to the corresponding FV
494 //
495 saq.push(GlobalData.getDoc(fpdModuleId));
496 String fvBinding = saq.getModuleFvBindingKeyword();
497
498 fpdModuleId.setFvBinding(fvBinding);
499 updateFvs(fvBinding, fpdModuleId);
500
501 //
502 // Prepare for out put file name
503 //
504 ModuleIdentification moduleId = fpdModuleId.getModule();
505
506 String baseName = saq.getModuleOutputFileBasename();
507
508 if (baseName == null) {
509 baseName = moduleId.getName();
510 }
511 outfiles.put(fpdModuleId, fpdModuleId.getArch() + File.separatorChar
512 + moduleId.getGuid() + "-" + baseName
513 + getSuffix(moduleId.getModuleType()));
514
515 //
516 // parse module build options, if any
517 //
518 GlobalData.addModuleToolChainOption(fpdModuleId, parseModuleBuildOptions(false));
519 GlobalData.addModuleToolChainFamilyOption(fpdModuleId, parseModuleBuildOptions(true));
520 saq.pop();
521 }
522 }
523
524 ToolChainMap parseModuleBuildOptions(boolean toolChainFamilyFlag) throws EdkException {
525 String[][] options = saq.getModuleBuildOptions(toolChainFamilyFlag);
526 if (options == null || options.length == 0) {
527 return new ToolChainMap();
528 }
529 return parseOptions(options);
530 }
531
532 private ToolChainMap parsePlatformBuildOptions(boolean toolChainFamilyFlag) throws EdkException {
533 String[][] options = saq.getPlatformBuildOptions(toolChainFamilyFlag);
534 if (options == null || options.length == 0) {
535 return new ToolChainMap();
536 }
537 return parseOptions(options);
538 }
539
540 private ToolChainMap parseOptions(String[][] options) throws EdkException {
541 ToolChainMap map = new ToolChainMap();
542 int flagIndex = ToolChainElement.ATTRIBUTE.value;
543
544 for (int i = 0; i < options.length; ++i) {
545 String flagString = options[i][flagIndex];
546 if (flagString == null) {
547 flagString = "";
548 }
549 options[i][flagIndex] = ToolChainAttribute.FLAGS + "";
550 map.put(options[i], flagString.trim());
551 }
552
553 return map;
554 }
555
556 private void parseToolChainFamilyOptions() throws EdkException {
557 GlobalData.setPlatformToolChainFamilyOption(parsePlatformBuildOptions(true));
558 }
559
560 private void parseToolChainOptions() throws EdkException {
561 GlobalData.setPlatformToolChainOption(parsePlatformBuildOptions(false));
562 }
563
564 /**
565 Add the current module to corresponding FV.
566
567 @param fvName current FV name
568 @param moduleName current module identification
569 **/
570 void updateFvs(String fvName, FpdModuleIdentification fpdModuleId) {
571 if (fvName == null || fvName.trim().length() == 0) {
572 fvName = "NULL";
573 }
574 String[] fvNameArray = fvName.split("[, \t]+");
575 for (int i = 0; i < fvNameArray.length; i++) {
576 //
577 // Put module to corresponding fvName
578 //
579 if (fvs.containsKey(fvNameArray[i])) {
580 Set<FpdModuleIdentification> set = fvs.get(fvNameArray[i]);
581 set.add(fpdModuleId);
582 } else {
583 Set<FpdModuleIdentification> set = new LinkedHashSet<FpdModuleIdentification>();
584 set.add(fpdModuleId);
585 fvs.put(fvNameArray[i], set);
586 }
587 }
588 }
589
590 /**
591 Get the suffix based on module type. Current relationship are listed:
592
593 <pre>
594 <b>ModuleType</b> <b>Suffix</b>
595 BASE .FFS
596 SEC .SEC
597 PEI_CORE .PEI
598 PEIM .PEI
599 DXE_CORE .DXE
600 DXE_DRIVER .DXE
601 DXE_RUNTIME_DRIVER .DXE
602 DXE_SAL_DRIVER .DXE
603 DXE_SMM_DRIVER .DXE
604 TOOL .FFS
605 UEFI_DRIVER .DXE
606 UEFI_APPLICATION .APP
607 USER_DEFINED .FFS
608 </pre>
609
610 @param moduleType module type
611 @return
612 @throws BuildException
613 If module type is null
614 **/
615 public static String getSuffix(String moduleType) throws BuildException {
616 if (moduleType == null) {
617 throw new BuildException("Module type is not specified.");
618 }
619
620 String[][] suffix = EdkDefinitions.ModuleTypeExtensions;
621
622 for (int i = 0; i < suffix.length; i++) {
623 if (suffix[i][0].equalsIgnoreCase(moduleType)) {
624 return suffix[i][1];
625 }
626 }
627 //
628 // Default is '.FFS'
629 //
630 return ".FFS";
631 }
632 /**
633 Add a property.
634
635 @param p property
636 **/
637 public void addProperty(Property p) {
638 properties.addElement(p);
639 }
640
641 public void setFpdFile(File fpdFile) {
642 this.fpdFile = fpdFile;
643 }
644
645 public void setType(String type) {
646 this.type = type;
647 }
648
649 public String getAllArchForModule(ModuleIdentification moduleId) {
650 String archs = "";
651 Iterator<FpdModuleIdentification> iter = outfiles.keySet().iterator();
652 while (iter.hasNext()) {
653 FpdModuleIdentification fpdModuleId = iter.next();
654
655 if (fpdModuleId.getModule().equals(moduleId)) {
656 archs += fpdModuleId.getArch() + " ";
657 }
658 }
659
660 return archs;
661 }
662
663 private Set<FpdModuleIdentification> getModuleSequenceForFv(String fvName) throws EdkException {
664 Node node = saq.getFpdModuleSequence(fvName);
665 Set<FpdModuleIdentification> result = new LinkedHashSet<FpdModuleIdentification>();
666
667 if ( node == null) {
668 EdkLog.log(this, EdkLog.EDK_WARNING, "FV[" + fvName + "] does not specify module sequence in FPD. Assuming present sequence as default sequence in FV. ");
669 return null;
670 } else {
671 NodeList childNodes = node.getChildNodes();
672 for (int i = 0; i < childNodes.getLength(); i++) {
673 Node childItem = childNodes.item(i);
674 if (childItem.getNodeType() == Node.ELEMENT_NODE) {
675 //
676 // Find child elements "IncludeModules"
677 //
678 if (childItem.getNodeName().compareTo("IncludeModules") == 0) {
679 //
680 // result will be updated
681 //
682 processNodes(childItem, result);
683 } else if (childItem.getNodeName().compareTo("FvName") == 0) {
684
685 } else if (childItem.getNodeName().compareTo("InfFileName") == 0) {
686
687 } else {
688 //
689 // Report Warning
690 //
691 EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised element " + childItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1']");
692 }
693 }
694 }
695 }
696
697 return result;
698 }
699
700 private void processNodes(Node node, Set<FpdModuleIdentification> result) throws EdkException {
701 //
702 // Found out all elements "Module"
703 //
704 NodeList childNodes = node.getChildNodes();
705 for (int j = 0; j < childNodes.getLength(); j++) {
706 Node childItem = childNodes.item(j);
707 if (childItem.getNodeType() == Node.ELEMENT_NODE) {
708 if (childItem.getNodeName().compareTo("Module") == 0) {
709 String moduleGuid = null;
710 String moduleVersion = null;
711 String packageGuid = null;
712 String packageVersion = null;
713 String arch = null;
714
715 NamedNodeMap attr = childItem.getAttributes();
716 for (int i = 0; i < attr.getLength(); i++) {
717 Node attrItem = attr.item(i);
718 if (attrItem.getNodeName().compareTo("ModuleGuid") == 0) {
719 moduleGuid = attrItem.getNodeValue();
720 } else if (attrItem.getNodeName().compareTo("ModuleVersion") == 0) {
721 moduleVersion = attrItem.getNodeValue();
722 } else if (attrItem.getNodeName().compareTo("PackageGuid") == 0) {
723 packageGuid = attrItem.getNodeValue();
724 } else if (attrItem.getNodeName().compareTo("PackageVersion") == 0) {
725 packageVersion = attrItem.getNodeValue();
726 } else if (attrItem.getNodeName().compareTo("Arch") == 0) {
727 arch = attrItem.getNodeValue();
728 } else {
729 //
730 // Report warning
731 //
732 EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised attribute " + attrItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules.Module");
733 }
734 }
735
736 PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
737 GlobalData.refreshPackageIdentification(packageId);
738
739 ModuleIdentification moduleId = new ModuleIdentification(moduleGuid, moduleVersion);
740 moduleId.setPackage(packageId);
741 GlobalData.refreshModuleIdentification(moduleId);
742
743 if (arch == null) {
744 throw new EdkException("Attribute [Arch] is required for element FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules.Module. ");
745 }
746
747 result.add(new FpdModuleIdentification(moduleId, arch));
748 } else {
749 //
750 // Report Warning
751 //
752 EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised element " + childItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules");
753 }
754 }
755 }
756 }
757 }