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