September 2001

Applies to:

     Microsoft Internet Explorer 5.0 (and later)
     Microsoft XML Parser 3.0
     Sybase PowerBuilder 7.0 or 8.0

Summary: This article explains how PowerBuilder (prior to PB 9) can utilize XML technology. XSLT is used to transform XML data from one format to another. In the examples an XSLT style sheet is used to transform Datawindow data saved as a XML file into HTML.The code also demonstrates how to use XSLT to display data in two distinct formats by using PowerScript.

Note  : More XML support (DataWindow XML support, PBDOM, XML import and save etc.) can be found in the PB 9 and higher release ! PB 10 has additionally XML Web Datawindow and XHTML support.
 

Contents

1.Introduction
2. Microsoft XML/XSL Processors
3. Overview of the Transformation Process
4. Steps To Transform DataWindow Data into XML
5. Using Multiple Style Sheets with PowerScript
6. PowerScript Code used for Transformation
7. Results
8. Conclusion

Appendix
- Error Handling and XSLT
- Additional Resources
- Glossary

1. Introduction

One of the advantages of using the Extensible Markup Language (XML) in exchanging data between different applications is the ease in which XML data can be tranformed into other formats and structures.. As an example, you may need to convert the employee information that is currently stored in a flat XML file, into a Hypertext Markup Language (HTML) file for use on your company's HR Web site. The "mechanism" used to accomplish these conversions is an XML-based language called XSL Transformations (XSLT).

You should have a basic understanding of XML and the terms used to describe XML-related files when reading this article.

2. Microsoft XML/XSL Processors

In the PowerBuilders Developers Journal (Issue 8/2001) there has been an article that describes the Microsoft XML Processor. Furthermore the following information from Microsoft has been included for completeness:

"There are several XSLT processors available, including the Microsoft MSXML 3.0 processor which can be downloaded from the Microsoft Online XML Developer Center. The MSXML 3.0 processor can also be installed with Microsoft Office XP and Microsoft Windows® XP.

The MSXML 3.0 parser supports both the XML DOM and the Simple API for XML (SAX2). The XML DOM is a tree-based application programming interface (API) that presents a standardized interpretation of an XML document to applications and scripts. The XML DOM implementation in MSXML allows you to load or create a document; gather errors, if any; access and manipulate the information and structures contained within the document; and save the document back out to an XML file, if necessary. Where the XML DOM defines the logical structure of an XML document in memory, the SAX2 provides an event-based API, which allows developers to hook directly into the document parsing process using event interfaces that serve up the document's information items as they are parsed. In other words, the XML DOM interfaces are made available to the application after the document has been parsed and loaded. The SAX2 interfaces are available to the application as the document is being parsed.

The XSLT processor is a Component Object Model (COM) object, so it can be invoked by any language that can create a COM object, including Microsoft Visual Basic® Scripting Edition (VBScript), Microsoft JScript®, Microsoft Visual Basic, Microsoft Visual Basic for Applications, or Microsoft Visual C++®.

Note The Microsoft XML parser/processor, MSXML, was originally released as a stand-alone product and was later included with Internet Explorer 5.0. Unfortunately, the XSLT standard changed substantially after Internet Explorer 5.0 was released, so the MSXML processor is archaic. You should switch to the latest version of MSXML (which was MSXML 3.0 as of this writing). For more information on switching to the current version of MSXML, see the article How to Redistribute the Microsoft XML Parser on the Microsoft Knowledge Base Web site.
To run the following examples, you will need to have the MSXML 3.0 processor installed on your system. "
 

3 Overview of the Transformation Process

To understand how XSLT works, we need to look at how XML-enabled browsers such as Microsoft Internet Explorer 5.0 or later handle XML data. When you open an XML data file in an XML-enabled Web browser, the browser uses a built-in parser, such as the Microsoft XML Parser (MSXML), to parse the elements of the XML document into a tree-like structure.

<?xml version="1.0"?>
<presentation code="ID111">
        <!-- Example XML file -->
        <title>A PB 8 XML example</title>
        <author>Klaus Kirchner</author>
        <audience>PB developers</audience>
        <time>12:30</time>
        <date>27.08.2001</date>
</presentation>

    ...

This document fragment would be parsed into a tree structure: Representation PB treeview

