Support using @ToolChainFamily in <Filename> to do the filter. This is also to fix...

[mirror_edk2.git] / Tools / Java / 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.HashMap;\r
import java.util.Iterator;\r
import java.util.LinkedHashMap;\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.tianocore.ExternsDocument.Externs.Extern;\r
import org.apache.xmlbeans.XmlObject;\r
import org.apache.xmlbeans.XmlString;\r
import org.tianocore.*;\r
import org.tianocore.FilenameDocument.Filename;\r
import org.tianocore.MsaHeaderDocument.MsaHeader;\r
import org.tianocore.ProtocolsDocument.Protocols.Protocol;\r
import org.tianocore.ProtocolsDocument.Protocols.ProtocolNotify;\r
import org.tianocore.build.autogen.CommonDefinition;\r
import org.tianocore.build.id.FpdModuleIdentification;\r
import org.tianocore.build.id.ModuleIdentification;\r
import org.tianocore.build.id.PackageIdentification;\r
import org.tianocore.build.id.PlatformIdentification;\r
import org.tianocore.build.toolchain.ToolChainInfo;\r
import org.tianocore.common.exception.EdkException;\r
import org.w3c.dom.Node;\r
\r
/**\r
 * SurfaceAreaQuery class is used to query Surface Area information from msa,\r
 * mbd, 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
    public String prefix = "http://www.TianoCore.org/2006/Edk2.0";\r
\r
    //\r
    // Contains name/value pairs of Surface Area document object. The name is\r
    // always the top level element name.\r
    //\r
    private Map<String, XmlObject> map = null;\r
\r
    //\r
    // mapStack is used to do nested query\r
    //\r
    private Stack<Map<String, XmlObject>> mapStack = new Stack<Map<String, XmlObject>>();\r
\r
    //\r
    // prefix of name space\r
    //\r
    private String nsPrefix = "sans";\r
\r
    //\r
    // xmlbeans needs a name space for each Xpath element\r
    //\r
    private String ns = null;\r
\r
    //\r
    // keep the namep declaration for xmlbeans Xpath query\r
    //\r
    private String queryDeclaration = null;\r
\r
    private StringBuffer normQueryString = new StringBuffer(4096);\r
    private Pattern xPathPattern = Pattern.compile("([^/]*)(/|//)([^/]+)");\r
\r
    /**\r
     * Set a Surface Area document for query later\r
     *\r
     * @param map\r
     *            A Surface Area document in TopLevelElementName/XmlObject\r
     *            format.\r
     */\r
    public SurfaceAreaQuery(Map<String, XmlObject> map) {\r
        ns = prefix;\r
        queryDeclaration = "declare namespace " + nsPrefix + "='" + ns + "'; ";\r
        this.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\r
     *            The TopLevelElementName/XmlObject format of a Surface Area\r
     *            document.\r
     */\r
    public void push(Map<String, XmlObject> newMap) {\r
        mapStack.push(this.map);\r
        this.map = newMap;\r
    }\r
\r
    /**\r
     * Discard current used Surface Area document and use the top document in\r
     * stack instead.\r
     */\r
    public void pop() {\r
        this.map = mapStack.pop();\r
    }\r
\r
    // /\r
    // / Convert xPath to be namespace qualified, which is necessary for\r
    // XmlBeans\r
    // / selectPath(). For example, converting /MsaHeader/ModuleType to\r
    // / /ns:MsaHeader/ns:ModuleType\r
    // /\r
    private String normalizeQueryString(String[] exp, String from) {\r
        normQueryString.setLength(0);\r
\r
        int i = 0;\r
        while (i < exp.length) {\r
            String newExp = from + exp[i];\r
            Matcher matcher = xPathPattern.matcher(newExp);\r
\r
            while (matcher.find()) {\r
                String starter = newExp.substring(matcher.start(1), matcher\r
                        .end(1));\r
                String seperator = newExp.substring(matcher.start(2), matcher\r
                        .end(2));\r
                String token = newExp.substring(matcher.start(3), matcher\r
                        .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\r
     *            xpath query string array\r
     * @returns An array of XmlObject if elements are found at the specified\r
     *          xpath\r
     * @returns NULL if nothing is at the specified xpath\r
     */\r
    public Object[] 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<Object> result = new ArrayList<Object>();\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\r
                    + normalizeQueryString(xPath, "$this/" + keys[i]);\r
            XmlObject[] tmp = rootNode.selectPath(query);\r
            for (int j = 0; j < tmp.length; ++j) {\r
                result.add((Object)tmp[j]);\r
            }\r
        }\r
\r
        int size = result.size();\r
        if (size <= 0) {\r
            return null;\r
        }\r
\r
        return (Object[]) result.toArray(new Object[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\r
     *            The top level element name\r
     * @param xPath\r
     *            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 Object[] 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\r
                + normalizeQueryString(xPath, "$this/" + rootName);\r
        XmlObject[] result = root.selectPath(query);\r
        if (result.length > 0) {\r
            return (Object[])result;\r
        }\r
\r
        query = queryDeclaration + normalizeQueryString(xPath, "/" + rootName);\r
        result = root.selectPath(query);\r
        if (result.length > 0) {\r
            return (Object[])result;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     * Retrieve SourceFiles/Filename for specified ARCH type\r
     *\r
     * @param arch\r
     *            architecture name\r
     * @returns An 2 dimension string array if elements are found at the known\r
     *          xpath\r
     * @returns NULL if nothing is found at the known xpath\r
     */\r
    public String[][] getSourceFiles(String arch) {\r
        String[] xPath;\r
        Object[] returns;\r
\r
        xPath = new String[] { "/Filename" };\r
\r
        returns = get("SourceFiles", xPath);\r
\r
        if (returns == null || returns.length == 0) {\r
            return new String[0][3];\r
        }\r
\r
        Filename[] sourceFileNames = (Filename[]) returns;\r
        List<String[]> outputList = new ArrayList<String[]>();\r
        for (int i = 0; i < sourceFileNames.length; i++) {\r
            List archList = sourceFileNames[i].getSupArchList();\r
            if (arch == null || arch.trim().equalsIgnoreCase("") || archList == null || contains(archList, arch)) {\r
                outputList.add(new String[] {sourceFileNames[i].getToolCode(), sourceFileNames[i].getStringValue(), sourceFileNames[i].getToolChainFamily()});\r
            }\r
        }\r
\r
        String[][] outputString = new String[outputList.size()][3];\r
        for (int index = 0; index < outputList.size(); index++) {\r
            //\r
            // ToolCode (FileType)\r
            //\r
            outputString[index][0] = outputList.get(index)[0];\r
            //\r
            // File name (relative to MODULE_DIR)\r
            //\r
            outputString[index][1] = outputList.get(index)[1];\r
            //\r
            // Tool chain family\r
            //\r
            outputString[index][2] = outputList.get(index)[2];\r
        }\r
        return outputString;\r
    }\r
\r
    /**\r
     * Retrieve /PlatformDefinitions/OutputDirectory from FPD\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 String getFpdOutputDirectory() {\r
        String[] xPath = new String[] { "/PlatformDefinitions" };\r
\r
        Object[] returns = get("PlatformSurfaceArea", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];\r
        return item.getOutputDirectory();\r
    }\r
\r
    public String getFpdIntermediateDirectories() {\r
        String[] xPath = new String[] { "/PlatformDefinitions" };\r
\r
        Object[] returns = get("PlatformSurfaceArea", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return "UNIFIED";\r
        }\r
        PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];\r
        if(item.getIntermediateDirectories() == null) {\r
            return null;\r
        }\r
        else {\r
            return item.getIntermediateDirectories().toString();\r
        }\r
    }\r
\r
    public String getModuleFfsKeyword() {\r
        String[] xPath = new String[] { "/" };\r
\r
        Object[] returns = get("ModuleSaBuildOptions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        ModuleSaBuildOptionsDocument.ModuleSaBuildOptions item = (ModuleSaBuildOptionsDocument.ModuleSaBuildOptions)returns[0];\r
        return item.getFfsFormatKey();\r
    }\r
\r
    public String getModuleFvBindingKeyword() {\r
        String[] xPath = new String[] { "/" };\r
\r
        Object[] returns = get("ModuleSaBuildOptions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        ModuleSaBuildOptionsDocument.ModuleSaBuildOptions item = (ModuleSaBuildOptionsDocument.ModuleSaBuildOptions)returns[0];\r
        return item.getFvBinding();\r
    }\r
\r
    public List getModuleSupportedArchs() {\r
        String[] xPath = new String[] { "/" };\r
\r
        Object[] returns = get("ModuleDefinitions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        ModuleDefinitionsDocument.ModuleDefinitions item = (ModuleDefinitionsDocument.ModuleDefinitions)returns[0];\r
        return item.getSupportedArchitectures();\r
    }\r
\r
    public BuildOptionsDocument.BuildOptions.Ffs[] getFpdFfs() {\r
        String[] xPath = new String[] {"/Ffs"};\r
\r
        Object[] returns = get("BuildOptions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return new BuildOptionsDocument.BuildOptions.Ffs[0];\r
        }\r
        return (BuildOptionsDocument.BuildOptions.Ffs[])returns;\r
    }\r
\r
    public String getModuleOutputFileBasename() {\r
        String[] xPath = new String[] { "/" };\r
\r
        Object[] returns = get("ModuleDefinitions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        ModuleDefinitionsDocument.ModuleDefinitions item = (ModuleDefinitionsDocument.ModuleDefinitions)returns[0];\r
        return item.getOutputFileBasename();\r
    }\r
\r
    /**\r
     * Retrieve BuildOptions/Option or Arch/Option\r
     *\r
     * @param toolChainFamilyFlag\r
     *            if true, retrieve options for toolchain family; otherwise for\r
     *            toolchain\r
     *\r
     * @returns String[][5] name, target, toolchain, arch, coommand of options\r
     *          if elements are found at the known xpath. String[0][] if dont\r
     *          find element.\r
     *\r
     * @returns Empty array if nothing is there\r
     */\r
    public String[][] getOptions(String from, String[] xPath, boolean toolChainFamilyFlag) {\r
        String target = null;\r
        String toolchain = null;\r
        String toolchainFamily = null;\r
        List<String> archList = null;\r
        String cmd = null;\r
        String optionName = null;\r
\r
        Object[] returns = get(from, xPath);\r
        if (returns == null) {\r
            return new String[0][5];\r
        }\r
\r
        List<String[]> optionList = new ArrayList<String[]>();\r
        OptionDocument.Option option;\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            option = (OptionDocument.Option) returns[i];\r
\r
            //\r
            // Get Target, ToolChain(Family), Arch, Cmd, and Option from Option,\r
            // then\r
            // put to result[][5] array in above order.\r
            //\r
            String[] targetList;\r
            if (option.getBuildTargets() == null) {\r
                target = null;\r
            }\r
            else {\r
                target = option.getBuildTargets().toString();\r
            }\r
            if (target != null) {\r
                targetList = target.split(" ");\r
            } else {\r
                targetList = new String[1];\r
                targetList[0] = null;\r
            }\r
\r
            if (toolChainFamilyFlag) {\r
                toolchainFamily = option.getToolChainFamily();\r
                if (toolchainFamily != null) {\r
                    toolchain = toolchainFamily.toString();\r
                } else {\r
                    toolchain = null;\r
                }\r
            } else {\r
                toolchain = option.getTagName();\r
            }\r
\r
            archList = new ArrayList<String>();\r
            List archEnumList = option.getSupArchList();\r
            if (archEnumList == null) {\r
                archList.add(null);\r
            } else {\r
                //archList.addAll(archEnumList);\r
                Iterator it = archEnumList.iterator();\r
                while (it.hasNext()) {\r
                    String archType = (String)it.next();\r
                    archList.add(archType);\r
                }\r
            }\r
\r
            cmd = option.getToolCode();\r
\r
            optionName = option.getStringValue();\r
            for (int t = 0; t < targetList.length; t++) {\r
                for (int j = 0; j < archList.size(); j++) {\r
                    optionList.add(new String[] { targetList[t],\r
                            toolchain, archList.get(j), cmd, optionName});\r
                }\r
            }\r
        }\r
\r
        String[][] result = new String[optionList.size()][5];\r
        for (int i = 0; i < optionList.size(); i++) {\r
            result[i][0] = optionList.get(i)[0];\r
            result[i][1] = optionList.get(i)[1];\r
            result[i][2] = optionList.get(i)[2];\r
            result[i][3] = optionList.get(i)[3];\r
            result[i][4] = optionList.get(i)[4];\r
        }\r
        return result;\r
    }\r
\r
    public String[][] getModuleBuildOptions(boolean toolChainFamilyFlag) {\r
        String[] xPath;\r
\r
        if (toolChainFamilyFlag == true) {\r
            xPath = new String[] {\r
                    "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",\r
                    "/Options/Option[@ToolChainFamily]", };\r
        } else {\r
            xPath = new String[] {\r
                    "/Options/Option[not(@ToolChainFamily) and not(@TagName)]",\r
                    "/Options/Option[@TagName]", };\r
        }\r
        return getOptions("ModuleSaBuildOptions", xPath, toolChainFamilyFlag);\r
    }\r
\r
    public String[][] getPlatformBuildOptions(boolean toolChainFamilyFlag) {\r
        String[] xPath;\r
\r
        if (toolChainFamilyFlag == true) {\r
            xPath = new String[] {\r
                    "/BuildOptions/Options/Option[not(@ToolChainFamily) and not(@TagName)]",\r
                    "/BuildOptions/Options/Option[@ToolChainFamily]", };\r
        } else {\r
            xPath = new String[] {\r
                    "/BuildOptions/Options/Option[not(@ToolChainFamily) and not(@TagName)]",\r
                    "/BuildOptions/Options/Option[@TagName]", };\r
        }\r
\r
        return getOptions("PlatformSurfaceArea", xPath, toolChainFamilyFlag);\r
    }\r
\r
    public ToolChainInfo getFpdToolChainInfo() {\r
        String[] xPath = new String[] { "/PlatformDefinitions" };\r
\r
        Object[] returns = get("PlatformSurfaceArea", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
\r
        PlatformDefinitionsDocument.PlatformDefinitions item = (PlatformDefinitionsDocument.PlatformDefinitions)returns[0];\r
        ToolChainInfo toolChainInfo = new ToolChainInfo();\r
        toolChainInfo.addTargets(item.getBuildTargets().toString());\r
        toolChainInfo.addArchs(item.getSupportedArchitectures().toString());\r
        toolChainInfo.addTagnames((String)null);\r
        return toolChainInfo;\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 String getModuleType() {\r
        String[] xPath = new String[] { "/ModuleType" };\r
\r
        Object[] 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 PackageDependencies/Package\r
     *\r
     * @param arch\r
     *            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 PackageIdentification[] getDependencePkg(String arch) throws EdkException {\r
        String[] xPath;\r
        String packageGuid = null;\r
        String packageVersion = null;\r
\r
\r
        xPath = new String[] { "/Package" };\r
\r
        Object[] returns = get("PackageDependencies", xPath);\r
        if (returns == null) {\r
            return new PackageIdentification[0];\r
        }\r
\r
        //\r
        //  Get packageIdentification\r
        //\r
        List<PackageIdentification> packageIdList = new ArrayList<PackageIdentification>();\r
        for (int i = 0; i < returns.length; i++) {\r
            PackageDependenciesDocument.PackageDependencies.Package item = (PackageDependenciesDocument.PackageDependencies.Package) returns[i];\r
            List archList = item.getSupArchList();\r
            if (arch == null || archList == null || contains(archList, arch)) {\r
                packageGuid = item.getPackageGuid();\r
                packageVersion = item.getPackageVersion();\r
                PackageIdentification pkgId = new PackageIdentification(null, packageGuid, packageVersion);\r
                GlobalData.refreshPackageIdentification(pkgId);\r
                packageIdList.add(pkgId);\r
            }\r
        }\r
\r
        return packageIdList.toArray(new PackageIdentification[packageIdList.size()]);\r
    }\r
\r
    /**\r
     * Retrieve LibraryClassDefinitions/LibraryClass for specified usage\r
     *\r
     * @param usage\r
     *            Library class usage\r
     *\r
     * @returns LibraryClass objects list if elements are found at the known\r
     *          xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[] getLibraryClasses(String usage, String arch) {\r
        String[] xPath;\r
        if (usage == null || usage.equals("")) {\r
            xPath = new String[] { "/LibraryClass" };\r
        } else {\r
            xPath = new String[] { "/LibraryClass[@Usage='" + usage + "']" };\r
        }\r
\r
        Object[] returns = get("LibraryClassDefinitions", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return new String[0];\r
        }\r
\r
        LibraryClassDocument.LibraryClass[] libraryClassList = (LibraryClassDocument.LibraryClass[]) returns;\r
        List<String> libraryClassName = new ArrayList<String>();\r
        for (int i = 0; i < libraryClassList.length; i++) {\r
			List archList = libraryClassList[i].getSupArchList();\r
\r
			if (arch == null || contains(archList, arch)) {\r
                libraryClassName.add(libraryClassList[i].getKeyword());\r
			}\r
        }\r
\r
        String[] libraryArray = new String[libraryClassName.size()];\r
        libraryClassName.toArray(libraryArray);\r
        return libraryArray;\r
    }\r
\r
    /**\r
     * Retrieve ModuleEntryPoint names\r
     *\r
     * @returns ModuleEntryPoint name list if elements are found at the known\r
     *          xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[] getModuleEntryPointArray() {\r
        String[] xPath = new String[] { "/Extern/ModuleEntryPoint" };\r
\r
        Object[] 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] = ((CNameType) returns[i]).getStringValue();\r
            }\r
\r
            return entryPoints;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     * retrieve Protocol for specified usage\r
     *\r
     * @param usage\r
     *            Protocol usage arch Architecture\r
     *\r
     * @returns Protocol String list if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getProtocolArray(String arch, String usage) {\r
        String[] xPath;\r
        String usageXpath = "";\r
        String archXpath = "";\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            archXpath = "/Protocol";\r
            if (usage != null && !usage.equals("")) {\r
                usageXpath = "/Protocol[@Usage='" + usage + "']";\r
                xPath = new String[] { usageXpath, archXpath };\r
            } else {\r
                return getProtocolArray(arch);\r
            }\r
\r
        }\r
\r
        Object[] returns = get("Protocols", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
        Protocol[] protocolList = (Protocol[]) returns;\r
\r
        String[] protocolArray = new String[returns.length];\r
        for (int i = 0; i < returns.length; i++) {\r
            protocolArray[i] = protocolList[i].getProtocolCName();\r
        }\r
        return protocolArray;\r
    }\r
\r
    /**\r
     * retrieve Protocol for specified usage\r
     *\r
     * @param arch\r
     *            Architecture\r
     *\r
     * @returns Protocol String list if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getProtocolArray(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            xPath = new String[] { "/Protocol" };\r
        }\r
\r
        Object[] returns = get("Protocols", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
        Protocol[] returnlList = (Protocol[]) returns;\r
\r
        List<String> protocolList = new ArrayList<String>();\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            List archList = returnlList[i].getSupArchList();\r
            if (archList == null || contains(archList, arch)){\r
                protocolList.add(returnlList[i].getProtocolCName());\r
            }\r
        }\r
        String[] protocolArray = new String[protocolList.size()];\r
        for (int i = 0; i < protocolList.size(); i++) {\r
            protocolArray[i] = protocolList.get(i);\r
        }\r
        return protocolArray;\r
    }\r
\r
    /**\r
     * Retrieve ProtocolNotify for specified usage\r
     *\r
     * @param usage\r
     *            ProtocolNotify usage\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getProtocolNotifyArray(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            xPath = new String[] { "/ProtocolNotify" };\r
        }\r
\r
        Object[] returns = get("Protocols", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        List<String> protocolNotifyList = new ArrayList<String>();\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            List archList = ((ProtocolNotify) returns[i]).getSupArchList();\r
            if (archList == null || contains(archList, arch)){\r
                protocolNotifyList.add(((ProtocolNotify) returns[i]).getProtocolNotifyCName());\r
            }\r
\r
        }\r
        String[] protocolNotifyArray = new String[protocolNotifyList.size()];\r
        for (int i = 0; i < protocolNotifyList.size(); i++) {\r
            protocolNotifyArray[i] = protocolNotifyList.get(i);\r
        }\r
        return protocolNotifyArray;\r
    }\r
\r
    /**\r
     * Retrieve ProtocolNotify for specified usage\r
     *\r
     * @param usage\r
     *            ProtocolNotify usage\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getProtocolNotifyArray(String arch, String usage) {\r
\r
        String[] xPath;\r
        String usageXpath;\r
        String archXpath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            archXpath = "/ProtocolNotify";\r
            if (usage != null && !usage.equals("")) {\r
                usageXpath = "/ProtocolNotify[@Usage='" + arch + "']";\r
                xPath = new String[] { archXpath, usageXpath };\r
            } else {\r
                return getProtocolNotifyArray(arch);\r
            }\r
        }\r
\r
        Object[] returns = get("Protocols", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        String[] protocolNotifyList = new String[returns.length];\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            protocolNotifyList[i] = ((ProtocolNotify) returns[i]).getProtocolNotifyCName();\r
        }\r
        return protocolNotifyList;\r
    }\r
\r
    /**\r
     * Retrieve ModuleUnloadImage names\r
     *\r
     * @returns ModuleUnloadImage name list if elements are found at the known\r
     *          xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[] getModuleUnloadImageArray() {\r
        String[] xPath = new String[] { "/Extern/ModuleUnloadImage" };\r
\r
        Object[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            String[] stringArray = new String[returns.length];\r
            CNameType[] doc = (CNameType[]) 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 ExternsDocument.Externs.Extern[] getExternArray() {\r
        String[] xPath = new String[] { "/Extern" };\r
\r
        Object[] 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 PpiNotify for specified arch\r
     *\r
     * @param arch\r
     *            PpiNotify arch\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getPpiNotifyArray(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            xPath = new String[] { "/PpiNotify" };\r
        }\r
\r
        Object[] returns = get("PPIs", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
\r
        List<String> ppiNotifyList = new ArrayList<String>();\r
        for (int i = 0; i < returns.length; i++) {\r
            List archList = ((PPIsDocument.PPIs.PpiNotify) returns[i]).getSupArchList();\r
            if (archList == null || contains(archList, arch)){\r
                ppiNotifyList.add(((PPIsDocument.PPIs.PpiNotify) returns[i]).getPpiNotifyCName());\r
            }\r
\r
        }\r
        String[] ppiNotifyArray = new String[ppiNotifyList.size()];\r
        for (int i = 0; i < ppiNotifyList.size(); i++) {\r
            ppiNotifyArray[i] = ppiNotifyList.get(i);\r
        }\r
\r
        return ppiNotifyArray;\r
    }\r
\r
    /**\r
     * Retrieve PpiNotify for specified usage and arch\r
     *\r
     * @param arch\r
     *            PpiNotify arch usage PpiNotify usage\r
     *\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getPpiNotifyArray(String arch, String usage) {\r
\r
        String[] xPath;\r
        String usageXpath;\r
        String archXpath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            archXpath = "/PpiNotify";\r
            if (usage != null && !usage.equals("")) {\r
                usageXpath = "/PpiNotify[@Usage='" + arch + "']";\r
                xPath = new String[] { archXpath, usageXpath };\r
            } else {\r
                return getProtocolNotifyArray(arch);\r
            }\r
        }\r
\r
        Object[] returns = get("PPIs", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        String[] ppiNotifyList = new String[returns.length];\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            ppiNotifyList[i] = ((PPIsDocument.PPIs.PpiNotify) returns[i]).getPpiNotifyCName();\r
        }\r
        return ppiNotifyList;\r
    }\r
\r
    /**\r
     * Retrieve Ppi for specified arch\r
     *\r
     * @param arch\r
     *            Ppi arch\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getPpiArray(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            xPath = new String[] { "/Ppi" };\r
        }\r
\r
        Object[] returns = get("PPIs", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        List<String> ppiList = new ArrayList<String>();\r
        for (int i = 0; i < returns.length; i++) {\r
            List archList = ((PPIsDocument.PPIs.Ppi) returns[i]).getSupArchList();\r
            if (archList == null || contains(archList, arch)){\r
                ppiList.add(((PPIsDocument.PPIs.Ppi) returns[i]).getPpiCName());\r
            }\r
\r
        }\r
        String[] ppiArray = new String[ppiList.size()];\r
        for (int i = 0; i < ppiList.size(); i++) {\r
            ppiArray[i] = ppiList.get(i);\r
        }\r
        return ppiArray;\r
    }\r
\r
    /**\r
     * Retrieve PpiNotify for specified usage and arch\r
     *\r
     * @param arch\r
     *            PpiNotify arch usage PpiNotify usage\r
     *\r
     *\r
     * @returns String[] if elements are found at the known xpath\r
     * @returns String[0] if nothing is there\r
     */\r
    public String[] getPpiArray(String arch, String usage) {\r
\r
        String[] xPath;\r
        String usageXpath;\r
        String archXpath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            archXpath = "/Ppi";\r
            if (usage != null && !usage.equals("")) {\r
                usageXpath = "/Ppi[@Usage='" + arch + "']";\r
                xPath = new String[] { archXpath, usageXpath };\r
            } else {\r
                return getProtocolNotifyArray(arch);\r
            }\r
        }\r
\r
        Object[] returns = get("PPIs", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        String[] ppiList = new String[returns.length];\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            ppiList[i] = ((PPIsDocument.PPIs.Ppi) returns[i]).getPpiCName();\r
        }\r
        return ppiList;\r
    }\r
\r
    /**\r
     * Retrieve GuidEntry information for specified usage\r
     *\r
     * @param arch\r
     *            GuidEntry arch\r
     *\r
     * @returns GuidEntry objects list if elements are found at the known xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[] getGuidEntryArray(String arch) {\r
        String[] xPath;\r
\r
        if (arch == null || arch.equals("")) {\r
            xPath = new String[] { "/GuidCNames" };\r
        } else {\r
            xPath = new String[] { "/GuidCNames" };\r
        }\r
\r
        Object[] returns = get("Guids", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        List<String> guidList = new ArrayList<String>();\r
        for (int i = 0; i < returns.length; i++) {\r
            List archList = ((GuidsDocument.Guids.GuidCNames) returns[i]).getSupArchList();\r
            if (archList == null || contains(archList, arch)){\r
                guidList.add(((GuidsDocument.Guids.GuidCNames) returns[i]).getGuidCName());\r
            }\r
\r
        }\r
        String[] guidArray = new String[guidList.size()];\r
        for (int i = 0; i < guidList.size(); i++) {\r
            guidArray[i] = guidList.get(i);\r
        }\r
        return guidArray;\r
\r
    }\r
\r
    /**\r
     * Retrieve GuidEntry information for specified usage\r
     *\r
     * @param arch\r
     *            GuidEntry arch 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 String[] getGuidEntryArray(String arch, String usage) {\r
        String[] xPath;\r
        String archXpath;\r
        String usageXpath;\r
\r
        if (arch == null || arch.equals("")) {\r
            return new String[0];\r
        } else {\r
            archXpath = "/GuidEntry";\r
            if (usage != null && !usage.equals("")) {\r
                usageXpath = "/GuidEntry[@Usage='" + arch + "']";\r
                xPath = new String[] { archXpath, usageXpath };\r
            } else {\r
                return getProtocolNotifyArray(arch);\r
            }\r
        }\r
\r
        Object[] returns = get("Guids", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        String[] guidList = new String[returns.length];\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            guidList[i] = ((GuidsDocument.Guids.GuidCNames) returns[i]).getGuidCName();\r
        }\r
        return guidList;\r
    }\r
\r
    /**\r
     * Retrieve Library instance information\r
     *\r
     * @param arch\r
     *            Architecture name\r
     * @param usage\r
     *            Library instance usage\r
     *\r
     * @returns library instance name list if elements are found at the known\r
     *          xpath\r
     * @returns null if nothing is there\r
     */\r
    public ModuleIdentification[] getLibraryInstance(String arch) throws EdkException {\r
        String[] xPath;\r
        String saGuid = null;\r
        String saVersion = null;\r
        String pkgGuid = null;\r
        String pkgVersion = null;\r
\r
        if (arch == null || arch.equalsIgnoreCase("")) {\r
            xPath = new String[] { "/Instance" };\r
        } else {\r
            //\r
            // Since Schema don't have SupArchList now, so the follow Xpath is\r
            // equal to "/Instance" and [not(@SupArchList) or @SupArchList= arch]\r
            // don't have effect.\r
            //\r
            xPath = new String[] { "/Instance[not(@SupArchList) or @SupArchList='"\r
                    + arch + "']" };\r
        }\r
\r
        Object[] returns = get("Libraries", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return new ModuleIdentification[0];\r
        }\r
\r
        ModuleIdentification[] saIdList = new ModuleIdentification[returns.length];\r
        for (int i = 0; i < returns.length; i++) {\r
            LibrariesDocument.Libraries.Instance library = (LibrariesDocument.Libraries.Instance) returns[i];\r
            saGuid = library.getModuleGuid();\r
            saVersion = library.getModuleVersion();\r
\r
            pkgGuid = library.getPackageGuid();\r
            pkgVersion = library.getPackageVersion();\r
\r
            ModuleIdentification saId = new ModuleIdentification(null, saGuid,\r
                    saVersion);\r
            PackageIdentification pkgId = new PackageIdentification(null,\r
                    pkgGuid, pkgVersion);\r
            GlobalData.refreshPackageIdentification(pkgId);\r
            saId.setPackage(pkgId);\r
            GlobalData.refreshModuleIdentification(saId);\r
\r
            saIdList[i] = saId;\r
\r
        }\r
        return saIdList;\r
    }\r
\r
    // /\r
    // / This method is used for retrieving the elements information which has\r
    // / CName sub-element\r
    // /\r
    private String[] getCNames(String from, String xPath[]) {\r
        Object[] 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
            // TBD\r
             strings[i] = ((CNameType) 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 String getLibConstructorName() {\r
        String[] xPath = new String[] { "/Extern/Constructor" };\r
\r
        Object[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            CNameType constructor = ((CNameType) 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 String getLibDestructorName() {\r
        String[] xPath = new String[] { "/Extern/Destructor" };\r
\r
        Object[] returns = get("Externs", xPath);\r
        if (returns != null && returns.length > 0) {\r
            //\r
            // Only support one Destructor function.\r
            //\r
             CNameType destructor = (CNameType) 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 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 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 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 String[] getDriverDiagArray() {\r
        String[] xPath = new String[] { "/Extern/DriverDiag" };\r
        return getCNames("Externs", xPath);\r
    }\r
\r
    /**\r
     * Retrive DriverBinding, ComponentName, DriverConfig,\r
     * DriverDiag group array\r
     * \r
     * @returns DriverBinding group name list if elements are found\r
     *        at the known xpath\r
     * @returns null if nothing is there\r
     */\r
	public String[][] getExternProtocolGroup() {\r
		String[] xPath = new String[] {"/Extern"};\r
		Object[] returns = get("Externs",xPath);\r
\r
        if (returns == null) {\r
			return new String[0][4];\r
		}\r
		List<Extern> externList = new ArrayList<Extern>();\r
		for (int i = 0; i < returns.length; i++) {\r
			org.tianocore.ExternsDocument.Externs.Extern extern = (org.tianocore.ExternsDocument.Externs.Extern)returns[i];\r
			if (extern.getDriverBinding() != null) {\r
				externList.add(extern);\r
			}\r
		}\r
\r
		String[][] externGroup = new String[externList.size()][4];\r
		for (int i = 0; i < externList.size(); i++) {\r
            String driverBindingStr = externList.get(i).getDriverBinding();\r
			if ( driverBindingStr != null){\r
				externGroup[i][0] = driverBindingStr;\r
			} else {\r
				externGroup[i][0] = null;\r
			}\r
\r
			String componentNameStr = externList.get(i).getComponentName();\r
			if (componentNameStr != null) {\r
				externGroup[i][1] = componentNameStr;\r
			} else {\r
				externGroup[i][1] = null;\r
			}\r
\r
			String driverConfigStr = externList.get(i).getDriverConfig();\r
			if (driverConfigStr != null) {\r
				externGroup[i][2] = driverConfigStr;\r
			} else {\r
				externGroup[i][2] = null;\r
			}\r
\r
			String driverDiagStr = externList.get(i).getDriverDiag();\r
			if (driverDiagStr != null) {\r
			    externGroup[i][3] = driverDiagStr;\r
			} else {\r
				externGroup[i][3] = null;\r
			}\r
		}\r
		return externGroup;\r
	}\r
    \r
    /**\r
     * Retrive SetVirtualAddressMapCallBack names\r
     *\r
     * @returns SetVirtualAddressMapCallBack name list if elements are found at\r
     *          the known xpath\r
     * @returns null if nothing is there\r
     */\r
    public 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 if elements are found at the\r
     *          known xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[] getExitBootServicesCallBackArray() {\r
        String[] xPath = new String[] { "/Extern/ExitBootServicesCallBack" };\r
        return getCNames("Externs", xPath);\r
    }\r
\r
    /**\r
      Judge whether current driver is PEI_PCD_DRIVER or DXE_PCD_DRIVER or\r
      NOT_PCD_DRIVER.\r
      \r
      @return CommonDefinition.PCD_DRIVER_TYPE  the type of current driver\r
    **/\r
    public CommonDefinition.PCD_DRIVER_TYPE getPcdDriverType() {\r
        String[] xPath   = new String[] {"/PcdIsDriver"};\r
        Object[] results = get ("Externs", xPath);\r
\r
        if (results != null && results.length != 0) {\r
            PcdDriverTypes type     = (PcdDriverTypes) results[0];\r
            String         typeStr  = type.enumValue().toString();\r
            if (typeStr.equals(CommonDefinition.PCD_DRIVER_TYPE.PEI_PCD_DRIVER.toString())) {\r
                return CommonDefinition.PCD_DRIVER_TYPE.PEI_PCD_DRIVER;\r
            } else if (typeStr.equals(CommonDefinition.PCD_DRIVER_TYPE.DXE_PCD_DRIVER.toString())) {\r
                return CommonDefinition.PCD_DRIVER_TYPE.DXE_PCD_DRIVER;\r
            }\r
            return CommonDefinition.PCD_DRIVER_TYPE.UNKNOWN_PCD_DRIVER;\r
        }\r
\r
        return CommonDefinition.PCD_DRIVER_TYPE.NOT_PCD_DRIVER;\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 Map<FpdModuleIdentification, Map<String, XmlObject>> getFpdModules() throws EdkException {\r
        String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };\r
        Object[] result = get("PlatformSurfaceArea", xPath);\r
        String arch = null;\r
        String fvBinding = null;\r
        String saGuid = null;\r
        String saVersion = null;\r
        String pkgGuid = null;\r
        String pkgVersion = null;\r
\r
        Map<FpdModuleIdentification, Map<String, XmlObject>> fpdModuleMap = new LinkedHashMap<FpdModuleIdentification, Map<String, XmlObject>>();\r
\r
        if (result == null) {\r
            return fpdModuleMap;\r
        }\r
\r
        for (int i = 0; i < result.length; i++) {\r
            //\r
            // Get Fpd SA Module element node and add to ObjectMap.\r
            //\r
            Map<String, XmlObject> ObjectMap = new HashMap<String, XmlObject>();\r
            ModuleSADocument.ModuleSA moduleSA = (ModuleSADocument.ModuleSA) result[i];\r
            if (((ModuleSADocument.ModuleSA) result[i]).getLibraries() != null) {\r
                ObjectMap.put("Libraries", moduleSA.getLibraries());\r
            }\r
            if (((ModuleSADocument.ModuleSA) result[i]).getPcdBuildDefinition() != null) {\r
                ObjectMap.put("PcdBuildDefinition", moduleSA.getPcdBuildDefinition());\r
            }\r
            if (((ModuleSADocument.ModuleSA) result[i]).getModuleSaBuildOptions() != null) {\r
                ObjectMap.put("ModuleSaBuildOptions", moduleSA.getModuleSaBuildOptions());\r
            }\r
\r
            //\r
            // Get Fpd SA Module attribute and create FpdMoudleIdentification.\r
            //\r
            if (moduleSA.isSetSupArchList()) {\r
                arch = moduleSA.getSupArchList().toString();\r
            } else {\r
                arch = null;\r
            }\r
\r
            // TBD\r
            fvBinding = null;\r
            saVersion = ((ModuleSADocument.ModuleSA) result[i]).getModuleVersion();\r
\r
            saGuid = moduleSA.getModuleGuid();\r
            pkgGuid = moduleSA.getPackageGuid();\r
            pkgVersion = moduleSA.getPackageVersion();\r
\r
            //\r
            // Create Module Identification which have class member of package\r
            // identification.\r
            //\r
            PackageIdentification pkgId = new PackageIdentification(null, pkgGuid, pkgVersion);\r
            GlobalData.refreshPackageIdentification(pkgId);\r
            \r
            ModuleIdentification saId = new ModuleIdentification(null, saGuid, saVersion);\r
            saId.setPackage(pkgId);\r
            GlobalData.refreshModuleIdentification(saId);\r
            \r
\r
\r
            //\r
            // Create FpdModule Identification which have class member of module\r
            // identification\r
            //\r
            String[] archList = new String[0];\r
            if (arch == null || arch.trim().length() == 0) {\r
                archList = GlobalData.getToolChainInfo().getArchs();\r
            } else {\r
                archList = arch.split(" ");\r
            }\r
            for (int j = 0; j < archList.length; j++) {\r
                FpdModuleIdentification fpdSaId = new FpdModuleIdentification(saId, archList[j]);\r
\r
                if (fvBinding != null) {\r
                    fpdSaId.setFvBinding(fvBinding);\r
                }\r
\r
                //\r
                // Put element to Map<FpdModuleIdentification, Map<String,\r
                // Object>>.\r
                //\r
                fpdModuleMap.put(fpdSaId, ObjectMap);\r
            }\r
        }\r
        return fpdModuleMap;\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 String[] getFpdValidImageNames() {\r
        String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='ImageName']/FvImageNames" };\r
\r
        Object[] queryResult = get("PlatformSurfaceArea", 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
    public Node getFpdUserExtensionPreBuild() {\r
        String[] xPath = new String[] { "/UserExtensions[@UserID='TianoCore' and @Identifier='0']" };\r
\r
        Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
        if (queryResult == null || queryResult.length == 0) {\r
            return null;\r
        }\r
        UserExtensionsDocument.UserExtensions a =  (UserExtensionsDocument.UserExtensions)queryResult[0];\r
\r
        return a.getDomNode();\r
    }\r
\r
    public Node getFpdUserExtensionPostBuild() {\r
        String[] xPath = new String[] { "/UserExtensions[@UserID='TianoCore' and @Identifier='1']" };\r
\r
        Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
        if (queryResult == null || queryResult.length == 0) {\r
            return null;\r
        }\r
        UserExtensionsDocument.UserExtensions a =  (UserExtensionsDocument.UserExtensions)queryResult[0];\r
\r
        return a.getDomNode();\r
    }\r
\r
    /**\r
     * Retrieve FV image option information\r
     *\r
     * @param fvName\r
     *            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 String[][] getFpdOptions(String fvName) {\r
           String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Options' and ./FvImageNames='"\r
                      + fvName + "']/FvImageOptions" };\r
           Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
           if (queryResult == null) {\r
                 return new String[0][];\r
           }\r
           ArrayList<String[]> list = new ArrayList<String[]>();\r
           for (int i = 0; i < queryResult.length; i++) {\r
               FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];\r
               List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item\r
               .getNameValueList();\r
               Iterator iter = namevalues.iterator();\r
               while (iter.hasNext()) {\r
                   FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter\r
                   .next();\r
                   list.add(new String[] { nvItem.getName(), nvItem.getValue() });\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
          return result;\r
\r
    }\r
\r
    public XmlObject getFpdBuildOptions() {\r
        String[] xPath = new String[] { "/BuildOptions" };\r
\r
        Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
\r
        if (queryResult == null || queryResult.length == 0) {\r
            return null;\r
        }\r
        return (XmlObject)queryResult[0];\r
    }\r
\r
    public PlatformIdentification getFpdHeader() {\r
        String[] xPath = new String[] { "/PlatformHeader" };\r
\r
        Object[] returns = get("PlatformSurfaceArea", xPath);\r
\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
        PlatformHeaderDocument.PlatformHeader header = (PlatformHeaderDocument.PlatformHeader) returns[0];\r
\r
        String name = header.getPlatformName();\r
\r
        String guid = header.getGuidValue();\r
\r
        String version = header.getVersion();\r
\r
        return new PlatformIdentification(name, guid, version);\r
    }\r
\r
    /**\r
     * Retrieve FV image attributes information\r
     *\r
     * @param fvName\r
     *            FV image name\r
     *\r
     * @returns attribute name/value list if elements are found at the known\r
     *          xpath\r
     * @returns empty list if nothing is there\r
     */\r
    public String[][] getFpdAttributes(String fvName) {\r
        String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Attributes' and ./FvImageNames='"\r
                         + fvName + "']/FvImageOptions" };\r
        Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
        if (queryResult == null) {\r
             return new String[0][];\r
        }\r
        ArrayList<String[]> list = new ArrayList<String[]>();\r
        for (int i = 0; i < queryResult.length; i++) {\r
\r
            FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];\r
            List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item.getNameValueList();\r
            Iterator iter = namevalues.iterator();\r
            while (iter.hasNext()) {\r
                FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter\r
                 .next();\r
                 list.add(new String[] { nvItem.getName(), nvItem.getValue() });\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
       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 String getFlashDefinitionFile() {\r
        String[] xPath = new String[] { "/PlatformDefinitions/FlashDeviceDefinitions/FlashDefinitionFile" };\r
\r
        Object[] queryResult = get("PlatformSurfaceArea", 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
    public String[][] getFpdGlobalVariable() {\r
        String[] xPath = new String[] { "/Flash/FvImages/NameValue" };\r
        Object[] queryResult = get("PlatformSurfaceArea", xPath);\r
        if (queryResult == null) {\r
            return new String[0][];\r
        }\r
\r
        String[][] result = new String[queryResult.length][2];\r
\r
        for (int i = 0; i < queryResult.length; i++) {\r
            FvImagesDocument.FvImages.NameValue item = (FvImagesDocument.FvImages.NameValue)queryResult[i];\r
            result[i][0] = item.getName();\r
            result[i][1] = item.getValue();\r
        }\r
        return result;\r
    }\r
\r
    /**\r
     * Retrieve FV image component options\r
     *\r
     * @param fvName\r
     *            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 String[][] getFpdComponents(String fvName) {\r
        String[] xPath = new String[] { "/Flash/FvImages/FvImage[@Type='Components' and ./FvImageNames='"+ fvName + "']/FvImageOptions" };\r
        Object[] queryResult = get("PlatformSurfaceArea", 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
        FvImagesDocument.FvImages.FvImage.FvImageOptions item = (FvImagesDocument.FvImages.FvImage.FvImageOptions) queryResult[i];\r
        List<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> namevalues = item.getNameValueList();\r
        Iterator iter = namevalues.iterator();\r
        while (iter.hasNext()) {\r
            FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nvItem = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue) iter\r
                        .next();\r
                   list.add(new String[] { nvItem.getName(), nvItem.getValue() });\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
            return result;\r
    }\r
\r
    /**\r
     * Retrieve PCD tokens\r
     *\r
     * @returns CName/ItemType pairs list if elements are found at the known\r
     *          xpath\r
     * @returns null if nothing is there\r
     */\r
    public String[][] getPcdTokenArray() {\r
        String[] xPath = new String[] { "/PcdData" };\r
\r
        Object[] returns = get("PCDs", xPath);\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
\r
        return null;\r
    }\r
\r
    /**\r
     * Retrieve MAS header\r
     *\r
     * @return\r
     * @return\r
     */\r
    public ModuleIdentification getMsaHeader() {\r
        String[] xPath = new String[] { "/" };\r
        Object[] returns = get("MsaHeader", xPath);\r
\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
\r
        MsaHeader msaHeader = (MsaHeader) returns[0];\r
        //\r
        // Get BaseName, ModuleType, GuidValue, Version\r
        // which in MsaHeader.\r
        //\r
        String name = msaHeader.getModuleName();\r
        String moduleType = msaHeader.getModuleType().toString();\r
        String guid = msaHeader.getGuidValue();\r
        String version = msaHeader.getVersion();\r
\r
        ModuleIdentification moduleId = new ModuleIdentification(name, guid,\r
                version);\r
\r
        moduleId.setModuleType(moduleType);\r
\r
        return moduleId;\r
    }\r
\r
    /**\r
     * Retrieve Extern Specification\r
     *\r
     * @param\r
     *\r
     * @return String[] If have specification element in the <extern> String[0]\r
     *         If no specification element in the <extern>\r
     *\r
     */\r
\r
    public String[] getExternSpecificaiton() {\r
        String[] xPath = new String[] { "/Specification" };\r
\r
        Object[] queryResult = get("Externs", xPath);\r
        if (queryResult == null) {\r
            return new String[0];\r
        }\r
\r
        String[] specificationList = new String[queryResult.length];\r
        for (int i = 0; i < queryResult.length; i++) {\r
             specificationList[i] = ((Sentence)queryResult[i])\r
             .getStringValue();\r
        }\r
        return specificationList;\r
    }\r
\r
    /**\r
     * Retreive MsaFile which in SPD\r
     *\r
     * @param\r
     * @return String[][3] The string sequence is ModuleName, ModuleGuid,\r
     *         ModuleVersion, MsaFile String[0][] If no msafile in SPD\r
     */\r
    public String[] getSpdMsaFile() {\r
        String[] xPath = new String[] { "/MsaFiles" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        List<String> filenameList = ((MsaFilesDocument.MsaFiles) returns[0])\r
                .getFilenameList();\r
        return filenameList.toArray(new String[filenameList.size()]);\r
    }\r
\r
    /**\r
     * Reteive\r
     */\r
    public Map<String, String[]> getSpdLibraryClasses() {\r
        String[] xPath = new String[] { "/LibraryClassDeclarations/LibraryClass" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        //\r
        // Create Map, Key - LibraryClass, String[] - LibraryClass Header file.\r
        //\r
        Map<String, String[]> libClassHeaderMap = new HashMap<String, String[]>();\r
\r
        if (returns == null) {\r
            return libClassHeaderMap;\r
        }\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass library = (LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass) returns[i];\r
            libClassHeaderMap.put(library.getName(), new String[] { library\r
                    .getIncludeHeader() });\r
        }\r
        return libClassHeaderMap;\r
    }\r
\r
    /**\r
     * Reteive\r
     */\r
    public Map<String, String> getSpdPackageHeaderFiles() {\r
        String[] xPath = new String[] { "/PackageHeaders/IncludePkgHeader" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        //\r
        // Create Map, Key - ModuleType, String - PackageInclude Header file.\r
        //\r
        Map<String, String> packageIncludeMap = new HashMap<String, String>();\r
\r
        if (returns == null) {\r
            return packageIncludeMap;\r
        }\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            PackageHeadersDocument.PackageHeaders.IncludePkgHeader includeHeader = (PackageHeadersDocument.PackageHeaders.IncludePkgHeader) returns[i];\r
            packageIncludeMap.put(includeHeader.getModuleType().toString(),\r
                    includeHeader.getStringValue());\r
        }\r
        return packageIncludeMap;\r
    }\r
\r
    public PackageIdentification getSpdHeader() {\r
        String[] xPath = new String[] { "/SpdHeader" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        if (returns == null || returns.length == 0) {\r
            return null;\r
        }\r
\r
        SpdHeaderDocument.SpdHeader header = (SpdHeaderDocument.SpdHeader) returns[0];\r
\r
        String name = header.getPackageName();\r
\r
        String guid = header.getGuidValue();\r
\r
        String version = header.getVersion();\r
\r
        return new PackageIdentification(name, guid, version);\r
    }\r
\r
    /**\r
     * Reteive\r
     */\r
    public Map<String, String[]> getSpdGuid() {\r
        String[] xPath = new String[] { "/GuidDeclarations/Entry" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        //\r
        // Create Map, Key - GuidName, String[] - C_NAME & GUID value.\r
        //\r
        Map<String, String[]> guidDeclMap = new HashMap<String, String[]>();\r
        if (returns == null) {\r
            return guidDeclMap;\r
        }\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            GuidDeclarationsDocument.GuidDeclarations.Entry entry = (GuidDeclarationsDocument.GuidDeclarations.Entry) returns[i];\r
            String[] guidPair = new String[2];\r
            guidPair[0] = entry.getCName();\r
            guidPair[1] = entry.getGuidValue();\r
            guidDeclMap.put(entry.getCName(), guidPair);\r
        }\r
        return guidDeclMap;\r
    }\r
\r
    /**\r
     * Reteive\r
     */\r
    public Map<String, String[]> getSpdProtocol() {\r
        String[] xPath = new String[] { "/ProtocolDeclarations/Entry" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        //\r
        // Create Map, Key - protocolName, String[] - C_NAME & GUID value.\r
        //\r
        Map<String, String[]> protoclMap = new HashMap<String, String[]>();\r
\r
        if (returns == null) {\r
            return protoclMap;\r
        }\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            ProtocolDeclarationsDocument.ProtocolDeclarations.Entry entry = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry) returns[i];\r
            String[] protocolPair = new String[2];\r
\r
            protocolPair[0] = entry.getCName();\r
            protocolPair[1] = entry.getGuidValue();\r
            protoclMap.put(entry.getCName(), protocolPair);\r
        }\r
        return protoclMap;\r
    }\r
\r
    /**\r
     * getSpdPpi() Retrieve the SPD PPI Entry\r
     *\r
     * @param\r
     * @return Map<String, String[2]> if get the PPI entry from SPD. Key - PPI\r
     *         Name String[0] - PPI CNAME String[1] - PPI Guid Null if no PPI\r
     *         entry in SPD.\r
     */\r
    public Map<String, String[]> getSpdPpi() {\r
        String[] xPath = new String[] { "/PpiDeclarations/Entry" };\r
\r
        Object[] returns = get("PackageSurfaceArea", xPath);\r
\r
        //\r
        // Create Map, Key - protocolName, String[] - C_NAME & GUID value.\r
        //\r
        Map<String, String[]> ppiMap = new HashMap<String, String[]>();\r
\r
        if (returns == null) {\r
            return ppiMap;\r
        }\r
\r
        for (int i = 0; i < returns.length; i++) {\r
            PpiDeclarationsDocument.PpiDeclarations.Entry entry = (PpiDeclarationsDocument.PpiDeclarations.Entry) returns[i];\r
            String[] ppiPair = new String[2];\r
            ppiPair[0] = entry.getCName();\r
            ppiPair[1] = entry.getGuidValue();\r
            ppiMap.put(entry.getCName(), ppiPair);\r
        }\r
        return ppiMap;\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 String getModuleGuid() {\r
        String[] xPath = new String[] { "" };\r
\r
        Object[] returns = get("MsaHeader", xPath);\r
        if (returns != null && returns.length > 0) {\r
            String guid = ((MsaHeaderDocument.MsaHeader) returns[0])\r
                    .getGuidValue();\r
            return guid;\r
        }\r
\r
        return null;\r
    }\r
\r
    //\r
    // For new Pcd\r
    //\r
    public ModuleSADocument.ModuleSA[] getFpdModuleSAs() {\r
        String[] xPath = new String[] { "/FrameworkModules/ModuleSA" };\r
        Object[] result = get("PlatformSurfaceArea", xPath);\r
        if (result != null) {\r
            return (ModuleSADocument.ModuleSA[]) result;\r
        }\r
        return new ModuleSADocument.ModuleSA[0];\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 String[] getModulePcdEntryNameArray() {\r
        PcdCodedDocument.PcdCoded.PcdEntry[] pcdEntries  = null;\r
        String[]            results;\r
        int                 index;\r
        String[]            xPath       = new String[] {"/PcdEntry"};\r
        Object[]         returns     = get ("PcdCoded", xPath);\r
\r
        if (returns == null) {\r
            return new String[0];\r
        }\r
\r
        pcdEntries = (PcdCodedDocument.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
    /**\r
     Search in a List for a given string\r
\r
     @return boolean\r
     **/\r
    public boolean contains(List list, String str) {\r
		if (list == null || list.size()== 0) {\r
			return true;\r
		}\r
        Iterator it = list.iterator();\r
        while (it.hasNext()) {\r
            String s = (String)it.next();\r
            if (s.equalsIgnoreCase(str)) {\r
                return true;\r
            }\r
        }\r
\r
        return false;\r
    }\r
\r
	public boolean isHaveTianoR8FlashMap(){\r
        String[]            xPath       = new String[] {"/"};\r
        Object[]         returns     = get ("Externs", xPath);\r
\r
        if (returns == null) {\r
            return false;\r
        }\r
\r
		ExternsDocument.Externs ext = (ExternsDocument.Externs)returns[0];\r
\r
		if (ext.getTianoR8FlashMapH()){\r
			return true;\r
	    }else {\r
			return false;\r
		}\r
	}\r
    \r
    public Node getFpdModuleSequence(String fvName) {\r
        String[] xPath = new String[] { "/BuildOptions/UserExtensions[@UserID='IMAGES' and @Identifier='1' and ./FvName='" + fvName + "']" };\r
        Object[] result = get("PlatformSurfaceArea", xPath);\r
        \r
        if (result == null || result.length == 0) {\r
            return null;\r
        }\r
        \r
        UserExtensionsDocument.UserExtensions a =  (UserExtensionsDocument.UserExtensions)result[0];\r
        \r
        return a.getDomNode();\r
    }\r
}\r