Rosetta Code

XML/Output: Difference between revisions

Page Discussion

XML/Output (view source)

Revision as of 11:56, 17 February 2024

26,210 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(24 intermediate revisions by 16 users not shown)
Line 14:
Short & shrift</pre>
Should produce the XML (but not necessarily with the indentation):
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
The document may include an <tt><?xml?></tt> declaration and document type declaration, but these are optional. If attempting this task by direct string manipulation, the implementation ''must'' include code to perform entity substitution for the characters that have entities defined in the XML 1.0 specification.
Line 26:
 
'''Note to editors:''' Program output with escaped characters will be viewed as the character on the page so you need to 'escape-the-escapes' to make the RC entry display what would be shown in a plain text viewer (See [[Talk:XML_Creation#Escaping_Escapes|this]]).
Alternately, output can be placed in <nowiki><syntaxhighlight lang ="xml"></langsyntaxhighlight></nowiki> tags without any special treatment.
 
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program outputXml64.s */
/* use special library libxml2 */
/* special link gcc with options -I/usr/include/libxml2 -lxml2 */
 
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessEndpgm: .asciz "Normal end of program.\n"
szFileName: .asciz "file2.xml"
szFileMode: .asciz "w"
szMessError: .asciz "Error detected !!!!. \n"
szName1: .asciz "April"
szName2: .asciz "Tam O'Shanter"
szName3: .asciz "Emily"
szRemark1: .asciz "Bubbly: I'm > Tam and <= Emily"
szRemark2: .asciz "Burns: \"When chapman billies leave the street ...\""
szRemark3: .asciz "Short & shrift"
szVersDoc: .asciz "1.0"
szLibCharRem: .asciz "CharacterRemarks"
szLibChar: .asciz "Character"
 
szLibName: .asciz "Name"
szCarriageReturn: .asciz "\n"
 
tbNames: .quad szName1 // area of pointer string name
.quad szName2
.quad szName3
.quad 0 // area end
tbRemarks: .quad szRemark1 // area of pointer string remark
.quad szRemark2
.quad szRemark3
.quad 0 // area end
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
 
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszVersDoc
bl xmlNewDoc // create doc
mov x19,x0 // doc address
mov x0,#0
ldr x1,qAdrszLibCharRem
bl xmlNewNode // create root node
mov x20,x0 // node characterisation address
mov x0,x19 // doc
mov x1,x20 // node root
bl xmlDocSetRootElement
ldr x22,qAdrtbNames
ldr x23,qAdrtbRemarks
mov x24,#0 // loop counter
1: // start loop
mov x0,#0
ldr x1,qAdrszLibChar // create node
bl xmlNewNode
mov x21,x0 // node character
// x0 = node address
ldr x1,qAdrszLibName
ldr x2,[x22,x24,lsl #3] // load name string address
bl xmlNewProp
ldr x0,[x23,x24,lsl #3] // load remark string address
bl xmlNewText
mov x1,x0
mov x0,x21
bl xmlAddChild
mov x0,x20
mov x1,x21
bl xmlAddChild
add x24,x24,#1
ldr x2,[x22,x24,lsl #3] // load name string address
cmp x2,#0 // = zero ?
bne 1b // no -> loop
 
ldr x0,qAdrszFileName
ldr x1,qAdrszFileMode
bl fopen // file open
cmp x0,#0
blt 99f
mov x24,x0 //FD
mov x1,x19
mov x2,x20
bl xmlDocDump // write doc on the file
 
mov x0,x24 // close file
bl fclose
mov x0,x19 // close document
bl xmlFreeDoc
bl xmlCleanupParser
ldr x0,qAdrszMessEndpgm
bl affichageMess
b 100f
99: // error
ldr x0,qAdrszMessError
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
 
qAdrszMessError: .quad szMessError
qAdrszMessEndpgm: .quad szMessEndpgm
qAdrszVersDoc: .quad szVersDoc
qAdrszLibCharRem: .quad szLibCharRem
qAdrszLibChar: .quad szLibChar
qAdrszLibName: .quad szLibName
qAdrtbNames: .quad tbNames
qAdrtbRemarks: .quad tbRemarks
qAdrszCarriageReturn: .quad szCarriageReturn
qStdout: .quad STDOUT
qAdrszFileName: .quad szFileName
qAdrszFileMode: .quad szFileMode
 
/************************************/
/* Strings comparaison */
/************************************/
/* x0 et x1 contains strings addresses */
/* x0 return 0 dans x0 if equal */
/* return -1 if string x0 < string x1 */
/* return 1 if string x0 > string x1 */
comparString:
stp x2,lr,[sp,-16]! // save registers
stp x3,x4,[sp,-16]! // save registers
mov x2,#0 // indice
1:
ldrb w3,[x0,x2] // one byte string 1
ldrb w4,[x1,x2] // one byte string 2
cmp w3,w4
blt 2f // less
bgt 3f // greather
cmp w3,#0 // 0 final
beq 4f // equal and end
add x2,x2,#1 //
b 1b // else loop
2:
mov x0,#-1 // less
b 100f
3:
mov x0,#1 // greather
b 100f
4:
mov x0,#0 // equal
b 100f
100:
ldp x3,x4,[sp],16 // restaur 2 registers
ldp x2,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
 
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">DEFINE PTR="CARD"
DEFINE CHARACTER_SIZE="4"
TYPE Character=[PTR name,remark]
 
PTR FUNC GetCharacterPointer(BYTE ARRAY d INT index)
RETURN (d+index*CHARACTER_SIZE)
 
PROC SetCharacter(BYTE ARRAY d INT index CHAR ARRAY n,r)
Character POINTER ch
 
ch=GetCharacterPointer(d,index)
ch.name=n
ch.remark=r
RETURN
 
PROC PrintEscaped(CHAR ARRAY s)
INT i
CHAR c
 
FOR i=1 TO s(0)
DO
c=s(i)
IF c='< THEN
Print("&lt;")
ELSEIF c='> THEN
Print("&gt;")
ELSEIF c='& THEN
Print("&amp;")
ELSE
Put(c)
FI
OD
RETURN
 
PROC OutputNode(CHAR ARRAY node,tagName,tagValue BYTE closing)
Put('<)
IF closing THEN Put('/) FI
Print(node)
IF tagName(0)>0 THEN
PrintF(" %S=""",tagName)
PrintEscaped(tagValue) Put('")
FI
Put('>)
RETURN
 
PROC OutputCharacter(Character POINTER ch)
CHAR ARRAY node="Character"
 
OutputNode(node,"name",ch.name,0)
PrintEscaped(ch.remark)
OutputNode(node,"","",1)
RETURN
 
PROC OutputCharacters(BYTE ARRAY d INT count)
CHAR ARRAY node="CharacterRemarks"
Character POINTER ch
INT i
 
OutputNode(node,"","",0) PutE()
FOR i=0 TO count-1
DO
ch=GetCharacterPointer(d,i)
OutputCharacter(ch) PutE()
OD
OutputNode(node,"","",1) PutE()
RETURN
 
PROC Main()
BYTE count=[3]
BYTE ARRAY d(12)
 
SetCharacter(d,0,"April","Bubbly: I'm > Tam and <= Emily")
SetCharacter(d,1,"Tam O'Shanter","Burns: ""When chapman billies leave the street ...""")
SetCharacter(d,2,"Emily","Short & shrift")
 
OutputCharacters(d,count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/XML_Output.png Screenshot from Atari 8-bit computer]
<pre>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns:"When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</pre>
 
=={{header|Ada}}==
Line 34 ⟶ 293:
 
character_remarks.adb:
<langsyntaxhighlight Adalang="ada">with Ada.Strings.Unbounded;
with Ada.Text_IO.Text_Streams;
with DOM.Core.Documents;
Line 73 ⟶ 332:
N => My_Document,
Pretty_Print => True);
end Character_Remarks;</langsyntaxhighlight>
 
=== Alternative version using Matreshka ===
Line 79 ⟶ 338:
Uses [http://forge.ada-ru.org/matreshka Matreshka SAX API for XML].
 
<langsyntaxhighlight Adalang="ada">with Ada.Wide_Wide_Text_IO;
 
with League.Strings;
Line 131 ⟶ 390:
(+"Tam O'Shanter", +"Burns: ""When chapman billies leave the street ..."""),
(+"Emily", +"Short & shrift")));
end Main;</langsyntaxhighlight>
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># returns a translation of str suitable for attribute values and content in an XML document #
OP TOXMLSTRING = ( STRING str )STRING:
BEGIN
Line 180 ⟶ 439:
)
)
</syntaxhighlight>
</lang>
{{out}}
<langsyntaxhighlight lang="xml"><CharacterRemarks><Character name="April">Bubbly: I&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
<lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program outputXml.s */
Line 390 ⟶ 650:
bx lr @ return
 
</syntaxhighlight>
</lang>
{{output}}
<pre>
Line 400 ⟶ 660:
CharacterRemarks>
</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">gosub constants
names := xmlescape(names)
remarks := xmlescape(remarks)
Line 450 ⟶ 711:
Short & shrift
)
return</langsyntaxhighlight>
 
=={{header|BASIC}}==
{{works with|FreeBASIC}}
<lang basic>Data "April", "Bubbly: I'm > Tam and <= Emily", _
"Tam O'Shanter", "Burns: ""When chapman billies leave the street ...""", _
"Emily", "Short & shrift"
 
Declare Function xmlquote(ByRef s As String) As String
Dim n As Integer, dev As String, remark As String
 
Print "<CharacterRemarks>"
For n = 0 to 2
Read dev, remark
Print " <Character name="""; xmlquote(dev); """>"; _
xmlquote(remark); "</Character>"
Next
Print "</CharacterRemarks>"
 
End
 
Function xmlquote(ByRef s As String) As String
Dim n As Integer
Dim r As String
For n = 0 To Len(s)
Dim c As String
c = Mid(s,n,1)
Select Case As Const Asc(c)
Case Asc("<")
r = r + "&lt;"
Case Asc(">")
r = r + "&gt;"
Case Asc("&")
r = r + "&amp;"
Case Asc("""")
r = r + "&quot;"
Case Asc("'")
r = r + "&apos;"
Case Else
r = r + c
End Select
Next
Function = r
End Function</lang>
==={{header|Applesoft BASIC}}===
<langsyntaxhighlight ApplesoftBasiclang="applesoftbasic">100 Q$ = CHR$(34)
110 DE$(0) = "April"
120 RE$(0) = "Bubbly: I'm > Tam and <= Emily"
Line 523 ⟶ 744:
370 PRINT C$;
380 NEXT N
390 RETURN</langsyntaxhighlight>
 
 
==={{header|Commodore BASIC}}===
 
Not terribly different from the Applesoft BASIC example above, but this allows for a few more character/entity translations.
 
<syntaxhighlight lang="gwbasic">1 rem xml/output - commodore basic
2 rem rosetta code
5 print chr$(147);chr$(14):gosub 900
10 rem set up array structure for data
11 rem we'll use a multi-dimensional array:
12 rem c$(x,y) where x is the rows and y is the fields
13 rem two fields: 0 = character name, 1 = remarks
15 dim c$(10,1):x=0:q$=chr$(34)
19 rem now read the data to populate the structure
20 for y=0 to 1
25 read t$
30 if t$="[end]" then x=x-1:goto 45
35 c$(x,y)=t$:print t$
40 next y:x=x+1:print:goto 20
45 rem need to sanitize for html entities
50 gosub 500
55 rem now we parse it out to xml format
60 print:print:gosub 150
70 end
75 :
150 print "<CharacterRemarks>"
155 for i=0 to x
160 t$="<Character name="+q$+c$(i,0)+q$+">"
165 t$=t$+c$(i,1)+"</Character>"
170 print " ";t$
175 next i
180 print "</CharacterRemarks>"
185 print
190 return
195 :
500 rem code html entities
505 for i=0 to x
510 for j=0 to 1
515 tm$=c$(i,j):tl=len(tm$):zz$=""
520 for tc=1 to tl
525 tc$=mid$(tm$,tc,1):cv=asc(tc$) and 127
530 zz$=zz$+et$(cv)
535 next tc
540 c$(i,j)=zz$
545 next j,i
550 return
555 :
900 rem set up entity lookup table
905 dim et$(127):for i=0 to 127:et$(i)=chr$(i):next
910 for i=1 to 15:read ci,et$(ci):next i:return
915 data 34,"&quot;",63,"&quest;",35,"&num;",64,"&commat;",47,"&sol;"
920 data 60,"&lt;",62,"&gt;",91,"&lsqb;",93,"rsqb;",92,"&pound;"
925 data 36,"&dollar;",37,"&percnt;",94,"&uarr;",95,"&larr;"
930 data 38,"&amp;"
935 :
1000 data "April","Bubble: I'm > Tam and <= Emily"
1005 data "Tam O'Shanter","Burns: 'When chapman billies leave the street...'"
1010 data "Emily","Short & shrift"
1015 data "Joey","Always look ^."
1999 data "[end]","[end]"</syntaxhighlight>
 
{{out}}
 
<pre>April
Bubble: I'm > Tam and <= Emily
Tam O'Shanter
Burns: 'When chapman billies leave the street...'
Emily
Short & shrift
Joey
Always look &uarr;.
 
<CharacterRemarks>
<Character name="April">Bubble: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: 'When chapman billies leave the street...'</Character>
<Character name="Emily">Short &amp; shrift</Character>
<Character name="Joey">Always look &uarr;.</Character>
</CharacterRemarks>
ready.
&#9608;</pre>
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat">( ( 2XML
= PCDATAentities attributeValueEntities doAll doAttributes
, xml
Line 637 ⟶ 945:
)
)
)</langsyntaxhighlight>
{{out}}
<pre><?xml?>
Line 646 ⟶ 954:
 
=={{header|C}}==
==={{libheader|libXML}}===
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 686 ⟶ 994:
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
==={{libheader|Gadget}}===
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
 
LIB_GADGET_START
 
const char* codes[] = {"&amp;","&gt;","&lt;"};
const char* repl[] = {"&",">","<"};
char* change_codes( const char* xml_line )
{
int i;
String xml;
Let( xml, xml_line );
Iterator up i [0:1:3]{
Get_fn_let( xml, Str_tran( xml, repl[i], codes[i] ) );
}
return xml;
}
char* generate_xml( const char* names[], int lnames, const char* remarks[] )
{
String xml;
char attrib[100];
int i;
Iterator up i [0:1:lnames]{
String remk;
Get_fn_let ( remk, change_codes( remarks[i] ) );
sprintf(attrib,"name=\"%s\"",names[i]);
if(!i) {
Get_fn_let ( xml, Parser("Character", attrib, remk, NORMAL_TAG ));
}else{
Get_fn_cat ( xml, Parser("Character", attrib, remk, NORMAL_TAG ));
}
Free secure remk;
}
Get_fn_let ( xml, Parser("CharacterRemarks", "", xml, NORMAL_TAG ));
Get_fn_let ( xml, Str_tran(xml,"><",">\n<") );
return xml;
}
 
#define alen(_X_) ( sizeof(_X_) / sizeof(const char*) )
Main
const char *names[] = {
"April", "Tam O'Shanter", "Emily"
};
const char *remarks[] = {
"Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"
};
char* xml = generate_xml( names, alen(names), remarks );
Print "%s\n", xml;
Free secure xml;
End
</syntaxhighlight>
{{out}}
 
$ ./tests/RC_xmlout
<syntaxhighlight lang="xml">
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
 
=={{header|C sharp}}==
{{works with|C sharp|C#|3.0+}}
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
 
class Program
{
static string CreateXML(Dictionary<string, string> characterRemarks)
{
var remarks = characterRemarks.Select(r => new XElement("Character", r.Value, new XAttribute("Name", r.Key)));
var xml = new XElement("CharacterRemarks", remarks);
return xml.ToString();
}
 
static void Main(string[] args)
{
var characterRemarks = new Dictionary<string, string>
{
{ "April", "Bubbly: I'm > Tam and <= Emily" },
{ "Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\"" },
{ "Emily", "Short & shrift" }
};
 
string xml = CreateXML(characterRemarks);
Console.WriteLine(xml);
}
}</syntaxhighlight>
 
=={{header|C++}}==
Library: Boost
<langsyntaxhighlight lang="cpp">#include <vector>
#include <utility>
#include <iostream>
Line 735 ⟶ 1,140:
xmlstring.append( "</CharacterRemarks>" ) ;
return xmlstring ;
}</langsyntaxhighlight>
 
=={{header|C sharp}}==
{{works with|C sharp|C#|3.0+}}
<lang csharp>using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
 
class Program
{
static string CreateXML(Dictionary<string, string> characterRemarks)
{
var remarks = characterRemarks.Select(r => new XElement("Character", r.Value, new XAttribute("Name", r.Key)));
var xml = new XElement("CharacterRemarks", remarks);
return xml.ToString();
}
 
static void Main(string[] args)
{
var characterRemarks = new Dictionary<string, string>
{
{ "April", "Bubbly: I'm > Tam and <= Emily" },
{ "Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\"" },
{ "Emily", "Short & shrift" }
};
 
string xml = CreateXML(characterRemarks);
Console.WriteLine(xml);
}
}</lang>
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="lisp">(use 'clojure.xml)
(defn character-remarks-xml [characters remarks]
(with-out-str (emit-element
Line 776 ⟶ 1,151:
{:tag :Character,
:attrs {:name (item 0)},
:content [(item 1)]}) )})))</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 782 ⟶ 1,157:
{{libheader|Closure XML}}
 
<langsyntaxhighlight lang="lisp">(defun write-xml (characters lines &optional (out *standard-output*))
(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))
(chars (dom:append-child doc (dom:create-element doc "Characters"))))
Line 791 ⟶ 1,166:
(dom:append-child chars c)))
characters lines)
(write-string (dom:map-document (cxml:make-rod-sink) doc) out)))</langsyntaxhighlight>
 
