Examples with VariableStack org.apache.xpath.VariableStack used on opensource projects

Example 1 with VariableStack

use of org.apache.xpath.VariableStack in project robovm by robovm.

the class ElemApplyTemplates method transformSelectedNodes.

/**
   * Perform a query if needed, and call transformNode for each child.
   *
   * @param transformer non-null reference to the the current transform-time state.
   *
   * @throws TransformerException Thrown in a variety of circumstances.
   * @xsl.usage advanced
   */
public void transformSelectedNodes(TransformerImpl transformer) throws TransformerException {
    final XPathContext xctxt = transformer.getXPathContext();
    final int sourceNode = xctxt.getCurrentNode();
    DTMIterator sourceNodes = m_selectExpression.asIterator(xctxt, sourceNode);
    VariableStack vars = xctxt.getVarStack();
    int nParams = getParamElemCount();
    int thisframe = vars.getStackFrame();
    boolean pushContextNodeListFlag = false;
    try {
        xctxt.pushCurrentNode(DTM.NULL);
        xctxt.pushCurrentExpressionNode(DTM.NULL);
        xctxt.pushSAXLocatorNull();
        transformer.pushElemTemplateElement(null);
        final Vector keys = (m_sortElems == null) ? null : transformer.processSortKeys(this, sourceNode);
        // Sort if we need to.
        if (null != keys)
            sourceNodes = sortNodes(xctxt, keys, sourceNodes);
        final SerializationHandler rth = transformer.getSerializationHandler();
        //      ContentHandler chandler = rth.getContentHandler();
        final StylesheetRoot sroot = transformer.getStylesheet();
        final TemplateList tl = sroot.getTemplateListComposed();
        final boolean quiet = transformer.getQuietConflictWarnings();
        // Should be able to get this from the iterator but there must be a bug.
        DTM dtm = xctxt.getDTM(sourceNode);
        int argsFrame = -1;
        if (nParams > 0) {
            // This code will create a section on the stack that is all the 
            // evaluated arguments.  These will be copied into the real params 
            // section of each called template.
            argsFrame = vars.link(nParams);
            vars.setStackFrame(thisframe);
            for (int i = 0; i < nParams; i++) {
                ElemWithParam ewp = m_paramElems[i];
                XObject obj = ewp.getValue(transformer, sourceNode);
                vars.setLocalVariable(i, obj, argsFrame);
            }
            vars.setStackFrame(argsFrame);
        }
        xctxt.pushContextNodeList(sourceNodes);
        pushContextNodeListFlag = true;
        IntStack currentNodes = xctxt.getCurrentNodeStack();
        IntStack currentExpressionNodes = xctxt.getCurrentExpressionNodeStack();
        // pushParams(transformer, xctxt);
        int child;
        while (DTM.NULL != (child = sourceNodes.nextNode())) {
            currentNodes.setTop(child);
            currentExpressionNodes.setTop(child);
            if (xctxt.getDTM(child) != dtm) {
                dtm = xctxt.getDTM(child);
            }
            final int exNodeType = dtm.getExpandedTypeID(child);
            final int nodeType = dtm.getNodeType(child);
            final QName mode = transformer.getMode();
            ElemTemplate template = tl.getTemplateFast(xctxt, child, exNodeType, mode, -1, quiet, dtm);
            // See http://www.w3.org/TR/xslt#built-in-rule.
            if (null == template) {
                switch(nodeType) {
                    case DTM.DOCUMENT_FRAGMENT_NODE:
                    case DTM.ELEMENT_NODE:
                        template = sroot.getDefaultRule();
                        // %OPT% direct faster?
                        break;
                    case DTM.ATTRIBUTE_NODE:
                    case DTM.CDATA_SECTION_NODE:
                    case DTM.TEXT_NODE:
                        // if(rth.m_elemIsPending || rth.m_docPending)
                        //  rth.flushPending(true);
                        transformer.pushPairCurrentMatched(sroot.getDefaultTextRule(), child);
                        transformer.setCurrentElement(sroot.getDefaultTextRule());
                        // dtm.dispatchCharactersEvents(child, chandler, false);
                        dtm.dispatchCharactersEvents(child, rth, false);
                        transformer.popCurrentMatched();
                        continue;
                    case DTM.DOCUMENT_NODE:
                        template = sroot.getDefaultRootRule();
                        break;
                    default:
                        // No default rules for processing instructions and the like.
                        continue;
                }
            } else {
                transformer.setCurrentElement(template);
            }
            transformer.pushPairCurrentMatched(template, child);
            // See comment with unlink, below
            int currentFrameBottom;
            if (template.m_frameSize > 0) {
                xctxt.pushRTFContext();
                // See comment with unlink, below
                currentFrameBottom = vars.getStackFrame();
                vars.link(template.m_frameSize);
                // xsl:params might not be nulled.
                if (/* nParams > 0 && */
                template.m_inArgsSize > 0) {
                    int paramIndex = 0;
                    for (ElemTemplateElement elem = template.getFirstChildElem(); null != elem; elem = elem.getNextSiblingElem()) {
                        if (Constants.ELEMNAME_PARAMVARIABLE == elem.getXSLToken()) {
                            ElemParam ep = (ElemParam) elem;
                            int i;
                            for (i = 0; i < nParams; i++) {
                                ElemWithParam ewp = m_paramElems[i];
                                if (ewp.m_qnameID == ep.m_qnameID) {
                                    XObject obj = vars.getLocalVariable(i, argsFrame);
                                    vars.setLocalVariable(paramIndex, obj);
                                    break;
                                }
                            }
                            if (i == nParams)
                                vars.setLocalVariable(paramIndex, null);
                        } else
                            break;
                        paramIndex++;
                    }
                }
            } else
                currentFrameBottom = 0;
            // each of them.
            for (ElemTemplateElement t = template.m_firstChild; t != null; t = t.m_nextSibling) {
                xctxt.setSAXLocator(t);
                try {
                    transformer.pushElemTemplateElement(t);
                    t.execute(transformer);
                } finally {
                    transformer.popElemTemplateElement();
                }
            }
            if (template.m_frameSize > 0) {
                // See Frank Weiss bug around 03/19/2002 (no Bugzilla report yet).
                // While unlink will restore to the proper place, the real position 
                // may have been changed for xsl:with-param, so that variables 
                // can be accessed.  
                // of right now.
                // More:
                // When we entered this function, the current 
                // frame buffer (cfb) index in the variable stack may 
                // have been manually set.  If we just call 
                // unlink(), however, it will restore the cfb to the 
                // previous link index from the link stack, rather than 
                // the manually set cfb.  So, 
                // the only safe solution is to restore it back 
                // to the same position it was on entry, since we're 
                // really not working in a stack context here. (Bug4218)
                vars.unlink(currentFrameBottom);
                xctxt.popRTFContext();
            }
            transformer.popCurrentMatched();
        }
    // end while (DTM.NULL != (child = sourceNodes.nextNode()))
    } catch (SAXException se) {
        transformer.getErrorListener().fatalError(new TransformerException(se));
    } finally {
        // Unlink to the original stack frame
        if (nParams > 0)
            vars.unlink(thisframe);
        xctxt.popSAXLocator();
        if (pushContextNodeListFlag)
            xctxt.popContextNodeList();
        transformer.popElemTemplateElement();
        xctxt.popCurrentExpressionNode();
        xctxt.popCurrentNode();
        sourceNodes.detach();
    }
}

