com.sun.org.apache.xpath.internal.patterns.StepPattern

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
/**
   * 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
/**
   * 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
/**
   * 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;
}