- Fixed EDKT240. Now the Blank.pad file for alignment purpose will no longer be needed.
[mirror_edk2.git] / Tools / Java / Source / GenBuild / org / tianocore / build / global / SurfaceAreaQuery.java
1 /** @file
2 This file is for surface area information retrieval.
3
4 Copyright (c) 2006, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14 package org.tianocore.build.global;
15
16 import java.util.ArrayList;
17 import java.util.HashMap;
18 import java.util.Iterator;
19 import java.util.LinkedHashMap;
20 import java.util.List;
21 import java.util.Map;
22 import java.util.Stack;
23 import java.util.regex.Matcher;
24 import java.util.regex.Pattern;
25
26 import org.tianocore.ExternsDocument.Externs.Extern;
27 import org.apache.xmlbeans.XmlObject;
28 import org.apache.xmlbeans.XmlString;
29 import org.tianocore.*;
30 import org.tianocore.FilenameDocument.Filename;
31 import org.tianocore.MsaHeaderDocument.MsaHeader;
32 import org.tianocore.ProtocolsDocument.Protocols.Protocol;
33 import org.tianocore.ProtocolsDocument.Protocols.ProtocolNotify;
34 import org.tianocore.build.autogen.CommonDefinition;
35 import org.tianocore.build.id.FpdModuleIdentification;
36 import org.tianocore.build.id.ModuleIdentification;
37 import org.tianocore.build.id.PackageIdentification;
38 import org.tianocore.build.id.PlatformIdentification;
39 import org.tianocore.build.toolchain.ToolChainInfo;
40 import org.tianocore.common.exception.EdkException;
41 import org.tianocore.common.definitions.EdkDefinitions;
42 import org.w3c.dom.Node;
43
44 /**
45 * SurfaceAreaQuery class is used to query Surface Area information from msa,
46 * mbd, spd and fpd files.
47 *
48 * This class should not instantiated. All the public interfaces is static.
49 *
50 * @since GenBuild 1.0
51 */
52 public class SurfaceAreaQuery {
53
54 public String prefix = "http://www.TianoCore.org/2006/Edk2.0";
55
56 //
57 // Contains name/value pairs of Surface Area document object. The name is
58 // always the top level element name.
59 //
60 private Map<String, XmlObject> map = null;
61
62 //
63 // mapStack is used to do nested query
64 //
65 private Stack<Map<String, XmlObject>> mapStack = new Stack<Map<String, XmlObject>>();
66
67 //
68 // prefix of name space
69 //
70 private String nsPrefix = "sans";
71
72 //
73 // xmlbeans needs a name space for each Xpath element
74 //
75 private String ns = null;
76
77 //
78 // keep the namep declaration for xmlbeans Xpath query
79 //
80 private String queryDeclaration = null;
81 private StringBuffer normQueryString = new StringBuffer(4096);
82 private Pattern xPathPattern = Pattern.compile("([^/]*)(/|//)([^/]+)");
83
84 /**
85 * Set a Surface Area document for query later
86 *
87 * @param map
88 * A Surface Area document in TopLevelElementName/XmlObject
89 * format.
90 */
91 public SurfaceAreaQuery(Map<String, XmlObject> map) {
92 ns = prefix;
93 queryDeclaration = "declare namespace " + nsPrefix + "='" + ns + "'; ";
94 this.map = map;
95 }
96
97 /**
98 * Push current used Surface Area document into query stack. The given new
99 * document will be used for any immediately followed getXXX() callings,
100 * untill pop() is called.
101 *
102 * @param newMap
103 * The TopLevelElementName/XmlObject format of a Surface Area
104 * document.
105 */
106 public void push(Map<String, XmlObject> newMap) {
107 mapStack.push(this.map);
108 this.map = newMap;
109 }
110
111 /**
112 * Discard current used Surface Area document and use the top document in
113 * stack instead.
114 */
115 public void pop() {
116 this.map = mapStack.pop();
117 }
118
119 // /
120 // / Convert xPath to be namespace qualified, which is necessary for
121 // XmlBeans
122 // / selectPath(). For example, converting /MsaHeader/ModuleType to
123 // / /ns:MsaHeader/ns:ModuleType
124 // /
125 private String normalizeQueryString(String[] exp, String from) {
126 normQueryString.setLength(0);
127
128 int i = 0;
129 while (i < exp.length) {
130 String newExp = from + exp[i];
131 Matcher matcher = xPathPattern.matcher(newExp);
132
133 while (matcher.find()) {
134 String starter = newExp.substring(matcher.start(1), matcher
135 .end(1));
136 String seperator = newExp.substring(matcher.start(2), matcher
137 .end(2));
138 String token = newExp.substring(matcher.start(3), matcher
139 .end(3));
140
141 normQueryString.append(starter);
142 normQueryString.append(seperator);
143 normQueryString.append(nsPrefix);
144 normQueryString.append(":");
145 normQueryString.append(token);
146 }
147
148 ++i;
149 if (i < exp.length) {
150 normQueryString.append(" | ");
151 }
152 }
153
154 return normQueryString.toString();
155 }
156
157 /**
158 * Search all XML documents stored in "map" for the specified xPath, using
159 * relative path (starting with '$this')
160 *
161 * @param xPath
162 * xpath query string array
163 * @returns An array of XmlObject if elements are found at the specified
164 * xpath
165 * @returns NULL if nothing is at the specified xpath
166 */
167 public Object[] get(String[] xPath) {
168 if (map == null) {
169 return null;
170 }
171
172 String[] keys = (String[]) map.keySet().toArray(new String[map.size()]);
173 List<Object> result = new ArrayList<Object>();
174 for (int i = 0; i < keys.length; ++i) {
175 XmlObject rootNode = (XmlObject) map.get(keys[i]);
176 if (rootNode == null) {
177 continue;
178 }
179
180 String query = queryDeclaration
181 + normalizeQueryString(xPath, "$this/" + keys[i]);
182 XmlObject[] tmp = rootNode.selectPath(query);
183 for (int j = 0; j < tmp.length; ++j) {
184 result.add((Object)tmp[j]);
185 }
186 }
187
188 int size = result.size();
189 if (size <= 0) {
190 return null;
191 }
192
193 return (Object[]) result.toArray(new Object[size]);
194 }
195
196 /**
197 * Search XML documents named by "rootName" for the given xPath, using
198 * relative path (starting with '$this')
199 *
200 * @param rootName
201 * The top level element name
202 * @param xPath
203 * The xpath query string array
204 * @returns An array of XmlObject if elements are found at the given xpath
205 * @returns NULL if nothing is found at the given xpath
206 */
207 public Object[] get(String rootName, String[] xPath) {
208 if (map == null) {
209 return null;
210 }
211
212 XmlObject root = (XmlObject) map.get(rootName);
213 if (root == null) {
214 return null;
215 }
216
217 String query = queryDeclaration
218 + normalizeQueryString(xPath, "$this/" + rootName);
219 XmlObject[] result = root.selectPath(query);
220 if (result.length > 0) {
221 return (Object[])result;
222 }
223
224 query = queryDeclaration + normalizeQueryString(xPath, "/" + rootName);
225 result = root.selectPath(query);
226 if (result.length > 0) {
227 return (Object[])result;
228 }
229
230 return null;
231 }
232
233 /**
234 * Retrieve SourceFiles/Filename for specified ARCH type
235 *
236 * @param arch
237 * architecture name
238 * @returns An 2 dimension string array if elements are found at the known
239 * xpath
240 * @returns NULL if nothing is found at the known xpath
241 */
242 public String[][] getSourceFiles(String arch) {
243 String[] xPath;
244 Object[] returns;
245
246 xPath = new String[] { "/Filename" };
247
248 returns = get("SourceFiles", xPath);
249
250 if (returns == null || returns.length == 0) {
251 return new String[0][3];
252 }
253
254 Filename[] sourceFileNames = (Filename[]) returns;
255 List<String[]> outputList = new ArrayList<String[]>();
256 for (int i = 0; i < sourceFileNames.length; i++) {
257 List archList = sourceFileNames[i].getSupArchList();
258 if (arch == null || arch.trim().equalsIgnoreCase("") || archList == null || contains(archList, arch)) {
259 outputList.add(new String[] {sourceFileNames[i].getToolCode(), sourceFileNames[i].getStringValue(), sourceFileNames[i].getToolChainFamily()});
260 }
261 }
262
263 String[][] outputString = new String[outputList.size()][3];
264 for (int index = 0; index < outputList.size(); index++) {
265 //
266 // ToolCode (FileType)
267 //
268 outputString[index][0] = outputList.get(index)[0];
269 //
270 // File name (relative to MODULE_DIR)
271 //
272 outputString[index][1] = outputList.get(index)[1];
273 //
274 // Tool chain family
275 //
276 outputString[index][2] = outputList.get(index)[2];
277 }
278 return outputString;
279 }
280
281 /**
282 * Retrieve /PlatformDefinitions/OutputDirectory from FPD
283 *
284 * @returns Directory names array if elements are found at the known xpath
285 * @returns Empty if nothing is found at the known xpath
286 */
287 public String getFpdOutputDirectory() {
288 String[] xPath = new String[] { "/PlatformDefinitions" };
289
290 Object[] returns = get("PlatformSurfaceArea", xPath);
291 if (returns == null || returns.length == 0) {
292 return null;
293 }
294 PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];
295 return item.getOutputDirectory();
296 }
297
298 public String getFpdIntermediateDirectories() {
299 String[] xPath = new String[] { "/PlatformDefinitions" };
300
301 Object[] returns = get("PlatformSurfaceArea", xPath);
302 if (returns == null || returns.length == 0) {
303 return "UNIFIED";
304 }
305 PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];
306 if(item.getIntermediateDirectories() == null) {
307 return null;
308 }
309 else {
310 return item.getIntermediateDirectories().toString();
311 }
312 }
313
314 public String getModuleFfsKeyword() {
315 String[] xPath = new String[] { "/" };
316
317 Object[] returns = get("ModuleSaBuildOptions", xPath);
318 if (returns == null || returns.length == 0) {
319 return null;
320 }
321 ModuleSaBuildOptionsDocument.ModuleSaBuildOptions item = (ModuleSaBuildOptionsDocument.ModuleSaBuildOptions)returns[0];
322 return item.getFfsFormatKey();
323 }
324
325 public String getModuleFvBindingKeyword() {
326 String[] xPath = new String[] { "/" };
327
328 Object[] returns = get("ModuleSaBuildOptions", xPath);
329 if (returns == null || returns.length == 0) {
330 return null;
331 }
332 ModuleSaBuildOptionsDocument.ModuleSaBuildOptions item = (ModuleSaBuildOptionsDocument.ModuleSaBuildOptions)returns[0];
333 return item.getFvBinding();
334 }
335
336 public List getModuleSupportedArchs() {
337 String[] xPath = new String[] { "/" };
338
339 Object[] returns = get("ModuleDefinitions", xPath);
340 if (returns == null || returns.length == 0) {
341 return null;
342 }
343 ModuleDefinitionsDocument.ModuleDefinitions item = (ModuleDefinitionsDocument.ModuleDefinitions)returns[0];
344 return item.getSupportedArchitectures();
345 }
346
347 public BuildOptionsDocument.BuildOptions.Ffs[] getFpdFfs() {
348 String[] xPath = new String[] {"/Ffs"};
349
350 Object[] returns = get("BuildOptions", xPath);
351 if (returns == null || returns.length == 0) {
352 return new BuildOptionsDocument.BuildOptions.Ffs[0];
353 }
354 return (BuildOptionsDocument.BuildOptions.Ffs[])returns;
355 }
356
357 public String getModuleOutputFileBasename() {
358 String[] xPath = new String[] { "/" };
359
360 Object[] returns = get("ModuleDefinitions", xPath);
361 if (returns == null || returns.length == 0) {
362 return null;
363 }
364 ModuleDefinitionsDocument.ModuleDefinitions item = (ModuleDefinitionsDocument.ModuleDefinitions)returns[0];
365 return item.getOutputFileBasename();
366 }
367
368 /**
369 * Retrieve BuildOptions/Option or Arch/Option
370 *
371 * @param toolChainFamilyFlag
372 * if true, retrieve options for toolchain family; otherwise for
373 * toolchain
374 *
375 * @returns String[][5] name, target, toolchain, arch, coommand of options
376 * if elements are found at the known xpath. String[0][] if dont
377 * find element.
378 *
379 * @returns Empty array if nothing is there
380 */
381 public String[][] getOptions(String from, String[] xPath, boolean toolChainFamilyFlag) {
382 String target = null;
383 String toolchain = null;
384 String toolchainFamily = null;
385 List<String> archList = null;
386 String cmd = null;
387 String optionName = null;
388
389 Object[] returns = get(from, xPath);
390 if (returns == null) {
391 return new String[0][5];
392 }
393
394 List<String[]> optionList = new ArrayList<String[]>();
395 OptionDocument.Option option;
396
397 for (int i = 0; i < returns.length; i++) {
398 option = (OptionDocument.Option) returns[i];
399
400 //
401 // Get Target, ToolChain(Family), Arch, Cmd, and Option from Option,
402 // then
403 // put to result[][5] array in above order.
404 //
405 String[] targetList;
406 if (option.getBuildTargets() == null) {
407 target = null;
408 }
409 else {
410 target = option.getBuildTargets().toString();
411 }
412 if (target != null) {
413 targetList = target.split(" ");
414 } else {
415 targetList = new String[1];
416 targetList[0] = null;
417 }
418
419 if (toolChainFamilyFlag) {
420 toolchainFamily = option.getToolChainFamily();
421 if (toolchainFamily != null) {
422 toolchain = toolchainFamily.toString();
423 } else {
424 toolchain = null;
425 }
426 } else {
427 toolchain = option.getTagName();
428 }
429
430 archList = new ArrayList<String>();
431 List archEnumList = option.getSupArchList();
432 if (archEnumList == null) {
433 archList.add(null);
434 } else {
435 //archList.addAll(archEnumList);
436 Iterator it = archEnumList.iterator();
437 while (it.hasNext()) {
438 String archType = (String)it.next();
439 archList.add(archType);
440 }
441 }
442
443 cmd = option.getToolCode();
444
445 optionName = option.getStringValue();
446 for (int t = 0; t < targetList.length; t++) {
447 for (int j = 0; j < archList.size(); j++) {
448 optionList.add(new String[] { targetList[t],
449 toolchain, archList.get(j), cmd, optionName});
450 }
451 }
452 }
453
454 String[][] result = new String[optionList.size()][5];
455 for (int i = 0; i < optionList.size(); i++) {
456 result[i][0] = optionList.get(i)[0];
457 result[i][1] = optionList.get(i)[1];
458 result[i][2] = optionList.get(i)[2];
459 result[i][3] = optionList.get(i)[3];
460 result[i][4] = optionList.get(i)[4];
461 }
462 return result;
463 }
464
465 public String[][] getModuleBuildOptions(boolean toolChainFamilyFlag) {
466 String[] xPath;
467
468 if (toolChainFamilyFlag == true) {
469 xPath = new String[] {
470 "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
471 "/Options/Option[@ToolChainFamily]", };
472 } else {
473 xPath = new String[] {
474 "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
475 "/Options/Option[@TagName]", };
476 }
477 return getOptions("ModuleSaBuildOptions", xPath, toolChainFamilyFlag);
478 }
479
480 public String[][] getPlatformBuildOptions(boolean toolChainFamilyFlag) {
481 String[] xPath;
482
483 if (toolChainFamilyFlag == true) {
484 xPath = new String[] {
485 "/BuildOptions/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
486 "/BuildOptions/Options/Option[@ToolChainFamily]", };
487 } else {
488 xPath = new String[] {
489 "/BuildOptions/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
490 "/BuildOptions/Options/Option[@TagName]", };
491 }
492
493 return getOptions("PlatformSurfaceArea", xPath, toolChainFamilyFlag);
494 }
495
496 public String[][] getMsaBuildOptions(boolean toolChainFamilyFlag) {
497 String[] xPath;
498
499 if (toolChainFamilyFlag == true) {
500 xPath = new String[] {
501 "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
502 "/Options/Option[@ToolChainFamily]", };
503 } else {
504 xPath = new String[] {
505 "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",
506 "/Options/Option[@TagName]", };
507 }
508
509 return getOptions("ModuleBuildOptions", xPath, toolChainFamilyFlag);
510 }
511
512 public ToolChainInfo getFpdToolChainInfo() {
513 String[] xPath = new String[] { "/PlatformDefinitions" };
514
515 Object[] returns = get("PlatformSurfaceArea", xPath);
516 if (returns == null || returns.length == 0) {
517 return null;
518 }
519
520 PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];
521 ToolChainInfo toolChainInfo = new ToolChainInfo();
522 toolChainInfo.addTargets(item.getBuildTargets().toString());
523 toolChainInfo.addArchs(item.getSupportedArchitectures().toString());
524 toolChainInfo.addTagnames((String)null);
525 return toolChainInfo;
526 }
527
528 /**
529 * Retrieve <xxxHeader>/ModuleType
530 *
531 * @returns The module type name if elements are found at the known xpath
532 * @returns null if nothing is there
533 */
534 public String getModuleType() {
535 String[] xPath = new String[] { "/ModuleType" };
536
537 Object[] returns = get(xPath);
538 if (returns != null && returns.length > 0) {
539 ModuleTypeDef type = (ModuleTypeDef) returns[0];
540 return type.enumValue().toString();
541 }
542
543 return null;
544 }
545
546 /**
547 * Retrieve PackageDependencies/Package
548 *
549 * @param arch
550 * Architecture name
551 *
552 * @returns package name list if elements are found at the known xpath
553 * @returns null if nothing is there
554 */
555 public PackageIdentification[] getDependencePkg(String arch) throws EdkException {
556 String[] xPath;
557 String packageGuid = null;
558 String packageVersion = null;
559
560
561 xPath = new String[] { "/Package" };
562
563 Object[] returns = get("PackageDependencies", xPath);
564 if (returns == null) {
565 return new PackageIdentification[0];
566 }
567
568 //
569 // Get packageIdentification
570 //
571 List<PackageIdentification> packageIdList = new ArrayList<PackageIdentification>();
572 for (int i = 0; i < returns.length; i++) {
573 PackageDependenciesDocument.PackageDependencies.Package item = (PackageDependenciesDocument.PackageDependencies.Package) returns[i];
574 List archList = item.getSupArchList();
575 if (arch == null || archList == null || contains(archList, arch)) {
576 packageGuid = item.getPackageGuid();
577 packageVersion = item.getPackageVersion();
578 PackageIdentification pkgId = new PackageIdentification(null, packageGuid, packageVersion);
579 GlobalData.refreshPackageIdentification(pkgId);
580 packageIdList.add(pkgId);
581 }
582 }
583
584 return packageIdList.toArray(new PackageIdentification[packageIdList.size()]);
585 }
586
587 /**
588 * Retrieve LibraryClassDefinitions/LibraryClass for specified usage
589 *
590 * @param usage
591 * Library class usage
592 *
593 * @returns LibraryClass objects list if elements are found at the known
594 * xpath
595 * @returns null if nothing is there
596 */
597 public String[] getLibraryClasses(String usage, String arch, String moduleType) {
598 String[] xPath;
599 if (usage == null || usage.equals("")) {
600 xPath = new String[] { "/LibraryClass" };
601 } else {
602 xPath = new String[] { "/LibraryClass[@Usage='" + usage + "']" };
603 }
604
605 Object[] returns = get("LibraryClassDefinitions", xPath);
606 if (returns == null || returns.length == 0) {
607 return new String[0];
608 }
609
610 LibraryClassDocument.LibraryClass[] libraryClassList = (LibraryClassDocument.LibraryClass[]) returns;
611 List<String> libraryClassName = new ArrayList<String>();
612 for (int i = 0; i < libraryClassList.length; i++) {
613 List archList = libraryClassList[i].getSupArchList();
614 List moduleTypeList = libraryClassList[i].getSupModuleList();
615 if ((arch == null || contains(archList, arch))
616 && (moduleType == null || contains(moduleTypeList, moduleType))) {
617 libraryClassName.add(libraryClassList[i].getKeyword());
618 }
619 }
620
621 String[] libraryArray = new String[libraryClassName.size()];
622 libraryClassName.toArray(libraryArray);
623 return libraryArray;
624 }
625
626 /**
627 * Retrieve ModuleEntryPoint names
628 *
629 * @returns ModuleEntryPoint name list if elements are found at the known
630 * xpath
631 * @returns null if nothing is there
632 */
633 public String[] getModuleEntryPointArray() {
634 String[] xPath = new String[] { "/Extern/ModuleEntryPoint" };
635
636 Object[] returns = get("Externs", xPath);
637
638 if (returns != null && returns.length > 0) {
639 String[] entryPoints = new String[returns.length];
640
641 for (int i = 0; i < returns.length; ++i) {
642 entryPoints[i] = ((CNameType) returns[i]).getStringValue();
643 }
644
645 return entryPoints;
646 }
647
648 return null;
649 }
650
651 /**
652 * retrieve Protocol for specified usage
653 *
654 * @param usage
655 * Protocol usage arch Architecture
656 *
657 * @returns Protocol String list if elements are found at the known xpath
658 * @returns String[0] if nothing is there
659 */
660 public String[] getProtocolArray(String arch, String usage) {
661 String[] xPath;
662 String usageXpath = "";
663 String archXpath = "";
664
665 if (arch == null || arch.equals("")) {
666 return new String[0];
667 } else {
668 archXpath = "/Protocol";
669 if (usage != null && !usage.equals("")) {
670 usageXpath = "/Protocol[@Usage='" + usage + "']";
671 xPath = new String[] { usageXpath, archXpath };
672 } else {
673 return getProtocolArray(arch);
674 }
675
676 }
677
678 Object[] returns = get("Protocols", xPath);
679 if (returns == null) {
680 return new String[0];
681 }
682 Protocol[] protocolList = (Protocol[]) returns;
683
684 String[] protocolArray = new String[returns.length];
685 for (int i = 0; i < returns.length; i++) {
686 protocolArray[i] = protocolList[i].getProtocolCName();
687 }
688 return protocolArray;
689 }
690
691 /**
692 * retrieve Protocol for specified usage
693 *
694 * @param arch
695 * Architecture
696 *
697 * @returns Protocol String list if elements are found at the known xpath
698 * @returns String[0] if nothing is there
699 */
700 public String[] getProtocolArray(String arch) {
701 String[] xPath;
702
703 if (arch == null || arch.equals("")) {
704 return new String[0];
705 } else {
706 xPath = new String[] { "/Protocol" };
707 }
708
709 Object[] returns = get("Protocols", xPath);
710 if (returns == null) {
711 return new String[0];
712 }
713 Protocol[] returnlList = (Protocol[]) returns;
714
715 List<String> protocolList = new ArrayList<String>();
716
717 for (int i = 0; i < returns.length; i++) {
718 List archList = returnlList[i].getSupArchList();
719 if (archList == null || contains(archList, arch)){
720 protocolList.add(returnlList[i].getProtocolCName());
721 }
722 }
723 String[] protocolArray = new String[protocolList.size()];
724 for (int i = 0; i < protocolList.size(); i++) {
725 protocolArray[i] = protocolList.get(i);
726 }
727 return protocolArray;
728 }
729
730 /**
731 * Retrieve ProtocolNotify for specified usage
732 *
733 * @param usage
734 * ProtocolNotify usage
735 *
736 * @returns String[] if elements are found at the known xpath
737 * @returns String[0] if nothing is there
738 */
739 public String[] getProtocolNotifyArray(String arch) {
740 String[] xPath;
741
742 if (arch == null || arch.equals("")) {
743 return new String[0];
744 } else {
745 xPath = new String[] { "/ProtocolNotify" };
746 }
747
748 Object[] returns = get("Protocols", xPath);
749 if (returns == null) {
750 return new String[0];
751 }
752
753 List<String> protocolNotifyList = new ArrayList<String>();
754
755 for (int i = 0; i < returns.length; i++) {
756 List archList = ((ProtocolNotify) returns[i]).getSupArchList();
757 if (archList == null || contains(archList, arch)){
758 protocolNotifyList.add(((ProtocolNotify) returns[i]).getProtocolNotifyCName());
759 }
760
761 }
762 String[] protocolNotifyArray = new String[protocolNotifyList.size()];
763 for (int i = 0; i < protocolNotifyList.size(); i++) {
764 protocolNotifyArray[i] = protocolNotifyList.get(i);
765 }
766 return protocolNotifyArray;
767 }
768
769 /**
770 * Retrieve ProtocolNotify for specified usage
771 *
772 * @param usage
773 * ProtocolNotify usage
774 *
775 * @returns String[] if elements are found at the known xpath
776 * @returns String[0] if nothing is there
777 */
778 public String[] getProtocolNotifyArray(String arch, String usage) {
779
780 String[] xPath;
781 String usageXpath;
782 String archXpath;
783
784 if (arch == null || arch.equals("")) {
785 return new String[0];
786 } else {
787 archXpath = "/ProtocolNotify";
788 if (usage != null && !usage.equals("")) {
789 usageXpath = "/ProtocolNotify[@Usage='" + arch + "']";
790 xPath = new String[] { archXpath, usageXpath };
791 } else {
792 return getProtocolNotifyArray(arch);
793 }
794 }
795
796 Object[] returns = get("Protocols", xPath);
797 if (returns == null) {
798 return new String[0];
799 }
800
801 String[] protocolNotifyList = new String[returns.length];
802
803 for (int i = 0; i < returns.length; i++) {
804 protocolNotifyList[i] = ((ProtocolNotify) returns[i]).getProtocolNotifyCName();
805 }
806 return protocolNotifyList;
807 }
808
809 /**
810 * Retrieve ModuleUnloadImage names
811 *
812 * @returns ModuleUnloadImage name list if elements are found at the known
813 * xpath
814 * @returns null if nothing is there
815 */
816 public String[] getModuleUnloadImageArray() {
817 String[] xPath = new String[] { "/Extern/ModuleUnloadImage" };
818
819 Object[] returns = get("Externs", xPath);
820 if (returns != null && returns.length > 0) {
821 String[] stringArray = new String[returns.length];
822 CNameType[] doc = (CNameType[]) returns;
823
824 for (int i = 0; i < returns.length; ++i) {
825 stringArray[i] = doc[i].getStringValue();
826 }
827
828 return stringArray;
829 }
830
831 return null;
832 }
833
834 /**
835 * Retrieve Extern
836 *
837 * @returns Extern objects list if elements are found at the known xpath
838 * @returns null if nothing is there
839 */
840 public ExternsDocument.Externs.Extern[] getExternArray() {
841 String[] xPath = new String[] { "/Extern" };
842
843 Object[] returns = get("Externs", xPath);
844 if (returns != null && returns.length > 0) {
845 return (ExternsDocument.Externs.Extern[]) returns;
846 }
847
848 return null;
849 }
850
851 /**
852 * Retrieve PpiNotify for specified arch
853 *
854 * @param arch
855 * PpiNotify arch
856 *
857 * @returns String[] if elements are found at the known xpath
858 * @returns String[0] if nothing is there
859 */
860 public String[] getPpiNotifyArray(String arch) {
861 String[] xPath;
862
863 if (arch == null || arch.equals("")) {
864 return new String[0];
865 } else {
866 xPath = new String[] { "/PpiNotify" };
867 }
868
869 Object[] returns = get("PPIs", xPath);
870 if (returns == null) {
871 return new String[0];
872 }
873
874
875 List<String> ppiNotifyList = new ArrayList<String>();
876 for (int i = 0; i < returns.length; i++) {
877 List archList = ((PPIsDocument.PPIs.PpiNotify) returns[i]).getSupArchList();
878 if (archList == null || contains(archList, arch)){
879 ppiNotifyList.add(((PPIsDocument.PPIs.PpiNotify) returns[i]).getPpiNotifyCName());
880 }
881
882 }
883 String[] ppiNotifyArray = new String[ppiNotifyList.size()];
884 for (int i = 0; i < ppiNotifyList.size(); i++) {
885 ppiNotifyArray[i] = ppiNotifyList.get(i);
886 }
887
888 return ppiNotifyArray;
889 }
890
891 /**
892 * Retrieve PpiNotify for specified usage and arch
893 *
894 * @param arch
895 * PpiNotify arch usage PpiNotify usage
896 *
897 *
898 * @returns String[] if elements are found at the known xpath
899 * @returns String[0] if nothing is there
900 */
901 public String[] getPpiNotifyArray(String arch, String usage) {
902
903 String[] xPath;
904 String usageXpath;
905 String archXpath;
906
907 if (arch == null || arch.equals("")) {
908 return new String[0];
909 } else {
910 archXpath = "/PpiNotify";
911 if (usage != null && !usage.equals("")) {
912 usageXpath = "/PpiNotify[@Usage='" + arch + "']";
913 xPath = new String[] { archXpath, usageXpath };
914 } else {
915 return getProtocolNotifyArray(arch);
916 }
917 }
918
919 Object[] returns = get("PPIs", xPath);
920 if (returns == null) {
921 return new String[0];
922 }
923
924 String[] ppiNotifyList = new String[returns.length];
925
926 for (int i = 0; i < returns.length; i++) {
927 ppiNotifyList[i] = ((PPIsDocument.PPIs.PpiNotify) returns[i]).getPpiNotifyCName();
928 }
929 return ppiNotifyList;
930 }
931
932 /**
933 * Retrieve Ppi for specified arch
934 *
935 * @param arch
936 * Ppi arch
937 *
938 * @returns String[] if elements are found at the known xpath
939 * @returns String[0] if nothing is there
940 */
941 public String[] getPpiArray(String arch) {
942 String[] xPath;
943
944 if (arch == null || arch.equals("")) {
945 return new String[0];
946 } else {
947 xPath = new String[] { "/Ppi" };
948 }
949
950 Object[] returns = get("PPIs", xPath);
951 if (returns == null) {
952 return new String[0];
953 }
954
955 List<String> ppiList = new ArrayList<String>();
956 for (int i = 0; i < returns.length; i++) {
957 List archList = ((PPIsDocument.PPIs.Ppi) returns[i]).getSupArchList();
958 if (archList == null || contains(archList, arch)){
959 ppiList.add(((PPIsDocument.PPIs.Ppi) returns[i]).getPpiCName());
960 }
961
962 }
963 String[] ppiArray = new String[ppiList.size()];
964 for (int i = 0; i < ppiList.size(); i++) {
965 ppiArray[i] = ppiList.get(i);
966 }
967 return ppiArray;
968 }
969
970 /**
971 * Retrieve PpiNotify for specified usage and arch
972 *
973 * @param arch
974 * PpiNotify arch usage PpiNotify usage
975 *
976 *
977 * @returns String[] if elements are found at the known xpath
978 * @returns String[0] if nothing is there
979 */
980 public String[] getPpiArray(String arch, String usage) {
981
982 String[] xPath;
983 String usageXpath;
984 String archXpath;
985
986 if (arch == null || arch.equals("")) {
987 return new String[0];
988 } else {
989 archXpath = "/Ppi";
990 if (usage != null && !usage.equals("")) {
991 usageXpath = "/Ppi[@Usage='" + arch + "']";
992 xPath = new String[] { archXpath, usageXpath };
993 } else {
994 return getProtocolNotifyArray(arch);
995 }
996 }
997
998 Object[] returns = get("PPIs", xPath);
999 if (returns == null) {
1000 return new String[0];
1001 }
1002
1003 String[] ppiList = new String[returns.length];
1004
1005 for (int i = 0; i < returns.length; i++) {
1006 ppiList[i] = ((PPIsDocument.PPIs.Ppi) returns[i]).getPpiCName();
1007 }
1008 return ppiList;
1009 }
1010
1011 /**
1012 * Retrieve GuidEntry information for specified usage
1013 *
1014 * @param arch
1015 * GuidEntry arch
1016 *
1017 * @returns GuidEntry objects list if elements are found at the known xpath
1018 * @returns null if nothing is there
1019 */
1020 public String[] getGuidEntryArray(String arch) {
1021 String[] xPath;
1022
1023 if (arch == null || arch.equals("")) {
1024 xPath = new String[] { "/GuidCNames" };
1025 } else {
1026 xPath = new String[] { "/GuidCNames" };
1027 }
1028
1029 Object[] returns = get("Guids", xPath);
1030 if (returns == null) {
1031 return new String[0];
1032 }
1033
1034 List<String> guidList = new ArrayList<String>();
1035 for (int i = 0; i < returns.length; i++) {
1036 List archList = ((GuidsDocument.Guids.GuidCNames) returns[i]).getSupArchList();
1037 if (archList == null || contains(archList, arch)){
1038 guidList.add(((GuidsDocument.Guids.GuidCNames) returns[i]).getGuidCName());
1039 }
1040
1041 }
1042 String[] guidArray = new String[guidList.size()];
1043 for (int i = 0; i < guidList.size(); i++) {
1044 guidArray[i] = guidList.get(i);
1045 }
1046 return guidArray;
1047
1048 }
1049
1050 /**
1051 * Retrieve GuidEntry information for specified usage
1052 *
1053 * @param arch
1054 * GuidEntry arch usage GuidEntry usage
1055 *
1056 * @returns GuidEntry objects list if elements are found at the known xpath
1057 * @returns null if nothing is there
1058 */
1059 public String[] getGuidEntryArray(String arch, String usage) {
1060 String[] xPath;
1061 String archXpath;
1062 String usageXpath;
1063
1064 if (arch == null || arch.equals("")) {
1065 return new String[0];
1066 } else {
1067 archXpath = "/GuidEntry";
1068 if (usage != null && !usage.equals("")) {
1069 usageXpath = "/GuidEntry[@Usage='" + arch + "']";
1070 xPath = new String[] { archXpath, usageXpath };
1071 } else {
1072 return getProtocolNotifyArray(arch);
1073 }
1074 }
1075
1076 Object[] returns = get("Guids", xPath);
1077 if (returns == null) {
1078 return new String[0];
1079 }
1080
1081 String[] guidList = new String[returns.length];
1082
1083 for (int i = 0; i < returns.length; i++) {
1084 guidList[i] = ((GuidsDocument.Guids.GuidCNames) returns[i]).getGuidCName();
1085 }
1086 return guidList;
1087 }
1088
1089 /**
1090 * Retrieve Library instance information
1091 *
1092 * @param arch
1093 * Architecture name
1094 * @param usage
1095 * Library instance usage
1096 *
1097 * @returns library instance name list if elements are found at the known
1098 * xpath
1099 * @returns null if nothing is there
1100 */
1101 public ModuleIdentification[] getLibraryInstance(String arch) throws EdkException {
1102 String[] xPath;
1103 String saGuid = null;
1104 String saVersion = null;
1105 String pkgGuid = null;
1106 String pkgVersion = null;
1107
1108 if (arch == null || arch.equalsIgnoreCase("")) {
1109 xPath = new String[] { "/Instance" };
1110 } else {
1111 //
1112 // Since Schema don't have SupArchList now, so the follow Xpath is
1113 // equal to "/Instance" and [not(@SupArchList) or @SupArchList= arch]
1114 // don't have effect.
1115 //
1116 xPath = new String[] { "/Instance[not(@SupArchList) or @SupArchList='"
1117 + arch + "']" };
1118 }
1119
1120 Object[] returns = get("Libraries", xPath);
1121 if (returns == null || returns.length == 0) {
1122 return new ModuleIdentification[0];
1123 }
1124
1125 ModuleIdentification[] saIdList = new ModuleIdentification[returns.length];
1126 for (int i = 0; i < returns.length; i++) {
1127 LibrariesDocument.Libraries.Instance library = (LibrariesDocument.Libraries.Instance) returns[i];
1128 saGuid = library.getModuleGuid();
1129 saVersion = library.getModuleVersion();
1130
1131 pkgGuid = library.getPackageGuid();
1132 pkgVersion = library.getPackageVersion();
1133
1134 ModuleIdentification saId = new ModuleIdentification(null, saGuid,
1135 saVersion);
1136 PackageIdentification pkgId = new PackageIdentification(null,
1137 pkgGuid, pkgVersion);
1138 GlobalData.refreshPackageIdentification(pkgId);
1139 saId.setPackage(pkgId);
1140 GlobalData.refreshModuleIdentification(saId);
1141
1142 saIdList[i] = saId;
1143
1144 }
1145 return saIdList;
1146 }
1147
1148 // /
1149 // / This method is used for retrieving the elements information which has
1150 // / CName sub-element
1151 // /
1152 private String[] getCNames(String from, String xPath[]) {
1153 Object[] returns = get(from, xPath);
1154 if (returns == null || returns.length == 0) {
1155 return null;
1156 }
1157
1158 String[] strings = new String[returns.length];
1159 for (int i = 0; i < returns.length; ++i) {
1160 // TBD
1161 strings[i] = ((CNameType) returns[i]).getStringValue();
1162 }
1163
1164 return strings;
1165 }
1166
1167 /**
1168 * Retrive library's constructor name
1169 *
1170 * @returns constructor name list if elements are found at the known xpath
1171 * @returns null if nothing is there
1172 */
1173 public String getLibConstructorName() {
1174 String[] xPath = new String[] { "/Extern/Constructor" };
1175
1176 Object[] returns = get("Externs", xPath);
1177 if (returns != null && returns.length > 0) {
1178 CNameType constructor = ((CNameType) returns[0]);
1179 return constructor.getStringValue();
1180 }
1181
1182 return null;
1183 }
1184
1185 /**
1186 * Retrive library's destructor name
1187 *
1188 * @returns destructor name list if elements are found at the known xpath
1189 * @returns null if nothing is there
1190 */
1191 public String getLibDestructorName() {
1192 String[] xPath = new String[] { "/Extern/Destructor" };
1193
1194 Object[] returns = get("Externs", xPath);
1195 if (returns != null && returns.length > 0) {
1196 //
1197 // Only support one Destructor function.
1198 //
1199 CNameType destructor = (CNameType) returns[0];
1200 return destructor.getStringValue();
1201 }
1202
1203 return null;
1204 }
1205
1206 /**
1207 * Retrive DriverBinding names
1208 *
1209 * @returns DriverBinding name list if elements are found at the known xpath
1210 * @returns null if nothing is there
1211 */
1212 public String[] getDriverBindingArray() {
1213 String[] xPath = new String[] { "/Extern/DriverBinding" };
1214 return getCNames("Externs", xPath);
1215 }
1216
1217 /**
1218 * Retrive ComponentName names
1219 *
1220 * @returns ComponentName name list if elements are found at the known xpath
1221 * @returns null if nothing is there
1222 */
1223 public String[] getComponentNameArray() {
1224 String[] xPath = new String[] { "/Extern/ComponentName" };
1225 return getCNames("Externs", xPath);
1226 }
1227
1228 /**
1229 * Retrive DriverConfig names
1230 *
1231 * @returns DriverConfig name list if elements are found at the known xpath
1232 * @returns null if nothing is there
1233 */
1234 public String[] getDriverConfigArray() {
1235 String[] xPath = new String[] { "/Extern/DriverConfig" };
1236 return getCNames("Externs", xPath);
1237 }
1238
1239 /**
1240 * Retrive DriverDiag names
1241 *
1242 * @returns DriverDiag name list if elements are found at the known xpath
1243 * @returns null if nothing is there
1244 */
1245 public String[] getDriverDiagArray() {
1246 String[] xPath = new String[] { "/Extern/DriverDiag" };
1247 return getCNames("Externs", xPath);
1248 }
1249
1250 /**
1251 * Retrive DriverBinding, ComponentName, DriverConfig,
1252 * DriverDiag group array
1253 *
1254 * @returns DriverBinding group name list if elements are found
1255 * at the known xpath
1256 * @returns null if nothing is there
1257 */
1258 public String[][] getExternProtocolGroup() {
1259 String[] xPath = new String[] {"/Extern"};
1260 Object[] returns = get("Externs",xPath);
1261
1262 if (returns == null) {
1263 return new String[0][4];
1264 }
1265 List<Extern> externList = new ArrayList<Extern>();
1266 for (int i = 0; i < returns.length; i++) {
1267 org.tianocore.ExternsDocument.Externs.Extern extern = (org.tianocore.ExternsDocument.Externs.Extern)returns[i];
1268 if (extern.getDriverBinding() != null) {
1269 externList.add(extern);
1270 }
1271 }
1272
1273 String[][] externGroup = new String[externList.size()][4];
1274 for (int i = 0; i < externList.size(); i++) {
1275 String driverBindingStr = externList.get(i).getDriverBinding();
1276 if ( driverBindingStr != null){
1277 externGroup[i][0] = driverBindingStr;
1278 } else {
1279 externGroup[i][0] = null;
1280 }
1281
1282 String componentNameStr = externList.get(i).getComponentName();
1283 if (componentNameStr != null) {
1284 externGroup[i][1] = componentNameStr;
1285 } else {
1286 externGroup[i][1] = null;
1287 }
1288
1289 String driverConfigStr = externList.get(i).getDriverConfig();
1290 if (driverConfigStr != null) {
1291 externGroup[i][2] = driverConfigStr;
1292 } else {
1293 externGroup[i][2] = null;
1294 }
1295
1296 String driverDiagStr = externList.get(i).getDriverDiag();
1297 if (driverDiagStr != null) {
1298 externGroup[i][3] = driverDiagStr;
1299 } else {
1300 externGroup[i][3] = null;
1301 }
1302 }
1303 return externGroup;
1304 }
1305
1306 /**
1307 * Retrive SetVirtualAddressMapCallBack names
1308 *
1309 * @returns SetVirtualAddressMapCallBack name list if elements are found at
1310 * the known xpath
1311 * @returns null if nothing is there
1312 */
1313 public String[] getSetVirtualAddressMapCallBackArray() {
1314 String[] xPath = new String[] { "/Extern/SetVirtualAddressMapCallBack" };
1315 return getCNames("Externs", xPath);
1316 }
1317
1318 /**
1319 * Retrive ExitBootServicesCallBack names
1320 *
1321 * @returns ExitBootServicesCallBack name list if elements are found at the
1322 * known xpath
1323 * @returns null if nothing is there
1324 */
1325 public String[] getExitBootServicesCallBackArray() {
1326 String[] xPath = new String[] { "/Extern/ExitBootServicesCallBack" };
1327 return getCNames("Externs", xPath);
1328 }
1329
1330 /**
1331 Judge whether current driver is PEI_PCD_DRIVER or DXE_PCD_DRIVER or
1332 NOT_PCD_DRIVER.
1333
1334 @return CommonDefinition.PCD_DRIVER_TYPE the type of current driver
1335 **/
1336 public CommonDefinition.PCD_DRIVER_TYPE getPcdDriverType() {
1337 String[] xPath = new String[] {"/PcdIsDriver"};
1338 Object[] results = get ("Externs", xPath);
1339
1340 if (results != null && results.length != 0) {
1341 PcdDriverTypes type = (PcdDriverTypes) results[0];
1342 String typeStr = type.enumValue().toString();
1343 if (typeStr.equals(CommonDefinition.PCD_DRIVER_TYPE.PEI_PCD_DRIVER.toString())) {
1344 return CommonDefinition.PCD_DRIVER_TYPE.PEI_PCD_DRIVER;
1345 } else if (typeStr.equals(CommonDefinition.PCD_DRIVER_TYPE.DXE_PCD_DRIVER.toString())) {
1346 return CommonDefinition.PCD_DRIVER_TYPE.DXE_PCD_DRIVER;
1347 }
1348 return CommonDefinition.PCD_DRIVER_TYPE.UNKNOWN_PCD_DRIVER;
1349 }
1350
1351 return CommonDefinition.PCD_DRIVER_TYPE.NOT_PCD_DRIVER;
1352 }
1353
1354 /**
1355 * Retrieve module surface area file information
1356 *
1357 * @returns ModuleSA objects list if elements are found at the known xpath
1358 * @returns Empty ModuleSA list if nothing is there
1359 */
1360 public Map<FpdModuleIdentification, Map<String, XmlObject>> getFpdModules() throws EdkException {
1361 String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };
1362 Object[] result = get("PlatformSurfaceArea", xPath);
1363 String arch = null;
1364 String fvBinding = null;
1365 String saGuid = null;
1366 String saVersion = null;
1367 String pkgGuid = null;
1368 String pkgVersion = null;
1369
1370 Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleMap = new LinkedHashMap<FpdModuleIdentification, Map<String, XmlObject>>();
1371
1372 if (result == null) {
1373 return fpdModuleMap;
1374 }
1375
1376 for (int i = 0; i < result.length; i++) {
1377 //
1378 // Get Fpd SA Module element node and add to ObjectMap.
1379 //
1380 Map<String, XmlObject> ObjectMap = new HashMap<String, XmlObject>();
1381 ModuleSADocument.ModuleSA moduleSA = (ModuleSADocument.ModuleSA) result[i];
1382 if (((ModuleSADocument.ModuleSA) result[i]).getLibraries() != null) {
1383 ObjectMap.put("Libraries", moduleSA.getLibraries());
1384 }
1385 if (((ModuleSADocument.ModuleSA) result[i]).getPcdBuildDefinition() != null) {
1386 ObjectMap.put("PcdBuildDefinition", moduleSA.getPcdBuildDefinition());
1387 }
1388 if (((ModuleSADocument.ModuleSA) result[i]).getModuleSaBuildOptions() != null) {
1389 ObjectMap.put("ModuleSaBuildOptions", moduleSA.getModuleSaBuildOptions());
1390 }
1391
1392 //
1393 // Get Fpd SA Module attribute and create FpdMoudleIdentification.
1394 //
1395 if (moduleSA.isSetSupArchList()) {
1396 arch = moduleSA.getSupArchList().toString();
1397 } else {
1398 arch = null;
1399 }
1400
1401 // TBD
1402 fvBinding = null;
1403 saVersion = ((ModuleSADocument.ModuleSA) result[i]).getModuleVersion();
1404
1405 saGuid = moduleSA.getModuleGuid();
1406 pkgGuid = moduleSA.getPackageGuid();
1407 pkgVersion = moduleSA.getPackageVersion();
1408
1409 //
1410 // Create Module Identification which have class member of package
1411 // identification.
1412 //
1413 PackageIdentification pkgId = new PackageIdentification(null, pkgGuid, pkgVersion);
1414 GlobalData.refreshPackageIdentification(pkgId);
1415
1416 ModuleIdentification saId = new ModuleIdentification(null, saGuid, saVersion);
1417 saId.setPackage(pkgId);
1418 GlobalData.refreshModuleIdentification(saId);
1419
1420
1421
1422 //
1423 // Create FpdModule Identification which have class member of module
1424 // identification
1425 //
1426 String[] archList = new String[0];
1427 if (arch == null || arch.trim().length() == 0) {
1428 archList = GlobalData.getToolChainInfo().getArchs();
1429 } else {
1430 archList = arch.split(" ");
1431 }
1432 for (int j = 0; j < archList.length; j++) {
1433 FpdModuleIdentification fpdSaId = new FpdModuleIdentification(saId, archList[j]);
1434
1435 if (fvBinding != null) {
1436 fpdSaId.setFvBinding(fvBinding);
1437 }
1438
1439 //
1440 // Put element to Map<FpdModuleIdentification, Map<String,
1441 // Object>>.
1442 //
1443 fpdModuleMap.put(fpdSaId, ObjectMap);
1444 }
1445 }
1446 return fpdModuleMap;
1447 }
1448
1449 /**
1450 * Retrieve valid image names
1451 *
1452 * @returns valid iamges name list if elements are found at the known xpath
1453 * @returns empty list if nothing is there
1454 */
1455 public String[] getFpdValidImageNames() {
1456 String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='ImageName']/FvImageNames" };
1457
1458 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1459 if (queryResult == null) {
1460 return new String[0];
1461 }
1462
1463 String[] result = new String[queryResult.length];
1464 for (int i = 0; i < queryResult.length; i++) {
1465 result[i] = ((XmlString) queryResult[i]).getStringValue();
1466 }
1467
1468 return result;
1469 }
1470
1471 public Node getFpdUserExtensionPreBuild() {
1472 String[] xPath = new String[] { "/UserExtensions[@UserID='TianoCore' and @Identifier='0']" };
1473
1474 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1475 if (queryResult == null || queryResult.length == 0) {
1476 return null;
1477 }
1478 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)queryResult[0];
1479
1480 return a.getDomNode();
1481 }
1482
1483 public Node getFpdUserExtensionPostBuild() {
1484 String[] xPath = new String[] { "/UserExtensions[@UserID='TianoCore' and @Identifier='1']" };
1485
1486 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1487 if (queryResult == null || queryResult.length == 0) {
1488 return null;
1489 }
1490 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)queryResult[0];
1491
1492 return a.getDomNode();
1493 }
1494
1495 public Node[] getFpdUserExtensions() {
1496 String[] xPath = new String[] { "/UserExtensions[@UserID='TianoCore' and not(@Identifier='1') and not(@Identifier='0')]" };
1497
1498 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1499 if (queryResult == null || queryResult.length == 0) {
1500 return new Node[0];
1501 }
1502
1503 Node[] nodeList = new Node[queryResult.length];
1504 for (int i = 0; i < queryResult.length; ++i) {
1505 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)queryResult[i];
1506 nodeList[i] = a.getDomNode();
1507 }
1508
1509 return nodeList;
1510 }
1511 /**
1512 * Retrieve FV image option information
1513 *
1514 * @param fvName
1515 * FV image name
1516 *
1517 * @returns option name/value list if elements are found at the known xpath
1518 * @returns empty list if nothing is there
1519 */
1520 public String[][] getFpdOptions(String fvName) {
1521 String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Options' and ./FvImageNames='"
1522 + fvName + "']/FvImageOptions" };
1523 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1524 if (queryResult == null) {
1525 return new String[0][];
1526 }
1527 ArrayList<String[]> list = new ArrayList<String[]>();
1528 for (int i = 0; i < queryResult.length; i++) {
1529 FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];
1530 List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item
1531 .getNameValueList();
1532 Iterator iter = namevalues.iterator();
1533 while (iter.hasNext()) {
1534 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter
1535 .next();
1536 list.add(new String[] { nvItem.getName(), nvItem.getValue() });
1537 }
1538 }
1539 String[][] result = new String[list.size()][2];
1540 for (int i = 0; i < list.size(); i++) {
1541 result[i][0] = list.get(i)[0];
1542 result[i][1] = list.get(i)[1];
1543 }
1544 return result;
1545
1546 }
1547
1548 public XmlObject getFpdBuildOptions() {
1549 String[] xPath = new String[] { "/BuildOptions" };
1550
1551 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1552
1553 if (queryResult == null || queryResult.length == 0) {
1554 return null;
1555 }
1556 return (XmlObject)queryResult[0];
1557 }
1558
1559 public PlatformIdentification getFpdHeader() {
1560 String[] xPath = new String[] { "/PlatformHeader" };
1561
1562 Object[] returns = get("PlatformSurfaceArea", xPath);
1563
1564 if (returns == null || returns.length == 0) {
1565 return null;
1566 }
1567 PlatformHeaderDocument.PlatformHeader header = (PlatformHeaderDocument.PlatformHeader) returns[0];
1568
1569 String name = header.getPlatformName();
1570
1571 String guid = header.getGuidValue();
1572
1573 String version = header.getVersion();
1574
1575 return new PlatformIdentification(name, guid, version);
1576 }
1577
1578 /**
1579 * Retrieve FV image attributes information
1580 *
1581 * @param fvName
1582 * FV image name
1583 *
1584 * @returns attribute name/value list if elements are found at the known
1585 * xpath
1586 * @returns empty list if nothing is there
1587 */
1588 public String[][] getFpdAttributes(String fvName) {
1589 String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Attributes' and ./FvImageNames='"
1590 + fvName + "']/FvImageOptions" };
1591 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1592 if (queryResult == null) {
1593 return new String[0][];
1594 }
1595 ArrayList<String[]> list = new ArrayList<String[]>();
1596 for (int i = 0; i < queryResult.length; i++) {
1597
1598 FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];
1599 List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item.getNameValueList();
1600 Iterator iter = namevalues.iterator();
1601 while (iter.hasNext()) {
1602 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter
1603 .next();
1604 list.add(new String[] { nvItem.getName(), nvItem.getValue() });
1605 }
1606 }
1607 String[][] result = new String[list.size()][2];
1608 for (int i = 0; i < list.size(); i++) {
1609 result[i][0] = list.get(i)[0];
1610 result[i][1] = list.get(i)[1];
1611 }
1612 return result;
1613 }
1614
1615 /**
1616 * Retrieve flash definition file name
1617 *
1618 * @returns file name if elements are found at the known xpath
1619 * @returns null if nothing is there
1620 */
1621 public String getFlashDefinitionFile() {
1622 String[] xPath = new String[] { "/PlatformDefinitions/FlashDeviceDefinitions/FlashDefinitionFile" };
1623
1624 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1625 if (queryResult == null || queryResult.length == 0) {
1626 return null;
1627 }
1628
1629 FileNameConvention filename = (FileNameConvention) queryResult[queryResult.length - 1];
1630 return filename.getStringValue();
1631 }
1632
1633 public String[][] getFpdGlobalVariable() {
1634 String[] xPath = new String[] { "/Flash/FvImages/NameValue" };
1635 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1636 if (queryResult == null) {
1637 return new String[0][];
1638 }
1639
1640 String[][] result = new String[queryResult.length][2];
1641
1642 for (int i = 0; i < queryResult.length; i++) {
1643 FvImagesDocument.FvImages.NameValue item = (FvImagesDocument.FvImages.NameValue)queryResult[i];
1644 result[i][0] = item.getName();
1645 result[i][1] = item.getValue();
1646 }
1647 return result;
1648 }
1649
1650 /**
1651 * Retrieve FV image component options
1652 *
1653 * @param fvName
1654 * FV image name
1655 *
1656 * @returns name/value pairs list if elements are found at the known xpath
1657 * @returns empty list if nothing is there
1658 */
1659 public String[][] getFpdComponents(String fvName) {
1660 String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Components' and ./FvImageNames='"+ fvName + "']/FvImageOptions" };
1661 Object[] queryResult = get("PlatformSurfaceArea", xPath);
1662 if (queryResult == null) {
1663 return new String[0][];
1664 }
1665
1666 ArrayList<String[]> list = new ArrayList<String[]>();
1667 for (int i = 0; i < queryResult.length; i++) {
1668 FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];
1669 List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item.getNameValueList();
1670 Iterator iter = namevalues.iterator();
1671 while (iter.hasNext()) {
1672 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter
1673 .next();
1674 list.add(new String[] { nvItem.getName(), nvItem.getValue() });
1675 }
1676 }
1677 String[][] result = new String[list.size()][2];
1678 for (int i = 0; i < list.size(); i++) {
1679 result[i][0] = list.get(i)[0];
1680 result[i][1] = list.get(i)[1];
1681 }
1682 return result;
1683 }
1684
1685 /**
1686 * Retrieve PCD tokens
1687 *
1688 * @returns CName/ItemType pairs list if elements are found at the known
1689 * xpath
1690 * @returns null if nothing is there
1691 */
1692 public String[][] getPcdTokenArray() {
1693 String[] xPath = new String[] { "/PcdData" };
1694
1695 Object[] returns = get("PCDs", xPath);
1696 if (returns == null || returns.length == 0) {
1697 return null;
1698 }
1699
1700 return null;
1701 }
1702
1703 /**
1704 * Retrieve MAS header
1705 *
1706 * @return
1707 * @return
1708 */
1709 public ModuleIdentification getMsaHeader() {
1710 String[] xPath = new String[] { "/" };
1711 Object[] returns = get("MsaHeader", xPath);
1712
1713 if (returns == null || returns.length == 0) {
1714 return null;
1715 }
1716
1717 MsaHeader msaHeader = (MsaHeader) returns[0];
1718 //
1719 // Get BaseName, ModuleType, GuidValue, Version
1720 // which in MsaHeader.
1721 //
1722 String name = msaHeader.getModuleName();
1723 String moduleType = msaHeader.getModuleType().toString();
1724 String guid = msaHeader.getGuidValue();
1725 String version = msaHeader.getVersion();
1726
1727 ModuleIdentification moduleId = new ModuleIdentification(name, guid,
1728 version);
1729
1730 moduleId.setModuleType(moduleType);
1731
1732 return moduleId;
1733 }
1734
1735 /**
1736 * Retrieve Extern Specification
1737 *
1738 * @param
1739 *
1740 * @return String[] If have specification element in the <extern> String[0]
1741 * If no specification element in the <extern>
1742 *
1743 */
1744
1745 public String[] getExternSpecificaiton() {
1746 String[] xPath = new String[] { "/Specification" };
1747
1748 Object[] queryResult = get("Externs", xPath);
1749 if (queryResult == null) {
1750 return new String[0];
1751 }
1752
1753 String[] specificationList = new String[queryResult.length];
1754 for (int i = 0; i < queryResult.length; i++) {
1755 specificationList[i] = ((Sentence)queryResult[i])
1756 .getStringValue();
1757 }
1758 return specificationList;
1759 }
1760
1761 /**
1762 * Retreive MsaFile which in SPD
1763 *
1764 * @param
1765 * @return String[][3] The string sequence is ModuleName, ModuleGuid,
1766 * ModuleVersion, MsaFile String[0][] If no msafile in SPD
1767 */
1768 public String[] getSpdMsaFile() {
1769 String[] xPath = new String[] { "/MsaFiles" };
1770
1771 Object[] returns = get("PackageSurfaceArea", xPath);
1772 if (returns == null) {
1773 return new String[0];
1774 }
1775
1776 List<String> filenameList = ((MsaFilesDocument.MsaFiles) returns[0])
1777 .getFilenameList();
1778 return filenameList.toArray(new String[filenameList.size()]);
1779 }
1780
1781 /**
1782 * Reteive
1783 */
1784 public Map<String, String[]> getSpdLibraryClasses() {
1785 String[] xPath = new String[] { "/LibraryClassDeclarations/LibraryClass" };
1786
1787 Object[] returns = get("PackageSurfaceArea", xPath);
1788
1789 //
1790 // Create Map, Key - LibraryClass, String[] - LibraryClass Header file.
1791 //
1792 Map<String, String[]> libClassHeaderMap = new HashMap<String, String[]>();
1793
1794 if (returns == null) {
1795 return libClassHeaderMap;
1796 }
1797
1798 for (int i = 0; i < returns.length; i++) {
1799 LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass library = (LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass) returns[i];
1800 libClassHeaderMap.put(library.getName(), new String[] { library
1801 .getIncludeHeader() });
1802 }
1803 return libClassHeaderMap;
1804 }
1805
1806 /**
1807 * Reteive
1808 */
1809 public Map<String, String> getSpdPackageHeaderFiles() {
1810 String[] xPath = new String[] { "/PackageHeaders/IncludePkgHeader" };
1811
1812 Object[] returns = get("PackageSurfaceArea", xPath);
1813
1814 //
1815 // Create Map, Key - ModuleType, String - PackageInclude Header file.
1816 //
1817 Map<String, String> packageIncludeMap = new HashMap<String, String>();
1818
1819 if (returns == null) {
1820 return packageIncludeMap;
1821 }
1822
1823 for (int i = 0; i < returns.length; i++) {
1824 PackageHeadersDocument.PackageHeaders.IncludePkgHeader includeHeader = (PackageHeadersDocument.PackageHeaders.IncludePkgHeader) returns[i];
1825 packageIncludeMap.put(includeHeader.getModuleType().toString(),
1826 includeHeader.getStringValue());
1827 }
1828 return packageIncludeMap;
1829 }
1830
1831 public PackageIdentification getSpdHeader() {
1832 String[] xPath = new String[] { "/SpdHeader" };
1833
1834 Object[] returns = get("PackageSurfaceArea", xPath);
1835
1836 if (returns == null || returns.length == 0) {
1837 return null;
1838 }
1839
1840 SpdHeaderDocument.SpdHeader header = (SpdHeaderDocument.SpdHeader) returns[0];
1841
1842 String name = header.getPackageName();
1843
1844 String guid = header.getGuidValue();
1845
1846 String version = header.getVersion();
1847
1848 return new PackageIdentification(name, guid, version);
1849 }
1850
1851 /**
1852 * Reteive
1853 */
1854 public Map<String, String[]> getSpdGuid() {
1855 String[] xPath = new String[] { "/GuidDeclarations/Entry" };
1856
1857 Object[] returns = get("PackageSurfaceArea", xPath);
1858
1859 //
1860 // Create Map, Key - GuidName, String[] - C_NAME & GUID value.
1861 //
1862 Map<String, String[]> guidDeclMap = new HashMap<String, String[]>();
1863 if (returns == null) {
1864 return guidDeclMap;
1865 }
1866
1867 for (int i = 0; i < returns.length; i++) {
1868 GuidDeclarationsDocument.GuidDeclarations.Entry entry = (GuidDeclarationsDocument.GuidDeclarations.Entry) returns[i];
1869 String[] guidPair = new String[2];
1870 guidPair[0] = entry.getCName();
1871 guidPair[1] = entry.getGuidValue();
1872 guidDeclMap.put(entry.getCName(), guidPair);
1873 }
1874 return guidDeclMap;
1875 }
1876
1877 /**
1878 * Reteive
1879 */
1880 public Map<String, String[]> getSpdProtocol() {
1881 String[] xPath = new String[] { "/ProtocolDeclarations/Entry" };
1882
1883 Object[] returns = get("PackageSurfaceArea", xPath);
1884
1885 //
1886 // Create Map, Key - protocolName, String[] - C_NAME & GUID value.
1887 //
1888 Map<String, String[]> protoclMap = new HashMap<String, String[]>();
1889
1890 if (returns == null) {
1891 return protoclMap;
1892 }
1893
1894 for (int i = 0; i < returns.length; i++) {
1895 ProtocolDeclarationsDocument.ProtocolDeclarations.Entry entry = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry) returns[i];
1896 String[] protocolPair = new String[2];
1897
1898 protocolPair[0] = entry.getCName();
1899 protocolPair[1] = entry.getGuidValue();
1900 protoclMap.put(entry.getCName(), protocolPair);
1901 }
1902 return protoclMap;
1903 }
1904
1905 /**
1906 * getSpdPpi() Retrieve the SPD PPI Entry
1907 *
1908 * @param
1909 * @return Map<String, String[2]> if get the PPI entry from SPD. Key - PPI
1910 * Name String[0] - PPI CNAME String[1] - PPI Guid Null if no PPI
1911 * entry in SPD.
1912 */
1913 public Map<String, String[]> getSpdPpi() {
1914 String[] xPath = new String[] { "/PpiDeclarations/Entry" };
1915
1916 Object[] returns = get("PackageSurfaceArea", xPath);
1917
1918 //
1919 // Create Map, Key - protocolName, String[] - C_NAME & GUID value.
1920 //
1921 Map<String, String[]> ppiMap = new HashMap<String, String[]>();
1922
1923 if (returns == null) {
1924 return ppiMap;
1925 }
1926
1927 for (int i = 0; i < returns.length; i++) {
1928 PpiDeclarationsDocument.PpiDeclarations.Entry entry = (PpiDeclarationsDocument.PpiDeclarations.Entry) returns[i];
1929 String[] ppiPair = new String[2];
1930 ppiPair[0] = entry.getCName();
1931 ppiPair[1] = entry.getGuidValue();
1932 ppiMap.put(entry.getCName(), ppiPair);
1933 }
1934 return ppiMap;
1935 }
1936
1937 /**
1938 * Retrieve module Guid string
1939 *
1940 * @returns GUILD string if elements are found at the known xpath
1941 * @returns null if nothing is there
1942 */
1943 public String getModuleGuid() {
1944 String[] xPath = new String[] { "" };
1945
1946 Object[] returns = get("MsaHeader", xPath);
1947 if (returns != null && returns.length > 0) {
1948 String guid = ((MsaHeaderDocument.MsaHeader) returns[0])
1949 .getGuidValue();
1950 return guid;
1951 }
1952
1953 return null;
1954 }
1955
1956 //
1957 // For new Pcd
1958 //
1959 public ModuleSADocument.ModuleSA[] getFpdModuleSAs() {
1960 String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };
1961 Object[] result = get("PlatformSurfaceArea", xPath);
1962 if (result != null) {
1963 return (ModuleSADocument.ModuleSA[]) result;
1964 }
1965 return new ModuleSADocument.ModuleSA[0];
1966
1967 }
1968
1969 /**
1970 Get name array who contains all PCDs in a module according to specified arch.
1971
1972 @param arch The specified architecture type.
1973
1974 @return String[] return all PCDs name into array, if no any PCD used by
1975 this module, a String[0] array is returned.
1976 **/
1977 public String[] getModulePcdEntryNameArray(String arch) {
1978 PcdCodedDocument.PcdCoded.PcdEntry[] pcdEntries = null;
1979 java.util.List archList = null;
1980 java.util.List<String> results = new java.util.ArrayList<String> ();
1981 int index;
1982 String[] xPath = new String[] {"/PcdEntry"};
1983 Object[] returns = get ("PcdCoded", xPath);
1984
1985 if (returns == null) {
1986 return new String[0];
1987 }
1988
1989 pcdEntries = (PcdCodedDocument.PcdCoded.PcdEntry[])returns;
1990
1991 for (index = 0; index < pcdEntries.length; index ++) {
1992 archList = pcdEntries[index].getSupArchList();
1993 //
1994 // If the ArchList is specified in MSA for this PCD, need check
1995 // current arch whether can support by this PCD.
1996 //
1997 if (archList != null) {
1998 if (archList.contains(arch)) {
1999 results.add(new String(pcdEntries[index].getCName()));
2000 }
2001 } else {
2002 //
2003 // If no ArchList is specificied in MSA for this PCD, that means
2004 // this PCD support all architectures.
2005 //
2006 results.add(new String(pcdEntries[index].getCName()));
2007 }
2008 }
2009
2010 if (results.size() == 0) {
2011 return new String[0];
2012 }
2013
2014 String[] retArray = new String[results.size()];
2015 results.toArray(retArray);
2016
2017 return retArray;
2018 }
2019
2020 /**
2021 Search in a List for a given string
2022
2023 @return boolean
2024 **/
2025 public boolean contains(List list, String str) {
2026 if (list == null || list.size()== 0) {
2027 return true;
2028 }
2029
2030 return list.contains(str);
2031 }
2032
2033 public boolean isHaveTianoR8FlashMap(){
2034 String[] xPath = new String[] {"/"};
2035 Object[] returns = get ("Externs", xPath);
2036
2037 if (returns == null) {
2038 return false;
2039 }
2040
2041 ExternsDocument.Externs ext = (ExternsDocument.Externs)returns[0];
2042
2043 if (ext.getTianoR8FlashMapH()){
2044 return true;
2045 }else {
2046 return false;
2047 }
2048 }
2049
2050 public Node getPeiApriori(String fvName) {
2051 String[] xPath = new String[] { "/BuildOptions/UserExtensions[@UserID='APRIORI' and @Identifier='0' and ./FvName='" + fvName + "']" };
2052 Object[] result = get("PlatformSurfaceArea", xPath);
2053
2054 if (result == null || result.length == 0) {
2055 return null;
2056 }
2057
2058 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)result[0];
2059
2060 return a.getDomNode();
2061 }
2062
2063 public Node getDxeApriori(String fvName) {
2064 String[] xPath = new String[] { "/BuildOptions/UserExtensions[@UserID='APRIORI' and @Identifier='1' and ./FvName='" + fvName + "']" };
2065 Object[] result = get("PlatformSurfaceArea", xPath);
2066
2067 if (result == null || result.length == 0) {
2068 return null;
2069 }
2070
2071 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)result[0];
2072
2073 return a.getDomNode();
2074 }
2075
2076 public Node getFpdModuleSequence(String fvName) {
2077 String[] xPath = new String[] { "/BuildOptions/UserExtensions[@UserID='IMAGES' and @Identifier='1' and ./FvName='" + fvName + "']" };
2078 Object[] result = get("PlatformSurfaceArea", xPath);
2079
2080 if (result == null || result.length == 0) {
2081 return null;
2082 }
2083
2084 UserExtensionsDocument.UserExtensions a = (UserExtensionsDocument.UserExtensions)result[0];
2085
2086 return a.getDomNode();
2087 }
2088
2089 /**
2090 Get the value of PCD by PCD cName
2091
2092 @return PcdValue String of PcdComponentName
2093 null If don't find ComponentName Pcd
2094 **/
2095 public String getPcdValueBycName(String cName){
2096 String[] xPath = new String[] { "/PcdData" };
2097 Object[] returns = get("PcdBuildDefinition", xPath);
2098 if (returns == null || returns.length == 0) {
2099 return null;
2100 }
2101 for (int i = 0; i < returns.length; i++) {
2102 PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)returns[i];
2103 if (pcdData.getCName().equalsIgnoreCase(cName)){
2104 return pcdData.getValue();
2105 }
2106 }
2107 return null;
2108 }
2109 }