Processing XML Documents with DOM Using BSF4ooRexx

Size: px

Start display at page:

Download "Processing XML Documents with DOM Using BSF4ooRexx"

Jonathan McCoy
5 years ago
Views:

1 MIS Department Processing XML Documents with DOM Using BSF4ooRexx Prof. Dr. Rony G. Flatscher Vienna University of Economics and Business Administration Wirtschaftsuniversität Wien Augasse 2-6 A-1090 Wien Hier DOM, Vortrags-/Vorlesungstitel Automatisierung p.1 von Windows im Master Anwendungen eintragen (3)

2 Overview Markup-Language Basics XML DOM Principles Exploiting DOM from oorexx Examples Roundup Hier DOM, Vortrags-/Vorlesungstitel p.2

3 Terms, 1 (Markup Languages) Tag Enables one to use tags to embrace regular text Opening tag (a.k.a. start tag) <some_tag_name> Closing tag (a.k.a. end tag) </some_tag_name> Allows for analyzing text, by noticing which parts of a text are surrounded ("embraced") by which tags "Element" The sequence "opening tag", text, "closing tag" Hier DOM, Vortrags-/Vorlesungstitel p.3

4 Terms, 2 (Markup Languages) Document Type Definition (DTD) Defines the tags and their attributes, if any Name (identifier) of the tag Attributes for tags "Content model" Nesting of tags and the allowed sequence of tags - Hierarchical structure! Allows to determine how many times an element may occur "Instance" of a DTD A document with text that got marked-up according to the rules defined in a DTD A document that has been checked whether the DTD rules were applied correctly is named a "valid" document Hier DOM, Vortrags-/Vorlesungstitel p.4

5 Terms, 3 (Markup Languages) HTML A markup language for the WWW DTD HTML-Browser Parses a document marked up according to HTML Formats the text, depending on the used tags Version 4.01: three variants defined SGML-based, hence it is possible to Use any case for the tags and attribute names Some closing tags may be omitted if the end tags can be determined by the rules set forth in the DTD It is possible to define exclusions Hier DOM, Vortrags-/Vorlesungstitel p.5

