XML/Input: Difference between revisions

Content added Content deleted

Inline

Revision as of 20:23, 18 May 2018

Given the following XML fragment, extract the list of student names using whatever means desired. If the only viable method is to use XPath, refer the reader to the task XML and XPath.

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students></lang>

Expected Output

April
Bob
Chad
Dave
Émily

8th

\ Load the XML text into the var 'x': quote * <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>

xml:parse var, x

\ print only xml nodes which have a tag of 'Student' and whose attributes are not empty

.xml \ xml --

xml:tag@ "Student" s:cmp if drop ;; then xml:attrs null? if drop ;; then

"Name" m:@ . cr drop ;

\ Iterate over the XML document in the var 'x' x @ ' .xml xml:each bye </lang>

Output:

April
Bob
Chad
Dave
Émily

Aikido

Put the XML in the file called t.xml <lang aikido> import xml

var s = openin ("t.xml") var tree = XML.parseStream (s)

foreach node tree {

   if (node.name == "Students") {
       foreach studentnode node {
           if (studentnode.name == "Student") {
               println (studentnode.getAttribute ("Name"))
           }
       }
   }

}

</lang> The output is (Aikido doesn't support unicode rendering):

April
Bob
Chad
Dave
Émily

AutoHotkey

simply using regular expressions <lang AutoHotkey>students = ( <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> )

quote = " ; " pos = 1 while, pos := RegExMatch(students, "Name=.(\w+)" . quote . "\sGender" , name, pos + 1) names .= name1 . "`n"

msgbox % names</lang>

The following code extracts the value of the property "Name" from every Student tag. It does not handle the &#CODE;; this can be left to others: a way to cope with it fastly, is to output a very simple HTML structure, so that the interpretation is left to an HTML reader/browser.

<lang awk>function parse_buf() {

   if ( match(buffer, /<Student[ \t]+[^>]*Name[ \t]*=[ \t]*"([^"]*)"/, mt) != 0 ) {
     students[mt[1]] = 1
   }
   buffer = ""

}

BEGIN {

 FS=""
 mode = 0
 buffer = ""
 li = 1

}

mode==1 {

 for(i=1; i <= NF; i++) {
   buffer = buffer $i
   if ( $i == ">" ) {
     mode = 0;
     break;
   }
 }
 if ( mode == 0 ) {
   li = i
 } else {
   li = 1
 }
 # let us process the buffer if "complete"
 if ( mode == 0 ) {
   parse_buf()
 }

}

mode==0 {

 for(i=li; i <= NF; i++) {
   if ( $i == "<" ) {
     mode = 1
     break;
   }
 }
 for(j=i; i <= NF; i++) {
   buffer = buffer $i
   if ( $i == ">" ) {
     mode = 0
     parse_buf()
   }
 }
 li = 1

}

END {

 for(k in students) {
   print k
 }

}</lang> Using getXML.awk written by Jan Weber, one could do this:

Works with: gawk

or

Works with: nawk

<lang awk>awk -f getXML.awk sample.xml | awk '

   $1 == "TAG"                 {tag = $2}
   tag == "Student" && /Name=/ {print substr($0, index($0, "=") + 1)}

'</lang> Using xmlparser.awk by Steve Coile, one can do this:

Works with: gawk

<lang awk>gawk -f xmlparser.awk sample.xml | awk '

   $1 == "begin"                                         {tag = $2}
   $1 == "attrib"                                        {attrib = $2}
   $1 == "value" && tag == "STUDENT" && attrib == "name" {print $2}

'</lang>

Both of these produce this output

April
Bob
Chad
Dave
&#x00C9;mily

Works with: XMLgawk

Scripts in AWK are often one-liners. This one-liner implementation searches for Student tags and then displays the contents of their Name attribute. The following line is meant to be typed in on the command line of a Unix shell or an MS-DOS command window.

gawk -lxml 'XMLSTARTELEM == "Student" {print XMLATTR["Name"]}' rosetta.xml

Output:

April
Bob
Chad
Dave
Émily

BBC BASIC

Works with: BBC BASIC for Windows

<lang bbcbasic> INSTALL @lib$+"XMLLIB"

     xmlfile$ = "C:\students.xml"
     PROC_initXML(xmlobj{}, xmlfile$)
     
     level% = FN_skipTo(xmlobj{}, "Students", 0)
     IF level%=0 ERROR 100, "Students not found"
     
     REPEAT
       IF FN_isTag(xmlobj{}) THEN
         tag$ = FN_nextToken(xmlobj{})
         IF LEFT$(tag$, 8) = "<Student" THEN
           np% = INSTR(tag$, "Name")
           IF np% THEN PRINT FN_repEnt(EVAL(MID$(tag$, np%+5)))
         ENDIF
       ELSE
         dummy$ = FN_nextToken(xmlobj{})
       ENDIF
     UNTIL FN_getLevel(xmlobj{}) < level%
     
     PROC_exitXML(xmlobj{})</lang>

Output:

April
Bob
Chad
Dave
Émily

Bracmat

