Rosetta Code

XML/XPath: Difference between revisions

Page Discussion

XML/XPath (view source)

Revision as of 20:44, 27 March 2024

16,817 bytes added ,  2 months ago
Added FreeBASIC
(Replaced the wrong solution with a solution which uses "libxml2" as external library.)
(Added FreeBASIC)
 
(11 intermediate revisions by 9 users not shown)
Line 36:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
<lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program xpathXml64.s */
Line 254:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
</lang>
{{output}}
<pre>
Line 284:
''AppleScript has no-built in support for XPath, but it could be used via a 'do shell script' command. Here's a solution using Apple System Events.
 
<langsyntaxhighlight AppleScriptlang="applescript">set theXMLdata to "<inventory title=\"OmniCorp Store #45x10^3\">
<section name=\"health\">
<item upc=\"123456789\" stock=\"12\">
Line 344:
return my getElementValuesByName(xmlData's contents, "price") -- Solution to part 3 of problem.
end tell</langsyntaxhighlight>Output for the three results (respectively):<langsyntaxhighlight AppleScriptlang="applescript">"<item upc=\"123456789\" stock=\"12\">
<name>Invisibility Cream</name>
<price>14.50</price>
Line 352:
{"Invisibility Cream", "Levitation Salve", "Blork and Freen Instameal", "Grob winglets"}
 
{"14.50", "23.99", "4.95", "3.56"}</langsyntaxhighlight>
 
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
<lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program xpathXml.s */
Line 590:
bx lr @ return
 
</syntaxhighlight>
</lang>
{{output}}
<pre>
Line 617:
=={{header|AutoHotkey}}==
With regular expressions
<langsyntaxhighlight AutoHotkeylang="autohotkey">FileRead, inventory, xmlfile.xml
 
RegExMatch(inventory, "<item.*?</item>", item1)
Line 628:
While, pos := RegExMatch(inventory, "<name>.*?</name>", name, pos + 1)
names .= name . "`n"
MsgBox % names</langsyntaxhighlight>
{{libheader|AHK XPath}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">#Include xpath.ahk
 
xpath_load(doc, "xmlfile.xml")
Line 644:
 
; Get an array of all the "name" elements
MsgBox % xpath(doc, "/inventory/section/item/name")</langsyntaxhighlight>
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat">{Retrieve the first "item" element}
( nestML$(get$("doc.xml",X,ML))
: ?
Line 712:
?
| out$!anArray {Not truly an array, but a list.}
);</langsyntaxhighlight>
 
=={{header|C}}==
{{libheader|LibXML}}
Takes XML document and XPath expression as inputs and prints results, usage is printed if invoked incorrectly.
<syntaxhighlight lang="c">
<lang C>
#include <libxml/parser.h>
#include <libxml/xpath.h>
Line 773:
return 0;
}
</langsyntaxhighlight>
testXML.xml contains the XML mentioned in the task description. Code must be compiled with the correct flags.
<pre>
Line 790:
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">XmlReader XReader;
// Either read the xml from a string ...
Line 831:
// Convert the generic list to an array and output the count of items.
Console.WriteLine(NodesValues.ToArray().Length);</langsyntaxhighlight>
 
=={{header|C++}}==
Line 838:
 
{{libheader|LibXML}}
<langsyntaxhighlight lang="cpp">#include <cassert>
#include <cstdlib>
#include <iostream>
Line 1,027:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Caché ObjectScript}}==
 
<langsyntaxhighlight lang="cos">Class XML.Inventory [ Abstract ]
{
 
Line 1,099:
}
 
}</langsyntaxhighlight>
{{out|Examples}}
<pre>
Line 1,110:
=={{header|CoffeeScript}}==
<div class='mw-collapsible mw-collapsed'>
<langsyntaxhighlight lang="coffeescript">
doc = new DOMParser().parseFromString '
<inventory title="OmniCorp Store #45x10^3">
Line 1,139:
</inventory>
', 'text/xml'
</syntaxhighlight>
</lang>
</div>
<nowiki>#</nowiki> "doc" is the XML as a Document object. Click expand to see parsing code ⇒
 
<langsyntaxhighlight lang="coffeescript">
# Retrieve the first "item" element
doc.evaluate('//item', doc, {}, 7, {}).snapshotItem 0
Line 1,156:
names = for i in [0...names.snapshotLength] by 1
names.snapshotItem i
</syntaxhighlight>
</lang>
 
=={{header|ColdFusion}}==
<langsyntaxhighlight lang="cfm"><cfsavecontent variable="xmlString">
<inventory
...
Line 1,179:
<cfset names = xmlSearch(xml, "//name")>
<!--- visualize the results --->
<cfdump var="#variables#"></langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 1,186:
{{libheader|cxml-stp}}
 
