Subversion Repositories openrisc

/* Stylesheet.java --

   Copyright (C) 2004,2006 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.transform;

import gnu.java.lang.CPStringBuilder;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

import javax.xml.XMLConstants;

import javax.xml.namespace.NamespaceContext;

import javax.xml.namespace.QName;

import javax.xml.transform.Source;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.xpath.XPathFunction;

import javax.xml.xpath.XPathFunctionResolver;

import javax.xml.xpath.XPathExpressionException;

import org.w3c.dom.Attr;

import org.w3c.dom.Document;

import org.w3c.dom.DOMException;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.Text;

import org.w3c.dom.UserDataHandler;

import gnu.xml.xpath.Expr;

import gnu.xml.xpath.NameTest;

import gnu.xml.xpath.NodeTypeTest;

import gnu.xml.xpath.Pattern;

import gnu.xml.xpath.Selector;

import gnu.xml.xpath.Root;

import gnu.xml.xpath.Test;

import gnu.xml.xpath.XPathImpl;

/**

 * An XSL stylesheet.

 *

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

 */

class Stylesheet

  implements NamespaceContext, XPathFunctionResolver, UserDataHandler, Cloneable

{

  static final String XSL_NS = "http://www.w3.org/1999/XSL/Transform";

  private static final NameTest STYLESHEET_PRESERVE_TEXT =

    new NameTest(new QName(XSL_NS, "text"), false, false);

  static final int OUTPUT_XML = 0;

  static final int OUTPUT_HTML = 1;

  static final int OUTPUT_TEXT = 2;

  final TransformerFactoryImpl factory;

  TransformerImpl transformer;

  Stylesheet parent;

  final XPathImpl xpath;

  final String systemId;

  final int precedence;

  final boolean debug;

  /**

   * Version of XSLT.

   */

  String version;

  Collection<String> extensionElementPrefixes;

  Collection<String> excludeResultPrefixes;

  /**

   * Set of element names for which we should strip whitespace.

   */

  Set<StrippingInstruction> stripSpace;

  /**

   * Set of element names for which we should preserve whitespace.

   */

  Set<StrippingInstruction> preserveSpace;

  /**

   * Output options.

   */

  Node output;

  int outputMethod;

  String outputVersion;

  String outputEncoding;

  boolean outputOmitXmlDeclaration;

  boolean outputStandalone;

  String outputPublicId;

  String outputSystemId;

  Collection<String> outputCdataSectionElements;

  boolean outputIndent;

  String outputMediaType;

  /**

   * Keys.

   */

  Collection<Key> keys;

  /**

   * Decimal formats.

   */

  Map<String,DecimalFormat> decimalFormats;

  /**

   * Namespace aliases.

   */

  Map<String,String> namespaceAliases;

  /**

   * Attribute-sets.

   */

  List<AttributeSet> attributeSets;

  /**

   * Variables.

   */

  List<ParameterNode> variables;

  /**

   * Variable and parameter bindings.

   */

  Bindings bindings;

  /**

   * Templates.

   */

  LinkedList<Template> templates;

  TemplateNode builtInNodeTemplate;

  TemplateNode builtInTextTemplate;

  /**

   * Holds the current node while parsing.

   * Necessary to associate the document function with its declaring node,

   * to resolve namespaces, and to maintain the current node for the

   * current() function.

   */

  Node current;

  /**

   * Set by a terminating message.

   */

  transient boolean terminated;

  /**

   * Current template in force.

   */

  transient Template currentTemplate;

  Stylesheet(TransformerFactoryImpl factory,

             Stylesheet parent,

             Document doc,

             String systemId,

             int precedence)

    throws TransformerConfigurationException

  {

    this.factory = factory;

    this.systemId = systemId;

    this.precedence = precedence;

    this.parent = parent;

    extensionElementPrefixes = new HashSet<String>();

    excludeResultPrefixes = new HashSet<String>();

    stripSpace = new LinkedHashSet<StrippingInstruction>();

    preserveSpace = new LinkedHashSet<StrippingInstruction>();

    outputCdataSectionElements = new LinkedHashSet<String>();

    xpath = (XPathImpl) factory.xpathFactory.newXPath();

    xpath.setNamespaceContext(this);

    if (parent == null)

      {

        bindings = new Bindings(this);

        attributeSets = new LinkedList<AttributeSet>();

        variables = new LinkedList<ParameterNode>();

        namespaceAliases = new LinkedHashMap<String,String>();

        templates = new LinkedList<Template>();

        keys = new LinkedList<Key>();

        decimalFormats = new LinkedHashMap<String,DecimalFormat>();

        initDefaultDecimalFormat();

        xpath.setXPathFunctionResolver(this);

      }

    else

      {

        /* Test for import circularity */

        for (Stylesheet ctx = this; ctx.parent != null; ctx = ctx.parent)

          {

            if (systemId != null && systemId.equals(ctx.parent.systemId))

              {

                String msg = "circularity importing " + systemId;

                throw new TransformerConfigurationException(msg);

              }

          }

        /* OK */

        Stylesheet root = getRootStylesheet();

        bindings = root.bindings;

        attributeSets = root.attributeSets;

        variables = root.variables;

        namespaceAliases = root.namespaceAliases;

        templates = root.templates;

        keys = root.keys;

        decimalFormats = root.decimalFormats;

        xpath.setXPathFunctionResolver(root);

      }

    xpath.setXPathVariableResolver(bindings);

    Test anyNode = new NodeTypeTest((short) 0);

    List<Test> tests = Collections.singletonList(anyNode);

    builtInNodeTemplate =

      new ApplyTemplatesNode(new Selector(Selector.CHILD, tests),

                             null, null, null, true);

    builtInTextTemplate =

      new ValueOfNode(new Selector(Selector.SELF, tests),

                      false);

    parse(doc.getDocumentElement(), true);

    current = doc; // Alow namespace resolution during processing

    debug = ("yes".equals(System.getProperty("xsl.debug")));

    if (debug)

      {

        System.err.println("Stylesheet: " + doc.getDocumentURI());

        for (Template t : templates)

          {

            t.list(System.err);

            System.err.println("--------------------");

          }

      }

  }

  Stylesheet getRootStylesheet()

  {

    Stylesheet stylesheet = this;

    while (stylesheet.parent != null)

      stylesheet = stylesheet.parent;

    return stylesheet;

  }

  void initDefaultDecimalFormat()

  {

    DecimalFormat defaultDecimalFormat = new DecimalFormat();

    DecimalFormatSymbols symbols = new DecimalFormatSymbols();

    symbols.setDecimalSeparator('.');

    symbols.setGroupingSeparator(',');

    symbols.setPercent('%');

    symbols.setPerMill('\u2030');

    symbols.setZeroDigit('0');

    symbols.setDigit('#');

    symbols.setPatternSeparator(';');

    symbols.setInfinity("Infinity");

    symbols.setNaN("NaN");

    symbols.setMinusSign('-');

    defaultDecimalFormat.setDecimalFormatSymbols(symbols);

    decimalFormats.put(null, defaultDecimalFormat);

  }

  // -- Cloneable --

  public Object clone()

  {

    try

      {

        Stylesheet clone = (Stylesheet) super.clone();

        clone.bindings = (Bindings) bindings.clone();

        LinkedList<Template> templates2 = new LinkedList<Template>();

        for (Template t : templates)

          {

            templates2.add(t.clone(clone));

          }

        clone.templates = templates2;

        LinkedList<AttributeSet> attributeSets2 = new LinkedList<AttributeSet>();

        for (AttributeSet as : attributeSets)

          {

            attributeSets2.add(as.clone(clone));

          }

        clone.attributeSets = attributeSets2;

        LinkedList<ParameterNode> variables2 = new LinkedList<ParameterNode>();

        for (ParameterNode var : variables)

          {

            variables2.add(var.clone(clone));

          }

        clone.variables = variables2;

        LinkedList<Key> keys2 = new LinkedList<Key>();

        for (Key k : keys)

          {

            keys2.add(k.clone(clone));

          }

        clone.keys = keys2;

        return clone;

      }

    catch (CloneNotSupportedException e)

      {

        throw new Error(e.getMessage());

      }

  }

  // -- Variable evaluation --

  void initTopLevelVariables(Node context)

    throws TransformerException

  {

    current = context;

    // Sort the variables into order

    // See XSLT 11.4: "If the template or expression specifying the value of

    // a global variable x references a global variable y, then the value

    // for y must be computed before the value of x."

    List<ParameterNode> topLevel = new ArrayList<ParameterNode>(variables);

    Collections.sort(topLevel);

    for (ParameterNode var : topLevel)

      {

        bindings.set(var.name,

                     var.getValue(this, null, context, 1, 1),

                     var.type);

      }

    current = null;

  }

  // -- NamespaceContext --

  public String getNamespaceURI(String prefix)

  {

    return (current == null) ? null : current.lookupNamespaceURI(prefix);

  }

  public String getPrefix(String namespaceURI)

  {

    return (current == null) ? null : current.lookupPrefix(namespaceURI);

  }

  public Iterator<String> getPrefixes(String namespaceURI)

  {

    // TODO

    return Collections.singleton(getPrefix(namespaceURI)).iterator();

  }

  final QName getQName(String name)

  {

    String localName = name, uri = null, prefix = null;

    int ci = name.indexOf(':');

    if (ci != -1)

      {

        prefix = name.substring(0, ci);

        localName = name.substring(ci + 1);

        uri = getNamespaceURI(prefix);

      }

    return new QName(uri, localName, prefix);

  }

  // -- Template selection --

  TemplateNode getTemplate(QName mode, Node context, boolean applyImports)

    throws TransformerException

  {

    if (debug)

      System.err.println("getTemplate: mode="+mode+" context="+context);

    Template selected = null;

    for (Template t : templates)

      {

        boolean isMatch = t.matches(mode, context);

        if (applyImports)

          {

            if (currentTemplate == null)

              {

                String msg = "current template may not be null " +

                  "during apply-imports";

                throw new TransformerException(msg);

              }

            if (!currentTemplate.imports(t))

              isMatch = false;

          }

        //System.err.println("\t"+context+" "+t+"="+isMatch);

        if (isMatch)

          {

            // Conflict resolution

            // @see http://www.w3.org/TR/xslt#conflict

            if (selected == null)

              selected = t;

            else

              {

                if (t.precedence < selected.precedence ||

                    t.priority < selected.priority)

                  continue;

                selected = t;

              }

          }

      }

    if (selected == null)

      {

        // Apply built-in template

        // Current template is unchanged

        if (debug)

          System.err.println("\tbuiltInTemplate context="+context);

        switch (context.getNodeType())

          {

          case Node.ELEMENT_NODE:

          case Node.DOCUMENT_NODE:

          case Node.DOCUMENT_FRAGMENT_NODE:

          case Node.PROCESSING_INSTRUCTION_NODE:

          case Node.COMMENT_NODE:

            return builtInNodeTemplate;

          case Node.TEXT_NODE:

          case Node.CDATA_SECTION_NODE:

          case Node.ATTRIBUTE_NODE:

            return builtInTextTemplate;

          default:

            return null;

          }

      }

    // Set current template

    currentTemplate = selected;

    if (debug)

      System.err.println("\ttemplate="+currentTemplate+" context="+context);

    return currentTemplate.node;

  }

  TemplateNode getTemplate(QName mode, QName name)

    throws TransformerException

  {

    Template selected = null;

    for (Template t : templates)

      {

        boolean isMatch = t.matches(name);

        if (isMatch)

          {

            // Conflict resolution

            // @see http://www.w3.org/TR/xslt#conflict

            if (selected == null)

              selected = t;

            else

              {

                if (t.precedence < selected.precedence ||

                    t.priority < selected.priority)

                  continue;

                selected = t;

              }

          }

      }

    if (selected == null)

      return null;

    return selected.node;

  }

  /**

   * template

   */

  final Template parseTemplate(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException, XPathExpressionException

  {

    String n = getAttribute(attrs, "name");

    QName name = (n == null) ? null : getQName(n);

    String m = getAttribute(attrs, "match");

    Pattern match = null;

    if (m != null)

      {

        try

          {

            match = (Pattern) xpath.compile(m);

          }

        catch (ClassCastException e)

          {

            String msg = "illegal pattern: " + m;

            throw new TransformerConfigurationException(msg);

          }

      }

    String p = getAttribute(attrs, "priority");

    String mm = getAttribute(attrs, "mode");

    QName mode = (mm == null) ? null : getQName(mm);

    Node children = node.getFirstChild();

    return new Template(this, name, match, parse(children),

                        precedence, p, mode);

  }

  /**

   * output

   */

  final void parseOutput(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException

  {

    output = node;

    String method = getAttribute(attrs, "method");

    if ("xml".equals(method) || method == null)

      outputMethod = OUTPUT_XML;

    else if ("html".equals(method))

      outputMethod = OUTPUT_HTML;

    else if ("text".equals(method))

      outputMethod = OUTPUT_TEXT;

    else

      {

        String msg = "unsupported output method: " + method;

        DOMSourceLocator l = new DOMSourceLocator(node);

        throw new TransformerConfigurationException(msg, l);

      }

    outputPublicId = getAttribute(attrs, "doctype-public");

    outputSystemId = getAttribute(attrs, "doctype-system");

    outputEncoding = getAttribute(attrs, "encoding");

    String indent = getAttribute(attrs, "indent");

    if (indent != null)

      outputIndent = "yes".equals(indent);

    outputVersion = getAttribute(attrs, "version");

    String omitXmlDecl = getAttribute(attrs, "omit-xml-declaration");

    if (omitXmlDecl != null)

      outputOmitXmlDeclaration = "yes".equals(omitXmlDecl);

    String standalone = getAttribute(attrs, "standalone");

    if (standalone != null)

      outputStandalone = "yes".equals(standalone);

    outputMediaType = getAttribute(attrs, "media-type");

    String cdataSectionElements =

      getAttribute(attrs, "cdata-section-elements");

    if (cdataSectionElements != null)

      {

        StringTokenizer st = new StringTokenizer(cdataSectionElements, " ");

        while (st.hasMoreTokens())

          outputCdataSectionElements.add(st.nextToken());

      }

  }

  /**

   * key

   */

  final void parseKey(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException, XPathExpressionException

  {

    String n = getRequiredAttribute(attrs, "name", node);

    String m = getRequiredAttribute(attrs, "match", node);

    String u = getRequiredAttribute(attrs, "use", node);

    QName name = getQName(n);

    Expr use = (Expr) xpath.compile(u);

    try

      {

        Pattern match = (Pattern) xpath.compile(m);

        Key key = new Key(name, match, use);

        keys.add(key);

      }

    catch (ClassCastException e)

      {

        throw new TransformerConfigurationException("invalid pattern: " + m);

      }

  }

  /**

   * decimal-format

   */

  final void parseDecimalFormat(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException

  {

    String dfName = getAttribute(attrs, "name");

    DecimalFormat df = new DecimalFormat();

    DecimalFormatSymbols symbols = new DecimalFormatSymbols();

    symbols.setDecimalSeparator(parseDFChar(attrs, "decimal-separator", '.'));

    symbols.setGroupingSeparator(parseDFChar(attrs, "grouping-separator", ','));

    symbols.setInfinity(parseDFString(attrs, "infinity", "Infinity"));

    symbols.setMinusSign(parseDFChar(attrs, "minus-sign", '-'));

    symbols.setNaN(parseDFString(attrs, "NaN", "NaN"));

    symbols.setPercent(parseDFChar(attrs, "percent", '%'));

    symbols.setPerMill(parseDFChar(attrs, "per-mille", '\u2030'));

    symbols.setZeroDigit(parseDFChar(attrs, "zero-digit", '0'));

    symbols.setDigit(parseDFChar(attrs, "digit", '#'));

    symbols.setPatternSeparator(parseDFChar(attrs, "pattern-separator", ';'));

    df.setDecimalFormatSymbols(symbols);

    decimalFormats.put(dfName, df);

  }

  private final char parseDFChar(NamedNodeMap attrs, String name, char def)

    throws TransformerConfigurationException

  {

    Node attr = attrs.getNamedItem(name);

    try

      {

        return (attr == null) ? def : attr.getNodeValue().charAt(0);

      }

    catch (StringIndexOutOfBoundsException e)

      {

        throw new TransformerConfigurationException("empty attribute '" +

                                                    name +

                                                    "' in decimal-format", e);

      }

  }

  private final String parseDFString(NamedNodeMap attrs, String name,

                                     String def)

  {

    Node attr = attrs.getNamedItem(name);

    return (attr == null) ? def : attr.getNodeValue();

  }

  /**

   * namespace-alias

   */

  final void parseNamespaceAlias(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException

  {

    String sp = getRequiredAttribute(attrs, "stylesheet-prefix", node);

    String rp = getRequiredAttribute(attrs, "result-prefix", node);

    namespaceAliases.put(sp, rp);

  }

  /**

   * attribute-set

   */

  final void parseAttributeSet(Node node, NamedNodeMap attrs)

    throws TransformerConfigurationException, XPathExpressionException

  {

    TemplateNode children = parse(node.getFirstChild());

    String name = getRequiredAttribute(attrs, "name", node);

    String uas = getAttribute(attrs, "use-attribute-sets");

    attributeSets.add(new AttributeSet(children, name, uas));

  }

  /**

   * Parse top-level elements.

   */

  void parse(Node node, boolean root)

    throws TransformerConfigurationException

  {

    while (node != null)

      {

        current = node;

        doParse(node, root);