package net.sf.saxon.event;
import net.sf.saxon.om.*;
import net.sf.saxon.sort.IntArraySet;
import net.sf.saxon.tinytree.TinyBuilder;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.type.Type;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* StartTagBuffer is a ProxyReceiver that buffers attributes and namespace events within a start tag.
* It maintains details of the namespace context, and a full set of attribute information, on behalf
* of other filters that need access to namespace information or need to process attributes in arbitrary
* order.
*
* <p>StartTagBuffer also implements namespace fixup (the process of creating namespace nodes|bindings on behalf
* of constructed element and attribute nodes). Although this would be done anyway, further down the pipeline,
* it has to be done early in the case of a validating pipeline, because the namespace bindings must be created
* before any namespace-sensitive attribute content is validated.</p>
*
* <p>The StartTagBuffer also allows error conditions to be buffered. This is because the XSIAttributeHandler
* validates attributes such as xsi:type and xsi:nil before attempting to match its parent element against
* a particle of its containing type. It is possible that the parent element will match a wildcard particle
* with processContents="skip", in which case an invalid xsi:type or xsi:nil attribute is not an error.</p>
*/
public class StartTagBuffer extends ProxyReceiver implements NamespaceResolver {
// The location provider for input events
LocationProvider inputLocationProvider;
// Details of the pending element event
int elementNameCode;
int elementTypeCode;
int elementLocationId;
int elementProperties;
// Details of pending attribute events
AttributeCollectionImpl bufferedAttributes;
private boolean acceptAttributes;
private boolean inDocument;
// We keep track of namespaces. The namespaces
// array holds a list of all namespaces currently declared (organised as pairs of entries,
// prefix followed by URI). The stack contains an entry for each element currently open; the
// value on the stack is an Integer giving the number of namespaces added to the main
// namespace stack by that element.
private int[] namespaces = new int[50]; // all namespace codes currently declared
private int namespacesSize = 0; // all namespaces currently declared
private int[] countStack = new int[50];
private int depth = 0;
private int attCount = 0;
// We can make an element node representing this start tag for use in evaluation xs:alternative
// (conditional type assignment) expressions. Once this is done, we keep it.
private NodeInfo elementNode;
/**
* Set the pipeline configuration
* @param pipe the pipeline configuration
*/
public void setPipelineConfiguration(PipelineConfiguration pipe) {
super.setPipelineConfiguration(pipe);
bufferedAttributes = new AttributeCollectionImpl(pipe.getConfiguration());
}
/**
* Start of a document node.
*/
public void startDocument(int properties) throws XPathException {
// a document node in the content sequence of an element is ignored. However, we need
// to stop attributes being created within the document node.
if (depth == 0) {
depth++;
super.startDocument(properties);
}
acceptAttributes = false;
inDocument = true; // we ought to clear this on endDocument, but it only affects diagnostics
}
/**
* Notify the end of a document node
*/
public void endDocument() throws XPathException {
if (depth == 1) {
depth--;
super.endDocument();
}
}
/**
* startElement
*/
public void startElement(int nameCode, int typeCode, int locationId, int properties) throws XPathException {
elementNameCode = nameCode;
elementTypeCode = typeCode;
elementLocationId = locationId;
elementProperties = properties;
bufferedAttributes.clear();
// Record the current height of the namespace list so it can be reset at endElement time
countStack[depth] = 0;
if (++depth >= countStack.length) {
int[] newstack = new int[depth*2];
System.arraycopy(countStack, 0, newstack, 0, depth);
countStack = newstack;
}
// Ensure that the element namespace is output, unless this is done
// automatically by the caller (which is true, for example, for a literal
// result element).
acceptAttributes = true;
inDocument = false;
if ((properties & ReceiverOptions.NAMESPACE_OK) == 0) {
namespace(getNamePool().getNamespaceCode(nameCode), 0);
}
attCount = 0;
elementNode = null;
}
public void namespace(int namespaceCode, int properties) throws XPathException {
if (!acceptAttributes) {
throw NoOpenStartTagException.makeNoOpenStartTagException(
Type.NAMESPACE, getNamePool().getPrefixFromNamespaceCode(namespaceCode),
getPipelineConfiguration().getHostLanguage(),
inDocument, false);
}
// avoid duplicates
for (int n=0; n<countStack[depth - 1]; n++) {
if (namespaces[namespacesSize - 1 - n] == namespaceCode) {
return;
}
}
addToStack(namespaceCode);
countStack[depth - 1]++;
}
/**
* Notify an attribute. Attributes are notified after the startElement event, and before any
* children. Namespaces and attributes may be intermingled.
*
* @param nameCode The name of the attribute, as held in the name pool
* @param typeCode The type of the attribute, as held in the name pool
* @param properties Bit significant value. The following bits are defined:
* <dd>DISABLE_ESCAPING</dd> <dt>Disable escaping for this attribute</dt>
* <dd>NO_SPECIAL_CHARACTERS</dd> <dt>Attribute value contains no special characters</dt>
* @throws IllegalStateException: attempt to output an attribute when there is no open element
* start tag
*/
public void attribute(int nameCode, int typeCode, CharSequence value, int locationId, int properties)
throws XPathException {
if (!acceptAttributes) {
throw NoOpenStartTagException.makeNoOpenStartTagException(
Type.ATTRIBUTE, getNamePool().getDisplayName(nameCode),
getPipelineConfiguration().getHostLanguage(),
inDocument, false);
}
// Perform namespace fixup for the attribute
if (((properties & ReceiverOptions.NAMESPACE_OK) == 0) &&
NamePool.isPrefixed(nameCode)) { // non-null prefix
nameCode = checkProposedPrefix(nameCode, attCount++);
}
bufferedAttributes.addAttribute(nameCode, typeCode, value.toString(), locationId, properties);
// Note: we're relying on the fact that AttributeCollection can hold two attributes of the same name
// and maintain their order, because the check for duplicate attributes is not done until later in the
// pipeline. We validate both the attributes (see Bugzilla #4600 which legitimizes this.)
}
/**
* Add a namespace declaration (or undeclaration) to the stack
* @param nscode the namepool namespace code for the declaration
*/
private void addToStack(int nscode) {
// expand the stack if necessary
if (namespacesSize+1 >= namespaces.length) {
int[] newlist = new int[namespacesSize*2];
System.arraycopy(namespaces, 0, newlist, 0, namespacesSize);
namespaces = newlist;
}
namespaces[namespacesSize++] = nscode;
}
/**
* startContent: Add any namespace undeclarations needed to stop
* namespaces being inherited from parent elements
*/
public void startContent() throws XPathException {
nextReceiver.startElement(elementNameCode, elementTypeCode, elementLocationId,
elementProperties | ReceiverOptions.NAMESPACE_OK);
declareNamespacesForStartElement();
final int length = bufferedAttributes.getLength();
for (int i=0; i<length; i++) {
nextReceiver.attribute(bufferedAttributes.getNameCode(i),
bufferedAttributes.getTypeAnnotation(i),
bufferedAttributes.getValue(i),
bufferedAttributes.getLocationId(i),
bufferedAttributes.getProperties(i) | ReceiverOptions.NAMESPACE_OK);
}
acceptAttributes = false;
nextReceiver.startContent();
}
protected void declareNamespacesForStartElement() throws XPathException {
for (int i=namespacesSize - countStack[depth-1]; i<namespacesSize; i++) {
nextReceiver.namespace(namespaces[i], 0);
}
}
public int[] getLocalNamespaces() {
int size = countStack[depth-1];
if (size == 0) {
return IntArraySet.EMPTY_INT_ARRAY;
} else {
int[] nscodes = new int[countStack[depth-1]];
System.arraycopy(namespaces, namespacesSize - size, nscodes, 0, size);
return nscodes;
}
}
protected void declareAllNamespaces() throws XPathException {
for (int i=0; i<namespacesSize; i++) {
nextReceiver.namespace(namespaces[i], 0);
}
}
/**
* endElement: Discard the namespaces declared on this element.
*/
public void endElement () throws XPathException {
nextReceiver.endElement();
undeclareNamespacesForElement();
}
protected void undeclareNamespacesForElement() {
namespacesSize -= countStack[--depth];
}
/**
* Get the name of the current element
* @return the namepool namecode of the element
*/
public int getElementNameCode() {
return elementNameCode;
}
/**
* Determine if the current element has any attributes
* @return true if the element has one or more attributes
*/
public boolean hasAttributes() {
return bufferedAttributes.getLength() > 0;
}
/**
* Get the value of the current attribute with a given nameCode
* @param nameCode the name of the required attribute
* @return the attribute value, or null if the attribute is not present
*/
public String getAttribute(int nameCode) {
return bufferedAttributes.getValueByFingerprint(nameCode & 0xfffff);
}
/**
* Get all the attributes on the current element start tag
* @return an AttributeCollection containing all the attributes
*/
public AttributeCollection getAllAttributes() {
return bufferedAttributes;
}
/**
* 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 bound to any namespace
*/
protected short getURICode(short prefixCode) {
for (int i=namespacesSize-1; i>=0; i--) {
if ((namespaces[i]>>16) == (prefixCode)) {
final short uriCode = (short)(namespaces[i]&0xffff);
if (uriCode == 0) {
// we've found a namespace undeclaration, so it's as if the prefix weren't there at all
break;
}
return uriCode;
}
}
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(namespacesSize);
for (int i=namespacesSize-1; i>=0; i--) {
String prefix = pool.getPrefixFromNamespaceCode(namespaces[i]);
if (!prefixes.contains(prefix)) {
prefixes.add(prefix);
}
}
prefixes.add("xml");
return prefixes.iterator();
}
/**
* 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 proposed element or attribute name
* @param seq sequence number of attribute, used for generating distinctive prefixes
* @return the actual allocated name, which may be different.
*/
private int checkProposedPrefix(int nameCode, int seq) throws XPathException {
NamePool namePool = getNamePool();
int nscode = namePool.getNamespaceCode(nameCode);
int nsprefix = nscode>>16;
short existingURICode = getURICode((short)nsprefix);
if (existingURICode == -1) {
// prefix has not been declared: declare it now (namespace fixup)
namespace(nscode, 0);
return nameCode;
} else {
if ((nscode & 0xffff) == existingURICode) {
// prefix is already bound to this URI
return nameCode; // all is well
} else {
// conflict: prefix is currently bound to a different URI
String prefix = getSubstitutePrefix(nscode, seq);
int newCode = namePool.allocate(
prefix,
namePool.getURI(nameCode),
namePool.getLocalName(nameCode));
namespace(namePool.getNamespaceCode(newCode), 0);
return newCode;
}
}
}
/**
* 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 of the proposed element or attribute name
* @param seq sequence number of attribute, used for generating distinctive prefixes
* @return the actual allocated name, which may be different.
*/
private String getSubstitutePrefix(int nscode, int seq) {
String prefix = getNamePool().getPrefixFromNamespaceCode(nscode);
return prefix + '_' + seq;
}
/**
* Get an element node representing the element whose start tag this is, as required
* for implementing conditional type assignment
* @return an element node. This contains all the required namespaces and attributes, and has no children;
* it is untyped, as are the attributes.
*/
public NodeInfo getElementNode() throws XPathException {
if (elementNode == null) {
int len = bufferedAttributes.getLength();
TinyBuilder builder = new TinyBuilder();
builder.setSizeParameters(new int[]{2, len+2, namespacesSize+2, 16});
builder.setPipelineConfiguration(getPipelineConfiguration());
builder.open();
builder.startElement(elementNameCode, StandardNames.XS_UNTYPED_ATOMIC, 0, 0);
for (int i=0; i<namespacesSize; i++) {
builder.namespace(namespaces[i], 0);
}
for (int i=0; i<len; i++) {
builder.attribute(bufferedAttributes.getNameCode(i), StandardNames.XS_UNTYPED_ATOMIC,
bufferedAttributes.getValue(i), 0, 0);
}
builder.startContent();
builder.endElement();
elementNode = builder.getCurrentRoot();
}
return elementNode;
}
}
// Copyright (c) 2004 - 2008 Saxonica Limited