[mirror_edk2.git] / Tools / Source / GenBuild / org / tianocore / build / global / SurfaceAreaQuery.java

/** @file\r
 This file is for surface area information retrieval.\r
\r
 Copyright (c) 2006, Intel Corporation\r
 All rights reserved. This program and the accompanying materials\r
 are licensed and made available under the terms and conditions of the BSD License\r
 which accompanies this distribution.  The full text of the license may be found at\r
 http://opensource.org/licenses/bsd-license.php\r
\r
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
 **/\r
package org.tianocore.build.global;\r
\r
import java.util.ArrayList;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Stack;\r
import java.util.regex.Matcher;\r
import java.util.regex.Pattern;\r
\r
import org.apache.xmlbeans.XmlNormalizedString;\r
import org.apache.xmlbeans.XmlObject;\r
import org.apache.xmlbeans.XmlString;\r
import org.tianocore.BuildOptionsDocument;\r
import org.tianocore.CName;\r
import org.tianocore.ExternsDocument;\r
import org.tianocore.FfsDocument;\r
import org.tianocore.FileNameConvention;\r
import org.tianocore.FrameworkComponentTypes;\r
import org.tianocore.FvImageOptionsDocument;\r
import org.tianocore.GuidDocument;\r
import org.tianocore.GuidsDocument;\r
import org.tianocore.LibrariesDocument;\r
import org.tianocore.LibraryClassDocument;\r
import org.tianocore.LibraryUsage;\r
import org.tianocore.ModuleSADocument;\r
import org.tianocore.ModuleTypeDef;\r
import org.tianocore.NameValueDocument;\r
import org.tianocore.OutputDirectoryDocument;\r
import org.tianocore.PPIsDocument;\r
import org.tianocore.PackageNameDocument;\r
import org.tianocore.ProtocolsDocument;\r
import org.tianocore.PcdCodedDocument.PcdCoded;\r
\r
/**\r
  SurfaceAreaQuery class is used to query Surface Area information from msa, mbd,\r
  spd and fpd files. \r
  \r
  This class should not instantiated. All the public interfaces is static.\r
  \r
  @since GenBuild 1.0\r
 **/\r