<langsyntaxhighlight lang="lisp">(dolist (system '(:xpath :cxml-stp :cxml))
(asdf:oos 'asdf:load-op system))
 
Line 1,200:
 
(node-array
(xpath:evaluate "/inventory/section/item/name" *doc*))</langsyntaxhighlight>
 
=={{header|D}}==
It is important to note that the KXML library currently only supports XPath minimally.
{{libheader|KXML}}
<langsyntaxhighlight lang="d">import kxml.xml;
char[]xmlinput =
"<inventory title=\"OmniCorp Store #45x10^3\">
Line 1,241:
}
auto namearray = root.parseXPath("inventory/section/item/name");
}</langsyntaxhighlight>
 
=={{header|Delphi}}==
<langsyntaxhighlight Delphilang="delphi">program XMLXPath;
 
{$APPTYPE CONSOLE}
Line 1,308:
for s in lItemNames do
Writeln('Item name = ' + s);
end.</langsyntaxhighlight>
 
Output:
<syntaxhighlight lang="text">First item node:
<item upc="123456789" stock="12">
<name>Invisibility Cream</name>
Line 1,326:
Item name = Levitation Salve
Item name = Blork and Freen Instameal
Item name = Grob winglets</langsyntaxhighlight>
 
=={{header|E}}==
Line 1,332:
{{libheader|E-XML}} (currently a very early work in progress/draft library; design comments welcome)
 
<langsyntaxhighlight lang="e">? def xml__quasiParser := <import:org.switchb.e.xml.makeXMLQuasiParser>()
> def xpath__quasiParser := xml__quasiParser.xPathQuasiParser()
> null
Line 1,382:
# xml`<name>Blork and Freen Instameal</name>`,
# xml`<name>Grob winglets</name>`]
</syntaxhighlight>
</lang>
 
=={{header|Erlang}}==
Line 1,388:
{{libheader|xmerl}}
 
<langsyntaxhighlight lang="erlang">
-module(xml_xpath).
-include_lib("xmerl/include/xmerl.hrl").
Line 1,437:
[ Content#xmlText.value
|| #xmlElement{content = [Content|_]} <- xmerl_xpath:string("//name", Document)].
</syntaxhighlight>
</lang>
 
Output:<pre>First item:
Line 1,454:
"Blork and Freen Instameal","Grob winglets"]
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="vbnet">Dim As String XML, item, price, nombre
Dim As Integer P1, P2
 
'' Read the XML file
Open "test3.xml" For Input As #1
XML = Input(Lof(1), #1)
Close #1
 
'' Find the first 'item' element
P1 = Instr(XML, "<item ")
P2 = Instr(XML, "</item>")
item = Mid(XML, P1, P2-P1+7)
Print "The first 'item' element is:"
Print item
 
'' Find all 'price' elements
Print "The 'prices' are:"
P1 = 1
Do
P1 = Instr(P1, XML, "<price>")
If P1 = 0 Then Exit Do
P2 = Instr(P1, XML, "</price>")
price = Mid(XML, P1+7, P2-P1-7)
Print price
P1 = P2 + 1
Loop
 
'' Find all 'nombre' elements
Print !"\nThe 'names' are:"
P1 = 1
Do
P1 = Instr(P1, XML, "<name>")
If P1 = 0 Then Exit Do
P2 = Instr(P1, XML, "</name>")
nombre = Mid(XML, P1+6, P2-P1-6)
Print nombre
P1 = P2 + 1
Loop
 
Sleep</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
open System.IO
open System.Xml.XPath
Line 1,499 ⟶ 1,541:
 
// array of all name elements
let names = seq { for name in nav.Select(@"//name") do yield name } |> Seq.toArray</langsyntaxhighlight>
 
=={{header|Factor}}==
Line 1,506 ⟶ 1,548:
{{libheader|xml.traversal}}
 
<langsyntaxhighlight lang="factor">
 
! Get first item element
Line 1,591 ⟶ 1,633:
</section>
</inventory>""" string>xml "name" deep-tags-named
</syntaxhighlight>
</lang>
 
=={{header|Gastona}}==
The example uses the command XMELON which parses a XML file of any schema and stores its
contents into db tables. This parser is described in the article [http://web3.codeproject.com/Articles/680642/XMeLon-Schema XMeLon-Schema]
<langsyntaxhighlight lang="gastona">#javaj#
 
<frames> oSal, XML Path sample, 300, 400
Line 1,674 ⟶ 1,716:
,, VAR+, tabnames, @<value>
DUMP, data,, tabnames
</syntaxhighlight>
</lang>
 
{{out|Output}}
Line 1,704 ⟶ 1,746:
=={{header|Go}}==
Using the standard <code>encoding/xml</code> package:
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,783 ⟶ 1,825:
}
fmt.Printf("names: %q\n", names)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,806 ⟶ 1,848:
 
{{libheader|xmlpath}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,843 ⟶ 1,885:
fmt.Println("no names")
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,853 ⟶ 1,895:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def inventory = new XmlSlurper().parseText("<inventory...") //optionally parseText(new File("inv.xml").text)
def firstItem = inventory.section.item[0] //1. first item
inventory.section.item.price.each { println it } //2. print each price
def allNamesArray = inventory.section.item.name.collect {it} //3. collect item names into an array</langsyntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List
import Control.Arrow
import Control.Monad
Line 1,883 ⟶ 1,925:
putStrLn "\n== Names ==\n"
print $ getsingleLineItems "name" xmlText</langsyntaxhighlight>
Using the Haskell XML Toolkit (HXT):
<langsyntaxhighlight lang="haskell">{-# LANGUAGE Arrows #-}
import Text.XML.HXT.Arrow
{- For HXT version >= 9.0, use instead:
Line 1,902 ⟶ 1,944:
[(item, names)] <- runX (readDocument [] "xmlpath.xml" >>> process)
print item
print names</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight lang="hicest">CHARACTER xml*1000, output*1000
READ(ClipBoard) xml
 
Line 1,919 ⟶ 1,961:
 
EDIT(Text=xml, SPR='<>', R='<name>', W=1, WordEnd=$CR, APpendTo=output, DO=999)
WRITE(ClipBoard) TRIM(output) </langsyntaxhighlight>
<langsyntaxhighlight lang="hicest"> upc="123456789" stock="12">
<name>Invisibility Cream</name>
<price>14.50</price>
Line 1,933 ⟶ 1,975:
Blork and Freen Instameal
Grob winglets
</syntaxhighlight>
</lang>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.io.StringReader;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
Line 1,995 ⟶ 2,037:
}
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
{{works with|Firefox|2.0}}
<langsyntaxhighlight lang="javascript">//create XMLDocument object from file
var xhr = new XMLHttpRequest();
xhr.open('GET', 'file.xml', false);
Line 2,021 ⟶ 2,063:
namesArray.push( name );
}
alert( namesArray );</langsyntaxhighlight>
 
Although some browsers support XPath, working with XML is much easier with E4X.
 
<langsyntaxhighlight lang="javascript">//create XML object from file
var xhr = new XMLHttpRequest();
xhr.open('GET', 'file.xml', false);
Line 2,045 ⟶ 2,087:
names.push( name );
}
alert( names );</langsyntaxhighlight>
 
=={{header|Julia}}==
Line 2,051 ⟶ 2,093:
vague about output format, so this is varied in the solution below. The first
test prints the raw XML node, and the second and third are further processed.
<langsyntaxhighlight lang="julia">using LibExpat
 
xdoc = raw"""<inventory title="OmniCorp Store #45x10^3">
Line 2,096 ⟶ 2,138:
namearray = LibExpat.find(etree, "//name")
println("Array of names of items:\n\t", map(s -> debracket(string(s)), namearray))
</langsyntaxhighlight>{{output}}<pre>
The first item's node XML entry is:
<item upc="123456789" stock="12">
Line 2,117 ⟶ 2,159:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.3
 
import javax.xml.parsers.DocumentBuilderFactory
Line 2,179 ⟶ 2,221:
println("\nThe names of each item are as follows :")
println(" ${names.joinToString("\n ")}")
}</langsyntaxhighlight>
 
{{out}}
Line 2,193 ⟶ 2,235:
Grob winglets
</pre>
 
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
 
# Perform XPath queries on a XML Document
 
# # Variables:
#
typeset -T Xml_t=(
typeset -h 'UPC' upc
typeset -i -h 'num in stock' stock=0
typeset -h 'name' name
typeset -F2 -h 'price' price
typeset -h 'description' description
 
function init_item {
typeset key ; key="$1"
typeset val ; val="${2%\<\/${key}*}"
 
case ${key} in
upc) _.upc="${val//@(\D)/}"
;;
stock) _.stock="${val//@(\D)/}"
;;
name) _.name="${val%\<\/${key}*}"
;;
price) _.price="${val}"
;;
description) _.description=$(echo ${val})
;;
esac
}
 