Figure 1. Example of data parsed into tree structure

Notice that it isn't the data but the elements containing the data that are being manipulated by the parser. It's also worth noting that the parsing and transformation are being done in memory and not in the input file. Thus the physical input file remains untouched by the transformation, enabling you to use the same input data for any number of transformations.

After the input data has been parsed by the Browser, stored in memory, and then restructured, the browser looks for a reference to an XSLT file. If the input file contains either a reference to an XSLT document or a scripting command to load an XSLT document, the browser parses the XSLT file into memory, also as a tree structure. The browser then uses a built-in processor to apply the XSLT tree structure to the XML data tree structure to perform the transformation. So in addition to its functions as a browser and an XML parser, an XML-enabled browser such as Internet Explorer also contains an XSL processor.

If no XSL/XSLT (or other style sheet) reference exists in the input XML data file, the data is displayed as raw XML or in another default structure, depending on the browser used. As you'll see, Internet Explorer 5.0 and later have a default XSL style sheet that displays XML files as an expandable tree-like structure when no XSL/XSLT file is specified.

During the transformation, the XSL processor cycles through the XSLT tree, attempting to match patterns within the XSLT commands to specific elements (also called nodes) in the XML input tree. When a pattern match is found, the browser then searches the XSLT tree for matching template rules, which it applies to the XML element or to descendants or children of the element. The result is an output tree that contains a series of elements, data, and any HTML tags or instructions necessary to format the data. An XSLT style sheet provides a template or "blueprint" of the output structure that will result from transforming the data. The content and presentation of this output is based on the input data and the style sheet (if one is used), which provides a series of commands to manipulate the structure of the elements and HTML tags to format the data.

To complete the process, the browser parses the output tree?again using the XML parser?and displays it either as an HTML document or as whatever format was specified during the transformation. Thus, at its lowest level, XSLT is used to convert one tree structure into another tree structure. The XSLT processor does this by storing and manipulating three different tree structures: the input XML and data, the XSLT style sheet, and the output XML and data.

For Information about the parsing process with Microsoft XML parser/processor and a description about the PowerBuilder function wf_parse_node() that enables the display of the parsed XML file in a treeview please see the article "Interfacing PowerBuilder with the WEB" in the PowerBuilders Developers Journal (Issue 8/20001). In the example application presented here, the parsing process is executed when pressing the Load File.. button in the XML Parser Sheet (via File..New..XML Parser). To examining the code, look into the script in the buttons clicked event.
 

4. Steps to Transform DataWindow Data into XML

The steps necessary to transform an existing DataWindow into another format by using XSLT can be described as follows:

- Export the data from a DataWindow into an XML document by using the save_as_xml function available in the window Employee DataWindow (via File..New..Employee DataWindow).
- Create an XSLT file (with an .xsl file extension) by using a text editor. In this file, add processing instructions to convert and restructure the data as desired. You will need a processing instruction for each element or group of elements you want in the output.
Note  : More XML support (DataWindow XML support, PBDOM, XML import and save etc.) can be found in the PB 9 release !

First, we will create the Employees.xml file and then look at a default style sheet in action, by using Internet Explorer to display our results with no explicit style sheet specified.

Open the Employee DataWindow Sheet and you will see a tabular DataWindow retrieving 4 columns from the employee table of the EAS Demo DB V4. When you press the button
Save As XML..you can enter a Filename eg. Employees.xml and press save. Now the Tabular DataWindow Data will be saved as a XML structure.
The function that is used extracts some basic information eg. the column names from the datawindow object and writes out the data together with the xml tag formatting to the file.
In the example several node names are hardcoded, but depending on the preferences this part could be enhanced by the programmer.

Locate the Employees.xml file and double-click to open.
Assuming your default browser is Internet Explorer 5.0 (or later), the file will be displayed as a tree structure with expandable branches of elements. This tree structure is created from the default XSLT style sheet used by Internet Explorer to transform the data.
The following code shows the default XML output from Internet Explorer.

        ......
 
 
 

5. Using Multiple Style Sheets with PowerScript

Let's look at how to use multiple XSLT style sheets to format the same XML data in two different styles by using PowerScript.

The sample we will look at (included in the download available with this article) uses the data from the Employees.xml file. We also want to provide the information in two formats: a simple list format as we are used to see in a tabular DataWindow presentation and a catalog format for a better look & feel.
 

