aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Task/XML-DOM-serialization/00-META.yaml Normal file
View file

@ -0,0 +1,3 @@
---
from: http://rosettacode.org/wiki/XML/DOM_serialization
note: XML

9
Task/XML-DOM-serialization/00-TASK.txt Normal file
View file

@ -0,0 +1,9 @@
Create a simple DOM and having it serialize to:
<?xml version="1.0" ?>
<root>
<element>
Some text here
</element>
</root>

102
Task/XML-DOM-serialization/AArch64-Assembly/xml-dom-serialization.aarch64 Normal file
View file

@ -0,0 +1,102 @@
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program createXml64.s */
/* install package libxml++2.6-dev */
/* link with gcc option -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 "file1.xml"
szFileMode: .asciz "w"
szMessError: .asciz "Error detected !!!!. \n"
szVersDoc: .asciz "1.0"
szLibRoot: .asciz "root"
szLibElement: .asciz "element"
szText: .asciz "some text here"
szCarriageReturn: .asciz "\n"
/*********************************/
/* 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,qAdrszLibRoot
bl xmlNewNode // create root node
cbz x0,99f
mov x20,x0 // node root address
mov x0,x19
mov x1,x20
bl xmlDocSetRootElement
mov x0,#0
ldr x1,qAdrszLibElement
bl xmlNewNode // create element node
mov x21,x0 // node element address
ldr x0,qAdrszText
bl xmlNewText // create text
mov x22,x0 // text address
mov x0,x21 // node element address
mov x1,x22 // text address
bl xmlAddChild // add text to element node
mov x0,x20 // node root address
mov x1,x21 // node element address
bl xmlAddChild // add node elemeny to root node
ldr x0,qAdrszFileName
ldr x1,qAdrszFileMode
bl fopen // file open
cmp x0,#0
blt 99f
mov x23,x0 // File descriptor
mov x1,x19 // doc
mov x2,x20 // root
bl xmlElemDump // write xml file
cmp x0,#0
blt 99f
mov x0,x23
bl fclose // file close
mov x0,x19
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
qAdrszLibRoot: .quad szLibRoot
qAdrszLibElement: .quad szLibElement
qAdrszText: .quad szText
qAdrszFileName: .quad szFileName
qAdrszFileMode: .quad szFileMode
qAdrszCarriageReturn: .quad szCarriageReturn
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

19
Task/XML-DOM-serialization/ABAP/xml-dom-serialization.abap Normal file
View file

@ -0,0 +1,19 @@
DATA: xml_string TYPE string.
DATA(xml) = cl_ixml=>create( ).
DATA(doc) = xml->create_document( ).
DATA(root) = doc->create_simple_element( name = 'root'
parent = doc ).
doc->create_simple_element( name = 'element'
parent = root
value = 'Some text here' ).
DATA(stream_factory) = xml->create_stream_factory( ).
DATA(stream) = stream_factory->create_ostream_cstring( string = xml_string ).
DATA(renderer) = xml->create_renderer( document = doc
ostream = stream ).
stream->set_pretty_print( abap_true ).
renderer->render( ).
cl_demo_output=>display_text( xml_string ).

174
Task/XML-DOM-serialization/ARM-Assembly/xml-dom-serialization.arm Normal file
View file

@ -0,0 +1,174 @@
/* ARM assembly Raspberry PI */
/* program createXml.s */
/* install package libxml++2.6-dev */
/* link with gcc option -lxml2 */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessEndpgm: .asciz "Normal end of program.\n"
szFileName: .asciz "file1.xml"
szFileMode: .asciz "w"
szMessError: .asciz "Error detected !!!!. \n"
szVersDoc: .asciz "1.0"
szLibRoot: .asciz "root"
szLibElement: .asciz "element"
szText: .asciz "some text here"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
ldr r0,iAdrszVersDoc
bl xmlNewDoc @ create doc
mov r9,r0 @ doc address
mov r0,#0
ldr r1,iAdrszLibRoot
bl xmlNewNode @ create root node
mov r8,r0 @ node root address
mov r0,r9
mov r1,r8
bl xmlDocSetRootElement
@TODO voir la gestion des erreurs
mov r0,#0
ldr r1,iAdrszLibElement
bl xmlNewNode @ create element node
mov r7,r0 @ node element address
ldr r0,iAdrszText
bl xmlNewText @ create text
mov r6,r0 @ text address
mov r0,r7 @ node element address
mov r1,r6 @ text address
bl xmlAddChild @ add text to element node
mov r0,r8 @ node root address
mov r1,r7 @ node element address
bl xmlAddChild @ add node elemeny to root node
ldr r0,iAdrszFileName
ldr r1,iAdrszFileMode
bl fopen @ file open
cmp r0,#0
blt 99f
mov r5,r0 @ File descriptor
mov r1,r9 @ doc
mov r2,r8 @ root
bl xmlElemDump @ write xml file
cmp r0,#0
blt 99f
mov r0,r5
bl fclose @ file close
mov r0,r9
bl xmlFreeDoc
bl xmlCleanupParser
ldr r0,iAdrszMessEndpgm
bl affichageMess
b 100f
99:
@ error
ldr r0,iAdrszMessError
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszMessError: .int szMessError
iAdrszMessEndpgm: .int szMessEndpgm
iAdrszVersDoc: .int szVersDoc
iAdrszLibRoot: .int szLibRoot
iAdrszLibElement: .int szLibElement
iAdrszText: .int szText
iAdrszFileName: .int szFileName
iAdrszFileMode: .int szFileMode
iAdrszCarriageReturn: .int szCarriageReturn
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registres
mov r2,#0 @ counter length
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur registers */
bx lr @ return
/******************************************************************/
/* Converting a register to a decimal */
/******************************************************************/
/* r0 contains value and r1 address area */
.equ LGZONECAL, 10
conversion10:
push {r1-r4,lr} @ save registers
mov r3,r1
mov r2,#LGZONECAL
1: @ start loop
bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
add r1,#48 @ digit
strb r1,[r3,r2] @ store digit on area
cmp r0,#0 @ stop if quotient = 0
subne r2,#1 @ previous position
bne 1b @ else loop
@ end replaces digit in front of area
mov r4,#0
2:
ldrb r1,[r3,r2]
strb r1,[r3,r4] @ store in area begin
add r4,#1
add r2,#1 @ previous position
cmp r2,#LGZONECAL @ end
ble 2b @ loop
mov r1,#' '
3:
strb r1,[r3,r4]
add r4,#1
cmp r4,#LGZONECAL @ end
ble 3b
100:
pop {r1-r4,lr} @ restaur registres
bx lr @return
/***************************************************/
/* division par 10 signé */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*
/* and http://www.hackersdelight.org/ */
/***************************************************/
/* r0 dividende */
/* r0 quotient */
/* r1 remainder */
divisionpar10:
/* r0 contains the argument to be divided by 10 */
push {r2-r4} @ save registers */
mov r4,r0
mov r3,#0x6667 @ r3 <- magic_number lower
movt r3,#0x6666 @ r3 <- magic_number upper
smull r1, r2, r3, r0 @ r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0)
mov r2, r2, ASR #2 @ r2 <- r2 >> 2
mov r1, r0, LSR #31 @ r1 <- r0 >> 31
add r0, r2, r1 @ r0 <- r2 + r1
add r2,r0,r0, lsl #2 @ r2 <- r0 * 5
sub r1,r4,r2, lsl #1 @ r1 <- r4 - (r2 * 2) = r4 - (r0 * 10)
pop {r2-r4}
bx lr @ return