6 Terms, 4 (Markup Languages) XML A slightly simplified version of SGML Allows the definition of DTDs for markup languages Since 2002 an alternative got introduced in the form of "XML Schema": Tag and attribute names must be written in exact case End tags must be always given Attribute values can now be enclosed within apostrophes/single quotes (') in addition to double quotes (") It is possible to explicitly denote empty elements <some_tag_name/> Hier DOM, Vortrags-/Vorlesungstitel p.6

7 Terms, 5 (Markup Languages) XML DTDs can be omitted A matching DTD can be always inferred, if the document is "well formed": All tags must be nested Tags must not overlap Start tags must have matching end tags Structure is always independent of the formatting! Cascading Style Sheets (CSS) Allows to define formatting (layout) rules for elements It is possible to define specific formatting (layout) rules for elements with attributes that have specific values or depending on the sequence of the elements Hier DOM, Vortrags-/Vorlesungstitel p.7

8 Terms (XHTML) Text, marked up in XHTML <html> <head> <title>this is my HTML file</title> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.8

9 XHTML Text Rendered in Firefox Hier DOM, Vortrags-/Vorlesungstitel p.9

10 Example: Linking a Cascading Style Sheet (CSS) Text, marked up in XHTML <html> <head> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.10

11 XHTML Text Rendered in Firefox with CSS Hier DOM, Vortrags-/Vorlesungstitel p.11

12 Example of a Cascading Style Sheets (CSS) Tag h1 { color: blue; text-align: center; font-family: Arial,sans-serif; font-size: 200%; } Tag body { background-color: yellow; font-family: Times, Avantgarde; font-size: small; } "class" Attribut.verb { background-color: white; color: red; font-weight: 900; } "id" Attribut #xyz1 { font-variant: small-caps; text-align: right; } "id" Attribut #a9876 { font-size: large; } Hier DOM, Vortrags-/Vorlesungstitel p.12

13 Document Object Model (DOM), 1 Parsing of a HTML/XML file Creates a parse tree in which the elements are nodes Each HTML browser needs to do this with each HTML file! Application Programming Interfaces (API) for Creating, querying, changing and deleting nodes from the tree This includes the manipulation of attributes as well! Intercepting events, while the user is working with the parse tree User generated events as a result of using the mouse or the keyboard Application generated events like "document loaded" Hier DOM, Vortrags-/Vorlesungstitel p.13

14 Document Object Model (DOM), 2 Example  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd"> <html> <head> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> html head body title link h1 p h1 p p span span Hier DOM, Vortrags-/Vorlesungstitel p.14

15 DOM (Document Object Model), 3 Java DOM Parsers A Java DOM parser processes the entire document "Factory" pattern, which allows different implementations of DOM parsers to be deployed via Java The DOM parser creates a parse tree where each node is one of type (cf. Java documentation of org.w3c.dom.node) Attr (attribute), CDATASection (character data section), Comment, Document, DocumentFragment, DocumentType, Element, Entity, EntityReference, Notation, ProcessingInstruction, Text The interface definitions for nodes (cf. org.w3c.dom.node) also include a set of methods to manipulate the parse tree Hier DOM, Vortrags-/Vorlesungstitel p.15

16 DOM (Document Object Model), 4 The interface org.xml.sax.errorhandler defines the methods a SAX/DOM error listener must implement error(saxparseexception exception) fatalerror(saxparseexception exception) warning(saxparseexception exception) org.xml.sax.saxparseexception has the following methods getcause() returns a Throwable Java object representing the cause getexception() returns an embedded exception, if any getmessage() returns a string with the detailed error message tostring() returns a string representation of the SAXParseException Hier DOM, Vortrags-/Vorlesungstitel p.16

17 DOM-parsing in oorexx Create an oorexx listener class for handling errors/warnings Create an oorexx listener object from it Create a Java object that embeds the oorexx listener object BSFCreateRexxProxy(rexxListenerObject,[slotArg,interfaceName[,...) interfacename denotes the Java interface name which methods the Rexx listener object handles It is possible to denote more than one Java interface, if the Rexx listener object is able to handle all methods defined by them! Let the Java DOM parser parse the document Process the resulting parse tree with Rexx routines node by node Hier DOM, Vortrags-/Vorlesungstitel p.17

18 "code01.rxj ": Extract Text from any XHTML Document The oorexx Program (Main Program), 1 /* purpose: demonstrate how to extract the text from a xml file using DOM */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* make important constants available via.local */ clzdomnode=bsf.loadclass("org.w3c.dom.node") -- load the Java interface class.local~cdata_section_node=clzdomnode~cdata_section_node -- save field value.local~text_node =clzdomnode~text_node -- save field value /* now collect all text and CDATA nodes and display them */ call follownode rootnode ::requires BSF.CLS /* get the Java support */... cut... Hier DOM, Vortrags-/Vorlesungstitel p.18

19 "code01.rxj ": Extract Text from any XHTML Document The oorexx Program (the oorexx Classes), 2... cut... ::requires BSF.CLS /* get the Java support */ ::routine follownode /* walks the document tree recursively */ use arg node call processnode node -- process received node if node~haschildnodes then do children=node~getchildnodes -- get NodeList loop i=0 to children~length based indexes! call follownode children~item(i) -- recurse end end ::routine processnode /* processes each node */ use arg node nodetype=node~getnodetype -- get type of node if nodetype=.text_node nodetype=.cdata_section_node then say pp(node~nodevalue) ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler") ::method unknown /* handles "warning", "error" and "fatalerror" events */ use arg methname, argarray -- arguments from the Java SAX parser exception=argarray[1 -- retrieve SAXException argument.error~say(methname":" - "line="exception~getlinenumber",col="exception~getcolumnnumber":" - pp(exception~getmessage)) Hier DOM, Vortrags-/Vorlesungstitel p.19

20 "code01.rxj ": Extract Text from any XHTML Document Running the oorexx Program, 3 f:\>rexx code01_text.rxj example2.html [ [ [This is my HTML file [ [ [ [ [Important Heading [ [This [is [ the first paragraph. [ [Another Important Heading [ [Another paragraph. [ [This [is [ it. [ [  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd"> <html> <head> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.20

21 "code01.rxj ": Extract Text from any XHTML Document Some Remarks, 4 Some remarks Text can be encoded as Plain text (node type TEXT_NODE) or CDATA sections (node type CDATA_SECTION_NODE) <[!CDATA[...character-data...> Ignorable whitespace is not ignored, but treated like any whitespace A node of type TEXT_NODE will be created for it The node types used in the Java DOM parser are retrievable via the Java interface class org.w3c.dom.node To make it easy to refer to these values from oorexx, the types TEXT_NODE and CDATA_SECTION_NODE are retrieved and made available to all parts of the Rexx program by storing them in.local Hier DOM, Vortrags-/Vorlesungstitel p.21

22 "code02.rxj": List Elements in Document Order The oorexx Program (Main Program), 1 /* purpose: demonstrate how to extract the text from a xml file using DOM */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* make important constants available via.local */ clzdomnode=bsf.loadclass("org.w3c.dom.node") -- load the Java interface class.local~element_node =clzdomnode~element_node -- save field value /* now collect all text and CDATA nodes and display them */ call follownode rootnode ::requires BSF.CLS /* get the Java support */... cut... Hier DOM, Vortrags-/Vorlesungstitel p.22

23 "code02.rxj": List Elements in Document Order The oorexx Program (the oorexx Classes), 2... cut... ::requires BSF.CLS /* get the Java support */ ::routine follownode /* walks the document tree recursively */ use arg node call processnode node -- process received node if node~haschildnodes then do children=node~getchildnodes -- get NodeList loop i=0 to children~length based indexes! call follownode children~item(i) -- recurse end end ::routine processnode /* processes each node */ use arg node nodetype=node~getnodetype -- get type of node if nodetype=.element_node then say pp(node~nodename) ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler") ::method unknown /* handles "warning", "error" and "fatalerror" events */ use arg methname, argarray -- arguments from the Java SAX parser exception=argarray[1 -- retrieve SAXException argument.error~say(methname":" - "line="exception~getlinenumber",col="exception~getcolumnnumber":" - pp(exception~getmessage)) Hier DOM, Vortrags-/Vorlesungstitel p.23

24 "code02.rxj": List Elements in Document Order Running the oorexx Program, 3 f:\>rexx code02_text.rxj example2.html [html [head [title [link [body [h1 [p [span [h1 [p [p [span  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <html> <head> "DTD/xhtml1-transitional.dtd"> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.24

25 "code02.rxj": List Elements in Document Order Some Remarks, 4 A few remarks The DOM parse tree has more nodes than shown in the output! This particular program processes nodes of type ELEMENT_NODE only The node types used in the Java DOM parser are retrievable via the Java interface class org.w3c.dom.node To make it easy to refer to these values from oorexx, the type ELEMENT_NODE is retrieved and made available to all parts of the Rexx program by storing it in.local One could also use the Java infrastructure to filter only those node types one is interested in Hier DOM, Vortrags-/Vorlesungstitel p.25

26 "code03.rxj" : List Elements in Document Order #2 The oorexx Program (Main Program), 1 /* purpose: demonstrate how to extract the text from a xml file using DOM */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* make important constants available via.local */ clzdomnode=bsf.loadclass("org.w3c.dom.node") -- load the Java interface class.local~element_node =clzdomnode~element_node -- save field value /* now collect all text and CDATA nodes and display them */ call follownode rootnode, 0 ::requires BSF.CLS /* get the Java support */... cut... Hier DOM, Vortrags-/Vorlesungstitel p.26

27 "code03.rxj" : List Elements in Document Order #2 The oorexx Program (the oorexx Classes), 2... cut... ::requires BSF.CLS /* get the Java support */ ::routine follownode /* walks the document tree recursively */ use arg node, level call processnode node, level -- process received node if node~haschildnodes then do children=node~getchildnodes -- get NodeList loop i=0 to children~length based indexes! call follownode children~item(i), level+1 -- recurse end end ::routine processnode /* processes each node */ use arg node, level nodetype=node~getnodetype -- get type of node if nodetype=.element_node then say " "~copies(level) pp(node~nodename) ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler") ::method unknown /* handles "warning", "error" and "fatalerror" events */ use arg methname, argarray -- arguments from the Java SAX parser exception=argarray[1 -- retrieve SAXException argument.error~say(methname":" - "line="exception~getlinenumber",col="exception~getcolumnnumber":" - pp(exception~getmessage)) Hier DOM, Vortrags-/Vorlesungstitel p.27

28 "code03.rxj" : List Elements in Document Order #2 Running the oorexx Program, 3 f:\>rexx code03_text.rxj example2.html [html [head [title [link [body [h1 [p [span [h1 [p [p [span  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <html> <head> "DTD/xhtml1-transitional.dtd"> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.28

29 "code03.rxj" : List Elements in Document Order #2 Some Remarks, 4 A few remarks The DOM parse tree has more nodes than shown in the output! Note whitespace before first shown element This particular program processes nodes of type ELEMENT_NODE only The node types used in the Java DOM parser are retrievable via the Java interface class org.w3c.dom.node To make it easy to refer to these values from oorexx, the type ELEMENT_NODE is retrieved and made available to all parts of the Rexx program by storing it in.local One could also use the Java infrastructure to filter only those node types one is interested in Hier DOM, Vortrags-/Vorlesungstitel p.29

30 "code04.rxj" : List Elements with Text The oorexx Program (Main Program), 1 /* purpose: demonstrate how to extract the text from a xml file using DOM */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* make important constants available via.local */ clzdomnode=bsf.loadclass("org.w3c.dom.node") -- load the Java interface class.local~cdata_section_node=clzdomnode~cdata_section_node -- save field value.local~text_node =clzdomnode~text_node -- save field value.local~element_node =clzdomnode~element_node -- save field value /* now collect all text and CDATA nodes and display them */ call follownode rootnode, 0 ::requires BSF.CLS /* get the Java support */... cut... Hier DOM, Vortrags-/Vorlesungstitel p.30

31 "code04.rxj" : List Elements with Text The oorexx Program (the oorexx Classes), 2... cut... ::requires BSF.CLS /* get the Java support */ ::routine follownode /* walks the document tree recursively */ use arg node, level call processnode node, level -- process received node if node~haschildnodes then do children=node~getchildnodes -- get NodeList loop i=0 to children~length based indexes! call follownode children~item(i), level+1 -- recurse end end ::routine processnode /* processes each node */ use arg node, level nodetype=node~getnodetype -- get type of node if nodetype=.text_node nodetype=.cdata_section_node then say " "~copies(level) "-->" pp(node~getnodevalue) -- instead of getdata() else if nodetype=.element_node then say " "~copies(level) pp(node~getnodename) ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler") ::method unknown /* handles "warning", "error" and "fatalerror" events */ use arg methname, argarray -- arguments from the Java SAX parser exception=argarray[1 -- retrieve SAXException argument.error~say(methname":" - "line="exception~getlinenumber",col="exception~getcolumnnumber":" - pp(exception~getmessage)) Hier DOM, Vortrags-/Vorlesungstitel p.31

32 "code04.rxj" : List Elements with Text Running the oorexx Program, 3 f:\>rexx code04_text.rxj example2.html [html --> [ [head --> [ [title --> [This is my HTML file --> [ [link --> [ --> [ [body --> [ [h1 --> [Important Heading --> [ [p --> [This [span --> [is --> [ the first paragraph. --> [ [h1 --> [Another Important Heading --> [ [p --> [Another paragraph. --> [ [p --> [This [span --> [is --> [ it. --> [ --> [  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd"> <html> <head> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.32

33 "code04.rxj" : List Elements with Text Some Remarks, 4 A few remarks The DOM parse tree has more nodes than shown in the output! Note whitespace before first shown element This particular program processes nodes of type TEXT_NODE, CDATA_SECTION_NODE and ELEMENT_NODE only The node types used in the Java DOM parser are retrievable via the Java interface class org.w3c.dom.node To make it easy to refer to these values from oorexx, the types TEXT_NODE, CDATA_SECTION_NODE and ELEMENT_NODE are retrieved and made available to all parts of the Rexx program by storing them in.local One could also use the Java infrastructure to filter only those node types one is interested in Hier DOM, Vortrags-/Vorlesungstitel p.33

34 More Available with Java DOM Parsing Than Documented by Java! The default DOM parser coming with Java (Apache's Xerces2) is capable of more than what is documented in Oracle's JavaDocs! The W3C interface org.w3c.dom.traversal.documenttraversal, cf. documentation at javadoc/org/w3c/dom/traversal/documenttraversal.html Method createnodeiterator(...) filters nodes and returns the result as a list with the methods defined in the interface org.w3c.dom.traversal.nodeiterator for its traversal Method createtreewalker(...) filters nodes and returns the result as a tree with the methods defined in the interface org.w3c.dom.traversal.treewalker for its traversal Hier DOM, Vortrags-/Vorlesungstitel p.34

35 Using A NodeIterator to Iterate over Elements Get the Java constant field value for showing (filtering) elements using the Java interface class org.w3c.dom.traversal.nodefilter and the constant field named SHOW_ELEMENT Create a NodeIterator from the DOM parse tree and use its methods to iterate over the filtered nodes Hint Compare the following code "code05.rxj" with "code02.rxj" above Hier DOM, Vortrags-/Vorlesungstitel p.35

36 "code05.rxj": List Elements in Document Order The oorexx Program (Main Program), 1 /* purpose: demonstrate how to list the element names in document order */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* get constant value to determine node types to filter */ whattoshow=bsf.getconstant("org.w3c.dom.traversal.nodefilter", "SHOW_ELEMENT") /* create a NodeIterator with only Element nodes */ iterator=rootnode~createnodeiterator(rootnode, whattoshow,.nil,.true) /* process list of Element nodes */ node=iterator~nextnode /* get first node */ loop while node<>.nil say pp(node~getnodename) node=iterator~nextnode /* get next node */ end ::requires BSF.CLS /* get the Java support */ ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler")... as depicted above... Hier DOM, Vortrags-/Vorlesungstitel p.36

37 "code05.rxj": List Elements in Document Order Running the oorexx Program, 2 f:\>rexx code05_text.rxj example2.html [html [head [title [link [body [h1 [p [span [h1 [p [p [span  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <html> <head> "DTD/xhtml1-transitional.dtd"> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.37

38 Using A TreeWalker to Iterate over Elements Get the Java constant field value for showing (filtering) elements using the Java interface class org.w3c.dom.traversal.nodefilter and the constant field named SHOW_ELEMENT Create a TreeWalker from the DOM parse tree and use its methods to iterate over the filtered nodes Note The createtreewalker() method will filter element related nodes as well (e.g. text nodes included in an element) Hint Compare the following code "code06.rxj" with "code03.rxj" above Hier DOM, Vortrags-/Vorlesungstitel p.38

39 "code06.rxj": List Elements in Document Order The oorexx Program (Main Program), 1 /* purpose: demonstrate how to list the element names in document order */ parse arg xmlfilename /* create an instance of the JAXP DocumentBuilderFactory */ factory=bsf.loadclass("javax.xml.parsers.documentbuilderfactory")~newinstance factory~setnamespaceaware(.true) -- set desired parser to namespace aware parser=factory~newdocumentbuilder -- create the parser from the factory eh=.errorhandler~new -- create an error handler Rexx object -- wrap up the Rexx error handler as a Java object javaeh=bsfcreaterexxproxy(eh,, "org.xml.sax.errorhandler") parser~seterrorhandler(javaeh) -- set the error handler for this parser rootnode=parser~parse(xmlfilename) -- parse the file, returns root node /* get constant value to determine node types to filter */.local~show_element=bsf.getconstant("org.w3c.dom.traversal.nodefilter", "SHOW_ELEMENT") whattoshow=.show_element /* create a TreeWalker with only Element nodes */ walker=rootnode~createtreewalker(rootnode, whattoshow,.nil,.true) /* process list of Element nodes */ call walkthetree walker~firstchild, 0 ::requires BSF.CLS /* get the Java support */... cut here... Hier DOM, Vortrags-/Vorlesungstitel p.39

40 "code06.rxj": List Elements in Document Order The oorexx Program, 2... cut here... /* process list of Element nodes */ call walkthetree walker~firstchild, 0 ::requires BSF.CLS /* get the Java support */ ::routine walkthetree /* walk the tree recursively */ use arg node, level say " "~copies(level) pp(node~getnodename) -- show element name indented child=node~firstchild -- depth first do while child<>.nil -- there may be other node types coming with elements in a TreeWalker if child~getnodetype=.show_element then -- make sure only element nodes call walkthetree child, level+1 -- recurse, increase level child=child~nextsibling -- breadth next end ::class ErrorHandler -- a Rexx error handler ("org.xml.sax.errorhandler")... as depicted above... Hier DOM, Vortrags-/Vorlesungstitel p.40

41 "code05.rxj": List Elements in Document Order Running the oorexx Program, 2 f:\>rexx code06_text.rxj example2.html [html [head [title [link [body [h1 [p [span [h1 [p [p [span  <!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" <html> <head> "DTD/xhtml1-transitional.dtd"> <title>this is my HTML file</title> <link rel="stylesheet" type="text/css" href="example2.css"/> </head> <body> <h1>important Heading</h1> <p>this <span class="verb">is</span> the first paragraph.</p> <h1>another Important Heading</h1> <p id="xyz1">another paragraph.</p> <p id="a9876">this <span class="verb">is</span> it.</p> </body> </html> Hier DOM, Vortrags-/Vorlesungstitel p.41

42 Roundup Parsing any XML encoded document possible Using BSF4ooRexx Exploiting Java's functionality for parsing XML documents DOM parsing DOM parser first creates parse tree One may directly walk the DOM parse tree or use the traversal methods to filter the DOM parse tree into a NodeIterator or TreeWalker Rather easy, needs enough memory for the parse tree Easy to exploit from oorexx! Hier DOM, Vortrags-/Vorlesungstitel p.42

43 Further Information World Wide Web Consortium ("W3C") (HTML, XHTML2) (Doctype links) DOM specific URLs (as of ) (current project home) (book) (Java 7 docs) W3C: Apache Xerces2: Sample files installed with BSF4ooRexx bsf4oorexx/samples/dom Hier DOM, Vortrags-/Vorlesungstitel p.43

Processing XML Documents with SAX Using BSF4ooRexx

MIS Department Processing XML Documents with SAX Using BSF4ooRexx 2013 International Rexx Symposium RTP, North Carolina Prof. Dr. Rony G. Flatscher Vienna University of Economics and Business Administration