package net.sf.saxon.pull;
import net.sf.saxon.om.*;
import net.sf.saxon.trans.XPathException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* PullNamespaceReducer is a PullFilter responsible for removing duplicate namespace
* declarations. It also performs namespace fixup: that is, it ensures that the
* namespaces used in element and attribute names are all declared.
* <p/>
* <p>This class is derived from, and contains much common code with, the NamespaceReducer
* in the push pipeline. (In the push version, however, namespace fixup is not
* performed by the NamespaceReducer, but by the ComplexContentOutputter).</p>
*
* @see net.sf.saxon.event.NamespaceReducer
*/
public class PullNamespaceReducer extends PullFilter implements NamespaceResolver {
// As well as keeping track of namespaces, this class keeps a stack of element names,
// so that the current element name is available to the caller after an endElement event
private int[] namestack = new int[50]; // stack of element name codes
int elementJustEnded = -1; // namecode of the element that has just ended
// We keep track of namespaces to avoid outputting duplicate declarations. The namespaces
// vector holds a list of all namespaces currently declared (organised as integer namespace codes).
// The countStack contains an entry for each element currently open; the
// value on the countStack is an Integer giving the number of namespaces added to the main
// namespace stack by that element.
private int[] allNamespaces = new int[50]; // all namespace codes currently declared
private int allNamespacesSize = 0; // all namespaces currently declared
private int[] namespaceCountStack = new int[50]; // one entry per started element, holding the number
// of namespaces declared at that level
private int depth = 0; // current depth of element nesting
private int[] localNamespaces; // namespaces declared on the current start element
private int localNamespacesSize = 0;
private int nameCode; // the namecode of the current element
private NamespaceDeclarations declaredNamespaces;
private AttributeCollection attributeCollection;
// Creating an element does not automatically inherit the namespaces of the containing element.
// TODO: disinheriting namespaces is not yet supported by the pull pipeline
//private boolean[] disinheritStack = new boolean[50];
private int[] pendingUndeclarations = null;
/**
* Create a namespace reducer for a pull pipeline
* @param base the next stage in the pipeline, from which events are read
*/
public PullNamespaceReducer(PullProvider base) {
super(base);
}
/**
* next(): handle next event.
* The START_ELEMENT event removes redundant namespace declarations, and
* possibly adds an xmlns="" undeclaration.
*/
public int next() throws XPathException {
currentEvent = super.next();
switch (currentEvent) {
case START_ELEMENT:
startElement();
break;
case END_ELEMENT:
endElement();
break;
case PROCESSING_INSTRUCTION:
case ATTRIBUTE:
case NAMESPACE:
nameCode = super.getNameCode();
break;
default:
nameCode = -1;
}
return currentEvent;
}
private void startElement() throws XPathException {
// If the parent element specified inherit=no, keep a list of namespaces that need to be
// undeclared
// if (depth>0 && disinheritStack[depth-1]) {
// pendingUndeclarations = new int[namespacesSize];
// System.arraycopy(namespaces, 0, pendingUndeclarations, 0, namespacesSize);
// } else {
// pendingUndeclarations = null;
// }
// Record the current height of the namespace list so it can be reset at endElement time
namespaceCountStack[depth] = 0;
//disinheritStack[depth] = (properties & ReceiverOptions.DISINHERIT_NAMESPACES) != 0;
if (++depth >= namespaceCountStack.length) {
int[] newstack = new int[depth * 2];
System.arraycopy(namespaceCountStack, 0, newstack, 0, depth);
//boolean[] disStack2 = new boolean[depth*2];
//System.arraycopy(disinheritStack, 0, disStack2, 0, depth);
namespaceCountStack = newstack;
//disinheritStack = disStack2;
int[] name2 = new int[depth * 2];
System.arraycopy(namestack, 0, name2, 0, depth);
namestack = name2;
}
// Get the list of namespaces associated with this element
NamespaceDeclarations declarations = super.getNamespaceDeclarations();
localNamespaces = declarations.getNamespaceCodes(nsBuffer);
localNamespacesSize = 0;
for (int i = 0; i < localNamespaces.length; i++) {
if (localNamespaces[i] == -1) {
break;
} else {
if (isNeeded(localNamespaces[i])) {
addGlobalNamespace(localNamespaces[i]);
namespaceCountStack[depth - 1]++;
localNamespaces[localNamespacesSize++] = localNamespaces[i];
}
}
}
// Namespace fixup: ensure that the element namespace is output
nameCode = checkProposedPrefix(super.getNameCode(), 0);
namestack[depth - 1] = nameCode;
// int elementNS = getNamePool().allocateNamespaceCode(getNameCode());
// if (isNeeded(elementNS)) {
// appendNamespace(elementNS);
// }
// Namespace fixup: ensure that all namespaces used in attribute names are declared
attributeCollection = super.getAttributes();
boolean modified = false;
for (int i = 0; i < attributeCollection.getLength(); i++) {
int nc = attributeCollection.getNameCode(i);
if ((nc & ~NamePool.FP_MASK) != 0) {
// Only need to do checking for an attribute that's namespaced
int newnc = checkProposedPrefix(nc, i + 1);
if (nc != newnc) {
if (!modified) {
attributeCollection = copyAttributeCollection(attributeCollection);
modified = true;
}
((AttributeCollectionImpl) attributeCollection).setAttribute(i, newnc,
attributeCollection.getTypeAnnotation(i),
attributeCollection.getValue(i),
attributeCollection.getLocationId(i),
attributeCollection.getProperties(i));
}
}
}
if (localNamespacesSize < localNamespaces.length) {
localNamespaces[localNamespacesSize] = -1; // add a terminator
}
declaredNamespaces = new NamespaceDeclarationsImpl(getNamePool(), localNamespaces);
// TODO: defer construction of this object until the user asks for it
namespaceCountStack[depth - 1] = localNamespacesSize;
}
private int[] nsBuffer = new int[20];
private void addLocalNamespace(int nc) {
if (localNamespacesSize < localNamespaces.length) {
localNamespaces[localNamespacesSize++] = nc;
} else {
if (localNamespacesSize == 0) {
localNamespaces = new int[10];
} else {
int[] nc2 = new int[localNamespacesSize * 2];
System.arraycopy(localNamespaces, 0, nc2, 0, localNamespacesSize);
localNamespaces = nc2;
localNamespaces[localNamespacesSize++] = nc;
}
}
addGlobalNamespace(nc);
}
/**
* Determine whether a namespace declaration is needed
* @param nscode the namespace code of the declaration (prefix plus uri)
* @return true if the namespace declaration is needed
*/
private boolean isNeeded(int nscode) {
if (nscode == NamespaceConstant.XML_NAMESPACE_CODE) {
// Ignore the XML namespace
return false;
}
// First cancel any pending undeclaration of this namespace prefix (there may be more than one)
if (pendingUndeclarations != null) {
for (int p = 0; p < pendingUndeclarations.length; p++) {
if ((nscode >> 16) == (pendingUndeclarations[p] >> 16)) {
pendingUndeclarations[p] = -1;
//break;
}
}
}
for (int i = allNamespacesSize - 1; i >= 0; i--) {
if (allNamespaces[i] == nscode) {
// it's a duplicate so we don't need it
return false;
}
if ((allNamespaces[i] >> 16) == (nscode >> 16)) {
// same prefix, different URI, so we do need it
return true;
}
}
// we need it unless it's a redundant xmlns=""
return (nscode != NamespaceConstant.NULL_NAMESPACE_CODE);
// startContent: Add any namespace undeclarations needed to stop
// namespaces being inherited from parent elements
// if (pendingUndeclarations != null) {
// for (int i=0; i<pendingUndeclarations.length; i++) {
// int nscode1 = pendingUndeclarations[i];
// if (nscode1 != -1) {
// namespace(nscode1 & 0xffff0000, 0);
// // relies on the namespace() method to prevent duplicate undeclarations
// }
// }
// }
//pendingUndeclarations = null;
}
/**
* Check that the prefix for an element or attribute is acceptable, allocating a substitute
* prefix if not. The prefix is acceptable unless a namespace declaration has been
* written that assignes this prefix to a different namespace URI. This method
* also checks that the element or attribute namespace has been declared, and declares it
* if not.
* @param nameCode the integer name code of the element or attribute
* @param seq sequence number used to generate a unique prefix code
* @return either the original nameCode, or a new nameCode in which the prefix has been changed
*/
private int checkProposedPrefix(int nameCode, int seq) {
NamePool namePool = getNamePool();
int nscode = namePool.getNamespaceCode(nameCode);
if (nscode == -1) {
// avoid calling allocate where possible, because it's synchronized
nscode = namePool.allocateNamespaceCode(nameCode);
}
int nsprefix = nscode >> 16;
for (int i = allNamespacesSize - 1; i >= 0; i--) {
if (nsprefix == (allNamespaces[i] >> 16)) {
// same prefix
if ((nscode & 0xffff) == (allNamespaces[i] & 0xffff)) {
// same URI
return nameCode; // all is well
} else {
// same prefix is bound to a different URI. Action depends on whether the declaration
// is local to this element or at an outer level
if (i + localNamespacesSize >= allNamespacesSize) {
// the prefix is already defined locally, so allocate a new one
String prefix = getSubstitutePrefix(nscode, seq);
int newNameCode = namePool.allocate(prefix,
namePool.getURI(nameCode),
namePool.getLocalName(nameCode));
int newNSCode = namePool.allocateNamespaceCode(newNameCode);
addLocalNamespace(newNSCode);
return newNameCode;
} else {
// the prefix has been used on an outer level, but we can reuse it here
addLocalNamespace(nscode);
return nameCode;
}
}
}
}
// there is no declaration of this prefix: declare it now
if (nscode != NamespaceConstant.NULL_NAMESPACE_CODE) {
addLocalNamespace(nscode);
}
return nameCode;
}
/**
* It is possible for a single output element to use the same prefix to refer to different
* namespaces. In this case we have to generate an alternative prefix for uniqueness. The
* one we generate is based on the sequential position of the element/attribute: this is
* designed to ensure both uniqueness (with a high probability) and repeatability
* @param nscode the namespace code
* @param seq sequence number to help in making the generated prefix unique
* @return the invented prefix
*/
private String getSubstitutePrefix(int nscode, int seq) {
String prefix = getNamePool().getPrefixFromNamespaceCode(nscode);
return prefix + '_' + seq;
}
/**
* Add a namespace declaration to the stack
* @param nscode the namespace code representing the namespace declaration
*/
private void addGlobalNamespace(int nscode) {
// expand the stack if necessary
if (allNamespacesSize + 1 >= allNamespaces.length) {
int[] newlist = new int[allNamespacesSize * 2];
System.arraycopy(allNamespaces, 0, newlist, 0, allNamespacesSize);
allNamespaces = newlist;
}
allNamespaces[allNamespacesSize++] = nscode;
}
/**
* Get the nameCode identifying the name of the current node. This method
* can be used after the {@link #START_ELEMENT}, {@link #PROCESSING_INSTRUCTION},
* {@link #ATTRIBUTE}, or {@link #NAMESPACE} events. With some PullProvider implementations,
* <b>including this one</b>, it can also be used after {@link #END_ELEMENT}
* If called at other times, the result is undefined and may result in an IllegalStateException.
* If called when the current node is an unnamed namespace node (a node representing the default namespace)
* the returned value is -1.
*
* @return the nameCode. The nameCode can be used to obtain the prefix, local name,
* and namespace URI from the name pool.
*/
public int getNameCode() {
if (currentEvent == END_ELEMENT) {
return elementJustEnded;
} else {
return nameCode;
}
}
/**
* Get the attributes associated with the current element. This method must
* be called only after a START_ELEMENT event has been notified. The contents
* of the returned AttributeCollection are guaranteed to remain unchanged
* until the next START_ELEMENT event, but may be modified thereafter. The object
* should not be modified by the client.
* <p/>
* <p>Attributes may be read before or after reading the namespaces of an element,
* but must not be read after the first child node has been read, or after calling
* one of the methods skipToEnd(), getStringValue(), or getTypedValue().</p>
*
* @return an AttributeCollection representing the attributes of the element
* that has just been notified.
*/
public AttributeCollection getAttributes() throws XPathException {
return attributeCollection;
}
private AttributeCollectionImpl copyAttributeCollection(AttributeCollection in) {
AttributeCollectionImpl out = new AttributeCollectionImpl(getPipelineConfiguration().getConfiguration());
for (int i = 0; i < in.getLength(); i++) {
out.addAttribute(in.getNameCode(i),
in.getTypeAnnotation(i),
in.getValue(i),
in.getLocationId(i),
in.getProperties(i));
}
return out;
}
/**
* Get the namespace declarations associated with the current element. This method must
* be called only after a START_ELEMENT event has been notified. In the case of a top-level
* START_ELEMENT event (that is, an element that either has no parent node, or whose parent
* is not included in the sequence being read), the NamespaceDeclarations object returned
* will contain a namespace declaration for each namespace that is in-scope for this element
* node. In the case of a non-top-level element, the NamespaceDeclarations will contain
* a set of namespace declarations and undeclarations, representing the differences between
* this element and its parent.
* <p/>
* <p>This class extends the semantics of the PullProvider interface by allowing this method
* to be called also after an END_ELEMENT event. This is to support PullToStax, which requires
* this functionality. In this situation it returns the namespaces declared on the startElement
* associated with the element that has just ended.</p>
* <p>It is permissible for this method to return namespace declarations that are redundant.</p>
* <p/>
* <p>The NamespaceDeclarations object is guaranteed to remain unchanged until the next START_ELEMENT
* event, but may then be overwritten. The object should not be modified by the client.</p>
* <p/>
* <p>Namespaces may be read before or after reading the attributes of an element,
* but must not be read after the first child node has been read, or after calling
* one of the methods skipToEnd(), getStringValue(), or getTypedValue().</p>*
*/
public NamespaceDeclarations getNamespaceDeclarations() throws XPathException {
if (currentEvent == END_ELEMENT) {
// this case is sufficiently rare that we don't worry about its efficiency.
// The namespaces that are needed are still on the namespace stack, even though the
// top-of-stack pointer has already been decremented.
int nscount = namespaceCountStack[depth];
int[] namespaces = new int[nscount];
System.arraycopy(allNamespaces, allNamespacesSize, namespaces, 0, nscount);
return new NamespaceDeclarationsImpl(getNamePool(), namespaces);
} else {
return declaredNamespaces;
}
}
/**
* endElement: Discard the namespaces declared on this element. Note, however, that for the
* benefit of PullToStax, the namespaces that go out of scope on this endElement are available
* so long as the endElement is the current event
*/
public void endElement() throws XPathException {
if (depth-- == 0) {
throw new IllegalStateException("Attempt to output end tag with no matching start tag");
}
elementJustEnded = namestack[depth];
allNamespacesSize -= namespaceCountStack[depth];
}
/**
* Get the URI code corresponding to a given prefix code, by searching the
* in-scope namespaces. This is a service provided to subclasses.
*
* @param prefixCode the 16-bit prefix code required
* @return the 16-bit URI code, or -1 if the prefix is not found
*/
protected short getURICode(short prefixCode) {
for (int i = allNamespacesSize - 1; i >= 0; i--) {
if ((allNamespaces[i] >> 16) == (prefixCode)) {
return (short) (allNamespaces[i] & 0xffff);
}
}
if (prefixCode == 0) {
return 0; // by default, no prefix means no namespace URI
} else {
return -1;
}
}
/**
* Get the namespace URI corresponding to a given prefix. Return null
* if the prefix is not in scope.
*
* @param prefix the namespace prefix
* @param useDefault true if the default namespace is to be used when the
* prefix is ""
* @return the uri for the namespace, or null if the prefix is not in scope
*/
public String getURIForPrefix(String prefix, boolean useDefault) {
NamePool pool = getNamePool();
if ((prefix == null || prefix.length() == 0) && !useDefault) {
return "";
} else if ("xml".equals(prefix)) {
return NamespaceConstant.XML;
} else {
short prefixCode = pool.getCodeForPrefix(prefix);
short uriCode = getURICode(prefixCode);
if (uriCode == -1) {
return null;
}
return pool.getURIFromURICode(uriCode);
}
}
/**
* Get an iterator over all the prefixes declared in this namespace context. This will include
* the default namespace (prefix="") and the XML namespace where appropriate
*/
public Iterator iteratePrefixes() {
NamePool pool = getNamePool();
List prefixes = new ArrayList(allNamespacesSize);
for (int i = allNamespacesSize - 1; i >= 0; i--) {
String prefix = pool.getPrefixFromNamespaceCode(allNamespaces[i]);
if (!prefixes.contains(prefix)) {
prefixes.add(prefix);
}
}
prefixes.add("xml");
return prefixes.iterator();
}
}
//
// The contents of this file are subject to the Mozilla Public License Version 1.0 (the "License");
// you may not use this file except in compliance with the License. You may obtain a copy of the
// License at http://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
// See the License for the specific language governing rights and limitations under the License.
//
// The Original Code is: all this file.
//
// The Initial Developer of the Original Code is Michael H. Kay.
//
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
//
// Contributor(s): none.
//
|