How to parse XML containing processing instructions

When parsing XML, you need to use a parser that supports retained processing instructions (PI). The PI format is , which is used to provide metadata or style sheet links. ElementTree in Python does not retain PI by default and needs to be captured by a custom parser. DOM in Java can be directly accessed through the ProcessingInstruction node. After extraction, it should be processed according to the target. For example, xml-stylesheet is used to associate styles. Custom targets trigger specific logic and keep the PI order and content unchanged when rewriting XML to ensure that key instructions are not lost.

When parsing XML that contains processing instructions (PIs), you need a parser that preserves them during processing. Processing instructions, which look like , are often used to provide hints or metadata to applications and should be handled carefully.

Understand Processing Instructions in XML

Processing instructions are not regular elements or text nodes—they have a target (like xml-stylesheet ) and optional data. They're commonly used for linking stylesheets or custom directives.

Example:

Key points:

• PIs start with and end with ?>
• The first word is the target (eg, custom-transform )
• The rest is treated as data and preserved as-is

Use a Suitable XML Parser

Not all XML parsers expose processing instructions by default. Choose one that supports full XML infoset, including PIs.

In Python using ElementTree:

• Standard xml.etree.ElementTree does not preserve PIs by default
• Use a custom parser with PI handling

import xml.etree.ElementTree as ET

class PIPreservingParser(ET.XMLParser):
def init (self):
super(). init ()
self._parser.DefaultHandler = self._default_handler
self.pis = []

def _default_handler(self, data):
if data.startswith("") and data.endswith("?>"):
self.pis.append(data)

#Usage
parser = PIPreservingParser()
tree = ET.parse("file.xml", parser)
print("Found PIs:", parser.pis)

In Java using DOM:

• DOM fully supports PIs via ProcessingInstruction nodes
• They appear as child nodes alongside elements

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(new File("file.xml"));

NodeList nodes = doc.getChildNodes();
for (int i = 0; i Node node = nodes.item(i);
if (node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) ​​{
ProcessingInstruction pi = (ProcessingInstruction) node;
System.out.println("Target: " pi.getTarget());
System.out.println("Data: " pi.getData());
}
}

Handle PIs Based on Target

Once parsed, process instructions based on their target name.

• xml-stylesheet : Use to locate associated XSL/CSS files
• Custom targets: Handle application-specific logic (eg, enable features)
• Ignore unknown targets if not relevant

Example logic:

• If target is custom-transform and data contains apply="true" , ​​trigger transformation
• Store PI data for later use during rendering or export

Preserve PIs When Rewriting XML

If modifying and reserializing XML, make sure to write PIs back correctly.

• Keep original order—PIs can affect processing
• Escape special characters in data if needed
• Avoid modifying PI content unless intentional

Most serializers don't output PIs unless explicitly told. When building output, include them at correct positions using proper syntax.

Basically, handle processing instructions by choosing the right parser, extracting them properly, and acting on their target and data as needed. The key is awareness—they're easy to miss but can carry important instructions.

The above is the detailed content of How to parse XML containing processing instructions. For more information, please follow other related articles on the PHP Chinese website!