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