public class SurfaceAreaQuery {\r
    /// \r
    /// Contains name/value pairs of Surface Area document object. The name is\r
    /// always the top level element name.\r
    ///  \r
    private static Map<String, XmlObject> map = null;\r
    \r
    ///\r
    /// mapStack is used to do nested query\r
    ///\r
    private static Stack< Map<String, XmlObject> > mapStack = new Stack< Map<String, XmlObject> >();\r
    \r
    /// \r
    /// prefix of name space\r
    /// \r
    private static String nsPrefix = "sans";\r
    \r
    ///\r
    /// xmlbeans needs a name space for each Xpath element \r
    ///\r
    private static String ns = null;\r
    \r
    ///\r
    /// keep the namep declaration for xmlbeans Xpath query\r
    ///\r
    private static String queryDeclaration = null;\r
\r
    /**\r
     Set a Surface Area document for query later\r
     \r
     @param     map     A Surface Area document in TopLevelElementName/XmlObject format.\r
     **/\r
    public static void setDoc(Map<String, XmlObject> map) {\r
        ns = OverrideProcess.prefix;\r
        queryDeclaration = "declare namespace " + nsPrefix + "='" + ns + "'; ";\r
        SurfaceAreaQuery.map = map;\r
    }\r
\r
    /**\r
     Push current used Surface Area document into query stack. The given new \r
     document  will be used for any immediately followed getXXX() callings, \r
     untill pop() is called.\r
     \r
     @param     newMap  The TopLevelElementName/XmlObject format of a Surface Area document.\r
     **/\r
    public static void push(Map<String, XmlObject> newMap) {\r
        mapStack.push(SurfaceAreaQuery.map);\r
        SurfaceAreaQuery.map = newMap;\r
    }\r
    \r
    /**\r
     Discard current used Surface Area document and use the top document in stack\r
     instead.\r
     **/\r
    public static void pop() {\r
        SurfaceAreaQuery.map = mapStack.pop();\r
    }\r
    \r
    ///\r
    /// Convert xPath to be namespace qualified, which is necessary for XmlBeans\r
    /// selectPath(). For example, converting /MsaHeader/ModuleType to\r
    /// /ns:MsaHeader/ns:ModuleType\r
    ///     \r
    private static String normalizeQueryString(String[] exp, String from) {\r
        StringBuffer normQueryString = new StringBuffer(4096);\r
\r
        int i = 0;\r
        while (i < exp.length) {\r
            String newExp = from + exp[i];\r
            Pattern pattern = Pattern.compile("([^/]*)(/|//)([^/]+)");\r
            Matcher matcher = pattern.matcher(newExp);\r
\r
            while (matcher.find()) {\r
                String starter = newExp.substring(matcher.start(1), matcher.end(1));\r
                String seperator = newExp.substring(matcher.start(2), matcher.end(2));\r
                String token = newExp.substring(matcher.start(3), matcher.end(3));\r
                \r
                normQueryString.append(starter);\r
                normQueryString.append(seperator);\r
                normQueryString.append(nsPrefix);\r
                normQueryString.append(":");\r
                normQueryString.append(token);\r
            }\r
\r
            ++i;\r
            if (i < exp.length) {\r
                normQueryString.append(" | ");\r
            }\r
        }\r
\r
        return normQueryString.toString();\r
    }\r
\r
    /**\r
      Search all XML documents stored in "map" for the specified xPath, using\r
      relative path (starting with '$this')\r
     \r
     @param     xPath   xpath query string array\r
     @returns   An array of XmlObject   if elements are found at the specified xpath\r
     @returns   NULL                    if nothing is at the specified xpath\r
     **/\r
    public static XmlObject[] get(String[] xPath) {\r
        if (map == null) {\r
            return null;\r
        }\r
        \r
        String[] keys = (String[]) map.keySet().toArray(new String[map.size()]);\r
        List<XmlObject> result = new ArrayList<XmlObject>();\r
        for (int i = 0; i < keys.length; ++i) {\r
            XmlObject rootNode = (XmlObject) map.get(keys[i]);\r
            if (rootNode == null) {\r
                continue;\r
            }\r
            \r
            String query = queryDeclaration + normalizeQueryString(xPath, "$this/" + keys[i]);\r
            XmlObject[] tmp = rootNode.selectPath(query);\r
            for (int j = 0; j < tmp.length; ++j) {\r
                result.add(tmp[j]);\r
            }\r
        }\r
        \r
        int size = result.size();\r
        if (size <= 0) {\r
            return null;\r
        }\r
        \r
        return (XmlObject[]) result.toArray(new XmlObject[size]);\r
    }\r
\r
    /**\r
     Search XML documents named by "rootName" for the given xPath, using\r
     relative path (starting with '$this')\r
     \r
     @param     rootName    The top level element name \r
     @param     xPath       The xpath query string array\r
     @returns   An array of XmlObject   if elements are found at the given xpath\r
     @returns   NULL                    if nothing is found at the given xpath\r
     **/\r
    public static XmlObject[] get(String rootName, String[] xPath) {\r
        if (map == null) {\r
            return null;\r
        }\r
        \r
        XmlObject root = (XmlObject) map.get(rootName);\r
        if (root == null) {\r
            return null;\r
        }\r
\r
        String query = queryDeclaration + normalizeQueryString(xPath, "$this/" + rootName);\r
        XmlObject[] result = root.selectPath(query);\r
        if (result.length > 0) {\r
            return result;\r
        }\r
\r
        query = queryDeclaration + normalizeQueryString(xPath, "/" + rootName);\r
        result = root.selectPath(query);\r
        if (result.length > 0) {\r
            return result;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve SourceFiles/Filename for specified ARCH type\r
      \r
     @param     arch        architecture name\r
     @returns   An array of XmlObject   if elements are found at the known xpath\r
     @returns   NULL                    if nothing is found at the known xpath\r
     **/\r
    public static XmlObject[] getSourceFiles(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            xPath = new String[] {\r
                "/Filename",\r
                "/Arch/Filename"\r
                };\r
        } else {\r
            xPath = new String[] {\r
                "/Filename[not(@ArchType) or @ArchType='ALL' or @ArchType='" + arch + "']",\r
                "/Arch[@ArchType='ALL' or @ArchType='" + arch + "']/Filename"\r
                };\r
        }\r
\r
        return get("SourceFiles", xPath);\r
    }\r
\r
    /**\r
     Retrieve BuildOptions/Ffs\r
\r
     @returns   FfsDocument.Ffs object  if elements are found at the known xpath\r
     @returns   NULL                    if nothing is found at the known xpath\r
     **/\r
    public static FfsDocument.Ffs getFfs() {\r
        String[] xPath = new String[] { "/Ffs" };\r
\r
        XmlObject[] returns = get("BuildOptions", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (FfsDocument.Ffs) returns[0];\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve BuildOptions/OutputDirectory\r
\r
     @returns   Directory names array   if elements are found at the known xpath\r
     @returns   Empty                   if nothing is found at the known xpath\r
     **/\r
    public static String[] getOutputDirectory() {\r
        String[] xPath = new String[] { "/OutputDirectory" };\r
\r
        XmlObject[] returns = get("BuildOptions", xPath);\r
        if (returns != null && returns.length > 0) {\r
            String[] dirString = new String[2];\r
\r
            OutputDirectoryDocument.OutputDirectory[] dir = (OutputDirectoryDocument.OutputDirectory[]) returns;\r
            dirString[0] = dir[0].getIntermediateDirectories().toString();\r
            dirString[1] = dir[0].getStringValue();\r
\r
            return dirString;\r
        }\r
\r
        return new String[] { "UNIFIED", null };\r
    }\r
\r
    /**\r
     Retrieve BuildOptions/Option or Arch/Option\r
\r
     @param     arch    architecture name\r
\r
     @returns   name/value pairs of options if elements are found at the known xpath\r
     @returns   Empty array                 if nothing is there\r
     **/\r
    public static String[][] getOptions(String arch){\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            xPath = new String[] {\r
                "/Option",\r
                "/Arch/Option"\r
                };\r
        } else {\r
            xPath = new String[] {\r
                "/Option",\r
                "/Arch[@ArchType='ALL' or @ArchType='" + arch + "']/Option"\r
                };\r
        }\r
\r
        XmlObject[] returns = get("BuildOptions", xPath);\r
        if (returns == null){\r
            return new String[0][2];\r
        }\r
        \r
        String[][] result = new String[returns.length][2];\r
        for (int i = 0; i < returns.length; i ++){\r
            String str;\r
            String name = null;\r
            String value = null;\r
\r
            if (returns[i] instanceof BuildOptionsDocument.BuildOptions.Option) {\r
                BuildOptionsDocument.BuildOptions.Option option = (BuildOptionsDocument.BuildOptions.Option)returns[i];\r
                str = option.getStringValue();\r
            } else if (returns[i] instanceof BuildOptionsDocument.BuildOptions.Arch.Option) {\r
                BuildOptionsDocument.BuildOptions.Arch.Option archOption = (BuildOptionsDocument.BuildOptions.Arch.Option)returns[i];\r
                str = archOption.getStringValue();\r
            } else {\r
                continue;\r
            }\r
            \r
            int equalIndex = str.indexOf('=');\r
            if ( equalIndex > 0) {\r
                name = str.substring(0, equalIndex).trim();\r
                value = str.substring(equalIndex + 1).trim();\r
                // TBD remove some forbidden name: BASE_NAME, ARCH and so on\r
                if (name.length() == 0){\r
                    name = null;\r
                }\r
            }\r
            result[i][0] = name;\r
            result[i][1] = value;\r
        }\r
\r
        return result;\r
    }\r
    \r
    /**\r
     Retrieve <xxxHeader>/ModuleType\r
\r
     @returns   The module type name    if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getModuleType() {\r
        String[] xPath = new String[] { "/ModuleType" };\r
\r
        XmlObject[] returns = get(xPath);\r
        if (returns != null && returns.length > 0) {\r
            ModuleTypeDef type = (ModuleTypeDef) returns[0];\r
            return type.enumValue().toString();\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve <xxxHeader>/ComponentType\r
     \r
     @returns   The component type name if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getComponentType() {\r
        String[] xPath = new String[] { "/ComponentType" };\r
\r
        XmlObject[] returns = get(xPath);\r
        if (returns != null && returns.length > 0) {\r
            FrameworkComponentTypes type = (FrameworkComponentTypes) returns[0];\r
            return type.enumValue().toString();\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve Includes/PackageName\r
\r
     @param     arch    Architecture name\r
\r
     @returns   package name list       if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static List<String> getIncludePackageName(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            xPath = new String[] {\r
                "/PackageName",\r
                "/Arch/PackageName"\r
                };\r
        } else {\r
            xPath = new String[] {\r
                "/PackageName",\r
                "/Arch[@ArchType='ALL' or @ArchType='" + arch + "']/PackageName"\r
                };\r
        }\r
        \r
        XmlObject[] returns = get("Includes", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
\r
        List<String> packageNames = new ArrayList<String>();\r
        PackageNameDocument.PackageName[] nameObj = (PackageNameDocument.PackageName[])returns;\r
        for (int i = 0; i < returns.length; ++i) {\r
            packageNames.add(nameObj[i].getStringValue());\r
        }\r
        \r
        return packageNames;\r
    }\r
\r
    /**\r
     Retrieve LibraryClassDefinitions/LibraryClass for specified usage\r
\r
     @param     usage   Library class usage\r
\r
     @returns   LibraryClass objects list   if elements are found at the known xpath\r
     @returns   null                        if nothing is there\r
     **/\r
    public static LibraryClassDocument.LibraryClass[] getLibraryClassArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] {"/LibraryClass"};\r
        } else {\r
            xPath = new String[] {"/LibraryClass[@Usage='" + usage + "']"};\r
        }\r
\r
        XmlObject[] returns = get("LibraryClassDefinitions", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (LibraryClassDocument.LibraryClass[]) returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve ModuleEntryPoint names\r
\r
     @returns   ModuleEntryPoint name list  if elements are found at the known xpath\r
     @returns   null                        if nothing is there\r
     **/\r
    public static String[] getModuleEntryPointArray() {\r
        String[] xPath = new String[] { "/Extern/ModuleEntryPoint" };\r
\r
        XmlObject[] returns = get("Externs", xPath);\r
\r
        if (returns != null && returns.length > 0) {\r
            String[] entryPoints = new String[returns.length];\r
\r
            for (int i = 0; i < returns.length; ++i) {\r
                entryPoints[i] = ((XmlNormalizedString) returns[i])\r
                                .getStringValue();\r
            }\r
\r
            return entryPoints;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve module Guid string\r
 \r
     @returns   GUILD string            if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getModuleGuid() {\r
        String[] xPath = new String[] { "/Guid" };\r
\r
        XmlObject[] returns = get(xPath);\r
        if (returns != null && returns.length > 0) {\r
            GuidDocument.Guid guid = (GuidDocument.Guid) returns[0];\r
            return guid.getStringValue();\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     retrieve Protocol for specified usage\r
\r
     @param     usage   Protocol usage\r
\r
     @returns   Protocol objects list   if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static ProtocolsDocument.Protocols.Protocol[] getProtocolArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] {"/Protocol"};\r
        } else {\r
            xPath = new String[] {"/Protocol[@Usage='" + usage + "']"};\r
        }\r
\r
        XmlObject[] returns = get("Protocols", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (ProtocolsDocument.Protocols.Protocol[]) returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve ProtocolNotify for specified usage\r
    \r
     @param     usage   ProtocolNotify usage\r
\r
     @returns   ProtocolNotify objects list     if elements are found at the known xpath\r
     @returns   null                            if nothing is there\r
     **/\r
    public static ProtocolsDocument.Protocols.ProtocolNotify[] getProtocolNotifyArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] {"/ProtocolNotify"};\r
        } else {\r
            xPath = new String[] {"/ProtocolNotify[@Usage='" + usage + "']"};\r
        }\r
\r
        XmlObject[] returns = get("Protocols", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (ProtocolsDocument.Protocols.ProtocolNotify[]) returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve ModuleUnloadImage names\r
\r
     @returns   ModuleUnloadImage name list     if elements are found at the known xpath\r
     @returns   null                            if nothing is there\r
     **/\r
    public static String[] getModuleUnloadImageArray() {\r
        String[] xPath = new String[] { "/Extern/ModuleUnloadImage" };\r
\r
        XmlObject[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            String[] stringArray = new String[returns.length];\r
            XmlNormalizedString[] doc = (XmlNormalizedString[])returns;\r
\r
            for (int i = 0; i < returns.length; ++i) {\r
                stringArray[i] = doc[i].getStringValue();\r
            }\r
\r
            return stringArray;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve Extern\r
\r
     @returns   Extern objects list     if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static ExternsDocument.Externs.Extern[] getExternArray() {\r
        String[] xPath = new String[] { "/Extern" };\r
\r
        XmlObject[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (ExternsDocument.Externs.Extern[]) returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve Ppi information\r
\r
     @param     usage   Ppi usage\r
\r
     @returns   Ppi objects list        if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static PPIsDocument.PPIs.Ppi[] getPpiArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] { "/Ppi" };\r
        } else {\r
            xPath = new String[] { "/Ppi[@Usage='" + usage + "']" };\r
        }\r
\r
        XmlObject[] returns = get("PPIs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (PPIsDocument.PPIs.Ppi[])returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrive PpiNotify information\r
    \r
     @param usage\r
\r
     @returns   PpiNotify objects list  if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static PPIsDocument.PPIs.PpiNotify[] getPpiNotifyArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] { "/PpiNotify" };\r
        } else {\r
            xPath = new String[] { "/PpiNotify[@Usage='" + usage + "']" };\r
        }\r
\r
        XmlObject[] returns = get("PPIs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (PPIsDocument.PPIs.PpiNotify[])returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve GuidEntry information for specified usage\r
\r
     @param     usage   GuidEntry usage\r
\r
     @returns   GuidEntry objects list  if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static GuidsDocument.Guids.GuidEntry[] getGuidEntryArray(String usage) {\r
        String[] xPath;\r
\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] { "/GuidEntry" };\r
        } else {\r
            xPath = new String[] { "/GuidEntry[@Usage='" + usage + "']" };\r
        }\r
\r
        XmlObject[] returns = get("Guids", xPath);\r
        if (returns != null && returns.length > 0) {\r
            return (GuidsDocument.Guids.GuidEntry[])returns;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrieve Library instance information\r
\r
     @param     arch    Architecture name\r
     @param     usage   Library instance usage\r
\r
     @returns   library instance name list  if elements are found at the known xpath\r
     @returns   null                        if nothing is there\r
     **/\r
    public static List<String> getLibraryInstance(String arch, String usage) {\r
        String[] xPath;\r
        String   archAttribute = "";\r
        String   usageAttribute = "";\r
\r
        if ((arch != null) || (!arch.equals(""))) {\r
            archAttribute = "[@ArchType='ALL' or @ArchType='" + arch + "']";\r
        }\r
        \r
        if ((usage != null) || (!usage.equals(""))) {\r
            // if no Usage attribute specified, default to ALWAYS_CONSUMED\r
            if (usage.equals(LibraryUsage.ALWAYS_CONSUMED.toString())) {\r
                usageAttribute = "[not(@Usage) or @Usage='" + usage + "']";\r
            } else {\r
                usageAttribute = "[@Usage='" + usage + "']";\r
            }\r
        }\r
        \r
        xPath = new String[] {\r
                "/Library" + usageAttribute,\r
                "/Arch" + archAttribute + "/Library" + usageAttribute\r
                };\r
\r
        XmlObject[] returns = get("Libraries", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        \r
        List<String> instances = new ArrayList<String>();\r
        for (int i = 0; i < returns.length; ++i) {\r
            if (returns[i] instanceof LibrariesDocument.Libraries.Library) {\r
                LibrariesDocument.Libraries.Library lib = (LibrariesDocument.Libraries.Library)returns[i];\r
                instances.add(lib.getStringValue());\r
            } else if (returns[i] instanceof LibrariesDocument.Libraries.Arch.Library) {\r
                LibrariesDocument.Libraries.Arch.Library lib = (LibrariesDocument.Libraries.Arch.Library)returns[i];\r
                instances.add(lib.getStringValue());\r
            }\r
        }\r
\r
        return instances;\r
    }\r
\r
    ///\r
    /// This method is used for retrieving the elements information which has \r
    /// CName sub-element\r
    ///\r
    private static String[] getCNames(String from, String xPath[]) {\r
        XmlObject[] returns = get(from, xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        \r
        String[] strings = new String[returns.length];\r
        for (int i = 0; i < returns.length; ++i) {\r
            strings[i] = ((CName)returns[i]).getStringValue(); \r
        }\r
        \r
        return strings;            \r
    }\r
    \r
    /**\r
     Retrive library's constructor name\r
\r
     @returns   constructor name list   if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getLibConstructorName() {\r
        String[] xPath = new String[] {"/Extern/Constructor"};\r
\r
        XmlObject[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            CName constructor = (CName)returns[0]; \r
            return constructor.getStringValue();            \r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     Retrive library's destructor name\r
\r
     @returns   destructor name list    if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getLibDestructorName() {\r
        String[] xPath = new String[] {"/Extern/Destructor"};\r
\r
        XmlObject[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            CName destructor = (CName)returns[0]; \r
            return destructor.getStringValue();            \r
        }\r
\r
        return null;\r
    }\r
    \r
    /**\r
     Retrive DriverBinding names\r
\r
     @returns   DriverBinding name list if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getDriverBindingArray() {\r
        String[] xPath = new String[] {"/Extern/DriverBinding"};\r
        return getCNames("Externs", xPath);\r
    }\r
    \r
    /**\r
     Retrive ComponentName names\r
\r
     @returns   ComponentName name list if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getComponentNameArray() {\r
        String[] xPath = new String[] {"/Extern/ComponentName"};\r
        return getCNames("Externs", xPath);\r
    }\r
    \r
    /**\r
     Retrive DriverConfig names\r
\r
     @returns   DriverConfig name list  if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getDriverConfigArray() {\r
        String[] xPath = new String[] {"/Extern/DriverConfig"};\r
        return getCNames("Externs", xPath);\r
    }\r
    \r
    /**\r
     Retrive DriverDiag names\r
\r
     @returns   DriverDiag name list    if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getDriverDiagArray() {\r
        String[] xPath = new String[] {"/Extern/DriverDiag"};\r
        return getCNames("Externs", xPath);\r
    }\r
\r
    /**\r
     Retrive SetVirtualAddressMapCallBack names\r
\r
     @returns   SetVirtualAddressMapCallBack name list  \r
                                        if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getSetVirtualAddressMapCallBackArray() {\r
        String[] xPath = new String[] {"/Extern/SetVirtualAddressMapCallBack"};\r
        return getCNames("Externs", xPath);\r
    }\r
    \r
    /**\r
     Retrive ExitBootServicesCallBack names\r
\r
     @returns   ExitBootServicesCallBack name list  \r
                                        if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String[] getExitBootServicesCallBackArray() {\r
        String[] xPath = new String[] {"/Extern/ExitBootServicesCallBack"};\r
        return getCNames("Externs", xPath);\r
    }\r
\r
    /**\r
     Retrieve module surface area file information\r
\r
     @returns   ModuleSA objects list   if elements are found at the known xpath\r
     @returns   Empty ModuleSA list     if nothing is there\r
     **/\r
    public static ModuleSADocument.ModuleSA[] getFpdModules() {\r
        String[] xPath = new String[] { "/TianoImage/*/ModuleSA" };\r
\r
        XmlObject[] result = get("FrameworkPlatformDescription", xPath);\r
        if (result == null) {\r
            return new ModuleSADocument.ModuleSA[0];\r
        }\r
\r
        return (ModuleSADocument.ModuleSA[]) result;\r
    }\r
\r
    /**\r
     Retrieve variables for FV images\r
\r
     @returns   name/value list        if elements are found at the known xpath\r
     @returns   empty list             if nothing is there\r
     **/\r
    public static String[][] getFpdGlobalVariable() {\r
        String[] xPath = new String[] { "/Flash/FvImages/NameValue" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null) {\r
            return new String[0][];\r
        }\r
\r
        String[][] result = new String[queryResult.length][2];\r
        for (int i = 0; i < queryResult.length; i++){\r
            result[i][0] = ((NameValueDocument.NameValue)queryResult[i]).getName();\r
            result[i][1] = ((NameValueDocument.NameValue)queryResult[i]).getValue();\r
        }\r
\r
        return result;\r
    }\r
    \r
    /**\r
     Retrieve valid image names\r
\r
     @returns   valid iamges name list  if elements are found at the known xpath\r
     @returns   empty list              if nothing is there\r
     **/\r
    public static String[] getFpdValidImageNames(){\r
        String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='ValidImageNames']/FvImageNames" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null) {\r
            return new String[0];\r
        }\r
\r
        String[] result = new String[queryResult.length];\r
        for (int i = 0; i < queryResult.length; i++){\r
            result[i] = ((XmlString)queryResult[i]).getStringValue();\r
        }\r
\r
        return result;\r
    }\r
\r
    /**\r
     Retrieve FV image option information\r
\r
     @param fvName  FV image name\r
\r
     @returns   option name/value list if elements are found at the known xpath\r
     @returns   empty list             if nothing is there\r
     **/\r
    public static String[][] getFpdOptions(String fvName){\r
        String[] xPath = new String[] {"/Flash/FvImages/FvImageName[@Name='" + fvName.toUpperCase() + "']/FvImageOptions/NameValue" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null) {\r
            return new String[0][];\r
        }\r
\r
        String[][] result = new String[queryResult.length][2];\r
        for (int i = 0; i < queryResult.length; i++){\r
            result[i][0] = ((NameValueDocument.NameValue)queryResult[i]).getName();\r
            result[i][1] = ((NameValueDocument.NameValue)queryResult[i]).getValue();\r
        }\r
\r
        return result;\r
    }\r
    \r
    /**\r
     Retrieve FV image attributes information\r
\r
     @param     fvName  FV image name\r
\r
     @returns   attribute name/value list   if elements are found at the known xpath\r
     @returns   empty list                  if nothing is there\r
     **/\r
    public static String[][] getFpdAttributes(String fvName){\r
        String[] xPath = new String[] {"/Flash/FvImages/FvImage[@Type='Attributes' and ./FvImageNames='" + fvName.toUpperCase() + "']/FvImageOptions" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null) {\r
            return new String[0][];\r
        }\r
\r
        ArrayList<String[]> list = new ArrayList<String[]>();\r
        for (int i = 0 ; i < queryResult.length; i++){\r
            FvImageOptionsDocument.FvImageOptions item = (FvImageOptionsDocument.FvImageOptions)queryResult[i];\r
\r
            List<NameValueDocument.NameValue> namevalues = item.getNameValueList();\r
            Iterator iter = namevalues.iterator();\r
            while (iter.hasNext()) {\r
                NameValueDocument.NameValue nvItem = (NameValueDocument.NameValue)iter.next();\r
                list.add(new String[]{nvItem.getName(), nvItem.getValue()});\r
            }\r
\r
            List<String> enables = item.getEnableList();\r
            iter = enables.iterator();\r
            while (iter.hasNext()) {\r
                String enableItem = (String)iter.next();\r
                list.add(new String[]{enableItem, "TRUE"});\r
            }\r
\r
            List<String> disables = item.getDisableList();\r
            iter = disables.iterator();\r
            while (iter.hasNext()) {\r
                String disableItem = (String)iter.next();\r
                list.add(new String[]{disableItem, "FALSE"});\r
            }\r
        }\r
\r
        String[][] result = new String[list.size()][2];\r
        for (int i = 0; i < list.size(); i++){\r
            result[i][0] = list.get(i)[0];\r
            result[i][1] = list.get(i)[1];\r
        }\r
\r
        return result;\r
    }\r
    \r
    /**\r
     Retrieve flash definition file name\r
\r
     @returns   file name               if elements are found at the known xpath\r
     @returns   null                    if nothing is there\r
     **/\r
    public static String getFlashDefinitionFile(){\r
        String[] xPath = new String[] {"/Flash/FlashDefinitionFile" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null || queryResult.length == 0) {\r
            return null;\r
        }\r
\r
        FileNameConvention filename = (FileNameConvention)queryResult[queryResult.length - 1];\r
        return filename.getStringValue();\r
    }\r
    \r
    /**\r
     Retrieve FV image component options\r
\r
     @param     fvName  FV image name\r
\r
     @returns   name/value pairs list   if elements are found at the known xpath\r
     @returns   empty list              if nothing is there\r
     **/\r
    public static String[][] getFpdComponents(String fvName){\r
        String[] xPath = new String[] {"/Flash/FvImages/FvImage[@Type='Components' and ./FvImageNames='" + fvName.toUpperCase() + "']/FvImageOptions" };\r
\r
        XmlObject[] queryResult = get("FrameworkPlatformDescription", xPath);\r
        if (queryResult == null) {\r
            return new String[0][];\r
        }\r
\r
        ArrayList<String[]> list = new ArrayList<String[]>();\r
        for (int i = 0 ; i < queryResult.length; i++){\r
            FvImageOptionsDocument.FvImageOptions item = (FvImageOptionsDocument.FvImageOptions)queryResult[i];\r
\r
            List<NameValueDocument.NameValue> namevalues = item.getNameValueList();\r
            Iterator iter = namevalues.iterator();\r
            while (iter.hasNext()) {\r
                NameValueDocument.NameValue nvItem = (NameValueDocument.NameValue)iter.next();\r
                list.add(new String[]{nvItem.getName(), nvItem.getValue()});\r
            }\r
\r
            List<String> enables = item.getEnableList();\r
            iter = enables.iterator();\r
            while (iter.hasNext()) {\r
                String enableItem = (String)iter.next();\r
                list.add(new String[]{enableItem, "TRUE"});\r
            }\r
\r
            List<String> disables = item.getDisableList();\r
            iter = disables.iterator();\r
            while (iter.hasNext()) {\r
                String disableItem = (String)iter.next();\r
                list.add(new String[]{disableItem, "FALSE"});\r
            }\r
        }\r
\r
        String[][] result = new String[list.size()][2];\r
        for (int i = 0; i < list.size(); i++){\r
            result[i][0] = list.get(i)[0];\r
            result[i][1] = list.get(i)[1];\r
        }\r
\r
        return result;\r
    }\r
    \r
    /**\r
       Get name array of PCD in a module. In one module, token space\r
       is same, and token name should not be conflicted.\r
       \r
       @return String[]\r
    **/\r
    public static String[] getModulePcdEntryNameArray() {\r
        PcdCoded.PcdEntry[] pcdEntries  = null;\r
        String[]            results;\r
        int                 index;\r
        String[]            xPath       = new String[] {"/PcdEntry"};\r
        XmlObject[]         returns     = get ("PcdCoded", xPath);\r
        if (returns == null) {\r
            return null;\r
        }\r
\r
        pcdEntries = (PcdCoded.PcdEntry[])returns;\r
        results    = new String[pcdEntries.length];\r
        \r
        for (index = 0; index < pcdEntries.length; index ++) {\r
            results[index] = pcdEntries[index].getCName();\r
        }\r
        return results;\r
    }\r
}\r