Get text between 2 processing instructions - xslt

Question

My goal is to get all text, including text inside elements, between 2 processing instructions using xslt.
Input file is DITA having standard XML-based structure. There are 2 processing instructions I am searching for <?PI start?> and <?PI end?>. I search for text after <?PI start?> and before <?PI end?>. There can be just text or an element that has text in it.
Input
<concept id="testcase" >
<title> Introduction</title>
<conbody>
<p>
<p>text01</p>
<?PI start 1?> text02 <?PI end 1?>
<b> text03 </b>
<?PI start 2?> text04 text05 <?PI end 2?> text06
<?PI start 3?> text07 <?PI end 3?>
</p>
<p>
<?PI start 4?>text11 <?PI end 4?>
<?PI start 5?><b>text12</b><?PI end 5?>
<?PI start 6?> text13<?PI end 6?>
</p>
</conbody>
</concept>
My approaches were:
match <?PI start?>, and try to get following-sibling until I will get to the <?PI end?>. Problem is there is no break for a loop in xslt as well as there is no way to change the value of variable, so I don't know how to stop.
xsl
<xsl:template match="//processing-instruction('PI')[contains(.,'start')]">
<xsl:variable name='text1' select="following-sibling::text()[preceding::processing-instruction('PI')[1][contains(.,'start')]][following::processing-instruction('PI')[1][contains(., 'end ')]] "/>
<xsl:variable name='text2' select="following-sibling::*[preceding::processing-instruction('PI')[1][contains(.,'start')]][following::processing-instruction('PI')[1][contains(., 'end')]]/text() "/>
<xsl:variable name="text" select="concat($text1,$text2)"/>
<xsl:value-of select="$text"/>
<xsl:copy>
<xsl:apply-templates select="#* | node()" />
</xsl:copy>
</xsl:template>
output
<concept xmlns:ditaarch="http://dita.oasis-open.org/architecture/2005/" id="testcase">
<title> Introduction</title>
<conbody>
<p>
<p>text01</p>
text02 <?PI start 1?> text02 <?PI end 1?>
<b> text03 </b>
text04 text05 <?PI start 2?> text04 text05 <?PI end 2?> text06
text07 <?PI start 3?> text07 <?PI end 3?>
</p>
<p>
text11 text12<?PI start 4?>text11 <?PI end 4?>
text13text12<?PI start 5?>
<b>text12</b><?PI end 5?>
text13<?PI start 6?> text13<?PI end 6?>
</p>
</conbody>
</concept>
match text or any element that has preceding-sibling <?PI start?> and following-sibling <?PI end?>.
xsl
<xsl:template match="//processing-instruction('PI')[contains(.,'start')]">
<xsl:for-each select="following-sibling::*">
<xsl:value-of select="./text()"/>
</xsl:for-each>
<xsl:for-each select="following-sibling::text()">
<xsl:value-of select="."/>
</xsl:for-each>
<xsl:copy>
<xsl:apply-templates select="#* | node()" />
</xsl:copy>
</xsl:template>
output
<concept xmlns:ditaarch="http://dita.oasis-open.org/architecture/2005/" id="testcase">
<title> Introduction</title>
<conbody>
<p>
<p>text01</p>
text03 text02
text04 text05 text06
text07
<?PI start 1?> text02 <?PI end 1?>
<b> text03 </b>
text04 text05 text06
text07
<?PI start 2?> text04 text05 <?PI end 2?> text06
text07
<?PI start 3?> text07 <?PI end 3?>
</p>
<p>
text12text11
text13
<?PI start 4?>text11 <?PI end 4?>
text12
text13
<?PI start 5?>
<b>text12</b><?PI end 5?>
text13
<?PI start 6?> text13<?PI end 6?>
</p>
</conbody>
</concept>
Problem is that it matches even the elements that are not between 2 processing instructions. For example text03 from below, as technically it does have preceding-sibling <?PI start?> and following-sibling <?PI end?>:
<?PI start 1?> text02 <?PI end 1?>
<b> text03 </b>
<?PI start 2?> text04 text05 <?PI end 2?>
XSLT version: 1.0
XSLT processor: Saxon-HE
I will appreaciate any input, ideas and sugesstions

Answer 1

If the PIs are always siblings then doing
<xsl:template match="processing-instruction('PI')[starts-with(.,'start')]">
<xsl:variable name="end-pi" select="following-sibling::processing-instruction('PI')[starts-with(., 'end')][1]"/>
<xsl:variable name="nodes-before-end"
select="following-sibling::node()[. << $end-pi]"/>
</xsl:template>
should suffice to select the nodes between the two PIs. Output them as needed, I couldn't quite tell where/how you want to output them.

Answer 2

I know this is not what you asked for, but maybe it will be useful.
I have this code that does almost exactly the same thing you asked for with minor difference: if the content of the node between 2 processing instructions is a collection of white-spaces or the text of a node between 2 processing instructions is a collection of white-spaces, it replaces them with empty nodes.
I am using pythons standard library, no need to install anything additional. Just make sure to run with python3(I run it with python3.6, but any python3+ should be fine)
from pprint import pprint
from typing import List
from xml.dom import minidom
from xml.dom import Node
import re
def get_all_processing_instruction_nodes(child_nodes: List):
start_end_pairs = []
current_pair = {}
for index, node in enumerate(child_nodes):
if node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
if "start" in node.nodeValue:
current_pair["start"] = {
"node": node,
"index": index
}
if "end" in node.nodeValue:
if "start" not in current_pair:
raise ValueError("End detected before start")
current_pair['end'] = {
"node": node,
"index": index
}
start_end_pairs.append(current_pair)
current_pair = {}
return start_end_pairs
def process_all_paired_child_nodes_recursively(node):
pi_pairs = get_all_processing_instruction_nodes(node.childNodes)
if pi_pairs:
print(node.nodeName, "::", node.nodeValue)
pprint(pi_pairs)
for pair in pi_pairs:
start_index = pair['start']['index']
end_index = pair['end']['index']
interesting_nodes = node.childNodes[start_index + 1: end_index]
process_interesting_nodes(interesting_nodes)
for child_node in node.childNodes:
process_all_paired_child_nodes_recursively(child_node)
def process_interesting_nodes(interesting_nodes: List):
for i_node in interesting_nodes:
if i_node.nodeValue:
i_node.nodeValue = re.sub(r"\s+", "", i_node.nodeValue)
def process_xml_file(input_file_path: str, output_file_path: str):
document_node = minidom.parse(input_file_path)
process_all_paired_child_nodes_recursively(document_node)
with open(output_file_path, "w") as f:
f.write(document_node.toxml(document_node._get_encoding()).decode())
You can easily modify the process_interesting nodes function to do anything with the matched nodes(note that the plain text between 2 processing instructions is parsed as a Text node in python so you treat it as a regular node).
Hope this helps. I would also recommend you take a look at the python's xml lib, especially the minidom part (https://docs.python.org/3/library/xml.dom.minidom.html). Minidom module, unlike the regular xml parser, allows you to tread processing instructions and comments as regular nodes.