Example usage for org.xml.sax XMLReader setContentHandler

List of usage examples for org.xml.sax XMLReader setContentHandler

  1. HOME
  2. Java
  3. org.xml
  4. org.xml.sax.*
  5. XMLReader
  6. setContentHandler

Introduction

In this page you can find the example usage for org.xml.sax XMLReader setContentHandler.

Prototype

public void setContentHandler(ContentHandler handler);

Source Link

Document

Allow an application to register a content event handler.

Usage

From source file:org.eclipse.swordfish.plugins.compression.CompressorImpl.java

public Source asUncompressedSource(Source src) {
    try {/*from  w w  w .j  a v a2  s. com*/
        String encoded = null;
        if (src instanceof DOMSource) {
            Node root = ((DOMSource) src).getNode();
            if (root instanceof Document) {
                root = ((Document) root).getDocumentElement();
            }
            Element rootElement = (Element) root;
            String qName = rootElement.getNodeName();
            String localName = qName.substring(qName.indexOf(":") + 1, qName.length());
            if (localName.equalsIgnoreCase(CompressionConstants.COMPRESSED_ELEMENT)) {
                Node node = rootElement.getFirstChild();
                if (node != null && node.getNodeType() == Node.TEXT_NODE) {
                    encoded = node.getNodeValue();
                }
            }
            if (null != encoded && encoded.length() > 0) {
                byte[] decoded = new Base64().decode(encoded.getBytes());
                InputStream is = new GZIPInputStream(new ByteArrayInputStream(decoded));
                DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
                Document doc = builder.parse(is);
                return new DOMSource(doc);
            } else {
                return src;
            }
        } else if (src instanceof StreamSource) {
            XMLReader xmlReader = XMLReaderFactory.createXMLReader();
            CompressedContentHandler ch = new CompressedContentHandler();
            xmlReader.setContentHandler(ch);
            xmlReader.parse(new InputSource(((StreamSource) src).getInputStream()));
            encoded = ch.getContent();
            if (null != encoded && encoded.length() > 0) {
                byte[] decoded = new Base64().decode(encoded.getBytes());
                InputStream is = new GZIPInputStream(new ByteArrayInputStream(decoded));
                return new StreamSource(is);
            } else {
                throw new SwordfishException("Payload is empty, cannot uncompress.");
            }
        } else {
            return asUncompressedSource(new SourceTransformer().toDOMSource(src));
        }
    } catch (Exception e) {
        LOG.error("Couldn't decompress source", e);
        throw new SwordfishException("Couldn't decompress source", e);
    }
}

From source file:org.entcore.feeder.aaf.BaseImportProcessing.java

protected void parse(final Handler<Message<JsonObject>> handler, final ImportProcessing importProcessing) {
    final String[] files = vertx.fileSystem().readDirSync(path, getFileRegex());
    final VoidHandler[] handlers = new VoidHandler[files.length + 1];
    handlers[handlers.length - 1] = new VoidHandler() {
        @Override/*from w  w  w. j  a  v a2  s .  c  o  m*/
        protected void handle() {
            next(handler, importProcessing);
        }
    };
    Arrays.sort(files);
    for (int i = files.length - 1; i >= 0; i--) {
        final int j = i;
        handlers[i] = new VoidHandler() {
            @Override
            protected void handle() {
                try {
                    String file = files[j];
                    log.info("Parsing file : " + file);
                    byte[] encoded = Files.readAllBytes(Paths.get(file));
                    String content = UNESCAPE_AAF.translate(new String(encoded, "UTF-8"));
                    InputSource in = new InputSource(new StringReader(content));
                    AAFHandler sh = new AAFHandler(BaseImportProcessing.this);
                    XMLReader xr = XMLReaderFactory.createXMLReader();
                    xr.setContentHandler(sh);
                    xr.setEntityResolver(new EntityResolver2() {
                        @Override
                        public InputSource getExternalSubset(String name, String baseURI)
                                throws SAXException, IOException {
                            return null;
                        }

                        @Override
                        public InputSource resolveEntity(String name, String publicId, String baseURI,
                                String systemId) throws SAXException, IOException {
                            return resolveEntity(publicId, systemId);
                        }

                        @Override
                        public InputSource resolveEntity(String publicId, String systemId)
                                throws SAXException, IOException {
                            if (systemId.equals("ficAlimMENESR.dtd")) {
                                Reader reader = new FileReader(path + File.separator + "ficAlimMENESR.dtd");
                                return new InputSource(reader);
                            } else {
                                return null;
                            }
                        }
                    });
                    xr.parse(in);
                    importer.flush(new Handler<Message<JsonObject>>() {
                        @Override
                        public void handle(Message<JsonObject> message) {
                            if ("ok".equals(message.body().getString("status"))) {
                                handlers[j + 1].handle(null);
                            } else {
                                error(message, handler);
                            }
                        }
                    });
                } catch (Exception e) {
                    error(e, handler);
                }
            }
        };
    }
    handlers[0].handle(null);
}