Employees.xml file
This file contains selected information on the employees from the Employees table from the sample database.
pb_list_style.xsl file
This file contains the XSLT style sheet that is used to display the Employees.xml file in a format that lists the relevant information. We will describe this file in a little more detail later.
pb_catalog_style.xsl file
This file contains the XSLT style sheet that is used to display the Employees.xml file in a format similar to a catalog. We will also discuss this file in more detail.
Result.html , result_cat.html files
This files are the result of the transformation.
Looking at this example in a little more detail, the Employees.xml data file contains information on employees. As with any XML file, it starts with an XML processing instruction indicating that this is an XML file and the version number (sometimes additionally specifies an encoding format like: encoding="utf-8"). The file contains an <employees> document element, which contains a series of <employee> elements. There is one set of <employee> elements for each employee. These elements, in turn, contain a series of child elements that encapsulate the employee information we are interested in providing to the client.

The following is a fragment of the Employee_data.xml data file.

<?xml version="1.0"?>
<employees>
<employee>
<emp_id>102</emp_id>
<emp_fname>Fran</emp_fname>
<emp_lname>Whitney</emp_lname>
<start_date>2/26/87</start_date>
</employee>
<employee>
<emp_id>105</emp_id>
<emp_fname>Matthew</emp_fname>
<emp_lname>Cobb</emp_lname>
<start_date>7/2/87</start_date>
</employee>
<employee>
<emp_id>129</emp_id>
<emp_fname>Philip</emp_fname>
<emp_lname>Chin</emp_lname>
<start_date>8/4/98</start_date>
</employee>

 ...

Next, the pb_list_style.xsl file is an XSLT style sheet file that contains the template rules, instructions, and HTML tags necessary to display our XML data as a simple list of employee characteristics.

The following code shows the pb_list_style.xsl XSLT style sheet file.

<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                 version="1.0">

<!-- This XSLT style sheet is used to transform the Employees.xml
file to a simple list (tabular) like format.  -->

<xsl:output method="html"/>
<xsl:template match="/">
 <html>
   <head>
     <title>The XSLT list style sheet</title>
   </head>
   <body>
     <table border="0" cellpadding="10">
      <tr>
       <th align="left">Employee ID</th>
       <th align="left">First Name</th>
       <th align="left">Last Name</th>
       <th align="left">Hire Date</th>
      </tr>
      <xsl:apply-templates select="/employees/employee">
       <xsl:sort select="emp_lname"/>
      </xsl:apply-templates>
    </table><p />
   </body>
 </html>
</xsl:template>

<!-- Outputs the child elements of the employees element. -->
<xsl:template match="employee">
   <tr>
    <td><xsl:value-of select="emp_id"/></td>
    <td><xsl:value-of select="emp_fname"/></td>
    <td><xsl:value-of select="emp_lname"/></td>
    <td><xsl:value-of select="start_date"/></td>
   </tr>
</xsl:template>
</xsl:stylesheet>
 

Both of the XSLT style sheets used in this sample use an HTML table to contain the employee information. However, by using different template rules, instructions, and HTML formatting tags, we can achieve very different display of data.

Continuing with our discussion, we see the first template instruction, which matches the root node of the document and is used to ensure that we process all of the elements in the document.

<xsl:template match="/">

Remember that the root node is synonymous with the document node in the XML DOM and represents the entire source document. It should not be confused with the document node, the <Employees> node in our example, which contains all of the remaining nodes in our document. Next in our sample there are a number of HTML tags to create a table with heading items.

Then the <xsl:apply-template> element directs the XSLT processor to find a template matching the value of the XPath expression "employees/employee" and if found, process each of its descendants, again looking for a matching template.

<xsl:apply-templates select="/employees/employee">
    <xsl:sort select="emp_lname"/>
</xsl:apply-templates>

The position of this instruction in the page we are constructing is where the employee information will be written. Further down in our file, we see a template match for the <employee> element.

<xsl:template match="employee">
   <tr>
    <td><xsl:value-of select="emp_id"/></td>
    <td><xsl:value-of select="emp_fname"/></td>
    <td><xsl:value-of select="emp_lname"/></td>
    <td><xsl:value-of select="start_date"/></td>
   </tr>