Example of use:
 
<langsyntaxhighlight lang="lisp">(write-xml '("April" "Tam O'Shanter" "Emily")
'("Bubbly: I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"))</langsyntaxhighlight>
 
{{out}}
Line 807 ⟶ 1,182:
=={{header|D}}==
{{libheader|KXML}}
<langsyntaxhighlight lang="d">import kxml.xml;
char[][][]characters =
[["April","Bubbly: I'm > Tam and <= Emily"],
Line 824 ⟶ 1,199:
addChars(root,characters);
std.stdio.writefln("%s",root.write);
}</langsyntaxhighlight>
<pre>
<?xml?>
Line 841 ⟶ 1,216:
 
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
<lang Delphi>
//You need to use these units
uses
Line 918 ⟶ 1,293:
end;
 
</syntaxhighlight>
</lang>
 
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
<lang Erlang>
-module( xml_output ).
 
Line 934 ⟶ 1,309:
 
contents() -> [{"April", "Bubbly: I'm > Tam and <= Emily"}, {"Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\""}, {"Emily", "Short & shrift"}].
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 943 ⟶ 1,318:
=={{header|Euphoria}}==
{{trans|BASIC}}
<langsyntaxhighlight lang="euphoria">function xmlquote(sequence s)
sequence r
r = ""
Line 976 ⟶ 1,351:
puts(1,"</Character>\n")
end for
puts(1,"</CharacterRemarks>\n")</langsyntaxhighlight>
 
{{out}}
Line 987 ⟶ 1,362:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">#light
 
open System.Xml
Line 1,008 ⟶ 1,383:
root.AppendChild node |> ignore
) characters
doc.OuterXml</langsyntaxhighlight>
<pre><CharacterRemarks>
<Character name="April">Bubbly: I'm &amp;gt; Tam and &amp;lt;= Emily</Character>
Line 1,016 ⟶ 1,391:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: sequences xml.syntax xml.writer ;
 