From source file:org.everit.authentication.cas.CasAuthentication.java

/**
 * Returns the value of an XML element. This method is used to process the XMLs sent by the CAS
 * server.//ww w .  ja v  a2 s.  c  o  m
 *
 * @param xmlAsString
 *          the XML string to process
 * @param elementName
 *          the name of the queried element
 * @return the value assigned to the queried element name
 * @throws RuntimeException
 *           if any error occurs during the parsing of the XML string
 */
private String getTextForElement(final String xmlAsString, final String elementName) {

    XMLReader xmlReader;
    try {
        xmlReader = saxParserFactory.newSAXParser().getXMLReader();
        xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
        xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes", false);
        xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    } catch (SAXException | ParserConfigurationException e) {
        throw new RuntimeException("Unable to create XMLReader", e);
    }

    StringBuilder builder = new StringBuilder();

    DefaultHandler handler = new DefaultHandlerExt(builder, elementName);

    xmlReader.setContentHandler(handler);
    xmlReader.setErrorHandler(handler);

    try {
        xmlReader.parse(new InputSource(new StringReader(xmlAsString)));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    return builder.toString();
}

From source file:org.everit.osgi.authentication.cas.internal.CasAuthenticationComponent.java

/**
 * Returns the value of an XML element. This method is used to process the XMLs sent by the CAS server.
 *
 * @param xmlAsString//from   w ww  . j ava 2 s  .c  o m
 *            the XML string to process
 * @param elementName
 *            the name of the queried element
 * @return the value assigned to the queried element name
 * @throws RuntimeException
 *             if any error occurs during the parsing of the XML string
 */
private String getTextForElement(final String xmlAsString, final String elementName) {

    XMLReader xmlReader;
    try {
        xmlReader = saxParserFactory.newSAXParser().getXMLReader();
        xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
        xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes", false);
        xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    } catch (final Exception e) {
        throw new RuntimeException("Unable to create XMLReader", e);
    }

    StringBuilder builder = new StringBuilder();

    DefaultHandler handler = new DefaultHandler() {

        private boolean foundElement = false;

        @Override
        public void characters(final char[] ch, final int start, final int length) throws SAXException {
            if (foundElement) {
                builder.append(ch, start, length);
            }
        }

        @Override
        public void endElement(final String uri, final String localName, final String qName)
                throws SAXException {
            if (localName.equals(elementName)) {
                foundElement = false;
            }
        }

        @Override
        public void startElement(final String uri, final String localName, final String qName,
                final Attributes attributes) throws SAXException {
            if (localName.equals(elementName)) {
                foundElement = true;
            }
        }
    };

    xmlReader.setContentHandler(handler);
    xmlReader.setErrorHandler(handler);

    try {
        xmlReader.parse(new InputSource(new StringReader(xmlAsString)));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    return builder.toString();
}

From source file:org.exist.http.SOAPServer.java

/**
 * Builds an XML Document from a string representation
 * /*from  ww  w.  j  ava2  s.  c  o m*/
 * @param buf   The XML Document content
 * 
 * @return   DOM XML Document
 */
private Document BuildXMLDocument(byte[] buf) throws SAXException, ParserConfigurationException, IOException {
    //try and construct xml document from input stream, we use eXist's in-memory DOM implementation
    final SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setNamespaceAware(true);
    //TODO we should be able to cope with context.getBaseURI()            
    final InputSource src = new InputSource(new ByteArrayInputStream(buf));
    final SAXParser parser = factory.newSAXParser();
    final XMLReader reader = parser.getXMLReader();
    final SAXAdapter adapter = new SAXAdapter();
    reader.setContentHandler(adapter);
    reader.setContentHandler(adapter);
    reader.parse(src);

    //return receiver.getDocument();
    return adapter.getDocument();
}

From source file:org.exist.mongodb.xquery.gridfs.Get.java

/**
 * Parse an byte-array containing (compressed) XML data into an eXist-db
 * document./*from ww w  .j a  va  2 s.co  m*/
 *
 * @param data Byte array containing the XML data.
 * @return Sequence containing the XML as DocumentImpl
 *
 * @throws XPathException Something bad happened.
 */
private Sequence processXML(XQueryContext xqueryContext, InputStream is) throws XPathException {

    Sequence content = null;
    try {
        final ValidationReport validationReport = new ValidationReport();
        final SAXAdapter adapter = new SAXAdapter(xqueryContext);
        final SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        final InputSource src = new InputSource(is);
        final SAXParser parser = factory.newSAXParser();
        XMLReader xr = parser.getXMLReader();

        xr.setErrorHandler(validationReport);
        xr.setContentHandler(adapter);
        xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);

        xr.parse(src);

        // Cleanup
        IOUtils.closeQuietly(is);

        if (validationReport.isValid()) {
            content = (DocumentImpl) adapter.getDocument();
        } else {
            String txt = String.format("Received document is not valid: %s", validationReport.toString());
            LOG.debug(txt);
            throw new XPathException(txt);
        }

    } catch (SAXException | ParserConfigurationException | IOException ex) {
        LOG.error(ex.getMessage(), ex);
        throw new XPathException(ex.getMessage());

    }

    return content;
}

From source file:org.exist.util.XMLReaderPool.java

public synchronized void returnXMLReader(XMLReader reader) {
    if (reader == null) {
        return;/*www. j av  a 2s  .co  m*/
    }

    try {
        reader.setContentHandler(DUMMY_HANDLER);
        reader.setErrorHandler(DUMMY_HANDLER);
        reader.setProperty(Namespaces.SAX_LEXICAL_HANDLER, DUMMY_HANDLER);

        // DIZZZ; workaround Xerces bug. Cached DTDs cause for problems during validation parsing.
        final GrammarPool grammarPool = (GrammarPool) getReaderProperty(reader,
                XMLReaderObjectFactory.APACHE_PROPERTIES_INTERNAL_GRAMMARPOOL);
        if (grammarPool != null) {
            grammarPool.clearDTDs();
        }

        super.returnObject(reader);

    } catch (final Exception e) {
        throw new IllegalStateException("error while returning XMLReader: " + e.getMessage(), e);
    }
}

From source file:org.exist.xquery.functions.request.GetData.java

private Sequence parseAsXml(InputStream is) {

    Sequence result = Sequence.EMPTY_SEQUENCE;
    XMLReader reader = null;

    context.pushDocumentContext();/*from  w  w  w.  j av a2s .  co  m*/
    try {
        //try and construct xml document from input stream, we use eXist's in-memory DOM implementation

        //we have to use CloseShieldInputStream otherwise the parser closes the stream and we cant later reread
        final InputSource src = new InputSource(new CloseShieldInputStream(is));

        reader = context.getBroker().getBrokerPool().getParserPool().borrowXMLReader();
        final MemTreeBuilder builder = context.getDocumentBuilder();
        final DocumentBuilderReceiver receiver = new DocumentBuilderReceiver(builder, true);
        reader.setContentHandler(receiver);
        reader.setProperty(Namespaces.SAX_LEXICAL_HANDLER, receiver);
        reader.parse(src);
        final Document doc = receiver.getDocument();

        result = (NodeValue) doc;
    } catch (final SAXException saxe) {
        //do nothing, we will default to trying to return a string below
    } catch (final IOException ioe) {
        //do nothing, we will default to trying to return a string below
    } finally {
        context.popDocumentContext();

        if (reader != null) {
            context.getBroker().getBrokerPool().getParserPool().returnXMLReader(reader);
        }
    }

    return result;
}

From source file:org.exist.xquery.modules.sql.ExecuteFunction.java

/**
 * evaluate the call to the XQuery execute() function, it is really the main entry point of this class.
 *
 * @param   args             arguments from the execute() function call
 * @param   contextSequence  the Context Sequence to operate on (not used here internally!)
 *
 * @return  A node representing the SQL result set
 *
 * @throws  XPathException  DOCUMENT ME!
 *
 * @see     org.exist.xquery.BasicFunction#eval(org.exist.xquery.value.Sequence[], org.exist.xquery.value.Sequence)
 *//*from   w  w w  .j a  v a  2 s  .c  om*/
@Override
public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
    // was a connection and SQL statement specified?
    if (args[0].isEmpty() || args[1].isEmpty()) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    // get the Connection
    long connectionUID = ((IntegerValue) args[0].itemAt(0)).getLong();
    Connection con = SQLModule.retrieveConnection(context, connectionUID);

    if (con == null) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    boolean preparedStmt = false;

    //setup the SQL statement
    String sql = null;
    Statement stmt = null;
    boolean executeResult = false;
    ResultSet rs = null;

    try {
        boolean makeNodeFromColumnName = false;
        MemTreeBuilder builder = context.getDocumentBuilder();
        int iRow = 0;

        //SQL or PreparedStatement?
        if (args.length == 3) {

            // get the SQL statement
            sql = args[1].getStringValue();
            stmt = con.createStatement();
            makeNodeFromColumnName = ((BooleanValue) args[2].itemAt(0)).effectiveBooleanValue();

            //execute the statement
            executeResult = stmt.execute(sql);

        } else if (args.length == 4) {

            preparedStmt = true;

            //get the prepared statement
            long statementUID = ((IntegerValue) args[1].itemAt(0)).getLong();
            PreparedStatementWithSQL stmtWithSQL = SQLModule.retrievePreparedStatement(context, statementUID);
            sql = stmtWithSQL.getSql();
            stmt = stmtWithSQL.getStmt();
            makeNodeFromColumnName = ((BooleanValue) args[3].itemAt(0)).effectiveBooleanValue();

            if (!args[2].isEmpty()) {
                setParametersOnPreparedStatement(stmt, (Element) args[2].itemAt(0));
            }

            //execute the prepared statement
            executeResult = ((PreparedStatement) stmt).execute();
        } else {
            //TODO throw exception
        }

        // DW: stmt can be null ?

        // execute the query statement
        if (executeResult) {
            /* SQL Query returned results */

            // iterate through the result set building an XML document
            rs = stmt.getResultSet();
            ResultSetMetaData rsmd = rs.getMetaData();
            int iColumns = rsmd.getColumnCount();

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("count", null, null), String.valueOf(-1));

            while (rs.next()) {
                builder.startElement(new QName("row", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
                builder.addAttribute(new QName("index", null, null), String.valueOf(rs.getRow()));

                // get each tuple in the row
                for (int i = 0; i < iColumns; i++) {
                    String columnName = rsmd.getColumnLabel(i + 1);

                    if (columnName != null) {

                        String colElement = "field";

                        if (makeNodeFromColumnName && columnName.length() > 0) {
                            // use column names as the XML node

                            /**
                             * Spaces in column names are replaced with
                             * underscore's
                             */
                            colElement = SQLUtils.escapeXmlAttr(columnName.replace(' ', '_'));
                        }

                        builder.startElement(new QName(colElement, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                null);

                        if (!makeNodeFromColumnName || columnName.length() <= 0) {
                            String name;

                            if (columnName.length() > 0) {
                                name = SQLUtils.escapeXmlAttr(columnName);
                            } else {
                                name = "Column: " + String.valueOf(i + 1);
                            }

                            builder.addAttribute(new QName("name", null, null), name);
                        }

                        builder.addAttribute(
                                new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                rsmd.getColumnTypeName(i + 1));
                        builder.addAttribute(new QName(TYPE_ATTRIBUTE_NAME, Namespaces.SCHEMA_NS, "xs"),
                                Type.getTypeName(SQLUtils.sqlTypeToXMLType(rsmd.getColumnType(i + 1))));

                        //get the content
                        if (rsmd.getColumnType(i + 1) == Types.SQLXML) {
                            //parse sqlxml value
                            try {
                                final SQLXML sqlXml = rs.getSQLXML(i + 1);

                                if (rs.wasNull()) {
                                    // Add a null indicator attribute if the value was SQL Null
                                    builder.addAttribute(
                                            new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                            "true");
                                } else {

                                    SAXParserFactory factory = SAXParserFactory.newInstance();
                                    factory.setNamespaceAware(true);
                                    InputSource src = new InputSource(sqlXml.getCharacterStream());
                                    SAXParser parser = factory.newSAXParser();
                                    XMLReader xr = parser.getXMLReader();

                                    SAXAdapter adapter = new AppendingSAXAdapter(builder);
                                    xr.setContentHandler(adapter);
                                    xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);
                                    xr.parse(src);
                                }
                            } catch (Exception e) {
                                throw new XPathException(
                                        "Could not parse column of type SQLXML: " + e.getMessage(), e);
                            }
                        } else {
                            //otherwise assume string value
                            final String colValue = rs.getString(i + 1);

                            if (rs.wasNull()) {
                                // Add a null indicator attribute if the value was SQL Null
                                builder.addAttribute(
                                        new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), "true");
                            } else {
                                if (colValue != null) {
                                    builder.characters(SQLUtils.escapeXmlText(colValue));
                                }
                            }
                        }

                        builder.endElement();
                    }
                }

                builder.endElement();
                iRow++;
            }

            builder.endElement();
        } else {
            /* SQL Query performed updates */

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("updateCount", null, null), String.valueOf(stmt.getUpdateCount()));
            builder.endElement();
        }

        // Change the root element count attribute to have the correct value
        NodeValue node = (NodeValue) builder.getDocument().getDocumentElement();
        Node count = node.getNode().getAttributes().getNamedItem("count");

        if (count != null) {
            count.setNodeValue(String.valueOf(iRow));
        }

        builder.endDocument();

        // return the XML result set
        return (node);

    } catch (SQLException sqle) {
        LOG.error("sql:execute() Caught SQLException \"" + sqle.getMessage() + "\" for SQL: \"" + sql + "\"",
                sqle);

        //return details about the SQLException
        MemTreeBuilder builder = context.getDocumentBuilder();

        builder.startDocument();
        builder.startElement(new QName("exception", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        boolean recoverable = false;

        if (sqle instanceof SQLRecoverableException) {
            recoverable = true;
        }
        builder.addAttribute(new QName("recoverable", null, null), String.valueOf(recoverable));

        builder.startElement(new QName("state", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(sqle.getSQLState());
        builder.endElement();

        builder.startElement(new QName("message", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        String state = sqle.getMessage();

        if (state != null) {
            builder.characters(state);
        }

        builder.endElement();

        builder.startElement(new QName("stack-trace", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        ByteArrayOutputStream bufStackTrace = new ByteArrayOutputStream();
        sqle.printStackTrace(new PrintStream(bufStackTrace));
        builder.characters(new String(bufStackTrace.toByteArray()));
        builder.endElement();

        builder.startElement(new QName("sql", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(SQLUtils.escapeXmlText(sql));
        builder.endElement();

        if (stmt instanceof PreparedStatement) {
            Element parametersElement = (Element) args[2].itemAt(0);

            if (parametersElement.getNamespaceURI().equals(SQLModule.NAMESPACE_URI)
                    && parametersElement.getLocalName().equals(PARAMETERS_ELEMENT_NAME)) {
                NodeList paramElements = parametersElement.getElementsByTagNameNS(SQLModule.NAMESPACE_URI,
                        PARAM_ELEMENT_NAME);

                builder.startElement(
                        new QName(PARAMETERS_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                for (int i = 0; i < paramElements.getLength(); i++) {
                    Element param = ((Element) paramElements.item(i));
                    String value = param.getFirstChild().getNodeValue();
                    String type = param.getAttributeNS(SQLModule.NAMESPACE_URI, TYPE_ATTRIBUTE_NAME);

                    builder.startElement(
                            new QName(PARAM_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                    builder.addAttribute(
                            new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), type);
                    builder.characters(SQLUtils.escapeXmlText(value));

                    builder.endElement();
                }

                builder.endElement();
            }
        }

        builder.startElement(new QName("xquery", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.addAttribute(new QName("line", null, null), String.valueOf(getLine()));
        builder.addAttribute(new QName("column", null, null), String.valueOf(getColumn()));
        builder.endElement();

        builder.endElement();
        builder.endDocument();

        return ((NodeValue) builder.getDocument().getDocumentElement());
    } finally {

        // close any record set or statement
        if (rs != null) {

            try {
                rs.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            rs = null;
        }

        if (!preparedStmt && stmt != null) {

            try {
                stmt.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            stmt = null;
        }

    }
}

From source file:org.exist.xquery.xproc.ProcessFunction.java

public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {

    if (args[0].isEmpty()) {
        return Sequence.EMPTY_SEQUENCE;
    }//from w  ww.  ja  v a  2  s  . c  o  m

    //        Sequence input = getArgument(0).eval(contextSequence, contextItem);

    UserArgs userArgs = new UserArgs();

    Sequence pipe = args[0];

    if (Type.subTypeOf(pipe.getItemType(), Type.NODE)) {

        if (pipe.getItemCount() != 1) {
            throw new XPathException(this, "Pipeline must have just ONE and only ONE element.");
        }

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStreamWriter osw;
        try {
            osw = new OutputStreamWriter(baos, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new XPathException(this, "Internal error");
        }

        XMLWriter xmlWriter = new XMLWriter(osw);

        SAXSerializer sax = new SAXSerializer();

        sax.setReceiver(xmlWriter);

        try {
            pipe.itemAt(0).toSAX(context.getBroker(), sax, new Properties());
            osw.flush();
            osw.close();
        } catch (Exception e) {
            throw new XPathException(this, e);
        }

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        userArgs.setPipeline(bais, XmldbURI.LOCAL_DB + "/");

    } else {
        userArgs.setPipeline(pipe.getStringValue());
    }

    InputStream defaultIn = null;

    //prepare primary input
    if (args.length > 2) {
        Sequence input = args[1];

        if (Type.subTypeOf(input.getItemType(), Type.NODE)) {

            if (input.getItemCount() != 1) {
                throw new XPathException(this, "Primary input must have just ONE and only ONE element.");
            }

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            OutputStreamWriter osw;
            try {
                osw = new OutputStreamWriter(baos, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                throw new XPathException(this, "Internal error");
            }

            XMLWriter xmlWriter = new XMLWriter(osw);

            SAXSerializer sax = new SAXSerializer();

            sax.setReceiver(xmlWriter);

            try {
                input.itemAt(0).toSAX(context.getBroker(), sax, new Properties());
                osw.flush();
                osw.close();
            } catch (Exception e) {
                throw new XPathException(this, e);
            }

            defaultIn = new ByteArrayInputStream(baos.toByteArray());

        } else {
            defaultIn = new ByteArrayInputStream(input.getStringValue().getBytes());
        }
    }

    //parse options
    if (args.length > 2) {
        parseOptions(userArgs, args[2]);
    } else if (args.length > 1) {
        parseOptions(userArgs, args[1]);
    }

    String outputResult;
    try {

        //getContext().getModuleLoadPath();

        URI staticBaseURI = null;

        Object key = getContext().getSource().getKey();
        if (key instanceof XmldbURI) {

            String uri = ((XmldbURI) key).removeLastSegment().toString();

            if (!uri.endsWith("/")) {
                uri += "/";
            }

            staticBaseURI = new URI("xmldb", "", uri, null);

        } else {

            String uri = getContext().getModuleLoadPath();
            if (uri == null || uri.isEmpty()) {
                staticBaseURI = new URI(XmldbURI.LOCAL_DB + "/");

            } else {

                if (uri.startsWith(XmldbURI.EMBEDDED_SERVER_URI_PREFIX)) {
                    uri = uri.substring(XmldbURI.EMBEDDED_SERVER_URI_PREFIX.length());
                }
                if (!uri.endsWith("/")) {
                    uri += "/";
                }

                staticBaseURI = new URI("xmldb", "", uri, null);
            }
        }

        outputResult = XProcRunner.run(staticBaseURI, context.getBroker(), userArgs, defaultIn);

    } catch (Exception e) {
        e.printStackTrace();
        throw new XPathException(this, e);
    }

    if (outputResult == null || outputResult.isEmpty()) {
        return Sequence.EMPTY_SEQUENCE;
    }

    StringReader reader = new StringReader(outputResult);
    try {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        InputSource src = new InputSource(reader);

        XMLReader xr = null;

        if (xr == null) {
            SAXParser parser = factory.newSAXParser();
            xr = parser.getXMLReader();
        }

        SAXAdapter adapter = new SAXAdapter(context);
        xr.setContentHandler(adapter);
        xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);
        xr.parse(src);

        return (DocumentImpl) adapter.getDocument();
    } catch (ParserConfigurationException e) {
        throw new XPathException(this, "Error while constructing XML parser: " + e.getMessage(), e);
    } catch (SAXException e) {
        throw new XPathException(this, "Error while parsing XML: " + e.getMessage(), e);
    } catch (IOException e) {
        throw new XPathException(this, "Error while parsing XML: " + e.getMessage(), e);
    }
}