This template contains a repetitive list of instructions to handle the children of the <employee> element. The first instruction, <td><xsl:value-of select="emp_id"/></td>, tells the processor to write the contents of the <emp_id> element into our table. This instruction is then repeated for each of the remaining children of the <employee> element.

Next we will look at the XSLT style sheet file, pb_catalog_style.xsl. This file contains the template rules, instructions, and HTML tags to display our XML data in a catalog style. The following code shows pb_catalog_style.xsl file.

<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                 version="1.0">

<!-- This XSLT style sheet is used to transform the employees.xml
file to a nicer format. -->

<xsl:output method="html"/>
<xsl:template match="/">
 <html>
   <head>
     <title>The XSLT catalog style sheet</title>
   </head>
   <body>
      <xsl:apply-templates select="/employees/employee">
       <xsl:sort select="emp_lname"/>
      </xsl:apply-templates>

   </body>
 </html>
</xsl:template>

<xsl:template match="employee">
 <table border="0" cellpadding="10" bgcolor="lightyellow">
   <tr>
    <td>
      <img src="{emp_id}.jpg" alt="{emp_fname}"/>
    </td>
    <td>
     <div>
      <b>Employee ID: </b><xsl:value-of select="emp_id"/>
     </div><p/>

     <div>
      <b>First Name: </b><xsl:value-of select="emp_fname"/>
     </div><p/>
     <div>
      <b>Last Name: </b><xsl:value-of select="emp_lname" />
      <br><b>Hiring Date: </b><xsl:value-of select="start_date"/></br>
     </div><p/>
     <div><font color="BLUE"><b>Company</b>
          <img src="sybase.gif" alt="Sybase"/></font></div>
    </td>
   </tr>
 </table>
</xsl:template>
</xsl:stylesheet>

The primary XSLT element of interest in this file is the <xsl:apply-template> element which, like its predecessor in the previous file, directs the XSLT processor to find a template matching the value of the XPath expression "employees/employee", the <xsl:template match="employee"> element in this example, and process each of its descendants. Looking further down the file, the template that matches this instruction contains a series of HTML tags that create table rows with special background coloring and other formatting attributes. Another row of data will contain a .gif file representing a picture of each employee (Only two gif files are included in the sample).The remaining template instructions instruct the processor to output the value of each specific element into our table and then we see a group of closing XSLT and HTML tags.

6. PowerScript Code used for Transformation
 

// Declare an OLE object as a reference to the parser
oleobject  lole_xml_document , lole_xsl_document
string ls_result
 

// Identify the file to parse (if hardcoded)
string ls_filename = "D:\testcases\pb8\PB_xml\employees.XML"
string ls_xslfilename = "D:\testcases\pb8\PB_xml\pb_list_style.xsl"
 

// Create the OLE Object
lole_xml_document = CREATE oleobject
lole_xsl_document = CREATE oleobject
//lole_result = CREATE oleobject
// Connect to the parser
// NOTE : This example uses the parser from IE5.
// Use the class name "MSXML2.DOMDocument.3.0"
// Older version: Microsoft.XMLDOM
// for the latest version.

Integer li_rc

li_rc = lole_xml_document.ConnectToNewObject("MSXML2.DOMDocument.3.0")

IF li_rc < 0 THEN

   MessageBox("Connecting to COM Object Failed", "Error: " + String(li_rc))

   DESTROY lole_xml_document

 Return

END IF
 

  Integer li_rc1

li_rc = lole_xsl_document.ConnectToNewObject("MSXML2.DOMDocument.3.0")

IF li_rc1 < 0 THEN

   MessageBox("Connecting to COM Object Failed", "Error: " + String(li_rc))

   DESTROY lole_xsl_document

 Return

END IF
 
 

// Load the file into memory (this will parse it)
boolean lb_test
lb_test=lole_xml_document.load(ls_filename)
  IF lb_test = false THEN
    //Demonstrate the parseError attribute
    MessageBox("Load of XML doc Failed", "ErrorCode: "+string(lole_xml_document.parseError.ErrorCode)+ "~n~r" &
  + "FilePosition: " +string(lole_xml_document.parseError.Filepos)+ "~n~r" &
  + "Line: " +string(lole_xml_document.parseError.Line)+ "~n~r" &
  + "LinePosition: " +string(lole_xml_document.parseError.Linepos)+ "~n~r" &
  + "Reason: " +string(lole_xml_document.parseError.Reason)+ "~n~r" &
  + "SourceText: " +string(lole_xml_document.parseError.SrcText))

   DESTROY lole_xml_document

   Return