24
Task/XML-DOM-serialization/Ada/xml-dom-serialization.ada Normal file
View file

@ -0,0 +1,24 @@
with Ada.Text_IO.Text_Streams;
with DOM.Core.Documents;
with DOM.Core.Nodes;
procedure Serialization is
My_Implementation : DOM.Core.DOM_Implementation;
My_Document : DOM.Core.Document;
My_Root_Node : DOM.Core.Element;
My_Element_Node : DOM.Core.Element;
My_Text_Node : DOM.Core.Text;
begin
My_Document := DOM.Core.Create_Document (My_Implementation);
My_Root_Node := DOM.Core.Documents.Create_Element (My_Document, "root");
My_Root_Node := DOM.Core.Nodes.Append_Child (My_Document, My_Root_Node);
My_Element_Node := DOM.Core.Documents.Create_Element (My_Document, "element");
My_Element_Node := DOM.Core.Nodes.Append_Child (My_Root_Node, My_Element_Node);
My_Text_Node := DOM.Core.Documents.Create_Text_Node (My_Document, "Some text here");
My_Text_Node := DOM.Core.Nodes.Append_Child (My_Element_Node, My_Text_Node);
DOM.Core.Nodes.Write
(Stream => Ada.Text_IO.Text_Streams.Stream
(Ada.Text_IO.Standard_Output),
N => My_Document,
Pretty_Print => True);
end Serialization;

36
Task/XML-DOM-serialization/AutoHotkey/xml-dom-serialization.ahk Normal file
View file

