XML/Input: Difference between revisions

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>

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

 

Expected Output

 

=={{header|8th}}==

\ Load the XML text into the var 'x':

\ Iterate over the XML document in the var 'x'

x @ ' .xml xml:each bye

{{out}}

April<br>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program inputXml64.s */

.include "../includeARM64.inc"

 

{{Output}}

<pre>

 

=={{header|ActionScript}}==

{

import flash.display.Sprite;

}

}

 

=={{header|Ada}}==

 

extract_students.adb:

with Input_Sources.Strings;

with Unicode.CES.Utf8;

My_Reader.Parse (Reader, Input);

Input_Sources.Strings.Close (Input);

 

my_reader.ads:

with Sax.Readers;

with Unicode.CES;

Qname : Unicode.CES.Byte_Sequence := "";

Atts : Sax.Attributes.Attributes'Class);

 

my_reader.adb:

package body My_Reader is

procedure Start_Element

end if;

end Start_Element;

 

Output:

 

===Alternative using a DOM document===

with Sax.Readers;

with Input_Sources.Strings;

end loop;

DOM.Readers.Free (Reader);

 

output is the same.

main.adb:

 

with XML.SAX.Input_Sources.Streams.Files;

with XML.SAX.Simple_Readers;

Reader.Set_Content_Handler (Handler'Unchecked_Access);

Reader.Parse (Input'Unchecked_Access);

 

handlers.ads:

 

with XML.SAX.Attributes;

with XML.SAX.Content_Handlers;

(Self : Handler) return League.Strings.Universal_String;

 

 

handlers.adb:

 

 

package body Handlers is

end Start_Element;

 

 

=={{header|Aikido}}==

Put the XML in the file called t.xml

import xml

 

}

 

The output is (Aikido doesn't support unicode rendering):

April

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program inputXml.s */

pop {r1-r4}

bx lr

{{output}}

<pre>

Normal end of program.

</pre>

 

=={{header|AutoHotkey}}==

simply using regular expressions

(

<Students>

names .= name1 . "`n"

 

 

=={{header|AWK}}==

The following code extracts the value of the property "Name" from every Student tag. It does not handle the <tt>&amp;#CODE;</tt>; 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.

 

{

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

print k

}

Using [http://awk.info/?getxml getXML.awk] written by Jan Weber, one could do this:

 

{{works with|gawk}} or {{works with|nawk}}

$1 == "TAG" {tag = $2}

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

Using [http://home.vrweb.de/~juergen.kahrs/gawk/XML/xmlgawk.html#Steve-Coile_0027s-xmlparse_002eawk-script xmlparser.awk] by Steve Coile, one can do this:

 

{{works with|gawk}}

$1 == "begin" {tag = $2}

$1 == "attrib" {attrib = $2}

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

 

Both of these produce this output

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

xmlfile$ = "C:\students.xml"

PROC_initXML(xmlobj{}, xmlfile$)

UNTIL FN_getLevel(xmlobj{}) < level%

Output:

<pre>

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 <code>(? (Name.?name) ?,</code> pattern) and open tags (the <code>? (Name.?name) ?</code> pattern).

Reading input from a file:

& ( get$("students.xml",X,ML)

: ?

| !names

)

 

Alternative solution, reading input from memory:

& ( get

$ ( "<Students>

| !names

)

Output:

<pre>April Bob Chad Dave Émily</pre>

=={{header|C}}==

 

{{uses from|Library|libxml|component1=xmlDoc|component2=xmlNode|component3=xmlReadMemory|component4=xmlDocGetRootElement|component5=xmlFreeDoc|component6=xmlCleanupParser|component7=xmlNode|component8=XML_ELEMENT_NODE|component9=xmlAttr|component10=xmlHasProp}}

{{uses from|Library|C Runtime|component1=printf}}

#include <stdlib.h>

#include <string.h>

xmlCleanupParser();

return 0;

 

=={{header|C sharp}}==

class Program

{

}

}

 

=={{header|C++}}==

{{uses from|Library|Qt|component1=QDomDocument|component2=QObject|component3=QDomElement}}

 

Using the Qt library's XML parser.

*/

}

return 0;

 

=={{header|Caché ObjectScript}}==

 

{

 

}

 

{{out|Examples}}

<pre>

{{uses from|Library|clojure.xml|component1=parse}}

This version uses the standard Clojure function ''xml-seq'

(import '(java.io ByteArrayInputStream))

(use 'clojure.xml) ; defines 'parse

 

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

 

The parse produces a data structure where each element is represented as a map with '':tag'', '':attrs'', and '':content'' keys.

''xml-seq'' produces a sequence of such nodes by walking the resulting tree.

 

(doseq [{:keys [tag attrs]} (xml-seq students)]

(if (= :Student tag)

(println (:Name attrs))))

 

=={{header|Common Lisp}}==

{{libheader|Closure XML}}

 

"<Students>

<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />

(dom:do-node-list (child (dom:child-nodes students) (nreverse student-names))

(when (dom:element-p child)

 

 

=={{header|D}}==

{{libheader|KXML}}

char[]xmlinput =

"<Students>

break;

}

 

=={{header|Delphi}}==

//You need to use these units

uses

Showmessage(GetStudents(XMLInput));

end;

 

=={{header|Erlang}}==

-module( xml_input ).

 

<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />

</Students>".

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

open System.Xml

open System.Xml.Linq

let names = students.Attributes <| xn "Name"

Seq.iter ((fun (a : XAttribute) -> a.Value) >> printfn "%s") names

 

=={{header|Factor}}==

 

: print-student-names ( string -- )

</Student>

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

 

=={{header|Fantom}}==

using xml

 

}

}

 

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

 

include ffl/str.fs

include ffl/xis.fs

;

 

 

=={{header|Fortran}}==

Uses [https://github.com/DLR-SC/tixi tixi library] (+ LibXML, curl as dependencies)

 

program tixi_rosetta

use tixi

 

end program tixi_rosetta

 

Compile

Uses [https://github.com/andreww/fox FoX]

 

program fox_rosetta

use FoX_dom

call destroy(doc)

end program fox_rosetta

 

Output

Dave

&mily

</pre>

 

=={{header|Go}}==

Go's <tt>xml.Unmarshal</tt> uses reflection to fill in data-structures recursively.

 

import (

fmt.Println(s.Name)

}

{{out}}

<pre>

 

=={{header|Groovy}}==

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />

 

def students = new XmlParser().parseText(input)

 

=={{header|Haskell}}==

import Text.XML.Light

 

xmlRead elm name = mapM_ putStrLn

. concatMap (map (fromJust.findAttr (unqual name)).filterElementsName (== unqual elm))

Show names:

April

Bob

Chad

Dave

 

=={{header|HicEst}}==

 

READ(ClipBoard) in

<pre>out is returned as:

April Bob Chad Dave &#x00C9;mily

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:

 

saxclass 'Students'

cocurrent'base'

April

Bob

 

and the definition of the variable <code>XML</code>:

<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

</Students>

 

=={{header|Java}}==

{{uses from|Library|java.io|component1=IOException|component2=StringReader}}

{{uses from|Library|org.xml.sax|component1=Attributes|component2=InputSource|component3=SAXException|component4=XMLReader|component5=helpers.DefaultHandler|component6=helpers.XMLReaderFactory}}

import java.io.StringReader;

import org.xml.sax.Attributes;

}

}

 

=={{header|JavaScript}}==

=== Browser version ===

This version tested against Chrome 37, Firefox 32, and IE 11:

var xmlstr = '<Students>' +

'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +

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

}

{{works with|Mozilla Firefox|32}}

 

=== Node.js version ===

var parseString = require('xml2js').parseString;

var xmlstr = '<Students>' +

}

});

 

=== E4X version ===

Alternatively, use the E4X featureset (currently only in Firefox):

var xmlstr = '<Students>' +

'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +

 

alert(output);

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

let docstr = """<Students>

println(attribute(elem, "Name"))

end

 

{{out}}

=={{header|Kotlin}}==

As this is just a small XML document, the DOM parser has been used rather than the SAX parser:

 

import javax.xml.parsers.DocumentBuilderFactory

}

}

 

{{out}}

=={{header|Lasso}}==

Task calls for a result not using Xpaths. Thus two examples shown. First uses Xpath, second uses regular expression.

define xml_attrmap(in::xml_namedNodeMap_attr) => {

local(out = map)

}

#names -> join('<br />')

'<hr />'

local(

#names -> insert(#regexp -> matchstring(1))

}

Output:

<pre>April

 

=={{header|Lingo}}==

r = RETURN

xml = "<Students>"&r&\

repeat with c in res.child

put c.attributes.name

 

{{out}}

=={{header|LiveCode}}==

Put the XML text in a text field called FieldXML for this exercise.

 

=={{header|Lua}}==

Requires LuaExpat

require 'lxp'

data = [[<Students>

p:parse(data)

p:close()

Output:

<pre>

Declare Object Nothing is optional. COM objects deleted when module exit by default.

 

Module CheckIt {

Const Enumerator=-4&

}

CheckIt

{{out}}

<pre>

</pre >

 

Bob

Chad

 

=={{header|MATLAB}}==

docRootNode = RootXML.getDocumentElement;

thisElement = RootXML.createElement('Student');

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

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

 

{{out}}

 

=={{header|Neko}}==

XML/Input in Neko

Tectonics:

parse_xml(xmlString, events);

 

 

{{out}}

<pre>

prompt$ nekoc xml-input.neko

Bob

Chad

Dave

<pre>

prompt$ neko xml-input.n | recode html

 

=={{header|newLISP}}==

(set 'xml-input "<Students>

<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />

(if (= (length x) 6)

(println (last (sexp (chop x))))))

 

Output:

 

=={{header|Nim}}==

 

let doc = newStringStream """<Students>

 

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

Output:

<pre>April

 

=={{header|Objeck}}==

use XML;

 

}

}

 

