Google Git
Sign in
apache / xalan-j / e31ae4c653d13f7df02d7529796ecc85bae2efe4 / . / src / org / apache / xpath / axes / WalkerFactory.java
blob: c8847450ad3026b8b07fa03544d395db60c62ec7 [file] [log] [blame]
/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, Lotus
* Development Corporation., http://www.lotus.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.xpath.axes;
import javax.xml.transform.TransformerException;
import org.apache.xalan.res.XSLMessages;
import org.apache.xml.dtm.Axis;
import org.apache.xml.dtm.DTMFilter;
import org.apache.xml.dtm.DTMIterator;
import org.apache.xpath.Expression;
import org.apache.xpath.functions.FuncLast;
import org.apache.xpath.functions.FuncPosition;
import org.apache.xpath.functions.Function;
import org.apache.xpath.objects.XNumber;
import org.apache.xpath.operations.Variable;
import org.apache.xpath.parser.Node;
import org.apache.xpath.parser.NodeTest;
import org.apache.xpath.parser.PathExpr;
import org.apache.xpath.parser.PatternAxis;
import org.apache.xpath.parser.Predicates;
import org.apache.xpath.parser.StepExpr;
import org.apache.xpath.res.XPATHErrorResources;
public class WalkerFactory
{
public static boolean isSet(int analysis, int bits)
{
return (0 != (analysis & bits));
}
/**
* Get a corresponding BIT_XXX from an axis.
* @param axis One of Axis.ANCESTOR, etc.
* @return One of BIT_ANCESTOR, etc.
*/
static public int getAnalysisBitFromAxes(int axis)
{
switch (axis) // Generate new traverser
{
case Axis.ANCESTOR :
return BIT_ANCESTOR;
case Axis.ANCESTORORSELF :
return BIT_ANCESTOR_OR_SELF;
case Axis.ATTRIBUTE :
return BIT_ATTRIBUTE;
case Axis.CHILD :
return BIT_CHILD;
case Axis.DESCENDANT :
return BIT_DESCENDANT;
case Axis.DESCENDANTORSELF :
return BIT_DESCENDANT_OR_SELF;
case Axis.FOLLOWING :
return BIT_FOLLOWING;
case Axis.FOLLOWINGSIBLING :
return BIT_FOLLOWING_SIBLING;
case Axis.NAMESPACE :
case Axis.NAMESPACEDECLS :
return BIT_NAMESPACE;
case Axis.PARENT :
return BIT_PARENT;
case Axis.PRECEDING :
return BIT_PRECEDING;
case Axis.PRECEDINGSIBLING :
return BIT_PRECEDING_SIBLING;
case Axis.SELF :
return BIT_SELF;
case Axis.ALLFROMNODE :
return BIT_DESCENDANT_OR_SELF;
// case Axis.PRECEDINGANDANCESTOR :
case Axis.DESCENDANTSFROMROOT :
case Axis.ALL :
case Axis.DESCENDANTSORSELFFROMROOT :
return BIT_DESCENDANT | BIT_DESCENDANT_OR_SELF | BIT_ANY_DESCENDANT_FROM_ROOT;
case Axis.ROOT :
return BIT_ROOT;
case Axis.FILTEREDLIST :
return BIT_FILTER;
default :
return BIT_FILTER;
}
}
/**
* Tell if the given axis goes downword. Bogus name, if you can think of
* a better one, please do tell. This really has to do with inverting
* attribute axis.
* @param axis One of Axis.XXX.
* @return true if the axis is not a child axis and does not go up from
* the axis root.
*/
public static boolean isDownwardAxisOfMany(int axis)
{
return (
(Axis.DESCENDANTORSELF == axis)
|| (Axis.DESCENDANT == axis)
|| (Axis.FOLLOWING == axis)
// || (Axis.FOLLOWINGSIBLING == axis)
|| (Axis.PRECEDING == axis)
// || (Axis.PRECEDINGSIBLING == axis)
);
}
/**
* First 8 bits are the number of top-level location steps. Hopefully
* there will never be more that 255 location steps!!!
*/
public static final int BITS_COUNT = 0x000000FF;
/** 4 bits are reserved for future use. */
public static final int BITS_RESERVED = 0x00000F00;
/** Bit is on if the expression contains a top-level predicate. */
public static final int BIT_PREDICATE = (0x00001000);
/** Bit is on if any of the walkers contain an ancestor step. */
public static final int BIT_ANCESTOR = (0x00001000 << 1);
/** Bit is on if any of the walkers contain an ancestor-or-self step. */
public static final int BIT_ANCESTOR_OR_SELF = (0x00001000 << 2);
/** Bit is on if any of the walkers contain an attribute step. */
public static final int BIT_ATTRIBUTE = (0x00001000 << 3);
/** Bit is on if any of the walkers contain a child step. */
public static final int BIT_CHILD = (0x00001000 << 4);
/** Bit is on if any of the walkers contain a descendant step. */
public static final int BIT_DESCENDANT = (0x00001000 << 5);
/** Bit is on if any of the walkers contain a descendant-or-self step. */
public static final int BIT_DESCENDANT_OR_SELF = (0x00001000 << 6);
/** Bit is on if any of the walkers contain a following step. */
public static final int BIT_FOLLOWING = (0x00001000 << 7);
/** Bit is on if any of the walkers contain a following-sibiling step. */
public static final int BIT_FOLLOWING_SIBLING = (0x00001000 << 8);
/** Bit is on if any of the walkers contain a namespace step. */
public static final int BIT_NAMESPACE = (0x00001000 << 9);
/** Bit is on if any of the walkers contain a parent step. */
public static final int BIT_PARENT = (0x00001000 << 10);
/** Bit is on if any of the walkers contain a preceding step. */
public static final int BIT_PRECEDING = (0x00001000 << 11);
/** Bit is on if any of the walkers contain a preceding-sibling step. */
public static final int BIT_PRECEDING_SIBLING = (0x00001000 << 12);
/** Bit is on if any of the walkers contain a self step. */
public static final int BIT_SELF = (0x00001000 << 13);
/**
* Bit is on if any of the walkers contain a filter (i.e. id(), extension
* function, etc.) step.
*/
public static final int BIT_FILTER = (0x00001000 << 14);
/** Bit is on if any of the walkers contain a root step. */
public static final int BIT_ROOT = (0x00001000 << 15);
/**
* If any of these bits are on, the expression may likely traverse outside
* the given subtree.
*/
public static final int BITMASK_TRAVERSES_OUTSIDE_SUBTREE =
(BIT_NAMESPACE // ??
| BIT_PRECEDING_SIBLING
| BIT_PRECEDING
| BIT_FOLLOWING_SIBLING
| BIT_FOLLOWING
| BIT_PARENT // except parent of attrs.
| BIT_ANCESTOR_OR_SELF | BIT_ANCESTOR | BIT_FILTER | BIT_ROOT);
/**
* Bit is on if any of the walkers can go backwards in document
* order from the context node.
*/
public static final int BIT_BACKWARDS_SELF = (0x00001000 << 16);
/** Found "//foo" pattern */
public static final int BIT_ANY_DESCENDANT_FROM_ROOT = (0x00001000 << 17);
/**
* Bit is on if any of the walkers contain an node() test. This is
* really only useful if the count is 1.
*/
public static final int BIT_NODETEST_ANY = (0x00001000 << 18);
// can't go higher than 18!
/** Bit is on if the expression is a match pattern. */
public static final int BIT_MATCH_PATTERN = (0x00001000 << 19);
/**
* Analyze a step and give information about it's predicates. Right now this
* just returns true or false if the step has a predicate.
*
* @param compiler non-null reference to compiler object that has processed
* the XPath operations into an opcode map.
* @param opPos The opcode position for the step.
* @param stepType The type of step, one of OP_GROUP, etc.
*
* @return true if step has a predicate.
*
* @throws javax.xml.transform.TransformerException
*/
static boolean analyzePredicate(StepExpr stepExpr)
throws javax.xml.transform.TransformerException
{
int childCount = stepExpr.jjtGetNumChildren();
Node lastChild = stepExpr.jjtGetChild(childCount - 1);
if (lastChild instanceof Predicates)
{
if (lastChild.jjtGetNumChildren() > 0)
{
return true;
}
}
return false;
}
/**
* Analyze the location path and return 32 bits that give information about
* the location path as a whole. See the BIT_XXX constants for meaning about
* each of the bits.
*
* @param compiler non-null reference to compiler object that has processed
* the XPath operations into an opcode map.
* @param stepOpCodePos The opcode position for the step.
* @param stepIndex The top-level step index withing the iterator.
*
* @return 32 bits as an integer that give information about the location
* path as a whole.
*
* @throws javax.xml.transform.TransformerException
*/
private static int analyze(PathExpr pathExpr, int stepIndex)
throws javax.xml.transform.TransformerException
{
int numSteps = pathExpr.jjtGetNumChildren();
int analysisResult = 0x00000000; // 32 bits of analysis
for (int i = stepIndex; i < numSteps; i++)
{
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(i);
boolean predAnalysis = analyzePredicate(stepExpr);
if (predAnalysis)
analysisResult |= BIT_PREDICATE;
Node firstChild = stepExpr.jjtGetChild(0);
if (firstChild instanceof PatternAxis)
{
int axis = ((PatternAxis) firstChild).getAxis();
switch (axis)
{
case Axis.ROOT :
analysisResult |= BIT_ROOT;
break;
case Axis.DESCENDANTSORSELFFROMROOT :
case Axis.DESCENDANTSFROMROOT :
analysisResult |= (BIT_ROOT | BIT_ANY_DESCENDANT_FROM_ROOT);
break;
case Axis.ANCESTOR :
analysisResult |= BIT_ANCESTOR;
break;
case Axis.ANCESTORORSELF :
analysisResult |= BIT_ANCESTOR_OR_SELF;
break;
case Axis.ATTRIBUTE :
analysisResult |= BIT_ATTRIBUTE;
break;
case Axis.NAMESPACE :
analysisResult |= BIT_NAMESPACE;
break;
case Axis.CHILD :
analysisResult |= BIT_CHILD;
break;
case Axis.DESCENDANT :
analysisResult |= BIT_DESCENDANT;
break;
case Axis.DESCENDANTORSELF :
analysisResult |= BIT_DESCENDANT_OR_SELF;
break;
case Axis.FOLLOWING :
analysisResult |= BIT_FOLLOWING;
break;
case Axis.FOLLOWINGSIBLING :
analysisResult |= BIT_FOLLOWING_SIBLING;
break;
case Axis.PRECEDING :
analysisResult |= BIT_PRECEDING;
break;
case Axis.PRECEDINGSIBLING :
analysisResult |= BIT_PRECEDING_SIBLING;
break;
case Axis.PARENT :
analysisResult |= BIT_PARENT;
break;
case Axis.SELF :
analysisResult |= BIT_SELF;
break;
default :
// TBD: Change the wording of this expression.
throw new RuntimeException(
XSLMessages.createXPATHMessage(
XPATHErrorResources.ER_NULL_ERROR_HANDLER,
new Object[] { firstChild.getClass().getName()}));
//"Programmer's assertion: unknown opcode: "
//+ stepType);
}
Node secondChild = stepExpr.jjtGetChild(1);
if (secondChild instanceof org.apache.xpath.parser.NodeTest)
{
org.apache.xpath.parser.NodeTest nt =
(org.apache.xpath.parser.NodeTest) secondChild;
if (nt.getWhatToShow() == org.apache.xml.dtm.DTMFilter.SHOW_ALL)
{
analysisResult |= BIT_NODETEST_ANY;
}
}
}
else
{
analysisResult |= BIT_FILTER;
}
}
analysisResult |= (numSteps & BITS_COUNT);
return analysisResult;
}
/**
* Create a new LocPathIterator iterator. The exact type of iterator
* returned is based on an analysis of the XPath operations.
*
* @param compiler non-null reference to compiler object that has processed
* the XPath operations into an opcode map.
* @param opPos The position of the operation code for this itterator.
*
* @return non-null reference to a LocPathIterator or derivative.
*
* @throws javax.xml.transform.TransformerException
*/
public static DTMIterator newDTMIterator(
PathExpr pathExpr,
boolean isTopLevel)
throws javax.xml.transform.TransformerException
{
int analysis = analyze(pathExpr, 0);
boolean isOneStep = isOneStep(analysis);
DTMIterator iter = getPossibleUnion(pathExpr, isTopLevel, isOneStep);
if(null != iter)
return iter;
// Is the iteration a one-step attribute pattern (i.e. select="@foo")?
if (isOneStep
&& walksSelfOnly(analysis)
&& isWild(analysis)
&& !hasPredicate(analysis))
{
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("SelfIteratorNoPredicate", analysis, pathExpr);
// Then use a simple iteration of the attributes, with node test
// and predicate testing.
iter = new SelfIteratorNoPredicate();
}
// Is the iteration exactly one child step?
else
if (walksChildrenOnly(analysis) && isOneStep)
{
// Does the pattern specify *any* child with no predicate? (i.e. select="child::node()".
if (isWild(analysis) && !hasPredicate(analysis))
{
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("ChildIterator", analysis, pathExpr);
// Use simple child iteration without any test.
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(0);
iter = new ChildIterator(stepExpr, analysis);
}
else
{
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("ChildTestIterator", analysis, pathExpr);
// Else use simple node test iteration with predicate test.
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(0);
iter = new ChildTestIterator(stepExpr, analysis);
}
}
// Is the iteration a one-step attribute pattern (i.e. select="@foo")?
else
if (isOneStep && walksAttributes(analysis))
{
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("AttributeIterator", analysis, pathExpr);
// Then use a simple iteration of the attributes, with node test
// and predicate testing.
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(0);
iter = new AttributeIterator(stepExpr, analysis);
}
else
if (isOneStep && !walksFilteredList(analysis))
{
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(0);
if (!walksNamespaces(analysis)
&& (walksInDocOrder(analysis) || isSet(analysis, BIT_PARENT)))
{
if (false || DEBUG_ITERATOR_CREATION)
diagnoseIterator("OneStepIteratorForward", analysis, pathExpr);
// Then use a simple iteration of the attributes, with node test
// and predicate testing.
iter = new OneStepIteratorForward(stepExpr, analysis);
}
else
{
if (false || DEBUG_ITERATOR_CREATION)
diagnoseIterator("OneStepIterator", analysis, pathExpr);
// Then use a simple iteration of the attributes, with node test
// and predicate testing.
iter = new OneStepIterator(stepExpr, analysis);
}
}
// Analysis of "//center":
// bits: 1001000000001010000000000000011
// count: 3
// root
// child:node()
// BIT_DESCENDANT_OR_SELF
// It's highly possible that we should have a seperate bit set for
// "//foo" patterns.
// For at least the time being, we can't optimize patterns like
// "//table[3]", because this has to be analyzed as
// "/descendant-or-self::node()/table[3]" in order for the indexes
// to work right.
else
if (isOptimizableForDescendantIterator(pathExpr,
0) // && getStepCount(analysis) <= 3
// && walksDescendants(analysis)
// && walksSubtreeOnlyFromRootOrContext(analysis)
)
{
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("DescendantIterator", analysis, pathExpr);
StepExpr stepExpr;
if (pathExpr.jjtGetNumChildren() == 2)
{
stepExpr = (StepExpr) pathExpr.jjtGetChild(1);
PatternAxis axisExpr = stepExpr.getAxisExpr();
axisExpr.setAxis(org.apache.xml.dtm.Axis.DESCENDANTSFROMROOT);
}
else
stepExpr = (StepExpr) pathExpr.jjtGetChild(0);
iter = new DescendantIterator(stepExpr);
}
else
{
if (isNaturalDocOrder(pathExpr, 0, analysis))
{
if (false || DEBUG_ITERATOR_CREATION)
{
diagnoseIterator("WalkingIterator", analysis, pathExpr);
}
iter =
new WalkingIterator(
pathExpr.getParser().getPrefixResolver(),
pathExpr);
}
else
{
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("MatchPatternIterator", analysis, compiler);
//
// return new MatchPatternIterator(compiler, opPos, analysis);
if (DEBUG_ITERATOR_CREATION)
diagnoseIterator("WalkingIteratorSorted", analysis, pathExpr);
iter =
new WalkingIteratorSorted(
pathExpr.getParser().getPrefixResolver(),
pathExpr);
}
}
if (iter instanceof LocPathIterator)
((LocPathIterator) iter).setIsTopLevel(isTopLevel);
return iter;
}
/**
* Check to see if we have a UnionPathIterator contained by a
* StepExpr and possibly a predicate, contained in a PathExpr.
* If this is the case, we just want the UnionPathIterator and
* any predicates it may have.
* It's likely that this reduction should be done somewhere else.
*
* @param pathExpr The path construction node that holds the subtree.
* @param isTopLevel True if this expression is at the top-level.
* @param isOneStep True if this expression only has one step.
* @return DTMIterator The reduced union iterator, or null if not a union.
* @throws TransformerException
*/
private static DTMIterator getPossibleUnion(
PathExpr pathExpr,
boolean isTopLevel,
boolean isOneStep)
throws TransformerException
{
Node n;
if(isOneStep &&
(n = pathExpr.jjtGetChild(0).jjtGetChild(0)) instanceof UnionPathIterator)
{
UnionPathIterator upi = (UnionPathIterator)n;
StepExpr se = (StepExpr)pathExpr.jjtGetChild(0);
upi.initPredicateInfo(se);
upi.setWhatToShow(DTMFilter.SHOW_ALL);
upi.setIsTopLevel(isTopLevel);
return upi;
}
else
return null;
}
public static void diagnoseIterator(
String name,
int analysis,
PathExpr pathExpr)
{
System.out.println(
pathExpr.toString()
+ ", "
+ name
+ ", "
+ Integer.toBinaryString(analysis)
+ ", "
+ getAnalysisString(analysis));
}
public static String getAnalysisString(int analysis)
{
StringBuffer buf = new StringBuffer();
buf.append("count: " + getStepCount(analysis) + " ");
if ((analysis & BIT_NODETEST_ANY) != 0)
{
buf.append("NTANY|");
}
if ((analysis & BIT_PREDICATE) != 0)
{
buf.append("PRED|");
}
if ((analysis & BIT_ANCESTOR) != 0)
{
buf.append("ANC|");
}
if ((analysis & BIT_ANCESTOR_OR_SELF) != 0)
{
buf.append("ANCOS|");
}
if ((analysis & BIT_ATTRIBUTE) != 0)
{
buf.append("ATTR|");
}
if ((analysis & BIT_CHILD) != 0)
{
buf.append("CH|");
}
if ((analysis & BIT_DESCENDANT) != 0)
{
buf.append("DESC|");
}
if ((analysis & BIT_DESCENDANT_OR_SELF) != 0)
{
buf.append("DESCOS|");
}
if ((analysis & BIT_FOLLOWING) != 0)
{
buf.append("FOL|");
}
if ((analysis & BIT_FOLLOWING_SIBLING) != 0)
{
buf.append("FOLS|");
}
if ((analysis & BIT_NAMESPACE) != 0)
{
buf.append("NS|");
}
if ((analysis & BIT_PARENT) != 0)
{
buf.append("P|");
}
if ((analysis & BIT_PRECEDING) != 0)
{
buf.append("PREC|");
}
if ((analysis & BIT_PRECEDING_SIBLING) != 0)
{
buf.append("PRECS|");
}
if ((analysis & BIT_SELF) != 0)
{
buf.append(".|");
}
if ((analysis & BIT_FILTER) != 0)
{
buf.append("FLT|");
}
if ((analysis & BIT_ROOT) != 0)
{
buf.append("R|");
}
return buf.toString();
}
/** Set to true for diagnostics about walker creation */
static final boolean DEBUG_PATTERN_CREATION = false;
/** Set to true for diagnostics about walker creation */
static final boolean DEBUG_WALKER_CREATION = false;
/** Set to true for diagnostics about iterator creation */
static final boolean DEBUG_ITERATOR_CREATION = false;
public static boolean hasPredicate(int analysis)
{
return (0 != (analysis & BIT_PREDICATE));
}
public static boolean isWild(int analysis)
{
return (0 != (analysis & BIT_NODETEST_ANY));
}
public static boolean walksAncestors(int analysis)
{
return isSet(analysis, BIT_ANCESTOR | BIT_ANCESTOR_OR_SELF);
}
public static boolean walksAttributes(int analysis)
{
return (0 != (analysis & BIT_ATTRIBUTE));
}
public static boolean walksNamespaces(int analysis)
{
return (0 != (analysis & BIT_NAMESPACE));
}
public static boolean walksChildren(int analysis)
{
return (0 != (analysis & BIT_CHILD));
}
public static boolean walksDescendants(int analysis)
{
return isSet(analysis, BIT_DESCENDANT | BIT_DESCENDANT_OR_SELF | BIT_ANY_DESCENDANT_FROM_ROOT);
}
public static boolean walksSubtree(int analysis)
{
return isSet(analysis, BIT_DESCENDANT | BIT_DESCENDANT_OR_SELF | BIT_CHILD);
}
public static boolean walksSubtreeOnlyMaybeAbsolute(int analysis)
{
return walksSubtree(analysis)
&& !walksExtraNodes(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis);
}
public static boolean walksSubtreeOnly(int analysis)
{
return walksSubtreeOnlyMaybeAbsolute(analysis) && !isAbsolute(analysis);
}
public static boolean walksFilteredList(int analysis)
{
return isSet(analysis, BIT_FILTER);
}
public static boolean walksSubtreeOnlyFromRootOrContext(int analysis)
{
return walksSubtree(analysis)
&& !walksExtraNodes(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& !isSet(analysis, BIT_FILTER);
}
public static boolean walksInDocOrder(int analysis)
{
return (
walksSubtreeOnlyMaybeAbsolute(analysis)
|| walksExtraNodesOnly(analysis)
|| walksFollowingOnlyMaybeAbsolute(analysis))
&& !isSet(analysis, BIT_FILTER);
}
public static boolean walksFollowingOnlyMaybeAbsolute(int analysis)
{
return isSet(analysis, BIT_SELF | BIT_FOLLOWING_SIBLING | BIT_FOLLOWING)
&& !walksSubtree(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis);
}
public static boolean walksUp(int analysis)
{
return isSet(analysis, BIT_PARENT | BIT_ANCESTOR | BIT_ANCESTOR_OR_SELF);
}
public static boolean walksSideways(int analysis)
{
return isSet(
analysis,
BIT_FOLLOWING
| BIT_FOLLOWING_SIBLING
| BIT_PRECEDING
| BIT_PRECEDING_SIBLING);
}
public static boolean walksExtraNodes(int analysis)
{
return isSet(analysis, BIT_NAMESPACE | BIT_ATTRIBUTE);
}
public static boolean walksExtraNodesOnly(int analysis)
{
return walksExtraNodes(analysis)
&& !isSet(analysis, BIT_SELF)
&& !walksSubtree(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& !isAbsolute(analysis);
}
public static boolean isAbsolute(int analysis)
{
return isSet(analysis, BIT_ROOT | BIT_FILTER);
}
public static boolean walksChildrenOnly(int analysis)
{
return walksChildren(analysis)
&& !isSet(analysis, BIT_SELF)
&& !walksExtraNodes(analysis)
&& !walksDescendants(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT));
}
public static boolean walksChildrenAndExtraAndSelfOnly(int analysis)
{
return walksChildren(analysis)
&& !walksDescendants(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT));
}
public static boolean walksDescendantsAndExtraAndSelfOnly(int analysis)
{
return !walksChildren(analysis)
&& walksDescendants(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT));
}
public static boolean walksSelfOnly(int analysis)
{
return isSet(analysis, BIT_SELF)
&& !walksSubtree(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& !isAbsolute(analysis);
}
public static boolean walksUpOnly(int analysis)
{
return !walksSubtree(analysis)
&& walksUp(analysis)
&& !walksSideways(analysis)
&& !isAbsolute(analysis);
}
public static boolean walksDownOnly(int analysis)
{
return walksSubtree(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& !isAbsolute(analysis);
}
public static boolean walksDownExtraOnly(int analysis)
{
return walksSubtree(analysis)
&& walksExtraNodes(analysis)
&& !walksUp(analysis)
&& !walksSideways(analysis)
&& !isAbsolute(analysis);
}
public static boolean canSkipSubtrees(int analysis)
{
return isSet(analysis, BIT_CHILD) | walksSideways(analysis);
}
public static boolean canCrissCross(int analysis)
{
// This could be done faster. Coded for clarity.
if (walksSelfOnly(analysis))
return false;
else
if (walksDownOnly(analysis) && !canSkipSubtrees(analysis))
return false;
else
if (walksChildrenAndExtraAndSelfOnly(analysis))
return false;
else
if (walksDescendantsAndExtraAndSelfOnly(analysis))
return false;
else
if (walksUpOnly(analysis))
return false;
else
if (walksExtraNodesOnly(analysis))
return false;
else
if (walksSubtree(analysis)
&& (walksSideways(analysis)
|| walksUp(analysis)
|| canSkipSubtrees(analysis)))
return true;
else
return false;
}
/**
* Tell if the pattern can be 'walked' with the iteration steps in natural
* document order, without duplicates.
*
* @param analysis The general analysis of the pattern.
*
* @return true if the walk can be done in natural order.
*
* @throws javax.xml.transform.TransformerException
*/
static public boolean isNaturalDocOrder(int analysis)
{
if (canCrissCross(analysis)
|| isSet(analysis, BIT_NAMESPACE)
|| walksFilteredList(analysis))
return false;
if (walksInDocOrder(analysis))
return true;
return false;
}
public static boolean isOneStep(int analysis)
{
return (analysis & BITS_COUNT) == 0x00000001;
}
public static int getStepCount(int analysis)
{
return (analysis & BITS_COUNT);
}
/**
* Tell if the pattern can be 'walked' with the iteration steps in natural
* document order, without duplicates.
*
* @param pathExpr Root of the path expression being analyzed.
* @param stepIndex The top-level step index withing the iterator.
* @param analysis The general analysis of the pattern.
*
* @return true if the walk can be done in natural order.
*
* @throws javax.xml.transform.TransformerException
*/
private static boolean isNaturalDocOrder(
PathExpr pathExpr,
int stepIndex,
int analysis)
throws javax.xml.transform.TransformerException
{
if (canCrissCross(analysis))
return false;
// Namespaces can present some problems, so just punt if we're looking for
// these.
if (isSet(analysis, BIT_NAMESPACE))
return false;
// The following, preceding, following-sibling, and preceding sibling can
// be found in doc order if we get to this point, but if they occur
// together, they produce
// duplicates, so it's better for us to eliminate this case so we don't
// have to check for duplicates during runtime if we're using a
// WalkingIterator.
if (isSet(analysis, BIT_FOLLOWING | BIT_FOLLOWING_SIBLING)
&& isSet(analysis, BIT_PRECEDING | BIT_PRECEDING_SIBLING))
return false;
// OK, now we have to check for select="@*/axis::*" patterns, which
// can also cause duplicates to happen. But select="axis*/@::*" patterns
// are OK, as are select="@foo/axis::*" patterns.
// Unfortunately, we can't do this just via the analysis bits.
int stepType;
boolean foundWildAttribute = false;
// Steps that can traverse anything other than down a
// subtree or that can produce duplicates when used in
// combonation are counted with this variable.
int potentialDuplicateMakingStepCount = 0;
int numSteps = pathExpr.jjtGetNumChildren();
for (int i = 0; i < numSteps; i++)
{
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(stepIndex);
Node firstChild = stepExpr.jjtGetChild(0);
if (firstChild instanceof PatternAxis)
{
Node secondChild = stepExpr.jjtGetChild(1);
org.apache.xpath.parser.NodeTest nt;
boolean isTotallyWild;
if (secondChild instanceof org.apache.xpath.parser.NodeTest)
{
nt = (org.apache.xpath.parser.NodeTest) secondChild;
isTotallyWild = nt.isTotallyWild();
// Double check.
if (0
!= (nt.getWhatToShow() | org.apache.xml.dtm.DTMFilter.SHOW_ALL))
{
isTotallyWild = true;
}
}
else
{
isTotallyWild = false;
nt = null;
}
int axis = ((PatternAxis) firstChild).getAxis();
switch (axis)
{
case Axis.NAMESPACE :
case Axis.ATTRIBUTE :
if (foundWildAttribute) // Maybe not needed, but be safe.
return false;
if (isTotallyWild)
foundWildAttribute = true;
break;
case Axis.DESCENDANTSFROMROOT :
case Axis.DESCENDANTSORSELFFROMROOT :
case Axis.ANCESTOR :
case Axis.ANCESTORORSELF :
case Axis.DESCENDANT :
case Axis.DESCENDANTORSELF :
case Axis.FOLLOWING :
case Axis.FOLLOWINGSIBLING :
case Axis.PRECEDING :
case Axis.PRECEDINGSIBLING :
case Axis.PARENT :
if (potentialDuplicateMakingStepCount > 0)
return false;
potentialDuplicateMakingStepCount++;
case Axis.ROOT :
case Axis.CHILD :
case Axis.SELF :
if (foundWildAttribute)
return false;
break;
default :
// TBD: Change the wording of this expression.
throw new RuntimeException(
XSLMessages.createXPATHMessage(
XPATHErrorResources.ER_NULL_ERROR_HANDLER,
new Object[] { firstChild.getClass().getName()}));
//"Programmer's assertion: unknown opcode: "
//+ stepType);
}
}
else
{
// For the moment return false if it is a filter expression.
// Ideally, we'd like to follow the analysis into a variable or function.
return false;
}
}
return true;
}
/**
* Special purpose function to see if we can optimize the pattern for
* a DescendantIterator.
*
* @param pathExpr Root of the path expression being analyzed.
* @param stepIndex The top-level step index withing the iterator.
*
* @return 32 bits as an integer that give information about the location
* path as a whole.
*
* @throws javax.xml.transform.TransformerException
*/
private static boolean isOptimizableForDescendantIterator(
PathExpr pathExpr,
int stepIndex)
throws javax.xml.transform.TransformerException
{
int stepType;
boolean foundDESCENDANTSFROMROOT = false;
int nodeTestType = DTMFilter.SHOW_ALL;
int numSteps = pathExpr.jjtGetNumChildren();
if (numSteps > 2)
return false;
for (int i = 0; i < numSteps; i++)
{
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(i);
int axis = stepExpr.getAxis();
switch (axis)
{
case Axis.SELF :
case Axis.ATTRIBUTE :
case Axis.ROOT :
case Axis.ANCESTOR :
case Axis.ANCESTORORSELF :
case Axis.NAMESPACE :
case Axis.DESCENDANT :
case Axis.DESCENDANTORSELF :
case Axis.FOLLOWING :
case Axis.FOLLOWINGSIBLING :
case Axis.PRECEDING :
case Axis.PRECEDINGSIBLING :
case Axis.PARENT :
return false;
case Axis.DESCENDANTSORSELFFROMROOT :
case Axis.DESCENDANTSFROMROOT :
if (0 != i)
return false;
foundDESCENDANTSFROMROOT = true;
if (analyzePredicate(stepExpr))
{
return false;
}
break;
case Axis.CHILD :
if (!foundDESCENDANTSFROMROOT || 1 != i)
return false;
if(mightBeProximate(stepExpr))
return false;
break;
default :
return false;
// TBD: Change the wording of this expression.
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{firstChild.getClass().getName()})); //"Programmer's assertion: unknown opcode: "
}
// TBD: I don't think the code will function properly without this.
// boolean mightBeProximate = mightBeProximate(compiler, stepOpCodePos, stepType);
// if(mightBeProximate)
// return false;
}
return true;
}
// TBD: Needs to use methods on the expressions instead of instanceof!
/**
* Tell if the predicates need to have proximity knowledge.
*/
public static boolean mightBeProximate(Expression stepExpr)
throws javax.xml.transform.TransformerException
{
boolean mightBeProximate = false;
int argLen;
Node lastChild = stepExpr.jjtGetChild(stepExpr.jjtGetNumChildren() - 1);
if (lastChild instanceof Predicates)
{
Predicates preds = (Predicates) lastChild;
int numChildren = preds.jjtGetNumChildren();
for (int i = 0; i < numChildren; i++)
{
Expression expr = (Expression) preds.jjtGetChild(i);
if (expr instanceof org.apache.xpath.operations.Variable)
{
return true;
// Would need more smarts to tell if this could be a number or not!
}
else
if (expr instanceof org.apache.xpath.objects.XNumber)
{
return true;
}
else
if (expr instanceof org.apache.xpath.parser.PathExpr
|| expr instanceof LocPathIterator)
{
// OK, keep going, we don't want to recurse.
}
else
if (expr instanceof org.apache.xpath.functions.Function)
{
boolean isProx =
functionProximateOrContainsProximate(
(org.apache.xpath.functions.Function) expr);
if (isProx)
return true;
break;
}
else
{
int numChildrenOfExpr = expr.jjtGetNumChildren();
for (int j = 0; j < numChildrenOfExpr; j++)
{
Expression exprChild = (Expression) expr.jjtGetChild(j);
boolean prox = isProximateInnerExpr(exprChild);
if (prox)
return true;
}
}
}
}
return mightBeProximate;
}
// TBD: Needs to use methods on the expressions instead of instanceof!
static boolean functionProximateOrContainsProximate(
org.apache.xpath.functions.Function func)
{
if (func instanceof org.apache.xpath.functions.FuncLast
|| func instanceof org.apache.xpath.functions.FuncPosition)
{
return true;
}
else
{
int numChildren = func.jjtGetNumChildren();
for (int i = 0; i < numChildren; i++)
{
Expression expr = (Expression) func.jjtGetChild(i);
boolean prox = isProximateInnerExpr(expr);
if (prox)
return true;
}
}
return false;
}
// TBD: Needs to use methods on the expressions instead of instanceof!
static boolean isProximateInnerExpr(Expression expr)
{
boolean mightBeProximate = false;
int argLen;
if (expr instanceof org.apache.xpath.parser.PathExpr
|| expr instanceof LocPathIterator)
{
// OK, we don't want to recurse!
}
else
if (expr instanceof org.apache.xpath.functions.Function)
{
boolean isProx =
functionProximateOrContainsProximate(
(org.apache.xpath.functions.Function) expr);
if (isProx)
return true;
}
else
{
int numChildrenOfExpr = expr.jjtGetNumChildren();
for (int j = 0; j < numChildrenOfExpr; j++)
{
Expression exprChild = (Expression) expr.jjtGetChild(j);
boolean prox = isProximateInnerExpr(exprChild);
if (prox)
return true;
}
}
return mightBeProximate;
}
/**
* Create the proper Walker from the axes type.
*
* @param compiler non-null reference to compiler object that has processed
* the XPath operations into an opcode map.
* @param opPos The opcode position for the step.
* @param lpi The owning location path iterator.
* @param analysis 32 bits of analysis, from which the type of AxesWalker
* may be influenced.
*
* @return non-null reference to AxesWalker derivative.
* @throws RuntimeException if the input is bad.
*/
private static AxesWalker createDefaultWalker(
StepExpr stepExpr,
WalkingIterator lpi,
int analysis)
{
AxesWalker ai = null;
PatternAxis patternAxis = stepExpr.getAxisExpr();
if (null != patternAxis)
{
boolean isTotallyWild = stepExpr.isTotallyWild();
int axis = stepExpr.getAxis();
switch (axis)
{
case Axis.ROOT :
ai = new AxesWalker(lpi, Axis.ROOT);
break;
case Axis.DESCENDANTSFROMROOT :
ai = new AxesWalker(lpi, Axis.DESCENDANTSFROMROOT);
break;
case Axis.DESCENDANTSORSELFFROMROOT :
ai = new AxesWalker(lpi, Axis.DESCENDANTSORSELFFROMROOT);
break;
case Axis.ANCESTOR :
ai = new ReverseAxesWalker(lpi, Axis.ANCESTOR);
break;
case Axis.ANCESTORORSELF :
ai = new ReverseAxesWalker(lpi, Axis.ANCESTORORSELF);
break;
case Axis.ATTRIBUTE :
ai = new AxesWalker(lpi, Axis.ATTRIBUTE);
break;
case Axis.NAMESPACE :
ai = new AxesWalker(lpi, Axis.NAMESPACE);
break;
case Axis.CHILD :
ai = new AxesWalker(lpi, Axis.CHILD);
break;
case Axis.DESCENDANT :
ai = new AxesWalker(lpi, Axis.DESCENDANT);
break;
case Axis.DESCENDANTORSELF :
ai = new AxesWalker(lpi, Axis.DESCENDANTORSELF);
break;
case Axis.FOLLOWING :
ai = new AxesWalker(lpi, Axis.FOLLOWING);
break;
case Axis.FOLLOWINGSIBLING :
ai = new AxesWalker(lpi, Axis.FOLLOWINGSIBLING);
break;
case Axis.PRECEDING :
ai = new ReverseAxesWalker(lpi, Axis.PRECEDING);
break;
case Axis.PRECEDINGSIBLING :
ai = new ReverseAxesWalker(lpi, Axis.PRECEDINGSIBLING);
break;
case Axis.PARENT :
ai = new ReverseAxesWalker(lpi, Axis.PARENT);
break;
case Axis.SELF :
ai = new AxesWalker(lpi, Axis.SELF);
break;
default :
throw new RuntimeException(
XSLMessages.createXPATHMessage(
XPATHErrorResources.ER_NULL_ERROR_HANDLER,
new Object[] { StepExpr.class.getName()}));
//"Programmer's assertion: unknown opcode: "
//+ stepType);
}
int whatToShow = stepExpr.getWhatToShow();
/*
System.out.print("construct: ");
NodeTest.debugWhatToShow(whatToShow);
System.out.println("or stuff: "+(whatToShow & (DTMFilter.SHOW_ATTRIBUTE
| DTMFilter.SHOW_ELEMENT
| DTMFilter.SHOW_PROCESSING_INSTRUCTION)));
*/
if ((0
== (whatToShow
& (DTMFilter.SHOW_ATTRIBUTE
| DTMFilter.SHOW_NAMESPACE
| DTMFilter.SHOW_ELEMENT
| DTMFilter.SHOW_PROCESSING_INSTRUCTION)))
|| (whatToShow == DTMFilter.SHOW_ALL))
ai.initNodeTest(whatToShow);
else
{
ai.initNodeTest(
whatToShow,
stepExpr.getNamespaceURI(),
stepExpr.getLocalName());
}
}
else
{
// FilterWalker
if (DEBUG_WALKER_CREATION)
System.out.println(
"new walker: FilterExprWalker: "
+ analysis
+ ", "
+ stepExpr.toString());
ai = new FilterExprWalker(lpi);
try
{
ai.init(stepExpr);
}
catch (TransformerException te)
{
throw new org.apache.xml.utils.WrappedRuntimeException(te);
}
ai.initNodeTest(DTMFilter.SHOW_ALL);
}
return ai;
}
/**
* <meta name="usage" content="advanced"/>
* This method is for building an array of possible levels
* where the target element(s) could be found for a match.
* @param xpath The xpath that is executing.
* @param context The current source tree context node.
*
* @param lpi The owning location path iterator object.
* @param compiler non-null reference to compiler object that has processed
* the XPath operations into an opcode map.
* @param stepOpCodePos The opcode position for the step.
* @param stepIndex The top-level step index withing the iterator.
*
* @return non-null AxesWalker derivative.
*
* @throws javax.xml.transform.TransformerException
*/
static AxesWalker loadWalkers(
org.apache.xpath.parser.PathExpr pathExpr,
WalkingIterator lpi)
throws javax.xml.transform.TransformerException
{
int stepType;
AxesWalker firstWalker = null;
AxesWalker walker, prevWalker = null;
int analysis = analyze(pathExpr, 0);
int numSteps = pathExpr.jjtGetNumChildren();
for (int i = 0; i < numSteps; i++)
{
StepExpr stepExpr = (StepExpr) pathExpr.jjtGetChild(i);
walker = createDefaultWalker(stepExpr, lpi, analysis);
walker.init(stepExpr);
// walker.setAnalysis(analysis);
if (null == firstWalker)
{
firstWalker = walker;
walker.exprSetParent(lpi);
}
else
{
prevWalker.setNextWalker(walker);
walker.setPrevWalker(prevWalker);
walker.exprSetParent(prevWalker);
}
prevWalker = walker;
}
return firstWalker;
}
}
//import org.apache.xpath.compiler.OpCodes;
//import org.apache.xpath.compiler.Compiler;
//import org.apache.xpath.compiler.FunctionTable;
//import org.apache.xpath.patterns.NodeTest;
//import org.apache.xpath.patterns.StepPattern;
//import org.apache.xpath.patterns.ContextMatchStepPattern;
//import org.apache.xpath.patterns.FunctionPattern;
//import org.apache.xpath.Expression;
//import org.apache.xpath.objects.XNumber;
//import org.apache.xalan.res.XSLMessages;
//import org.apache.xpath.res.XPATHErrorResources;
//
//import org.apache.xml.dtm.DTMFilter;
//import org.apache.xml.dtm.DTMIterator;
//import org.apache.xml.dtm.Axis;
//
///**
// * This class is both a factory for XPath location path expressions,
// * which are built from the opcode map output, and an analysis engine
// * for the location path expressions in order to provide optimization hints.
// */
//public class WalkerFactory
//{
//
// /**
// * <meta name="usage" content="advanced"/>
// * This method is for building an array of possible levels
// * where the target element(s) could be found for a match.
// * @param xpath The xpath that is executing.
// * @param context The current source tree context node.
// *
// * @param lpi The owning location path iterator.
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// *
// * @return non-null AxesWalker derivative.
// *
// * @throws javax.xml.transform.TransformerException
// */
// static AxesWalker loadOneWalker(
// WalkingIterator lpi, Compiler compiler, int stepOpCodePos)
// throws javax.xml.transform.TransformerException
// {
//
// AxesWalker firstWalker = null;
// int stepType = compiler.getOpMap()[stepOpCodePos];
//
// if (stepType != OpCodes.ENDOP)
// {
//
// // m_axesWalkers = new AxesWalker[1];
// // As we unwind from the recursion, create the iterators.
// firstWalker = createDefaultWalker(compiler, stepType, lpi, 0);
//
// firstWalker.init(compiler, stepOpCodePos, stepType);
// }
//
// return firstWalker;
// }
//
// /**
// * <meta name="usage" content="advanced"/>
// * This method is for building an array of possible levels
// * where the target element(s) could be found for a match.
// * @param xpath The xpath that is executing.
// * @param context The current source tree context node.
// *
// * @param lpi The owning location path iterator object.
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// * @param stepIndex The top-level step index withing the iterator.
// *
// * @return non-null AxesWalker derivative.
// *
// * @throws javax.xml.transform.TransformerException
// */
// static AxesWalker loadWalkers(
// WalkingIterator lpi, Compiler compiler, int stepOpCodePos, int stepIndex)
// throws javax.xml.transform.TransformerException
// {
//
// int stepType;
// AxesWalker firstWalker = null;
// AxesWalker walker, prevWalker = null;
// int ops[] = compiler.getOpMap();
// int analysis = analyze(compiler, stepOpCodePos, stepIndex);
//
// while (OpCodes.ENDOP != (stepType = ops[stepOpCodePos]))
// {
// walker = createDefaultWalker(compiler, stepOpCodePos, lpi, analysis);
//
// walker.init(compiler, stepOpCodePos, stepType);
// walker.exprSetParent(lpi);
//
// // walker.setAnalysis(analysis);
// if (null == firstWalker)
// {
// firstWalker = walker;
// }
// else
// {
// prevWalker.setNextWalker(walker);
// walker.setPrevWalker(prevWalker);
// }
//
// prevWalker = walker;
// stepOpCodePos = compiler.getNextStepPos(stepOpCodePos);
//
// if (stepOpCodePos < 0)
// break;
// }
//
// return firstWalker;
// }
//
// public static boolean isSet(int analysis, int bits)
// {
// return (0 != (analysis & bits));
// }
//
// public static void diagnoseIterator(String name, int analysis, Compiler compiler)
// {
// System.out.println(compiler.toString()+", "+name+", "
// + Integer.toBinaryString(analysis) + ", "
// + getAnalysisString(analysis));
// }
//
// /**
// * Create a new LocPathIterator iterator. The exact type of iterator
// * returned is based on an analysis of the XPath operations.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param opPos The position of the operation code for this itterator.
// *
// * @return non-null reference to a LocPathIterator or derivative.
// *
// * @throws javax.xml.transform.TransformerException
// */
// public static DTMIterator newDTMIterator(
// Compiler compiler, int opPos,
// boolean isTopLevel)
// throws javax.xml.transform.TransformerException
// {
//
// int firstStepPos = compiler.getFirstChildPos(opPos);
// int analysis = analyze(compiler, firstStepPos, 0);
// boolean isOneStep = isOneStep(analysis);
// DTMIterator iter;
//
// // Is the iteration a one-step attribute pattern (i.e. select="@foo")?
// if (isOneStep && walksSelfOnly(analysis) &&
// isWild(analysis) && !hasPredicate(analysis))
// {
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("SelfIteratorNoPredicate", analysis, compiler);
//
// // Then use a simple iteration of the attributes, with node test
// // and predicate testing.
// iter = new SelfIteratorNoPredicate(compiler, opPos, analysis);
// }
// // Is the iteration exactly one child step?
// else if (walksChildrenOnly(analysis) && isOneStep)
// {
//
// // Does the pattern specify *any* child with no predicate? (i.e. select="child::node()".
// if (isWild(analysis) && !hasPredicate(analysis))
// {
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("ChildIterator", analysis, compiler);
//
// // Use simple child iteration without any test.
// iter = new ChildIterator(compiler, opPos, analysis);
// }
// else
// {
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("ChildTestIterator", analysis, compiler);
//
// // Else use simple node test iteration with predicate test.
// iter = new ChildTestIterator(compiler, opPos, analysis);
// }
// }
// // Is the iteration a one-step attribute pattern (i.e. select="@foo")?
// else if (isOneStep && walksAttributes(analysis))
// {
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("AttributeIterator", analysis, compiler);
//
// // Then use a simple iteration of the attributes, with node test
// // and predicate testing.
// iter = new AttributeIterator(compiler, opPos, analysis);
// }
// else if(isOneStep && !walksFilteredList(analysis))
// {
// if( !walksNamespaces(analysis)
// && (walksInDocOrder(analysis) || isSet(analysis, BIT_PARENT)))
// {
// if (false || DEBUG_ITERATOR_CREATION)
// diagnoseIterator("OneStepIteratorForward", analysis, compiler);
//
// // Then use a simple iteration of the attributes, with node test
// // and predicate testing.
// iter = new OneStepIteratorForward(compiler, opPos, analysis);
// }
// else
// {
// if (false || DEBUG_ITERATOR_CREATION)
// diagnoseIterator("OneStepIterator", analysis, compiler);
//
// // Then use a simple iteration of the attributes, with node test
// // and predicate testing.
// iter = new OneStepIterator(compiler, opPos, analysis);
// }
// }
//
// // Analysis of "//center":
// // bits: 1001000000001010000000000000011
// // count: 3
// // root
// // child:node()
// // BIT_DESCENDANT_OR_SELF
// // It's highly possible that we should have a seperate bit set for
// // "//foo" patterns.
// // For at least the time being, we can't optimize patterns like
// // "//table[3]", because this has to be analyzed as
// // "/descendant-or-self::node()/table[3]" in order for the indexes
// // to work right.
// else if (isOptimizableForDescendantIterator(compiler, firstStepPos, 0)
// // && getStepCount(analysis) <= 3
// // && walksDescendants(analysis)
// // && walksSubtreeOnlyFromRootOrContext(analysis)
// )
// {
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("DescendantIterator", analysis, compiler);
//
// iter = new DescendantIterator(compiler, opPos, analysis);
// }
// else
// {
// if(isNaturalDocOrder(compiler, firstStepPos, 0, analysis))
// {
// if (false || DEBUG_ITERATOR_CREATION)
// {
// diagnoseIterator("WalkingIterator", analysis, compiler);
// }
//
// iter = new WalkingIterator(compiler, opPos, analysis, true);
// }
// else
// {
//// if (DEBUG_ITERATOR_CREATION)
//// diagnoseIterator("MatchPatternIterator", analysis, compiler);
////
//// return new MatchPatternIterator(compiler, opPos, analysis);
// if (DEBUG_ITERATOR_CREATION)
// diagnoseIterator("WalkingIteratorSorted", analysis, compiler);
//
// iter = new WalkingIteratorSorted(compiler, opPos, analysis, true);
// }
// }
// if(iter instanceof LocPathIterator)
// ((LocPathIterator)iter).setIsTopLevel(isTopLevel);
//
// return iter;
// }
//
// /**
// * Special purpose function to see if we can optimize the pattern for
// * a DescendantIterator.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// * @param stepIndex The top-level step index withing the iterator.
// *
// * @return 32 bits as an integer that give information about the location
// * path as a whole.
// *
// * @throws javax.xml.transform.TransformerException
// */
// public static int getAxisFromStep(
// Compiler compiler, int stepOpCodePos)
// throws javax.xml.transform.TransformerException
// {
//
// int ops[] = compiler.getOpMap();
// int stepType = ops[stepOpCodePos];
//
// switch (stepType)
// {
// case OpCodes.FROM_FOLLOWING :
// return Axis.FOLLOWING;
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// return Axis.FOLLOWINGSIBLING;
// case OpCodes.FROM_PRECEDING :
// return Axis.PRECEDING;
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// return Axis.PRECEDINGSIBLING;
// case OpCodes.FROM_PARENT :
// return Axis.PARENT;
// case OpCodes.FROM_NAMESPACE :
// return Axis.NAMESPACE;
// case OpCodes.FROM_ANCESTORS :
// return Axis.ANCESTOR;
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// return Axis.ANCESTORORSELF;
// case OpCodes.FROM_ATTRIBUTES :
// return Axis.ATTRIBUTE;
// case OpCodes.FROM_ROOT :
// return Axis.ROOT;
// case OpCodes.FROM_CHILDREN :
// return Axis.CHILD;
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
// return Axis.DESCENDANTORSELF;
// case OpCodes.FROM_DESCENDANTS :
// return Axis.DESCENDANT;
// case OpCodes.FROM_SELF :
// return Axis.SELF;
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// case OpCodes.OP_VARIABLE :
// return Axis.FILTEREDLIST;
// }
//
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// //+ stepType);
// }
//
// /**
// * Get a corresponding BIT_XXX from an axis.
// * @param axis One of Axis.ANCESTOR, etc.
// * @return One of BIT_ANCESTOR, etc.
// */
// static public int getAnalysisBitFromAxes(int axis)
// {
// switch (axis) // Generate new traverser
// {
// case Axis.ANCESTOR :
// return BIT_ANCESTOR;
// case Axis.ANCESTORORSELF :
// return BIT_ANCESTOR_OR_SELF;
// case Axis.ATTRIBUTE :
// return BIT_ATTRIBUTE;
// case Axis.CHILD :
// return BIT_CHILD;
// case Axis.DESCENDANT :
// return BIT_DESCENDANT;
// case Axis.DESCENDANTORSELF :
// return BIT_DESCENDANT_OR_SELF;
// case Axis.FOLLOWING :
// return BIT_FOLLOWING;
// case Axis.FOLLOWINGSIBLING :
// return BIT_FOLLOWING_SIBLING;
// case Axis.NAMESPACE :
// case Axis.NAMESPACEDECLS :
// return BIT_NAMESPACE;
// case Axis.PARENT :
// return BIT_PARENT;
// case Axis.PRECEDING :
// return BIT_PRECEDING;
// case Axis.PRECEDINGSIBLING :
// return BIT_PRECEDING_SIBLING;
// case Axis.SELF :
// return BIT_SELF;
// case Axis.ALLFROMNODE :
// return BIT_DESCENDANT_OR_SELF;
// // case Axis.PRECEDINGANDANCESTOR :
// case Axis.DESCENDANTSFROMROOT :
// case Axis.ALL :
// case Axis.DESCENDANTSORSELFFROMROOT :
// return BIT_ANY_DESCENDANT_FROM_ROOT;
// case Axis.ROOT :
// return BIT_ROOT;
// case Axis.FILTEREDLIST :
// return BIT_FILTER;
// default :
// return BIT_FILTER;
// }
// }
//
// static boolean functionProximateOrContainsProximate(Compiler compiler,
// int opPos)
// {
// int endFunc = opPos + compiler.getOp(opPos + 1) - 1;
// opPos = compiler.getFirstChildPos(opPos);
// int funcID = compiler.getOp(opPos);
// // System.out.println("funcID: "+funcID);
// // System.out.println("opPos: "+opPos);
// // System.out.println("endFunc: "+endFunc);
// switch(funcID)
// {
// case FunctionTable.FUNC_LAST:
// case FunctionTable.FUNC_POSITION:
// return true;
// default:
// opPos++;
// int i = 0;
// for (int p = opPos; p < endFunc; p = compiler.getNextOpPos(p), i++)
// {
// int innerExprOpPos = p+2;
// int argOp = compiler.getOp(innerExprOpPos);
// boolean prox = isProximateInnerExpr(compiler, innerExprOpPos);
// if(prox)
// return true;
// }
//
// }
// return false;
// }
//
// static boolean isProximateInnerExpr(Compiler compiler, int opPos)
// {
// int op = compiler.getOp(opPos);
// int innerExprOpPos = opPos+2;
// switch(op)
// {
// case OpCodes.OP_ARGUMENT:
// if(isProximateInnerExpr(compiler, innerExprOpPos))
// return true;
// break;
// case OpCodes.OP_VARIABLE:
// case OpCodes.OP_NUMBERLIT:
// case OpCodes.OP_LITERAL:
// case OpCodes.OP_LOCATIONPATH:
// break; // OK
// case OpCodes.OP_FUNCTION:
// boolean isProx = functionProximateOrContainsProximate(compiler, opPos);
// if(isProx)
// return true;
// break;
// case OpCodes.OP_GT:
// case OpCodes.OP_GTE:
// case OpCodes.OP_LT:
// case OpCodes.OP_LTE:
// case OpCodes.OP_EQUALS:
// int leftPos = compiler.getFirstChildPos(op);
// int rightPos = compiler.getNextOpPos(leftPos);
// isProx = isProximateInnerExpr(compiler, leftPos);
// if(isProx)
// return true;
// isProx = isProximateInnerExpr(compiler, rightPos);
// if(isProx)
// return true;
// break;
// default:
// return true; // be conservative...
// }
// return false;
// }
//
// /**
// * Tell if the predicates need to have proximity knowledge.
// */
// public static boolean mightBeProximate(Compiler compiler, int opPos, int stepType)
// throws javax.xml.transform.TransformerException
// {
//
// boolean mightBeProximate = false;
// int argLen;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// argLen = compiler.getArgLength(opPos);
// break;
// default :
// argLen = compiler.getArgLengthOfStep(opPos);
// }
//
// int predPos = compiler.getFirstPredicateOpPos(opPos);
// int count = 0;
//
// while (OpCodes.OP_PREDICATE == compiler.getOp(predPos))
// {
// count++;
//
// int innerExprOpPos = predPos+2;
// int predOp = compiler.getOp(innerExprOpPos);
//
// switch(predOp)
// {
// case OpCodes.OP_VARIABLE:
// return true; // Would need more smarts to tell if this could be a number or not!
// case OpCodes.OP_LOCATIONPATH:
// // OK.
// break;
// case OpCodes.OP_NUMBER:
// case OpCodes.OP_NUMBERLIT:
// return true; // that's all she wrote!
// case OpCodes.OP_FUNCTION:
// boolean isProx
// = functionProximateOrContainsProximate(compiler, innerExprOpPos);
// if(isProx)
// return true;
// break;
// case OpCodes.OP_GT:
// case OpCodes.OP_GTE:
// case OpCodes.OP_LT:
// case OpCodes.OP_LTE:
// case OpCodes.OP_EQUALS:
// int leftPos = compiler.getFirstChildPos(innerExprOpPos);
// int rightPos = compiler.getNextOpPos(leftPos);
// isProx = isProximateInnerExpr(compiler, leftPos);
// if(isProx)
// return true;
// isProx = isProximateInnerExpr(compiler, rightPos);
// if(isProx)
// return true;
// break;
// default:
// return true; // be conservative...
// }
//
// predPos = compiler.getNextOpPos(predPos);
// }
//
// return mightBeProximate;
// }
//
// /**
// * Special purpose function to see if we can optimize the pattern for
// * a DescendantIterator.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// * @param stepIndex The top-level step index withing the iterator.
// *
// * @return 32 bits as an integer that give information about the location
// * path as a whole.
// *
// * @throws javax.xml.transform.TransformerException
// */
// private static boolean isOptimizableForDescendantIterator(
// Compiler compiler, int stepOpCodePos, int stepIndex)
// throws javax.xml.transform.TransformerException
// {
//
// int stepType;
// int ops[] = compiler.getOpMap();
// int stepCount = 0;
// boolean foundDorDS = false;
// boolean foundSelf = false;
// boolean foundDS = false;
//
// int nodeTestType = OpCodes.NODETYPE_NODE;
//
// while (OpCodes.ENDOP != (stepType = ops[stepOpCodePos]))
// {
// // The DescendantIterator can only do one node test. If there's more
// // than one, use another iterator.
// if(nodeTestType != OpCodes.NODETYPE_NODE && nodeTestType != OpCodes.NODETYPE_ROOT)
// return false;
//
// stepCount++;
// if(stepCount > 3)
// return false;
//
// boolean mightBeProximate = mightBeProximate(compiler, stepOpCodePos, stepType);
// if(mightBeProximate)
// return false;
//
// switch (stepType)
// {
// case OpCodes.FROM_FOLLOWING :
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// case OpCodes.FROM_PRECEDING :
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// case OpCodes.FROM_PARENT :
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// case OpCodes.FROM_NAMESPACE :
// case OpCodes.FROM_ANCESTORS :
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// case OpCodes.FROM_ATTRIBUTES :
// case OpCodes.MATCH_ATTRIBUTE :
// case OpCodes.MATCH_ANY_ANCESTOR :
// case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
// return false;
// case OpCodes.FROM_ROOT :
// if(1 != stepCount)
// return false;
// break;
// case OpCodes.FROM_CHILDREN :
// if(!foundDS && !(foundDorDS && foundSelf))
// return false;
// break;
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
// foundDS = true;
// case OpCodes.FROM_DESCENDANTS :
// if(3 == stepCount)
// return false;
// foundDorDS = true;
// break;
// case OpCodes.FROM_SELF :
// if(1 != stepCount)
// return false;
// foundSelf = true;
// break;
// default :
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// // + stepType);
// }
//
// nodeTestType = compiler.getStepTestType(stepOpCodePos);
//
// int nextStepOpCodePos = compiler.getNextStepPos(stepOpCodePos);
//
// if (nextStepOpCodePos < 0)
// break;
//
// if(OpCodes.ENDOP != ops[nextStepOpCodePos])
// {
// if(compiler.countPredicates(stepOpCodePos) > 0)
// {
// return false;
// }
// }
//
// stepOpCodePos = nextStepOpCodePos;
// }
//
// return true;
// }
//
// /**
// * Analyze the location path and return 32 bits that give information about
// * the location path as a whole. See the BIT_XXX constants for meaning about
// * each of the bits.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// * @param stepIndex The top-level step index withing the iterator.
// *
// * @return 32 bits as an integer that give information about the location
// * path as a whole.
// *
// * @throws javax.xml.transform.TransformerException
// */
// private static int analyze(
// Compiler compiler, int stepOpCodePos, int stepIndex)
// throws javax.xml.transform.TransformerException
// {
//
// int stepType;
// int ops[] = compiler.getOpMap();
// int stepCount = 0;
// int analysisResult = 0x00000000; // 32 bits of analysis
//
// while (OpCodes.ENDOP != (stepType = ops[stepOpCodePos]))
// {
// stepCount++;
//
// // String namespace = compiler.getStepNS(stepOpCodePos);
// // boolean isNSWild = (null != namespace)
// // ? namespace.equals(NodeTest.WILD) : false;
// // String localname = compiler.getStepLocalName(stepOpCodePos);
// // boolean isWild = (null != localname) ? localname.equals(NodeTest.WILD) : false;
// boolean predAnalysis = analyzePredicate(compiler, stepOpCodePos,
// stepType);
//
// if (predAnalysis)
// analysisResult |= BIT_PREDICATE;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// analysisResult |= BIT_FILTER;
// break;
// case OpCodes.FROM_ROOT :
// analysisResult |= BIT_ROOT;
// break;
// case OpCodes.FROM_ANCESTORS :
// analysisResult |= BIT_ANCESTOR;
// break;
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// analysisResult |= BIT_ANCESTOR_OR_SELF;
// break;
// case OpCodes.FROM_ATTRIBUTES :
// analysisResult |= BIT_ATTRIBUTE;
// break;
// case OpCodes.FROM_NAMESPACE :
// analysisResult |= BIT_NAMESPACE;
// break;
// case OpCodes.FROM_CHILDREN :
// analysisResult |= BIT_CHILD;
// break;
// case OpCodes.FROM_DESCENDANTS :
// analysisResult |= BIT_DESCENDANT;
// break;
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
//
// // Use a special bit to to make sure we get the right analysis of "//foo".
// if (2 == stepCount && BIT_ROOT == analysisResult)
// {
// analysisResult |= BIT_ANY_DESCENDANT_FROM_ROOT;
// }
//
// analysisResult |= BIT_DESCENDANT_OR_SELF;
// break;
// case OpCodes.FROM_FOLLOWING :
// analysisResult |= BIT_FOLLOWING;
// break;
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// analysisResult |= BIT_FOLLOWING_SIBLING;
// break;
// case OpCodes.FROM_PRECEDING :
// analysisResult |= BIT_PRECEDING;
// break;
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// analysisResult |= BIT_PRECEDING_SIBLING;
// break;
// case OpCodes.FROM_PARENT :
// analysisResult |= BIT_PARENT;
// break;
// case OpCodes.FROM_SELF :
// analysisResult |= BIT_SELF;
// break;
// case OpCodes.MATCH_ATTRIBUTE :
// analysisResult |= (BIT_MATCH_PATTERN | BIT_ATTRIBUTE);
// break;
// case OpCodes.MATCH_ANY_ANCESTOR :
// analysisResult |= (BIT_MATCH_PATTERN | BIT_ANCESTOR);
// break;
// case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
// analysisResult |= (BIT_MATCH_PATTERN | BIT_PARENT);
// break;
// default :
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// //+ stepType);
// }
//
// if (OpCodes.NODETYPE_NODE == ops[stepOpCodePos + 3]) // child::node()
// {
// analysisResult |= BIT_NODETEST_ANY;
// }
//
// stepOpCodePos = compiler.getNextStepPos(stepOpCodePos);
//
// if (stepOpCodePos < 0)
// break;
// }
//
// analysisResult |= (stepCount & BITS_COUNT);
//
// return analysisResult;
// }
//
// /**
// * Tell if the given axis goes downword. Bogus name, if you can think of
// * a better one, please do tell. This really has to do with inverting
// * attribute axis.
// * @param axis One of Axis.XXX.
// * @return true if the axis is not a child axis and does not go up from
// * the axis root.
// */
// public static boolean isDownwardAxisOfMany(int axis)
// {
// return ((Axis.DESCENDANTORSELF == axis) ||
// (Axis.DESCENDANT == axis)
// || (Axis.FOLLOWING == axis)
//// || (Axis.FOLLOWINGSIBLING == axis)
// || (Axis.PRECEDING == axis)
//// || (Axis.PRECEDINGSIBLING == axis)
// );
// }
//
// /**
// * Read a <a href="http://www.w3.org/TR/xpath#location-paths">LocationPath</a>
// * as a generalized match pattern. What this means is that the LocationPath
// * is read backwards, as a test on a given node, to see if it matches the
// * criteria of the selection, and ends up at the context node. Essentially,
// * this is a backwards query from a given node, to find the context node.
// * <p>So, the selection "foo/daz[2]" is, in non-abreviated expanded syntax,
// * "self::node()/following-sibling::foo/child::daz[position()=2]".
// * Taking this as a match pattern for a probable node, it works out to
// * "self::daz/parent::foo[child::daz[position()=2 and isPrevStepNode()]
// * precedingSibling::node()[isContextNodeOfLocationPath()]", adding magic
// * isPrevStepNode and isContextNodeOfLocationPath operations. Predicates in
// * the location path have to be executed by the following step,
// * because they have to know the context of their execution.
// *
// * @param mpi The MatchPatternIterator to which the steps will be attached.
// * @param compiler The compiler that holds the syntax tree/op map to
// * construct from.
// * @param stepOpCodePos The current op code position within the opmap.
// * @param stepIndex The top-level step index withing the iterator.
// *
// * @return A StepPattern object, which may contain relative StepPatterns.
// *
// * @throws javax.xml.transform.TransformerException
// */
// static StepPattern loadSteps(
// MatchPatternIterator mpi, Compiler compiler, int stepOpCodePos,
// int stepIndex)
// throws javax.xml.transform.TransformerException
// {
// if (DEBUG_PATTERN_CREATION)
// {
// System.out.println("================");
// System.out.println("loadSteps for: "+compiler.getPatternString());
// }
// int stepType;
// StepPattern step = null;
// StepPattern firstStep = null, prevStep = null;
// int ops[] = compiler.getOpMap();
// int analysis = analyze(compiler, stepOpCodePos, stepIndex);
//
// while (OpCodes.ENDOP != (stepType = ops[stepOpCodePos]))
// {
// step = createDefaultStepPattern(compiler, stepOpCodePos, mpi, analysis,
// firstStep, prevStep);
//
// if (null == firstStep)
// {
// firstStep = step;
// }
// else
// {
//
// //prevStep.setNextWalker(step);
// step.setRelativePathPattern(prevStep);
// }
//
// prevStep = step;
// stepOpCodePos = compiler.getNextStepPos(stepOpCodePos);
//
// if (stepOpCodePos < 0)
// break;
// }
//
// int axis = Axis.SELF;
// int paxis = Axis.SELF;
// StepPattern tail = step;
// for (StepPattern pat = step; null != pat;
// pat = pat.getRelativePathPattern())
// {
// int nextAxis = pat.getAxis();
// //int nextPaxis = pat.getPredicateAxis();
// pat.setAxis(axis);
//
// // The predicate axis can't be moved!!! Test Axes103
// // pat.setPredicateAxis(paxis);
//
// // If we have an attribute or namespace axis that went up, then
// // it won't find the attribute in the inverse, since the select-to-match
// // axes are not invertable (an element is a parent of an attribute, but
// // and attribute is not a child of an element).
// // If we don't do the magic below, then "@*/ancestor-or-self::*" gets
// // inverted for match to "self::*/descendant-or-self::@*/parent::node()",
// // which obviously won't work.
// // So we will rewrite this as:
// // "self::*/descendant-or-self::*/attribute::*/parent::node()"
// // Child has to be rewritten a little differently:
// // select: "@*/parent::*"
// // inverted match: "self::*/child::@*/parent::node()"
// // rewrite: "self::*/attribute::*/parent::node()"
// // Axes that go down in the select, do not have to have special treatment
// // in the rewrite. The following inverted match will still not select
// // anything.
// // select: "@*/child::*"
// // inverted match: "self::*/parent::@*/parent::node()"
// // Lovely business, this.
// // -sb
// int whatToShow = pat.getWhatToShow();
// if(whatToShow == DTMFilter.SHOW_ATTRIBUTE ||
// whatToShow == DTMFilter.SHOW_NAMESPACE)
// {
// int newAxis = (whatToShow == DTMFilter.SHOW_ATTRIBUTE) ?
// Axis.ATTRIBUTE : Axis.NAMESPACE;
// if(isDownwardAxisOfMany(axis))
// {
// StepPattern attrPat = new StepPattern(whatToShow,
// pat.getNamespace(),
// pat.getLocalName(),
// //newAxis, pat.getPredicateAxis);
// newAxis, 0); // don't care about the predicate axis
// XNumber score = pat.getStaticScore();
// pat.setNamespace(null);
// pat.setLocalName(NodeTest.WILD);
// attrPat.setPredicates(pat.getPredicates());
// pat.setPredicates(null);
// pat.setWhatToShow(DTMFilter.SHOW_ELEMENT);
// StepPattern rel = pat.getRelativePathPattern();
// pat.setRelativePathPattern(attrPat);
// attrPat.setRelativePathPattern(rel);
// attrPat.setStaticScore(score);
//
// // This is needed to inverse a following pattern, because of the
// // wacky Xalan rules for following from an attribute. See axes108.
// // By these rules, following from an attribute is not strictly
// // inverseable.
// if(Axis.PRECEDING == pat.getAxis())
// pat.setAxis(Axis.PRECEDINGANDANCESTOR);
//
// else if(Axis.DESCENDANT == pat.getAxis())
// pat.setAxis(Axis.DESCENDANTORSELF);
//
// pat = attrPat;
// }
// else if(Axis.CHILD == pat.getAxis())
// {
// // In this case just change the axis.
// // pat.setWhatToShow(whatToShow);
// pat.setAxis(Axis.ATTRIBUTE);
// }
// }
// axis = nextAxis;
// //paxis = nextPaxis;
// tail = pat;
// }
//
// if(axis < Axis.ALL)
// {
// StepPattern selfPattern = new ContextMatchStepPattern(axis, paxis);
// // We need to keep the new nodetest from affecting the score...
// XNumber score = tail.getStaticScore();
// tail.setRelativePathPattern(selfPattern);
// tail.setStaticScore(score);
// selfPattern.setStaticScore(score);
// }
//
// if (DEBUG_PATTERN_CREATION)
// {
// System.out.println("Done loading steps: "+step.toString());
//
// System.out.println("");
// }
// return step; // start from last pattern?? //firstStep;
// }
//
// /**
// * Create a StepPattern that is contained within a LocationPath.
// *
// *
// * @param compiler The compiler that holds the syntax tree/op map to
// * construct from.
// * @param stepOpCodePos The current op code position within the opmap.
// * @param mpi The MatchPatternIterator to which the steps will be attached.
// * @param analysis 32 bits of analysis, from which the type of AxesWalker
// * may be influenced.
// * @param tail The step that is the first step analyzed, but the last
// * step in the relative match linked list, i.e. the tail.
// * May be null.
// * @param head The step that is the current head of the relative
// * match step linked list.
// * May be null.
// *
// * @return the head of the list.
// *
// * @throws javax.xml.transform.TransformerException
// */
// private static StepPattern createDefaultStepPattern(
// Compiler compiler, int opPos, MatchPatternIterator mpi,
// int analysis, StepPattern tail, StepPattern head)
// throws javax.xml.transform.TransformerException
// {
//
// int stepType = compiler.getOp(opPos);
// boolean simpleInit = false;
// int totalNumberWalkers = (analysis & BITS_COUNT);
// boolean prevIsOneStepDown = true;
// int firstStepPos = compiler.getFirstChildPos(opPos);
//
// int whatToShow = compiler.getWhatToShow(opPos);
// StepPattern ai = null;
// int axis, predicateAxis;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// prevIsOneStepDown = false;
//
// Expression expr;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// expr = compiler.compile(opPos);
// break;
// default :
// expr = compiler.compile(opPos + 2);
// }
//
// axis = Axis.FILTEREDLIST;
// predicateAxis = Axis.FILTEREDLIST;
// ai = new FunctionPattern(expr, axis, predicateAxis);
// simpleInit = true;
// break;
// case OpCodes.FROM_ROOT :
// whatToShow = DTMFilter.SHOW_DOCUMENT
// | DTMFilter.SHOW_DOCUMENT_FRAGMENT;
//
// axis = Axis.ROOT;
// predicateAxis = Axis.ROOT;
// ai = new StepPattern(DTMFilter.SHOW_DOCUMENT |
// DTMFilter.SHOW_DOCUMENT_FRAGMENT,
// axis, predicateAxis);
// break;
// case OpCodes.FROM_ATTRIBUTES :
// whatToShow = DTMFilter.SHOW_ATTRIBUTE;
// axis = Axis.PARENT;
// predicateAxis = Axis.ATTRIBUTE;
// // ai = new StepPattern(whatToShow, Axis.SELF, Axis.SELF);
// break;
// case OpCodes.FROM_NAMESPACE :
// whatToShow = DTMFilter.SHOW_NAMESPACE;
// axis = Axis.PARENT;
// predicateAxis = Axis.NAMESPACE;
// // ai = new StepPattern(whatToShow, axis, predicateAxis);
// break;
// case OpCodes.FROM_ANCESTORS :
// axis = Axis.DESCENDANT;
// predicateAxis = Axis.ANCESTOR;
// break;
// case OpCodes.FROM_CHILDREN :
// axis = Axis.PARENT;
// predicateAxis = Axis.CHILD;
// break;
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// axis = Axis.DESCENDANTORSELF;
// predicateAxis = Axis.ANCESTORORSELF;
// break;
// case OpCodes.FROM_SELF :
// axis = Axis.SELF;
// predicateAxis = Axis.SELF;
// break;
// case OpCodes.FROM_PARENT :
// axis = Axis.CHILD;
// predicateAxis = Axis.PARENT;
// break;
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// axis = Axis.FOLLOWINGSIBLING;
// predicateAxis = Axis.PRECEDINGSIBLING;
// break;
// case OpCodes.FROM_PRECEDING :
// axis = Axis.FOLLOWING;
// predicateAxis = Axis.PRECEDING;
// break;
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// axis = Axis.PRECEDINGSIBLING;
// predicateAxis = Axis.FOLLOWINGSIBLING;
// break;
// case OpCodes.FROM_FOLLOWING :
// axis = Axis.PRECEDING;
// predicateAxis = Axis.FOLLOWING;
// break;
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
// axis = Axis.ANCESTORORSELF;
// predicateAxis = Axis.DESCENDANTORSELF;
// break;
// case OpCodes.FROM_DESCENDANTS :
// axis = Axis.ANCESTOR;
// predicateAxis = Axis.DESCENDANT;
// break;
// default :
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// //+ stepType);
// }
// if(null == ai)
// {
// whatToShow = compiler.getWhatToShow(opPos); // %REVIEW%
// ai = new StepPattern(whatToShow, compiler.getStepNS(opPos),
// compiler.getStepLocalName(opPos),
// axis, predicateAxis);
// }
//
// if (false || DEBUG_PATTERN_CREATION)
// {
// System.out.print("new step: "+ ai);
// System.out.print(", axis: " + Axis.names[ai.getAxis()]);
// System.out.print(", predAxis: " + Axis.names[ai.getAxis()]);
// System.out.print(", what: ");
// System.out.print(" ");
// ai.debugWhatToShow(ai.getWhatToShow());
// }
//
// int argLen = compiler.getFirstPredicateOpPos(opPos);
//
// ai.setPredicates(compiler.getCompiledPredicates(argLen));
//
// return ai;
// }
//
// /**
// * Analyze a step and give information about it's predicates. Right now this
// * just returns true or false if the step has a predicate.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param opPos The opcode position for the step.
// * @param stepType The type of step, one of OP_GROUP, etc.
// *
// * @return true if step has a predicate.
// *
// * @throws javax.xml.transform.TransformerException
// */
// static boolean analyzePredicate(Compiler compiler, int opPos, int stepType)
// throws javax.xml.transform.TransformerException
// {
//
// int argLen;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// argLen = compiler.getArgLength(opPos);
// break;
// default :
// argLen = compiler.getArgLengthOfStep(opPos);
// }
//
// int pos = compiler.getFirstPredicateOpPos(opPos);
// int nPredicates = compiler.countPredicates(pos);
//
// return (nPredicates > 0) ? true : false;
// }
//
// /**
// * Create the proper Walker from the axes type.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param opPos The opcode position for the step.
// * @param lpi The owning location path iterator.
// * @param analysis 32 bits of analysis, from which the type of AxesWalker
// * may be influenced.
// *
// * @return non-null reference to AxesWalker derivative.
// * @throws RuntimeException if the input is bad.
// */
// private static AxesWalker createDefaultWalker(Compiler compiler, int opPos,
// WalkingIterator lpi, int analysis)
// {
//
// AxesWalker ai = null;
// int stepType = compiler.getOp(opPos);
//
// /*
// System.out.println("0: "+compiler.getOp(opPos));
// System.out.println("1: "+compiler.getOp(opPos+1));
// System.out.println("2: "+compiler.getOp(opPos+2));
// System.out.println("3: "+compiler.getOp(opPos+3));
// System.out.println("4: "+compiler.getOp(opPos+4));
// System.out.println("5: "+compiler.getOp(opPos+5));
// */
// boolean simpleInit = false;
// int totalNumberWalkers = (analysis & BITS_COUNT);
// boolean prevIsOneStepDown = true;
//
// switch (stepType)
// {
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// prevIsOneStepDown = false;
//
// if (DEBUG_WALKER_CREATION)
// System.out.println("new walker: FilterExprWalker: " + analysis
// + ", " + compiler.toString());
//
// ai = new FilterExprWalker(lpi);
// simpleInit = true;
// break;
// case OpCodes.FROM_ROOT :
// ai = new AxesWalker(lpi, Axis.ROOT);
// break;
// case OpCodes.FROM_ANCESTORS :
// prevIsOneStepDown = false;
// ai = new ReverseAxesWalker(lpi, Axis.ANCESTOR);
// break;
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// prevIsOneStepDown = false;
// ai = new ReverseAxesWalker(lpi, Axis.ANCESTORORSELF);
// break;
// case OpCodes.FROM_ATTRIBUTES :
// ai = new AxesWalker(lpi, Axis.ATTRIBUTE);
// break;
// case OpCodes.FROM_NAMESPACE :
// ai = new AxesWalker(lpi, Axis.NAMESPACE);
// break;
// case OpCodes.FROM_CHILDREN :
// ai = new AxesWalker(lpi, Axis.CHILD);
// break;
// case OpCodes.FROM_DESCENDANTS :
// prevIsOneStepDown = false;
// ai = new AxesWalker(lpi, Axis.DESCENDANT);
// break;
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
// prevIsOneStepDown = false;
// ai = new AxesWalker(lpi, Axis.DESCENDANTORSELF);
// break;
// case OpCodes.FROM_FOLLOWING :
// prevIsOneStepDown = false;
// ai = new AxesWalker(lpi, Axis.FOLLOWING);
// break;
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// prevIsOneStepDown = false;
// ai = new AxesWalker(lpi, Axis.FOLLOWINGSIBLING);
// break;
// case OpCodes.FROM_PRECEDING :
// prevIsOneStepDown = false;
// ai = new ReverseAxesWalker(lpi, Axis.PRECEDING);
// break;
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// prevIsOneStepDown = false;
// ai = new ReverseAxesWalker(lpi, Axis.PRECEDINGSIBLING);
// break;
// case OpCodes.FROM_PARENT :
// prevIsOneStepDown = false;
// ai = new ReverseAxesWalker(lpi, Axis.PARENT);
// break;
// case OpCodes.FROM_SELF :
// ai = new AxesWalker(lpi, Axis.SELF);
// break;
// default :
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// //+ stepType);
// }
//
// if (simpleInit)
// {
// ai.initNodeTest(DTMFilter.SHOW_ALL);
// }
// else
// {
// int whatToShow = compiler.getWhatToShow(opPos);
//
// /*
// System.out.print("construct: ");
// NodeTest.debugWhatToShow(whatToShow);
// System.out.println("or stuff: "+(whatToShow & (DTMFilter.SHOW_ATTRIBUTE
// | DTMFilter.SHOW_ELEMENT
// | DTMFilter.SHOW_PROCESSING_INSTRUCTION)));
// */
// if ((0 == (whatToShow
// & (DTMFilter.SHOW_ATTRIBUTE | DTMFilter.SHOW_NAMESPACE | DTMFilter.SHOW_ELEMENT
// | DTMFilter.SHOW_PROCESSING_INSTRUCTION))) || (whatToShow == DTMFilter.SHOW_ALL))
// ai.initNodeTest(whatToShow);
// else
// {
// ai.initNodeTest(whatToShow, compiler.getStepNS(opPos),
// compiler.getStepLocalName(opPos));
// }
// }
//
// return ai;
// }
//
// public static String getAnalysisString(int analysis)
// {
// StringBuffer buf = new StringBuffer();
// buf.append("count: "+getStepCount(analysis)+" ");
// if((analysis & BIT_NODETEST_ANY) != 0)
// {
// buf.append("NTANY|");
// }
// if((analysis & BIT_PREDICATE) != 0)
// {
// buf.append("PRED|");
// }
// if((analysis & BIT_ANCESTOR) != 0)
// {
// buf.append("ANC|");
// }
// if((analysis & BIT_ANCESTOR_OR_SELF) != 0)
// {
// buf.append("ANCOS|");
// }
// if((analysis & BIT_ATTRIBUTE) != 0)
// {
// buf.append("ATTR|");
// }
// if((analysis & BIT_CHILD) != 0)
// {
// buf.append("CH|");
// }
// if((analysis & BIT_DESCENDANT) != 0)
// {
// buf.append("DESC|");
// }
// if((analysis & BIT_DESCENDANT_OR_SELF) != 0)
// {
// buf.append("DESCOS|");
// }
// if((analysis & BIT_FOLLOWING) != 0)
// {
// buf.append("FOL|");
// }
// if((analysis & BIT_FOLLOWING_SIBLING) != 0)
// {
// buf.append("FOLS|");
// }
// if((analysis & BIT_NAMESPACE) != 0)
// {
// buf.append("NS|");
// }
// if((analysis & BIT_PARENT) != 0)
// {
// buf.append("P|");
// }
// if((analysis & BIT_PRECEDING) != 0)
// {
// buf.append("PREC|");
// }
// if((analysis & BIT_PRECEDING_SIBLING) != 0)
// {
// buf.append("PRECS|");
// }
// if((analysis & BIT_SELF) != 0)
// {
// buf.append(".|");
// }
// if((analysis & BIT_FILTER) != 0)
// {
// buf.append("FLT|");
// }
// if((analysis & BIT_ROOT) != 0)
// {
// buf.append("R|");
// }
// return buf.toString();
// }
//
// /** Set to true for diagnostics about walker creation */
// static final boolean DEBUG_PATTERN_CREATION = false;
//
// /** Set to true for diagnostics about walker creation */
// static final boolean DEBUG_WALKER_CREATION = false;
//
// /** Set to true for diagnostics about iterator creation */
// static final boolean DEBUG_ITERATOR_CREATION = false;
//
// public static boolean hasPredicate(int analysis)
// {
// return (0 != (analysis & BIT_PREDICATE));
// }
//
// public static boolean isWild(int analysis)
// {
// return (0 != (analysis & BIT_NODETEST_ANY));
// }
//
// public static boolean walksAncestors(int analysis)
// {
// return isSet(analysis, BIT_ANCESTOR | BIT_ANCESTOR_OR_SELF);
// }
//
// public static boolean walksAttributes(int analysis)
// {
// return (0 != (analysis & BIT_ATTRIBUTE));
// }
//
// public static boolean walksNamespaces(int analysis)
// {
// return (0 != (analysis & BIT_NAMESPACE));
// }
//
// public static boolean walksChildren(int analysis)
// {
// return (0 != (analysis & BIT_CHILD));
// }
//
// public static boolean walksDescendants(int analysis)
// {
// return isSet(analysis, BIT_DESCENDANT | BIT_DESCENDANT_OR_SELF);
// }
//
// public static boolean walksSubtree(int analysis)
// {
// return isSet(analysis, BIT_DESCENDANT | BIT_DESCENDANT_OR_SELF | BIT_CHILD);
// }
//
// public static boolean walksSubtreeOnlyMaybeAbsolute(int analysis)
// {
// return walksSubtree(analysis)
// && !walksExtraNodes(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// ;
// }
//
// public static boolean walksSubtreeOnly(int analysis)
// {
// return walksSubtreeOnlyMaybeAbsolute(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
// public static boolean walksFilteredList(int analysis)
// {
// return isSet(analysis, BIT_FILTER);
// }
//
// public static boolean walksSubtreeOnlyFromRootOrContext(int analysis)
// {
// return walksSubtree(analysis)
// && !walksExtraNodes(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && !isSet(analysis, BIT_FILTER)
// ;
// }
//
// public static boolean walksInDocOrder(int analysis)
// {
// return (walksSubtreeOnlyMaybeAbsolute(analysis)
// || walksExtraNodesOnly(analysis)
// || walksFollowingOnlyMaybeAbsolute(analysis))
// && !isSet(analysis, BIT_FILTER)
// ;
// }
//
// public static boolean walksFollowingOnlyMaybeAbsolute(int analysis)
// {
// return isSet(analysis, BIT_SELF | BIT_FOLLOWING_SIBLING | BIT_FOLLOWING)
// && !walksSubtree(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// ;
// }
//
// public static boolean walksUp(int analysis)
// {
// return isSet(analysis, BIT_PARENT | BIT_ANCESTOR | BIT_ANCESTOR_OR_SELF);
// }
//
// public static boolean walksSideways(int analysis)
// {
// return isSet(analysis, BIT_FOLLOWING | BIT_FOLLOWING_SIBLING |
// BIT_PRECEDING | BIT_PRECEDING_SIBLING);
// }
//
// public static boolean walksExtraNodes(int analysis)
// {
// return isSet(analysis, BIT_NAMESPACE | BIT_ATTRIBUTE);
// }
//
// public static boolean walksExtraNodesOnly(int analysis)
// {
// return walksExtraNodes(analysis)
// && !isSet(analysis, BIT_SELF)
// && !walksSubtree(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
// public static boolean isAbsolute(int analysis)
// {
// return isSet(analysis, BIT_ROOT | BIT_FILTER);
// }
//
// public static boolean walksChildrenOnly(int analysis)
// {
// return walksChildren(analysis)
// && !isSet(analysis, BIT_SELF)
// && !walksExtraNodes(analysis)
// && !walksDescendants(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT))
// ;
// }
//
// public static boolean walksChildrenAndExtraAndSelfOnly(int analysis)
// {
// return walksChildren(analysis)
// && !walksDescendants(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT))
// ;
// }
//
// public static boolean walksDescendantsAndExtraAndSelfOnly(int analysis)
// {
// return !walksChildren(analysis)
// && walksDescendants(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && (!isAbsolute(analysis) || isSet(analysis, BIT_ROOT))
// ;
// }
//
// public static boolean walksSelfOnly(int analysis)
// {
// return isSet(analysis, BIT_SELF)
// && !walksSubtree(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
//
// public static boolean walksUpOnly(int analysis)
// {
// return !walksSubtree(analysis)
// && walksUp(analysis)
// && !walksSideways(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
// public static boolean walksDownOnly(int analysis)
// {
// return walksSubtree(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
// public static boolean walksDownExtraOnly(int analysis)
// {
// return walksSubtree(analysis) && walksExtraNodes(analysis)
// && !walksUp(analysis)
// && !walksSideways(analysis)
// && !isAbsolute(analysis)
// ;
// }
//
// public static boolean canSkipSubtrees(int analysis)
// {
// return isSet(analysis, BIT_CHILD) | walksSideways(analysis);
// }
//
// public static boolean canCrissCross(int analysis)
// {
// // This could be done faster. Coded for clarity.
// if(walksSelfOnly(analysis))
// return false;
// else if(walksDownOnly(analysis) && !canSkipSubtrees(analysis))
// return false;
// else if(walksChildrenAndExtraAndSelfOnly(analysis))
// return false;
// else if(walksDescendantsAndExtraAndSelfOnly(analysis))
// return false;
// else if(walksUpOnly(analysis))
// return false;
// else if(walksExtraNodesOnly(analysis))
// return false;
// else if(walksSubtree(analysis)
// && (walksSideways(analysis)
// || walksUp(analysis)
// || canSkipSubtrees(analysis)))
// return true;
// else
// return false;
// }
//
// /**
// * Tell if the pattern can be 'walked' with the iteration steps in natural
// * document order, without duplicates.
// *
// * @param analysis The general analysis of the pattern.
// *
// * @return true if the walk can be done in natural order.
// *
// * @throws javax.xml.transform.TransformerException
// */
// static public boolean isNaturalDocOrder(int analysis)
// {
// if(canCrissCross(analysis) || isSet(analysis, BIT_NAMESPACE) ||
// walksFilteredList(analysis))
// return false;
//
// if(walksInDocOrder(analysis))
// return true;
//
// return false;
// }
//
// /**
// * Tell if the pattern can be 'walked' with the iteration steps in natural
// * document order, without duplicates.
// *
// * @param compiler non-null reference to compiler object that has processed
// * the XPath operations into an opcode map.
// * @param stepOpCodePos The opcode position for the step.
// * @param stepIndex The top-level step index withing the iterator.
// * @param analysis The general analysis of the pattern.
// *
// * @return true if the walk can be done in natural order.
// *
// * @throws javax.xml.transform.TransformerException
// */
// private static boolean isNaturalDocOrder(
// Compiler compiler, int stepOpCodePos, int stepIndex, int analysis)
// throws javax.xml.transform.TransformerException
// {
// if(canCrissCross(analysis))
// return false;
//
// // Namespaces can present some problems, so just punt if we're looking for
// // these.
// if(isSet(analysis, BIT_NAMESPACE))
// return false;
//
// // The following, preceding, following-sibling, and preceding sibling can
// // be found in doc order if we get to this point, but if they occur
// // together, they produce
// // duplicates, so it's better for us to eliminate this case so we don't
// // have to check for duplicates during runtime if we're using a
// // WalkingIterator.
// if(isSet(analysis, BIT_FOLLOWING | BIT_FOLLOWING_SIBLING) &&
// isSet(analysis, BIT_PRECEDING | BIT_PRECEDING_SIBLING))
// return false;
//
// // OK, now we have to check for select="@*/axis::*" patterns, which
// // can also cause duplicates to happen. But select="axis*/@::*" patterns
// // are OK, as are select="@foo/axis::*" patterns.
// // Unfortunately, we can't do this just via the analysis bits.
//
// int stepType;
// int ops[] = compiler.getOpMap();
// int stepCount = 0;
// boolean foundWildAttribute = false;
//
// // Steps that can traverse anything other than down a
// // subtree or that can produce duplicates when used in
// // combonation are counted with this variable.
// int potentialDuplicateMakingStepCount = 0;
//
// while (OpCodes.ENDOP != (stepType = ops[stepOpCodePos]))
// {
// stepCount++;
//
// switch (stepType)
// {
// case OpCodes.FROM_ATTRIBUTES :
// case OpCodes.MATCH_ATTRIBUTE :
// if(foundWildAttribute) // Maybe not needed, but be safe.
// return false;
//
// // This doesn't seem to work as a test for wild card. Hmph.
// // int nodeTestType = compiler.getStepTestType(stepOpCodePos);
//
// String localName = compiler.getStepLocalName(stepOpCodePos);
// // System.err.println("localName: "+localName);
// if(localName.equals("*"))
// {
// foundWildAttribute = true;
// }
// break;
// case OpCodes.FROM_FOLLOWING :
// case OpCodes.FROM_FOLLOWING_SIBLINGS :
// case OpCodes.FROM_PRECEDING :
// case OpCodes.FROM_PRECEDING_SIBLINGS :
// case OpCodes.FROM_PARENT :
// case OpCodes.OP_VARIABLE :
// case OpCodes.OP_EXTFUNCTION :
// case OpCodes.OP_FUNCTION :
// case OpCodes.OP_GROUP :
// case OpCodes.FROM_NAMESPACE :
// case OpCodes.FROM_ANCESTORS :
// case OpCodes.FROM_ANCESTORS_OR_SELF :
// case OpCodes.MATCH_ANY_ANCESTOR :
// case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
// case OpCodes.FROM_DESCENDANTS_OR_SELF :
// case OpCodes.FROM_DESCENDANTS :
// if(potentialDuplicateMakingStepCount > 0)
// return false;
// potentialDuplicateMakingStepCount++;
// case OpCodes.FROM_ROOT :
// case OpCodes.FROM_CHILDREN :
// case OpCodes.FROM_SELF :
// if(foundWildAttribute)
// return false;
// break;
// default :
// throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[]{Integer.toString(stepType)})); //"Programmer's assertion: unknown opcode: "
// // + stepType);
// }
//
// int nextStepOpCodePos = compiler.getNextStepPos(stepOpCodePos);
//
// if (nextStepOpCodePos < 0)
// break;
//
// stepOpCodePos = nextStepOpCodePos;
// }
//
// return true;
// }
//
// public static boolean isOneStep(int analysis)
// {
// return (analysis & BITS_COUNT) == 0x00000001;
// }
//
// public static int getStepCount(int analysis)
// {
// return (analysis & BITS_COUNT);
// }
//
// /**
// * First 8 bits are the number of top-level location steps. Hopefully
// * there will never be more that 255 location steps!!!
// */
// public static final int BITS_COUNT = 0x000000FF;
//
// /** 4 bits are reserved for future use. */
// public static final int BITS_RESERVED = 0x00000F00;
//
// /** Bit is on if the expression contains a top-level predicate. */
// public static final int BIT_PREDICATE = (0x00001000);
//
// /** Bit is on if any of the walkers contain an ancestor step. */
// public static final int BIT_ANCESTOR = (0x00001000 << 1);
//
// /** Bit is on if any of the walkers contain an ancestor-or-self step. */
// public static final int BIT_ANCESTOR_OR_SELF = (0x00001000 << 2);
//
// /** Bit is on if any of the walkers contain an attribute step. */
// public static final int BIT_ATTRIBUTE = (0x00001000 << 3);
//
// /** Bit is on if any of the walkers contain a child step. */
// public static final int BIT_CHILD = (0x00001000 << 4);
//
// /** Bit is on if any of the walkers contain a descendant step. */
// public static final int BIT_DESCENDANT = (0x00001000 << 5);
//
// /** Bit is on if any of the walkers contain a descendant-or-self step. */
// public static final int BIT_DESCENDANT_OR_SELF = (0x00001000 << 6);
//
// /** Bit is on if any of the walkers contain a following step. */
// public static final int BIT_FOLLOWING = (0x00001000 << 7);
//
// /** Bit is on if any of the walkers contain a following-sibiling step. */
// public static final int BIT_FOLLOWING_SIBLING = (0x00001000 << 8);
//
// /** Bit is on if any of the walkers contain a namespace step. */
// public static final int BIT_NAMESPACE = (0x00001000 << 9);
//
// /** Bit is on if any of the walkers contain a parent step. */
// public static final int BIT_PARENT = (0x00001000 << 10);
//
// /** Bit is on if any of the walkers contain a preceding step. */
// public static final int BIT_PRECEDING = (0x00001000 << 11);
//
// /** Bit is on if any of the walkers contain a preceding-sibling step. */
// public static final int BIT_PRECEDING_SIBLING = (0x00001000 << 12);
//
// /** Bit is on if any of the walkers contain a self step. */
// public static final int BIT_SELF = (0x00001000 << 13);
//
// /**
// * Bit is on if any of the walkers contain a filter (i.e. id(), extension
// * function, etc.) step.
// */
// public static final int BIT_FILTER = (0x00001000 << 14);
//
// /** Bit is on if any of the walkers contain a root step. */
// public static final int BIT_ROOT = (0x00001000 << 15);
//
// /**
// * If any of these bits are on, the expression may likely traverse outside
// * the given subtree.
// */
// public static final int BITMASK_TRAVERSES_OUTSIDE_SUBTREE = (BIT_NAMESPACE // ??
// | BIT_PRECEDING_SIBLING
// | BIT_PRECEDING
// | BIT_FOLLOWING_SIBLING
// | BIT_FOLLOWING
// | BIT_PARENT // except parent of attrs.
// | BIT_ANCESTOR_OR_SELF
// | BIT_ANCESTOR
// | BIT_FILTER
// | BIT_ROOT);
//
// /**
// * Bit is on if any of the walkers can go backwards in document
// * order from the context node.
// */
// public static final int BIT_BACKWARDS_SELF = (0x00001000 << 16);
//
// /** Found "//foo" pattern */
// public static final int BIT_ANY_DESCENDANT_FROM_ROOT = (0x00001000 << 17);
//
// /**
// * Bit is on if any of the walkers contain an node() test. This is
// * really only useful if the count is 1.
// */
// public static final int BIT_NODETEST_ANY = (0x00001000 << 18);
//
// // can't go higher than 18!
//
// /** Bit is on if the expression is a match pattern. */
// public static final int BIT_MATCH_PATTERN = (0x00001000 << 19);
//}