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|Ada}}==

 

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

 

=={{header|Bracmat}}==

= PCDATAentities attributeValueEntities doAll doAttributes

, xml

)

)

{{out}}

<pre><?xml?>

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

return EXIT_SUCCESS;

 

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

XMLOutput ==

"<CharacterRemarks>\n" putchars

"</CharacterRemarks>\n" putchars.

 

] XMLOutput.

 

 

=={{header|Julia}}==

 

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

 

println(xdoc)

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

<CharacterRemarks>

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

</CharacterRemarks>

</pre>

 

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

 

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

<pre><CharacterRemarks>

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

</CharacterRemarks></pre>

 

docRootNode = RootXML.getDocumentElement;

thisElement = RootXML.createElement('Character');

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

thisElement.setTextContent('Short & shrift');

<pre>

xmlwrite(RootXML)

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

 

result = <>CharacterRemarks()

for name, remark in items zip(names, remarks):

 

echo charsToXML(@["April", "Tam O'Shanter", "Emily"],

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

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

Output:

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

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

 

=={{header|Objeck}}==

 

}

}

 

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

 

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

</Character>

</CharacterRemarks></pre>

 

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

</CharacterRemarks>

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

];

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

 

{{out}}

</CharacterRemarks>

</pre>

 

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