Example 2 with VariableStack

use of org.apache.xpath.VariableStack in project robovm by robovm.

the class ElemParam method execute.

/**
   * Execute a variable declaration and push it onto the variable stack.
   * @see <a href="http://www.w3.org/TR/xslt#variables">variables in XSLT Specification</a>
   *
   * @param transformer non-null reference to the the current transform-time state.
   *
   * @throws TransformerException
   */
public void execute(TransformerImpl transformer) throws TransformerException {
    VariableStack vars = transformer.getXPathContext().getVarStack();
    if (!vars.isLocalSet(m_index)) {
        int sourceNode = transformer.getXPathContext().getCurrentNode();
        XObject var = getValue(transformer, sourceNode);
        // transformer.getXPathContext().getVarStack().pushVariable(m_qname, var);
        transformer.getXPathContext().getVarStack().setLocalVariable(m_index, var);
    }
}

Example 3 with VariableStack

use of org.apache.xpath.VariableStack in project robovm by robovm.

the class ElemExsltFunction method execute.

public void execute(TransformerImpl transformer, XObject[] args) throws TransformerException {
    XPathContext xctxt = transformer.getXPathContext();
    VariableStack vars = xctxt.getVarStack();
    // Increment the frame bottom of the variable stack by the
    // frame size
    int thisFrame = vars.getStackFrame();
    int nextFrame = vars.link(m_frameSize);
    if (m_inArgsSize < args.length) {
        throw new TransformerException("function called with too many args");
    }
    // have to clear the section of the stack frame that has params.
    if (m_inArgsSize > 0) {
        vars.clearLocalSlots(0, m_inArgsSize);
        if (args.length > 0) {
            vars.setStackFrame(thisFrame);
            NodeList children = this.getChildNodes();
            for (int i = 0; i < args.length; i++) {
                Node child = children.item(i);
                if (children.item(i) instanceof ElemParam) {
                    ElemParam param = (ElemParam) children.item(i);
                    vars.setLocalVariable(param.getIndex(), args[i], nextFrame);
                }
            }
            vars.setStackFrame(nextFrame);
        }
    }
    //  Removed ElemTemplate 'push' and 'pop' of RTFContext, in order to avoid losing the RTF context 
    //  before a value can be returned. ElemExsltFunction operates in the scope of the template that called 
    //  the function.
    //  xctxt.pushRTFContext();
    vars.setStackFrame(nextFrame);
    transformer.executeChildTemplates(this, true);
    // Reset the stack frame after the function call
    vars.unlink(thisFrame);
// Following ElemTemplate 'pop' removed -- see above.
// xctxt.popRTFContext(); 
}

