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