: print-character-remarks ( names remarks -- )
[ [XML <Character name=<-> ><-></Character> XML] ] 2map
[XML <CharacterRemarks><-></CharacterRemarks> XML] pprint-xml ;</langsyntaxhighlight>
Example of usage:
<langsyntaxhighlight lang="factor">{ "April" "Tam O'Shanter" "Emily" } {
"Bubbly: I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"
} print-remarks</langsyntaxhighlight>
 
=={{header|Fantom}}==
<langsyntaxhighlight lang="fantom">
using xml
 
Line 1,056 ⟶ 1,431:
}
}
</syntaxhighlight>
</lang>
 
{{out}} (not exactly conforming):
Line 1,072 ⟶ 1,447:
{{libheader|Forth Foundation Library}}
 
<langsyntaxhighlight lang="forth">include ffl/est.fs
include ffl/xos.fs
 
Line 1,112 ⟶ 1,487:
 
\ Output xml string
xml str-get type cr</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="basic">Data "April", "Bubbly: I'm > Tam and <= Emily", _
"Tam O'Shanter", "Burns: ""When chapman billies leave the street ...""", _
"Emily", "Short & shrift"
 
Declare Function xmlquote(ByRef s As String) As String
Dim n As Integer, dev As String, remark As String
 
Print "<CharacterRemarks>"
For n = 0 to 2
Read dev, remark
Print " <Character name="""; xmlquote(dev); """>"; _
xmlquote(remark); "</Character>"
Next
Print "</CharacterRemarks>"
 
End
 
Function xmlquote(ByRef s As String) As String
Dim n As Integer
Dim r As String
For n = 0 To Len(s)
Dim c As String
c = Mid(s,n,1)
Select Case As Const Asc(c)
Case Asc("<")
r = r + "&lt;"
Case Asc(">")
r = r + "&gt;"
Case Asc("&")
r = r + "&amp;"
Case Asc("""")
r = r + "&quot;"
Case Asc("'")
r = r + "&apos;"
Case Else
r = r + c
End Select
Next
Function = r
End Function</syntaxhighlight>
 
