Here are the examples of the java api class com.sun.org.apache.xpath.internal.patterns.StepPattern taken from open source projects.
1. WalkerFactory#loadSteps()
Project: openjdk
File: WalkerFactory.java
File: WalkerFactory.java
/** * 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 analysis = analyze(compiler, stepOpCodePos, stepIndex); while (OpCodes.ENDOP != (stepType = compiler.getOp(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, // don't care about the predicate axis 0); 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); // 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(""); } // start from last pattern?? //firstStep; return step; }
2. Compiler#stepPattern()
Project: openjdk
File: Compiler.java
File: Compiler.java
/** * Compile a step pattern unit expression, used for both location paths * and match patterns. * * @param opPos The current position in the m_opMap array. * @param stepCount The number of steps to expect. * @param ancestorPattern The owning StepPattern, which may be null. * * @return reference to {@link com.sun.org.apache.xpath.internal.patterns.StepPattern} instance. * * @throws TransformerException if a error occurs creating the Expression. */ protected StepPattern stepPattern(int opPos, int stepCount, StepPattern ancestorPattern) throws TransformerException { int startOpPos = opPos; int stepType = getOp(opPos); if (OpCodes.ENDOP == stepType) { return null; } boolean addMagicSelf = true; int endStep = getNextOpPos(opPos); // int nextStepType = getOpMap()[endStep]; StepPattern pattern; // boolean isSimple = ((OpCodes.ENDOP == nextStepType) && (stepCount == 0)); int argLen; switch(stepType) { case OpCodes.OP_FUNCTION: if (DEBUG) System.out.println("MATCH_FUNCTION: " + m_currentPattern); addMagicSelf = false; argLen = getOp(opPos + OpMap.MAPINDEX_LENGTH); pattern = new FunctionPattern(compileFunction(opPos), Axis.PARENT, Axis.CHILD); break; case OpCodes.FROM_ROOT: if (DEBUG) System.out.println("FROM_ROOT, " + m_currentPattern); addMagicSelf = false; argLen = getArgLengthOfStep(opPos); opPos = getFirstChildPosOfStep(opPos); pattern = new StepPattern(DTMFilter.SHOW_DOCUMENT | DTMFilter.SHOW_DOCUMENT_FRAGMENT, Axis.PARENT, Axis.CHILD); break; case OpCodes.MATCH_ATTRIBUTE: if (DEBUG) System.out.println("MATCH_ATTRIBUTE: " + getStepLocalName(startOpPos) + ", " + m_currentPattern); argLen = getArgLengthOfStep(opPos); opPos = getFirstChildPosOfStep(opPos); pattern = new StepPattern(DTMFilter.SHOW_ATTRIBUTE, getStepNS(startOpPos), getStepLocalName(startOpPos), Axis.PARENT, Axis.ATTRIBUTE); break; case OpCodes.MATCH_ANY_ANCESTOR: if (DEBUG) System.out.println("MATCH_ANY_ANCESTOR: " + getStepLocalName(startOpPos) + ", " + m_currentPattern); argLen = getArgLengthOfStep(opPos); opPos = getFirstChildPosOfStep(opPos); int what = getWhatToShow(startOpPos); // bit-o-hackery, but this code is due for the morgue anyway... if (0x00000500 == what) addMagicSelf = false; pattern = new StepPattern(getWhatToShow(startOpPos), getStepNS(startOpPos), getStepLocalName(startOpPos), Axis.ANCESTOR, Axis.CHILD); break; case OpCodes.MATCH_IMMEDIATE_ANCESTOR: if (DEBUG) System.out.println("MATCH_IMMEDIATE_ANCESTOR: " + getStepLocalName(startOpPos) + ", " + m_currentPattern); argLen = getArgLengthOfStep(opPos); opPos = getFirstChildPosOfStep(opPos); pattern = new StepPattern(getWhatToShow(startOpPos), getStepNS(startOpPos), getStepLocalName(startOpPos), Axis.PARENT, Axis.CHILD); break; default: //"unknown match operation!"); error(XPATHErrorResources.ER_UNKNOWN_MATCH_OPERATION, null); return null; } pattern.setPredicates(getCompiledPredicates(opPos + argLen)); if (null == ancestorPattern) { // This is the magic and invisible "." at the head of every // match pattern, and corresponds to the current node in the context // list, from where predicates are counted. // So, in order to calculate "foo[3]", it has to count from the // current node in the context list, so, from that current node, // the full pattern is really "self::node()/child::foo[3]". If you // translate this to a select pattern from the node being tested, // which is really how we're treating match patterns, it works out to // self::foo/parent::node[child::foo[3]]", or close enough. /* if(addMagicSelf && pattern.getPredicateCount() > 0) { StepPattern selfPattern = new StepPattern(DTMFilter.SHOW_ALL, Axis.PARENT, Axis.CHILD); // We need to keep the new nodetest from affecting the score... XNumber score = pattern.getStaticScore(); pattern.setRelativePathPattern(selfPattern); pattern.setStaticScore(score); selfPattern.setStaticScore(score); }*/ } else { // System.out.println("Setting "+ancestorPattern+" as relative to "+pattern); pattern.setRelativePathPattern(ancestorPattern); } StepPattern relativePathPattern = stepPattern(endStep, stepCount + 1, pattern); return (null != relativePathPattern) ? relativePathPattern : pattern; }
3. WalkerFactory#createDefaultStepPattern()
Project: openjdk
File: WalkerFactory.java
File: WalkerFactory.java
/** * 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; boolean prevIsOneStepDown = true; 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: //"Programmer's assertion: unknown opcode: " throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NULL_ERROR_HANDLER, new Object[] { Integer.toString(stepType) })); } if (null == ai) { // %REVIEW% whatToShow = compiler.getWhatToShow(opPos); 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.getNames(ai.getAxis())); System.out.print(", predAxis: " + Axis.getNames(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; }