=={{header|OCaml}}==

from the toplevel using the library [http://tech.motion-twin.com/xmllight.html xml-light]:

# #load "xml-light.cma" ;;

 

Dave

&#x00C9;mily

 

Another solution using the library [http://erratique.ch/software/xmlm xmlm]:

#load "xmlm.cmo"

open Xmlm

List.iter (function ((_, "Name"), name) -> print_endline name | _ -> ()) attrs

| _ -> ()

 

using the [http://www.xs4all.nl/~mmzeeman/ocaml/ ocaml expat wrapper]:

 

 

let xml_str = "

);

parse p xml_str;

 

=={{header|OpenEdge ABL/Progress 4GL}}==

 

/** ==== Definitions ===== **/

DEFINE VARIABLE chXMLString AS LONGCHAR NO-UNDO.

END.

 

 

=={{header|OpenEdge/Progress}}==

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

 

DEF VAR lcc AS LONGCHAR.

DEF VAR hxdoc AS HANDLE.

DELETE OBJECT hxdoc.

 

 

'''Output:'''

 

=={{header|Oz}}==

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

Parser = {New XMLParser.parser init}

StudentNames = {Map Students GetStudentName}

in

 

=={{header|Perl}}==

{{libheader|XML::Simple}}

use XML::Simple;

 

</Students>');

 

{{out}}

<pre>April

 

=={{header|Phix}}==

{{out}}

<pre>

"April"

 

=={{header|PHP}}==

$data = '<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

if ( XMLREADER::ELEMENT == $xml->nodeType && $xml->localName == 'Student' )

echo $xml->getAttribute('Name') . "\n";

 

=={{header|PicoLisp}}==

 

(mapcar

'((L) (attr L 'Name))

Output:

<pre>-> ("April" "Bob" "Chad" "Dave" "Émily")</pre>

 

=={{header|Pike}}==

string in = "<Students>\n"

" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"

collect += ({ node->get_attributes()->Name });

});

 