Example 4 with VariableStack

use of org.apache.xpath.VariableStack in project robovm by robovm.

the class TransformerImpl method clearParameters.

/**
   * Reset the parameters to a null list.
   */
public void clearParameters() {
    synchronized (m_reentryGuard) {
        VariableStack varstack = new VariableStack();
        m_xcontext.setVarStack(varstack);
        m_userParams = null;
    }
}

Example 5 with VariableStack

use of org.apache.xpath.VariableStack in project robovm by robovm.

the class TransformerImpl method pushGlobalVars.

/**
   * Internal -- push the global variables from the Stylesheet onto
   * the context's runtime variable stack.
   * <p>If we encounter a variable
   * that is already defined in the variable stack, we ignore it.  This
   * is because the second variable definition will be at a lower import
   * precedence.  Presumably, global"variables at the same import precedence
   * with the same name will have been caught during the recompose process.
   * <p>However, if we encounter a parameter that is already defined in the
   * variable stack, we need to see if this is a parameter whose value was
   * supplied by a setParameter call.  If so, we need to "receive" the one
   * already in the stack, ignoring this one.  If it is just an earlier
   * xsl:param or xsl:variable definition, we ignore it using the same
   * reasoning as explained above for the variable.
   *
   * @param contextNode The root of the source tree, can't be null.
   *
   * @throws TransformerException
   */
protected void pushGlobalVars(int contextNode) throws TransformerException {
    XPathContext xctxt = m_xcontext;
    VariableStack vs = xctxt.getVarStack();
    StylesheetRoot sr = getStylesheet();
    Vector vars = sr.getVariablesAndParamsComposed();
    int i = vars.size();
    vs.link(i);
    while (--i >= 0) {
        ElemVariable v = (ElemVariable) vars.elementAt(i);
        // XObject xobj = v.getValue(this, contextNode);
        XObject xobj = new XUnresolvedVariable(v, contextNode, this, vs.getStackFrame(), 0, true);
        if (null == vs.elementAt(i))
            vs.setGlobalVariable(i, xobj);
    }
}