END IF

// Load the file into memory (this will parse it)
boolean lb_test1
lb_test1=lole_xsl_document.load(ls_xslfilename)
  IF lb_test1 = false THEN
    //KK-Demonstrate the parseError attribute
    MessageBox("Load of XML doc Failed", "ErrorCode: "+string(lole_xsl_document.parseError.ErrorCode)+ "~n~r" &
  + "FilePosition: " +string(lole_xsl_document.parseError.Filepos)+ "~n~r" &
  + "Line: " +string(lole_xsl_document.parseError.Line)+ "~n~r" &
  + "LinePosition: " +string(lole_xsl_document.parseError.Linepos)+ "~n~r" &
  + "Reason: " +string(lole_xsl_document.parseError.Reason)+ "~n~r" &
  + "SourceText: " +string(lole_xml_document.parseError.SrcText))

   DESTROY lole_xsl_document

   Return

END IF
 

ls_result=lole_xml_document.transformNode(lole_xsl_document)
is_html_result=ls_result

mle_1.text=ls_result
// Disconnect from the XML parser
lole_xml_document.DisConnectObject()

lole_xsl_document.DisConnectObject()
 

// Destroy the OLE object
DESTROY lole_xml_document
DESTROY lole_xsl_document

We first declare and create an instance of the XML DOM Document object for both the XML data and the XSLT style sheet so we can get at the properties and methods for these objects.

oleobject  lole_xml_document , lole_xsl_document

// Create the OLE Object
lole_xml_document = CREATE oleobject
lole_xsl_document = CREATE oleobject

li_rc = lole_xml_document.ConnectToNewObject("MSXML2.DOMDocument.3.0")
li_rc = lole_xsl_document.ConnectToNewObject("MSXML2.DOMDocument.3.0")
 

Then we load the XML file and XSLT style sheet into the variables. Please make sure that the filenames are matching the location where the example files are stored on the harddisc.

lb_test=lole_xml_document.load(ls_filename)
lb_test1=lole_xsl_document.load(ls_xslfilename)

XML-based files are said to be "well-formed" if they conform to specific rules for XML documents such as each opening tag has a closing tag, there must be a single outermost element that encloses the others, tags must be nested inside of each other and not overlap, and so forth. XML documents can also conform to a stricter level of "correctness" if they are "valid". Valid XML documents are well-formed documents that meet two additional criteria: they must refer to a document type definition (DTD) document (such as an XSL file) and the structure of the XML data
must conform to the DTD document. Remember that XSLT is a subset of XSL (so it also counts) that describes the structure of the XML data. If you are transforming unstructured (non-XML) data, you would want to set lole_xml_document.ValidateOnParse=False.

After loading the XML data and XSLT style sheet into memory, we call the transformNode method.

ls_result=lole_xml_document.transformNode(lole_xsl_document)

This method performs the actual transformation by running the XSLT style sheet against the XML data and returning HTML data. The result of this call is stored in the string variable ls_result.

7. Results

After the button "pb_list_style" is pressed the HTML result is displayed in the multiline edit control and can be saved as an html file using the Save HTML.. button. When the HTML file has been
saved we can open it using a Browser, or using the Browser Sheet in the Example Application (via File..New..Browser).
Also the input file is parsed and displayed in the treeview in order to examine the structure of the loaded XML file.

Result : List Style - result.html

    .....
 
 

When the other commandbutton is pressed (pb_catalog_style) the resulting HTML file shows table rows with special background coloring and other formatting attributes. Another row of data will contain a .gif file representing a picture of each employee, as described in the stylesheet.

Result : Catalog Style - result_cat.html

....
 

8. Conclusion

We have seen how PowerBuilder and  XML can be used together. We first looked at parsing a XML document using PowerBuilder, then used PowerBuilder to save DataWindow data into a XML file and finally applied XSLT to transform the generated input XML file into two different HTML output files.
 

APPENDIX

Error Handling and XSLT
 