@ -0,0 +1,36 @@
version = "1.0"
xmlheader := "<?xml version=" . version . "?>" . "<" . root . ">"
element("root", "child")
element("root", "element", "more text here")
element("root_child", "kid", "yak yak")
MsgBox % xmlheader . serialize("root")
Return
element(parent, name, text="")
{
Global
%parent%_children .= name . "`n"
%parent%_%name% = %parent%_%name%
%parent%_%name%_name := name
%parent%_%name%_text := text
}
serialize(root){
StringSplit, root, root, _
xml .= "<" . root%root0% . ">"
StringTrimRight, %root%_children, %root%_children, 1
Loop, Parse, %root%_children, `n
{
If %root%_%A_LoopField%_children
xml .= serialize(%root%_%A_LoopField%)
Else
{
element := "<" . %root%_%A_LoopField%_name . ">"
element .= %root%_%A_LoopField%_text
element .= "</" . %root%_%A_LoopField%_name . ">"
xml .= element
}
}
Return xml .= "</" . root%root0% . ">"
}

8
Task/XML-DOM-serialization/Bracmat/xml-dom-serialization-1.bracmat Normal file
View file

@ -0,0 +1,8 @@
( ("?"."xml version=\"1.0\" ")
\n
(root.,"\n " (element.,"
Some text here
") \n)
: ?xml
& out$(toML$!xml)
);

4
Task/XML-DOM-serialization/Bracmat/xml-dom-serialization-2.bracmat Normal file
View file

@ -0,0 +1,4 @@
( ("?"."xml version=\"1.0\"") (root.,(element.,"Some text here"))
: ?xml
& out$(toML$!xml)
);

161
Task/XML-DOM-serialization/C++/xml-dom-serialization.cpp Normal file
View file

@ -0,0 +1,161 @@
#include <cassert>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlsave.h>
#include <libxml/xmlstring.h>
#include <libxml/xmlversion.h>
#ifndef LIBXML_TREE_ENABLED
# error libxml was not configured with DOM tree support
#endif
#ifndef LIBXML_OUTPUT_ENABLED
# error libxml was not configured with serialization support
#endif
// Because libxml2 is a C library, we need a couple things to make it work
// well with modern C++:
// 1) a ScopeGuard-like type to handle cleanup functions; and
// 2) an exception type that transforms the library's errors.
// ScopeGuard-like type to handle C library cleanup functions.
template <typename F>
class [[nodiscard]] scope_exit
{
public:
// C++20: Constructor can (and should) be [[nodiscard]].
/*[[nodiscard]]*/ constexpr explicit scope_exit(F&& f) :
f_{std::move(f)}
{}
~scope_exit()
{
f_();
}
// Non-copyable, non-movable.
scope_exit(scope_exit const&) = delete;
scope_exit(scope_exit&&) = delete;
auto operator=(scope_exit const&) -> scope_exit& = delete;
auto operator=(scope_exit&&) -> scope_exit& = delete;
private:
F f_;
};
// Exception that gets last libxml2 error.
class libxml_error : public std::runtime_error
{
public:
libxml_error() : libxml_error(std::string{}) {}
explicit libxml_error(std::string message) :
std::runtime_error{make_message_(std::move(message))}
{}
private:
static auto make_message_(std::string message) -> std::string
{
if (auto const last_error = ::xmlGetLastError(); last_error)
{
if (not message.empty())
message += ": ";
message += last_error->message;
}
return message;
}
};
auto add_text(::xmlNode* node, ::xmlChar const* content)
{
// Create a new text node with the desired content.
auto const text_node = ::xmlNewText(content);
if (not text_node)
throw libxml_error{"failed to create text node"};
// Try to add it to the node. If it succeeds, that node will take
// ownership of the text node. If it fails, we have to clean up the text
// node ourselves first, then we can throw.
if (auto const res = ::xmlAddChild(node, text_node); not res)
{
::xmlFreeNode(text_node);
throw libxml_error{"failed to add text node"};
}
return text_node;
}
auto main() -> int
{
// Set this to true if you don't want the XML declaration.
constexpr auto no_xml_declaration = false;
try
{
// Initialize libxml.
::xmlInitParser();
LIBXML_TEST_VERSION
auto const libxml_cleanup = scope_exit{[] { ::xmlCleanupParser(); }};
// Create a new document.
auto doc = ::xmlNewDoc(reinterpret_cast<::xmlChar const*>(u8"1.0"));
if (not doc)
throw libxml_error{"failed to create document"};
auto const doc_cleanup = scope_exit{[doc] { ::xmlFreeDoc(doc); }};
// Create the root element.
auto root = ::xmlNewNode(nullptr,
reinterpret_cast<::xmlChar const*>(u8"root"));
if (not root)
throw libxml_error{"failed to create root element"};
::xmlDocSetRootElement(doc, root); // doc now owns root
// Add whitespace. Unless you know the whitespace is not significant,
// you should do this manually, rather than relying on automatic
// indenting.
add_text(root, reinterpret_cast<::xmlChar const*>(u8"\n "));
// Add the child element.
if (auto const res = ::xmlNewTextChild(root, nullptr,
reinterpret_cast<::xmlChar const*>(u8"element"),
reinterpret_cast<::xmlChar const*>(
u8"\n Some text here\n "));
not res)
throw libxml_error{"failed to create child text element"};
// Add whitespace.
add_text(root, reinterpret_cast<::xmlChar const*>(u8"\n"));
// Output tree. Note that the output is UTF-8 in all cases. If you
// want something different, use xmlSaveFileEnc() or the second
// argument of xmlSaveDoc().
if constexpr (no_xml_declaration)
{
auto const save_context = ::xmlSaveToFilename("-", nullptr,
XML_SAVE_NO_DECL);
auto const save_context_cleanup = scope_exit{[save_context] {
::xmlSaveClose(save_context); }};
if (auto const res = ::xmlSaveDoc(save_context, doc); res == -1)
throw libxml_error{"failed to write tree to stdout"};
}
else
{
if (auto const res = ::xmlSaveFile("-", doc); res == -1)
throw libxml_error{"failed to write tree to stdout"};
}
}
catch (std::exception const& x)
{
std::cerr << "ERROR: " << x.what() << '\n';
return EXIT_FAILURE;
}
}

16
Task/XML-DOM-serialization/C-sharp/xml-dom-serialization.cs Normal file
View file

@ -0,0 +1,16 @@
using System.Xml;
using System.Xml.Serialization;
[XmlRoot("root")]
public class ExampleXML
{
[XmlElement("element")]
public string element = "Some text here";
static void Main(string[] args)
{
var xmlnamespace = new XmlSerializerNamespaces();
xmlnamespace.Add("", ""); //used to stop default namespaces from printing
var writer = XmlWriter.Create("output.xml");
new XmlSerializer(typeof(ExampleXML)).Serialize(writer, new ExampleXML(), xmlnamespace);
}
//Output: <?xml version="1.0" encoding="utf-8"?><root><element>Some text here</element></root>
}

18
Task/XML-DOM-serialization/C/xml-dom-serialization-1.c Normal file
View file

@ -0,0 +1,18 @@
#include <libxml/parser.h>
#include <libxml/tree.h>
int main()
{
xmlDoc *doc = xmlNewDoc("1.0");
xmlNode *root = xmlNewNode(NULL, BAD_CAST "root");
xmlDocSetRootElement(doc, root);
xmlNode *node = xmlNewNode(NULL, BAD_CAST "element");
xmlAddChild(node, xmlNewText(BAD_CAST "some text here"));
xmlAddChild(root, node);
xmlSaveFile("myfile.xml", doc);
xmlFreeDoc(doc);
xmlCleanupParser();
}

16
Task/XML-DOM-serialization/C/xml-dom-serialization-2.c Normal file
View file

@ -0,0 +1,16 @@
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String XML, body;
Stack{
Store ( XML, Parser( "element", "","Some text here", NORMAL_TAG) );
Store ( XML, Parser( "root", "",XML, NORMAL_TAG) );
} Stack_off;
body = Multi_copy( body,"<?xml version=\"1.0\" ?>", XML, NULL);
Print "%s\n", body;
Free secure XML, body;
End

15
Task/XML-DOM-serialization/C/xml-dom-serialization-3.c Normal file
View file

@ -0,0 +1,15 @@
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String XML, body;
Get_fn_let( XML, Parser( "element", "","Some text here", NORMAL_TAG) );
Get_fn_let( XML, Parser( "root", "",XML, NORMAL_TAG) );
body = Multi_copy( body,"<?xml version=\"1.0\" ?>", XML, NULL);
Print "%s\n", body;
Free secure XML, body;
End

17
Task/XML-DOM-serialization/C/xml-dom-serialization-4.c Normal file
View file

@ -0,0 +1,17 @@
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String XML, body;
Stack{
Store ( XML, Parser( "root", "",
Parser( "element", "","Some text here", NORMAL_TAG),
NORMAL_TAG) );
} Stack_off;
body = Multi_copy( body,"<?xml version=\"1.0\" ?>", XML, NULL);
Print "%s\n", body;
Free secure XML, body;
End

17
Task/XML-DOM-serialization/C/xml-dom-serialization-5.c Normal file
View file

@ -0,0 +1,17 @@
#include <gadget/gadget.h>
LIB_GADGET_START
Main
String body;
Stack{
Store ( body, Multi_copy( body,"<?xml version=\"1.0\" ?>",
Parser( "root", "", Parser( "element", "","Some text here",
NORMAL_TAG), NORMAL_TAG),
NULL) );
}
Print "%s\n", body;
Free secure body;
End

7
Task/XML-DOM-serialization/Clojure/xml-dom-serialization.clj Normal file
View file

@ -0,0 +1,7 @@
(require '[clojure.data.xml :as xml])
(def xml-example (xml/element :root {} (xml/element :element {} "Some text here")))
(with-open [out-file (java.io.OutputStreamWriter.
(java.io.FileOutputStream. "/tmp/output.xml") "UTF-8")]
(xml/emit xml-example out-file))

8
Task/XML-DOM-serialization/Common-Lisp/xml-dom-serialization-1.lisp Normal file
View file

@ -0,0 +1,8 @@
(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))
(root (dom:create-element doc "root"))
(element (dom:create-element doc "element"))
(text (dom:create-text-node doc "Some text here")))
(dom:append-child element text)
(dom:append-child root element)
(dom:append-child doc root)
(dom:map-document (cxml:make-rod-sink) doc))

7
Task/XML-DOM-serialization/Common-Lisp/xml-dom-serialization-2.lisp Normal file
View file

@ -0,0 +1,7 @@
(let ((doc (dom:create-document 'rune-dom:implementation nil nil nil)))
(dom:append-child
(dom:append-child
(dom:append-child doc (dom:create-element doc "root"))
(dom:create-element doc "element"))
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))

9
Task/XML-DOM-serialization/Common-Lisp/xml-dom-serialization-3.lisp Normal file
View file

@ -0,0 +1,9 @@
(defun append-child* (parent &rest children)
(reduce 'dom:append-child children :initial-value parent))
(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil)))
(append-child* doc
(dom:create-element doc "root")
(dom:create-element doc "element")
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))

12
Task/XML-DOM-serialization/D/xml-dom-serialization.d Normal file
View file

@ -0,0 +1,12 @@
module xmltest ;
import std.stdio ;
import std.xml ;
void main() {
auto doc = new Document("root") ;
//doc.prolog = q"/<?xml version="1.0"?>/" ; // default
doc ~= new Element("element", "Some text here") ;
writefln(doc) ;
// output: <?xml version="1.0"?><root><element>Some text here</element></root>
}

11
Task/XML-DOM-serialization/E/xml-dom-serialization.e Normal file
View file

@ -0,0 +1,11 @@
def document := <unsafe:javax.xml.parsers.makeDocumentBuilderFactory> \
.newInstance() \
.newDocumentBuilder() \
.getDOMImplementation() \
.createDocument(null, "root", null)
def root := document.getDocumentElement()
root.appendChild(
def element := document.createElement("element"))
element.appendChild(
document.createTextNode("Some text here"))
println(document.saveXML(root))

17
Task/XML-DOM-serialization/F-Sharp/xml-dom-serialization.fs Normal file
View file

@ -0,0 +1,17 @@
open System.Xml
[<EntryPoint>]
let main argv =
let xd = new XmlDocument()
// Create the required nodes:
xd.AppendChild (xd.CreateXmlDeclaration("1.0", null, null)) |> ignore
let root = xd.AppendChild (xd.CreateNode("element", "root", ""))
let element = root.AppendChild (xd.CreateElement("element", "element", ""))
element.AppendChild (xd.CreateTextNode("Some text here")) |> ignore
// The same can be accomplished with:
// xd.LoadXml("""<?xml version="1.0"?><root><element>Some text here</element></root>""")
let xw = new XmlTextWriter(System.Console.Out)
xw.Formatting <- Formatting.Indented
xd.WriteContentTo(xw)
0

4
Task/XML-DOM-serialization/Factor/xml-dom-serialization-1.factor Normal file
View file

@ -0,0 +1,4 @@
USING: xml.syntax xml.writer ;
<XML <root><element>Some text here</element></root> XML>
pprint-xml

6
Task/XML-DOM-serialization/Factor/xml-dom-serialization-2.factor Normal file
View file

@ -0,0 +1,6 @@
USING: sequences xml.syntax xml.writer ;
3 [XML <element>Some text here</element> XML] <repetition>
[XML <element2><element3>1.0</element3></element2> XML] append
<XML <root><-></root> XML>
pprint-xml

17
Task/XML-DOM-serialization/Fantom/xml-dom-serialization.fantom Normal file
View file

@ -0,0 +1,17 @@
using xml
class XmlDom
{
public static Void main ()
{
doc := XDoc()
root := XElem("root")
doc.add (root)
child := XElem("element")
child.add(XText("Some text here"))
root.add (child)
doc.write(Env.cur.out)
}
}

29
Task/XML-DOM-serialization/Forth/xml-dom-serialization.fth Normal file
View file

@ -0,0 +1,29 @@
include ffl/dom.fs
\ Create a dom variable 'doc' in the dictionary
dom-create doc
\ Add the document root with its version attribute
dom.document doc dom-append-node
s" version" s" 1.0" dom.attribute doc dom-append-node
\ Add root and element
doc dom-parent 2drop
s" root" dom.element doc dom-append-node
s" element" dom.element doc dom-append-node
\ Add the text
s" Some text here" dom.text doc dom-append-node
\ Convert the document to a string and print
doc dom-write-string [IF]
type cr
[THEN]

21
Task/XML-DOM-serialization/Go/xml-dom-serialization-1.go Normal file
View file

@ -0,0 +1,21 @@
package main
import (
"fmt"
dom "gitlab.com/stone.code/xmldom-go.git"
)
func main() {
d, err := dom.ParseStringXml(`
<?xml version="1.0" ?>
<root>
<element>
Some text here
</element>
</root>`)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(d.ToXml()))
}

5
Task/XML-DOM-serialization/Go/xml-dom-serialization-2.go Normal file
View file

@ -0,0 +1,5 @@
<root>
<element>
Some text here
</element>
</root>

7
Task/XML-DOM-serialization/Groovy/xml-dom-serialization.groovy Normal file
View file

@ -0,0 +1,7 @@
import groovy.xml.MarkupBuilder
def writer = new StringWriter() << '<?xml version="1.0" ?>\n'
def xml = new MarkupBuilder(writer)
xml.root() {
element('Some text here' )
}
println writer

14
Task/XML-DOM-serialization/Haskell/xml-dom-serialization.hs Normal file
View file

@ -0,0 +1,14 @@
import Data.List
import Text.XML.Light
xmlDOM :: String -> String
xmlDOM txt = showTopElement $ Element
(unqual "root")
[]
[ Elem $ Element
(unqual "element")
[]
[Text $ CData CDataText txt Nothing]
Nothing
]
Nothing

11
Task/XML-DOM-serialization/J/xml-dom-serialization-1.j Normal file
View file

@ -0,0 +1,11 @@
serialize=: ('<?xml version="1.0" ?>',LF),;@serialize1&''
serialize1=:4 :0
if.L.x do.
start=. y,'<',(0{::x),'>',LF
middle=. ;;(}.x) serialize1&.> <' ',y
end=. y,'</',(0{::x),'>',LF
<start,middle,end
else.
<y,x,LF
end.
)

1
Task/XML-DOM-serialization/J/xml-dom-serialization-2.j Normal file
View file

@ -0,0 +1 @@
obj=: 'root';<'element';'some text here'

7
Task/XML-DOM-serialization/J/xml-dom-serialization-3.j Normal file
View file

@ -0,0 +1,7 @@
serialize obj
<?xml version="1.0" ?>
<root>
<element>
some text here
</element>
</root>

105
Task/XML-DOM-serialization/Java/xml-dom-serialization-1.java Normal file
View file

@ -0,0 +1,105 @@
import java.io.StringWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class RDOMSerialization {
private Document domDoc;
public RDOMSerialization() {
return;
}
protected void buildDOMDocument() {
DocumentBuilderFactory factory;
DocumentBuilder builder;
DOMImplementation impl;
Element elmt1;
Element elmt2;
try {
factory = DocumentBuilderFactory.newInstance();
builder = factory.newDocumentBuilder();
impl = builder.getDOMImplementation();
domDoc = impl.createDocument(null, null, null);
elmt1 = domDoc.createElement("root");
elmt2 = domDoc.createElement("element");
elmt2.setTextContent("Some text here");
domDoc.appendChild(elmt1);
elmt1.appendChild(elmt2);
}
catch (ParserConfigurationException ex) {
ex.printStackTrace();
}
return;
}
protected void serializeXML() {
DOMSource domSrc;
Transformer txformer;
StringWriter sw;
StreamResult sr;
try {
domSrc = new DOMSource(domDoc);
txformer = TransformerFactory.newInstance().newTransformer();
txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
txformer.setOutputProperty(OutputKeys.METHOD, "xml");
txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
txformer.setOutputProperty(OutputKeys.INDENT, "yes");
txformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
sw = new StringWriter();
sr = new StreamResult(sw);
txformer.transform(domSrc, sr);
System.out.println(sw.toString());
}
catch (TransformerConfigurationException ex) {
ex.printStackTrace();
}
catch (TransformerFactoryConfigurationError ex) {
ex.printStackTrace();
}
catch (TransformerException ex) {
ex.printStackTrace();
}
return;
}
public static void serializationDriver(String[] args) {
RDOMSerialization lcl = new RDOMSerialization();
lcl.buildDOMDocument();
lcl.serializeXML();
return;
}
public static void main(String[] args) {
serializationDriver(args);
return;
}
}

4
Task/XML-DOM-serialization/Java/xml-dom-serialization-2.java Normal file
View file

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
<element>Some text here</element>
</root>

6
Task/XML-DOM-serialization/JavaScript/xml-dom-serialization-1.js Normal file
View file

@ -0,0 +1,6 @@
var doc = document.implementation.createDocument( null, 'root', null );
var root = doc.documentElement;
var element = doc.createElement( 'element' );
root.appendChild( element );
element.appendChild( document.createTextNode('Some text here') );
var xmlString = new XMLSerializer().serializeToString( doc );

4
Task/XML-DOM-serialization/JavaScript/xml-dom-serialization-2.js Normal file
View file

@ -0,0 +1,4 @@
var xml = <root>
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();

6
Task/XML-DOM-serialization/JavaScript/xml-dom-serialization-3.js Normal file
View file

@ -0,0 +1,6 @@
XML.ignoreProcessingInstructions = false;
var xml = <?xml version="1.0"?>
<root>
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();

17
Task/XML-DOM-serialization/Julia/xml-dom-serialization.julia Normal file
View file

@ -0,0 +1,17 @@
using LightXML
# Modified from the documentation for LightXML.jl. The underlying library requires an encoding string be printed.
# create an empty XML document
xdoc = XMLDocument()
# create & attach a root node
xroot = create_root(xdoc, "root")
# create the first child
xs1 = new_child(xroot, "element")
# add the inner content
add_text(xs1, "some text here")
println(xdoc)

31
Task/XML-DOM-serialization/Kotlin/xml-dom-serialization.kotlin Normal file
View file

@ -0,0 +1,31 @@
// version 1.1.3
import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.transform.dom.DOMSource
import java.io.StringWriter
import javax.xml.transform.stream.StreamResult
import javax.xml.transform.TransformerFactory
fun main(args: Array<String>) {
val dbFactory = DocumentBuilderFactory.newInstance()
val dBuilder = dbFactory.newDocumentBuilder()
val doc = dBuilder.newDocument()
val root = doc.createElement("root") // create root node
doc.appendChild(root)
val element = doc.createElement("element") // create element node
val text = doc.createTextNode("Some text here") // create text node
element.appendChild(text)
root.appendChild(element)
// serialize
val source = DOMSource(doc)
val sw = StringWriter()
val result = StreamResult(sw)
val tFactory = TransformerFactory.newInstance()
tFactory.newTransformer().apply {
setOutputProperty("indent", "yes")
setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4")
transform(source, result)
}
println(sw)
}

3
Task/XML-DOM-serialization/Lasso/xml-dom-serialization.lasso Normal file
View file

@ -0,0 +1,3 @@
content_type( 'text/xml' );// set MIME type if serving
xml( '<?xml version="1.0" ?><root><element>Some text here</element></root>' );

14
Task/XML-DOM-serialization/Lingo/xml-dom-serialization.lingo Normal file
View file

@ -0,0 +1,14 @@
-- create an XML document
doc = newObject("XML", "<?xml version='1.0' ?>")
root = doc.createElement("root")
doc.appendChild(root)
element = doc.createElement("element")
root.appendChild(element)
textNode = doc.createTextNode("Some text here")
element.appendChild(textNode)
put doc.toString()
-- "<?xml version='1.0' ?><root><element>Some text here</element></root>"

6
Task/XML-DOM-serialization/Lua/xml-dom-serialization.lua Normal file
View file

@ -0,0 +1,6 @@
require("LuaXML")
local dom = xml.new("root")
local element = xml.new("element")
table.insert(element, "Some text here")
dom:append(element)
dom:save("dom.xml")

5
Task/XML-DOM-serialization/MATLAB/xml-dom-serialization.m Normal file
View file

@ -0,0 +1,5 @@
docNode = com.mathworks.xml.XMLUtils.createDocument('root');
docRootNode = docNode.getDocumentElement;
thisElement = docNode.createElement('element');
thisElement.appendChild(docNode.createTextNode('Some text here'));
docRootNode.appendChild(thisElement);

3
Task/XML-DOM-serialization/Mathematica/xml-dom-serialization.math Normal file
View file

@ -0,0 +1,3 @@
DOM = XMLObject["Document"][{XMLObject["Declaration"]["Version" -> "1.0","Encoding" -> "utf-8"]},
XMLElement["root", {}, {XMLElement["element", {}, {"Some text here"}]}], {}];
ExportString[DOM, "XML", "AttributeQuoting" -> "\""]

68
Task/XML-DOM-serialization/NetRexx/xml-dom-serialization-1.netrexx Normal file
View file

@ -0,0 +1,68 @@
/* NetRexx */
options replace format comments java crossref symbols nobinary
import java.io.StringWriter
import javax.xml.
import org.w3c.dom.
class RDOMSerialization public
properties private
domDoc = Document
method main(args = String[]) public static
lcl = RDOMSerialization()
lcl.buildDOMDocument()
lcl.serializeXML()
return
method buildDOMDocument() inheritable
do
factory = DocumentBuilderFactory.newInstance()
builder = factory.newDocumentBuilder()
impl = builder.getDOMImplementation()
domDoc = impl.createDocument(null, null, null)
elmt1 = domDoc.createElement("root")
elmt2 = domDoc.createElement("element")
elmt2.setTextContent("Some text here")
domDoc.appendChild(elmt1)
elmt1.appendChild(elmt2)
catch exPC = ParserConfigurationException
exPC.printStackTrace
end
return
method serializeXML() inheritable
do
domSrc = DOMSource(domDoc)
txformer = TransformerFactory.newInstance().newTransformer()
txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
txformer.setOutputProperty(OutputKeys.METHOD, "xml")
txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
txformer.setOutputProperty(OutputKeys.INDENT, "yes")
txformer.setOutputProperty(OutputKeys.STANDALONE, "yes")
txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2")
sw = StringWriter()
sr = StreamResult(sw)
txformer.transform(domSrc, sr)
say sw.toString
catch exTC = TransformerConfigurationException
exTC.printStackTrace
catch exTF = TransformerFactoryConfigurationError
exTF.printStackTrace
catch exTE = TransformerException
exTE.printStackTrace
end
return

4
Task/XML-DOM-serialization/NetRexx/xml-dom-serialization-2.netrexx Normal file
View file

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<root>
<element>Some text here</element>
</root>

13
Task/XML-DOM-serialization/Nim/xml-dom-serialization.nim Normal file
View file

@ -0,0 +1,13 @@
import xmldom
var
dom = getDOM()
document = dom.createDocument("", "root")
topElement = document.documentElement
firstElement = document.createElement "element"
textNode = document.createTextNode "Some text here"
topElement.appendChild firstElement
firstElement.appendChild textNode
echo document

13
Task/XML-DOM-serialization/Objeck/xml-dom-serialization.objeck Normal file
View file

@ -0,0 +1,13 @@
use XML;
bundle Default {
class Test {
function : Main(args : String[]) ~ Nil {
builder := XMLBuilder->New("root", "1.0");
root := builder->GetRoot();
element := XMLElement->New(XMLElementType->ELEMENT, "element", "Some text here");
root->AddChild(element);
builder->ToString()->PrintLine();
}
}
}

23
Task/XML-DOM-serialization/OpenEdge-Progress/xml-dom-serialization.openedge Normal file
View file

@ -0,0 +1,23 @@
DEFINE VARIABLE hxdoc AS HANDLE NO-UNDO.
DEFINE VARIABLE hxroot AS HANDLE NO-UNDO.
DEFINE VARIABLE hxelement AS HANDLE NO-UNDO.
DEFINE VARIABLE hxtext AS HANDLE NO-UNDO.
DEFINE VARIABLE lcc AS LONGCHAR NO-UNDO.
CREATE X-DOCUMENT hxdoc.
CREATE X-NODEREF hxroot.
hxdoc:CREATE-NODE( hxroot, 'root', 'ELEMENT' ).
hxdoc:APPEND-CHILD( hxroot ).
CREATE X-NODEREF hxelement.
hxdoc:CREATE-NODE( hxelement, 'element', 'ELEMENT' ).
hxroot:APPEND-CHILD( hxelement ).
CREATE X-NODEREF hxtext.
hxdoc:CREATE-NODE( hxtext, 'element', 'TEXT' ).
hxelement:APPEND-CHILD( hxtext ).
hxtext:NODE-VALUE = 'Some text here'.
hxdoc:SAVE( 'LONGCHAR', lcc ).
MESSAGE STRING( lcc ) VIEW-AS ALERT-BOX.

7
Task/XML-DOM-serialization/Oz/xml-dom-serialization-1.oz Normal file
View file

@ -0,0 +1,7 @@
declare
proc {Main}
DOM = root(element("Some text here"))
in
{System.showInfo {Serialize DOM}}
end
...

4
Task/XML-DOM-serialization/Oz/xml-dom-serialization-2.oz Normal file
View file

@ -0,0 +1,4 @@
<?xml version="1.0" ?>
<root>
<element>Some text here</element>
</root>

9
Task/XML-DOM-serialization/PHP/xml-dom-serialization.php Normal file
View file

@ -0,0 +1,9 @@
<?php
$dom = new DOMDocument();//the constructor also takes the version and char-encoding as it's two respective parameters
$dom->formatOutput = true;//format the outputted xml
$root = $dom->createElement('root');
$element = $dom->createElement('element');
$element->appendChild($dom->createTextNode('Some text here'));
$root->appendChild($element);
$dom->appendChild($root);
$xmlstring = $dom->saveXML();

26
Task/XML-DOM-serialization/Pascal/xml-dom-serialization.pas Normal file
View file

@ -0,0 +1,26 @@
program CrearXML;
{$mode objfpc}{$H+}
uses
Classes, XMLWrite, DOM;
var
xdoc: TXMLDocument; // variable objeto documento XML
NodoRaiz, NodoPadre, NodoHijo: TDOMNode; // variables a los nodos
begin
//crear el documento
xdoc := TXMLDocument.create;
NodoRaiz := xdoc.CreateElement('root'); // crear el nodo raíz
Xdoc.Appendchild(NodoRaiz); // guardar nodo raíz
NodoPadre := xdoc.CreateElement('element'); // crear el nodo hijo
NodoHijo := xdoc.CreateTextNode('Some text here'); // insertar el valor del nodo
NodoPadre.Appendchild(NodoHijo); // guardar nodo
NodoRaiz.AppendChild(NodoPadre); // insertar el nodo hijo en el correspondiente nodo padre
writeXMLFile(xDoc,'prueba.xml'); // escribir el XML
NodoRaiz.free;
NodoPadre.free;
NodoHijo.free;
Xdoc.free;
end.

2
Task/XML-DOM-serialization/Perl/xml-dom-serialization-1.pl Normal file
View file

@ -0,0 +1,2 @@
use XML::Simple;
print XMLout( { root => { element => "Some text here" } }, NoAttr => 1, RootName => "" );

7
Task/XML-DOM-serialization/Perl/xml-dom-serialization-2.pl Normal file
View file

@ -0,0 +1,7 @@
use XML::DOM::BagOfTricks qw(createDocument createTextElement);
my ($doc, $root) = createDocument('root');
$root->appendChild(
createTextElement($doc, 'element', 'Some text here')
);
print $doc->toString;

12
Task/XML-DOM-serialization/Perl/xml-dom-serialization-3.pl Normal file
View file

@ -0,0 +1,12 @@
use XML::LibXML;
$xml = XML::LibXML::Document->new('1.0');
$node = $xml->createElement('root');
$xml->setDocumentElement($node);
$node2 = $xml->createElement('element');
$text = $xml->createTextNode('Some text here');
$node2->addChild($text);
$node->appendWellBalancedChunk('text');
$node->addChild($node2);
print $xml->toString;

8
Task/XML-DOM-serialization/Phix/xml-dom-serialization.phix Normal file
View file

@ -0,0 +1,8 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">xml</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">elem</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_element</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"element"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Some text here"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">root</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_element</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"root"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">elem</span><span style="color: #0000FF;">}),</span>
<span style="color: #000000;">doc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_doc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">root</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">`&lt;?xml version="1.0" ?&gt;`</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">xml_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">doc</span><span style="color: #0000FF;">))</span>
<!--

4
Task/XML-DOM-serialization/PicoLisp/xml-dom-serialization.l Normal file
View file

@ -0,0 +1,4 @@
(load "@lib/xm.l")
(xml? T)
(xml '(root NIL (element NIL "Some text here")))

14
Task/XML-DOM-serialization/Pike/xml-dom-serialization-1.pike Normal file
View file

@ -0,0 +1,14 @@
object dom = Parser.XML.Tree.SimpleRootNode();
dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), ""));
object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "root", ([]), "");
dom->add_child(node);
object subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "element", ([]), "");
node->add_child(subnode);
node = subnode;
subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "Some text here");
node->add_child(subnode);
dom->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"

27
Task/XML-DOM-serialization/Pike/xml-dom-serialization-2.pike Normal file
View file

@ -0,0 +1,27 @@
object make_xml_node(array|string in, void|int level)
{
level++;
if (stringp(in))
return Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), in);
else
{
object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, in[0], in[1], "");
foreach(in[2..];; array|string child)
{
node->add_child(make_xml_node(child, level));
}
return node;
}
}
object make_xml_tree(array input)
{
object dom = Parser.XML.Tree.SimpleRootNode();
dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), ""));
dom->add_child(make_xml_node(input));
return dom;
}
array input = ({ "root", ([]), ({ "element", ([]), "Some text here" }) });
make_xml_tree(input)->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"

32
Task/XML-DOM-serialization/Pike/xml-dom-serialization-3.pike Normal file
View file

@ -0,0 +1,32 @@
object indent_xml(object parent, void|int indent_text, void|int level)
{
int subnodes = false;
foreach(parent->get_children();; object child)
{
if (child->get_node_type() == Parser.XML.Tree.XML_ELEMENT ||
(child->get_node_type() == Parser.XML.Tree.XML_TEXT && indent_text))
{
subnodes = true;
parent->add_child_before(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+" "*level), child);
indent_xml(child, indent_text, level+1);
}
}
if (subnodes && level)
parent->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+" "*(level-1)));
return parent;
}
indent_xml(make_xml_tree(input))->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?>\r\n"
"<root>\r\n"
" <element>Some text here</element>\r\n"
"</root>"
indent_xml(make_xml_tree(input), 1)->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?>\r\n"
"<root>\r\n"
" <element>\r\n"
" Some text here\r\n"
" </element>\r\n"
"</root>"

12
Task/XML-DOM-serialization/Python/xml-dom-serialization-1.py Normal file
View file

@ -0,0 +1,12 @@
from xml.dom.minidom import getDOMImplementation
dom = getDOMImplementation()
document = dom.createDocument(None, "root", None)
topElement = document.documentElement
firstElement = document.createElement("element")
topElement.appendChild(firstElement)
textNode = document.createTextNode("Some text here")
firstElement.appendChild(textNode)
xmlString = document.toprettyxml(" " * 4)

5
Task/XML-DOM-serialization/Python/xml-dom-serialization-2.py Normal file
View file

@ -0,0 +1,5 @@
from xml.etree import ElementTree as et
root = et.Element("root")
et.SubElement(root, "element").text = "Some text here"
xmlString = et.tostring(root)

16
Task/XML-DOM-serialization/Racket/xml-dom-serialization.rkt Normal file
View file

@ -0,0 +1,16 @@
#lang at-exp racket
(require xml)
(define xml-str
@~a{<?xml version="1.0" ?>
<root>
<element>
Some text here
</element>
</root>})
;; read & parse to get an xml value
(define xml (read-xml/document (open-input-string xml-str)))
;; print it out in xml form, which is identical to the input xml
(write-xml xml)
(newline)

6
Task/XML-DOM-serialization/Raku/xml-dom-serialization-1.raku Normal file
View file

@ -0,0 +1,6 @@
use XML;
use XML::Writer;
say my $document = XML::Document.new(
XML::Writer.serialize( :root[ :element['Some text here', ], ] )
);

1
Task/XML-DOM-serialization/Raku/xml-dom-serialization-2.raku Normal file
View file

@ -0,0 +1 @@
<?xml version="1.0"?><root><element>Some text here</element></root>

6
Task/XML-DOM-serialization/Rascal/xml-dom-serialization-1.rascal Normal file
View file

@ -0,0 +1,6 @@
import lang::xml::DOM;
public void main(){
x = document(element(none(), "root", [element(none(), "element", [charData("Some text here")])]));
return println(xmlPretty(x));
}

5
Task/XML-DOM-serialization/Rascal/xml-dom-serialization-2.rascal Normal file
View file

@ -0,0 +1,5 @@
rascal>main()
<?xml version="1.0" encoding="UTF-8"?>
<root>
<element>Some text here</element>
</root>

12
Task/XML-DOM-serialization/Ruby/xml-dom-serialization.rb Normal file
View file

@ -0,0 +1,12 @@
require("rexml/document")
include REXML
(doc = Document.new) << XMLDecl.new
root = doc.add_element('root')
element = root.add_element('element')
element.add_text('Some text here')
# save to a string
# (the first argument to write() needs an object that understands "<<")
serialized = String.new
doc.write(serialized, 4)
puts serialized

2
Task/XML-DOM-serialization/Scala/xml-dom-serialization.scala Normal file
View file

@ -0,0 +1,2 @@
val xml = <root><element>Some text here</element></root>
scala.xml.XML.save(filename="output.xml", node=xml, enc="UTF-8", xmlDecl=true, doctype=null)

5
Task/XML-DOM-serialization/Sidef/xml-dom-serialization.sidef Normal file
View file

@ -0,0 +1,5 @@
require('XML::Simple');
print %S'XML::Simple'.XMLout(
:(root => :( element => 'Some text here' )),
NoAttr => 1, RootName => '',
);

6
Task/XML-DOM-serialization/Tcl/xml-dom-serialization-1.tcl Normal file
View file

@ -0,0 +1,6 @@
package require tdom
set d [dom createDocument root]
set root [$d documentElement]
$root appendChild [$d createElement element]
[$root firstChild] appendChild [$d createTextNode "Some text here"]
$d asXML

6
Task/XML-DOM-serialization/Tcl/xml-dom-serialization-2.tcl Normal file
View file

@ -0,0 +1,6 @@
package require dom
set doc [dom::DOMImplementation create]
set root [dom::document createElement $doc root]
set elem [dom::document createElement $root element]
set text [dom::document createTextNode $elem "Some text here"]
dom::DOMImplementation serialize $doc -newline {element}

37
Task/XML-DOM-serialization/Wren/xml-dom-serialization-1.wren Normal file
View file

@ -0,0 +1,37 @@
class XmlDocument {
construct new(root) {
_root = root
}
toString { "<?xml version=\"1.0\" ?>\n%(_root.toString(0))" }
}
class XmlElement {
construct new(name, text) {
_name = name
_text = text
_children = []
}
name { _name }
text { _text }
children { _children }
addChild(child) { _children.add(child) }
toString(level) {
var indent = " "
var s = indent * level + "<%(name)>\n"
if (_text != "") s = s + indent * (level + 1) + _text + "\n"
for (c in _children) {
s = s + c.toString(level+1) + "\n"
}
return s + indent * level + "</%(name)>"
}
}
var root = XmlElement.new("root", "")
var child = XmlElement.new("element", "Some text here")
root.addChild(child)
var doc = XmlDocument.new(root)
System.print(doc)

8
Task/XML-DOM-serialization/Wren/xml-dom-serialization-2.wren Normal file
View file

@ -0,0 +1,8 @@
import "./xsequence" for XDocument, XElement
var doc = XDocument.new(
XElement.new("root",
XElement.new("element", "Some text here")
)
)
System.print(doc)

13
Task/XML-DOM-serialization/XProc/xml-dom-serialization.xproc Normal file
View file

@ -0,0 +1,13 @@
<p:pipeline xmlns:p="http://www.w3.org/ns/xproc" version="1.0">
<p:identity>
<p:input port="source">
<p:inline>
<root>
<element>
Some text here
</element>
</root>
</p:inline>
</p:input>
</p:identity>
</p:pipeline>

5
Task/XML-DOM-serialization/XQuery/xml-dom-serialization-1.xquery Normal file
View file

@ -0,0 +1,5 @@
<root>
<element>
Some text here
</element>
</root>

10
Task/XML-DOM-serialization/XQuery/xml-dom-serialization-2.xquery Normal file
View file

@ -0,0 +1,10 @@
let $rootTagname := 'root'
let $elementTagname := 'element'
let $elementContent := 'Some text here'
return
element {$rootTagname}
{
element{$elementTagname}
{$elementContent}
}

10
Task/XML-DOM-serialization/XSLT/xml-dom-serialization.xslt Normal file
View file

@ -0,0 +1,10 @@
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes" />
<xsl:template match="/"> <!-- replace the root of the incoming document with our own model -->
<xsl:element name="root">
<xsl:element name="element">
<xsl:text>Some text here</xsl:text>
</xsl:element>
</xsl:element>
</xsl:template>
</xsl:stylesheet>

96
Task/XML-DOM-serialization/Z80-Assembly/xml-dom-serialization.z80 Normal file
View file

@ -0,0 +1,96 @@
org &1000
main:
ld hl,XML_Header
ld de,XMLRam
call strcpy
ld hl,XML_Root
push hl
call AddXMLNode
ld hl,XML_Element
push hl
call AddXMLNode
ld hl,XML_Entry
call strcpy
pop hl ;ld hl,XML_Element
call CloseXMLNode
pop hl ;ld hl,XML_Root
call CloseXMLNode
ld hl,XMLRam
jp PrintString ;and then return to basic.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
AddXMLNode:
;hl = pointer to desired node name
;de = destination ram
;carry flag; set = <foo/>, clear = <foo></foo>
push af
ld a,'<'
ld (de),a
inc de
call strcpy
pop af
jr nc,skip_AddXMLNode
ld a,'/'
ld (de),a
inc de
skip_AddXMLNode:
ld a,'>'
ld (de),a
inc de
xor a
ld (de),a
;don't inc de afterwards, since we may want to add more
ret
CloseXMLNode:
ld a,'<'
ld (de),a
inc de
ld a,'/'
ld (de),a
inc de
call strcpy
ld a,'>'
ld (de),a
inc de
xor a
ld (de),a
ret
PrintString:
ld a,(hl)
or a
ret z
call &BB5A
inc hl
jr PrintString
strcpy:
;HL = string source
;DE = destination
;copies 1 byte at a time until a null terminator is copied, then exits.
ld a,(hl)
ld (de),a
or a
ret z
inc hl
inc de
jp strcpy
org &1200
XML_Header:
byte "<?xml version=",&22,"1.0",&22,"?>",0
XML_Root:
byte "root",0
XML_Element:
byte "element",0
XML_Entry:
byte "some text here",0
org &1300
XMLRam: ;this is where the output is stored.