=={{header|Go}}==
'''Using package xml to marshal from a data structure:'''
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,149 ⟶ 1,567:
}
fmt.Println(x)
}</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I&#39;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&#39;Shanter">Burns: &#34;When chapman billies leave the street ...&#34;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
Using the text/template package to generate text:
(but still leaning on the xml package for escaping.)
<langsyntaxhighlight lang="go">package main
import (
Line 1,204 ⟶ 1,622:
}
fmt.Println(x)
}</langsyntaxhighlight>
Output is same as marshalled version.
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def writer = new StringWriter()
def builder = new groovy.xml.MarkupBuilder(writer)
def names = ["April", "Tam O'Shanter", "Emily"]
Line 1,217 ⟶ 1,635:
}
 
println writer.toString()</langsyntaxhighlight>
 
=={{header|Haskell}}==
This implementation uses the [http://hackage.haskell.org/package/xml <code>xml</code> package].
 
<langsyntaxhighlight lang="haskell">import Text.XML.Light
 
characterRemarks :: [String] -> [String] -> String
Line 1,234 ⟶ 1,652:
[Attr (unqual "name") name]
[Text $ CData CDataText remark Nothing]
Nothing</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">CHARACTER names="April~Tam O'Shanter~Emily~"
CHARACTER remarks*200/%Bubbly: I'm > Tam and <= Emily~Burns: "When chapman billies leave the street ..."~Short & shrift~%/
CHARACTER XML*1000
Line 1,251 ⟶ 1,669:
XML = TRIM(XML) // '<Character name="' // name // '">' // remark // '</Character>' // $CRLF
ENDDO
XML = TRIM(XML) // "</CharacterRemarks>"</langsyntaxhighlight>
 
=={{header|J}}==
Line 1,257 ⟶ 1,675:
First create the table of substitutions and the verb which properly escapes the input string:
 
<langsyntaxhighlight lang="j">tbl=: ('&quote;'; '&amp;'; '&lt;'; '&gt;') (a.i.'"&<>')} <"0 a.
esc=: [:; {&tbl@:i.~&a.</langsyntaxhighlight>
 
Then create the verb which combines name with remark:
<langsyntaxhighlight Jlang="j">cmb=: [:; dyad define &.>
'<Character name="', (esc x), '">', (esc y), '</Character>', LF
)</langsyntaxhighlight>
 
Finally, create the verb which creates the final XML:
<langsyntaxhighlight lang="j">xmlify=: '<CharacterRemarks>', LF, cmb, '</CharacterRemarks>'"_</langsyntaxhighlight>
 
Example:
 
<langsyntaxhighlight lang="j">names=: 'April'; 'Tam O''Shanter'; 'Emily'
 
remarks=: <;._2]0 :0
Line 1,276 ⟶ 1,694:
Burns: "When chapman billies leave the street ..."
Short & shrift
)</langsyntaxhighlight>
 
<syntaxhighlight lang="text"> names xmlify remarks
<CharacterRemarks>
<Character name="April"> I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter"> Burns: &quote;When chapman billies leave the street ...&quote;</Character>
<Character name="Emily"> Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
=={{header|Java}}==
===Using DOM===
<langsyntaxhighlight lang="java">import java.io.StringWriter;
 
import javax.xml.parsers.DocumentBuilderFactory;
Line 1,347 ⟶ 1,765:
}
}</langsyntaxhighlight>
 
Result:
<langsyntaxhighlight lang="xml"><?xml version="1.0" encoding="UTF-8" standalone="no"?>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character></langsyntaxhighlight>
 
===Using the Streaming API for XML (StAX)===
<langsyntaxhighlight lang="java">import java.io.StringWriter;
 
import javax.xml.stream.XMLOutputFactory;
Line 1,394 ⟶ 1,812:
}
}
}</langsyntaxhighlight>
 
This produces:
<langsyntaxhighlight lang="xml"><?xml version="1.0" encoding="UTF-8"?><CharacterRemarks><Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character><Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character><Character name="Emily">Short &amp; shrift</Character></CharacterRemarks></langsyntaxhighlight>
 
