/** * Get a raw iterator over the results of the expression. This returns results without * any conversion of the returned items to "native" Java classes. This method is intended * for use by applications that need to process the results of the expression using * internal Saxon interfaces. * @param contextItem the context item for evaluating the expression * @return an iterator over the results of the expression, with no conversion of returned items * @since 9.0 */ public SequenceIterator rawIterator(Item contextItem) throws XPathException { XPathContextMajor context = new XPathContextMajor(contextItem, executable); context.openStackFrame(stackFrameMap); return rawIterator(context); }
/** * Construct a new context as a copy of another. The new context is effectively added * to the top of a stack, and contains a pointer to the previous context */ public XPathContextMajor newContext() { return XPathContextMajor.newContext(this); }
/** * Construct a new minor context. A minor context can only hold new values of the focus * (currentIterator) and current output destination. */ public XPathContextMinor newMinorContext() { return newContext().newMinorContext(); // notAllowed(); // return null; }
/** * Make an XPathContext object for expression evaluation. * <p>This method is intended for internal use.</p> * * @return the new XPathContext */ public XPathContextMajor newXPathContext() { XPathContextMajor c = new XPathContextMajor(this); c.setCurrentOutputUri(principalResultURI); return c; }
/** * Construct a new context without copying (used for the context in a function call) */ public XPathContextMajor newCleanContext() { XPathContextMajor c = new XPathContextMajor(getController()); c.setCaller(this); return c; }
public TailCall processLeavingTail(XPathContext context) throws XPathException { XPathContextMajor cm = (XPathContextMajor)context; ParameterSet params = assembleParams(context, actualParams); cm.setLocalParameters(params); cm.requestTailCall(continueFunction, emptyArgs); return null; }
initialContext.createThreadManager(); initialContext.setOrigin(this); initialContext.setReceiver(out); initialContext.setCurrentIterator(new ManualIterator<>(globalContextItem)); XPathContextMajor c2 = initialContext.newContext(); initialContext.setOrigin(this); c2.setCurrentComponent(initialComponent); c2.openStackFrame(t.getStackFrameMap()); c2.setLocalParameters(ordinaryParams); c2.setTunnelParameters(tunnelParams); initialContext.waitForChildThreads(); out.close();
initialContext.setOrigin(this); currentIter.next(); initialContext.setCurrentIterator(currentIter); props.setProperty(SaxonOutputKeys.IMPLICIT_RESULT_DOCUMENT, "yes"); initialContext.changeOutputDestination(props, result, true, Configuration.XSLT, Validation.PRESERVE, null); initialContext.getCurrentIterator(), mode, null, null, initialContext, false, 0); XPathContextMajor c2 = initialContext.newContext(); c2.setOrigin(this); c2.openStackFrame(t.getStackFrameMap()); c2.setLocalParameters(new ParameterSet()); c2.setTunnelParameters(new ParameterSet()); Receiver out = initialContext.getReceiver(); if (out instanceof ComplexContentOutputter && ((ComplexContentOutputter)out).contentHasBeenWritten()) { if (principalResultURI != null) {
/** * Evaluate in a general context */ public Item evaluateItem(XPathContext c) throws XPathException { if (operation == EXPRESSION) { PreparedExpression pexpr = prepareExpression(c); return new ObjectValue(pexpr); } else if (operation == EVALUATE_NODE) { XPathContextMajor c2 = c.newCleanContext(); PreparedExpression pexpr = prepareExpression(c2); c2.setOrigin(details); c2.openStackFrame(pexpr.stackFrameMap); return pexpr.expression.evaluateItem(c2); } else { XPathContextMajor c2 = c.newCleanContext(); PreparedExpression pexpr = prepareExpression(c2); for (int i=1; i<argument.length; i++) { int slot = pexpr.variables[i-1].getLocalSlotNumber(); c2.setLocalVariable(slot, ExpressionTool.eagerEvaluate(argument[i],c)); } c2.setOrigin(details); c2.openStackFrame(pexpr.stackFrameMap); c2.setCurrentIterator(c.getCurrentIterator()); return pexpr.expression.evaluateItem(c2); } }
/** * Call the function dynamically. For this to be possible, the static arguments of the function call * must have been set up as SuppliedParameterReference objects. The actual arguments are placed on the * callee's stack, and the type conversion takes place "in situ". * @param suppliedArguments the values to be used for the arguments of the function * @param context the dynamic evaluation context * @return the result of evaluating the function */ public ValueRepresentation dynamicCall(ValueRepresentation[] suppliedArguments, XPathContext context) throws XPathException { ValueRepresentation[] convertedArgs = new ValueRepresentation[suppliedArguments.length]; XPathContextMajor c2 = context.newCleanContext(); c2.setOrigin(this); c2.setCaller(context); c2.openStackFrame(suppliedArguments.length); for (int i=0; i<suppliedArguments.length; i++) { c2.setLocalVariable(i, suppliedArguments[i]); convertedArgs[i] = ExpressionTool.lazyEvaluate(argument[i], c2, 10); } XPathContextMajor c3 = c2.newCleanContext(); c3.setOrigin(this); return function.call(convertedArgs, c3); }
/** * Apply an accumulator rule * * @param rule the rule to apply * @param node the node that was matched * @param isPostDescent false for the pre-descent visit to a node, true for the post-descent visit * @param value the value of the accumulator before applying the rule * @param context the dynamic evaluation context * @return the value of the accumulator after applying the rule * @throws XPathException if a dynamic error occurs during the evaluation */ private Sequence<?> processRule(Rule rule, NodeInfo node, boolean isPostDescent, Sequence<?> value, XPathContext context) throws XPathException { AccumulatorRule target = (AccumulatorRule) rule.getAction(); Expression delta = target.getNewValueExpression(); XPathContextMajor c2 = context.newCleanContext(); final Controller controller = c2.getController(); assert controller != null; ManualIterator<NodeInfo> initialNode = new ManualIterator<>(node); c2.setCurrentIterator(initialNode); c2.openStackFrame(target.getStackFrameMap()); c2.setLocalVariable(0, value); c2.setCurrentComponent(accumulator.getDeclaringComponent()); c2.setTemporaryOutputState(StandardNames.XSL_ACCUMULATOR_RULE); value = Evaluator.EAGER_SEQUENCE.evaluate(delta, c2); //System.err.println("Node " + ((TinyNodeImpl) node).getNodeNumber() + " : " + value); values.add(new DataPoint(new Visit(node, isPostDescent), value)); return value; }
/** * Process the function call in push mode * @param context the XPath dynamic context * @throws XPathException */ public void process(XPathContext context) throws XPathException { ValueRepresentation[] actualArgs = evaluateArguments(context); if (tailCall) { ((XPathContextMajor)context).requestTailCall(function, actualArgs); } else { SequenceReceiver out = context.getReceiver(); XPathContextMajor c2 = context.newCleanContext(); c2.setReceiver(out); c2.setOrigin(this); function.process(actualArgs, c2); } }
/** * Process the template call encapsulated by this package. * * @return another TailCall. This will never be the original call, but it may be the next * recursive call. For example, if A calls B which calls C which calls D, then B may return * a TailCall to A representing the call from B to C; when this is processed, the result may be * a TailCall representing the call from C to D. * @throws XPathException if a dynamic error occurs */ public TailCall processLeavingTail() throws XPathException { TemplateRule nh = (TemplateRule) rule.getAction(); nh.initialize(); XPathContextMajor c2 = evaluationContext.newContext(); c2.setOrigin(NextMatch.this); //c2.setOriginatingConstructType(LocationKind.TEMPLATE); c2.setLocalParameters(params); c2.setTunnelParameters(tunnelParams); c2.openStackFrame(nh.getStackFrameMap()); c2.setCurrentTemplateRule(rule); c2.setCurrentComponent(evaluationContext.getCurrentComponent()); // System.err.println("Tail call on template"); return nh.applyLeavingTail(c2); } }
/** * Return an Iterator to iterate over the values of a sequence. The value of every * expression can be regarded as a sequence, so this method is supported for all * expressions. This default implementation relies on the process() method: it * "pushes" the results of the instruction to a sequence in memory, and then * iterates over this in-memory sequence. * <p>In principle instructions should implement a pipelined iterate() method that * avoids the overhead of intermediate storage.</p> * * @param context supplies the context for evaluation * @return a SequenceIterator that can be used to iterate over the result * of the expression * @throws XPathException if any dynamic error occurs evaluating the * expression */ /*@NotNull*/ public SequenceIterator<?> iterate(XPathContext context) throws XPathException { GroupIterator master = getGroupIterator(context); XPathContextMajor c2 = context.newContext(); c2.setOrigin(this); c2.trackFocus(master); c2.setCurrentGroupIterator(master); c2.setCurrentTemplateRule(null); return new ContextMappingIterator<>(this, c2); }
/** * Evaluate the variable. That is, * get the value of the select expression if present or the content * of the element otherwise, either as a tree or as a sequence */ public ValueRepresentation getSelectValue(XPathContext context) throws XPathException { if (select==null) { throw new AssertionError("*** No select expression for global variable $" + getVariableQName().getDisplayName() + "!!"); } else { XPathContextMajor c2 = context.newCleanContext(); c2.setOrigin(this); UnfailingIterator initialNode = SingletonIterator.makeIterator(c2.getController().getContextForGlobalVariables()); initialNode.next(); c2.setCurrentIterator(initialNode); if (stackFrameMap != null) { c2.openStackFrame(stackFrameMap); } return ExpressionTool.evaluate(select, evaluationMode, c2, referenceCount); } }
/** * Return an Iterator to iterate over the values of a sequence. The value of every * expression can be regarded as a sequence, so this method is supported for all * expressions. This default implementation relies on the process() method: it * "pushes" the results of the instruction to a sequence in memory, and then * iterates over this in-memory sequence. * <p/> * In principle instructions should implement a pipelined iterate() method that * avoids the overhead of intermediate storage. * * @param context supplies the context for evaluation * @return a SequenceIterator that can be used to iterate over the result * of the expression * @throws XPathException if any dynamic error occurs evaluating the * expression */ public SequenceIterator iterate(XPathContext context) throws XPathException { GroupIterator master = getGroupIterator(context); XPathContextMajor c2 = context.newContext(); c2.setOrigin(this); c2.setCurrentIterator(master); c2.setCurrentGroupIterator(master); c2.setCurrentTemplateRule(null); return new ContextMappingIterator(this, c2); }
/** * Return an Iterator to iterate over the values of the sequence. * * @exception XPathException if any dynamic error occurs evaluating the * expression * @param context supplies the context for evaluation * @return a SequenceIterator that can be used to iterate over the result * of the expression */ public SequenceIterator iterate(XPathContext context) throws XPathException { SequenceIterator master = select.iterate(context); XPathContextMajor c2 = context.newContext(); c2.setOrigin(this); c2.setCurrentTemplateRule(null); c2.setCurrentIterator(master); master = new ContextMappingIterator(this, c2); return master; }
public TailCall processLeavingTail(XPathContext context) throws XPathException { XPathContext c = context; while (!(c instanceof XPathContextMajor)) { c = c.getCaller(); } XPathContextMajor cm = (XPathContextMajor)c; if (actualParams.length == 1) { cm.setLocalVariable(actualParams[0].getSlotNumber(), actualParams[0].getSelectValue(context)); } else { // we can't overwrite any of the parameters until we've evaluated all of them: test iterate012 Sequence[] oldVars = cm.getAllVariableValues(); Sequence[] newVars = Arrays.copyOf(oldVars, oldVars.length); for (WithParam wp : actualParams) { newVars[wp.getSlotNumber()] = wp.getSelectValue(context); } cm.resetAllVariableValues(newVars); } cm.requestTailCall(this, null); return null; }
/** * Make a new XPath context for evaluating patterns if there is any possibility that the * pattern uses local variables * * @param context The existing XPath context * @return a new XPath context */ public XPathContext makeNewContext(XPathContext context) { XPathContextMajor c2 = context.newContext(); c2.setOrigin(context.getController()); // WHY? c2.openStackFrame(getStackFrameSlotsNeeded()); if (!(context.getCurrentComponent().getActor() instanceof Accumulator)) { c2.setCurrentComponent(context.getCurrentMode()); // bug 3706 } return c2; }
/** * Set the context item for evaluation of the XPath Expression * @param item the context item * @throws XPathException if the node is in a document that was built under the wrong configuration */ public void setContextItem(Item item) throws XPathException { if (item instanceof NodeInfo) { if (!((NodeInfo)item).getConfiguration().isCompatible(contextObject.getConfiguration())) { throw new XPathException( "Supplied node must be built using the same or a compatible Configuration", SaxonErrorCode.SXXP0004); } } UnfailingIterator iter = SingletonIterator.makeIterator(item); iter.next(); contextObject.setCurrentIterator(iter); }