XML/Output: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
(14 intermediate revisions by 10 users not shown) | |||
Line 14:
Short & shrift</pre>
Should produce the XML (but not necessarily with the indentation):
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
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
=={{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 */
Line 197:
/* 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("<")
ELSEIF c='> THEN
Print(">")
ELSEIF c='& THEN
Print("&")
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 > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns:"When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</pre>
=={{header|Ada}}==
Line 205 ⟶ 293:
character_remarks.adb:
<
with Ada.Text_IO.Text_Streams;
with DOM.Core.Documents;
Line 244 ⟶ 332:
N => My_Document,
Pretty_Print => True);
end Character_Remarks;</
=== Alternative version using Matreshka ===
Line 250 ⟶ 338:
Uses [http://forge.ada-ru.org/matreshka Matreshka SAX API for XML].
<
with League.Strings;
Line 302 ⟶ 390:
(+"Tam O'Shanter", +"Burns: ""When chapman billies leave the street ..."""),
(+"Emily", +"Short & shrift")));
end Main;</
=={{header|ALGOL 68}}==
<
OP TOXMLSTRING = ( STRING str )STRING:
BEGIN
Line 351 ⟶ 439:
)
)
</syntaxhighlight>
{{out}}
<
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ...</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program outputXml.s */
Line 562 ⟶ 650:
bx lr @ return
</syntaxhighlight>
{{output}}
<pre>
Line 574 ⟶ 662:
=={{header|AutoHotkey}}==
<
names := xmlescape(names)
remarks := xmlescape(remarks)
Line 623 ⟶ 711:
Short & shrift
)
return</
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<
110 DE$(0) = "April"
120 RE$(0) = "Bubbly: I'm > Tam and <= Emily"
Line 656 ⟶ 744:
370 PRINT C$;
380 NEXT N
390 RETURN</
Line 663 ⟶ 751:
Not terribly different from the Applesoft BASIC example above, but this allows for a few more character/entity translations.
<
2 rem rosetta code
5 print chr$(147);chr$(14):gosub 900
Line 717 ⟶ 805:
1010 data "Emily","Short & shrift"
1015 data "Joey","Always look ^."
1999 data "[end]","[end]"</
{{out}}
Line 746 ⟶ 834:
=={{header|Bracmat}}==
<
= PCDATAentities attributeValueEntities doAll doAttributes
, xml
Line 857 ⟶ 945:
)
)
)</
{{out}}
<pre><?xml?>
Line 866 ⟶ 954:
=={{header|C}}==
==={{libheader|libXML}}===
<
#include <stdlib.h>
#include <string.h>
Line 906 ⟶ 994:
return EXIT_SUCCESS;
}</
==={{libheader|Gadget}}===
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
LIB_GADGET_START
const char* codes[] = {"&",">","<"};
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 > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{header|C sharp}}==
{{works with|C sharp|C#|3.0+}}
<
using System.Collections.Generic;
using System.Linq;
Line 936 ⟶ 1,091:
Console.WriteLine(xml);
}
}</
=={{header|C++}}==
Library: Boost
<
#include <utility>
#include <iostream>
Line 985 ⟶ 1,140:
xmlstring.append( "</CharacterRemarks>" ) ;
return xmlstring ;
}</
=={{header|Clojure}}==
<
(defn character-remarks-xml [characters remarks]
(with-out-str (emit-element
Line 996 ⟶ 1,151:
{:tag :Character,
:attrs {:name (item 0)},
:content [(item 1)]}) )})))</
=={{header|Common Lisp}}==
Line 1,002 ⟶ 1,157:
{{libheader|Closure XML}}
<
(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))
(chars (dom:append-child doc (dom:create-element doc "Characters"))))
Line 1,011 ⟶ 1,166:
(dom:append-child chars c)))
characters lines)
(write-string (dom:map-document (cxml:make-rod-sink) doc) out)))</
Example of use:
<
'("Bubbly: I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"))</
{{out}}
Line 1,027 ⟶ 1,182:
=={{header|D}}==
{{libheader|KXML}}
<
char[][][]characters =
[["April","Bubbly: I'm > Tam and <= Emily"],
Line 1,044 ⟶ 1,199:
addChars(root,characters);
std.stdio.writefln("%s",root.write);
}</
<pre>
<?xml?>
Line 1,061 ⟶ 1,216:
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
//You need to use these units
uses
Line 1,138 ⟶ 1,293:
end;
</syntaxhighlight>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( xml_output ).
Line 1,154 ⟶ 1,309:
contents() -> [{"April", "Bubbly: I'm > Tam and <= Emily"}, {"Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\""}, {"Emily", "Short & shrift"}].
</syntaxhighlight>
{{out}}
<pre>
Line 1,163 ⟶ 1,318:
=={{header|Euphoria}}==
{{trans|BASIC}}
<
sequence r
r = ""
Line 1,196 ⟶ 1,351:
puts(1,"</Character>\n")
end for
puts(1,"</CharacterRemarks>\n")</
{{out}}
Line 1,207 ⟶ 1,362:
=={{header|F_Sharp|F#}}==
<
open System.Xml
Line 1,228 ⟶ 1,383:
root.AppendChild node |> ignore
) characters
doc.OuterXml</
<pre><CharacterRemarks>
<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>
Line 1,236 ⟶ 1,391:
=={{header|Factor}}==
<
: print-character-remarks ( names remarks -- )
[ [XML <Character name=<-> ><-></Character> XML] ] 2map
[XML <CharacterRemarks><-></CharacterRemarks> XML] pprint-xml ;</
Example of usage:
<
"Bubbly: I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"
} print-remarks</
=={{header|Fantom}}==
<
using xml
Line 1,276 ⟶ 1,431:
}
}
</syntaxhighlight>
{{out}} (not exactly conforming):
Line 1,292 ⟶ 1,447:
{{libheader|Forth Foundation Library}}
<
include ffl/xos.fs
Line 1,332 ⟶ 1,487:
\ Output xml string
xml str-get type cr</
=={{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 + "<"
Case Asc(">")
r = r + ">"
Case Asc("&")
r = r + "&"
Case Asc("""")
r = r + """
Case Asc("'")
r = r + "'"
Case Else
r = r + c
End Select
Next
Function = r
End Function</syntaxhighlight>
=={{header|Go}}==
'''Using package xml to marshal from a data structure:'''
<
import (
Line 1,370 ⟶ 1,567:
}
fmt.Println(x)
}</
{{out}}
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
Using the text/template package to generate text:
(but still leaning on the xml package for escaping.)
<
import (
Line 1,425 ⟶ 1,622:
}
fmt.Println(x)
}</
Output is same as marshalled version.
=={{header|Groovy}}==
<
def builder = new groovy.xml.MarkupBuilder(writer)
def names = ["April", "Tam O'Shanter", "Emily"]
Line 1,438 ⟶ 1,635:
}
println writer.toString()</
=={{header|Haskell}}==
This implementation uses the [http://hackage.haskell.org/package/xml <code>xml</code> package].
<
characterRemarks :: [String] -> [String] -> String
Line 1,455 ⟶ 1,652:
[Attr (unqual "name") name]
[Text $ CData CDataText remark Nothing]
Nothing</
=={{header|HicEst}}==
<
CHARACTER remarks*200/%Bubbly: I'm > Tam and <= Emily~Burns: "When chapman billies leave the street ..."~Short & shrift~%/
CHARACTER XML*1000
Line 1,472 ⟶ 1,669:
XML = TRIM(XML) // '<Character name="' // name // '">' // remark // '</Character>' // $CRLF
ENDDO
XML = TRIM(XML) // "</CharacterRemarks>"</
=={{header|J}}==
Line 1,478 ⟶ 1,675:
First create the table of substitutions and the verb which properly escapes the input string:
<
esc=: [:; {&tbl@:i.~&a.</
Then create the verb which combines name with remark:
<
'<Character name="', (esc x), '">', (esc y), '</Character>', LF
)</
Finally, create the verb which creates the final XML:
<
Example:
<
remarks=: <;._2]0 :0
Line 1,497 ⟶ 1,694:
Burns: "When chapman billies leave the street ..."
Short & shrift
)</
<syntaxhighlight lang="text"> names xmlify remarks
<CharacterRemarks>
<Character name="April"> I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter"> Burns: "e;When chapman billies leave the street ..."e;</Character>
<Character name="Emily"> Short & shrift</Character>
</CharacterRemarks></
=={{header|Java}}==
===Using DOM===
<
import javax.xml.parsers.DocumentBuilderFactory;
Line 1,568 ⟶ 1,765:
}
}</
Result:
<
<CharacterRemarks>
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character></
===Using the Streaming API for XML (StAX)===
<
import javax.xml.stream.XMLOutputFactory;
Line 1,615 ⟶ 1,812:
}
}
}</
This produces:
<
=={{header|Joy}}==
<syntaxhighlight lang="joy">
DEFINE subst ==
[[['< "<" putchars]
Line 1,630 ⟶ 1,827:
XMLOutput ==
"<CharacterRemarks>\n" putchars
[
"</CharacterRemarks>\n" putchars.
[
] XMLOutput.
</syntaxhighlight>
=={{header|jq}}==
{{trans|Wren}}
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq'''
<syntaxhighlight lang=jq>
def escapes: [
["&" , "&"], # must do this one first
["\"", """],
["'" , "'"],
["<" , "<"],
[">" , ">"]
];
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}}==
<
dialog = [("April", "Bubbly: I'm > Tam and <= Emily"),
Line 1,656 ⟶ 1,888:
println(xdoc)
</
<?xml version="1.0" encoding="utf-8"?>
<CharacterRemarks>
Line 1,666 ⟶ 1,898:
=={{header|Kotlin}}==
<
import javax.xml.parsers.DocumentBuilderFactory
Line 1,710 ⟶ 1,942:
println(sw)
}
</syntaxhighlight>
{{out}}
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{header|Lasso}}==
Lasso has built in support for both creating and parsing xml.
<
fail_if(#names -> size != #remarks -> size, -1, 'Input arrays not of same size')
Line 1,757 ⟶ 1,989:
array(`April`, `Tam O'Shanter`, `Emily`),
array(`Bubbly: I'm > Tam and <= Emily`, `Burns: "When chapman billies leave the street ..."`, `Short & shrift`)
)</
{{out}}
<
<?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,768 ⟶ 2,000:
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{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.
<
function addNode(parent, nodeName, key, value, content)
Line 1,784 ⟶ 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)</
{{out}}
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
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:
<
print(xmlStr)</
{{out}}
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{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'm &qt; Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Some tricky input with the second remark
<
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" -> "\""]</
{{out}}
<pre><CharacterRemarks>
<Character name=\"April\">Bubbly:I'm > Tam and <= Emily</Character>
Line 1,820 ⟶ 2,082:
=={{header|MATLAB}}==
<
docRootNode = RootXML.getDocumentElement;
thisElement = RootXML.createElement('Character');
Line 1,833 ⟶ 2,095:
thisElement.setAttribute('Name','Emily')
thisElement.setTextContent('Short & shrift');
docRootNode.appendChild(thisElement);</
{{out}}
Line 1,853 ⟶ 2,115:
===Using DOM===
{{trans|Java}}
<
options replace format comments java crossref savelog symbols nobinary
Line 1,918 ⟶ 2,180:
return
</syntaxhighlight>
;Output
<
<CharacterRemarks>
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
Line 1,926 ⟶ 2,188:
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
===Using the Streaming API for XML (StAX)===
{{trans|Java}}
<
options replace format comments java crossref savelog symbols nobinary
Line 1,978 ⟶ 2,240:
return
</syntaxhighlight>
;Output
<
<CharacterRemarks>
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
Line 1,986 ⟶ 2,248:
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{header|Nim}}==
<
proc charsToXML(names, remarks: seq[string]): XmlNode =
Line 1,999 ⟶ 2,261:
@["Bubbly: I'm > Tam and <= Emily",
"Burns: \"When chapman billies leave the street ...\"",
"Short & shrift"])</
Output:
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{header|Objeck}}==
<
use Collection.Generic;
Line 2,037 ⟶ 2,299:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
Line 2,043 ⟶ 2,305:
from the toplevel using the library [http://tech.motion-twin.com/xmllight.html xml-light]:
<
# #load "xml-light.cma" ;;
Line 2,065 ⟶ 2,327:
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
- : unit = ()</
Another solution using the library [http://erratique.ch/software/xmlm xmlm]:
<
#load "xmlm.cmo"
open Xmlm
Line 2,090 ⟶ 2,352:
) datas;
output xo (`El_end);
print_newline()</
=={{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.
<
proc {Main}
Names = ["April"
Line 2,183 ⟶ 2,445:
end
in
{Main}</
Output:
<
<CharacterRemarks>
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{header|Perl}}==
{{libheader|XML::Mini}}
<
use strict;
use XML::Mini::Document;
Line 2,213 ⟶ 2,475:
$stud->text($s->[1]);
}
print $doc->toString();</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<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;">"<"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&lt;"</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">">"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&gt;"</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"&"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;"</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"\""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&quot;"</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"\'"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&apos;"</span><span style="color: #0000FF;">}})</span>
<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>
<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>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<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>
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"<CharacterRemarks>\n"</span>
<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>
<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;">" <CharacterName=\"%s\">%s</Character>\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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">&</span> <span style="color: #008000;">"</CharacterRemarks>\n"</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">testset</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"April"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Bubbly: I'm > Tam and <= Emily"</span><span style="color: #0000FF;">},</span>
<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>
<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>
<span style="color: #000080;font-style:italic;">-- Sample output:
-- <CharacterRemarks>
--
-- <CharacterName="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>
-- <CharacterName="Emily">Short &amp; shrift</Character>
-- </CharacterRemarks></span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
<
(de characterRemarks (Names Remarks)
Line 2,269 ⟶ 2,534:
"I'm > Tam and <= Emily"
"Burns: \"When chapman billies leave the street ..."
"Short & shrift" ) )</
Output:
<pre><CharacterRemarks>
Line 2,278 ⟶ 2,543:
=={{header|PureBasic}}==
<
dataItemCount:
Data.i 3
Line 2,336 ⟶ 2,601:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
Sample output:
<pre><CharacterRemarks>
Line 2,348 ⟶ 2,613:
=={{header|Python}}==
Normal output is all one line of XML, the .replace(...) makes it more readable.
<
>>> from itertools import izip
>>> def characterstoxml(names, remarks):
Line 2,361 ⟶ 2,626:
remarks = [ "Bubbly: I'm > Tam and <= Emily",
'Burns: "When chapman billies leave the street ..."',
'Short & shrift' ] ).replace('><','>\n<')</
Gives the output:
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{header|R}}==
{{libheader|XML}}
<
char2xml <- function(names, remarks){
tt <- xmlHashTree()
Line 2,383 ⟶ 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") )</
Gives the output: <!-- manually inserted "&" where required to protect actual R output from the browser -->
Line 2,394 ⟶ 2,659:
=={{header|Racket}}==
<
#lang racket
(require xml)
Line 2,411 ⟶ 2,676:
"Burns: \"When chapman billies leave the street ...\""
"Short & shrift"))))
</syntaxhighlight>
Output:
<
<CharacterRemarks>
<Character name="April">
Line 2,427 ⟶ 2,692:
</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{header|Raku}}==
Line 2,433 ⟶ 2,698:
{{works with|Rakudo|2018.05}}
<syntaxhighlight lang="raku"
my @students =
Line 2,443 ⟶ 2,708:
my @lines = map { :Character[:name(.[0]), .[1]] }, @students;
say XML::Writer.serialize( CharacterRemarks => @lines );</
{{out}}
<
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character></CharacterRemarks></
=={{header|Rascal}}==
<
import lang::xml::DOM;
Line 2,465 ⟶ 2,730:
return println(xmlPretty(x));
}
}</
This gives an output:
<
<?xml version="1.0" encoding="UTF-8"?>
<CharacterRemarks>
Line 2,476 ⟶ 2,741:
ok</
=={{header|REXX}}==
REXX doesn't have any functions to handle XML entities, an abbreviated version is included here.
<
charname. =
charname.1 = "April"
Line 2,596 ⟶ 2,861:
xml_: parse arg _ /*make an XML entity (&xxxx;) */
if pos(_, $)\==0 then return changestr(_, $, "&"arg(2)";")
return $</
Some older REXXes don't have a '''changestr''' bif, so one is included here ──► [[CHANGESTR.REX]].
Line 2,618 ⟶ 2,883:
=={{header|Ruby}}==
The {{libheader|REXML}}library handles character mapping when adding attributes and text.
<
include REXML
Line 2,635 ⟶ 2,900:
# output with indentation
doc.write($stdout, 2)</
produces <!-- manually inserted "&" where required to protect actual Ruby output from the browser -->
Line 2,651 ⟶ 2,916:
=={{header|Rust}}==
<
use std::collections::HashMap;
Line 2,708 ⟶ 2,973:
assert!(output.contains("<Character name=\"Emily\">Short & shrift</Character>"));
}
}</
=={{header|Scala}}==
<
val remarks = List("Bubbly: I'm > Tam and <= Emily", """Burns: "When chapman billies leave the street ..."""", "Short & shrift")
Line 2,720 ⟶ 2,985:
characterRemarks(names, remarks)
</syntaxhighlight>
Result:
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character><Character name="Tam O'Shanter">Burns:
"When chapman billies leave the street ..."</Character><Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
=={{header|SenseTalk}}==
<
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
Line 2,735 ⟶ 3,000:
insert (_tag: "Character", name: name, _children: item the counter of remarks) as tree into document's _children
end repeat
put document</
{{out}}
Line 2,748 ⟶ 3,013:
=={{header|Sidef}}==
{{trans|Perl}}
<
var students = [
Line 2,766 ⟶ 3,031:
};
print doc.toString;</
=={{header|Slate}}==
<
{'April' -> 'Bubbly: I\'m > Tam and <= Emily'.
'Tam O\'Shanter' -> 'Burns: "When chapman billies leave the street ..."'.
Line 2,783 ⟶ 3,048:
].
inform: writer contents</
Produces:
<div style="width:full;overflow:scroll">
Line 2,792 ⟶ 3,057:
=={{header|Tcl}}==
===Using only Tcl string manipulation===
<
list [string map "' ' \\\" " < > > < & &" $string]
}
Line 2,819 ⟶ 3,084:
append cmd " \[< Character {Name [xquote $name]} [xquote $comment]\]"
}
puts [eval $cmd]</
produces<pre><CharacterRemarks><Character Name='April'>Bubbly: I&apos;m &lt; Tam and &gt;= Emily</Character>
<Character Name='Tam O&apos;Shanter'>Burns: &quot;When chapman billies leave the street ...&quot;</Character>
Line 2,826 ⟶ 3,091:
===Working with DOM trees===
Using {{libheader|tDOM}}
<
set xml [dom createDocument CharacterRemarks]
foreach {name comment} {
Line 2,838 ⟶ 3,103:
[$xml documentElement] appendChild $elem
}
$xml asXML</
<pre><CharacterRemarks>
<Character name="April">Bubbly: I'm &amp;gt; Tam and &amp;lt;= Emily</Character>
Line 2,845 ⟶ 3,110:
</CharacterRemarks></pre>
Using {{libheader|TclXML}}
<
set xml [dom::DOMImplementation create]
set root [dom::document createElement $xml CharacterRemarks]
Line 2,857 ⟶ 3,122:
dom::document createTextNode $element $comment
}
dom::DOMImplementation serialize $xml -indent 1</
produces (with line breaks added for clarity:
<pre><?xml version="1.0"?>
Line 2,867 ⟶ 3,132:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
STRUCTURE xmloutput
Line 2,889 ⟶ 3,154:
WRITE/NEXT d
ENDACCESS d
</syntaxhighlight>
Output in file "dest":
<pre>
Line 2,901 ⟶ 3,166:
=={{header|VBScript}}==
Saves in a file.
<syntaxhighlight lang="vbscript}}">
Set objXMLDoc = CreateObject("msxml2.domdocument")
Line 2,919 ⟶ 3,184:
objRoot.appendChild objNode
End Function
</syntaxhighlight>
=={{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.
<
Replace("&", "&", BEGIN+ALL+NOERR) // this must be the first replace!
Replace("<", "<", BEGIN+ALL+NOERR)
Line 2,940 ⟶ 3,205:
}
EOF
IT("</CharacterRemarks>") IN</
Example input:
Line 2,959 ⟶ 3,224:
=={{header|Visual Basic .NET}}==
<
Sub Main()
Dim charRemarks As New Dictionary(Of String, String)
Line 2,972 ⟶ 3,237:
Console.WriteLine(xml)
End Sub
End Module</
Output:
Line 2,984 ⟶ 3,249:
=={{header|Wren}}==
<
["&" , "&"], // must do this one first
["\"", """],
Line 3,014 ⟶ 3,279:
"Short & shrift"
]
xmlDoc.call(names, remarks)</
{{out}}
<
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
<Character name="Tam O'Shanter">Burns: "When chapman billies leave the street ..."</Character>
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks></
<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}}==
<
string 0; \use zero-terminated strings
Line 3,053 ⟶ 3,344:
];
Text(0, "</CharacterRemarks>"); CrLf(0);
]</
{{out}}
Line 3,074 ⟶ 3,365:
Variant #1-1: using a FLOWR expression and element constructors
<
let $names := ("April","Tam O'Shanter","Emily")
let $remarks := ("Bubbly: I'm > Tam and <= Emily", 'Burns: "When chapman billies leave the street ..."',"Short & shrift")
Line 3,084 ⟶ 3,375:
}
}
</syntaxhighlight>
Variant #1-2: using a FLOWR expression and literal XML
<
let $names := ("April","Tam O'Shanter","Emily")
let $remarks := ("Bubbly: I'm > Tam and <= Emily", 'Burns: "When chapman billies leave the street ..."',"Short & shrift")
Line 3,097 ⟶ 3,388:
}
</CharacterRemarks>
</syntaxhighlight>
Variant #2-1: using a Higher Order Function and element constructors
<
xquery version "3.1";
Line 3,114 ⟶ 3,405:
})
}
</syntaxhighlight>
Variant #2-2: using a Higher Order Function and literal XML expressions :)
<
xquery version "3.1";
Line 3,130 ⟶ 3,421:
}
</CharacterRemarks>
</syntaxhighlight>
Result for all variants:
<
<CharacterRemarks>
<Character name="April">Bubbly: I'm > Tam and <= Emily</Character>
Line 3,140 ⟶ 3,431:
<Character name="Emily">Short & shrift</Character>
</CharacterRemarks>
</syntaxhighlight>
=={{header|Yabasic}}==
<
dim sign$(1)
long = token(sign$, sign$(), ",")
Line 3,188 ⟶ 3,479:
next i
print xml_CharacterRemarks$(testset$())</
=={{header|zkl}}==
<
text.replace(" &"," &") .replace(" \""," "")
.replace(" '"," '") .replace(" <"," <") .replace(" >"," >")
Line 3,208 ⟶ 3,499:
0'|Burns: "When chapman billies leave the street ..."|,
"Short & shrift"))
.print();</
{{out}}
<pre>
|