Output:

 

=={{header|PowerShell}}==

[xml]$xml = @'

<Students>

 

 

 

=={{header|PureBasic}}==

Uses a PureBasic XML library (which is linked automatically) that is based on the library [http://expat.sourceforge.net/ expat XML parser] licensed under the MIT license.

 

src$ = "<Students>"

MessageRequester("Student Names", studentNames\s)

FreeXML(0)

Sample output:

<pre>

 

=={{header|Python}}==

 

doc = """<Students>

 

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

 

=={{header|R}}==

{{libheader|XML}}

#Read in XML string

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

</Students>'))

close(tc)

[1] "<Students>"

[2] " <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"

[8] " <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />"

[9] "</Students>"

xmltree <- xmlTreeParse(str)

 

#Change the encoding so that Emily displays correctly

Encoding(studentsnames) <- "UTF-8"

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

 

=={{header|Racket}}==

 

#lang racket

(require xml xml/path)

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

 

=={{header|Raku}}==

 

{{libheader|XML}}

 

my $xml = from-xml '<Students>

</Students>';

 

 

=={{header|Rascal}}==

 

public void getNames(loc a){

case element(_,"Student",[_*,attribute(_,"Name", x),_*]): println(x);

};

Output:

April

Bob

Dave

Émily

 

=={{header|REBOL}}==

Title: "XML Reading"

URL: http://rosettacode.org/wiki/XML_Reading

print select student/2 "Name"

]

 

Output:

=={{header|REXX}}==

===version 1===

g.=

g.1 = '<Students> '

parse var g.j 'Name="' studname '"'

if studname\=='' then say studname

{{out|output|text=&nbsp; when using the default (internal) input:}}

<pre>

===version 2===

This REXX version handles more HTML tags for output.

g.=

g.1 = '<Students> '

$=XML_('£',"pound") ; $=XML_('╦',"boxHD") ; $=XML_('²',"sup2") ; $=XML_('é','#x00e9')

$=XML_('¥',"yen") ; $=XML_('╠',"boxVR") ; $=XML_('■',"square ") ; $=XML_('â',"acirc")

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

 

=={{header|Ruby}}==

{{libheader|REXML}}

include REXML

 

 

# using xpath

 

=={{header|Run BASIC}}==

'XMLPARSER methods

 

print count;" ";#spy value$();" ->";#spy ATTRIBVALUE$(1)

 

=={{header|Rust}}==

This implementation uses [https://crates.io/crates/xml-rs xml-rs], which provides a streaming reader API.

 

use xml::{name::OwnedName, reader::EventReader, reader::XmlEvent};

 

}

Ok(())

 

{{out}}

This DOM can then be iterated in a convenient fashion.

 

 

const DOCUMENT: &str = r#"

Ok(())

}

 

{{out}}

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

 

<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

</Students>

 

 

=={{header|Sidef}}==

{{trans|Perl}}

 

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

</Students>');

 

{{out}}

<pre>

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

 

tree: (Xml SimpleParser newOn: '<Students>

Dave

&#x00C9;mily

 

=={{header|Tcl}}==

Using {{libheader|tDOM}}

set tree [dom parse $xml]

set studentNodes [$tree getElementsByTagName Student] ;# or: set studentNodes [[$tree documentElement] childNodes]

foreach node $studentNodes {

puts [$node getAttribute Name]

Using {{libheader|TclXML}}

set parser [xml::parser -elementstartcommand elem]

proc elem {name attlist args} {

}

}

 

Using just pure-Tcl (originally on http://wiki.tcl.tk/3919):

regsub -all {>\s*<} [string trim $xml " \n\t<>"] "\} \{" xml

set xml [string map {> "\} \{#text \{" < "\}\} \{"} $xml]

}

}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

MODE DATA

ENDLOOP

ENDCOMPILE

Output:

<pre>

The name Émily is properly converted from the HTML/XML escape syntax.

 

@(collect :vars (NAME GENDER YEAR MONTH DAY (PET_TYPE "none") (PET_NAME "")))

@ (cases)

@{NAME 12} @GENDER @YEAR-@MONTH-@DAY @PET_TYPE @PET_NAME

@ (end)

 

Sample run:

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

 

@NAME

 

<pre>

 

=={{header|VBA}}==

 

Const strXml As String = "" & _

End If

Set myNodes = Nothing

{{out}}

<pre>April

=={{header|Vedit macro language}}==

This implementation finds all ''Student'' tags and then displays the contents of their ''Name'' parameter.

Search("<Student|X", ERRBREAK)

#1 = Cur_Pos

Type_Block(#2, Cur_Pos)

Type_Newline

 

Output:

 

=={{header|Visual Basic .NET}}==

<Student Name="April"/>

<Student Name="Bob"/>

For Each name In names

Console.WriteLine(name)

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

Wren doesn't currently have an XML parser though we don't really need one for this task as string pattern matching is sufficient to extract the student names.

 

var xml =

}

}

 

{{out}}

Émily

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

CrLf(0);

];

 

{{out}}

 

=={{header|Yabasic}}==

 

data 32, 173, 189, 156, 207, 190, 221, 245, 249, 184, 166, 174, 170, 32, 169, 238

name$ = convASCII$(mid$(xml$, p, p2 - p), "&#x")

print name$

 

=={{header|zkl}}==

Uses regular expressions and the data is in a file identical to task description.<br/>

Assumes: a name attribute is complete in a line and only one name per line.

unicode:=RegExp(0'|.*(&#x[0-9a-fA-F]+;)|);

xml:=File("foo.xml").read();

});

 

{{out}}<pre>L("April","Bob","Chad","Dave","Émily")</pre>