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