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