The get function can read markup into a native datastructure, which can be analysed using pattern matching. The read datastructure is a flat list of tags and text fragments. For proper nesting of elements extra code would have to be written, but in this simple task that is not necessary. On the downside, the pattern must both handle empty tags (the (? (Name.?name) ?, pattern) and open tags (the ? (Name.?name) ? pattern). Reading input from a file: <lang bracmat>( :?names & ( get$("students.xml",X,ML)

   :   ?
       ( ( Student
         .   (? (Name.?name) ?,)
           | ? (Name.?name) ?
         )
       & !names !name:?names
       & ~
       )
       ?
 | !names
 )

)</lang>

Alternative solution, reading input from memory: <lang bracmat>( :?names & ( get

     $ ( "<Students>
 <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
 <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />
 <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />
 <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">
   <Pet Type=\"dog\" Name=\"Rover\" />
 </Student>
 <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />

</Students>"

       , MEM
       , X
       , ML
       )
   :   ?
       ( ( Student
         .   (? (Name.?name) ?,)
           | ? (Name.?name) ?
         )
       & !names !name:?names
       & ~
       )
       ?
 | !names
 )

)</lang> Output:

April Bob Chad Dave Émily

C

Library: LibXML

Uses: libxml (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/libxml/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

Uses: C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

<lang c>#include <stdio.h>

include <stdlib.h>
include <string.h>
include <libxml/parser.h>
include <libxml/tree.h>

static void print_names(xmlNode *node) {

 xmlNode *cur_node = NULL;
 for (cur_node = node; cur_node; cur_node = cur_node->next) {
   if (cur_node->type == XML_ELEMENT_NODE) {
     if ( strcmp(cur_node->name, "Student") == 0 ) {

xmlAttr *prop = NULL; if ( (prop = xmlHasProp(cur_node, "Name")) != NULL ) { printf("%s\n", prop->children->content);

}

     }
   }
   print_names(cur_node->children);
 }

}

const char *buffer =

 "<Students>\n"
 "  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
 "  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n"
 "  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n"
 "  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n"
 "    <Pet Type=\"dog\" Name=\"Rover\" />\n"
 "  </Student>\n"
 "  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />\n"
 "</Students>\n";

int main() {

 xmlDoc *doc = NULL;
 xmlNode *root = NULL;

 doc = xmlReadMemory(buffer, strlen(buffer), NULL, NULL, 0);
 if ( doc != NULL ) {
   root = xmlDocGetRootElement(doc);
   print_names(root);
   xmlFreeDoc(doc);
 }
 xmlCleanupParser();
 return 0;

}</lang>

C++

Library: Qt

Uses: Qt (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/Qt/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

<lang cpp>/* Using the Qt library's XML parser.

/

include <iostream>

include <QDomDocument>
include <QObject>

int main() {

   QDomDocument doc;

   doc.setContent(
      QObject::tr(
         "<Students>\n"
         "<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
         "<Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n"
         "<Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n"
         "<Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n"
         "<Pet Type=\"dog\" Name=\"Rover\" />\n"
         "</Student>\n"
         "<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />\n"
         "</Students>"));
   
   QDomElement n = doc.documentElement().firstChildElement("Student");
   while(!n.isNull()) {
       std::cout << qPrintable(n.attribute("Name")) << std::endl;
       n = n.nextSiblingElement();
   }
   return 0;

}</lang>

C#

<lang csharp> class Program {

   static void Main(string[] args)
   {   
       XDocument xmlDoc = XDocument.Load("XMLFile1.xml");
       var query = from p in xmlDoc.Descendants("Student")
                   select p.Attribute("Name");

       foreach (var item in query)
       {
           Console.WriteLine(item.Value);
       }
       Console.ReadLine();
   }

} </lang>

Caché ObjectScript

<lang cos>Class XML.Students [ Abstract ] {

XData XMLData { <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> }

ClassMethod Output() As %Status {

  // get xml stream from the 'XData' block contained in this class and parse
  Set xdata=##class(%Dictionary.CompiledXData).%OpenId($this_"||XMLData",, .sc)
  If $$$ISERR(sc) Quit sc
  Set sc=##class(%XML.TextReader).ParseStream(xdata.Data, .hdlr)
  If $$$ISERR(sc) Quit sc
  
  // iterate through document, node by node
  While hdlr.Read() {

If hdlr.Path="/Students/Student", hdlr.MoveToAttributeName("Name") { Write hdlr.Value, ! }

  }
  
  // finished
  Quit $$$OK

}

}</lang>

Examples:

USER>Do ##class(XML.Students).Output()
April
Bob
Chad
Dave
Émily

Clojure

Uses: java.io (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/java.io/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

Uses: clojure.xml (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/clojure.xml/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

This version uses the standard Clojure function xml-seq' <lang lisp> (import '(java.io ByteArrayInputStream)) (use 'clojure.xml) ; defines 'parse

(def xml-text "<Students>

 <Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
 <Student Name='Bob' Gender='M'  DateOfBirth='1990-03-04' />
 <Student Name='Chad' Gender='M'  DateOfBirth='1991-05-06' />
 <Student Name='Dave' Gender='M'  DateOfBirth='1992-07-08'>
   <Pet Type='dog' Name='Rover' />
 </Student>
 <Student DateOfBirth='1993-09-10' Gender='F' Name='Émily' />

</Students>")

(def students (parse (-> xml-text .getBytes ByteArrayInputStream.))) </lang>

The parse produces a data structure where each element is represented as a map with :tag, :attrs, and :content keys. Thus the "April" element becomes {:tag :Student, :attrs {:Name "April", :Gender "F", :DateOfBirth "1989-01-02"}, :content nil}. xml-seq produces a sequence of such nodes by walking the resulting tree.

<lang lisp> (doseq [{:keys [tag attrs]} (xml-seq students)]

 (if (= :Student tag)
   (println (:Name attrs))))

</lang>

Common Lisp

Library: Closure XML

<lang lisp>(defparameter *xml-blob* "<Students>

 <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
 <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />
 <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />
 <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">
   <Pet Type=\"dog\" Name=\"Rover\" />
 </Student>
 <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />

</Students>")

(let* ((document (cxml:parse *xml-blob* (cxml-dom:make-dom-builder)))

      (students (dom:item (dom:get-elements-by-tag-name document "Students") 0))
      (student-names '()))
 (dom:do-node-list (child (dom:child-nodes students) (nreverse student-names))
   (when (dom:element-p child)
     (push (dom:get-attribute child "Name") student-names))))</lang>

produces<lang lisp>("April" "Bob" "Chad" "Dave" "Émily")</lang>

D

Library: KXML

<lang d>import kxml.xml; char[]xmlinput = "<Students>

 <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
 <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />
 <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />
 <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">
   <Pet Type=\"dog\" Name=\"Rover\" />
 </Student>
 <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />

</Students>";

void main() {

       auto root = readDocument(xmlinput);
       foreach(students;root.getChildren) if (!students.isCData && students.getName == "Students") {
               // now look for student subnodes
               foreach(student;students.getChildren) if (!student.isCData && student.getName == "Student") {
                       // we found a student!
                       std.stdio.writefln("%s",student.getAttribute("Name"));
               }
               // we only want one, so break out of the loop once we find a match
               break;
       }

}</lang>

Delphi

<lang Delphi> //You need to use these units uses

 SysUtils,
 Dialogs,
 XMLIntf,
 XMLDoc;

//..............................................

//This function process the XML function GetStudents(aXMLInput: string): string; var

 XMLDoc: IXMLDocument;
 i: Integer;

begin

 //Creating the TXMLDocument instance
 XMLDoc:= TXMLDocument.Create(nil);

 //Loading8 the XML string
 XMLDoc.LoadFromXML(aXMLInput);

 //Parsing the xml document
 for i:=0 to XMLDoc.DocumentElement.ChildNodes.Count - 1 do
   Result:= Result + XMLDoc.DocumentElement.ChildNodes.Get(i).GetAttributeNS('Name', ) + #13#10;

 //Removing the trailing #13#10 characters
 Result:= Trim(Result);

end;

//..............................................

//Consuming code example (fragment) var

 XMLInput: string;

begin

 XMLInput:= '<Students>' +
               '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
               '<Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />' +
               '<Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />' +
               '<Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">' +
                 '<Pet Type="dog" Name="Rover" />' +
               '</Student>' +
               '<Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />'+
             '</Students>';
 Showmessage(GetStudents(XMLInput));

end; </lang>

Erlang

<lang Erlang> -module( xml_input ).

-export( [task/0] ).

-include_lib("xmerl/include/xmerl.hrl").

task() ->

   {XML, []} = xmerl_scan:string( xml(), [{encoding, "iso-10646-utf-1"}] ),
   Attributes = lists:flatten( [X || #xmlElement{name='Student', attributes=X} <- XML#xmlElement.content] ),
   [io:fwrite("~s~n", [X]) || #xmlAttribute{name='Name', value=X} <- Attributes].

xml() -> "<Students>

 <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
 <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />
 <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />
 <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">
   <Pet Type=\"dog\" Name=\"Rover\" />
 </Student>
 <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />

</Students>". </lang>

Output:

38> xml_input:task().
April
Bob
Chad
Dave
Émily

F#

<lang fsharp>open System.IO open System.Xml open System.Xml.Linq

let xn s = XName.Get(s)

let xd = XDocument.Load(new StringReader(""" <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> """)) // "

[<EntryPoint>] let main argv =

   let students = xd.Descendants <| xn "Student"
   let names = students.Attributes <| xn "Name"
   Seq.iter ((fun (a : XAttribute) ->  a.Value) >> printfn "%s") names
   0</lang>

Factor

<lang factor>USING: io sequences xml xml.data xml.traversal ;

print-student-names ( string -- )

   string>xml "Student" tags-named [ "Name" attr print ] each ;

"""<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>""" print-student-names</lang>

Fantom

<lang fantom> using xml

class XmlInput {

 public static Void main () 
 {
   // create the XML parser
   parser := XParser(File("sample-xml.xml".toUri).in)
   // parse the document, creating an XML document
   XDoc doc := parser.parseDoc
   // walk through each child element from the root of the document
   doc.root.elems.each |elem|
   {
     // printing the Name attribute of all Students
     if (elem.name == "Student") { echo (elem.get("Name")) }
   }
 }

} </lang>

Forth

Library: Forth Foundation Library

<lang forth>include ffl/est.fs include ffl/str.fs include ffl/xis.fs

\ Build input string str-create xmlstr

x+ xmlstr str-append-string ;

s\" <Students>\n" x+ s\" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n" x+ s\" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n" x+ s\" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n" x+ s\" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n" x+ s\" <Pet Type=\"dog\" Name=\"Rover\" />\n" x+ s\" </Student>\n" x+ s\" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />\n" x+ s\" </Students>\n" x+

\ Setup xml parser xis-create xmlparser xmlstr str-get xmlparser xis-set-string

\ Parse the xml

xmlparse

 BEGIN
   xmlparser xis-read  dup xis.error <> over xis.done <> AND
 WHILE
   dup xis.start-tag = over xis.empty-element = OR IF
     drop
     s" Student" compare 0= IF
       0 ?DO
         2swap s" Name" compare 0= IF
           type cr
         ELSE
           2drop
         THEN
       LOOP
     ELSE
       xis+remove-attribute-parameters
     THEN
   ELSE
     xis+remove-read-parameters
   THEN
 REPEAT
 drop

xmlparse</lang>

Fortran

tixi library

Uses tixi library (+ LibXML, curl as dependencies)

<lang fortran> program tixi_rosetta

 use tixi
 implicit none
 integer :: i
 character (len=100) :: xml_file_name 
 integer :: handle
 integer :: error	
 character(len=100) :: name, xml_attr
 xml_file_name = 'rosetta.xml'

 call tixi_open_document( xml_file_name, handle, error )
 i = 1
 do 
     xml_attr = '/Students/Student['//int2char(i)//']'
     call tixi_get_text_attribute( handle, xml_attr,'Name', name, error )      
     if(error /= 0) exit
     write(*,*) name
     i = i + 1
 enddo

 call tixi_close_document( handle, error )

 contains

 function int2char(i) result(res)
   character(:),allocatable :: res
   integer,intent(in) :: i
   character(range(i)+2) :: tmp
   write(tmp,'(i0)') i
   res = trim(tmp)
 end function int2char

end program tixi_rosetta </lang>

Compile

gfortran tixi_rosetta.f90 tixi.f90 -L../tixi/tixi-master/build/lib/ -lTIXI -lTIXIf  -lxml2 -lcurl -o tixi_rosetta.x

Output

./tixi_rosetta.x 
 April                                                                                               
 Bob                                                                                                 
 Chad                                                                                                
 Dave                                                                                                
 Émily

Fortran XML library (FoX)

Uses FoX

<lang fortran> program fox_rosetta

  use FoX_dom
  use FoX_sax
  implicit none
  integer :: i
  type(Node), pointer :: doc => null()
  type(Node), pointer :: p1 => null()
  type(Node), pointer :: p2 => null()
  type(NodeList), pointer :: pointList => null()
  character(len=100) :: name

  doc => parseFile("rosetta.xml")
  if(.not. associated(doc)) stop "error doc"

  p1 => item(getElementsByTagName(doc, "Students"), 0)
  if(.not. associated(p1)) stop "error p1"
  ! write(*,*) getNodeName(p1)

  pointList => getElementsByTagname(p1, "Student")
  ! write(*,*) getLength(pointList), "Student elements"

  do i = 0, getLength(pointList) - 1
     p2 => item(pointList, i)
     call extractDataAttribute(p2, "Name", name)
     write(*,*) name
  enddo

  call destroy(doc)

end program fox_rosetta </lang>

Output

./fox_rosetta.x 
 April                                                                                               
 Bob                                                                                                 
 Chad                                                                                                
 Dave                                                                                                
 &mily

Go

Go's xml.Unmarshal uses reflection to fill in data-structures recursively. <lang go>package main

import (

   "encoding/xml"
   "fmt"

)

const XML_Data = ` <Students>

  <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
  <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
  <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
  <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
     <Pet Type="dog" Name="Rover" />
  </Student>
  <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> `

type Students struct {

   Student []Student

}

type Student struct {

   Name string `xml:",attr"`
   //  Gender      string `xml:",attr"`
   //  DateOfBirth string `xml:",attr"`
   //  Pets        []Pet  `xml:"Pet"`

}

type Pet struct {

   Type string `xml:",attr"`
   Name string `xml:",attr"`

}

// xml.Unmarshal quietly skips well formed input with no corresponding // member in the output data structure. With Gender, DateOfBirth, and // Pets commented out of the Student struct, as above, Student contains // only Name, and this is the only value extracted from the input XML_Data. func main() {

   var data Students
   err := xml.Unmarshal([]byte(XML_Data), &data)
   if err != nil {
       fmt.Println(err)
       return
   }
   for _, s := range data.Student {
       fmt.Println(s.Name)
   }

}</lang>

Output:

April
Bob
Chad
Dave
Émily

Groovy

<lang groovy>def input = """<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>"""

def students = new XmlParser().parseText(input) students.each { println it.'@Name' }</lang>

Haskell

<lang haskell>import Data.Maybe import Text.XML.Light

students="<Students>"++

       " <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"++
       " <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />"++
       " <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\"/>"++
       " <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">"++
       "   <Pet Type=\"dog\" Name=\"Rover\" />  </Student>"++
       " <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />"++
       "</Students>"

xmlRead elm name = mapM_ putStrLn

     . concatMap (map (fromJust.findAttr (unqual name)).filterElementsName (== unqual elm))
     . onlyElems.  parseXML</lang>

Show names: <lang haskell>*Main> xmlRead "Student" "Name" students April Bob Chad Dave Émily</lang>

HicEst

<lang HicEst>CHARACTER in*1000, out*100

READ(ClipBoard) in EDIT(Text=in, SPR='"', Right='<Student', Right='Name=', Word=1, WordEnd, APpendTo=out, DO)</lang>

out is returned as:
April  Bob  Chad  Dave  Émily

J

J's system includes several XML processing libraries. This task is probably best addressed using XPath (this is the type of problem XPath was designed to solve), but the task description implicitly discourages that method. So we can use the SAX library instead:

<lang j>load'xml/sax'

saxclass 'Students' startElement =: ([: smoutput 'Name' getAttribute~ [)^:('Student'-:]) cocurrent'base'

process_Students_ XML</lang>

April
Bob
Chad
Dave
Émily

and the definition of the variable XML: <lang j>XML=: noun define <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> )</lang>

Java

Uses: java.io (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/java.io/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

Uses: org.xml.sax (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/org.xml.sax/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

<lang java>import java.io.IOException; import java.io.StringReader; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import org.xml.sax.XMLReader; import org.xml.sax.helpers.DefaultHandler; import org.xml.sax.helpers.XMLReaderFactory;

public class StudentHandler extends DefaultHandler {

 public static void main(String[] args)throws Exception{
   String xml = "<Students>\n"+
   "<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"+
   "<Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n"+
   "<Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n"+
   "<Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n"+
   "  <Pet Type=\"dog\" Name=\"Rover\" />\n"+
   "</Student>\n"+
   "<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />\n"+
   "</Students>";
   StudentHandler handler = new StudentHandler();
   handler.parse(new InputSource(new StringReader(xml)));
 }

 public void parse(InputSource src) throws SAXException, IOException {

XMLReader parser = XMLReaderFactory.createXMLReader();

   parser.setContentHandler(this);
   parser.parse(src);
 }

 @Override
 public void characters(char[] ch, int start, int length) throws SAXException {
   //if there were text as part of the elements, we would deal with it here
   //by adding it to a StringBuffer, but we don't have to for this task
   super.characters(ch, start, length);
 }

 @Override
 public void endElement(String uri, String localName, String qName) throws SAXException {
   //this is where we would get the info from the StringBuffer if we had to,
   //but all we need is attributes
   super.endElement(uri, localName, qName);
 }

 @Override
 public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
   if(qName.equals("Student")){
     System.out.println(attributes.getValue("Name"));
   }
 }

}</lang>

JavaScript

Browser version

This version tested against Chrome 37, Firefox 32, and IE 11: <lang JavaScript> var xmlstr = '<Students>' +

 '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
 '<Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />' +
 '<Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />' +
 '<Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">' +
   '<Pet Type="dog" Name="Rover" />' +
 '</Student>' +
 '<Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />' +

'</Students>';

if (window.DOMParser)

 {
 parser=new DOMParser();
 xmlDoc=parser.parseFromString(xmlstr,"text/xml");
 }

else // Internet Explorer

 {
 xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
 xmlDoc.async=false;
 xmlDoc.loadXML(xmlstr); 
 }

var students=xmlDoc.getElementsByTagName('Student'); for(var e=0; e<=students.length-1; e++) {

 console.log(students[e].attributes.Name.value);

} </lang>

Works with: Mozilla Firefox version 32

Node.js version

<lang JavaScript> var parseString = require('xml2js').parseString; var xmlstr = '<Students>' +

 '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
 '<Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />' +
 '<Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />' +
 '<Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">' +
   '<Pet Type="dog" Name="Rover" />' +
 '</Student>' +
 '<Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />' +

'</Students>';

parseString(xmlstr, function (err, result) {

  if (!err) {
     result.Students.Student.forEach( function(student) {
        console.log(student.$.Name);
     } );
  }

}); </lang>

E4X version

Alternatively, use the E4X featureset (currently only in Firefox): <lang JavaScript> var xmlstr = '<Students>' +

 '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
 '<Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />' +
 '<Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />' +
 '<Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">' +
   '<Pet Type="dog" Name="Rover" />' +
 '</Student>' +
 '<Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />' +

'</Students>'; var xml = XML(xmlstr); var list = xml.Student.@Name; var output = ; for (var i = 0; i < list.length(); i++) {

 if (i > 0) {
   output += ', ';
 }
 output += list[i];

}

alert(output); </lang>

Julia

Works with: Julia version 0.6

<lang julia>using LightXML

let docstr = """<Students>

     <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
     <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
     <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
     <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
       <Pet Type="dog" Name="Rover" />
     </Student>
     <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />
   </Students>"""

   doc = parse_string(docstr)
   xroot = root(doc)
   for elem in xroot["Student"]
       println(attribute(elem, "Name"))
   end

end</lang>

Output:

April
Bob
Chad
Dave
Émily

Kotlin

As this is just a small XML document, the DOM parser has been used rather than the SAX parser: <lang scala>// version 1.1.3

import javax.xml.parsers.DocumentBuilderFactory import org.xml.sax.InputSource import java.io.StringReader import org.w3c.dom.Node import org.w3c.dom.Element

val xml = """ <Students>

   <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
   <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
   <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
   <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
       <Pet Type="dog" Name="Rover" />
   </Student>
   <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> """

fun main(args: Array<String>) {

   val dbFactory = DocumentBuilderFactory.newInstance()
   val dBuilder  = dbFactory.newDocumentBuilder()
   val xmlInput = InputSource(StringReader(xml))
   val doc = dBuilder.parse(xmlInput)
   val nList = doc.getElementsByTagName("Student")
   for (i in 0 until nList.length) {
       val node = nList.item(i)
       if (node.nodeType == Node.ELEMENT_NODE) {
           val element = node as Element
           val name = element.getAttribute("Name")
           println(name)
       }
   }

}</lang>

Output:

April
Bob
Chad
Dave
Émily

Lasso

Task calls for a result not using Xpaths. Thus two examples shown. First uses Xpath, second uses regular expression. <lang Lasso>// makes extracting attribute values easier define xml_attrmap(in::xml_namedNodeMap_attr) => { local(out = map) with attr in #in do #out->insert(#attr->name = #attr->value) return #out }

local( text = '<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> ', xml = xml(#text) )

local( students = #xml -> extract('//Student'), names = array ) with student in #students do { #names -> insert(xml_attrmap(#student -> attributes) -> find('Name')) }

names -> join('
')

</lang> <lang Lasso>// not using XML or Xpath

'

local( regexp = regexp(-find = `<Student.*?Name="(.*?)"`, -input = #text, -ignoreCase), names = array )

while( #regexp -> find) => { #names -> insert(#regexp -> matchstring(1)) }

names -> join('
')</lang>

Output:

April
Bob
Chad
Dave
Émily
-----------
April
Bob
Chad
Dave
Émily

Lingo

<lang lingo>q = QUOTE r = RETURN xml = "<Students>"&r&\ " <Student Name="&q&"April"&q&" Gender="&q&"F"&q&" DateOfBirth="&q&"1989-01-02"&q&" />"&r&\ " <Student Name="&q&"Bob"&q&" Gender="&q&"M"&q&" DateOfBirth="&q&"1990-03-04"&q&" />"&r&\ " <Student Name="&q&"Chad"&q&" Gender="&q&"M"&q&" DateOfBirth="&q&"1991-05-06"&q&" />"&r&\ " <Student Name="&q&"Dave"&q&" Gender="&q&"M"&q&" DateOfBirth="&q&"1992-07-08"&q&">"&r&\ " <Pet Type="&q&"dog"&q&" Name="&q&"Rover"&q&" />"&r&\ " </Student>"&r&\ " <Student DateOfBirth="&q&"1993-09-10"&q&" Gender="&q&"F"&q&" Name="&q&"Émily"&q&" />"&r&\ "</Students>"

parser = xtra("xmlparser").new() parser.parseString(xml) res = parser.makePropList() repeat with c in res.child

 put c.attributes.name

end repeat</lang>

Output:

-- "April"
-- "Bob"
-- "Chad"
-- "Dave"
-- "Émily"

LiveCode

Put the XML text in a text field called FieldXML for this exercise. <lang LiveCode>put revXMLCreateTree(fld "FieldXML",true,true,false) into currTree put revXMLAttributeValues(currTree,"Students","Student","Name",return,-1)</lang>

Lua

Requires LuaExpat <lang lua> require 'lxp' data = [[<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>]]

p = lxp.new({StartElement = function (parser, name, attr) if name == 'Student' and attr.Name then print(attr.Name) end end})

p:parse(data) p:close() </lang> Output:

April 
Bob 
Chad 
Dave 
Émily

Mathematica

<lang Mathematica>Column[Cases[Import["test.xml","XML"],Rule["Name", n_ ] -> n,Infinity]]</lang> Output:

April 
Bob 
Chad 
Dave 
Émily

Matlab

<lang Matlab> RootXML = com.mathworks.xml.XMLUtils.createDocument('Students'); docRootNode = RootXML.getDocumentElement; thisElement = RootXML.createElement('Student'); thisElement.setAttribute('Name','April') thisElement.setAttribute('Gender','F') thisElement.setAttribute('DateOfBirth','1989-01-02') docRootNode.appendChild(thisElement); thisElement = RootXML.createElement('Student'); thisElement.setAttribute('Name','Bob') thisElement.setAttribute('Gender','M') thisElement.setAttribute('DateOfBirth','1990-03-04') docRootNode.appendChild(thisElement); thisElement = RootXML.createElement('Student'); thisElement.setAttribute('Name','Chad') thisElement.setAttribute('Gender','M') thisElement.setAttribute('DateOfBirth','1991-05-06') docRootNode.appendChild(thisElement); thisElement = RootXML.createElement('Student'); thisElement.setAttribute('Name','Dave') thisElement.setAttribute('Gender','M') thisElement.setAttribute('DateOfBirth','1992-07-08') node = RootXML.createElement('Pet'); node.setAttribute('Type','dog') node.setAttribute('name','Rover') thisElement.appendChild(node); docRootNode.appendChild(thisElement); thisElement = RootXML.createElement('Student'); thisElement.setAttribute('Name','Émily') thisElement.setAttribute('Gender','F') thisElement.setAttribute('DateOfBirth','1993-09-10') docRootNode.appendChild(thisElement); clearvars -except RootXML

for I=0:1:RootXML.getElementsByTagName('Student').item(0).getAttributes.getLength-1

   if strcmp(RootXML.getElementsByTagName('Student').item(0).getAttributes.item(I).getName,'Name')
       tag=I;
       break
   end

end

for I=0:1:RootXML.getElementsByTagName('Student').getLength-1

   disp(RootXML.getElementsByTagName('Student').item(I).getAttributes.item(tag).getValue)

end </lang> Output:

April 
Bob 
Chad 
Dave 
Émily

newLISP

<lang newlisp> (set 'xml-input "<Students>

 <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
 <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />
 <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />
 <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">
   <Pet Type=\"dog\" Name=\"Rover\" />
 </Student>
 <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />

</Students>")

(set 'sexp (xml-parse xml-input))

(dolist (x (ref-all "Name" sexp)) (if (= (length x) 6) (println (last (sexp (chop x)))))) </lang>

Output:

April 
Bob 
Chad 
Dave 
Émily

Nim

<lang nim>import xmlparser, xmltree, streams

let doc = newStringStream """<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>"""

for i in doc.parseXml.findAll "Student":

 echo i.attr "Name"</lang>

Output:

April
Bob
Chad
Dave
Émily

Objeck

<lang objeck> use XML;

bundle Default {

 class Test {
   function : Main(args : String[]) ~ Nil {
     in := String->New();
     in->Append("<Students>");
     in->Append("<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />");
     in->Append("<Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />");
     in->Append("<Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />");
     in->Append("<Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">");
     in->Append("<Pet Type=\"dog\" Name=\"Rover\" />");
     in->Append("</Student>");
     in->Append("<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" /></Students>");
   
     parser := XmlParser->New(in);
     if(parser->Parse()) {
       root := parser->GetRoot();
       children := root->GetChildren("Student");
       each(i : children) {
         child : XMLElement := children->Get(i)->As(XMLElement);
         XMLElement->DecodeString(child->GetAttribute("Name"))->PrintLine();
       };
     };
   }
 }

} </lang>

OCaml

from the toplevel using the library xml-light: <lang ocaml># #directory "+xml-light" (* or maybe "+site-lib/xml-light" *) ;;

#load "xml-light.cma" ;;

let x = Xml.parse_string "

 <Students>
   <Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
   <Student Name='Bob' Gender='M'  DateOfBirth='1990-03-04' />
   <Student Name='Chad' Gender='M'  DateOfBirth='1991-05-06' />
   <Student Name='Dave' Gender='M'  DateOfBirth='1992-07-08'>
     <Pet Type='dog' Name='Rover' />
   </Student>
   <Student DateOfBirth='1993-09-10' Gender='F' Name='Émily' />
 </Students>"
 in
 Xml.iter (function
   Xml.Element ("Student", attrs, _) ->
      List.iter (function ("Name", name) -> print_endline name | _ -> ()) attrs
 | _ -> ()) x
 ;;

April Bob Chad Dave Émily - : unit = ()</lang>

Another solution using the library xmlm: <lang ocaml>#directory "+xmlm"

load "xmlm.cmo"

open Xmlm

let str = "

 <Students>
   <Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
   <Student Name='Bob'   Gender='M' DateOfBirth='1990-03-04' />
   <Student Name='Chad'  Gender='M' DateOfBirth='1991-05-06' />
   <Student Name='Dave'  Gender='M' DateOfBirth='1992-07-08'>
     <Pet Type='dog' Name='Rover' />
   </Student>
   <Student DateOfBirth='1993-09-10' Gender='F' Name='Émily' />
 </Students>"

let xi = make_input(`String(0, str))

let () =

 while not(eoi xi) do
   match Xmlm.input xi with
   | `El_start ((_, "Student"), attrs) ->
       List.iter (function ((_, "Name"), name) -> print_endline name | _ -> ()) attrs
   | _ -> ()
 done</lang>

using the ocaml expat wrapper:

<lang ocaml>open Expat

let xml_str = "

 <Students>
   <Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
   <Student Name='Bob'   Gender='M' DateOfBirth='1990-03-04' />
   <Student Name='Chad'  Gender='M' DateOfBirth='1991-05-06' />
   <Student Name='Dave'  Gender='M' DateOfBirth='1992-07-08'>
     <Pet Type='dog' Name='Rover' />
   </Student>
   <Student DateOfBirth='1993-09-10' Gender='F' Name='Émily' />
 </Students>"

let () =

 let p = parser_create None in
 set_start_element_handler p
   (fun tag attrs ->
      if tag = "Student" then
        List.iter (function ("Name", name) -> print_endline name | _ -> ()) attrs
   );
 parse p xml_str;
 final p;</lang>

OpenEdge/Progress

The following example uses the X-DOCUMENT DOM parser. For larger documents the SAX parser is recommended.

<lang progress> DEF VAR lcc AS LONGCHAR. DEF VAR hxdoc AS HANDLE. DEF VAR hxstudents AS HANDLE. DEF VAR hxstudent AS HANDLE. DEF VAR hxname AS HANDLE. DEF VAR ii AS INTEGER EXTENT 2. DEF VAR cstudents AS CHARACTER.

lcc = '<Students>'

     +  '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />'
     +  '<Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />'
     +  '<Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />'
     +  '<Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">'
     +  '<Pet Type="dog" Name="Rover" />'
     +  '</Student>'
     +  '<Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />'
     +  '</Students>'.

CREATE X-DOCUMENT hxdoc. hxdoc:LOAD( 'LONGCHAR', lcc, FALSE ).

DO ii[1] = 1 TO hxdoc:NUM-CHILDREN:

  CREATE X-NODEREF hxstudents.
  hxdoc:GET-CHILD( hxstudents, ii[1] ).
  IF hxstudents:NAME = 'Students' THEN DO ii[2] = 1 TO hxstudents:NUM-CHILDREN:
     CREATE X-NODEREF hxstudent.
     hxstudents:GET-CHILD( hxstudent, ii[2] ).
     IF hxstudent:NAME = 'Student' THEN 
        cstudents = cstudents + hxstudent:GET-ATTRIBUTE( 'Name' ) + '~n'.
     DELETE OBJECT hxstudent.
  END.
  DELETE OBJECT hxstudents.

END. DELETE OBJECT hxdoc.

MESSAGE cstudents VIEW-AS ALERT-BOX.</lang>

Output:

---------------------------
Message
---------------------------
April
Bob
Chad
Dave
Émily
---------------------------
OK   
---------------------------

Oz

<lang oz>declare

 [XMLParser] = {Module.link ['x-oz://system/xml/Parser.ozf']}
 Parser = {New XMLParser.parser init}

 Data =
  "<Students>"
 #"  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"
 #"  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />"
 #"  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />"
 #"  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">"
 #"    <Pet Type=\"dog\" Name=\"Rover\" />"
 #"  </Student>"
 #"  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />"
 #"</Students>"

 fun {IsStudentElement X}
    case X of element(name:'Student' ...) then true
    else false
    end
 end

 fun {GetStudentName element(attributes:As ...)}
    [NameAttr] = {Filter As fun {$ attribute(name:N ...)} N == 'Name' end}
 in
    NameAttr.value
 end

 [StudentsDoc] = {Parser parseVS(Data $)}
 Students = {Filter StudentsDoc.children IsStudentElement}
 StudentNames = {Map Students GetStudentName}

in

 {ForAll StudentNames System.showInfo}</lang>

Perl

Library: XML::Simple Simple

<lang perl>use XML::Simple;

my $ref = XMLin('<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>');

print join( "\n", map { $_->{'Name'} } @{$ref->{'Student'}});</lang>

Perl 6

Works with: Rakudo version 2018.02

Library: XML

<lang perl6>use XML;

my $xml = from-xml '<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>';

say .<Name> for $xml.nodes.grep(/Student/)</lang>

PHP

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>'; $xml = new XMLReader(); $xml->xml( $data ); while ( $xml->read() ) if ( XMLREADER::ELEMENT == $xml->nodeType && $xml->localName == 'Student' ) echo $xml->getAttribute('Name') . "\n"; ?></lang>

PicoLisp

<lang PicoLisp>(load "@lib/xm.l")

(mapcar

  '((L) (attr L 'Name))
  (body (in "file.xml" (xml))) )</lang>

Output:

-> ("April" "Bob" "Chad" "Dave" "Émily")

Pike

<lang Pike> string in = "<Students>\n"

           "  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
           "  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />\n"
           "  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />\n"
           "  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">\n"
           "    <Pet Type=\"dog\" Name=\"Rover\" />\n"
           "  </Student>\n"
           "  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />\n"
           "</Students>\n";

object s = Parser.XML.Tree.simple_parse_input(in);

array collect = ({}); s->walk_inorder(lambda(object node)

               { 
                   if (node->get_tag_name() == "Student") 
                       collect += ({ node->get_attributes()->Name }); 
               });

write("%{%s\n%}", collect);</lang>

Output:

April
Bob
Chad
Dave
Émily

PowerShell

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> '@

foreach ($node in $xml.DocumentElement.ChildNodes) {$node.Name}

</lang>

OpenEdge ABL/Progress 4GL

<lang OpenEdgeABL> /** ==== Definitions ===== **/ DEFINE VARIABLE chXMLString AS LONGCHAR NO-UNDO. DEFINE TEMP-TABLE ttStudent NO-UNDO XML-NODE-NAME 'Student'

   FIELD StudentName AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'Name'        LABEL 'Name'
   FIELD Gender      AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'Gender'      LABEL 'Gender'
   FIELD DateOfBirth AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'DateOfBirth' LABEL 'Date Of Birth'.

DEFINE DATASET dsStudents XML-NODE-NAME 'Students' FOR ttStudent.

/** ==== Main block ====**/

/** ASSIGN the XML string with the XML data.. **/ chXMLString = '<Students>~

               <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />~
               <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />~
               <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />~
               <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">~
                   <Pet Type="dog" Name="Rover" />~
               </Student>~
               <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />~
              </Students>'.

/** Read the string into the dataset...**/ DATASET dsStudents:READ-XML('LONGCHAR', chXMLString, 'EMPTY',?,?).

/** Loop thought each temp-table record to produce the results...**/ FOR EACH ttStudent:

   DISPLAY ttStudent.StudentName.

END.

</lang>

PureBasic

Uses a PureBasic XML library (which is linked automatically) that is based on the library expat XML parser licensed under the MIT license. <lang PureBasic>Define studentNames.String, src$

src$ = "<Students>" src$ + "<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />" src$ + "<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />" src$ + "<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />" src$ + "<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>" src$ + "<Pet Type='dog' Name='Rover' />" src$ + "</Student>" src$ + "<Student DateOfBirth='1993-09-10' Gender='F' Name='Émily' />" src$ + "</Students>"

This procedure is generalized to match any attribute of any normal element's node name
i.e. get_values(MainXMLNode(0),"Pet","Type",@petName.String) and displaying petName\s
would display "dog".

Procedure get_values(*cur_node, nodeName$, attribute$, *valueResults.String)

 ;If nodeName$ and attribute$ are matched then the value
 ;will be added to the string structure pointed to by *valueResults .
 Protected result$

 While *cur_node
   If XMLNodeType(*cur_node) = #PB_XML_Normal
     
     result$ = GetXMLNodeName(*cur_node)
     If result$ = nodeName$
       If ExamineXMLAttributes(*cur_node)
         While NextXMLAttribute(*cur_node)
           If XMLAttributeName(*cur_node) = attribute$
             If *valueResults <> #Null
               *valueResults\s + XMLAttributeValue(*cur_node) + Chr(13) ;value + carriage-return
             EndIf 
           EndIf
         Wend
       EndIf
     EndIf 
     
   EndIf 
   
   get_values(ChildXMLNode(*cur_node), nodeName$, attribute$, *valueResults)
   *cur_node = NextXMLNode(*cur_node)
 Wend

EndProcedure

CatchXML(0,@src$,Len(src$))

If IsXML(0)

 get_values(MainXMLNode(0), "Student", "Name",@studentNames)
 MessageRequester("Student Names", studentNames\s)
 FreeXML(0)

EndIf </lang> Sample output:

April
Bob
Chad
Dave
Émily

Python

<lang python>import xml.dom.minidom

doc = """<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>"""

doc = xml.dom.minidom.parseString(doc)

for i in doc.getElementsByTagName("Student"):

   print i.getAttribute("Name")</lang>

R

Library: XML

<lang R>library(XML)

Read in XML string

str <- readLines(tc <- textConnection('<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>')) close(tc) str</lang>

[1] "<Students>"                                                                 
[2] "  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"       
[3] "  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />"        
[4] "  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />"       
[5] "  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">"         
[6] "    <Pet Type=\"dog\" Name=\"Rover\" />"                                    
[7] "  </Student>"                                                               
[8] "  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />"
[9] "</Students>"

<lang R>#Convert to an XML tree xmltree <- xmlTreeParse(str)

Retrieve the students, and how many there are

students <- xmltree$doc$children$Students nstudents <- length(students)

Get each of their names

studentsnames <- character(nstudents) for(i in 1:nstudents) {

  this.student <- students$children[i]$Student
  studentsnames[i] <- this.student$attributes["Name"]

}

Change the encoding so that Emily displays correctly

Encoding(studentsnames) <- "UTF-8" studentsnames</lang>

[1] "April" "Bob"   "Chad"  "Dave"  "Émily"i

Racket

lang racket

(require xml xml/path)

(define input

<<END

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> END

(define students

 (xml->xexpr 
  (document-element
   (read-xml (open-input-string input)))))

(se-path*/list '(Student #:Name) students) </lang>

Rascal

<lang rascal>import lang::xml::DOM;

public void getNames(loc a){ D = parseXMLDOM(readFile(a)); visit(D){ case element(_,"Student",[_*,attribute(_,"Name", x),_*]): println(x); }; }</lang> Output: <lang rascal>rascal>getNames(|file:///Users/.../Desktop/xmlinput.xml|) April Bob Chad Dave Émily ok</lang>

REBOL

<lang REBOL>REBOL [ Title: "XML Reading" Author: oofoe Date: 2009-12-08 URL: http://rosettacode.org/wiki/XML_Reading ]

xml: { <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students> }

REBOL has a simple built-in XML parser. It's not terribly fancy, but
it's easy to use. It converts the XML into a nested list of blocks
which can be accessed using standard REBOL path operators. The only
annoying part (in this case) is that it does try to preserve
whitespace, so some of the parsed elements are just things like line
endings and whatnot, which I need to ignore.

Once I have drilled down to the individual student records, I can
just use the standard REBOL 'select' to locate the requested
property.

data: parse-xml xml students: data/3/1/3 ; Drill down to student records. foreach student students [ if block! = type? student [ ; Ignore whitespace elements. print select student/2 "Name" ] ]</lang>

Output:

April
Bob
Chad
Dave
Émily

REXX

version 1

<lang rexx>/*REXX program extracts student names from an XML string(s). */ g.= g.1 = '<Students> ' g.2 = ' <Student Name="April" Gender="F" DateOfBirth="1989-01-02" /> ' g.3 = ' <Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" /> ' g.4 = ' <Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" /> ' g.5 = ' <Student Name="Dave" Gender="M" DateOfBirth="1992-07-08"> ' g.6 = ' <Pet Type="dog" Name="Rover" /> ' g.7 = ' </Student> ' g.8 = ' <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" /> ' g.9 = '</Students> '

 do j=1  while g.j\==
 g.j=space(g.j)
 parse var   g.j   'Name="'   studname   '"'
 if studname\==  then say studname
 end   /*j*/                                    /*stick a fork in it,  we're all done. */</lang>

output when using the default (internal) input:

April
Bob
Chad
Dave
Rover
Émily

version 2

This REXX version handles more HTML tags for output. <lang rexx>/*REXX program extracts student names from an XML string(s). */ g.= g.1 = '<Students> ' g.2 = ' <Student Name="April" Gender="F" DateOfBirth="1989-01-02" /> ' g.3 = ' <Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" /> ' g.4 = ' <Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" /> ' g.5 = ' <Student Name="Dave" Gender="M" DateOfBirth="1992-07-08"> ' g.6 = ' <Pet Type="dog" Name="Rover" / > ' g.7 = ' </Student> ' g.8 = ' <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" /> ' g.9 = '</Students> '

       do j=1  while g.j\==
       g.j=space(g.j)
       parse  var   g.j   'Name="'   studname   '"'
       if studname==  then iterate
       if pos('&', studname)\==0  then studname=xmlTranE(studname)
       say studname
       end   /*j*/

exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ xml_: parse arg ,_ /*transkate an XML entity (&xxxx;) */

       xmlEntity! = '&'_";"
       if pos(xmlEntity!, $)\==0  then $=changestr(xmlEntity!, $, arg(1) )
       if left(_, 2)=='#x'  then do
                                 xmlEntity!='&'left(_, 3)translate( substr(_, 4) )";"
                                 $=changestr(xmlEntity!, $, arg(1) )
                                 end
       return $

/*──────────────────────────────────────────────────────────────────────────────────────*/ xmlTranE: procedure; parse arg $ /*Following are most of the chars in */

                                                /*the  DOS  (under Windows)  codepage. */

$=XML_('â',"ETH") ; $=XML_('ƒ',"fnof") ; $=XML_('═',"boxH") $=XML_('â','#x00e2') ; $=XML_('á',"aacute"); $=XML_('╬',"boxVH") $=XML_('â','#x00e9') ; $=XML_('á','#x00e1'); $=XML_('╧',"boxHu") $=XML_('ä',"auml") ; $=XML_('í',"iacute"); $=XML_('╨',"boxhU") $=XML_('ä','#x00e4') ; $=XML_('í','#x00ed'); $=XML_('╤',"boxHd") $=XML_('à',"agrave") ; $=XML_('ó',"oacute"); $=XML_('╥',"boxhD") $=XML_('à','#x00e0') ; $=XML_('ó','#x00f3'); $=XML_('╙',"boxUr") $=XML_('å',"aring") ; $=XML_('ú',"uacute"); $=XML_('╘',"boxuR") $=XML_('å','#x00e5') ; $=XML_('ú','#x00fa'); $=XML_('╒',"boxdR") $=XML_('ç',"ccedil") ; $=XML_('ñ',"ntilde"); $=XML_('╓',"boxDr") $=XML_('ç','#x00e7') ; $=XML_('ñ','#x00f1'); $=XML_('╫',"boxVh") $=XML_('ê',"ecirc") ; $=XML_('Ñ',"Ntilde"); $=XML_('╪',"boxvH") $=XML_('ê','#x00ea') ; $=XML_('Ñ','#x00d1'); $=XML_('┘',"boxul") $=XML_('ë',"euml") ; $=XML_('¿',"iquest"); $=XML_('┌',"boxdr") $=XML_('ë','#x00eb') ; $=XML_('⌐',"bnot") ; $=XML_('█',"block") $=XML_('è',"egrave") ; $=XML_('¬',"not") ; $=XML_('▄',"lhblk") $=XML_('è','#x00e8') ; $=XML_('½',"frac12"); $=XML_('▀',"uhblk") $=XML_('ï',"iuml") ; $=XML_('½',"half") ; $=XML_('α',"alpha") $=XML_('ï','#x00ef') ; $=XML_('¼',"frac14"); $=XML_('ß',"beta") $=XML_('î',"icirc") ; $=XML_('¡',"iexcl") ; $=XML_('ß',"szlig") $=XML_('î','#x00ee') ; $=XML_('«',"laqru") ; $=XML_('ß','#x00df') $=XML_('ì',"igrave") ; $=XML_('»',"raqru") ; $=XML_('Γ',"Gamma") $=XML_('ì','#x00ec') ; $=XML_('░',"blk12") ; $=XML_('π',"pi") $=XML_('Ä',"Auml") ; $=XML_('▒',"blk14") ; $=XML_('Σ',"Sigma") $=XML_('Ä','#x00c4') ; $=XML_('▓',"blk34") ; $=XML_('σ',"sigma") $=XML_('Å',"Aring") ; $=XML_('│',"boxv") ; $=XML_('µ',"mu") $=XML_('Å','#x00c5') ; $=XML_('┤',"boxvl") ; $=XML_('τ',"tau") $=XML_('É',"Eacute") ; $=XML_('╡',"boxvL") ; $=XML_('Φ',"phi") $=XML_('É','#x00c9') ; $=XML_('╢',"boxVl") ; $=XML_('Θ',"Theta") $=XML_('æ',"aelig") ; $=XML_('╖',"boxDl") ; $=XML_('δ',"delta") $=XML_('æ','#x00e6') ; $=XML_('╕',"boxdL") ; $=XML_('∞',"infin") $=XML_('Æ',"AElig") ; $=XML_('╣',"boxVL") ; $=XML_('φ',"Phi") $=XML_('Æ','#x00c6') ; $=XML_('║',"boxV") ; $=XML_('ε',"epsilon") $=XML_('ô',"ocirc") ; $=XML_('╗',"boxDL") ; $=XML_('∩',"cap") $=XML_('ô','#x00f4') ; $=XML_('╝',"boxUL") ; $=XML_('≡',"equiv") $=XML_('ö',"ouml") ; $=XML_('╜',"boxUl") ; $=XML_('±',"plusmn") $=XML_('ö','#x00f6') ; $=XML_('╛',"boxuL") ; $=XML_('±',"pm") $=XML_('ò',"ograve") ; $=XML_('┐',"boxdl") ; $=XML_('±',"PlusMinus") ; $=XML_('ò','#x00f2') ; $=XML_('└',"boxur") ; $=XML_('≥',"ge") $=XML_('û',"ucirc") ; $=XML_('┴',"bottom"); $=XML_('≤',"le") $=XML_('û','#x00fb') ; $=XML_('┴',"boxhu") ; $=XML_('÷',"div") $=XML_('ù',"ugrave") ; $=XML_('┬',"boxhd") ; $=XML_('÷',"divide") $=XML_('ù','#x00f9') ; $=XML_('├',"boxvr") ; $=XML_('≈',"approx") $=XML_('ÿ',"yuml") ; $=XML_('─',"boxh") ; $=XML_('∙',"bull") $=XML_('ÿ','#x00ff') ; $=XML_('┼',"boxvh") ; $=XML_('°',"deg") $=XML_('Ö',"Ouml") ; $=XML_('╞',"boxvR") ; $=XML_('·',"middot") $=XML_('Ö','#x00d6') ; $=XML_('╟',"boxVr") ; $=XML_('·',"middledot") ; $=XML_('Ü',"Uuml") ; $=XML_('╚',"boxUR") ; $=XML_('·',"centerdot") ; $=XML_('Ü','#x00dc') ; $=XML_('╔',"boxDR") ; $=XML_('·',"CenterDot") ; $=XML_('¢',"cent") ; $=XML_('╩',"boxHU") ; $=XML_('√',"radic") $=XML_('£',"pound") ; $=XML_('╦',"boxHD") ; $=XML_('²',"sup2") $=XML_('¥',"yen") ; $=XML_('╠',"boxVR") ; $=XML_('■',"square ") return $</lang> Some older REXXes don't have a changestr BIF, ; $=XML_('♥',"hearts") ; $=XML_('♦',"diams") ; $=XML_('♣',"clubs") ; $=XML_('♠',"spades") ; $=XML_('♂',"male") ; $=XML_('♀',"female") ; $=XML_('☼',"#x263c") ; $=XML_('↕',"UpDownArrow") ; $=XML_('¶',"para") ; $=XML_('§',"sect") ; $=XML_('↑',"uarr") ; $=XML_('↑',"uparrow") ; $=XML_('↑',"ShortUpArrow") ; $=XML_('↓',"darr") ; $=XML_('↓',"downarrow") ; $=XML_('↓',"ShortDownArrow") ; $=XML_('←',"larr") ; $=XML_('←',"leftarrow") ; $=XML_('←',"ShortLeftArrow") ; $=XML_('1c'x,"rarr") ; $=XML_('1c'x,"rightarrow") ; $=XML_('1c'x,"ShortRightArrow") ; $=XML_('!',"excl") ; $=XML_('"',"apos") ; $=XML_('$',"dollar") ; $=XML_("'","quot") ; $=XML_('*',"ast") ; $=XML_('/',"sol") ; $=XML_(':',"colon") ; $=XML_('<',"lt") ; $=XML_('=',"equals") ; $=XML_('>',"gt") ; $=XML_('?',"quest") ; $=XML_('_',"commat") ; $=XML_('[',"lbrack") ; $=XML_('\',"bsol") ; $=XML_(']',"rbrack") $=XML_('^',"Hat") ; $=XML_('`',"grave") ; $=XML_('{',"lbrace") ; $=XML_('{',"lcub") ; $=XML_('|',"vert") ; $=XML_('|',"verbar") ; $=XML_('}',"rbrace") ; $=XML_('}',"rcub") ; $=XML_('Ç',"Ccedil") $=XML_('Ç','#x00c7') $=XML_('ü',"uuml") $=XML_('ü','#x00fc') ; $=XML_('é',"eacute") ; $=XML_('é','#x00e9') ; $=XML_('â',"acirc") so one is included here ──► CHANGESTR.REX.

output when using the default (internal) input:

April
Bob
Chad
Dave
Rover
Émily

Ruby

Library: REXML

<lang ruby>require 'rexml/document' include REXML

doc = Document.new(File.new("sample.xml"))

or
doc = Document.new(xml_string)

without using xpath

doc.each_recursive do |node|

 puts node.attributes["Name"] if node.name == "Student"

end

using xpath

doc.each_element("*/Student") {|node| puts node.attributes["Name"]}</lang>

Run BASIC

<lang runbasic>' ------------------------------------------------------------------------ 'XMLPARSER methods

'#handle ELEMENTCOUNT() - Return the number of child XML elements '#handle KEY$() - Return the key as a string from an XML expression like <key>value</key> '#handle VALUE$() - Return the value as a string from an XML expression like <key>value</key> '#handle VALUEFORKEY$(keyExpr$) - Return the value for the specified tag key in keyExpr$ '#handle #ELEMENT(n) - Return the nth child-element XML element '#handle #ELEMENT(nameExpr$) - Return the child-element XML element named by nameExpr$ '#handle ATTRIBCOUNT() - Return a count of attribute pairs; <a attrA="abc" attrB="def"> has two pairs '#handle ATTRIBKEY$(n) - Return the key string of the nth attribute '#handle ATTRIBVALUE$(n) - Return the value string of the nth attribute '#handle ATTRIBVALUE$(n$) - Return the value string of the attribute with the key n$, or an empty string if it doesn't exist. '#handle ISNULL() - Returns zero (or false) '#handle DEBUG$() - Returns the string "Xmlparser" ' ------------------------------------------------------------------------

' The xml string xml$ = " <Students>

 <Student Name=""April"" Gender=""F"" DateOfBirth=""1989-01-02"" />
 <Student Name=""Bob"" Gender=""M""  DateOfBirth=""1990-03-04"" />
 <Student Name=""Chad"" Gender=""M""  DateOfBirth=""1991-05-06"" />
 <Student Name=""Dave"" Gender=""M""  DateOfBirth=""1992-07-08"">
   <Pet Type=""dog"" Name=""Rover"" />
 </Student>
 <Student DateOfBirth=""1993-09-10"" Gender=""F"" Name=""Émily"" />

</Students>"

' Creates the xml handler, using the string xmlparser #spies, xml$

' Uses elementCount() to know how many elements are in betweeb <spies>...</spies> for count = 1 to #spies elementCount()

 ' Uses "count" to work through the elements, and assigns the element to the
 ' handle "#spy"
 #spy = #spies #element(count)

 ' Prints the value, or inner text, of "#spy": Sam, Clover, & Alex
 print count;" ";#spy value$();" ->";#spy ATTRIBVALUE$(1)

next count</lang>

Scala

Scala has native XML support, with query constructs similar to XPath and XQuery.

<lang scala>val students =

 <Students>
   <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
   <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
   <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
   <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
     <Pet Type="dog" Name="Rover" />
   </Student>
   <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />
 </Students>

students \ "Student" \\ "@Name" foreach println</lang>

Sidef

Translation of: Perl

<lang ruby>require('XML::Simple');

var ref = %S'XML::Simple'.XMLin('<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />

</Students>');

ref{:Student}.each { say _{:Name} };</lang>

Output:

April
Bob
Chad
Dave
Émily

Slate

Some lines in this example are too long (more than 80 characters). Please fix the code if it's possible and remove this message.

Slate's XML Reader is still being developed at the time of this writing.

<lang slate>slate[1]> [ |tree|

 tree: (Xml SimpleParser newOn: '<Students>
   <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
   <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
   <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
   <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
     <Pet Type="dog" Name="Rover" />
   </Student>
   <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" />
 </Students>') parse.
 tree name = 'Students' ifTrue: [(tree children select: #is: `er <- Xml Element)
                                        do: [|:child| child name = 'Student' ifTrue: [inform: (child attributes at: 'Name' ifAbsent: ['Noname'])]]].

] do. April Bob Chad Dave Émily Nil</lang>

Tcl

Using

Library: tDOM

<lang tcl>package require tdom set tree [dom parse $xml] set studentNodes [$tree getElementsByTagName Student] ;# or: set studentNodes [[$tree documentElement] childNodes]

foreach node $studentNodes {

   puts [$node getAttribute Name]

}</lang>

Using

Library: TclXML

<lang tcl>package require xml set parser [xml::parser -elementstartcommand elem] proc elem {name attlist args} {

   if {$name eq "Student"} {
       puts [dict get $attlist Name]
   }

} $parser parse $xml</lang>

Using just pure-Tcl (originally on http://wiki.tcl.tk/3919): <lang Tcl>proc xml2list xml {

   regsub -all {>\s*<} [string trim $xml " \n\t<>"] "\} \{" xml
   set xml [string map {> "\} \{#text \{" < "\}\} \{"}  $xml]
   set res ""   ;# string to collect the result
   set stack {} ;# track open tags
   set rest {}
   foreach item "{$xml}" {
       switch -regexp -- $item {

^# {append res "{[lrange $item 0 end]} " ; #text item} ^/ { regexp {/(.+)} $item -> tagname ;# end tag set expected [lindex $stack end] set stack [lrange $stack 0 end-1] append res "\}\} "

/$ { # singleton - start and end in one <> group

               regexp {([^ ]+)( (.+))?/$} $item -> tagname - rest
               set rest [lrange [string map {= " "} $rest] 0 end]
               append res "{$tagname [list $rest] {}} "

} default {

               set tagname [lindex $item 0] ;# start tag
               set rest [lrange [string map {= " "} $item] 1 end]
               lappend stack $tagname
               append res "\{$tagname [list $rest] \{"

}

       }
   }
   string map {"\} \}" "\}\}"} [lindex $res 0]   ;#"

} proc deent str {

   regsub -all {&\#x(.+?);} $str {\\u\1} str
   subst -nocommands -novar $str

}

----------------------- Testing the whole thing:

set xml {<Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Émily" /></Students>

} foreach i [lindex [xml2list $xml] 2] {

   if {[lindex $i 0] eq "Student"} {
       foreach {att val} [lindex $i 1] {
           if {$att eq "Name"} {puts [deent $val]}
       }
   }

}</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT MODE DATA $$ SET xmldata =* <Students>

 <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
 <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />
 <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />
 <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">
   <Pet Type="dog" Name="Rover" />
 </Student>
 <Student DateOfBirth="1993-09-10" Gender="F" Name="Emily" />

</Students> $$ MODE TUSCRIPT COMPILE LOOP x = xmldata SET name=GET_TAG_NAME (x) IF (name!="student") CYCLE

studentname=GET_ATTRIBUTE (x,"Name")
IF (studentname!="") PRINT studentname

ENDLOOP ENDCOMPILE </lang> Output:

April
Bob
Chad
Dave
Emily

TXR

This program shows how most of the information in the XML can be extracted with very little code, which doesn't actually understand XML. The name Émily is properly converted from the HTML/XML escape syntax.

<lang txr><Students> @(collect :vars (NAME GENDER YEAR MONTH DAY (PET_TYPE "none") (PET_NAME ""))) @ (cases)

 <Student Name="@NAME" Gender="@GENDER" DateOfBirth="@YEAR-@MONTH-@DAY"@(skip)

@ (or)

 <Student DateOfBirth="@YEAR-@MONTH-@DAY" Gender="@GENDER" Name="@NAME"@(skip)

@ (end) @ (maybe)

   <Pet Type="@PET_TYPE" Name="@PET_NAME" />

@ (end) @(until) </Students> @(end) @(output :filter :from_html) NAME G DOB PET @ (repeat) @{NAME 12} @GENDER @YEAR-@MONTH-@DAY @PET_TYPE @PET_NAME @ (end) @(end)</lang>

Sample run:

$ txr students.txr students.xml
NAME         G DOB        PET
April        F 1989-01-02 none 
Bob          M 1990-03-04 none 
Chad         M 1991-05-06 none 
Dave         M 1992-07-08 dog Rover
Émily        F 1993-09-10 none

To obtain the output specified in this task, we can simply reduce the @(output) block to this:

<lang txr>@(output :filter :from_html) @NAME @(end)</lang>

April
Bob
Chad
Dave
Émily

Vedit macro language

This implementation finds all Student tags and then displays the contents of their Name parameter. <lang vedit>Repeat(ALL) {

   Search("<Student|X", ERRBREAK)
   #1 = Cur_Pos
   Match_Paren()
   if (Search_Block(/Name=|{",'}/, #1, Cur_Pos, BEGIN+ADVANCE+NOERR+NORESTORE)==0) { Continue }
   #2 = Cur_Pos
   Search(/|{",'}/)
   Type_Block(#2, Cur_Pos)
   Type_Newline

}</lang>

Output:

April
Bob
Chad
Dave
Émily

VBA

<lang vb>Option Explicit

Const strXml As String = "" & _ "<Students>" & _

   "<Student Name=""April"" Gender=""F"" DateOfBirth=""1989-01-02"" />" & _
   "<Student Name=""Bob"" Gender=""M""  DateOfBirth=""1990-03-04"" />" & _
   "<Student Name=""Chad"" Gender=""M""  DateOfBirth=""1991-05-06"" />" & _
   "<Student Name=""Dave"" Gender=""M""  DateOfBirth=""1992-07-08"">" & _
       "<Pet Type=""dog"" Name=""Rover"" />" & _
   "</Student>" & _
   "<Student DateOfBirth=""1993-09-10"" Gender=""F"" Name=""Émily"" />" & _

"</Students>"

Sub Main_Xml() Dim MyXml As Object Dim myNodes, myNode

   With CreateObject("MSXML2.DOMDocument")
       .LoadXML strXml
       Set myNodes = .getElementsByTagName("Student")
   End With
   If Not myNodes Is Nothing Then
       For Each myNode In myNodes
           Debug.Print myNode.getAttribute("Name")
       Next
   End If
   Set myNodes = Nothing

End Sub</lang>

Output:

April
Bob
Chad
Dave
Émily

Visual Basic .NET

             <Student Name="April"/>
             <Student Name="Bob"/>
             <Student Name="Chad"/>
             <Student Name="Dave"/>
             <Student Name="Emily"/>
          </Students>

Dim names = (From node In xml...<Student> Select node.@Name).ToArray

For Each name In names

    Console.WriteLine(name)

Next</lang>

XPL0

<lang XPL0>code ChOut=8, CrLf=9; \intrinsic routines string 0; \use zero-terminated strings

func StrLen(A); \Return number of characters in an ASCIIZ string char A; int I; for I:= 0 to -1>>1-1 do

   if A(I) = 0 then return I;

func StrFind(A, B); \Search for ASCIIZ string A in string B \Returns address of first occurrence of string A in B, or zero if A is not found char A, B; \strings to be compared int LA, LB, I, J; [LA:= StrLen(A); LB:= StrLen(B); for I:= 0 to LB-LA do

   [for J:= 0 to LA-1 do
       if A(J) # B(J+I) then J:= LA+1;
   if J = LA then return B+I;  \found
   ];

return 0; ];

char XML, P; [XML:= "<Students>

       <Student Name=^"April^" Gender=^"F^" DateOfBirth=^"1989-01-02^" />
       <Student Name=^"Bob^" Gender=^"M^" DateOfBirth=^"1990-03-04^" />
       <Student Name=^"Chad^" Gender=^"M^" DateOfBirth=^"1991-05-06^" />
       <Student Name=^"Dave^" Gender=^"M^" DateOfBirth=^"1992-07-08^">
       <Pet Type=^"dog^" Name=^"Rover^" />
       </Student>
       <Student DateOfBirth=^"1993-09-10^" Gender=^"F^" Name=^"Émily^" />
       </Students>";

P:= XML; loop [P:= StrFind("<Student ", P);

       if P=0 then quit;
       P:= StrFind("Name=", P);
       if P=0 then quit;
       P:= P + StrLen("Name=x");
       repeat  ChOut(0, P(0));
               P:= P+1;
       until   P(0) = ^";
       CrLf(0);
       ];

]</lang>

Output:

April
Bob
Chad
Dave
Émily

zkl

Uses regular expressions and the data is in a file identical to task description.
Assumes: a name attribute is complete in a line and only one name per line. <lang zkl>student:=RegExp(0'|.*<Student\s*.+Name\s*=\s*"([^"]+)"|); unicode:=RegExp(0'|.*(&#x[0-9a-fA-F]+;)|); xml:=File("foo.xml").read();

students:=xml.pump(List,'wrap(line){

  if(student.search(line)){
     s:=student.matched[1];    // ( (match start,len),group text )
     while(unicode.search(s)){ // convert "É" to 0xc9 to UTF-8

c:=unicode.matched[1]; uc:=c[3,-1].toInt(16).toString(-8);

     	 s=s.replace(c,uc);
     }
     s
  }
  else Void.Skip; // line doesn't contain <Student ... Name ...

});

students.println();</lang>

Output:

L("April","Bob","Chad","Dave","Émily")

@@ Line 2,193: / Line 2,193: @@
 =={{header|REXX}}==
 ===version 1===
-<lang rexx>/*REXX program to extract student names from an  XML string(s).         */
+<lang rexx>/*REXX program  extracts  student names  from an  XML  string(s).                       */
 g.=
-g.1='<Students>                                                             '
+g.1 = '<Students>                                                             '
-g.2='  <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />         '
+g.2 = '  <Student Name="April" Gender="F" DateOfBirth="1989-01-02" />         '
-g.3='  <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />          '
+g.3 = '  <Student Name="Bob" Gender="M"  DateOfBirth="1990-03-04" />          '
-g.4='  <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />         '
+g.4 = '  <Student Name="Chad" Gender="M"  DateOfBirth="1991-05-06" />         '
-g.5='  <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">           '
+g.5 = '  <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">           '
-g.6='    <Pet Type="dog" Name="Rover" />                                    '
+g.6 = '    <Pet Type="dog" Name="Rover" />                                    '
-g.7='  </Student>                                                           '
+g.7 = '  </Student>                                                           '
-g.8='  <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />  '
+g.8 = '  <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />  '
-g.9='</Students>                                                            '
+g.9 = '</Students>                                                            '
-  do j=1 while g.j\==''
+  do j=1  while g.j\==''
   g.j=space(g.j)
-  parse var g.j 'Name="' studname '"'
+  parse var   g.j   'Name="'   studname   '"'
   if studname\==''  then say studname
+  end   /*j*/                                    /*stick a fork in it,  we're all done. */</lang>
-  end   /*j*/
+{{out|output|text=&nbsp; when using the default (internal) input:}}
-                                       /*stick a fork in it, we're done.*/</lang>
-'''output'''
 <pre>
 April
@@ Line 2,223: / Line 2,222: @@
 ===version 2===
 This REXX version handles more HTML tags for output.
-<lang rexx>/*REXX program to extract student names from an  XML string(s).         */
+<lang rexx>/*REXX program  extracts  student names  from an  XML  string(s).                       */
 g.=
-g.1='<Students>                                                             '
+g.1 = '<Students>                                                             '
-g.2='  <Student Name="April" Gender="F"  DateOfBirth="1989-01-02" />        '
+g.2 = '  <Student Name="April" Gender="F"  DateOfBirth="1989-01-02" />        '
-g.3='  <Student Name="Bob" Gender="M"   DateOfBirth="1990-03-04" />         '
+g.3 = '  <Student Name="Bob" Gender="M"   DateOfBirth="1990-03-04" />         '
-g.4='  <Student Name="Chad" Gender="M"   DateOfBirth="1991-05-06" />        '
+g.4 = '  <Student Name="Chad" Gender="M"   DateOfBirth="1991-05-06" />        '
-g.5='  <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">           '
+g.5 = '  <Student Name="Dave" Gender="M"  DateOfBirth="1992-07-08">           '
-g.6='    <Pet Type="dog" Name="Rover" / >                                   '
+g.6 = '    <Pet Type="dog" Name="Rover" / >                                   '
-g.7='  </Student>                                                           '
+g.7 = '  </Student>                                                           '
-g.8='  <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />  '
+g.8 = '  <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />  '
-g.9='</Students>                                                            '
+g.9 = '</Students>                                                            '
-        do j=1 while g.j\==''
+        do j=1  while g.j\==''
         g.j=space(g.j)
-        parse var g.j 'Name="' studname '"'
+        parse  var   g.j   'Name="'   studname   '"'
-        if studname=='' then iterate
+        if studname==''  then iterate
-        if pos('&',studname)\==0 then studname=xmlTranE(studname)
+        if pos('&', studname)\==0  then studname=xmlTranE(studname)
         say studname
         end   /*j*/
-exit                                   /*stick a fork in it, we're done.*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
-/*──────────────────────────────────XML_ subroutine─────────────────────*/
-xml_: parse arg ,_                     /*tran an XML entity   (&xxxx;)  */
+xml_:   parse arg ,_                             /*transkate an  XML  entity   (&xxxx;) */
-xmlEntity! = '&'_";"
+        xmlEntity! = '&'_";"
-if pos(xmlEntity!,x)\==0  then x=changestr(xmlEntity!,x,arg(1))
+        if pos(xmlEntity!, $)\==0  then $=changestr(xmlEntity!, $, arg(1) )
-if left(_,2)=='#x' then do
+        if left(_, 2)=='#x'  then do
-                        xmlEntity!='&'left(_,3)translate(substr(_,4))";"
+                                  xmlEntity!='&'left(_, 3)translate( substr(_, 4) )";"
-                        x=changestr(xmlEntity!,x,arg(1))
+                                  $=changestr(xmlEntity!, $, arg(1) )
-                        end
+                                  end
-return x
+        return $
+/*──────────────────────────────────────────────────────────────────────────────────────*/
-/*──────────────────────────────────XMLTRANE subroutine─────────────────*/
-xmlTranE: procedure; parse arg x   /*Following are most of the chars in*/
+xmlTranE: procedure; parse arg $                 /*Following are most of the chars in   */
-                                   /*the DOS (under Windows) codepage. */
+                                                 /*the  DOS  (under Windows)  codepage. */
-x=XML_('♥',"hearts")           ; x=XML_('â',"ETH")    ; x=XML_('ƒ',"fnof")  ; x=XML_('═',"boxH")
+$=XML_('â',"ETH")    ; $=XML_('ƒ',"fnof")  ; $=XML_('═',"boxH")      ; $=XML_('♥',"hearts")
-x=XML_('♦',"diams")            ; x=XML_('â','#x00e2') ; x=XML_('á',"aacute"); x=XML_('╬',"boxVH")
+$=XML_('â','#x00e2') ; $=XML_('á',"aacute"); $=XML_('╬',"boxVH")     ; $=XML_('♦',"diams")
-x=XML_('♣',"clubs")            ; x=XML_('â','#x00e9') ; x=XML_('á','#x00e1'); x=XML_('╧',"boxHu")
+$=XML_('â','#x00e9') ; $=XML_('á','#x00e1'); $=XML_('╧',"boxHu")     ; $=XML_('♣',"clubs")
-x=XML_('♠',"spades")           ; x=XML_('ä',"auml")   ; x=XML_('í',"iacute"); x=XML_('╨',"boxhU")
+$=XML_('ä',"auml")   ; $=XML_('í',"iacute"); $=XML_('╨',"boxhU")     ; $=XML_('♠',"spades")
-x=XML_('♂',"male")             ; x=XML_('ä','#x00e4') ; x=XML_('í','#x00ed'); x=XML_('╤',"boxHd")
+$=XML_('ä','#x00e4') ; $=XML_('í','#x00ed'); $=XML_('╤',"boxHd")     ; $=XML_('♂',"male")
-x=XML_('♀',"female")           ; x=XML_('à',"agrave") ; x=XML_('ó',"oacute"); x=XML_('╥',"boxhD")
+$=XML_('à',"agrave") ; $=XML_('ó',"oacute"); $=XML_('╥',"boxhD")     ; $=XML_('♀',"female")
-x=XML_('☼',"#x263c")           ; x=XML_('à','#x00e0') ; x=XML_('ó','#x00f3'); x=XML_('╙',"boxUr")
+$=XML_('à','#x00e0') ; $=XML_('ó','#x00f3'); $=XML_('╙',"boxUr")     ; $=XML_('☼',"#x263c")
-x=XML_('↕',"UpDownArrow")      ; x=XML_('å',"aring")  ; x=XML_('ú',"uacute"); x=XML_('╘',"boxuR")
+$=XML_('å',"aring")  ; $=XML_('ú',"uacute"); $=XML_('╘',"boxuR")     ; $=XML_('↕',"UpDownArrow")
-x=XML_('¶',"para")             ; x=XML_('å','#x00e5') ; x=XML_('ú','#x00fa'); x=XML_('╒',"boxdR")
+$=XML_('å','#x00e5') ; $=XML_('ú','#x00fa'); $=XML_('╒',"boxdR")     ; $=XML_('¶',"para")
-x=XML_('§',"sect")             ; x=XML_('ç',"ccedil") ; x=XML_('ñ',"ntilde"); x=XML_('╓',"boxDr")
+$=XML_('ç',"ccedil") ; $=XML_('ñ',"ntilde"); $=XML_('╓',"boxDr")     ; $=XML_('§',"sect")
-x=XML_('↑',"uarr")             ; x=XML_('ç','#x00e7') ; x=XML_('ñ','#x00f1'); x=XML_('╫',"boxVh")
+$=XML_('ç','#x00e7') ; $=XML_('ñ','#x00f1'); $=XML_('╫',"boxVh")     ; $=XML_('↑',"uarr")
-x=XML_('↑',"uparrow")          ; x=XML_('ê',"ecirc")  ; x=XML_('Ñ',"Ntilde"); x=XML_('╪',"boxvH")
+$=XML_('ê',"ecirc")  ; $=XML_('Ñ',"Ntilde"); $=XML_('╪',"boxvH")     ; $=XML_('↑',"uparrow")
-x=XML_('↑',"ShortUpArrow")     ; x=XML_('ê','#x00ea') ; x=XML_('Ñ','#x00d1'); x=XML_('┘',"boxul")
+$=XML_('ê','#x00ea') ; $=XML_('Ñ','#x00d1'); $=XML_('┘',"boxul")     ; $=XML_('↑',"ShortUpArrow")
-x=XML_('↓',"darr")             ; x=XML_('ë',"euml")   ; x=XML_('¿',"iquest"); x=XML_('┌',"boxdr")
+$=XML_('ë',"euml")   ; $=XML_('¿',"iquest"); $=XML_('┌',"boxdr")     ; $=XML_('↓',"darr")
-x=XML_('↓',"downarrow")        ; x=XML_('ë','#x00eb') ; x=XML_('⌐',"bnot")  ; x=XML_('█',"block")
+$=XML_('ë','#x00eb') ; $=XML_('⌐',"bnot")  ; $=XML_('█',"block")     ; $=XML_('↓',"downarrow")
-x=XML_('↓',"ShortDownArrow")   ; x=XML_('è',"egrave") ; x=XML_('¬',"not")   ; x=XML_('▄',"lhblk")
+$=XML_('è',"egrave") ; $=XML_('¬',"not")   ; $=XML_('▄',"lhblk")     ; $=XML_('↓',"ShortDownArrow")
-x=XML_('←',"larr")             ; x=XML_('è','#x00e8') ; x=XML_('½',"frac12"); x=XML_('▀',"uhblk")
+$=XML_('è','#x00e8') ; $=XML_('½',"frac12"); $=XML_('▀',"uhblk")     ; $=XML_('←',"larr")
-x=XML_('←',"leftarrow")        ; x=XML_('ï',"iuml")   ; x=XML_('½',"half")  ; x=XML_('α',"alpha")
+$=XML_('ï',"iuml")   ; $=XML_('½',"half")  ; $=XML_('α',"alpha")     ; $=XML_('←',"leftarrow")
-x=XML_('←',"ShortLeftArrow")   ; x=XML_('ï','#x00ef') ; x=XML_('¼',"frac14"); x=XML_('ß',"beta")
+$=XML_('ï','#x00ef') ; $=XML_('¼',"frac14"); $=XML_('ß',"beta")      ; $=XML_('←',"ShortLeftArrow")
-x=XML_('1c'x,"rarr")           ; x=XML_('î',"icirc")  ; x=XML_('¡',"iexcl") ; x=XML_('ß',"szlig")
+$=XML_('î',"icirc")  ; $=XML_('¡',"iexcl") ; $=XML_('ß',"szlig")     ; $=XML_('1c'x,"rarr")
-x=XML_('1c'x,"rightarrow")     ; x=XML_('î','#x00ee') ; x=XML_('«',"laqru") ; x=XML_('ß','#x00df')
+$=XML_('î','#x00ee') ; $=XML_('«',"laqru") ; $=XML_('ß','#x00df')    ; $=XML_('1c'x,"rightarrow")
-x=XML_('1c'x,"ShortRightArrow"); x=XML_('ì',"igrave") ; x=XML_('»',"raqru") ; x=XML_('Γ',"Gamma")
+$=XML_('ì',"igrave") ; $=XML_('»',"raqru") ; $=XML_('Γ',"Gamma")     ; $=XML_('1c'x,"ShortRightArrow")
-x=XML_('!',"excl")             ; x=XML_('ì','#x00ec') ; x=XML_('░',"blk12") ; x=XML_('π',"pi")
+$=XML_('ì','#x00ec') ; $=XML_('░',"blk12") ; $=XML_('π',"pi")        ; $=XML_('!',"excl")
-x=XML_('"',"apos")             ; x=XML_('Ä',"Auml")   ; x=XML_('▒',"blk14") ; x=XML_('Σ',"Sigma")
+$=XML_('Ä',"Auml")   ; $=XML_('▒',"blk14") ; $=XML_('Σ',"Sigma")     ; $=XML_('"',"apos")
-x=XML_('$',"dollar")           ; x=XML_('Ä','#x00c4') ; x=XML_('▓',"blk34") ; x=XML_('σ',"sigma")
+$=XML_('Ä','#x00c4') ; $=XML_('▓',"blk34") ; $=XML_('σ',"sigma")     ; $=XML_('$',"dollar")
-x=XML_("'","quot")             ; x=XML_('Å',"Aring")  ; x=XML_('│',"boxv")  ; x=XML_('µ',"mu")
+$=XML_('Å',"Aring")  ; $=XML_('│',"boxv")  ; $=XML_('µ',"mu")        ; $=XML_("'","quot")
-x=XML_('*',"ast")              ; x=XML_('Å','#x00c5') ; x=XML_('┤',"boxvl") ; x=XML_('τ',"tau")
+$=XML_('Å','#x00c5') ; $=XML_('┤',"boxvl") ; $=XML_('τ',"tau")       ; $=XML_('*',"ast")
-x=XML_('/',"sol")              ; x=XML_('É',"Eacute") ; x=XML_('╡',"boxvL") ; x=XML_('Φ',"phi")
+$=XML_('É',"Eacute") ; $=XML_('╡',"boxvL") ; $=XML_('Φ',"phi")       ; $=XML_('/',"sol")
-x=XML_(':',"colon")            ; x=XML_('É','#x00c9') ; x=XML_('╢',"boxVl") ; x=XML_('Θ',"Theta")
+$=XML_('É','#x00c9') ; $=XML_('╢',"boxVl") ; $=XML_('Θ',"Theta")     ; $=XML_(':',"colon")
-x=XML_('<',"lt")               ; x=XML_('æ',"aelig")  ; x=XML_('╖',"boxDl") ; x=XML_('δ',"delta")
+$=XML_('æ',"aelig")  ; $=XML_('╖',"boxDl") ; $=XML_('δ',"delta")     ; $=XML_('<',"lt")
-x=XML_('=',"equals")           ; x=XML_('æ','#x00e6') ; x=XML_('╕',"boxdL") ; x=XML_('∞',"infin")
+$=XML_('æ','#x00e6') ; $=XML_('╕',"boxdL") ; $=XML_('∞',"infin")     ; $=XML_('=',"equals")
-x=XML_('>',"gt")               ; x=XML_('Æ',"AElig")  ; x=XML_('╣',"boxVL") ; x=XML_('φ',"Phi")
+$=XML_('Æ',"AElig")  ; $=XML_('╣',"boxVL") ; $=XML_('φ',"Phi")       ; $=XML_('>',"gt")
-x=XML_('?',"quest")            ; x=XML_('Æ','#x00c6') ; x=XML_('║',"boxV")  ; x=XML_('ε',"epsilon")
+$=XML_('Æ','#x00c6') ; $=XML_('║',"boxV")  ; $=XML_('ε',"epsilon")   ; $=XML_('?',"quest")
-x=XML_('@',"commat")           ; x=XML_('ô',"ocirc")  ; x=XML_('╗',"boxDL") ; x=XML_('∩',"cap")
+$=XML_('ô',"ocirc")  ; $=XML_('╗',"boxDL") ; $=XML_('∩',"cap")       ; $=XML_('_',"commat")
-x=XML_('[',"lbrack")           ; x=XML_('ô','#x00f4') ; x=XML_('╝',"boxUL") ; x=XML_('≡',"equiv")
+$=XML_('ô','#x00f4') ; $=XML_('╝',"boxUL") ; $=XML_('≡',"equiv")     ; $=XML_('[',"lbrack")
-x=XML_('\',"bsol")             ; x=XML_('ö',"ouml")   ; x=XML_('╜',"boxUl") ; x=XML_('±',"plusmn")
+$=XML_('ö',"ouml")   ; $=XML_('╜',"boxUl") ; $=XML_('±',"plusmn")    ; $=XML_('\',"bsol")
-x=XML_(']',"rbrack")           ; x=XML_('ö','#x00f6') ; x=XML_('╛',"boxuL") ; x=XML_('±',"pm")
+$=XML_('ö','#x00f6') ; $=XML_('╛',"boxuL") ; $=XML_('±',"pm")        ; $=XML_(']',"rbrack")
-x=XML_('^',"Hat")              ; x=XML_('ò',"ograve") ; x=XML_('┐',"boxdl") ; x=XML_('±',"PlusMinus")
+$=XML_('ò',"ograve") ; $=XML_('┐',"boxdl") ; $=XML_('±',"PlusMinus") ; $=XML_('^',"Hat")
-x=XML_('`',"grave")            ; x=XML_('ò','#x00f2') ; x=XML_('└',"boxur") ; x=XML_('≥',"ge")
+$=XML_('ò','#x00f2') ; $=XML_('└',"boxur") ; $=XML_('≥',"ge")        ; $=XML_('`',"grave")
-x=XML_('{',"lbrace")           ; x=XML_('û',"ucirc")  ; x=XML_('┴',"bottom"); x=XML_('≤',"le")
+$=XML_('û',"ucirc")  ; $=XML_('┴',"bottom"); $=XML_('≤',"le")        ; $=XML_('{',"lbrace")
-x=XML_('{',"lcub")             ; x=XML_('û','#x00fb') ; x=XML_('┴',"boxhu") ; x=XML_('÷',"div")
+$=XML_('û','#x00fb') ; $=XML_('┴',"boxhu") ; $=XML_('÷',"div")       ; $=XML_('{',"lcub")
-x=XML_('|',"vert")             ; x=XML_('ù',"ugrave") ; x=XML_('┬',"boxhd") ; x=XML_('÷',"divide")
+$=XML_('ù',"ugrave") ; $=XML_('┬',"boxhd") ; $=XML_('÷',"divide")    ; $=XML_('|',"vert")
-x=XML_('|',"verbar")           ; x=XML_('ù','#x00f9') ; x=XML_('├',"boxvr") ; x=XML_('≈',"approx")
+$=XML_('ù','#x00f9') ; $=XML_('├',"boxvr") ; $=XML_('≈',"approx")    ; $=XML_('|',"verbar")
-x=XML_('}',"rbrace")           ; x=XML_('ÿ',"yuml")   ; x=XML_('─',"boxh")  ; x=XML_('∙',"bull")
+$=XML_('ÿ',"yuml")   ; $=XML_('─',"boxh")  ; $=XML_('∙',"bull")      ; $=XML_('}',"rbrace")
-x=XML_('}',"rcub")             ; x=XML_('ÿ','#x00ff') ; x=XML_('┼',"boxvh") ; x=XML_('°',"deg")
+$=XML_('ÿ','#x00ff') ; $=XML_('┼',"boxvh") ; $=XML_('°',"deg")       ; $=XML_('}',"rcub")
-x=XML_('Ç',"Ccedil")           ; x=XML_('Ö',"Ouml")   ; x=XML_('╞',"boxvR") ; x=XML_('·',"middot")
+$=XML_('Ö',"Ouml")   ; $=XML_('╞',"boxvR") ; $=XML_('·',"middot")    ; $=XML_('Ç',"Ccedil")
-x=XML_('Ç','#x00c7')           ; x=XML_('Ö','#x00d6') ; x=XML_('╟',"boxVr") ; x=XML_('·',"middledot")
+$=XML_('Ö','#x00d6') ; $=XML_('╟',"boxVr") ; $=XML_('·',"middledot") ; $=XML_('Ç','#x00c7')
-x=XML_('ü',"uuml")             ; x=XML_('Ü',"Uuml")   ; x=XML_('╚',"boxUR") ; x=XML_('·',"centerdot")
+$=XML_('Ü',"Uuml")   ; $=XML_('╚',"boxUR") ; $=XML_('·',"centerdot") ; $=XML_('ü',"uuml")
-x=XML_('ü','#x00fc')           ; x=XML_('Ü','#x00dc') ; x=XML_('╔',"boxDR") ; x=XML_('·',"CenterDot")
+$=XML_('Ü','#x00dc') ; $=XML_('╔',"boxDR") ; $=XML_('·',"CenterDot") ; $=XML_('ü','#x00fc')
-x=XML_('é',"eacute")           ; x=XML_('¢',"cent")   ; x=XML_('╩',"boxHU") ; x=XML_('√',"radic")
+$=XML_('¢',"cent")   ; $=XML_('╩',"boxHU") ; $=XML_('√',"radic")     ; $=XML_('é',"eacute")
-x=XML_('é','#x00e9')           ; x=XML_('£',"pound")  ; x=XML_('╦',"boxHD") ; x=XML_('²',"sup2")
+$=XML_('£',"pound")  ; $=XML_('╦',"boxHD") ; $=XML_('²',"sup2")      ; $=XML_('é','#x00e9')
-x=XML_('â',"acirc")            ; x=XML_('¥',"yen")    ; x=XML_('╠',"boxVR") ; x=XML_('■',"squart ")
+$=XML_('¥',"yen")    ; $=XML_('╠',"boxVR") ; $=XML_('■',"square ")   ; $=XML_('â',"acirc")
-return x</lang>
+return $</lang>
 Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
-<br><br>
+{{out|output|text=&nbsp; when using the default (internal) input:}}
-'''output'''
 <pre>
 April

Revision as of 20:23, 18 May 2018

Alternative using a DOM document

Alternative version using Matreshka

tixi library

Fortran XML library (FoX)

Browser version

Node.js version

E4X version

version 1

version 2