XML/Output: Difference between revisions

{{task|XML}}

 

As an example, calling the function with the three names of:

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 too that although the task is written to take two lists of corresponding data, a single mapping/hash/dictionary of names to remarks is also acceptable.

 

=={{header|Ada}}==

{{works with|GNAT}}

 

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

names := xmlescape(names)

remarks := xmlescape(remarks)

Short & shrift

)

 

=={{header|BASIC}}==

 

 

 

 

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

 

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

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

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

{{trans|BASIC}}

sequence r

r = ""

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

end for

 

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

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

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

</CharacterRemarks>

 

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

 

}

}

 

<pre>

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

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

"encoding/xml"

"fmt"

"text/template"

)

 

func xmlEscapeString(s string) string {

xml.Escape(&b, []byte(s))

return b.String()

// Define function required by task description.

xRemarks := func(crms []crm) (string, error) {

err := xt.Execute(&b, crms)

return b.String(), err

}

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.

 

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>

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

</CharacterRemarks></pre>

 

=={{header|NetRexx}}==

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

 

(de characterRemarks (Names Remarks)

"I'm > Tam and <= Emily"

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

Output:

<pre><CharacterRemarks>

</CharacterRemarks></pre>

 

=={{header|PureBasic}}==

Structure characteristic

name.s

remark.s

EndStructure

NewList didel.characteristic()

ResetList(didel())

FirstElement(didel())

ResetList(didel())

FirstElement(didel())

 

 

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

char2xml(remark.j)'"</Character>'

end /*j*/

 

 

end /*m*/

 

 

 

 

charname 1 = April

charname 2 = Tam O'Shanter

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

{ names zip remarks map { case (name, remark) => <Character name={name}>{remark}</Character> } }

</CharacterRemarks>

 

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

</CharacterRemarks>

</pre>

 

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

 

{{omit from|Batch File|No way of XML parsing or processing.}}