XML/Output: Difference between revisions

Short & shrift</pre>

Should produce the XML (but not necessarily with the indentation):

<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>

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.

'''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]]).

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program outputXml64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Action!}}==

DEFINE CHARACTER_SIZE="4"

TYPE Character=[PTR name,remark]

OutputCharacters(d,count)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/XML_Output.png Screenshot from Atari 8-bit computer]

character_remarks.adb:

with Ada.Text_IO.Text_Streams;

with DOM.Core.Documents;

N => My_Document,

Pretty_Print => True);

=== Alternative version using Matreshka ===

Uses [http://forge.ada-ru.org/matreshka Matreshka SAX API for XML].

with League.Strings;

(+"Tam O'Shanter", +"Burns: ""When chapman billies leave the street ..."""),

(+"Emily", +"Short & shrift")));

=={{header|ALGOL 68}}==

OP TOXMLSTRING = ( STRING str )STRING:

BEGIN

)

)

{{out}}

<Character name="Tam O&apos;Shanter">Burns: &quot;When chapman billies leave the street ...</Character>

<Character name="Emily">Short &amp; shrift</Character>

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program outputXml.s */

bx lr @ return

{{output}}

<pre>

=={{header|AutoHotkey}}==

names := xmlescape(names)

remarks := xmlescape(remarks)

Short & shrift

)

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

110 DE$(0) = "April"

120 RE$(0) = "Bubbly: I'm > Tam and <= Emily"

370 PRINT C$;

380 NEXT N

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

1010 data "Emily","Short & shrift"

1015 data "Joey","Always look ^."

{{out}}

=={{header|Bracmat}}==

= PCDATAentities attributeValueEntities doAll doAttributes

, xml

)

)

{{out}}

<pre><?xml?>

=={{header|C}}==

{{libheader|libXML}}

#include <stdlib.h>

#include <string.h>

return EXIT_SUCCESS;

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

{{works with|C sharp|C#|3.0+}}

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(xml);

}

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

Library: Boost

#include <utility>

#include <iostream>

xmlstring.append( "</CharacterRemarks>" ) ;

return xmlstring ;

=={{header|Clojure}}==

(defn character-remarks-xml [characters remarks]

(with-out-str (emit-element

{:tag :Character,

:attrs {:name (item 0)},

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

{{libheader|Closure XML}}

(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))

(chars (dom:append-child doc (dom:create-element doc "Characters"))))

(dom:append-child chars c)))

characters lines)

Example of use:

'("Bubbly: I'm > Tam and <= Emily"

"Burns: \"When chapman billies leave the street ...\""

{{out}}

=={{header|D}}==

{{libheader|KXML}}

char[][][]characters =

[["April","Bubbly: I'm > Tam and <= Emily"],

addChars(root,characters);

std.stdio.writefln("%s",root.write);

<pre>

<?xml?>

=={{header|Delphi}}==

//You need to use these units

uses

end;

=={{header|Erlang}}==

-module( xml_output ).

contents() -> [{"April", "Bubbly: I'm > Tam and <= Emily"}, {"Tam O'Shanter", "Burns: \"When chapman billies leave the street ...\""}, {"Emily", "Short & shrift"}].

{{out}}

<pre>

=={{header|Euphoria}}==

{{trans|BASIC}}

sequence r

r = ""

puts(1,"</Character>\n")

end for

{{out}}

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

open System.Xml

root.AppendChild node |> ignore

) characters

<pre><CharacterRemarks>

<Character name="April">Bubbly: I'm &amp;gt; Tam and &amp;lt;= Emily</Character>

=={{header|Factor}}==

: print-character-remarks ( names remarks -- )

[ [XML <Character name=<-> ><-></Character> XML] ] 2map

Example of usage:

"Bubbly: I'm > Tam and <= Emily"

"Burns: \"When chapman billies leave the street ...\""

"Short & shrift"

=={{header|Fantom}}==

using xml

}

}

{{out}} (not exactly conforming):

{{libheader|Forth Foundation Library}}

include ffl/xos.fs

\ Output xml string

=={{header|FreeBASIC}}==

"Tam O'Shanter", "Burns: ""When chapman billies leave the street ...""", _

"Emily", "Short & shrift"

Next

Function = r

=={{header|Go}}==

'''Using package xml to marshal from a data structure:'''

import (

}

fmt.Println(x)

{{out}}

<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>

Using the text/template package to generate text:

(but still leaning on the xml package for escaping.)

import (

}

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"]

}

=={{header|Haskell}}==

This implementation uses the [http://hackage.haskell.org/package/xml <code>xml</code> package].

characterRemarks :: [String] -> [String] -> String

[Attr (unqual "name") name]

[Text $ CData CDataText remark Nothing]

=={{header|HicEst}}==

CHARACTER remarks*200/%Bubbly: I'm > Tam and <= Emily~Burns: "When chapman billies leave the street ..."~Short & shrift~%/

CHARACTER XML*1000

XML = TRIM(XML) // '<Character name="' // name // '">' // remark // '</Character>' // $CRLF

ENDDO

=={{header|J}}==

First create the table of substitutions and the verb which properly escapes the input string:

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

Burns: "When chapman billies leave the street ..."

Short & shrift

<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>

=={{header|Java}}==

===Using DOM===

import javax.xml.parsers.DocumentBuilderFactory;

}

Result:

<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>

===Using the Streaming API for XML (StAX)===

import javax.xml.stream.XMLOutputFactory;

}

}

This produces:

=={{header|Joy}}==

DEFINE subst ==

[[['< "&lt;" putchars]

=={{header|Julia}}==

dialog = [("April", "Bubbly: I'm > Tam and <= Emily"),

println(xdoc)

<?xml version="1.0" encoding="utf-8"?>

<CharacterRemarks>

=={{header|Kotlin}}==

import javax.xml.parsers.DocumentBuilderFactory

println(sw)

}

{{out}}

<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>

=={{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')

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">

<Character name="Emily">Short &amp; shrift</Character>

</CharacterRemarks>

=={{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)

addNode(root, "Character", "name", "Tam O'Shanter", 'Burns: "When chapman billies leave the street ..."')

addNode(root, "Character", "name", "Emily", "Short & shrift")

{{out}}

<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>

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:

{{out}}

<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>

=={{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"};

XMLElement["Character", {"name" -> c[[2]]}, {r[[2]]}],

XMLElement["Character", {"name" -> c[[3]]}, {r[[3]]}]

{{out}}

<pre><CharacterRemarks>

=={{header|MATLAB}}==

docRootNode = RootXML.getDocumentElement;

thisElement = RootXML.createElement('Character');

thisElement.setAttribute('Name','Emily')

thisElement.setTextContent('Short & shrift');

{{out}}

===Using DOM===

{{trans|Java}}

options replace format comments java crossref savelog symbols nobinary

return

;Output

<CharacterRemarks>

<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>

<Character name="Emily">Short &amp; shrift</Character>

</CharacterRemarks>

===Using the Streaming API for XML (StAX)===

{{trans|Java}}

options replace format comments java crossref savelog symbols nobinary

return

;Output

<CharacterRemarks>

<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>

<Character name="Emily">Short &amp; shrift</Character>

</CharacterRemarks>

=={{header|Nim}}==

proc charsToXML(names, remarks: seq[string]): XmlNode =

@["Bubbly: I'm > Tam and <= Emily",

"Burns: \"When chapman billies leave the street ...\"",

Output:

<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>

=={{header|Objeck}}==

use Collection.Generic;

}

}

=={{header|OCaml}}==

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

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

<Character name="Emily">Short &amp; shrift</Character>

</CharacterRemarks>

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

#load "xmlm.cmo"

open Xmlm

) datas;

output xo (`El_end);

=={{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"

end

in

Output:

<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>

=={{header|Perl}}==

{{libheader|XML::Mini}}

use strict;

use XML::Mini::Document;

$stud->text($s->[1]);

}

=={{header|Phix}}==

<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;">"&lt;"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&amp;lt;"</span><span style="color: #0000FF;">},</span>

-- &lt;CharacterName="Emily"&gt;Short &amp;amp; shrift&lt;/Character&gt;

-- &lt;/CharacterRemarks&gt;</span>

=={{header|PicoLisp}}==

(de characterRemarks (Names Remarks)

"I'm > Tam and <= Emily"

"Burns: \"When chapman billies leave the street ..."

Output:

<pre><CharacterRemarks>

=={{header|PureBasic}}==

dataItemCount:

Data.i 3

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre><CharacterRemarks>

=={{header|Python}}==

Normal output is all one line of XML, the .replace(...) makes it more readable.

>>> from itertools import izip

>>> def characterstoxml(names, remarks):

remarks = [ "Bubbly: I'm > Tam and <= Emily",

'Burns: "When chapman billies leave the street ..."',

Gives the output:

<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>

=={{header|R}}==

{{libheader|XML}}

char2xml <- function(names, remarks){

tt <- xmlHashTree()

}

output <- char2xml( names=c("April","Tam O'Shanter","Emily"),

Gives the output: <!-- manually inserted "&amp;" where required to protect actual R output from the browser -->

=={{header|Racket}}==

#lang racket

(require xml)

"Burns: \"When chapman billies leave the street ...\""

"Short & shrift"))))

Output:

<CharacterRemarks>

<Character name="April">

</Character>

</CharacterRemarks>

=={{header|Raku}}==

{{works with|Rakudo|2018.05}}

my @students =

my @lines = map { :Character[:name(.[0]), .[1]] }, @students;

{{out}}

<Character name="Tam O'Shanter">Burns: &quot;When chapman billies leave the street ...&quot;</Character>

=={{header|Rascal}}==

import lang::xml::DOM;

return println(xmlPretty(x));

}

This gives an output:

<?xml version="1.0" encoding="UTF-8"?>

<CharacterRemarks>

=={{header|REXX}}==

REXX doesn't have any functions to handle XML entities, an abbreviated version is included here.

charname. =

charname.1 = "April"

xml_: parse arg _ /*make an XML entity (&xxxx;) */

if pos(_, $)\==0 then return changestr(_, $, "&"arg(2)";")

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

=={{header|Ruby}}==

The {{libheader|REXML}}library handles character mapping when adding attributes and text.

include REXML

# output with indentation

produces <!-- manually inserted "&amp;" where required to protect actual Ruby output from the browser -->

=={{header|Rust}}==

use std::collections::HashMap;

assert!(output.contains("<Character name=\"Emily\">Short &amp; shrift</Character>"));

}

=={{header|Scala}}==

val remarks = List("Bubbly: I'm > Tam and <= Emily", """Burns: "When chapman billies leave the street ..."""", "Short & shrift")

characterRemarks(names, remarks)

Result:

<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>

=={{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

insert (_tag: "Character", name: name, _children: item the counter of remarks) as tree into document's _children

end repeat

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var students = [

};

=={{header|Slate}}==

{'April' -> 'Bubbly: I\'m > Tam and <= Emily'.

'Tam O\'Shanter' -> 'Burns: "When chapman billies leave the street ..."'.

].

Produces:

<div style="width:full;overflow:scroll">

=={{header|Tcl}}==

===Using only Tcl string manipulation===

list [string map "' &apos; \\\" &quot; < &gt; > &lt; & &amp;" $string]

}

append cmd " \[< Character {Name [xquote $name]} [xquote $comment]\]"

}

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>

===Working with DOM trees===

Using {{libheader|tDOM}}

set xml [dom createDocument CharacterRemarks]

foreach {name comment} {

[$xml documentElement] appendChild $elem

}

<pre><CharacterRemarks>

<Character name="April">Bubbly: I'm &amp;amp;gt; Tam and &amp;amp;lt;= Emily</Character>

</CharacterRemarks></pre>

Using {{libheader|TclXML}}

set xml [dom::DOMImplementation create]

set root [dom::document createElement $xml CharacterRemarks]

dom::document createTextNode $element $comment

}

produces (with line breaks added for clarity:

<pre><?xml version="1.0"?>

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

STRUCTURE xmloutput

WRITE/NEXT d

ENDACCESS d

Output in file "dest":

<pre>

=={{header|VBScript}}==

Saves in a file.

Set objXMLDoc = CreateObject("msxml2.domdocument")

objRoot.appendChild objNode

End Function

=={{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("&", "&amp;", BEGIN+ALL+NOERR) // this must be the first replace!

Replace("<", "&lt;", BEGIN+ALL+NOERR)

}

EOF

Example input:

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

Sub Main()

Dim charRemarks As New Dictionary(Of String, String)

Console.WriteLine(xml)

End Sub

Output:

=={{header|Wren}}==

["&" , "&amp;"], // must do this one first

["\"", "&quot;"],

"Short & shrift"

]

{{out}}

<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>

<br>

{{libheader|Wren-xsequence}}

Alternatively, using an XML library.

var createXmlDoc = Fn.new { |names, remarks|

]

var doc = createXmlDoc.call(names, remarks)

{{out}}

Same as the first version but prefixed by:

=={{header|XPL0}}==

string 0; \use zero-terminated strings

];

Text(0, "</CharacterRemarks>"); CrLf(0);

{{out}}

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 &amp; shrift")

}

}

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 &amp; shrift")

}

</CharacterRemarks>

Variant #2-1: using a Higher Order Function and element constructors

xquery version "3.1";

})

}

Variant #2-2: using a Higher Order Function and literal XML expressions :)

xquery version "3.1";

}

</CharacterRemarks>

Result for all variants:

<CharacterRemarks>

<Character name="April">Bubbly: I'm &gt; Tam and &lt;= Emily</Character>

<Character name="Emily">Short &amp; shrift</Character>

</CharacterRemarks>

=={{header|Yabasic}}==

dim sign$(1)

long = token(sign$, sign$(), ",")

next i

=={{header|zkl}}==

text.replace(" &"," &amp;") .replace(" \""," &quot;")

.replace(" '"," &apos;") .replace(" <"," &lt;") .replace(" >"," &gt;")

0'|Burns: "When chapman billies leave the street ..."|,

"Short & shrift"))

{{out}}

<pre>