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