mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2024-12-24 21:33:51 +03:00
1069 lines
34 KiB
C
1069 lines
34 KiB
C
/**
|
|
* section: xmlWriter
|
|
* synopsis: use various APIs for the xmlWriter
|
|
* purpose: tests a number of APIs for the xmlWriter, especially
|
|
* the various methods to write to a filename, to a memory
|
|
* buffer, to a new document, or to a subtree. It shows how to
|
|
* do encoding string conversions too. The resulting
|
|
* documents are then serialized.
|
|
* usage: testWriter
|
|
* test: testWriter && for i in 1 2 3 4 ; do diff $(srcdir)/writer.xml writer$$i.tmp || break ; done
|
|
* author: Alfred Mickautsch
|
|
* copy: see Copyright for the status of this software.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <libxml/encoding.h>
|
|
#include <libxml/xmlwriter.h>
|
|
#include <libxml/parser.h>
|
|
|
|
#ifndef _WIN32
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
|
|
#define MY_ENCODING "ISO-8859-1"
|
|
|
|
void testXmlwriterFilename(const char *uri);
|
|
void testXmlwriterMemory(void);
|
|
void testXmlwriterDoc(void);
|
|
void testXmlwriterTree(void);
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
/*
|
|
* this initialize the library and check potential ABI mismatches
|
|
* between the version it was compiled for and the actual shared
|
|
* library used.
|
|
*/
|
|
LIBXML_TEST_VERSION
|
|
|
|
/* first, the file version */
|
|
testXmlwriterFilename("writer1.tmp");
|
|
unlink("writer1.tmp");
|
|
|
|
/* next, the memory version */
|
|
testXmlwriterMemory();
|
|
|
|
/* next, the DOM version */
|
|
testXmlwriterDoc();
|
|
|
|
/* next, the tree version */
|
|
testXmlwriterTree();
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* testXmlwriterFilename:
|
|
* @uri: the output URI
|
|
*
|
|
* test the xmlWriter interface when writing to a new file
|
|
*/
|
|
void
|
|
testXmlwriterFilename(const char *uri)
|
|
{
|
|
int rc;
|
|
xmlTextWriterPtr writer;
|
|
|
|
/* Create a new XmlWriter for uri, with no compression. */
|
|
writer = xmlNewTextWriterFilename(uri, 0);
|
|
if (writer == NULL) {
|
|
printf("testXmlwriterFilename: Error creating the xml writer\n");
|
|
return;
|
|
}
|
|
|
|
/* Start the document with the xml default for the version,
|
|
* encoding ISO 8859-1 and the default for the standalone
|
|
* declaration. */
|
|
rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartDocument\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "EXAMPLE". Since this is the first
|
|
* element, this will be the root element of the document. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is a comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ORDER" as child of EXAMPLE. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "version" and value "1.0" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
|
|
BAD_CAST "1.0");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "xml:lang" and value "de" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
|
|
BAD_CAST "de");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of ORDER */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is another comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteFormatComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "HEADER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "X_ORDER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
|
|
"%010d", 53535);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "CUSTOMER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
|
|
"%d", 1010);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_1" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1",
|
|
BAD_CAST "Mueller");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_2" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2",
|
|
BAD_CAST "Joerg");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named HEADER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRIES" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test>");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
10);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test 2>");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
20);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRIES. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "FOOTER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "TEXT" as child of FOOTER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
|
|
BAD_CAST "This is a text.");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named FOOTER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Here we could close the elements ORDER and EXAMPLE using the
|
|
* function xmlTextWriterEndElement, but since we do not want to
|
|
* write any other elements, we simply call xmlTextWriterEndDocument,
|
|
* which will do all the work. */
|
|
rc = xmlTextWriterEndDocument(writer);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterFilename: Error at xmlTextWriterEndDocument\n");
|
|
return;
|
|
}
|
|
|
|
xmlFreeTextWriter(writer);
|
|
}
|
|
|
|
/**
|
|
* testXmlwriterMemory:
|
|
* @file: the output file
|
|
*
|
|
* test the xmlWriter interface when writing to memory
|
|
*/
|
|
void
|
|
testXmlwriterMemory(void)
|
|
{
|
|
int rc;
|
|
xmlTextWriterPtr writer;
|
|
xmlBufferPtr buf;
|
|
|
|
/* Create a new XML buffer, to which the XML document will be
|
|
* written */
|
|
buf = xmlBufferCreate();
|
|
if (buf == NULL) {
|
|
printf("testXmlwriterMemory: Error creating the xml buffer\n");
|
|
return;
|
|
}
|
|
|
|
/* Create a new XmlWriter for memory, with no compression.
|
|
* Remark: there is no compression for this kind of xmlTextWriter */
|
|
writer = xmlNewTextWriterMemory(buf, 0);
|
|
if (writer == NULL) {
|
|
printf("testXmlwriterMemory: Error creating the xml writer\n");
|
|
return;
|
|
}
|
|
|
|
/* Start the document with the xml default for the version,
|
|
* encoding ISO 8859-1 and the default for the standalone
|
|
* declaration. */
|
|
rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartDocument\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "EXAMPLE". Since this is the first
|
|
* element, this will be the root element of the document. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of EXAMPLE. */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is a comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ORDER" as child of EXAMPLE. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "version" and value "1.0" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
|
|
BAD_CAST "1.0");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "xml:lang" and value "de" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
|
|
BAD_CAST "de");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of ORDER */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is another comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteFormatComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "HEADER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "X_ORDER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
|
|
"%010d", 53535);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "CUSTOMER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
|
|
"%d", 1010);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_1" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1",
|
|
BAD_CAST "Mueller");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_2" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2",
|
|
BAD_CAST "Joerg");
|
|
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named HEADER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRIES" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test>");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
10);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test 2>");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
20);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRIES. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "FOOTER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "TEXT" as child of FOOTER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
|
|
BAD_CAST "This is a text.");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named FOOTER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Here we could close the elements ORDER and EXAMPLE using the
|
|
* function xmlTextWriterEndElement, but since we do not want to
|
|
* write any other elements, we simply call xmlTextWriterEndDocument,
|
|
* which will do all the work. */
|
|
rc = xmlTextWriterEndDocument(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterMemory: Error at xmlTextWriterEndDocument\n");
|
|
return;
|
|
}
|
|
|
|
xmlFreeTextWriter(writer);
|
|
|
|
xmlBufferFree(buf);
|
|
}
|
|
|
|
/**
|
|
* testXmlwriterDoc:
|
|
* @file: the output file
|
|
*
|
|
* test the xmlWriter interface when creating a new document
|
|
*/
|
|
void
|
|
testXmlwriterDoc(void)
|
|
{
|
|
int rc;
|
|
xmlTextWriterPtr writer;
|
|
xmlDocPtr doc;
|
|
|
|
|
|
/* Create a new XmlWriter for DOM, with no compression. */
|
|
writer = xmlNewTextWriterDoc(&doc, 0);
|
|
if (writer == NULL) {
|
|
printf("testXmlwriterDoc: Error creating the xml writer\n");
|
|
return;
|
|
}
|
|
|
|
/* Start the document with the xml default for the version,
|
|
* encoding ISO 8859-1 and the default for the standalone
|
|
* declaration. */
|
|
rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartDocument\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "EXAMPLE". Since this is the first
|
|
* element, this will be the root element of the document. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of EXAMPLE. */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is a comment");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ORDER" as child of EXAMPLE. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "version" and value "1.0" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
|
|
BAD_CAST "1.0");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "xml:lang" and value "de" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
|
|
BAD_CAST "de");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of ORDER */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is another comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterDoc: Error at xmlTextWriterWriteFormatComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "HEADER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "X_ORDER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
|
|
"%010d", 53535);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "CUSTOMER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
|
|
"%d", 1010);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_1" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1",
|
|
BAD_CAST "Mueller");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_2" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2",
|
|
BAD_CAST "Joerg");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named HEADER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRIES" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test>");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
10);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test 2>");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
20);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRIES. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "FOOTER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "TEXT" as child of FOOTER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
|
|
BAD_CAST "This is a text.");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named FOOTER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Here we could close the elements ORDER and EXAMPLE using the
|
|
* function xmlTextWriterEndElement, but since we do not want to
|
|
* write any other elements, we simply call xmlTextWriterEndDocument,
|
|
* which will do all the work. */
|
|
rc = xmlTextWriterEndDocument(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterDoc: Error at xmlTextWriterEndDocument\n");
|
|
return;
|
|
}
|
|
|
|
xmlFreeTextWriter(writer);
|
|
|
|
xmlFreeDoc(doc);
|
|
}
|
|
|
|
/**
|
|
* testXmlwriterTree:
|
|
* @file: the output file
|
|
*
|
|
* test the xmlWriter interface when writing to a subtree
|
|
*/
|
|
void
|
|
testXmlwriterTree(void)
|
|
{
|
|
int rc;
|
|
xmlTextWriterPtr writer;
|
|
xmlDocPtr doc;
|
|
xmlNodePtr node;
|
|
|
|
/* Create a new XML DOM tree, to which the XML document will be
|
|
* written */
|
|
doc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
|
|
if (doc == NULL) {
|
|
printf
|
|
("testXmlwriterTree: Error creating the xml document tree\n");
|
|
return;
|
|
}
|
|
|
|
/* Create a new XML node, to which the XML document will be
|
|
* appended */
|
|
node = xmlNewDocNode(doc, NULL, BAD_CAST "EXAMPLE", NULL);
|
|
if (node == NULL) {
|
|
printf("testXmlwriterTree: Error creating the xml node\n");
|
|
return;
|
|
}
|
|
|
|
/* Make ELEMENT the root node of the tree */
|
|
xmlDocSetRootElement(doc, node);
|
|
|
|
/* Create a new XmlWriter for DOM tree, with no compression. */
|
|
writer = xmlNewTextWriterTree(doc, node, 0);
|
|
if (writer == NULL) {
|
|
printf("testXmlwriterTree: Error creating the xml writer\n");
|
|
return;
|
|
}
|
|
|
|
/* Start the document with the xml default for the version,
|
|
* encoding ISO 8859-1 and the default for the standalone
|
|
* declaration. */
|
|
rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartDocument\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of EXAMPLE. */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is a comment");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ORDER" as child of EXAMPLE. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "version" and value "1.0" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
|
|
BAD_CAST "1.0");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Add an attribute with name "xml:lang" and value "de" to ORDER. */
|
|
rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
|
|
BAD_CAST "de");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
|
|
return;
|
|
}
|
|
|
|
/* Write a comment as child of ORDER */
|
|
rc = xmlTextWriterWriteComment(writer, BAD_CAST "This is another comment");
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteFormatComment\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "HEADER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "X_ORDER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
|
|
"%010d", 53535);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "CUSTOMER_ID" as child of HEADER. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
|
|
"%d", 1010);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_1" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1",
|
|
BAD_CAST "Mueller");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "NAME_2" as child of HEADER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2",
|
|
BAD_CAST "Joerg");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named HEADER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRIES" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test>");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
10);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "ENTRY" as child of ENTRIES. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ARTICLE" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
|
|
BAD_CAST "<Test 2>");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "ENTRY_NO" as child of ENTRY. */
|
|
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
|
|
20);
|
|
if (rc < 0) {
|
|
printf
|
|
("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRY. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named ENTRIES. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Start an element named "FOOTER" as child of ORDER. */
|
|
rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Write an element named "TEXT" as child of FOOTER. */
|
|
rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
|
|
BAD_CAST "This is a text.");
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Close the element named FOOTER. */
|
|
rc = xmlTextWriterEndElement(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
|
|
return;
|
|
}
|
|
|
|
/* Here we could close the elements ORDER and EXAMPLE using the
|
|
* function xmlTextWriterEndElement, but since we do not want to
|
|
* write any other elements, we simply call xmlTextWriterEndDocument,
|
|
* which will do all the work. */
|
|
rc = xmlTextWriterEndDocument(writer);
|
|
if (rc < 0) {
|
|
printf("testXmlwriterTree: Error at xmlTextWriterEndDocument\n");
|
|
return;
|
|
}
|
|
|
|
xmlFreeTextWriter(writer);
|
|
|
|
xmlFreeDoc(doc);
|
|
}
|
|
|
|
#else
|
|
int main(void) {
|
|
fprintf(stderr, "Writer or output support not compiled in\n");
|
|
return 0;
|
|
}
|
|
#endif
|