This approach works guaranteed cross-processor because the order of execution
is defined here: the processor *must* call the accumulator-after only after
all the processing is done (as a by-product, this means that
accumulator-after can only be called in post-descent instructions, meaning,
*after* all children are processed, which in this case is the following
sibling of xsl:appy-templates).
I don't think that's completely true. For example, consider a processor where
the parsing and transformation are done in separate threads, and accumulators
are evaluated in the parsing thread. And suppose that the user has control over
how much memory is allocated to the buffer shared between the two. So the
parsing thread can get ahead of the transformation thread by an arbitrary
amount; which means that the final time can be computed long before the
transformation is finished.
I don't know a processor that works that way, but it would be a conformant
implementation.
Michael Kay
Saxonica
--~----------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
EasyUnsubscribe: http://lists.mulberrytech.com/unsub/xsl-list/1167547
or by email: xsl-list-unsub(_at_)lists(_dot_)mulberrytech(_dot_)com
--~--