=={{header|Joy}}==
<syntaxhighlight lang="joy">
<lang Joy>
DEFINE subst ==
[[['< "&lt;" putchars]
Line 1,409 ⟶ 1,827:
XMLOutput ==
"<CharacterRemarks>\n" putchars
[ "<Character name=\"" putchars uncons swap putchars "\">" putchars first subst "</Character>\n" putchars] step
"</CharacterRemarks>\n" putchars.
 
[ [ "April" "Bubbly: I'm > Tam and <= Emily" ]
[ "Tam O'Shanter" "Burns: \"When chapman billies leave the street ...\"" ]
[ "Emily" "Short & shrift" ]
] XMLOutput.
</syntaxhighlight>
</lang>
 
=={{header|jq}}==
{{trans|Wren}}
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq'''
<syntaxhighlight lang=jq>
def escapes: [
["&" , "&amp;"], # must do this one first
["\"", "&quot;"],
["'" , "&apos;"],
["<" , "&lt;"],
[">" , "&gt;"]
];
 
def xmlEscape:
reduce escapes[] as $esc (.; gsub($esc[0]; $esc[1]));
 
def xmlDoc(names; remarks):
reduce range(0;names|length) as $i ("<CharacterRemarks>\n";
(names[$i]|xmlEscape) as $name
| (remarks[$i]|xmlEscape) as $remark
| . + " <Character name=\"\($name)\">\($remark)</Character>\n")
+ "</CharacterRemarks>" ;
 
def names: ["April", "Tam O'Shanter", "Emily"];
def remarks: [
"Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"
];
 
xmlDoc(names; remarks)
</syntaxhighlight>
{{output}}
As for [[#Wren|Wren]].
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using LightXML
 
dialog = [("April", "Bubbly: I'm > Tam and <= Emily"),
Line 1,436 ⟶ 1,888:
 
println(xdoc)
</langsyntaxhighlight>{{output}}<pre>
<?xml version="1.0" encoding="utf-8"?>
<CharacterRemarks>
Line 1,446 ⟶ 1,898:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.3
 
import javax.xml.parsers.DocumentBuilderFactory
Line 1,490 ⟶ 1,942:
println(sw)
}
</syntaxhighlight>
</lang>
 
{{out}}
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
=={{header|Lasso}}==
Lasso has built in support for both creating and parsing xml.
<langsyntaxhighlight Lassolang="lasso">define character2xml(names::array, remarks::array) => {
 
fail_if(#names -> size != #remarks -> size, -1, 'Input arrays not of same size')
Line 1,537 ⟶ 1,989:
array(`April`, `Tam O'Shanter`, `Emily`),
array(`Bubbly: I'm > Tam and <= Emily`, `Burns: "When chapman billies leave the street ..."`, `Short & shrift`)
)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg:svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
Line 1,548 ⟶ 2,000:
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
Using the LuaXML library as available via luarocks. Note that strings in Lua can be enclosed in either single or double quotes to help reduce the need for escape characters.
<langsyntaxhighlight Lualang="lua">require("LuaXML")
 
function addNode(parent, nodeName, key, value, content)
Line 1,564 ⟶ 2,016:
addNode(root, "Character", "name", "Tam O'Shanter", 'Burns: "When chapman billies leave the street ..."')
addNode(root, "Character", "name", "Emily", "Short & shrift")
print(root)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
Note also that LuaXML escapes quote marks and apostrophes, which makes the output slightly different to the task requirement. This can be 'fixed' if necessary using Lua's in-built string.gsub function:
<langsyntaxhighlight Lualang="lua">xmlStr = xml.str(root):gsub("&apos;", "'"):gsub("&quot;", '"')
print(xmlStr)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Flush
Data "April", {Bubbly: I'm > Tam and <= Emily}
Data "Tam O'Shanter", {Burns: "When chapman billies leave the street ..."}
Data "Emily", {Short & shrift}
declare xml xmlData
with xml, "xml" as doc$, "beautify" as beautify
method xml, "PrepareNode", "CharacterRemarks" as Node
method xml, "InsertNode", Node
while not empty
read name$, text$
method xml, "PrepareNode", "Character", text$ as Node1
method xml, "PlaceAttributeToNode", Node1, "name", name$
method xml, "AppendChild", Node1
end while
beautify=-4
Report doc$
}
CheckIt
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I&apos;m &qt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></syntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Some tricky input with the second remark
<langsyntaxhighlight Mathematicalang="mathematica">c = {"April", "Tam O'Shanter","Emily"};
r = {"Bubbly:I'm > Tam and <= Emily" ,
StringReplace["Burns:\"When chapman billies leave the street ...\"", "\"" -> ""], "Short & shrift"};
 
ExportString[ XMLElement[ "CharacterRemarks", {},
{XMLElement["Character", {"name" -> c[[1]]}, {r[[1]]}],
XMLElement["Character", {"name" -> c[[2]]}, {r[[2]]}],
XMLElement["Character", {"name" -> c[[3]]}, {r[[3]]}]
}], "XML", "AttributeQuoting" -> "\""]</langsyntaxhighlight>
{{out}}
 
<pre><CharacterRemarks>
<Character name=\"April\">Bubbly:I'm &gt; Tam and &lt;= Emily</Character>
Line 1,599 ⟶ 2,081:
</CharacterRemarks></pre>
 
=={{header|MatlabMATLAB}}==
<syntaxhighlight lang="matlab">RootXML = com.mathworks.xml.XMLUtils.createDocument('CharacterRemarks');
<lang Matlab>
RootXML = com.mathworks.xml.XMLUtils.createDocument('CharacterRemarks');
docRootNode = RootXML.getDocumentElement;
thisElement = RootXML.createElement('Character');
Line 1,614 ⟶ 2,095:
thisElement.setAttribute('Name','Emily')
thisElement.setTextContent('Short & shrift');
docRootNode.appendChild(thisElement);</syntaxhighlight>
 
</lang>
{{out}}
Output;
 
<pre>
xmlwrite(RootXML)
Line 1,633 ⟶ 2,115:
===Using DOM===
{{trans|Java}}
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
 
options replace format comments java crossref savelog symbols nobinary
Line 1,698 ⟶ 2,180:
 
return
</syntaxhighlight>
</lang>
;Output
<langsyntaxhighlight lang="xml"><?xml version="1.0" encoding="UTF-8" standalone="no"?>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
Line 1,706 ⟶ 2,188:
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
===Using the Streaming API for XML (StAX)===
{{trans|Java}}
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
 
options replace format comments java crossref savelog symbols nobinary
Line 1,758 ⟶ 2,240:
 
return
</syntaxhighlight>
</lang>
;Output
<langsyntaxhighlight lang="xml"><?xml version="1.0" encoding="UTF-8"?>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
Line 1,766 ⟶ 2,248:
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import xmltree, strtabs, sequtils
 
proc charsToXML(names, remarks: seq[string]): XmlNode =
result = <>CharacterRemarks()
for name, remark in items zip(names, remarks):
result.add( <>Character(name=name, remark.newText))
 
echo charsToXML(@["April", "Tam O'Shanter", "Emily"],
@["Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"])</langsyntaxhighlight>
Output:
<presyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></presyntaxhighlight>
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">use Data.XML;
use XMLCollection.Generic;
use Structure;
 
class Test {
bundle Default {
function : Main(args : String[]) ~ Nil {
class Test {
# list of name
function : Main(args : String[]) ~ Nil {
names := Vector->New()<String>;
# list of name
names := Vector->NewAddBack("April");
names->AddBack("AprilTam O'Shanter"->As(Base));
names->AddBack("Tam O'ShanterEmily"->As(Base));
# list of comments
names->AddBack("Emily"->As(Base));
comments := Vector->New()<String>;
# list of comments
comments->AddBack("Bubbly: I'm > Tam and <= Emily");
comments := Vector->New();
comments->AddBack("BubblyBurns: I'm\"When >chapman Tambillies andleave <=the Emilystreet ...\""->As(Base));
comments->AddBack(XmlElement->EncodeString("Burns:Short \"When& chapman billies leave the street ...\shrift""->As(Base));
# build XML document
comments->AddBack("Short & shrift"->As(Base));
builder := XmlBuilder->New("CharacterRemarks");
# build XML document
builderroot := XMLBuilderbuilder->NewGetRoot("CharacterRemarks");
if(names->Size() root := buildercomments->GetRootSize();) {
ifeach(names->Size()i =: comments->Size()names) {
element := XmlElement->New(XmlElement->Type->ELEMENT, "Character");
each(i : names) {
element := XMLElement->NewAddAttribute(XMLElementTypeXmlAttribute->ELEMENTNew("name", names->Get(i)));
element->SetContent(XmlElement->EncodeString(comments->Get(i)));
names->Get(i)->As(String),
commentsroot->GetAddChild(i)->As(String)element);
root->AddChild(element)};
};
builder->ToString()->PrintLine();
};
XMLElement->DecodeString(builder->ToString())->PrintLine();
}
}
}
</syntaxhighlight>
</lang>
 
=={{header|OCaml}}==
Line 1,826 ⟶ 2,305:
from the toplevel using the library [http://tech.motion-twin.com/xmllight.html xml-light]:
 
<langsyntaxhighlight lang="ocaml"># #directory "+xml-light" (* or maybe "+site-lib/xml-light" *) ;;
 
# #load "xml-light.cma" ;;
Line 1,848 ⟶ 2,327:
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
- : unit = ()</langsyntaxhighlight>
 
Another solution using the library [http://erratique.ch/software/xmlm xmlm]:
 
<langsyntaxhighlight lang="ocaml">#directory "+xmlm"
#load "xmlm.cmo"
open Xmlm
Line 1,873 ⟶ 2,352:
) datas;
output xo (`El_end);
print_newline()</langsyntaxhighlight>
 
=={{header|Oz}}==
It is natural to represent XML document as nested Oz records. Writing a function that serializes records to textual XML is not too difficult.
 
<langsyntaxhighlight lang="oz">declare
proc {Main}
Names = ["April"
Line 1,966 ⟶ 2,445:
end
in
{Main}</langsyntaxhighlight>
 
Output:
<langsyntaxhighlight lang="xml"><?xml version="1.0" ?>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
=={{header|Perl}}==
{{libheader|XML::Mini}}
<langsyntaxhighlight lang="perl">#! /usr/bin/perl
use strict;
use XML::Mini::Document;
Line 1,996 ⟶ 2,475:
$stud->text($s->[1]);
}
print $doc->toString();</langsyntaxhighlight>
 
=={{header|Perl 6}}==
{{works with|Rakudo|2018.05}}
 
<lang perl6>use XML::Writer;
 
my @students =
[ Q[April], Q[Bubbly: I'm > Tam and <= Emily] ],
[ Q[Tam O'Shanter], Q[Burns: "When chapman billies leave the street ..."] ],
[ Q[Emily], Q[Short & shrift] ]
;
 
my @lines = map { :Character[:name(.[0]), .[1]] }, @students;
 
say XML::Writer.serialize( CharacterRemarks => @lines );</lang>
{{out}}
<lang XML><CharacterRemarks><Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character></CharacterRemarks></lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>constant {hchars,hsubs} = columnize({{"<","&lt;"},
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
{">","&gt;"},
<span style="color: #008080;">constant</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">hchars</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hsubs</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({{</span><span style="color: #008000;">"&lt;"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;lt;"</span><span style="color: #0000FF;">},</span>
{"&","&amp;"},
<span style="color: #0000FF;">{</span><span style="color: #008000;">"&gt;"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;gt;"</span><span style="color: #0000FF;">},</span>
{"\"","&quot;"},
<span style="color: #0000FF;">{</span><span style="color: #008000;">"&"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;amp;"</span><span style="color: #0000FF;">},</span>
{"\'","&apos;"}})
<span style="color: #0000FF;">{</span><span style="color: #008000;">"\""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;quot;"</span><span style="color: #0000FF;">},</span>
function xmlquote_all(sequence s)
<span style="color: #0000FF;">{</span><span style="color: #008000;">"\'"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;apos;"</span><span style="color: #0000FF;">}})</span>
for i=1 to length(s) do
<span style="color: #008080;">function</span> <span style="color: #000000;">xmlquote_all</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
s[i] = substitute_all(s[i],hchars,hsubs)
<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;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
end for
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">hchars</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hsubs</span><span style="color: #0000FF;">)</span>
return s
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end function
<span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
function xml_CharacterRemarks(sequence data)
string res = "<CharacterRemarks>\n"
<span style="color: #008080;">function</span> <span style="color: #000000;">xml_CharacterRemarks</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">data</span><span style="color: #0000FF;">)</span>
for i=1 to length(data) do
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"&lt;CharacterRemarks&gt;\n"</span>
res &= sprintf(" <CharacterName=\"%s\">%s</Character>\n",xmlquote_all(data[i]))
<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;">data</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
end for
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">" &lt;CharacterName=\"%s\"&gt;%s&lt;/Character&gt;\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">xmlquote_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">data</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]))</span>
return res & "</CharacterRemarks>\n"
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end function
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">"&lt;/CharacterRemarks&gt;\n"</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
constant testset = {
{"April", "Bubbly: I'm > Tam and <= Emily"},
<span style="color: #008080;">constant</span> <span style="color: #000000;">testset</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span>
{"Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\""},
<span style="color: #0000FF;">{</span><span style="color: #008000;">"April"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Bubbly: I'm &gt; Tam and &lt;= Emily"</span><span style="color: #0000FF;">},</span>
{"Emily", "Short & shrift"}
<span style="color: #0000FF;">{</span><span style="color: #008000;">"Tam O'Shanter"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Burns: \"When chapman billies leave the street ...\""</span><span style="color: #0000FF;">},</span>
}
<span style="color: #0000FF;">{</span><span style="color: #008000;">"Emily"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Short & shrift"</span><span style="color: #0000FF;">}</span>
printf(1,xml_CharacterRemarks(testset))
<span style="color: #0000FF;">}</span>
 
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">xml_CharacterRemarks</span><span style="color: #0000FF;">(</span><span style="color: #000000;">testset</span><span style="color: #0000FF;">))</span>
-- Sample output:
-- <CharacterRemarks>
<span style="color: #000080;font-style:italic;">-- Sample output:
-- <CharacterName="April">Bubbly: I&apos;m &amp;gt; Tam and &amp;lt;= Emily</Character>
-- &lt;CharacterRemarks&gt;
-- <CharacterName="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
-- <&lt;CharacterName="EmilyApril">Short&gt;Bubbly: I&amp;apos;m shrift<&amp;gt; Tam and &amp;lt;= Emily&lt;/Character>&gt;
-- &lt;CharacterName="Tam O&amp;apos;Shanter"&gt;Burns: &amp;quot;When chapman billies leave the street ...&amp;quot;&lt;/Character&gt;
-- </CharacterRemarks></lang>
-- &lt;CharacterName="Emily"&gt;Short &amp;amp; shrift&lt;/Character&gt;
-- &lt;/CharacterRemarks&gt;</span>
<!--</syntaxhighlight>-->
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(load "@lib/xml.l")
 
(de characterRemarks (Names Remarks)
Line 2,071 ⟶ 2,534:
"I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ..."
"Short & shrift" ) )</langsyntaxhighlight>
Output:
<pre><CharacterRemarks>
Line 2,080 ⟶ 2,543:
 
=={{header|PureBasic}}==
<langsyntaxhighlight Purebasiclang="purebasic">DataSection
dataItemCount:
Data.i 3
Line 2,138 ⟶ 2,601:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
Sample output:
<pre><CharacterRemarks>
Line 2,150 ⟶ 2,613:
=={{header|Python}}==
Normal output is all one line of XML, the .replace(...) makes it more readable.
<langsyntaxhighlight lang="python">>>> from xml.etree import ElementTree as ET
>>> from itertools import izip
>>> def characterstoxml(names, remarks):
Line 2,163 ⟶ 2,626:
remarks = [ "Bubbly: I'm > Tam and <= Emily",
'Burns: "When chapman billies leave the street ..."',
'Short & shrift' ] ).replace('><','>\n<')</langsyntaxhighlight>
Gives the output:
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
=={{header|R}}==
{{libheader|XML}}
<langsyntaxhighlight Rlang="r">library(XML)
char2xml <- function(names, remarks){
tt <- xmlHashTree()
Line 2,185 ⟶ 2,648:
}
output <- char2xml( names=c("April","Tam O'Shanter","Emily"),
remarks=c("Bubbly: I'm > Tam and <= Emily", 'Burns: "When chapman billies leave the street ..."', "Short & shrift") )</langsyntaxhighlight>
 
Gives the output: <!-- manually inserted "&amp;" where required to protect actual R output from the browser -->
Line 2,196 ⟶ 2,659:
=={{header|Racket}}==
 
<langsyntaxhighlight lang="racket">
#lang racket
(require xml)
Line 2,213 ⟶ 2,676:
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"))))
</syntaxhighlight>
</lang>
 
Output:
 
<langsyntaxhighlight lang="xml">
<CharacterRemarks>
<Character name="April">
Line 2,229 ⟶ 2,692:
</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.05}}
 
<syntaxhighlight lang="raku" line>use XML::Writer;
 
my @students =
[ Q[April], Q[Bubbly: I'm > Tam and <= Emily] ],
[ Q[Tam O'Shanter], Q[Burns: "When chapman billies leave the street ..."] ],
[ Q[Emily], Q[Short & shrift] ]
;
 
my @lines = map { :Character[:name(.[0]), .[1]] }, @students;
 
say XML::Writer.serialize( CharacterRemarks => @lines );</syntaxhighlight>
{{out}}
<syntaxhighlight lang="xml"><CharacterRemarks><Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character></CharacterRemarks></syntaxhighlight>
 
=={{header|Rascal}}==
<langsyntaxhighlight lang="rascal">import Prelude;
import lang::xml::DOM;
 
Line 2,247 ⟶ 2,730:
return println(xmlPretty(x));
}
}</langsyntaxhighlight>
This gives an output:
<langsyntaxhighlight lang="rascal">rascal>xmloutput(charnames, remarks)
<?xml version="1.0" encoding="UTF-8"?>
<CharacterRemarks>
Line 2,258 ⟶ 2,741:
 
 
ok</langsyntaxhighlight>
 
=={{header|REXX}}==
REXX doesn't have any functions to handle XML entities, an abbreviated version is included here.
<langsyntaxhighlight lang="rexx">/*REXX program creates an HTML (XML) list of character names and corresponding remarks. */
charname. =
charname.1 = "April"
Line 2,378 ⟶ 2,861:
xml_: parse arg _ /*make an XML entity (&xxxx;) */
if pos(_, $)\==0 then return changestr(_, $, "&"arg(2)";")
return $</langsyntaxhighlight>
Some older REXXes don't have a '''changestr''' bif, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
 
Line 2,400 ⟶ 2,883:
=={{header|Ruby}}==
The {{libheader|REXML}}library handles character mapping when adding attributes and text.
<langsyntaxhighlight lang="ruby">require 'rexml/document'
include REXML
 
Line 2,417 ⟶ 2,900:
 
# output with indentation
doc.write($stdout, 2)</langsyntaxhighlight>
 
produces <!-- manually inserted "&amp;" where required to protect actual Ruby output from the browser -->
Line 2,433 ⟶ 2,916:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">extern crate xml;
 
use std::collections::HashMap;
Line 2,490 ⟶ 2,973:
assert!(output.contains("<Character name=\"Emily\">Short &amp; shrift</Character>"));
}
}</langsyntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">val names = List("April", "Tam O'Shanter", "Emily")
 
val remarks = List("Bubbly: I'm > Tam and <= Emily", """Burns: "When chapman billies leave the street ..."""", "Short & shrift")
Line 2,502 ⟶ 2,985:
 
characterRemarks(names, remarks)
</syntaxhighlight>
</lang>
 
Result:
<langsyntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character><Character name="Tam O'Shanter">Burns:
&quot;When chapman billies leave the street ...&quot;</Character><Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></langsyntaxhighlight>
 
=={{header|SenseTalk}}==
<syntaxhighlight lang="sensetalk">put ("April", "Tam O'Shanter", "Emily") into names
put ("Bubbly: I'm > Tam and <= Emily", <<Burns: "When chapman billies leave the street ...">>, "Short & shrift") into remarks
put (_tag: "CharacterRemarks") as tree into document
repeat for each item name in names
insert (_tag: "Character", name: name, _children: item the counter of remarks) as tree into document's _children
end repeat
put document</syntaxhighlight>
 
{{out}}
<pre>
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</pre>
 
=={{header|Sidef}}==
{{trans|Perl}}
<langsyntaxhighlight lang="ruby">require('XML::Mini::Document');
 
var students = [
Line 2,530 ⟶ 3,031:
};
 
print doc.toString;</langsyntaxhighlight>
 
=={{header|Slate}}==
 
<langsyntaxhighlight lang="slate">lobby define: #remarks -> (
{'April' -> 'Bubbly: I\'m > Tam and <= Emily'.
'Tam O\'Shanter' -> 'Burns: "When chapman billies leave the street ..."'.
Line 2,547 ⟶ 3,048:
].
 
inform: writer contents</langsyntaxhighlight>
Produces:
<div style="width:full;overflow:scroll">
Line 2,556 ⟶ 3,057:
=={{header|Tcl}}==
===Using only Tcl string manipulation===
<langsyntaxhighlight Tcllang="tcl">proc xquote string {
list [string map "' &apos; \\\" &quot; < &gt; > &lt; & &amp;" $string]
}
Line 2,583 ⟶ 3,084:
append cmd " \[< Character {Name [xquote $name]} [xquote $comment]\]"
}
puts [eval $cmd]</langsyntaxhighlight>
produces<pre><CharacterRemarks><Character Name='April'>Bubbly: I&amp;apos;m &amp;lt; Tam and &amp;gt;= Emily</Character>
<Character Name='Tam O&amp;apos;Shanter'>Burns: &amp;quot;When chapman billies leave the street ...&amp;quot;</Character>
Line 2,590 ⟶ 3,091:
===Working with DOM trees===
Using {{libheader|tDOM}}
<langsyntaxhighlight lang="tcl">package require tdom
set xml [dom createDocument CharacterRemarks]
foreach {name comment} {
Line 2,602 ⟶ 3,103:
[$xml documentElement] appendChild $elem
}
$xml asXML</langsyntaxhighlight>
<pre><CharacterRemarks>
<Character name="April">Bubbly: I'm &amp;amp;gt; Tam and &amp;amp;lt;= Emily</Character>
Line 2,609 ⟶ 3,110:
</CharacterRemarks></pre>
Using {{libheader|TclXML}}
<langsyntaxhighlight lang="tcl">package require dom
set xml [dom::DOMImplementation create]
set root [dom::document createElement $xml CharacterRemarks]
Line 2,621 ⟶ 3,122:
dom::document createTextNode $element $comment
}
dom::DOMImplementation serialize $xml -indent 1</langsyntaxhighlight>
produces (with line breaks added for clarity:
<pre><?xml version="1.0"?>
Line 2,631 ⟶ 3,132:
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
STRUCTURE xmloutput
Line 2,653 ⟶ 3,154:
WRITE/NEXT d
ENDACCESS d
</syntaxhighlight>
</lang>
Output in file "dest":
<pre>
Line 2,665 ⟶ 3,166:
=={{header|VBScript}}==
Saves in a file.
<syntaxhighlight lang="vbscript}}">
<lang VBScript}}>
Set objXMLDoc = CreateObject("msxml2.domdocument")
 
Line 2,683 ⟶ 3,184:
objRoot.appendChild objNode
End Function
</syntaxhighlight>
</lang>
 
=={{header|Vedit macro language}}==
The input data is given in an edit buffer, one name+remark pair on each line line, separated with TAB character.
<langsyntaxhighlight lang="vedit">// Replace special characters with entities:
Replace("&", "&amp;", BEGIN+ALL+NOERR) // this must be the first replace!
Replace("<", "&lt;", BEGIN+ALL+NOERR)
Line 2,704 ⟶ 3,205:
}
EOF
IT("</CharacterRemarks>") IN</langsyntaxhighlight>
 
Example input:
Line 2,723 ⟶ 3,224:
 
=={{header|Visual Basic .NET}}==
<langsyntaxhighlight lang="vbnet">Module XMLOutput
Sub Main()
Dim charRemarks As New Dictionary(Of String, String)
Line 2,736 ⟶ 3,237:
Console.WriteLine(xml)
End Sub
End Module</langsyntaxhighlight>
 
Output:
Line 2,744 ⟶ 3,245:
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street..."</Character>
<Character name="Emily">Short &amp;amp; shrift</Character>
</CharacterRemarks>
</pre>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">var escapes = [
["&" , "&amp;"], // must do this one first
["\"", "&quot;"],
["'" , "&apos;"],
["<" , "&lt;"],
[">" , "&gt;"]
]
 
var xmlEscape = Fn.new { |s|
for (esc in escapes) s = s.replace(esc[0], esc[1])
return s
}
 
var xmlDoc = Fn.new { |names, remarks|
var xml = "<CharacterRemarks>\n"
for (i in 0...names.count) {
var name = xmlEscape.call(names[i])
var remark = xmlEscape.call(remarks[i])
xml = xml + " <Character name=\"%(name)\">%(remark)</Character>\n"
}
xml = xml + "</CharacterRemarks>"
System.print(xml)
}
 
var names = ["April", "Tam O'Shanter", "Emily"]
var remarks = [
"Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"
]
xmlDoc.call(names, remarks)</syntaxhighlight>
 
{{out}}
<syntaxhighlight lang="xml"><CharacterRemarks>
<Character name="April">Bubbly: I&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks></syntaxhighlight>
<br>
{{libheader|Wren-xsequence}}
Alternatively, using an XML library.
<syntaxhighlight lang="wren">import "./xsequence" for XDocument, XElement, XAttribute
 
var createXmlDoc = Fn.new { |names, remarks|
var root = XElement.new("CharacterRemarks")
for (i in 0...names.count) {
var xe = XElement.new("Character", remarks[i])
xe.add(XAttribute.new("name", names[i]))
root.add(xe)
}
return XDocument.new(root)
}
 
var names = ["April", "Tam O'Shanter", "Emily"]
var remarks = [
"Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"
]
var doc = createXmlDoc.call(names, remarks)
System.print(doc)</syntaxhighlight>
{{out}}
Same as the first version but prefixed by:
<syntaxhighlight lang="xml"><?xml version="1.0" encoding="utf-8"?></syntaxhighlight>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code ChOut=8, CrLf=9, Text=12;
string 0; \use zero-terminated strings
 
proc XmlOut(S); \Output string in XML format
char S;
repeat case S(0) of \character entity substitutions
^<: Text(0, "&lt;");
^>: Text(0, "&gt;");
^&: Text(0, "&amp;");
^": Text(0, "&quot;");
^': Text(0, "&apos;")
other ChOut(0, S(0));
S:= S+1;
until S(0) = 0;
 
int Name, Remark, I;
[Name:= ["April", "Tam O'Shanter", "Emily"];
Remark:= ["Bubbly: I'm > Tam and <= Emily",
"Burns: ^"When chapman billies leave the street ...^"",
"Short & shrift"];
Text(0, "<CharacterRemarks>"); CrLf(0);
for I:= 0 to 3-1 do
[Text(0, " <Character name=^"");
XmlOut(Name(I));
Text(0, "^">");
XmlOut(Remark(I));
Text(0, "</Character>"); CrLf(0);
];
Text(0, "</CharacterRemarks>"); CrLf(0);
]</syntaxhighlight>
 
{{out}}
<pre>
<CharacterRemarks>
<Character name="April">Bubbly: I&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</pre>
Line 2,757 ⟶ 3,365:
Variant #1-1: using a FLOWR expression and element constructors
 
<langsyntaxhighlight lang="xquery">
let $names := ("April","Tam O'Shanter","Emily")
let $remarks := ("Bubbly: I'm > Tam and <= Emily", 'Burns: "When chapman billies leave the street ..."',"Short &amp; shrift")
Line 2,767 ⟶ 3,375:
}
}
</syntaxhighlight>
</lang>
 
Variant #1-2: using a FLOWR expression and literal XML
 
<langsyntaxhighlight lang="xquery">
let $names := ("April","Tam O'Shanter","Emily")
let $remarks := ("Bubbly: I'm > Tam and <= Emily", 'Burns: "When chapman billies leave the street ..."',"Short &amp; shrift")
Line 2,780 ⟶ 3,388:
}
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
Variant #2-1: using a Higher Order Function and element constructors
 
<langsyntaxhighlight lang="xquery">
xquery version "3.1";
 
Line 2,797 ⟶ 3,405:
})
}
</syntaxhighlight>
</lang>
 
Variant #2-2: using a Higher Order Function and literal XML expressions :)
 
<langsyntaxhighlight lang="xquery">
xquery version "3.1";
 
Line 2,813 ⟶ 3,421:
}
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
Result for all variants:
 
<langsyntaxhighlight lang="xml">
<CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
Line 2,823 ⟶ 3,431:
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
</lang>
 
=={{header|XPL0}}==
<lang XPL0>code ChOut=8, CrLf=9, Text=12;
string 0; \use zero-terminated strings
 
proc XmlOut(S); \Output string in XML format
char S;
repeat case S(0) of \character entity substitutions
^<: Text(0, "&lt;");
^>: Text(0, "&gt;");
^&: Text(0, "&amp;");
^": Text(0, "&quot;");
^': Text(0, "&apos;")
other ChOut(0, S(0));
S:= S+1;
until S(0) = 0;
 
int Name, Remark, I;
[Name:= ["April", "Tam O'Shanter", "Emily"];
Remark:= ["Bubbly: I'm > Tam and <= Emily",
"Burns: ^"When chapman billies leave the street ...^"",
"Short & shrift"];
Text(0, "<CharacterRemarks>"); CrLf(0);
for I:= 0 to 3-1 do
[Text(0, " <Character name=^"");
XmlOut(Name(I));
Text(0, "^">");
XmlOut(Remark(I));
Text(0, "</Character>"); CrLf(0);
];
Text(0, "</CharacterRemarks>"); CrLf(0);
]</lang>
 
{{out}}
<pre>
<CharacterRemarks>
<Character name="April">Bubbly: I&apos;m &gt; Tam and &lt;= Emily</Character>
<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
<Character name="Emily">Short &amp; shrift</Character>
</CharacterRemarks>
</pre>
 
=={{header|Yabasic}}==
<langsyntaxhighlight Yabasiclang="yabasic">sign$ = "<,&lt;,>,&gt;,&,&amp;"
dim sign$(1)
long = token(sign$, sign$(), ",")
Line 2,912 ⟶ 3,479:
next i
 
print xml_CharacterRemarks$(testset$())</langsyntaxhighlight>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn xmlEscape(text){
text.replace(" &"," &amp;") .replace(" \""," &quot;")
.replace(" '"," &apos;") .replace(" <"," &lt;") .replace(" >"," &gt;")
Line 2,932 ⟶ 3,499:
0'|Burns: "When chapman billies leave the street ..."|,
"Short & shrift"))
.print();</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,485

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/94911...349366"