11a278326a8f35114d3339233f655a40995f5c05
[mirror_edk2.git] / Tools / Source / FrameworkWizard / src / org / tianocore / frameworkwizard / platform / ui / 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.frameworkwizard.platform.ui.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.Set;
23 import java.util.Stack;
24 import java.util.regex.Matcher;
25 import java.util.regex.Pattern;
26
27 import org.apache.xmlbeans.XmlNormalizedString;
28 import org.apache.xmlbeans.XmlObject;
29 import org.apache.xmlbeans.XmlString;
30 import org.tianocore.BuildTargetList;
31 import org.tianocore.DataIdDocument;
32 import org.tianocore.ExternsDocument;
33 import org.tianocore.FileNameConvention;
34 //import org.tianocore.FvImageDocument;
35 import org.tianocore.GuidDeclarationsDocument;
36 import org.tianocore.LibrariesDocument;
37 import org.tianocore.LibraryClassDeclarationsDocument;
38 import org.tianocore.LibraryClassDocument;
39 import org.tianocore.ModuleSADocument;
40 import org.tianocore.ModuleTypeDef;
41 import org.tianocore.MsaFilesDocument;
42 import org.tianocore.MsaHeaderDocument;
43 import org.tianocore.PackageDependenciesDocument;
44 import org.tianocore.PackageHeadersDocument;
45 import org.tianocore.PpiDeclarationsDocument;
46 import org.tianocore.ProtocolDeclarationsDocument;
47 import org.tianocore.SpdHeaderDocument;
48 import org.tianocore.FilenameDocument.Filename;
49 import org.tianocore.MsaHeaderDocument.MsaHeader;
50 import org.tianocore.PlatformHeaderDocument;
51 import org.tianocore.frameworkwizard.platform.ui.id.FpdModuleIdentification;
52 import org.tianocore.frameworkwizard.platform.ui.id.ModuleIdentification;
53 import org.tianocore.frameworkwizard.platform.ui.id.PackageIdentification;
54 import org.tianocore.frameworkwizard.platform.ui.id.PlatformIdentification;
55
56 /**
57 * SurfaceAreaQuery class is used to query Surface Area information from msa,
58 * mbd, spd and fpd files.
59 *
60 * This class should not instantiated. All the public interfaces is static.
61 *
62 * @since GenBuild 1.0
63 */
64 public class SurfaceAreaQuery {
65
66 public static String prefix = "http://www.TianoCore.org/2006/Edk2.0";
67
68 // /
69 // / Contains name/value pairs of Surface Area document object. The name is
70 // / always the top level element name.
71 // /
72 private static Map<String, XmlObject> map = null;
73
74 // /
75 // / mapStack is used to do nested query
76 // /
77 private static Stack<Map<String, XmlObject>> mapStack = new Stack<Map<String, XmlObject>>();
78
79 // /
80 // / prefix of name space
81 // /
82 private static String nsPrefix = "sans";
83
84 // /
85 // / xmlbeans needs a name space for each Xpath element
86 // /
87 private static String ns = null;
88
89 // /
90 // / keep the namep declaration for xmlbeans Xpath query
91 // /
92 private static String queryDeclaration = null;
93
94 /**
95 * Set a Surface Area document for query later
96 *
97 * @param map
98 * A Surface Area document in TopLevelElementName/XmlObject
99 * format.
100 */
101 public static void setDoc(Map<String, XmlObject> map) {
102 ns = prefix;
103 queryDeclaration = "declare namespace " + nsPrefix + "='" + ns + "'; ";
104 SurfaceAreaQuery.map = map;
105 }
106
107 /**
108 * Push current used Surface Area document into query stack. The given new
109 * document will be used for any immediately followed getXXX() callings,
110 * untill pop() is called.
111 *
112 * @param newMap
113 * The TopLevelElementName/XmlObject format of a Surface Area
114 * document.
115 */
116 public static void push(Map<String, XmlObject> newMap) {
117 mapStack.push(SurfaceAreaQuery.map);
118 SurfaceAreaQuery.map = newMap;
119 }
120
121 /**
122 * Discard current used Surface Area document and use the top document in
123 * stack instead.
124 */
125 public static void pop() {
126 SurfaceAreaQuery.map = mapStack.pop();
127 }
128
129 // /
130 // / Convert xPath to be namespace qualified, which is necessary for
131 // XmlBeans
132 // / selectPath(). For example, converting /MsaHeader/ModuleType to
133 // / /ns:MsaHeader/ns:ModuleType
134 // /
135 private static String normalizeQueryString(String[] exp, String from) {
136 StringBuffer normQueryString = new StringBuffer(4096);
137
138 int i = 0;
139 while (i < exp.length) {
140 String newExp = from + exp[i];
141 Pattern pattern = Pattern.compile("([^/]*)(/|//)([^/]+)");
142 Matcher matcher = pattern.matcher(newExp);
143
144 while (matcher.find()) {
145 String starter = newExp.substring(matcher.start(1), matcher
146 .end(1));
147 String seperator = newExp.substring(matcher.start(2), matcher
148 .end(2));
149 String token = newExp.substring(matcher.start(3), matcher
150 .end(3));
151
152 normQueryString.append(starter);
153 normQueryString.append(seperator);
154 normQueryString.append(nsPrefix);
155 normQueryString.append(":");
156 normQueryString.append(token);
157 }
158
159 ++i;
160 if (i < exp.length) {
161 normQueryString.append(" | ");
162 }
163 }
164
165 return normQueryString.toString();
166 }
167
168 /**
169 * Search all XML documents stored in "map" for the specified xPath, using
170 * relative path (starting with '$this')
171 *
172 * @param xPath
173 * xpath query string array
174 * @returns An array of XmlObject if elements are found at the specified
175 * xpath
176 * @returns NULL if nothing is at the specified xpath
177 */
178 public static XmlObject[] get(String[] xPath) {
179 if (map == null) {
180 return null;
181 }
182
183 String[] keys = (String[]) map.keySet().toArray(new String[map.size()]);
184 List<XmlObject> result = new ArrayList<XmlObject>();
185 for (int i = 0; i < keys.length; ++i) {
186 XmlObject rootNode = (XmlObject) map.get(keys[i]);
187 if (rootNode == null) {
188 continue;
189 }
190
191 String query = queryDeclaration
192 + normalizeQueryString(xPath, "$this/" + keys[i]);
193 XmlObject[] tmp = rootNode.selectPath(query);
194 for (int j = 0; j < tmp.length; ++j) {
195 result.add(tmp[j]);
196 }
197 }
198
199 int size = result.size();
200 if (size <= 0) {
201 return null;
202 }
203
204 return (XmlObject[]) result.toArray(new XmlObject[size]);
205 }
206
207 /**
208 * Search XML documents named by "rootName" for the given xPath, using
209 * relative path (starting with '$this')
210 *
211 * @param rootName
212 * The top level element name
213 * @param xPath
214 * The xpath query string array
215 * @returns An array of XmlObject if elements are found at the given xpath
216 * @returns NULL if nothing is found at the given xpath
217 */
218 public static XmlObject[] get(String rootName, String[] xPath) {
219 if (map == null) {
220 return null;
221 }
222
223 XmlObject root = (XmlObject) map.get(rootName);
224 if (root == null) {
225 return null;
226 }
227
228 String query = queryDeclaration
229 + normalizeQueryString(xPath, "$this/" + rootName);
230 XmlObject[] result = root.selectPath(query);
231 if (result.length > 0) {
232 return result;
233 }
234
235 query = queryDeclaration + normalizeQueryString(xPath, "/" + rootName);
236 result = root.selectPath(query);
237 if (result.length > 0) {
238 return result;
239 }
240
241 return null;
242 }
243
244 /**
245 * Retrieve SourceFiles/Filename for specified ARCH type
246 *
247 * @param arch
248 * architecture name
249 * @returns An 2 dimension string array if elements are found at the known
250 * xpath
251 * @returns NULL if nothing is found at the known xpath
252 */
253 public static String[][] getSourceFiles(String arch) {
254 String[] xPath;
255 XmlObject[] returns;
256
257 if (arch == null || arch.equals("")) {
258 xPath = new String[] { "/Filename" };
259 } else {
260 xPath = new String[] { "/Filename[not(@SupArchList) or @SupArchList='"
261 + arch + "']" };
262 }
263
264 returns = get("SourceFiles", xPath);
265
266 if (returns == null || returns.length == 0) {
267 return null;
268 }
269
270 Filename[] sourceFileNames = (Filename[]) returns;
271 String[][] outputString = new String[sourceFileNames.length][2];
272 for (int i = 0; i < sourceFileNames.length; i++) {
273 outputString[i][0] = sourceFileNames[i].getToolCode();
274 outputString[i][1] = sourceFileNames[i].getStringValue();
275 }
276 return outputString;
277 }
278
279 /**
280 * Retrieve /PlatformDefinitions/OutputDirectory from FPD
281 *
282 * @returns Directory names array if elements are found at the known xpath
283 * @returns Empty if nothing is found at the known xpath
284 */
285 public static String getFpdOutputDirectory() {
286 String[] xPath = new String[] { "/PlatformDefinitions/OutputDirectory" };
287
288 XmlObject[] returns = get("FrameworkPlatformDescription", xPath);
289 if (returns != null && returns.length > 0) {
290 // String TBD
291 }
292
293 return null;
294 }
295
296 public static String getFpdIntermediateDirectories() {
297 String[] xPath = new String[] { "/PlatformDefinitions/IntermediateDirectories" };
298
299 XmlObject[] returns = get("FrameworkPlatformDescription", xPath);
300 if (returns != null && returns.length > 0) {
301 // TBD
302 }
303 return "UNIFIED";
304 }
305
306 public static String getBuildTarget() {
307 String[] xPath = new String[] { "/PlatformDefinitions/BuildTargets" };
308
309 XmlObject[] returns = get("FrameworkPlatformDescription", xPath);
310 if (returns != null && returns.length > 0) {
311 return ((BuildTargetList) returns[0]).getStringValue();
312 }
313
314 return null;
315 }
316
317 /**
318 * Retrieve <xxxHeader>/ModuleType
319 *
320 * @returns The module type name if elements are found at the known xpath
321 * @returns null if nothing is there
322 */
323 public static String getModuleType() {
324 String[] xPath = new String[] { "/ModuleType" };
325
326 XmlObject[] returns = get(xPath);
327 if (returns != null && returns.length > 0) {
328 ModuleTypeDef type = (ModuleTypeDef) returns[0];
329 return type.enumValue().toString();
330 }
331
332 return null;
333 }
334
335 /**
336 * Retrieve PackageDependencies/Package
337 *
338 * @param arch
339 * Architecture name
340 *
341 * @returns package name list if elements are found at the known xpath
342 * @returns null if nothing is there
343 */
344 public static PackageIdentification[] getDependencePkg(String arch) {
345 String[] xPath;
346 String packageGuid = null;
347 String packageVersion = null;
348
349 if (arch == null || arch.equals("")) {
350 xPath = new String[] { "/PackageDependencies/Package" };
351 } else {
352 xPath = new String[] { "/PackageDependencies/Package[not(@SupArchList) or @SupArchList='"
353 + arch + "']" };
354 }
355
356 XmlObject[] returns = get("ModuleSurfaceArea", xPath);
357 if (returns == null) {
358 return new PackageIdentification[0];
359 }
360 PackageIdentification[] packageIdList = new PackageIdentification[returns.length];
361 for (int i = 0; i < returns.length; i++) {
362 PackageDependenciesDocument.PackageDependencies.Package item = (PackageDependenciesDocument.PackageDependencies.Package) returns[i];
363 packageGuid = item.getPackageGuid();
364 packageVersion = item.getPackageVersion();
365
366 Set<PackageIdentification> spi = GlobalData.getPackageList();
367 Iterator<PackageIdentification> ispi = spi.iterator();
368 String ver = "";
369 while(ispi.hasNext()) {
370 PackageIdentification pi = ispi.next();
371 if (packageVersion != null) {
372 if (pi.getGuid().equalsIgnoreCase(packageGuid) && pi.getVersion().equals(packageVersion)) {
373 packageIdList[i] = pi;
374 break;
375 }
376 }
377 else {
378 if (pi.getGuid().equalsIgnoreCase(packageGuid)) {
379 if (pi.getVersion() != null && pi.getVersion().compareTo(ver) > 0){
380 ver = pi.getVersion();
381 packageIdList[i] = pi;
382 }
383 else if (packageIdList[i] == null){
384 packageIdList[i] = pi;
385 }
386 }
387 }
388
389 }
390 }
391 return packageIdList;
392 }
393
394 /**
395 * Retrieve LibraryClassDefinitions/LibraryClass for specified usage
396 *
397 * @param usage
398 * Library class usage
399 *
400 * @returns LibraryClass objects list if elements are found at the known
401 * xpath
402 * @returns null if nothing is there
403 */
404 public static String[] getLibraryClasses(String usage) {
405 String[] xPath;
406
407 if (usage == null || usage.equals("")) {
408 xPath = new String[] { "/LibraryClass" };
409 } else {
410 xPath = new String[] { "/LibraryClass[@Usage='" + usage + "']" };
411 }
412
413 XmlObject[] returns = get("LibraryClassDefinitions", xPath);
414 if (returns == null || returns.length == 0) {
415 return new String[0];
416 }
417
418 LibraryClassDocument.LibraryClass[] libraryClassList = (LibraryClassDocument.LibraryClass[]) returns;
419 String[] libraryClassName = new String[libraryClassList.length];
420 for (int i = 0; i < libraryClassList.length; i++) {
421 libraryClassName[i] = libraryClassList[i].getKeyword();
422 }
423 return libraryClassName;
424 }
425
426 /**
427 * Retrieve ModuleEntryPoint names
428 *
429 * @returns ModuleEntryPoint name list if elements are found at the known
430 * xpath
431 * @returns null if nothing is there
432 */
433 public static String[] getModuleEntryPointArray() {
434 String[] xPath = new String[] { "/Extern/ModuleEntryPoint" };
435
436 XmlObject[] returns = get("Externs", xPath);
437
438 if (returns != null && returns.length > 0) {
439 String[] entryPoints = new String[returns.length];
440
441 for (int i = 0; i < returns.length; ++i) {
442 entryPoints[i] = ((XmlNormalizedString) returns[i])
443 .getStringValue();
444 }
445
446 return entryPoints;
447 }
448
449 return null;
450 }
451
452
453
454
455 /**
456 * Retrieve ModuleUnloadImage names
457 *
458 * @returns ModuleUnloadImage name list if elements are found at the known
459 * xpath
460 * @returns null if nothing is there
461 */
462 public static String[] getModuleUnloadImageArray() {
463 String[] xPath = new String[] { "/Extern/ModuleUnloadImage" };
464
465 XmlObject[] returns = get("Externs", xPath);
466 if (returns != null && returns.length > 0) {
467 String[] stringArray = new String[returns.length];
468 XmlNormalizedString[] doc = (XmlNormalizedString[]) returns;
469
470 for (int i = 0; i < returns.length; ++i) {
471 stringArray[i] = doc[i].getStringValue();
472 }
473
474 return stringArray;
475 }
476
477 return null;
478 }
479
480 /**
481 * Retrieve Extern
482 *
483 * @returns Extern objects list if elements are found at the known xpath
484 * @returns null if nothing is there
485 */
486 public static ExternsDocument.Externs.Extern[] getExternArray() {
487 String[] xPath = new String[] { "/Extern" };
488
489 XmlObject[] returns = get("Externs", xPath);
490 if (returns != null && returns.length > 0) {
491 return (ExternsDocument.Externs.Extern[]) returns;
492 }
493
494 return null;
495 }
496
497 /**
498 * Retrieve Library instance information
499 *
500 * @param arch
501 * Architecture name
502 * @param usage
503 * Library instance usage
504 *
505 * @returns library instance name list if elements are found at the known
506 * xpath
507 * @returns null if nothing is there
508 */
509 public static ModuleIdentification[] getLibraryInstance(String arch) {
510 String[] xPath;
511 String saGuid = null;
512 String saVersion = null;
513 String pkgGuid = null;
514 String pkgVersion = null;
515
516 if (arch == null || arch.equalsIgnoreCase("")) {
517 xPath = new String[] { "/Instance" };
518 } else {
519 xPath = new String[] { "/Instance[not(@SupArchList) or @SupArchList='"
520 + arch + "']" };
521 }
522
523 XmlObject[] returns = get("Libraries", xPath);
524 if (returns == null || returns.length == 0) {
525 return new ModuleIdentification[0];
526 }
527
528 ModuleIdentification[] saIdList = new ModuleIdentification[returns.length];
529 for (int i = 0; i < returns.length; i++) {
530 LibrariesDocument.Libraries.Instance library = (LibrariesDocument.Libraries.Instance) returns[i];
531 saGuid = library.getModuleGuid();
532 saVersion = library.getModuleVersion();
533
534 pkgGuid = library.getPackageGuid();
535 pkgVersion = library.getPackageVersion();
536
537 ModuleIdentification saId = new ModuleIdentification(null, saGuid,
538 saVersion);
539 PackageIdentification pkgId = new PackageIdentification(null,
540 pkgGuid, pkgVersion);
541 saId.setPackage(pkgId);
542
543 saIdList[i] = saId;
544
545 }
546 return saIdList;
547 }
548
549 // /
550 // / This method is used for retrieving the elements information which has
551 // / CName sub-element
552 // /
553 private static String[] getCNames(String from, String xPath[]) {
554 XmlObject[] returns = get(from, xPath);
555 if (returns == null || returns.length == 0) {
556 return null;
557 }
558
559 String[] strings = new String[returns.length];
560 for (int i = 0; i < returns.length; ++i) {
561 // TBD
562 // strings[i] = ((CName) returns[i]).getStringValue();
563 }
564
565 return strings;
566 }
567
568 /**
569 * Retrive library's constructor name
570 *
571 * @returns constructor name list if elements are found at the known xpath
572 * @returns null if nothing is there
573 */
574 public static String getLibConstructorName() {
575 String[] xPath = new String[] { "/Extern/Constructor" };
576
577 XmlObject[] returns = get("Externs", xPath);
578 if (returns != null && returns.length > 0) {
579 // CName constructor = (CName) returns[0];
580 // return constructor.getStringValue();
581 }
582
583 return null;
584 }
585
586 /**
587 * Retrive library's destructor name
588 *
589 * @returns destructor name list if elements are found at the known xpath
590 * @returns null if nothing is there
591 */
592 public static String getLibDestructorName() {
593 String[] xPath = new String[] { "/Extern/Destructor" };
594
595 XmlObject[] returns = get("Externs", xPath);
596 if (returns != null && returns.length > 0) {
597 // CName destructor = (CName) returns[0];
598 // return destructor.getStringValue();
599 }
600
601 return null;
602 }
603
604 /**
605 * Retrive DriverBinding names
606 *
607 * @returns DriverBinding name list if elements are found at the known xpath
608 * @returns null if nothing is there
609 */
610 public static String[] getDriverBindingArray() {
611 String[] xPath = new String[] { "/Extern/DriverBinding" };
612 return getCNames("Externs", xPath);
613 }
614
615 /**
616 * Retrive ComponentName names
617 *
618 * @returns ComponentName name list if elements are found at the known xpath
619 * @returns null if nothing is there
620 */
621 public static String[] getComponentNameArray() {
622 String[] xPath = new String[] { "/Extern/ComponentName" };
623 return getCNames("Externs", xPath);
624 }
625
626 /**
627 * Retrive DriverConfig names
628 *
629 * @returns DriverConfig name list if elements are found at the known xpath
630 * @returns null if nothing is there
631 */
632 public static String[] getDriverConfigArray() {
633 String[] xPath = new String[] { "/Extern/DriverConfig" };
634 return getCNames("Externs", xPath);
635 }
636
637 /**
638 * Retrive DriverDiag names
639 *
640 * @returns DriverDiag name list if elements are found at the known xpath
641 * @returns null if nothing is there
642 */
643 public static String[] getDriverDiagArray() {
644 String[] xPath = new String[] { "/Extern/DriverDiag" };
645 return getCNames("Externs", xPath);
646 }
647
648 /**
649 * Retrive SetVirtualAddressMapCallBack names
650 *
651 * @returns SetVirtualAddressMapCallBack name list if elements are found at
652 * the known xpath
653 * @returns null if nothing is there
654 */
655 public static String[] getSetVirtualAddressMapCallBackArray() {
656 String[] xPath = new String[] { "/Extern/SetVirtualAddressMapCallBack" };
657 return getCNames("Externs", xPath);
658 }
659
660 /**
661 * Retrive ExitBootServicesCallBack names
662 *
663 * @returns ExitBootServicesCallBack name list if elements are found at the
664 * known xpath
665 * @returns null if nothing is there
666 */
667 public static String[] getExitBootServicesCallBackArray() {
668 String[] xPath = new String[] { "/Extern/ExitBootServicesCallBack" };
669 return getCNames("Externs", xPath);
670 }
671
672 /**
673 * Retrieve module surface area file information
674 *
675 * @returns ModuleSA objects list if elements are found at the known xpath
676 * @returns Empty ModuleSA list if nothing is there
677 */
678 public static Map<FpdModuleIdentification, Map<String, XmlObject>> getFpdModules() {
679 String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };
680 XmlObject[] result = get("FrameworkPlatformDescription", xPath);
681 String arch = null;
682 String fvBinding = null;
683 String saGuid = null;
684 String saVersion = null;
685 String pkgGuid = null;
686 String pkgVersion = null;
687
688 Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleMap = new LinkedHashMap<FpdModuleIdentification, Map<String, XmlObject>>();
689
690 if (result == null) {
691 return fpdModuleMap;
692 }
693
694 for (int i = 0; i < result.length; i++) {
695 //
696 // Get Fpd SA Module element node and add to xmlObjectMap.
697 //
698 Map<String, XmlObject> xmlObjectMap = new HashMap<String, XmlObject>();
699 ModuleSADocument.ModuleSA moduleSA = (ModuleSADocument.ModuleSA) result[i];
700 if (((ModuleSADocument.ModuleSA) result[i]).getLibraries() != null) {
701 xmlObjectMap.put("Libraries", moduleSA.getLibraries());
702 }
703 if (((ModuleSADocument.ModuleSA) result[i]).getPcdBuildDefinition() != null) {
704 xmlObjectMap.put("PcdBuildDefinition", moduleSA
705 .getPcdBuildDefinition());
706 }
707 if (((ModuleSADocument.ModuleSA) result[i])
708 .getModuleSaBuildOptions() != null) {
709 xmlObjectMap.put("ModuleSaBuildOptions", moduleSA
710 .getModuleSaBuildOptions());
711 }
712
713 //
714 // Get Fpd SA Module attribute and create FpdMoudleIdentification.
715 //
716 arch = moduleSA.getSupArchList().toString();
717
718 // TBD
719 fvBinding = null;
720 saVersion = ((ModuleSADocument.ModuleSA) result[i])
721 .getModuleVersion();
722
723 saGuid = moduleSA.getModuleGuid();
724 pkgGuid = moduleSA.getPackageGuid();
725 pkgVersion = moduleSA.getPackageVersion();
726
727 //
728 // Create Module Identification which have class member of package
729 // identification.
730 //
731 PackageIdentification pkgId = new PackageIdentification(null,
732 pkgGuid, pkgVersion);
733 ModuleIdentification saId = new ModuleIdentification(null, saGuid,
734 saVersion);
735
736 saId.setPackage(pkgId);
737
738 //
739 // Create FpdModule Identification which have class member of module
740 // identification
741 //
742 FpdModuleIdentification fpdSaId = new FpdModuleIdentification(saId,
743 arch);
744 if (arch != null) {
745 fpdSaId.setArch(arch);
746 }
747 if (fvBinding != null) {
748 fpdSaId.setFvBinding(fvBinding);
749 }
750
751 //
752 // Put element to Map<FpdModuleIdentification, Map<String,
753 // XmlObject>>.
754 //
755 fpdModuleMap.put(fpdSaId, xmlObjectMap);
756 }
757 return fpdModuleMap;
758 }
759
760 /**
761 * Retrieve valid image names
762 *
763 * @returns valid iamges name list if elements are found at the known xpath
764 * @returns empty list if nothing is there
765 */
766 public static String[] getFpdValidImageNames() {
767 String[] xPath = new String[] { "/PlatformDefinitions/FlashDeviceDefinitions/FvImages/FvImage[@Type='ValidImageNames']/FvImageNames" };
768
769 XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);
770 if (queryResult == null) {
771 return new String[0];
772 }
773
774 String[] result = new String[queryResult.length];
775 for (int i = 0; i < queryResult.length; i++) {
776 result[i] = ((XmlString) queryResult[i]).getStringValue();
777 }
778
779 return result;
780 }
781
782
783
784 public static XmlObject getFpdBuildOptions() {
785 String[] xPath = new String[] { "/BuildOptions" };
786
787 XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);
788
789 if (queryResult == null || queryResult.length == 0) {
790 return null;
791 }
792 return queryResult[0];
793 }
794
795 public static PlatformIdentification getFpdHeader() {
796 String[] xPath = new String[] { "/PlatformHeader" };
797
798 XmlObject[] returns = get("FrameworkPlatformDescription", xPath);
799
800 if (returns == null || returns.length == 0) {
801 return null;
802 }
803 PlatformHeaderDocument.PlatformHeader header = (PlatformHeaderDocument.PlatformHeader) returns[0];
804
805 String name = header.getPlatformName();
806
807 String guid = header.getGuidValue();
808
809 String version = header.getVersion();
810
811 return new PlatformIdentification(name, guid, version);
812 }
813
814 /**
815 * Retrieve flash definition file name
816 *
817 * @returns file name if elements are found at the known xpath
818 * @returns null if nothing is there
819 */
820 public static String getFlashDefinitionFile() {
821 String[] xPath = new String[] { "/PlatformDefinitions/FlashDeviceDefinitions/FlashDefinitionFile" };
822
823 XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);
824 if (queryResult == null || queryResult.length == 0) {
825 return null;
826 }
827
828 FileNameConvention filename = (FileNameConvention) queryResult[queryResult.length - 1];
829 return filename.getStringValue();
830 }
831
832 /**
833 * Retrieve FV image component options
834 *
835 * @param fvName
836 * FV image name
837 *
838 * @returns name/value pairs list if elements are found at the known xpath
839 * @returns empty list if nothing is there
840 */
841 public static String[][] getFpdComponents(String fvName) {
842 String[] xPath = new String[] { "/PlatformDefinitions/FlashDeviceDefinitions/DataRegions/FvDataRegion[@Name='"
843 + fvName.toUpperCase() + "']/DataId" };
844
845 XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);
846 if (queryResult == null) {
847 return new String[0][];
848 }
849
850 ArrayList<String[]> list = new ArrayList<String[]>();
851 for (int i = 0; i < queryResult.length; i++) {
852 DataIdDocument.DataId item = (DataIdDocument.DataId) queryResult[i];
853 list
854 .add(new String[] { item.getStringValue(),
855 item.getDataSize() });
856 }
857
858 String[][] result = new String[list.size()][2];
859 for (int i = 0; i < list.size(); i++) {
860 result[i][0] = list.get(i)[0];
861 result[i][1] = list.get(i)[1];
862 }
863
864 return result;
865 }
866
867 /**
868 * Retrieve PCD tokens
869 *
870 * @returns CName/ItemType pairs list if elements are found at the known
871 * xpath
872 * @returns null if nothing is there
873 */
874 public static String[][] getPcdTokenArray() {
875 String[] xPath = new String[] { "/PcdData" };
876
877 XmlObject[] returns = get("PCDs", xPath);
878 if (returns == null || returns.length == 0) {
879 return null;
880 }
881
882 // PcdCoded.PcdData[] pcds = (PcdCoded.PcdData[]) returns;
883 // String[][] result = new String[pcds.length][2];
884 // for (int i = 0; i < returns.length; ++i) {
885 // if (pcds[i].getItemType() != null) {
886 // result[i][1] = pcds[i].getItemType().toString();
887 // } else {
888 // result[i][1] = null;
889 // }
890 // result[i][0] = pcds[i].getCName();
891 // }
892
893 return null;
894 }
895
896
897
898 /**
899 * Retrieve MSA header
900 *
901 * @return
902 * @return
903 */
904 public static ModuleIdentification getMsaHeader() {
905 String[] xPath = new String[] { "/" };
906 XmlObject[] returns = get("MsaHeader", xPath);
907
908 if (returns == null || returns.length == 0) {
909 return null;
910 }
911
912 MsaHeader msaHeader = (MsaHeader) returns[0];
913 //
914 // Get BaseName, ModuleType, GuidValue, Version
915 // which in MsaHeader.
916 //
917 String name = msaHeader.getModuleName();
918 String moduleType = "";
919 if (msaHeader.getModuleType() != null) {
920 moduleType = msaHeader.getModuleType().toString();
921 }
922
923 String guid = msaHeader.getGuidValue();
924 String version = msaHeader.getVersion();
925
926 ModuleIdentification moduleId = new ModuleIdentification(name, guid,
927 version);
928
929 moduleId.setModuleType(moduleType);
930
931 return moduleId;
932 }
933
934 /**
935 * Retrieve Extern Specification
936 *
937 * @param
938 *
939 * @return String[] If have specification element in the <extern> String[0]
940 * If no specification element in the <extern>
941 *
942 */
943
944 public static String[] getExternSpecificaiton() {
945 String[] xPath = new String[] { "/Specification" };
946
947 XmlObject[] queryResult = get("Externs", xPath);
948 if (queryResult == null) {
949 return new String[0];
950 }
951
952 String[] specificationList = new String[queryResult.length];
953 for (int i = 0; i < queryResult.length; i++) {
954 // specificationList[i] = ((SpecificationDocument.Specification)
955 // queryResult[i])
956 // .getStringValue();
957 }
958 return specificationList;
959 }
960
961 /**
962 * Retreive MsaFile which in SPD
963 *
964 * @param
965 * @return String[][3] The string sequence is ModuleName, ModuleGuid,
966 * ModuleVersion, MsaFile String[0][] If no msafile in SPD
967 */
968 public static String[] getSpdMsaFile() {
969 String[] xPath = new String[] { "/MsaFiles" };
970
971 XmlObject[] returns = get("PackageSurfaceArea", xPath);
972 if (returns == null) {
973 return new String[0];
974 }
975
976 List<String> filenameList = ((MsaFilesDocument.MsaFiles) returns[0])
977 .getFilenameList();
978 return filenameList.toArray(new String[filenameList.size()]);
979 }
980
981 /**
982 * Reteive
983 */
984 public static Map<String, String[]> getSpdLibraryClasses() {
985 String[] xPath = new String[] { "/LibraryClassDeclarations/LibraryClass" };
986
987 XmlObject[] returns = get("PackageSurfaceArea", xPath);
988
989 //
990 // Create Map, Key - LibraryClass, String[] - LibraryClass Header file.
991 //
992 Map<String, String[]> libClassHeaderMap = new HashMap<String, String[]>();
993
994 if (returns == null) {
995 return libClassHeaderMap;
996 }
997
998 for (int i = 0; i < returns.length; i++) {
999 LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass library = (LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass) returns[i];
1000 libClassHeaderMap.put(library.getName(), new String[] { library
1001 .getIncludeHeader() });
1002 }
1003 return libClassHeaderMap;
1004 }
1005
1006 /**
1007 * Reteive
1008 */
1009 public static Map<String, String> getSpdPackageHeaderFiles() {
1010 String[] xPath = new String[] { "/PackageHeaders/IncludePkgHeader" };
1011
1012 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1013
1014 //
1015 // Create Map, Key - ModuleType, String - PackageInclude Header file.
1016 //
1017 Map<String, String> packageIncludeMap = new HashMap<String, String>();
1018
1019 if (returns == null) {
1020 return packageIncludeMap;
1021 }
1022 GlobalData.log.info("" + returns[0].getClass().getName());
1023 for (int i = 0; i < returns.length; i++) {
1024 PackageHeadersDocument.PackageHeaders.IncludePkgHeader includeHeader = (PackageHeadersDocument.PackageHeaders.IncludePkgHeader) returns[i];
1025 packageIncludeMap.put(includeHeader.getModuleType().toString(),
1026 includeHeader.getStringValue());
1027 }
1028 return packageIncludeMap;
1029 }
1030
1031 public static PackageIdentification getSpdHeader() {
1032 String[] xPath = new String[] { "/SpdHeader" };
1033
1034 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1035
1036 if (returns == null || returns.length == 0) {
1037 return null;
1038 }
1039
1040 SpdHeaderDocument.SpdHeader header = (SpdHeaderDocument.SpdHeader) returns[0];
1041
1042 String name = header.getPackageName();
1043
1044 String guid = header.getGuidValue();
1045
1046 String version = header.getVersion();
1047
1048 return new PackageIdentification(name, guid, version);
1049 }
1050
1051 /**
1052 * Reteive
1053 */
1054 public static Map<String, String[]> getSpdGuid() {
1055 String[] xPath = new String[] { "/GuidDeclarations/Entry" };
1056
1057 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1058
1059 //
1060 // Create Map, Key - GuidName, String[] - C_NAME & GUID value.
1061 //
1062 Map<String, String[]> guidDeclMap = new HashMap<String, String[]>();
1063 if (returns == null) {
1064 return guidDeclMap;
1065 }
1066
1067 for (int i = 0; i < returns.length; i++) {
1068 GuidDeclarationsDocument.GuidDeclarations.Entry entry = (GuidDeclarationsDocument.GuidDeclarations.Entry) returns[i];
1069 String[] guidPair = new String[2];
1070 guidPair[0] = entry.getCName();
1071 guidPair[1] = entry.getGuidValue();
1072 guidDeclMap.put(entry.getName(), guidPair);
1073 }
1074 return guidDeclMap;
1075 }
1076
1077 /**
1078 * Reteive
1079 */
1080 public static Map<String, String[]> getSpdProtocol() {
1081 String[] xPath = new String[] { "/ProtocolDeclarations/Entry" };
1082
1083 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1084
1085 //
1086 // Create Map, Key - protocolName, String[] - C_NAME & GUID value.
1087 //
1088 Map<String, String[]> protoclMap = new HashMap<String, String[]>();
1089
1090 if (returns == null) {
1091 return protoclMap;
1092 }
1093
1094 for (int i = 0; i < returns.length; i++) {
1095 ProtocolDeclarationsDocument.ProtocolDeclarations.Entry entry = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry) returns[i];
1096 String[] protocolPair = new String[2];
1097
1098 protocolPair[0] = entry.getCName();
1099 protocolPair[1] = entry.getGuidValue();
1100 protoclMap.put(entry.getName(), protocolPair);
1101 }
1102 return protoclMap;
1103 }
1104
1105 /**
1106 * getSpdPpi() Retrieve the SPD PPI Entry
1107 *
1108 * @param
1109 * @return Map<String, String[2]> if get the PPI entry from SPD. Key - PPI
1110 * Name String[0] - PPI CNAME String[1] - PPI Guid Null if no PPI
1111 * entry in SPD.
1112 */
1113 public static Map<String, String[]> getSpdPpi() {
1114 String[] xPath = new String[] { "/PpiDeclarations/Entry" };
1115
1116 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1117
1118 //
1119 // Create Map, Key - protocolName, String[] - C_NAME & GUID value.
1120 //
1121 Map<String, String[]> ppiMap = new HashMap<String, String[]>();
1122
1123 if (returns == null) {
1124 return ppiMap;
1125 }
1126
1127 for (int i = 0; i < returns.length; i++) {
1128 PpiDeclarationsDocument.PpiDeclarations.Entry entry = (PpiDeclarationsDocument.PpiDeclarations.Entry) returns[i];
1129 String[] ppiPair = new String[2];
1130 ppiPair[0] = entry.getCName();
1131 ppiPair[1] = entry.getGuidValue();
1132 ppiMap.put(entry.getName(), ppiPair);
1133 }
1134 return ppiMap;
1135 }
1136
1137 /**
1138 * getModuleSupportedArchs()
1139 *
1140 * This function is to Retrieve Archs one module supported.
1141 *
1142 * @param
1143 * @return supportArch String of supporting archs. null No arch specified in
1144 * <MouduleSupport> element.
1145 */
1146 public static List<String> getModuleSupportedArchs() {
1147 String[] xPath = new String[] { "/ModuleDefinitions/SupportedArchitectures" };
1148
1149 XmlObject[] returns = get("ModuleSurfaceArea", xPath);
1150
1151 if (returns == null) {
1152 return null;
1153 }
1154
1155 return (List<String>)returns[0];
1156 }
1157
1158 public static XmlObject[] getSpdPcdDeclarations() {
1159 String[] xPath = null;
1160 // if (tsGuid != null){
1161 // xPath = new String[] { "/PcdDeclarations/PcdEntry[C_Name='" + cName + "' and TokenSpaceGuid='"+ tsGuid + "']" };
1162 // }
1163 // else{
1164 // xPath = new String[] { "/PcdDeclarations/PcdEntry[C_Name='" + cName + "']" };
1165 // }
1166 xPath = new String[] { "/PcdDeclarations/PcdEntry"};
1167 XmlObject[] returns = get("PackageSurfaceArea", xPath);
1168
1169 return returns;
1170 }
1171
1172 public static XmlObject[] getFpdPcdBuildDefinitions(String cName, String tsGuid, String type) {
1173 String[] xPath = new String[] { "/PcdBuildDefinition/PcdData[C_Name='" + cName + "' and TokenSpaceGuid='"
1174 + tsGuid + "' and DatumType!='" + type + "']" };
1175
1176 XmlObject[] returns = get("ModuleSA", xPath);
1177
1178 return returns;
1179 }
1180 /**
1181 * getToolChainFamily
1182 *
1183 * This function is to retrieve ToolChainFamily attribute of FPD
1184 * <BuildOptions>
1185 *
1186 * @param
1187 * @return toolChainFamily If find toolChainFamily attribute in
1188 * <BuildOptions> Null If don't have toolChainFamily in
1189 * <BuildOptions>.
1190 */
1191 public String getToolChainFamily() {
1192 String[] xPath = new String[] { "/BuildOptions" };
1193
1194 XmlObject[] result = get("FrameworkPlatformDescription", xPath);
1195 if (result == null) {
1196 return null;
1197 }
1198 // toolChainFamily =
1199 // ((BuildOptionsDocument.BuildOptions)result[0]).getToolChainFamilies();
1200 // return toolChainFamily;
1201 return null;
1202 }
1203
1204 /**
1205 * Retrieve module Guid string
1206 *
1207 * @returns GUILD string if elements are found at the known xpath
1208 * @returns null if nothing is there
1209 */
1210 public static String getModuleGuid() {
1211 String[] xPath = new String[] { "" };
1212
1213 XmlObject[] returns = get("MsaHeader", xPath);
1214 if (returns != null && returns.length > 0) {
1215 String guid = ((MsaHeaderDocument.MsaHeader) returns[0])
1216 .getGuidValue();
1217 return guid;
1218 }
1219
1220 return null;
1221 }
1222
1223 //
1224 // For new Pcd
1225 //
1226 public static ModuleSADocument.ModuleSA[] getFpdModuleSAs() {
1227 String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };
1228 XmlObject[] result = get("FrameworkPlatformDescription", xPath);
1229 if (result != null) {
1230 return (ModuleSADocument.ModuleSA[]) result;
1231 }
1232 return new ModuleSADocument.ModuleSA[0];
1233
1234 }
1235 }