* This class defines extensions to the XPath parser to handle the additional

* syntax supported in XQuery

*/

    private boolean memoFunction = false;

    private boolean disableCycleChecks = false;

    private int errorCount = 0;

    private XPathException firstError = null;

    protected Executable executable;

    private boolean foundCopyNamespaces = false;

    private boolean foundBoundarySpaceDeclaration = false;

    private boolean foundOrderingDeclaration = false;

    private boolean foundEmptyOrderingDeclaration = false;

    private boolean foundDefaultCollation = false;

    private boolean foundConstructionDeclaration = false;

    private boolean foundDefaultFunctionNamespace = false;

    private boolean foundDefaultElementNamespace = false;

    private boolean foundBaseURIDeclaration = false;

    private boolean preambleProcessed = false;

    public Set importedModules = new HashSet(5);

    List namespacesToBeSealed = new ArrayList(10);

    List schemaImports = new ArrayList(5);

    List moduleImports = new ArrayList(5);

    private Expression defaultValue = null;

    /**

     * Constructor for internal use: this class should be instantiated via the QueryModule

     */

    public QueryParser() {

    }

    /**

     * Create an XQueryExpression

     * @param query the source text of the query

     * @param staticContext the static context of the query

     * @param config the Saxon configuration

     * @return the compiled XQuery expression

     */

    public XQueryExpression makeXQueryExpression(String query,

                                                 QueryModule staticContext,

                                                 Configuration config) throws XPathException {

        try {

            if (config.getXMLVersion() == Configuration.XML10) {

                query = normalizeLineEndings10(query);

            } else {

                query = normalizeLineEndings11(query);

            }

            Executable exec = staticContext.getExecutable();

            if (exec == null) {

                exec = new Executable(config);

                exec.setHostLanguage(Configuration.XQUERY);

                staticContext.setExecutable(exec);

            }

            Properties outputProps = new Properties();

            outputProps.setProperty(OutputKeys.METHOD, "xml");

            outputProps.setProperty(OutputKeys.INDENT, "yes");

            exec.setDefaultOutputProperties(outputProps);

            exec.setLocationMap(new LocationMap());

            exec.setFunctionLibrary(new ExecutableFunctionLibrary(config));

            // this will be changed later

            setExecutable(exec);

            Expression exp = parseQuery(query, 0, Token.EOF, staticContext);

            int loc = env.getLocationMap().allocateLocationId(env.getSystemId(), 1);

            exp.setContainer(new TemporaryContainer(staticContext.getLocationMap(), loc));

            //staticContext.bindUnboundFunctionCalls();

            exec.fixupQueryModules(staticContext);

            // Check for cyclic dependencies among the modules

            if (!disableCycleChecks) {

                Iterator miter = exec.getQueryLibraryModules();

                while (miter.hasNext()) {

                    QueryModule module = (QueryModule)miter.next();

                    module.lookForModuleCycles(new Stack(), 1);

                }

            }

            // Make the XQueryexpression object

            XQueryExpression queryExp = new XQueryExpression(exp, exec, staticContext, config);

            //exp = queryExp.getExpression();

            // Make the function library that's available at run-time (e.g. for saxon:evaluate()). This includes

            // all user-defined functions regardless of which module they are in

            FunctionLibrary userlib = exec.getFunctionLibrary();

            FunctionLibraryList lib = new FunctionLibraryList();

            lib.addFunctionLibrary(

                    SystemFunctionLibrary.getSystemFunctionLibrary(SystemFunctionLibrary.XPATH_ONLY));

            lib.addFunctionLibrary(config.getVendorFunctionLibrary());

            lib.addFunctionLibrary(new ConstructorFunctionLibrary(config));

            if (config.isAllowExternalFunctions()) {

                Configuration.getPlatform().addFunctionLibraries(lib, config, Configuration.XQUERY);

            }

            lib.addFunctionLibrary(userlib);

            exec.setFunctionLibrary(lib);