If nothing is returned (no html) it is best to check the parseError object to see if there was a parsing error when loading either the XML file or style sheet. The Document object of the XML DOM exposes a parseError object, which can be examined to tell if an error occurred. If an error did occur, you can retrieve the cause or display an error message in the page.

The parseError object provides seven properties that can be checked to reveal more information about the error. The following table describes the properties of the parseError object.
 
 

For example, you could use the following fragment of PowerScript in your code to detect and display error details eg. while loading the XML document:

IF lb_test1 = false THEN
    //KK-Demonstrate the parseError attribute
    MessageBox("Load of XML doc Failed", "ErrorCode: "+string(lole_xsl_document.parseError.ErrorCode)+ "~n~r" &
  + "FilePosition: " +string(lole_xsl_document.parseError.Filepos)+ "~n~r" &
  + "Line: " +string(lole_xsl_document.parseError.Line)+ "~n~r" &
  + "LinePosition: " +string(lole_xsl_document.parseError.Linepos)+ "~n~r" &
  + "Reason: " +string(lole_xsl_document.parseError.Reason)+ "~n~r" &
  + "SourceText: " +string(lole_xml_document.parseError.SrcText))
 
 

More information about the parseError object can be found on the Microsoft Online XML Developer Center.
 
 

Additional Resources

For more information about XML, see the Sybase document Fast Track to XML, linked below.

For a more in-depth discussion of the concepts presented in this article, see the W3C Extensible Markup Language (XML) Web site at http://www.w3.org/XML/ .

For more information about XPATH, see the Sybase document Using XPath to Navigate XML Documents also linked below.

For more information about XSL and XSLT, see the W3C Extensible StyleSheet Language (XSL) Web site at http://www.w3.org/Style/XSL  or check the XSL Developer's Guide on MSDN.

For information about the PowerBuilders Developers Journal article, see http://www.sys-con.com/pbdj/ section August issue 2001.

You can contact the author of the PBDJ article: Paul Donohue, email: techwave@pauldonohue.com and his Web site www.pauldonohue.com .

Glossary
This glossary defines some of the technical terms presented in this article. For more information on any of these terms, see the links in the Additional Resources section of this article.

Attribute
A name=value pair appearing in an element's start tag such as  match="//employees".

Comment
An item in an XSLT style sheet that contains extraneous information. Written between the delimiters <!-- and -->.

Document Element
The outermost element of a document. The Document Element contains all of the other elements. Contrasted with the root node.

Element
A logical element within an XSLT style sheet delimited by start and end tags such as <Title>Sales Representative</Title>.

Expression
An XPath construct that can be evaluated to a string, number, Boolean, or set of nodes. Expressions are used in many contexts such as the select attribute of the <xsl:templates> element.

Namespace
A named collection of names. A namespace is named by using a URI, to ensure uniqueness, and utilizes a preface to provide context for elements and attributes.

Node
An object of a tree structure.

Output Method
XSLT defines three output methods: XML, HTML, and text.

Pattern
A construct that defines a condition that every node either satisfies or does not satisfy. Used as XPath expressions in XSLT elements such as <xsl:template>.

Processing Instruction Nodes
Nodes containing processing instructions. Processing instructions carry instructions to the software that receives the XML document and processes it. Written between the delimiters <? and ?> such as the <?xml version="1.0" encoding="UTF-8" ?> declaration in an XML document.

Result Tree
The output of a style sheet. A style sheet defines a transformation from a source tree structure to a result tree structure.

Root Node
The top-most node in a tree structure. If the tree structure represents a well-formed XML document, the root node will have exactly one element node, representing the document element, and no child nodes. It may also contain comment nodes and processing instructions nodes as children.

Template Body
A sequence of XSLT instructions, HTML tags, and text forming the contents of an <xsl:template> element.

Template Rule
An <xsl:template> element with a match= attribute. A template rule may be invoked by using the <xsl:apply-templates> instruction.

Tree Structure
An abstract data structure representing the information content of an XML document. The tree structure always has a single root.

URI
Uniform Resource Identifier: a generalization of the URLs (Uniform Resource Locators) used to uniquely identify resources such as addresses on the Internet.

Well-formed
A document is well-formed if it follows the syntax rules in the XML specification. These include such rules as there must be a single outermost element that encloses all other elements and all start tags must have closing tags.
 

Related Links