Subversion Repositories openrisc

/* XMLStreamWriterImpl.java --

   Copyright (C) 2005  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GNU Classpath is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

package gnu.xml.stream;

import java.io.IOException;

import java.io.Writer;

import java.util.Enumeration;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.Set;

import javax.xml.XMLConstants;

import javax.xml.namespace.NamespaceContext;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import org.xml.sax.helpers.NamespaceSupport;

/**

 * Simple XML stream writer.

 *

 * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>

 */

public class XMLStreamWriterImpl

  implements XMLStreamWriter

{

  /**

   * The underlying character stream to write to.

   */

  protected final Writer writer;

  /**

   * The encoding being used.

   * Note that this must match the encoding of the character stream.

   */

  protected final String encoding;

  /**

   * Whether prefix defaulting is being used.

   * If true and a prefix has not been defined for a namespace specified on

   * an element or an attribute, a new prefix and namespace declaration will

   * be created.

   */

  protected final boolean prefixDefaulting;

  /**

   * The namespace context used to determine the namespace-prefix mappings

   * in scope.

   */

  protected NamespaceContext namespaceContext;

  /**

   * The stack of elements in scope.

   * Used to close the remaining elements.

   */

  private LinkedList elements;

  /**

   * Whether a start element has been opened but not yet closed.

   */

  private boolean inStartElement;

  /**

   * Whether we are in an empty element.

   */

  private boolean emptyElement;

  private NamespaceSupport namespaces;

  private int count = 0;

  private boolean xml11;

  private boolean hasXML11RestrictedChars;

  /**

   * Constructor.

   * @see #writer

   * @see #encoding

   * @see #prefixDefaulting

   */

  protected XMLStreamWriterImpl(Writer writer, String encoding,

                                boolean prefixDefaulting)

  {

    this.writer = writer;

    this.encoding = encoding;

    this.prefixDefaulting = prefixDefaulting;

    elements = new LinkedList();

    namespaces = new NamespaceSupport();

  }

  /**

   * Write the end of a start-element event.

   * This will close the element if it was defined to be an empty element.

   */

  private void endStartElement()

    throws IOException

  {

    if (!inStartElement)

      return;

    if (emptyElement)

      {

        writer.write('/');

        elements.removeLast();

        namespaces.popContext();

        emptyElement = false;

      }

    writer.write('>');

    inStartElement = false;

  }

  public void writeStartElement(String localName)

    throws XMLStreamException

  {

    try

      {

        if (!isName(localName))

          throw new IllegalArgumentException("illegal Name: " + localName);

        endStartElement();

        namespaces.pushContext();

        writer.write('<');

        writer.write(localName);

        elements.addLast(new String[] { null, localName });

        inStartElement = true;

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeStartElement(String namespaceURI, String localName)

    throws XMLStreamException

  {

    try

      {

        if (namespaceURI != null && !isURI(namespaceURI))

          throw new IllegalArgumentException("illegal URI: " + namespaceURI);

        if (!isName(localName))

          throw new IllegalArgumentException("illegal Name: " + localName);

        endStartElement();

        namespaces.pushContext();

        String prefix = getPrefix(namespaceURI);

        boolean isDeclared = (prefix != null);

        if (!isDeclared)

          {

            if (prefixDefaulting)

              prefix = createPrefix(namespaceURI);

            else

              throw new XMLStreamException("namespace " + namespaceURI +

                                           " has not been declared");

          }

        writer.write('<');

        if (!"".equals(prefix))

          {

            writer.write(prefix);

            writer.write(':');

          }

        writer.write(localName);

        inStartElement = true;

        if (!isDeclared)

          {

            writeNamespaceImpl(prefix, namespaceURI);

          }

        elements.addLast(new String[] { prefix, localName });

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  /**

   * Creates a new unique prefix in the document.

   * Subclasses may override this method to provide a suitably unique prefix

   * for the given namespace.

   * @param namespaceURI the namespace URI

   */

  protected String createPrefix(String namespaceURI)

  {

    Set prefixes = new HashSet();

    for (Enumeration e = namespaces.getPrefixes(); e.hasMoreElements(); )

      prefixes.add(e.nextElement());

    String ret;

    do

      {

        ret = "ns" + (count++);

      }

    while (prefixes.contains(ret));

    return ret;

  }

  public void writeStartElement(String prefix, String localName,

                                String namespaceURI)

    throws XMLStreamException

  {

    try

      {

        if (namespaceURI != null && !isURI(namespaceURI))

          throw new IllegalArgumentException("illegal URI: " + namespaceURI);

        if (prefix != null && !isPrefix(prefix))

          throw new IllegalArgumentException("illegal NCName: " + prefix);

        if (!isNCName(localName))

          throw new IllegalArgumentException("illegal NCName: " + localName);

        endStartElement();

        namespaces.pushContext();

        String currentPrefix = getPrefix(namespaceURI);

        boolean isCurrent = prefix.equals(currentPrefix);

        writer.write('<');

        if (!"".equals(prefix))

          {

            writer.write(prefix);

            writer.write(':');

          }

        writer.write(localName);

        if (prefixDefaulting && !isCurrent)

          {

            writeNamespaceImpl(prefix, namespaceURI);

          }

        elements.addLast(new String[] { prefix, localName });

        inStartElement = true;

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeEmptyElement(String namespaceURI, String localName)

    throws XMLStreamException

  {

    writeStartElement(namespaceURI, localName);

    emptyElement = true;

  }

  public void writeEmptyElement(String prefix, String localName,

                                String namespaceURI)

    throws XMLStreamException

  {

    writeStartElement(prefix, localName, namespaceURI);

    emptyElement = true;

  }

  public void writeEmptyElement(String localName)

    throws XMLStreamException

  {

    writeStartElement(localName);

    emptyElement = true;

  }

  public void writeEndElement()

    throws XMLStreamException

  {

    if (elements.isEmpty())

      throw new IllegalStateException("no matching start element");

    try

      {

        endStartElement();

        String[] element = (String[]) elements.removeLast();

        namespaces.popContext();

        writer.write('<');

        writer.write('/');

        if (element[0] != null && !"".equals(element[0]))

          {

            writer.write(element[0]);

            writer.write(':');

          }

        writer.write(element[1]);

        writer.write('>');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeEndDocument()

    throws XMLStreamException

  {

    while (!elements.isEmpty())

      writeEndElement();

  }

  public void close()

    throws XMLStreamException

  {

    flush();

  }

  public void flush()

    throws XMLStreamException

  {

    try

      {

        writer.flush();

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeAttribute(String localName, String value)

    throws XMLStreamException

  {

    if (!inStartElement)

      throw new IllegalStateException();

    try

      {

        if (!isName(localName))

          throw new IllegalArgumentException("illegal Name: " + localName);

        if (!isChars(value))

          throw new IllegalArgumentException("illegal character: " + value);

        writer.write(' ');

        writer.write(localName);

        writer.write('=');

        writer.write('"');

        if (hasXML11RestrictedChars)

          writeEncodedWithRestrictedChars(value, true);

        else

          writeEncoded(value, true);

        writer.write('"');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeAttribute(String prefix, String namespaceURI,

                             String localName, String value)

    throws XMLStreamException

  {

    if (!inStartElement)

      throw new IllegalStateException();

    try

      {

        if (namespaceURI != null && !isURI(namespaceURI))

          throw new IllegalArgumentException("illegal URI: " + namespaceURI);

        if (prefix != null && !isPrefix(prefix))

          throw new IllegalArgumentException("illegal NCName: " + prefix);

        if (!isNCName(localName))

          throw new IllegalArgumentException("illegal NCName: " + localName);

        if (!isChars(value))

          throw new IllegalArgumentException("illegal character: " + value);

        String currentPrefix = getPrefix(namespaceURI);

        if (currentPrefix == null)

          {

            if (prefixDefaulting)

              writeNamespaceImpl(prefix, namespaceURI);

            else

              throw new XMLStreamException("namespace " + namespaceURI +

                                           " is not bound");

          }

        else if (!currentPrefix.equals(prefix))

          throw new XMLStreamException("namespace " + namespaceURI +

                                       " is bound to prefix " +

                                       currentPrefix);

        writer.write(' ');

        if (!"".equals(prefix))

          {

            writer.write(prefix);

            writer.write(':');

          }

        writer.write(localName);

        writer.write('=');

        writer.write('"');

        if (hasXML11RestrictedChars)

          writeEncodedWithRestrictedChars(value, true);

        else

          writeEncoded(value, true);

        writer.write('"');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeAttribute(String namespaceURI, String localName,

                             String value)

    throws XMLStreamException

  {

    if (!inStartElement)

      throw new IllegalStateException();

    try

      {

        if (namespaceURI != null && !isURI(namespaceURI))

          throw new IllegalArgumentException("illegal URI: " + namespaceURI);

        if (!isName(localName))

          throw new IllegalArgumentException("illegal Name: " + localName);

        if (!isChars(value))

          throw new IllegalArgumentException("illegal character: " + value);

        String prefix = getPrefix(namespaceURI);

        if (prefix == null)

          {

            if (prefixDefaulting)

              {

                prefix = XMLConstants.DEFAULT_NS_PREFIX;

                writeNamespaceImpl(prefix, namespaceURI);

              }

            else

              throw new XMLStreamException("namespace " + namespaceURI +

                                           " is not bound");

          }

        writer.write(' ');

        if (!"".equals(prefix))

          {

            writer.write(prefix);

            writer.write(':');

          }

        writer.write(localName);

        writer.write('=');

        writer.write('"');

        if (hasXML11RestrictedChars)

          writeEncodedWithRestrictedChars(value, true);

        else

          writeEncoded(value, true);

        writer.write('"');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeNamespace(String prefix, String namespaceURI)

    throws XMLStreamException

  {

    if (prefix == null || "".equals(prefix) || "xmlns".equals(prefix))

    {

      writeDefaultNamespace(namespaceURI);

      return;

    }

    if (!inStartElement)

      throw new IllegalStateException();

    try

      {

        if (!isURI(namespaceURI))

          throw new IllegalArgumentException("illegal URI: " + namespaceURI);

        if (!isPrefix(prefix))

          throw new IllegalArgumentException("illegal NCName: " + prefix);

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

    writeNamespaceImpl(prefix, namespaceURI);

  }

  private void writeNamespaceImpl(String prefix, String namespaceURI)

    throws XMLStreamException

  {

    try

      {

        if (prefix == null)

          prefix = XMLConstants.DEFAULT_NS_PREFIX;

        setPrefix(prefix, namespaceURI);

        writer.write(' ');

        writer.write("xmlns");

        if (!XMLConstants.DEFAULT_NS_PREFIX.equals(prefix))

          {

            writer.write(':');

            writer.write(prefix);

          }

        writer.write('=');

        writer.write('"');

        writer.write(namespaceURI);

        writer.write('"');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeDefaultNamespace(String namespaceURI)

    throws XMLStreamException

  {

    if (!inStartElement)

      throw new IllegalStateException();

    if (!isURI(namespaceURI))

      throw new IllegalArgumentException("illegal URI: " + namespaceURI);

    writeNamespaceImpl(XMLConstants.DEFAULT_NS_PREFIX, namespaceURI);

  }

  public void writeComment(String data)

    throws XMLStreamException

  {

    if (data == null)

      return;

    try

      {

        if (!isChars(data))

          throw new IllegalArgumentException("illegal XML character: " + data);

        if (data.indexOf("--") != -1)

          throw new IllegalArgumentException("illegal comment: " + data);

        endStartElement();

        writer.write("<!--");

        if (hasXML11RestrictedChars)

          {

            int[] seq = UnicodeReader.toCodePointArray(data);

            for (int i = 0; i < seq.length; i++)

              {

                int c = seq[i];

                if (XMLParser.isXML11RestrictedChar(c))

                  writer.write("&#x" + Integer.toHexString(c) + ";");

                else

                  writer.write(Character.toChars(i));

              }

          }

        else

          writer.write(data);

        writer.write("-->");

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeProcessingInstruction(String target)

    throws XMLStreamException

  {

    writeProcessingInstruction(target, null);

  }

  public void writeProcessingInstruction(String target, String data)

    throws XMLStreamException

  {

    try

      {

        if (!isName(target) || "xml".equalsIgnoreCase(target))

          throw new IllegalArgumentException("illegal PITarget: " + target);

        if (data != null && !isChars(data))

          throw new IllegalArgumentException("illegal XML character: " + data);

        endStartElement();

        writer.write('<');

        writer.write('?');

        writer.write(target);

        if (data != null)

          {

            writer.write(' ');

            if (hasXML11RestrictedChars)

              {

                int[] seq = UnicodeReader.toCodePointArray(data);

                for (int i = 0; i < seq.length; i++)

                  {

                    int c = seq[i];

                    if (XMLParser.isXML11RestrictedChar(c))

                      writer.write("&#x" + Integer.toHexString(c) + ";");

                    else

                      writer.write(Character.toChars(i));

                  }

              }

            else

              writer.write(data);

          }

        writer.write('?');

        writer.write('>');

      }

    catch (IOException e)

      {

        XMLStreamException e2 = new XMLStreamException(e);

        e2.initCause(e);

        throw e2;

      }

  }

  public void writeCData(String data)

    throws XMLStreamException

  {

    try

      {

        if (!isChars(data) || hasXML11RestrictedChars)

          throw new IllegalArgumentException("illegal XML character: " + data);

        if (data.indexOf("]]") != -1)

          throw new IllegalArgumentException("illegal CDATA section: " + data);

        endStartElement();

        writer.write("<![CDATA[");