function prt_item {
print "upc= ${_.upc}"
print "stock= ${_.stock}"
print "name= ${_.name}"
print "price= ${_.price}"
print "description= ${_.description}"
}
)
 
# # Functions:
#
 
 
######
# main #
######
integer i=0
typeset -a Item_t
 
buff=$(< xmldoc) # read xmldoc
item=${buff%%'</item>'*} ; buff=${.sh.match}
 
while [[ -n ${item} ]]; do
Xml_t Item_t[i]
item=${item#*'<item'} ; item=$(echo ${item})
for word in ${item}; do
if [[ ${word} == *=* ]]; then
Item_t[i].init_item ${word%\=*} ${word#*\=}
else
if [[ ${word} == \<* ]]; then # Beginning
key=${word%%\>*} ; key=${key#*\<}
val=${word#*\>}
fi
 
[[ ${word} != \<* && ${word} != *\> ]] && val+=" ${word} "
 
if [[ ${word} == *\> ]]; then # End
val+=" ${word%\<${key}\>*}"
Item_t[i].init_item "${key}" "${val}"
fi
fi
done
(( i++ ))
item=${buff#*'</item>'} ; item=${item%%'</item>'*} ; buff=${.sh.match}
done
 
print "First Item element:"
Item_t[0].prt_item
 
typeset -a names
printf "\nList of prices:\n"
for ((i=0; i<${#Item_t[*]}-1; i++)); do
print ${Item_t[i].price}
names[i]=${Item_t[i].name}
done
 
printf "\nArray of names:\n"
for (( i=0; i<${#names[*]}; i++)); do
print "names[$i] = ${names[i]}"
done</syntaxhighlight>
{{out}}<pre>
First Item element:
upc= 123456789
stock= 12
name= Invisibility Cream
price= 14.50
description= Makes you invisible
 
List of prices:
14.50
23.99
4.95
3.56
 
Array of names:
names[0] = Invisibility Cream
names[1] = Levitation Salve
names[2] = Blork and Freen Instameal
names[3] = Grob winglets</pre>
 
=={{header|Lasso}}==
Lasso has built in support for both XML handling and Xpaths
<langsyntaxhighlight Lassolang="lasso">// makes extracting attribute values easier
define xml_attrmap(in::xml_namedNodeMap_attr) => {
local(out = map)
Line 2,265 ⟶ 2,420:
'<br /><br />'
'<strong>Array with all names:</strong><br />'
#xml -> extract('//name') -> asstaticarray</langsyntaxhighlight>
Output:
<pre>First item:
Line 2,282 ⟶ 2,437:
=={{header|LiveCode}}==
Copy the xml in this task into a text field called "FieldXML"
<langsyntaxhighlight LiveCodelang="livecode">put revXMLCreateTree(fld "FieldXML",true,true,false) into xmltree
 
// task 1
Line 2,295 ⟶ 2,450:
filter namenodes without empty
split namenodes using cr
put namenodes is an array</langsyntaxhighlight>
 
=={{header|Lua}}==
Requires LuaExpat
<langsyntaxhighlight lang="lua">require 'lxp'
data = [[<inventory title="OmniCorp Store #45x10^3">
<section name="health">
Line 2,342 ⟶ 2,497:
 
print('Name: ', table.concat(names, ', '))
print('Price: ', table.concat(prices, ', '))</langsyntaxhighlight>
Output:<pre>
<item upc="123456789" stock="12">
Line 2,353 ⟶ 2,508:
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">example = Import["test.txt", "XML"];
Cases[example, XMLElement["item", _ , _] , Infinity] // First
Cases[example, XMLElement["price", _, List[n_]] -> n, Infinity] // Column
Cases[example, XMLElement["name", _, List[n_]] -> n, Infinity] // Column</langsyntaxhighlight>
{{out}}
Output:<pre>
<pre>XMLElement[item,{upc->123456789,stock->12},
{XMLElement[name,{},{Invisibility Cream}],XMLElement[price,{},{14.50}],XMLElement[description,{},{Makes you invisible}]}]
 
14.50
23.99
4.95
3.56
 
Invisibility Cream
Levitation Salve
Blork and Freen Instameal
Grob winglets</pre>
</pre>
 
=={{header|NetRexx}}==
{{trans|Java}}
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
 
import javax.xml.parsers.
import javax.xml.xpath.
import org.w3c.dom.
import org.w3c.dom.Node
import org.xml.sax.
 
Line 2,453 ⟶ 2,606:
 
return
</syntaxhighlight>
</lang>
'''Output:'''
<pre>
Line 2,476 ⟶ 2,629:
Nim standard library provides several modules to process XML, but none to process XPath requests. There is no third party library to do that either.
 
So we provide here a solution which uses the C "libxml2" library. Nim allows to interface with C with a great flexibility. Declaring the external functionfunctions is quite easy. The major part of the work consists into declaringdeclare the data types. In "libxml2" there are a lot of structures and we have translated only what is needed to solve the task (or actually a bit more actually).
 
For the first request, we use <code>//section[1]/item[1]</code> instead of <code>//item[1]</code> (asthis is also what the Python version does). The latter request works but returnsit the list ofreturns the first elementselement in each section which doesn’t seem to be what is expected.
 
<langsyntaxhighlight Nimlang="nim">import sequtils, strutils
 
const LibXml = "libxml2.so"
Line 2,664 ⟶ 2,817:
echo names
 
xmlXPathFreeContext(context)</langsyntaxhighlight>
 
{{out}}
Line 2,685 ⟶ 2,838:
=={{header|Objeck}}==
XPath is used to fetch element tags.
<langsyntaxhighlight lang="objeck">
use XML;
 
Line 2,743 ⟶ 2,896:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Oz}}==
We implement a small subset of XPath for this task:
<langsyntaxhighlight lang="oz">declare
[XMLParser] = {Module.link ['x-oz://system/xml/Parser.ozf']}
 
Line 2,833 ⟶ 2,986:
#"</inventory>"
in
{Main Data}</langsyntaxhighlight>
 
=={{header|Perl}}==
{{libheader|XML::XPath}}
<langsyntaxhighlight lang="perl">use XML::XPath qw();
 
my $x = XML::XPath->new('<inventory ... </inventory>');
Line 2,843 ⟶ 2,996:
[$x->findnodes('//item[1]')->get_nodelist]->[0];
print $x->findnodes_as_string('//price');
$x->findnodes('//name')->get_nodelist;</langsyntaxhighlight>
 
=={{header|Phix}}==
Phix has no direct support for XPath, but achieving the requirements using the standard xml_parse() is not exactly difficult.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>include builtins/xml.e
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">xml</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
constant xml_txt = """
<span style="color: #008080;">constant</span> <span style="color: #000000;">xml_txt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
<inventory title="OmniCorp Store #45x10^3">
&lt;inventory title="OmniCorp Store #45x10^3"&gt;
<section name="health">
&lt;section name="health"&gt;
<item upc="123456789" stock="12">
&lt;item upc="123456789" stock="12"&gt;
<name>Invisibility Cream</name>
&lt;name&gt;Invisibility Cream&lt;/name&gt;
<price>14.50</price>
&lt;price&gt;14.50&lt;/price&gt;
<description>Makes you invisible</description>
&lt;description&gt;Makes you invisible&lt;/description&gt;
</item>
&lt;/item&gt;
<item upc="445322344" stock="18">
&lt;item upc="445322344" stock="18"&gt;
<name>Levitation Salve</name>
&lt;name&gt;Levitation Salve&lt;/name&gt;
<price>23.99</price>
&lt;price&gt;23.99&lt;/price&gt;
<description>Levitate yourself for up to 3 hours per application</description>
&lt;description&gt;Levitate yourself for up to 3 hours per application&lt;/description&gt;
</item>
&lt;/item&gt;
</section>
&lt;/section&gt;
<section name="food">
&lt;section name="food"&gt;
<item upc="485672034" stock="653">
&lt;item upc="485672034" stock="653"&gt;
<name>Blork and Freen Instameal</name>
&lt;name&gt;Blork and Freen Instameal&lt;/name&gt;
<price>4.95</price>
&lt;price&gt;4.95&lt;/price&gt;
<description>A tasty meal in a tablet; just add water</description>
&lt;description&gt;A tasty meal in a tablet; just add water&lt;/description&gt;
</item>
&lt;/item&gt;
<item upc="132957764" stock="44">
&lt;item upc="132957764" stock="44"&gt;
<name>Grob winglets</name>
&lt;name&gt;Grob winglets&lt;/name&gt;
<price>3.56</price>
&lt;price&gt;3.56&lt;/price&gt;
<description>Tender winglets of Grob. Just add water</description>
&lt;description&gt;Tender winglets of Grob. Just add water&lt;/description&gt;
</item>
&lt;/item&gt;
</section>
&lt;/section&gt;
</inventory>
&lt;/inventory&gt;
""",
"""</span><span style="color: #0000FF;">,</span>
-- or, of course, xml_txt = get_text("input.xml")
<span style="color: #000080;font-style:italic;">-- or, of course, xml_txt = get_text("input.xml")</span>
xml = xml_parse(xml_txt)
<span style="color: #000000;">xml</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">xml_parse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">xml_txt</span><span style="color: #0000FF;">)</span>
 
sequence sections = xml_get_nodes(xml[XML_CONTENTS],"section"),
<span style="color: #004080;">sequence</span> <span style="color: #000000;">sections</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">xml_get_nodes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">xml</span><span style="color: #0000FF;">[</span><span style="color: #000000;">XML_CONTENTS</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"section"</span><span style="color: #0000FF;">),</span>
item1 = {},
<span style="color: #000000;">item1</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span>
prices = {},
<span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span>
names = {}
<span style="color: #000000;">names</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
 
for s=1 to length(sections) do
<span style="color: #008080;">for</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sections</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
sequence items = xml_get_nodes(sections[s],"item")
<span style="color: #004080;">sequence</span> <span style="color: #000000;">items</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">xml_get_nodes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sections</span><span style="color: #0000FF;">[</span><span style="color: #000000;">s</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"item"</span><span style="color: #0000FF;">)</span>
if item1={} then item1 = items[1] end if
<span style="color: #008080;">if</span> <span style="color: #000000;">item1</span><span style="color: #0000FF;">={}</span> <span style="color: #008080;">then</span> <span style="color: #000000;">item1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">items</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
for i=1 to length(items) do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">items</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
prices = append(prices,xml_get_nodes(items[i],"price")[1][XML_CONTENTS])
<span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">prices</span><span style="color: #0000FF;">,</span><span style="color: #000000;">xml_get_nodes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">items</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"price"</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">XML_CONTENTS</span><span style="color: #0000FF;">])</span>
names = append(names,xml_get_nodes(items[i],"name")[1][XML_CONTENTS])
<span style="color: #000000;">names</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">names</span><span style="color: #0000FF;">,</span><span style="color: #000000;">xml_get_nodes</span><span style="color: #0000FF;">(</span><span style="color: #000000;">items</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"name"</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">XML_CONTENTS</span><span style="color: #0000FF;">])</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 
puts(1,"===item[1]===\n")
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"===item[1]===\n"</span><span style="color: #0000FF;">)</span>
sequence tmp = xml_new_doc(item1)
<span style="color: #004080;">sequence</span> <span style="color: #000000;">tmp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_doc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">item1</span><span style="color: #0000FF;">)</span>
puts(1,xml_sprint(tmp))
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">xml_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">))</span>
puts(1,"===prices===\n")
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"===prices===\n"</span><span style="color: #0000FF;">)</span>
pp(prices)
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">prices</span><span style="color: #0000FF;">)</span>
puts(1,"===names===\n")
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"===names===\n"</span><span style="color: #0000FF;">)</span>
pp(names,{pp_Maxlen,90})</lang>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">names</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">pp_Maxlen</span><span style="color: #0000FF;">,</span><span style="color: #000000;">90</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,916 ⟶ 3,071:
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php"><?php
//PHP5 only example due to changes in XML extensions between version 4 and 5 (Tested on PHP5.2.0)
$doc = DOMDocument::loadXML('<inventory title="OmniCorp Store #45x10^3">...</inventory>');
Line 2,945 ⟶ 3,100:
{
$result[] = $node;
}</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(load "@lib/xm.l")
 
(let Sections (body (in "file.xml" (xml)))
Line 2,959 ⟶ 3,114:
(for S Sections
(for L (body S)
(link (car (body L 'name))) ) ) ) )</langsyntaxhighlight>
Output:
<pre>(item
Line 2,974 ⟶ 3,129:
=={{header|PowerShell}}==
Cast the <code>$document</code> string as <code>[xml]</code> and you have access to .NET methods affecting XML.
<syntaxhighlight lang="powershell">
<lang PowerShell>
$document = [xml]@'
<inventory title="OmniCorp Store #45x10^3">
Line 3,006 ⟶ 3,161:
$query = "/inventory/section/item"
$items = $document.SelectNodes($query)
</syntaxhighlight>
</lang>
The first item:
<syntaxhighlight lang="powershell">
<lang PowerShell>
$items[0]
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 3,020 ⟶ 3,175:
</pre>
Get some useful information:
<syntaxhighlight lang="powershell">
<lang PowerShell>
$namesAndPrices = $items | Select-Object -Property name, price
$namesAndPrices
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 3,034 ⟶ 3,189:
</pre>
Here are the prices:
<syntaxhighlight lang="powershell">
<lang PowerShell>
$items.price
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 3,045 ⟶ 3,200:
</pre>
Here are the names:
<syntaxhighlight lang="powershell">
<lang PowerShell>
$items.name
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 3,057 ⟶ 3,212:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python"># Python has basic xml parsing built in
 
from xml.dom import minidom
Line 3,074 ⟶ 3,229:
 
# 3rd Task: Get an array of all the "name" elements
namesArray = xmldoc.getElementsByTagName("name")</langsyntaxhighlight>
In Python 2.5+ you can use ElementTree's limited XPath support
<langsyntaxhighlight lang="python">
import xml.etree.ElementTree as ET
 
Line 3,094 ⟶ 3,249:
 
# list of names
names = doc.findall("section/item/name") # or ".//name"</langsyntaxhighlight>
Or, you can install the <tt>lxml</tt> package and get full XPath support
<langsyntaxhighlight lang="python">
from lxml import etree
 
Line 3,111 ⟶ 3,266:
print "{0:0.2f}".format(float(p.text)) # could raise exception on missing text or invalid float() conversion
 
names = doc.xpath("//name") # list of names</langsyntaxhighlight>
 
=={{header|R}}==
{{libheader|XML (R)}}
<syntaxhighlight lang="r">
<lang R>## Require the XML package you can download from http://www.omegahat.org/RSXML/
library("XML")
doc <- xmlInternalTreeParse("test3.xml")
 
# 1st Task: Retrieve the first "item" element
# Retrieve the first "item" element
(firstItemElement <- getNodeSet(doc, "//item")[[1]])
getNodeSet(doc, "//item")[[1]]
# 2nd task: Perform an action on each "price" element (print it out)
 
prices <- sapply(getNodeSet(doc, "//price"), xmlValue)
# Perform an action on each "price" element
for(i in 1:length(prices)) print(prices[i])
sapply(getNodeSet(doc, "//price"), xmlValue)
# 3rd Task: Get an array of all the "name" elements
 
(namesArray <- sapply(getNodeSet(doc, "//name"), xmlValue))</lang>
# Get an array of all the "name" elements
sapply(getNodeSet(doc, "//name"), xmlValue)
 
</syntaxhighlight>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang at-exp racket
 
Line 3,175 ⟶ 3,334:
(se-path*/list '(item name) data)
;; => '("Invisibility Cream" "Levitation Salve" "Blork and Freen Instameal" "Grob winglets")
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
 
<syntaxhighlight lang="raku" perl6line>use XML::XPath;
 
my $XML = XML::XPath.new(xml => q:to/END/);
Line 3,216 ⟶ 3,375:
.contents.put for $XML.find('//price').List;
 
put "\nName elements:\n", $XML.find('//name')».contents.join: ', ';</langsyntaxhighlight>
{{out}}
<pre>First item:
Line 3,231 ⟶ 3,390:
 
=={{header|Rascal}}==
<langsyntaxhighlight lang="rascal">import lang::xml::DOM;
import Prelude;
 
Line 3,253 ⟶ 3,412:
L += n;
return L;
}</langsyntaxhighlight>
Example output:
<langsyntaxhighlight lang="rascal">rascal>get_first_item(|file:///Users/.../Desktop/xmlpath.xml|)
<?xml version="1.0" encoding="UTF-8"?>
<item stock="12" upc="123456789">
Line 3,274 ⟶ 3,433:
 
rascal>get_names(|file:///Users/.../Desktop/xmlpath.xml|)
list[str]: ["Invisibility Cream","Levitation Salve","Blork and Freen Instameal","Grob winglets"]</langsyntaxhighlight>
 
=={{header|REXX}}==
===hard coded parsing===
<langsyntaxhighlight lang="rexx">/*REXX program to parse various queries on an XML document (from a file). */
iFID='XPATH.XML' /*name of the input XML file (doc). */
$= /*string will contain the file's text. */
Line 3,312 ⟶ 3,471:
say names.k /*display a name from the NAMES list.*/
end /*k*/
/*stick a fork in it, we're all done. */</langsyntaxhighlight>
'''output'''
<pre>
Line 3,329 ⟶ 3,488:
 
===generic parsing===
<langsyntaxhighlight lang="rexx">/*REXX program to parse various queries on an XML document (from a file). */
iFID='XPATH.XML' /*name of the input XML file (doc). */
$= /*string will contain the file's text. */
Line 3,360 ⟶ 3,519:
end /*#*/
#=#-1 /*adjust # of thing found.*/
return</langsyntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> version.
 
=={{header|Ruby}}==
{{libheader|REXML}}
<langsyntaxhighlight lang="ruby">#Example taken from the REXML tutorial (http://www.germane-software.com/software/rexml/docs/tutorial.html)
require "rexml/document"
include REXML
Line 3,380 ⟶ 3,539:
XPath.each( doc, "//price") { |element| puts element.text }
# Gets an array of all of the "name" elements in the document.
names = XPath.match( doc, "//name" )</langsyntaxhighlight>
 
=={{header|Scala}}==
Line 3,387 ⟶ 3,546:
better show the results.
 
<langsyntaxhighlight lang="scala">
scala> val xml: scala.xml.Elem =
| <inventory title="OmniCorp Store #45x10^3">
Line 3,431 ⟶ 3,590:
 
scala> val names = (xml \\ "name").toArray
names: Array[scala.xml.Node] = Array(<name>Invisibility Cream</name>, <name>Levitation Salve</name>, <name>Blork and Freen Instameal</name>, <name>Grob winglets</name>)</langsyntaxhighlight>
 
=={{header|SenseTalk}}==
<langsyntaxhighlight lang="sensetalk">Set XMLSource to {{
<inventory title="OmniCorp Store #45x10^3">
<section name="health">
Line 3,465 ⟶ 3,624:
put node "//item[1]" of XMLSource
put node "//price/text()" of XMLSource
put all nodes "//name" of XMLSource</langsyntaxhighlight>
 
{{out}}
Line 3,480 ⟶ 3,639:
=={{header|Sidef}}==
{{trans|Perl}}
<langsyntaxhighlight lang="ruby">require('XML::XPath');
 
var x = %s'XML::XPath'.new(ARGF.slurp);
Line 3,486 ⟶ 3,645:
[x.findnodes('//item[1]')][0];
say [x.findnodes('//price')].map{x.getNodeText(_)};
[x.findnodes('//name')];</langsyntaxhighlight>
 
{{out}}
Line 3,495 ⟶ 3,654:
=={{header|Tcl}}==
{{libheader|tDOM}}
<langsyntaxhighlight lang="tcl"># assume $xml holds the XML data
package require tdom
set doc [dom parse $xml]
Line 3,508 ⟶ 3,667:
foreach node [$root selectNodes //price] {
puts [$node text]
}</langsyntaxhighlight>
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT,{}
MODE DATA
Line 3,574 ⟶ 3,733:
names=SPLIT(names)
TRACE *firstitem,names
</syntaxhighlight>
</lang>
Output:
<pre style='height:30ex;overflow:scroll'>
Line 3,596 ⟶ 3,755:
 
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
<lang vb>
Set objXMLDoc = CreateObject("msxml2.domdocument")
 
Line 3,626 ⟶ 3,785:
WScript.StdOut.Write list_name
WScript.StdOut.WriteBlankLines(2)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,642 ⟶ 3,801:
=={{header|Visual Basic .NET}}==
 
<langsyntaxhighlight lang="vbnet">Dim first_item = xml.XPathSelectElement("//item")
Console.WriteLine(first_item)
Line 3,649 ⟶ 3,808:
Next
Dim names = (From item In xml.XPathSelectElements("//name") Select item.Value).ToArray</langsyntaxhighlight>
 
=={{header|Wren}}==
{{libheader|Wren-pattern}}
Wren does not have built-in support for XML/XPath and, to my knowledge, there is no third party module which adds such support either. We therefore have to fall back on string pattern matching to perform the required queries.
<syntaxhighlight lang="wren">import "./pattern" for Pattern
 
var doc = """
<inventory title="OmniCorp Store #45x10^3">
<section name="health">
<item upc="123456789" stock="12">
<name>Invisibility Cream</name>
<price>14.50</price>
<description>Makes you invisible</description>
</item>
<item upc="445322344" stock="18">
<name>Levitation Salve</name>
<price>23.99</price>
<description>Levitate yourself for up to 3 hours per application</description>
</item>
</section>
<section name="food">
<item upc="485672034" stock="653">
<name>Blork and Freen Instameal</name>
<price>4.95</price>
<description>A tasty meal in a tablet; just add water</description>
</item>
<item upc="132957764" stock="44">
<name>Grob winglets</name>
<price>3.56</price>
<description>Tender winglets of Grob. Just add water</description>
</item>
</section>
</inventory>
"""
 
var p1 = Pattern.new("<item ")
var match1 = p1.find(doc)
var p2 = Pattern.new("<//item>")
var match2 = p2.find(doc)
System.print("The first 'item' element is:")
System.print(" " + doc[match1.index..match2.index + 6])
 
var p3 = Pattern.new("<price>[+1^<]<//price>")
var matches = p3.findAll(doc)
System.print("\nThe 'prices' are:")
for (m in matches) System.print(m.captures[0].text)
 
var p4 = Pattern.new("<name>[+1^<]<//name>")
var matches2 = p4.findAll(doc)
var names = matches2.map { |m| m.captures[0].text }.toList
System.print("\nThe 'names' are:")
System.print(names.join("\n"))</syntaxhighlight>
 
{{out}}
<pre>
The first 'item' element is:
<item upc="123456789" stock="12">
<name>Invisibility Cream</name>
<price>14.50</price>
<description>Makes you invisible</description>
</item>
 
The 'prices' are:
14.50
23.99
4.95
3.56
 
The 'names' are:
Invisibility Cream
Levitation Salve
Blork and Freen Instameal
Grob winglets
</pre>
<br>
{{libheader|Wren-xsequence}}
Since the first version was written, the above XML parser has appeared. Consequently, the solution can now be rewritten as follows, the output being the same as before.
 
Note that this library doesn't support XPath as such though for this particular task simple 'for' statements suffice.
<syntaxhighlight lang="wren">import "./xsequence" for XDocument
 
var xml = """
<inventory title="OmniCorp Store #45x10^3">
<section name="health">
<item upc="123456789" stock="12">
<name>Invisibility Cream</name>
<price>14.50</price>
<description>Makes you invisible</description>
</item>
<item upc="445322344" stock="18">
<name>Levitation Salve</name>
<price>23.99</price>
<description>Levitate yourself for up to 3 hours per application</description>
</item>
</section>
<section name="food">
<item upc="485672034" stock="653">
<name>Blork and Freen Instameal</name>
<price>4.95</price>
<description>A tasty meal in a tablet; just add water</description>
</item>
<item upc="132957764" stock="44">
<name>Grob winglets</name>
<price>3.56</price>
<description>Tender winglets of Grob. Just add water</description>
</item>
</section>
</inventory>
"""
 
var doc = XDocument.parse(xml)
System.print("The first 'item' element is:")
System.print(doc.root.element("section").element("item"))
 
var prices = []
var names = []
for (el in doc.root.elements) {
for (el2 in el.elements) {
prices.add(el2.element("price").value)
names.add(el2.element("name").value)
}
}
System.print("\nThe 'prices' are:\n%(prices.join("\n"))")
System.print("\nThe 'names' are:\n%(names.join("\n"))")</syntaxhighlight>
 
=={{header|XPL0}}==
To run: xml <xml.xml
<syntaxhighlight lang "XPL0">include xpllib; \for StrFind
 
char XML(1000000), P, P1, P2, Addr;
int I, Ch;
[I:= 0;
loop [Ch:= ChIn(1);
XML(I):= Ch;
if Ch = $1A \EOF\ then quit;
I:= I+1;
];
XML(I):= 0;
 
P1:= StrFind(XML, "<item ");
P2:= StrFind(XML, "</item>");
Text(0, "The first 'item' element is:^m^j");
for P:= P1 to P2+6 do ChOut(0, P(0));
CrLf(0);
 
Text(0, "^m^jThe 'prices' are:^m^j");
Addr:= XML;
loop [P1:= StrFind(Addr, "<price>");
if P1 = 0 then quit;
P2:= StrFind(Addr, "</price>");
if P2 = 0 then quit;
for P:= P1+7 to P2-1 do ChOut(0, P(0));
CrLf(0);
Addr:= P2+1;
];
Text(0, "^m^jThe 'names' are:^m^j");
Addr:= XML;
loop [P1:= StrFind(Addr, "<name>");
if P1 = 0 then quit;
P2:= StrFind(Addr, "</name>");
if P2 = 0 then quit;
for P:= P1+6 to P2-1 do ChOut(0, P(0));
CrLf(0);
Addr:= P2+1;
];
]</syntaxhighlight>
{{out}}
<pre>
The first 'item' element is:
<item upc="123456789" stock="12">
<name>Invisibility Cream</name>
<price>14.50</price>
<description>Makes you invisible</description>
</item>
 
The 'prices' are:
14.50
23.99
4.95
3.56
 
The 'names' are:
Invisibility Cream
Levitation Salve
Blork and Freen Instameal
Grob winglets
</pre>
 
=={{header|XProc}}==
<langsyntaxhighlight lang="xml"><p:pipeline xmlns:p="http://www.w3.org/ns/xproc"
name="one-two-three"
version="1.0">
Line 3,681 ⟶ 4,027:
</p:input>
</p:insert>
</p:pipeline></langsyntaxhighlight>
 
=={{header|XQuery}}==
<langsyntaxhighlight lang="xquery">(:
1. Retrieve the first "item" element
Notice the braces around //item. This evaluates first all item elements and then retrieving the first one.
Line 3,702 ⟶ 4,048:
<prices>{$price}</prices>
<names>{$names}</names>
</result></langsyntaxhighlight>
 
Performing this XQuery on the given input document results in
<langsyntaxhighlight lang="xquery"><?xml version="1.0" encoding="UTF-8"?>
<result>
<firstItem>
Line 3,721 ⟶ 4,067:
<name>Grob winglets</name>
</names>
</result></langsyntaxhighlight>
 
=={{header|XSLT}}==
<langsyntaxhighlight lang="xml"><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text" />
<xsl:template match="/">
Line 3,747 ⟶ 4,093:
<xsl:copy-of select="//name" />
</xsl:template>
</xsl:stylesheet></langsyntaxhighlight>
 
{{omit from|Batch File|No way of XML parsing or processing.}}
Jjuanhdez
2,131

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/10048...362981"