third_party/libxml/src/xmlwriter.c

   1
   2 /*
   3  * xmlwriter.c: XML text writer implementation
   4  *
   5  * For license and disclaimer see the license and disclaimer of
   6  * libxml2.
   7  *
   8  * alfred@mickautsch.de
   9  */
  10
  11 #define IN_LIBXML
  12 #include "libxml.h"
  13 #include <string.h>
  14
  15 #include <libxml/xmlmemory.h>
  16 #include <libxml/parser.h>
  17 #include <libxml/uri.h>
  18 #include <libxml/HTMLtree.h>
  19
  20 #ifdef LIBXML_WRITER_ENABLED
  21
  22 #include <libxml/xmlwriter.h>
  23
  24 #define B64LINELEN 72
  25 #define B64CRLF "\r\n"
  26
  27 /*
  28  * The following VA_COPY was coded following an example in
  29  * the Samba project.  It may not be sufficient for some
  30  * esoteric implementations of va_list (i.e. it may need
  31  * something involving a memcpy) but (hopefully) will be
  32  * sufficient for libxml2.
  33  */
  34 #ifndef VA_COPY
  35   #ifdef HAVE_VA_COPY
  36     #define VA_COPY(dest, src) va_copy(dest, src)
  37   #else
  38     #ifdef HAVE___VA_COPY
  39       #define VA_COPY(dest,src) __va_copy(dest, src)
  40     #else
  41       #define VA_COPY(dest,src) (dest) = (src)
  42     #endif
  43   #endif
  44 #endif
  45
  46 /*
  47  * Types are kept private
  48  */
  49 typedef enum {
  50     XML_TEXTWRITER_NONE = 0,
  51     XML_TEXTWRITER_NAME,
  52     XML_TEXTWRITER_ATTRIBUTE,
  53     XML_TEXTWRITER_TEXT,
  54     XML_TEXTWRITER_PI,
  55     XML_TEXTWRITER_PI_TEXT,
  56     XML_TEXTWRITER_CDATA,
  57     XML_TEXTWRITER_DTD,
  58     XML_TEXTWRITER_DTD_TEXT,
  59     XML_TEXTWRITER_DTD_ELEM,
  60     XML_TEXTWRITER_DTD_ELEM_TEXT,
  61     XML_TEXTWRITER_DTD_ATTL,
  62     XML_TEXTWRITER_DTD_ATTL_TEXT,
  63     XML_TEXTWRITER_DTD_ENTY,    /* entity */
  64     XML_TEXTWRITER_DTD_ENTY_TEXT,
  65     XML_TEXTWRITER_DTD_PENT,    /* parameter entity */
  66     XML_TEXTWRITER_COMMENT
  67 } xmlTextWriterState;
  68
  69 typedef struct _xmlTextWriterStackEntry xmlTextWriterStackEntry;
  70
  71 struct _xmlTextWriterStackEntry {
  72     xmlChar *name;
  73     xmlTextWriterState state;
  74 };
  75
  76 typedef struct _xmlTextWriterNsStackEntry xmlTextWriterNsStackEntry;
  77 struct _xmlTextWriterNsStackEntry {
  78     xmlChar *prefix;
  79     xmlChar *uri;
  80     xmlLinkPtr elem;
  81 };
  82
  83 struct _xmlTextWriter {
  84     xmlOutputBufferPtr out;     /* output buffer */
  85     xmlListPtr nodes;           /* element name stack */
  86     xmlListPtr nsstack;         /* name spaces stack */
  87     int level;
  88     int indent;                 /* enable indent */
  89     int doindent;               /* internal indent flag */
  90     xmlChar *ichar;             /* indent character */
  91     char qchar;                 /* character used for quoting attribute values */
  92     xmlParserCtxtPtr ctxt;
  93     int no_doc_free;
  94     xmlDocPtr doc;
  95 };
  96
  97 static void xmlFreeTextWriterStackEntry(xmlLinkPtr lk);
  98 static int xmlCmpTextWriterStackEntry(const void *data0,
  99                                       const void *data1);
 100 static int xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer);
 101 static void xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk);
 102 static int xmlCmpTextWriterNsStackEntry(const void *data0,
 103                                         const void *data1);
 104 static int xmlTextWriterWriteDocCallback(void *context,
 105                                          const xmlChar * str, int len);
 106 static int xmlTextWriterCloseDocCallback(void *context);
 107
 108 static xmlChar *xmlTextWriterVSprintf(const char *format, va_list argptr);
 109 static int xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
 110                                       const unsigned char *data);
 111 static void xmlTextWriterStartDocumentCallback(void *ctx);
 112 static int xmlTextWriterWriteIndent(xmlTextWriterPtr writer);
 113 static int
 114   xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
 115                                        xmlTextWriterStackEntry * p);
 116
 117 /**
 118  * xmlWriterErrMsg:
 119  * @ctxt:  a writer context
 120  * @error:  the error number
 121  * @msg:  the error message
 122  *
 123  * Handle a writer error
 124  */
 125 static void
 126 xmlWriterErrMsg(xmlTextWriterPtr ctxt, xmlParserErrors error,
 127                const char *msg)
 128 {
 129     if (ctxt != NULL) {
 130         __xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
 131                     NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
 132                     NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
 133     } else {
 134         __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
 135                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
 136     }
 137 }
 138
 139 /**
 140  * xmlWriterErrMsgInt:
 141  * @ctxt:  a writer context
 142  * @error:  the error number
 143  * @msg:  the error message
 144  * @val:  an int
 145  *
 146  * Handle a writer error
 147  */
 148 static void
 149 xmlWriterErrMsgInt(xmlTextWriterPtr ctxt, xmlParserErrors error,
 150                const char *msg, int val)
 151 {
 152     if (ctxt != NULL) {
 153         __xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
 154                     NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
 155                     NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
 156     } else {
 157         __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
 158                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
 159     }
 160 }
 161
 162 /**
 163  * xmlNewTextWriter:
 164  * @out:  an xmlOutputBufferPtr
 165  *
 166  * Create a new xmlNewTextWriter structure using an xmlOutputBufferPtr
 167  * NOTE: the @out parameter will be deallocated when the writer is closed
 168  *       (if the call succeed.)
 169  *
 170  * Returns the new xmlTextWriterPtr or NULL in case of error
 171  */
 172 xmlTextWriterPtr
 173 xmlNewTextWriter(xmlOutputBufferPtr out)
 174 {
 175     xmlTextWriterPtr ret;
 176
 177     ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
 178     if (ret == NULL) {
 179         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 180                         "xmlNewTextWriter : out of memory!\n");
 181         return NULL;
 182     }
 183     memset(ret, 0, (size_t) sizeof(xmlTextWriter));
 184
 185     ret->nodes = xmlListCreate((xmlListDeallocator)
 186                                xmlFreeTextWriterStackEntry,
 187                                (xmlListDataCompare)
 188                                xmlCmpTextWriterStackEntry);
 189     if (ret->nodes == NULL) {
 190         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 191                         "xmlNewTextWriter : out of memory!\n");
 192         xmlFree(ret);
 193         return NULL;
 194     }
 195
 196     ret->nsstack = xmlListCreate((xmlListDeallocator)
 197                                  xmlFreeTextWriterNsStackEntry,
 198                                  (xmlListDataCompare)
 199                                  xmlCmpTextWriterNsStackEntry);
 200     if (ret->nsstack == NULL) {
 201         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 202                         "xmlNewTextWriter : out of memory!\n");
 203         xmlListDelete(ret->nodes);
 204         xmlFree(ret);
 205         return NULL;
 206     }
 207
 208     ret->out = out;
 209     ret->ichar = xmlStrdup(BAD_CAST " ");
 210     ret->qchar = '"';
 211
 212     if (!ret->ichar) {
 213         xmlListDelete(ret->nodes);
 214         xmlListDelete(ret->nsstack);
 215         xmlFree(ret);
 216         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 217                         "xmlNewTextWriter : out of memory!\n");
 218         return NULL;
 219     }
 220
 221     ret->doc = xmlNewDoc(NULL);
 222
 223     ret->no_doc_free = 0;
 224
 225     return ret;
 226 }
 227
 228 /**
 229  * xmlNewTextWriterFilename:
 230  * @uri:  the URI of the resource for the output
 231  * @compression:  compress the output?
 232  *
 233  * Create a new xmlNewTextWriter structure with @uri as output
 234  *
 235  * Returns the new xmlTextWriterPtr or NULL in case of error
 236  */
 237 xmlTextWriterPtr
 238 xmlNewTextWriterFilename(const char *uri, int compression)
 239 {
 240     xmlTextWriterPtr ret;
 241     xmlOutputBufferPtr out;
 242
 243     out = xmlOutputBufferCreateFilename(uri, NULL, compression);
 244     if (out == NULL) {
 245         xmlWriterErrMsg(NULL, XML_IO_EIO,
 246                         "xmlNewTextWriterFilename : cannot open uri\n");
 247         return NULL;
 248     }
 249
 250     ret = xmlNewTextWriter(out);
 251     if (ret == NULL) {
 252         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 253                         "xmlNewTextWriterFilename : out of memory!\n");
 254         xmlOutputBufferClose(out);
 255         return NULL;
 256     }
 257
 258     ret->indent = 0;
 259     ret->doindent = 0;
 260     return ret;
 261 }
 262
 263 /**
 264  * xmlNewTextWriterMemory:
 265  * @buf:  xmlBufferPtr
 266  * @compression:  compress the output?
 267  *
 268  * Create a new xmlNewTextWriter structure with @buf as output
 269  * TODO: handle compression
 270  *
 271  * Returns the new xmlTextWriterPtr or NULL in case of error
 272  */
 273 xmlTextWriterPtr
 274 xmlNewTextWriterMemory(xmlBufferPtr buf, int compression ATTRIBUTE_UNUSED)
 275 {
 276     xmlTextWriterPtr ret;
 277     xmlOutputBufferPtr out;
 278
 279 /*::todo handle compression */
 280     out = xmlOutputBufferCreateBuffer(buf, NULL);
 281
 282     if (out == NULL) {
 283         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 284                         "xmlNewTextWriterMemory : out of memory!\n");
 285         return NULL;
 286     }
 287
 288     ret = xmlNewTextWriter(out);
 289     if (ret == NULL) {
 290         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
 291                         "xmlNewTextWriterMemory : out of memory!\n");
 292         xmlOutputBufferClose(out);
 293         return NULL;
 294     }
 295
 296     return ret;
 297 }
 298
 299 /**
 300  * xmlNewTextWriterPushParser:
 301  * @ctxt: xmlParserCtxtPtr to hold the new XML document tree
 302  * @compression:  compress the output?
 303  *
 304  * Create a new xmlNewTextWriter structure with @ctxt as output
 305  * NOTE: the @ctxt context will be freed with the resulting writer
 306  *       (if the call succeeds).
 307  * TODO: handle compression
 308  *
 309  * Returns the new xmlTextWriterPtr or NULL in case of error
 310  */
 311 xmlTextWriterPtr
 312 xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt,
 313                            int compression ATTRIBUTE_UNUSED)
 314 {
 315     xmlTextWriterPtr ret;
 316     xmlOutputBufferPtr out;
 317
 318     if (ctxt == NULL) {
 319         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 320                         "xmlNewTextWriterPushParser : invalid context!\n");
 321         return NULL;
 322     }
 323
 324     out = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
 325                                   xmlTextWriterWriteDocCallback,
 326                                   (xmlOutputCloseCallback)
 327                                   xmlTextWriterCloseDocCallback,
 328                                   (void *) ctxt, NULL);
 329     if (out == NULL) {
 330         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 331                         "xmlNewTextWriterPushParser : error at xmlOutputBufferCreateIO!\n");
 332         return NULL;
 333     }
 334
 335     ret = xmlNewTextWriter(out);
 336     if (ret == NULL) {
 337         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 338                         "xmlNewTextWriterPushParser : error at xmlNewTextWriter!\n");
 339         xmlOutputBufferClose(out);
 340         return NULL;
 341     }
 342
 343     ret->ctxt = ctxt;
 344
 345     return ret;
 346 }
 347
 348 /**
 349  * xmlNewTextWriterDoc:
 350  * @doc: address of a xmlDocPtr to hold the new XML document tree
 351  * @compression:  compress the output?
 352  *
 353  * Create a new xmlNewTextWriter structure with @*doc as output
 354  *
 355  * Returns the new xmlTextWriterPtr or NULL in case of error
 356  */
 357 xmlTextWriterPtr
 358 xmlNewTextWriterDoc(xmlDocPtr * doc, int compression)
 359 {
 360     xmlTextWriterPtr ret;
 361     xmlSAXHandler saxHandler;
 362     xmlParserCtxtPtr ctxt;
 363
 364     memset(&saxHandler, '\0', sizeof(saxHandler));
 365     xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
 366     saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
 367     saxHandler.startElement = xmlSAX2StartElement;
 368     saxHandler.endElement = xmlSAX2EndElement;
 369
 370     ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
 371     if (ctxt == NULL) {
 372         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 373                 "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
 374         return NULL;
 375     }
 376     /*
 377      * For some reason this seems to completely break if node names
 378      * are interned.
 379      */
 380     ctxt->dictNames = 0;
 381
 382     ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
 383     if (ctxt->myDoc == NULL) {
 384         xmlFreeParserCtxt(ctxt);
 385         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 386                         "xmlNewTextWriterDoc : error at xmlNewDoc!\n");
 387         return NULL;
 388     }
 389
 390     ret = xmlNewTextWriterPushParser(ctxt, compression);
 391     if (ret == NULL) {
 392         xmlFreeDoc(ctxt->myDoc);
 393         xmlFreeParserCtxt(ctxt);
 394         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 395                 "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
 396         return NULL;
 397     }
 398
 399     xmlSetDocCompressMode(ctxt->myDoc, compression);
 400
 401     if (doc != NULL) {
 402         *doc = ctxt->myDoc;
 403         ret->no_doc_free = 1;
 404     }
 405
 406     return ret;
 407 }
 408
 409 /**
 410  * xmlNewTextWriterTree:
 411  * @doc: xmlDocPtr
 412  * @node: xmlNodePtr or NULL for doc->children
 413  * @compression:  compress the output?
 414  *
 415  * Create a new xmlNewTextWriter structure with @doc as output
 416  * starting at @node
 417  *
 418  * Returns the new xmlTextWriterPtr or NULL in case of error
 419  */
 420 xmlTextWriterPtr
 421 xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, int compression)
 422 {
 423     xmlTextWriterPtr ret;
 424     xmlSAXHandler saxHandler;
 425     xmlParserCtxtPtr ctxt;
 426
 427     if (doc == NULL) {
 428         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 429                         "xmlNewTextWriterTree : invalid document tree!\n");
 430         return NULL;
 431     }
 432
 433     memset(&saxHandler, '\0', sizeof(saxHandler));
 434     xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
 435     saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
 436     saxHandler.startElement = xmlSAX2StartElement;
 437     saxHandler.endElement = xmlSAX2EndElement;
 438
 439     ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
 440     if (ctxt == NULL) {
 441         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 442                         "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
 443         return NULL;
 444     }
 445     /*
 446      * For some reason this seems to completely break if node names
 447      * are interned.
 448      */
 449     ctxt->dictNames = 0;
 450
 451     ret = xmlNewTextWriterPushParser(ctxt, compression);
 452     if (ret == NULL) {
 453         xmlFreeParserCtxt(ctxt);
 454         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
 455                         "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
 456         return NULL;
 457     }
 458
 459     ctxt->myDoc = doc;
 460     ctxt->node = node;
 461     ret->no_doc_free = 1;
 462
 463     xmlSetDocCompressMode(doc, compression);
 464
 465     return ret;
 466 }
 467
 468 /**
 469  * xmlFreeTextWriter:
 470  * @writer:  the xmlTextWriterPtr
 471  *
 472  * Deallocate all the resources associated to the writer
 473  */
 474 void
 475 xmlFreeTextWriter(xmlTextWriterPtr writer)
 476 {
 477     if (writer == NULL)
 478         return;
 479
 480     if (writer->out != NULL)
 481         xmlOutputBufferClose(writer->out);
 482
 483     if (writer->nodes != NULL)
 484         xmlListDelete(writer->nodes);
 485
 486     if (writer->nsstack != NULL)
 487         xmlListDelete(writer->nsstack);
 488
 489     if (writer->ctxt != NULL) {
 490         if ((writer->ctxt->myDoc != NULL) && (writer->no_doc_free == 0)) {
 491             xmlFreeDoc(writer->ctxt->myDoc);
 492             writer->ctxt->myDoc = NULL;
 493         }
 494         xmlFreeParserCtxt(writer->ctxt);
 495     }
 496
 497     if (writer->doc != NULL)
 498         xmlFreeDoc(writer->doc);
 499
 500     if (writer->ichar != NULL)
 501         xmlFree(writer->ichar);
 502     xmlFree(writer);
 503 }
 504
 505 /**
 506  * xmlTextWriterStartDocument:
 507  * @writer:  the xmlTextWriterPtr
 508  * @version:  the xml version ("1.0") or NULL for default ("1.0")
 509  * @encoding:  the encoding or NULL for default
 510  * @standalone: "yes" or "no" or NULL for default
 511  *
 512  * Start a new xml document
 513  *
 514  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 515  */
 516 int
 517 xmlTextWriterStartDocument(xmlTextWriterPtr writer, const char *version,
 518                            const char *encoding, const char *standalone)
 519 {
 520     int count;
 521     int sum;
 522     xmlLinkPtr lk;
 523     xmlCharEncodingHandlerPtr encoder;
 524
 525     if ((writer == NULL) || (writer->out == NULL)) {
 526         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 527                         "xmlTextWriterStartDocument : invalid writer!\n");
 528         return -1;
 529     }
 530
 531     lk = xmlListFront(writer->nodes);
 532     if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
 533         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 534                         "xmlTextWriterStartDocument : not allowed in this context!\n");
 535         return -1;
 536     }
 537
 538     encoder = NULL;
 539     if (encoding != NULL) {
 540         encoder = xmlFindCharEncodingHandler(encoding);
 541         if (encoder == NULL) {
 542             xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
 543                             "xmlTextWriterStartDocument : out of memory!\n");
 544             return -1;
 545         }
 546     }
 547
 548     writer->out->encoder = encoder;
 549     if (encoder != NULL) {
 550         if (writer->out->conv == NULL) {
 551             writer->out->conv = xmlBufferCreateSize(4000);
 552         }
 553         xmlCharEncOutFunc(encoder, writer->out->conv, NULL);
 554         if ((writer->doc != NULL) && (writer->doc->encoding == NULL))
 555             writer->doc->encoding = xmlStrdup((xmlChar *)writer->out->encoder->name);
 556     } else
 557         writer->out->conv = NULL;
 558
 559     sum = 0;
 560     count = xmlOutputBufferWriteString(writer->out, "<?xml version=");
 561     if (count < 0)
 562         return -1;
 563     sum += count;
 564     count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 565     if (count < 0)
 566         return -1;
 567     sum += count;
 568     if (version != 0)
 569         count = xmlOutputBufferWriteString(writer->out, version);
 570     else
 571         count = xmlOutputBufferWriteString(writer->out, "1.0");
 572     if (count < 0)
 573         return -1;
 574     sum += count;
 575     count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 576     if (count < 0)
 577         return -1;
 578     sum += count;
 579     if (writer->out->encoder != 0) {
 580         count = xmlOutputBufferWriteString(writer->out, " encoding=");
 581         if (count < 0)
 582             return -1;
 583         sum += count;
 584         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 585         if (count < 0)
 586             return -1;
 587         sum += count;
 588         count =
 589             xmlOutputBufferWriteString(writer->out,
 590                                        writer->out->encoder->name);
 591         if (count < 0)
 592             return -1;
 593         sum += count;
 594         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 595         if (count < 0)
 596             return -1;
 597         sum += count;
 598     }
 599
 600     if (standalone != 0) {
 601         count = xmlOutputBufferWriteString(writer->out, " standalone=");
 602         if (count < 0)
 603             return -1;
 604         sum += count;
 605         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 606         if (count < 0)
 607             return -1;
 608         sum += count;
 609         count = xmlOutputBufferWriteString(writer->out, standalone);
 610         if (count < 0)
 611             return -1;
 612         sum += count;
 613         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
 614         if (count < 0)
 615             return -1;
 616         sum += count;
 617     }
 618
 619     count = xmlOutputBufferWriteString(writer->out, "?>\n");
 620     if (count < 0)
 621         return -1;
 622     sum += count;
 623
 624     return sum;
 625 }
 626
 627 /**
 628  * xmlTextWriterEndDocument:
 629  * @writer:  the xmlTextWriterPtr
 630  *
 631  * End an xml document. All open elements are closed, and
 632  * the content is flushed to the output.
 633  *
 634  * Returns the bytes written or -1 in case of error
 635  */
 636 int
 637 xmlTextWriterEndDocument(xmlTextWriterPtr writer)
 638 {
 639     int count;
 640     int sum;
 641     xmlLinkPtr lk;
 642     xmlTextWriterStackEntry *p;
 643
 644     if (writer == NULL) {
 645         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 646                         "xmlTextWriterEndDocument : invalid writer!\n");
 647         return -1;
 648     }
 649
 650     sum = 0;
 651     while ((lk = xmlListFront(writer->nodes)) != NULL) {
 652         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
 653         if (p == 0)
 654             break;
 655         switch (p->state) {
 656             case XML_TEXTWRITER_NAME:
 657             case XML_TEXTWRITER_ATTRIBUTE:
 658             case XML_TEXTWRITER_TEXT:
 659                 count = xmlTextWriterEndElement(writer);
 660                 if (count < 0)
 661                     return -1;
 662                 sum += count;
 663                 break;
 664             case XML_TEXTWRITER_PI:
 665             case XML_TEXTWRITER_PI_TEXT:
 666                 count = xmlTextWriterEndPI(writer);
 667                 if (count < 0)
 668                     return -1;
 669                 sum += count;
 670                 break;
 671             case XML_TEXTWRITER_CDATA:
 672                 count = xmlTextWriterEndCDATA(writer);
 673                 if (count < 0)
 674                     return -1;
 675                 sum += count;
 676                 break;
 677             case XML_TEXTWRITER_DTD:
 678             case XML_TEXTWRITER_DTD_TEXT:
 679             case XML_TEXTWRITER_DTD_ELEM:
 680             case XML_TEXTWRITER_DTD_ELEM_TEXT:
 681             case XML_TEXTWRITER_DTD_ATTL:
 682             case XML_TEXTWRITER_DTD_ATTL_TEXT:
 683             case XML_TEXTWRITER_DTD_ENTY:
 684             case XML_TEXTWRITER_DTD_ENTY_TEXT:
 685             case XML_TEXTWRITER_DTD_PENT:
 686                 count = xmlTextWriterEndDTD(writer);
 687                 if (count < 0)
 688                     return -1;
 689                 sum += count;
 690                 break;
 691             case XML_TEXTWRITER_COMMENT:
 692                 count = xmlTextWriterEndComment(writer);
 693                 if (count < 0)
 694                     return -1;
 695                 sum += count;
 696                 break;
 697             default:
 698                 break;
 699         }
 700     }
 701
 702     if (!writer->indent) {
 703         count = xmlOutputBufferWriteString(writer->out, "\n");
 704         if (count < 0)
 705             return -1;
 706         sum += count;
 707     }
 708
 709     sum += xmlTextWriterFlush(writer);
 710
 711     return sum;
 712 }
 713
 714 /**
 715  * xmlTextWriterStartComment:
 716  * @writer:  the xmlTextWriterPtr
 717  *
 718  * Start an xml comment.
 719  *
 720  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 721  */
 722 int
 723 xmlTextWriterStartComment(xmlTextWriterPtr writer)
 724 {
 725     int count;
 726     int sum;
 727     xmlLinkPtr lk;
 728     xmlTextWriterStackEntry *p;
 729
 730     if (writer == NULL) {
 731         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 732                         "xmlTextWriterStartComment : invalid writer!\n");
 733         return -1;
 734     }
 735
 736     sum = 0;
 737     lk = xmlListFront(writer->nodes);
 738     if (lk != 0) {
 739         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
 740         if (p != 0) {
 741             switch (p->state) {
 742                 case XML_TEXTWRITER_TEXT:
 743                 case XML_TEXTWRITER_NONE:
 744                     break;
 745                 case XML_TEXTWRITER_NAME:
 746                     /* Output namespace declarations */
 747                     count = xmlTextWriterOutputNSDecl(writer);
 748                     if (count < 0)
 749                         return -1;
 750                     sum += count;
 751                     count = xmlOutputBufferWriteString(writer->out, ">");
 752                     if (count < 0)
 753                         return -1;
 754                     sum += count;
 755                     if (writer->indent) {
 756                         count =
 757                             xmlOutputBufferWriteString(writer->out, "\n");
 758                         if (count < 0)
 759                             return -1;
 760                         sum += count;
 761                     }
 762                     p->state = XML_TEXTWRITER_TEXT;
 763                     break;
 764                 default:
 765                     return -1;
 766             }
 767         }
 768     }
 769
 770     p = (xmlTextWriterStackEntry *)
 771         xmlMalloc(sizeof(xmlTextWriterStackEntry));
 772     if (p == 0) {
 773         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
 774                         "xmlTextWriterStartElement : out of memory!\n");
 775         return -1;
 776     }
 777
 778     p->name = NULL;
 779     p->state = XML_TEXTWRITER_COMMENT;
 780
 781     xmlListPushFront(writer->nodes, p);
 782
 783     if (writer->indent) {
 784         count = xmlTextWriterWriteIndent(writer);
 785         if (count < 0)
 786             return -1;
 787         sum += count;
 788     }
 789
 790     count = xmlOutputBufferWriteString(writer->out, "<!--");
 791     if (count < 0)
 792         return -1;
 793     sum += count;
 794
 795     return sum;
 796 }
 797
 798 /**
 799  * xmlTextWriterEndComment:
 800  * @writer:  the xmlTextWriterPtr
 801  *
 802  * End the current xml coment.
 803  *
 804  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 805  */
 806 int
 807 xmlTextWriterEndComment(xmlTextWriterPtr writer)
 808 {
 809     int count;
 810     int sum;
 811     xmlLinkPtr lk;
 812     xmlTextWriterStackEntry *p;
 813
 814     if (writer == NULL) {
 815         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 816                         "xmlTextWriterEndComment : invalid writer!\n");
 817         return -1;
 818     }
 819
 820     lk = xmlListFront(writer->nodes);
 821     if (lk == 0) {
 822         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 823                         "xmlTextWriterEndComment : not allowed in this context!\n");
 824         return -1;
 825     }
 826
 827     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
 828     if (p == 0)
 829         return -1;
 830
 831     sum = 0;
 832     switch (p->state) {
 833         case XML_TEXTWRITER_COMMENT:
 834             count = xmlOutputBufferWriteString(writer->out, "-->");
 835             if (count < 0)
 836                 return -1;
 837             sum += count;
 838             break;
 839         default:
 840             return -1;
 841     }
 842
 843     if (writer->indent) {
 844         count = xmlOutputBufferWriteString(writer->out, "\n");
 845         if (count < 0)
 846             return -1;
 847         sum += count;
 848     }
 849
 850     xmlListPopFront(writer->nodes);
 851     return sum;
 852 }
 853
 854 /**
 855  * xmlTextWriterWriteFormatComment:
 856  * @writer:  the xmlTextWriterPtr
 857  * @format:  format string (see printf)
 858  * @...:  extra parameters for the format
 859  *
 860  * Write an xml comment.
 861  *
 862  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 863  */
 864 int XMLCDECL
 865 xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
 866                                 const char *format, ...)
 867 {
 868     int rc;
 869     va_list ap;
 870
 871     va_start(ap, format);
 872
 873     rc = xmlTextWriterWriteVFormatComment(writer, format, ap);
 874
 875     va_end(ap);
 876     return rc;
 877 }
 878
 879 /**
 880  * xmlTextWriterWriteVFormatComment:
 881  * @writer:  the xmlTextWriterPtr
 882  * @format:  format string (see printf)
 883  * @argptr:  pointer to the first member of the variable argument list.
 884  *
 885  * Write an xml comment.
 886  *
 887  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 888  */
 889 int
 890 xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
 891                                  const char *format, va_list argptr)
 892 {
 893     int rc;
 894     xmlChar *buf;
 895
 896     if (writer == NULL) {
 897         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
 898                         "xmlTextWriterWriteVFormatComment : invalid writer!\n");
 899         return -1;
 900     }
 901
 902     buf = xmlTextWriterVSprintf(format, argptr);
 903     if (buf == NULL)
 904         return -1;
 905
 906     rc = xmlTextWriterWriteComment(writer, buf);
 907
 908     xmlFree(buf);
 909     return rc;
 910 }
 911
 912 /**
 913  * xmlTextWriterWriteComment:
 914  * @writer:  the xmlTextWriterPtr
 915  * @content:  comment string
 916  *
 917  * Write an xml comment.
 918  *
 919  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 920  */
 921 int
 922 xmlTextWriterWriteComment(xmlTextWriterPtr writer, const xmlChar * content)
 923 {
 924     int count;
 925     int sum;
 926
 927     sum = 0;
 928     count = xmlTextWriterStartComment(writer);
 929     if (count < 0)
 930         return -1;
 931     sum += count;
 932     count = xmlTextWriterWriteString(writer, content);
 933     if (count < 0)
 934         return -1;
 935     sum += count;
 936     count = xmlTextWriterEndComment(writer);
 937     if (count < 0)
 938         return -1;
 939     sum += count;
 940
 941     return sum;
 942 }
 943
 944 /**
 945  * xmlTextWriterStartElement:
 946  * @writer:  the xmlTextWriterPtr
 947  * @name:  element name
 948  *
 949  * Start an xml element.
 950  *
 951  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
 952  */
 953 int
 954 xmlTextWriterStartElement(xmlTextWriterPtr writer, const xmlChar * name)
 955 {
 956     int count;
 957     int sum;
 958     xmlLinkPtr lk;
 959     xmlTextWriterStackEntry *p;
 960
 961     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
 962         return -1;
 963
 964     sum = 0;
 965     lk = xmlListFront(writer->nodes);
 966     if (lk != 0) {
 967         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
 968         if (p != 0) {
 969             switch (p->state) {
 970                 case XML_TEXTWRITER_PI:
 971                 case XML_TEXTWRITER_PI_TEXT:
 972                     return -1;
 973                 case XML_TEXTWRITER_NONE:
 974                     break;
 975                                 case XML_TEXTWRITER_ATTRIBUTE:
 976                                         count = xmlTextWriterEndAttribute(writer);
 977                                         if (count < 0)
 978                                                 return -1;
 979                                         sum += count;
 980                                         /* fallthrough */
 981                 case XML_TEXTWRITER_NAME:
 982                     /* Output namespace declarations */
 983                     count = xmlTextWriterOutputNSDecl(writer);
 984                     if (count < 0)
 985                         return -1;
 986                     sum += count;
 987                     count = xmlOutputBufferWriteString(writer->out, ">");
 988                     if (count < 0)
 989                         return -1;
 990                     sum += count;
 991                     if (writer->indent)
 992                         count =
 993                             xmlOutputBufferWriteString(writer->out, "\n");
 994                     p->state = XML_TEXTWRITER_TEXT;
 995                     break;
 996                 default:
 997                     break;
 998             }
 999         }
1000     }
1001
1002     p = (xmlTextWriterStackEntry *)
1003         xmlMalloc(sizeof(xmlTextWriterStackEntry));
1004     if (p == 0) {
1005         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1006                         "xmlTextWriterStartElement : out of memory!\n");
1007         return -1;
1008     }
1009
1010     p->name = xmlStrdup(name);
1011     if (p->name == 0) {
1012         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1013                         "xmlTextWriterStartElement : out of memory!\n");
1014         xmlFree(p);
1015         return -1;
1016     }
1017     p->state = XML_TEXTWRITER_NAME;
1018
1019     xmlListPushFront(writer->nodes, p);
1020
1021     if (writer->indent) {
1022         count = xmlTextWriterWriteIndent(writer);
1023         sum += count;
1024     }
1025
1026     count = xmlOutputBufferWriteString(writer->out, "<");
1027     if (count < 0)
1028         return -1;
1029     sum += count;
1030     count =
1031         xmlOutputBufferWriteString(writer->out, (const char *) p->name);
1032     if (count < 0)
1033         return -1;
1034     sum += count;
1035
1036     return sum;
1037 }
1038
1039 /**
1040  * xmlTextWriterStartElementNS:
1041  * @writer:  the xmlTextWriterPtr
1042  * @prefix:  namespace prefix or NULL
1043  * @name:  element local name
1044  * @namespaceURI:  namespace URI or NULL
1045  *
1046  * Start an xml element with namespace support.
1047  *
1048  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1049  */
1050 int
1051 xmlTextWriterStartElementNS(xmlTextWriterPtr writer,
1052                             const xmlChar * prefix, const xmlChar * name,
1053                             const xmlChar * namespaceURI)
1054 {
1055     int count;
1056     int sum;
1057     xmlChar *buf;
1058
1059     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1060         return -1;
1061
1062     buf = NULL;
1063     if (prefix != 0) {
1064         buf = xmlStrdup(prefix);
1065         buf = xmlStrcat(buf, BAD_CAST ":");
1066     }
1067     buf = xmlStrcat(buf, name);
1068
1069     sum = 0;
1070     count = xmlTextWriterStartElement(writer, buf);
1071     xmlFree(buf);
1072     if (count < 0)
1073         return -1;
1074     sum += count;
1075
1076     if (namespaceURI != 0) {
1077         xmlTextWriterNsStackEntry *p = (xmlTextWriterNsStackEntry *)
1078         xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
1079         if (p == 0) {
1080             xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1081                             "xmlTextWriterStartElementNS : out of memory!\n");
1082             return -1;
1083         }
1084
1085         buf = xmlStrdup(BAD_CAST "xmlns");
1086         if (prefix != 0) {
1087             buf = xmlStrcat(buf, BAD_CAST ":");
1088             buf = xmlStrcat(buf, prefix);
1089         }
1090
1091         p->prefix = buf;
1092         p->uri = xmlStrdup(namespaceURI);
1093         if (p->uri == 0) {
1094             xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1095                             "xmlTextWriterStartElementNS : out of memory!\n");
1096             xmlFree(p);
1097             return -1;
1098         }
1099         p->elem = xmlListFront(writer->nodes);
1100
1101         xmlListPushFront(writer->nsstack, p);
1102     }
1103
1104     return sum;
1105 }
1106
1107 /**
1108  * xmlTextWriterEndElement:
1109  * @writer:  the xmlTextWriterPtr
1110  *
1111  * End the current xml element.
1112  *
1113  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1114  */
1115 int
1116 xmlTextWriterEndElement(xmlTextWriterPtr writer)
1117 {
1118     int count;
1119     int sum;
1120     xmlLinkPtr lk;
1121     xmlTextWriterStackEntry *p;
1122
1123     if (writer == NULL)
1124         return -1;
1125
1126     lk = xmlListFront(writer->nodes);
1127     if (lk == 0) {
1128         xmlListDelete(writer->nsstack);
1129         writer->nsstack = NULL;
1130         return -1;
1131     }
1132
1133     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1134     if (p == 0) {
1135         xmlListDelete(writer->nsstack);
1136         writer->nsstack = NULL;
1137         return -1;
1138     }
1139
1140     sum = 0;
1141     switch (p->state) {
1142         case XML_TEXTWRITER_ATTRIBUTE:
1143             count = xmlTextWriterEndAttribute(writer);
1144             if (count < 0) {
1145                 xmlListDelete(writer->nsstack);
1146                 writer->nsstack = NULL;
1147                 return -1;
1148             }
1149             sum += count;
1150             /* fallthrough */
1151         case XML_TEXTWRITER_NAME:
1152             /* Output namespace declarations */
1153             count = xmlTextWriterOutputNSDecl(writer);
1154             if (count < 0)
1155                 return -1;
1156             sum += count;
1157
1158             if (writer->indent) /* next element needs indent */
1159                 writer->doindent = 1;
1160             count = xmlOutputBufferWriteString(writer->out, "/>");
1161             if (count < 0)
1162                 return -1;
1163             sum += count;
1164             break;
1165         case XML_TEXTWRITER_TEXT:
1166             if ((writer->indent) && (writer->doindent)) {
1167                 count = xmlTextWriterWriteIndent(writer);
1168                 sum += count;
1169                 writer->doindent = 1;
1170             } else
1171                 writer->doindent = 1;
1172             count = xmlOutputBufferWriteString(writer->out, "</");
1173             if (count < 0)
1174                 return -1;
1175             sum += count;
1176             count = xmlOutputBufferWriteString(writer->out,
1177                                                (const char *) p->name);
1178             if (count < 0)
1179                 return -1;
1180             sum += count;
1181             count = xmlOutputBufferWriteString(writer->out, ">");
1182             if (count < 0)
1183                 return -1;
1184             sum += count;
1185             break;
1186         default:
1187             return -1;
1188     }
1189
1190     if (writer->indent) {
1191         count = xmlOutputBufferWriteString(writer->out, "\n");
1192         sum += count;
1193     }
1194
1195     xmlListPopFront(writer->nodes);
1196     return sum;
1197 }
1198
1199 /**
1200  * xmlTextWriterFullEndElement:
1201  * @writer:  the xmlTextWriterPtr
1202  *
1203  * End the current xml element. Writes an end tag even if the element is empty
1204  *
1205  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1206  */
1207 int
1208 xmlTextWriterFullEndElement(xmlTextWriterPtr writer)
1209 {
1210     int count;
1211     int sum;
1212     xmlLinkPtr lk;
1213     xmlTextWriterStackEntry *p;
1214
1215     if (writer == NULL)
1216         return -1;
1217
1218     lk = xmlListFront(writer->nodes);
1219     if (lk == 0)
1220         return -1;
1221
1222     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1223     if (p == 0)
1224         return -1;
1225
1226     sum = 0;
1227     switch (p->state) {
1228         case XML_TEXTWRITER_ATTRIBUTE:
1229             count = xmlTextWriterEndAttribute(writer);
1230             if (count < 0)
1231                 return -1;
1232             sum += count;
1233             /* fallthrough */
1234         case XML_TEXTWRITER_NAME:
1235             /* Output namespace declarations */
1236             count = xmlTextWriterOutputNSDecl(writer);
1237             if (count < 0)
1238                 return -1;
1239             sum += count;
1240
1241             count = xmlOutputBufferWriteString(writer->out, ">");
1242             if (count < 0)
1243                 return -1;
1244             sum += count;
1245             if (writer->indent)
1246                 writer->doindent = 0;
1247             /* fallthrough */
1248         case XML_TEXTWRITER_TEXT:
1249             if ((writer->indent) && (writer->doindent)) {
1250                 count = xmlTextWriterWriteIndent(writer);
1251                 sum += count;
1252                 writer->doindent = 1;
1253             } else
1254                 writer->doindent = 1;
1255             count = xmlOutputBufferWriteString(writer->out, "</");
1256             if (count < 0)
1257                 return -1;
1258             sum += count;
1259             count = xmlOutputBufferWriteString(writer->out,
1260                                                (const char *) p->name);
1261             if (count < 0)
1262                 return -1;
1263             sum += count;
1264             count = xmlOutputBufferWriteString(writer->out, ">");
1265             if (count < 0)
1266                 return -1;
1267             sum += count;
1268             break;
1269         default:
1270             return -1;
1271     }
1272
1273     if (writer->indent) {
1274         count = xmlOutputBufferWriteString(writer->out, "\n");
1275         sum += count;
1276     }
1277
1278     xmlListPopFront(writer->nodes);
1279     return sum;
1280 }
1281
1282 /**
1283  * xmlTextWriterWriteFormatRaw:
1284  * @writer:  the xmlTextWriterPtr
1285  * @format:  format string (see printf)
1286  * @...:  extra parameters for the format
1287  *
1288  * Write a formatted raw xml text.
1289  *
1290  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1291  */
1292 int XMLCDECL
1293 xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, const char *format,
1294                             ...)
1295 {
1296     int rc;
1297     va_list ap;
1298
1299     va_start(ap, format);
1300
1301     rc = xmlTextWriterWriteVFormatRaw(writer, format, ap);
1302
1303     va_end(ap);
1304     return rc;
1305 }
1306
1307 /**
1308  * xmlTextWriterWriteVFormatRaw:
1309  * @writer:  the xmlTextWriterPtr
1310  * @format:  format string (see printf)
1311  * @argptr:  pointer to the first member of the variable argument list.
1312  *
1313  * Write a formatted raw xml text.
1314  *
1315  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1316  */
1317 int
1318 xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, const char *format,
1319                              va_list argptr)
1320 {
1321     int rc;
1322     xmlChar *buf;
1323
1324     if (writer == NULL)
1325         return -1;
1326
1327     buf = xmlTextWriterVSprintf(format, argptr);
1328     if (buf == NULL)
1329         return -1;
1330
1331     rc = xmlTextWriterWriteRaw(writer, buf);
1332
1333     xmlFree(buf);
1334     return rc;
1335 }
1336
1337 /**
1338  * xmlTextWriterWriteRawLen:
1339  * @writer:  the xmlTextWriterPtr
1340  * @content:  text string
1341  * @len:  length of the text string
1342  *
1343  * Write an xml text.
1344  * TODO: what about entities and special chars??
1345  *
1346  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1347  */
1348 int
1349 xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, const xmlChar * content,
1350                          int len)
1351 {
1352     int count;
1353     int sum;
1354     xmlLinkPtr lk;
1355     xmlTextWriterStackEntry *p;
1356
1357     if (writer == NULL) {
1358         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
1359                         "xmlTextWriterWriteRawLen : invalid writer!\n");
1360         return -1;
1361     }
1362
1363     if ((content == NULL) || (len < 0)) {
1364         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
1365                         "xmlTextWriterWriteRawLen : invalid content!\n");
1366         return -1;
1367     }
1368
1369     sum = 0;
1370     lk = xmlListFront(writer->nodes);
1371     if (lk != 0) {
1372         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1373         count = xmlTextWriterHandleStateDependencies(writer, p);
1374         if (count < 0)
1375             return -1;
1376         sum += count;
1377     }
1378
1379     if (writer->indent)
1380         writer->doindent = 0;
1381
1382     if (content != NULL) {
1383         count =
1384             xmlOutputBufferWrite(writer->out, len, (const char *) content);
1385         if (count < 0)
1386             return -1;
1387         sum += count;
1388     }
1389
1390     return sum;
1391 }
1392
1393 /**
1394  * xmlTextWriterWriteRaw:
1395  * @writer:  the xmlTextWriterPtr
1396  * @content:  text string
1397  *
1398  * Write a raw xml text.
1399  *
1400  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1401  */
1402 int
1403 xmlTextWriterWriteRaw(xmlTextWriterPtr writer, const xmlChar * content)
1404 {
1405     return xmlTextWriterWriteRawLen(writer, content, xmlStrlen(content));
1406 }
1407
1408 /**
1409  * xmlTextWriterWriteFormatString:
1410  * @writer:  the xmlTextWriterPtr
1411  * @format:  format string (see printf)
1412  * @...:  extra parameters for the format
1413  *
1414  * Write a formatted xml text.
1415  *
1416  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1417  */
1418 int XMLCDECL
1419 xmlTextWriterWriteFormatString(xmlTextWriterPtr writer, const char *format,
1420                                ...)
1421 {
1422     int rc;
1423     va_list ap;
1424
1425     if ((writer == NULL) || (format == NULL))
1426         return -1;
1427
1428     va_start(ap, format);
1429
1430     rc = xmlTextWriterWriteVFormatString(writer, format, ap);
1431
1432     va_end(ap);
1433     return rc;
1434 }
1435
1436 /**
1437  * xmlTextWriterWriteVFormatString:
1438  * @writer:  the xmlTextWriterPtr
1439  * @format:  format string (see printf)
1440  * @argptr:  pointer to the first member of the variable argument list.
1441  *
1442  * Write a formatted xml text.
1443  *
1444  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1445  */
1446 int
1447 xmlTextWriterWriteVFormatString(xmlTextWriterPtr writer,
1448                                 const char *format, va_list argptr)
1449 {
1450     int rc;
1451     xmlChar *buf;
1452
1453     if ((writer == NULL) || (format == NULL))
1454         return -1;
1455
1456     buf = xmlTextWriterVSprintf(format, argptr);
1457     if (buf == NULL)
1458         return -1;
1459
1460     rc = xmlTextWriterWriteString(writer, buf);
1461
1462     xmlFree(buf);
1463     return rc;
1464 }
1465
1466 /**
1467  * xmlTextWriterWriteString:
1468  * @writer:  the xmlTextWriterPtr
1469  * @content:  text string
1470  *
1471  * Write an xml text.
1472  *
1473  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1474  */
1475 int
1476 xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar * content)
1477 {
1478     int count;
1479     int sum;
1480     xmlLinkPtr lk;
1481     xmlTextWriterStackEntry *p;
1482     xmlChar *buf;
1483
1484     if ((writer == NULL) || (content == NULL))
1485         return -1;
1486
1487     sum = 0;
1488     buf = (xmlChar *) content;
1489     lk = xmlListFront(writer->nodes);
1490     if (lk != 0) {
1491         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1492         if (p != 0) {
1493             switch (p->state) {
1494                 case XML_TEXTWRITER_NAME:
1495                 case XML_TEXTWRITER_TEXT:
1496 #if 0
1497                     buf = NULL;
1498                     xmlOutputBufferWriteEscape(writer->out, content, NULL);
1499 #endif
1500                     buf = xmlEncodeSpecialChars(NULL, content);
1501                     break;
1502                 case XML_TEXTWRITER_ATTRIBUTE:
1503                     buf = NULL;
1504                     xmlAttrSerializeTxtContent(writer->out->buffer, writer->doc,
1505                                                NULL, content);
1506                     break;
1507                 default:
1508                     break;
1509             }
1510         }
1511     }
1512
1513     if (buf != NULL) {
1514         count = xmlTextWriterWriteRaw(writer, buf);
1515
1516         if (buf != content)     /* buf was allocated by us, so free it */
1517             xmlFree(buf);
1518
1519         if (count < 0)
1520             return -1;
1521         sum += count;
1522     }
1523
1524     return sum;
1525 }
1526
1527 /**
1528  * xmlOutputBufferWriteBase64:
1529  * @out: the xmlOutputBufferPtr
1530  * @data:   binary data
1531  * @len:  the number of bytes to encode
1532  *
1533  * Write base64 encoded data to an xmlOutputBuffer.
1534  * Adapted from John Walker's base64.c (http://www.fourmilab.ch/).
1535  *
1536  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1537  */
1538 static int
1539 xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
1540                            const unsigned char *data)
1541 {
1542     static unsigned char dtable[64] =
1543             {'A','B','C','D','E','F','G','H','I','J','K','L','M',
1544              'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
1545              'a','b','c','d','e','f','g','h','i','j','k','l','m',
1546              'n','o','p','q','r','s','t','u','v','w','x','y','z',
1547              '0','1','2','3','4','5','6','7','8','9','+','/'};
1548
1549     int i;
1550     int linelen;
1551     int count;
1552     int sum;
1553
1554     if ((out == NULL) || (len < 0) || (data == NULL))
1555         return(-1);
1556
1557     linelen = 0;
1558     sum = 0;
1559
1560     i = 0;
1561     while (1) {
1562         unsigned char igroup[3];
1563         unsigned char ogroup[4];
1564         int c;
1565         int n;
1566
1567         igroup[0] = igroup[1] = igroup[2] = 0;
1568         for (n = 0; n < 3 && i < len; n++, i++) {
1569             c = data[i];
1570             igroup[n] = (unsigned char) c;
1571         }
1572
1573         if (n > 0) {
1574             ogroup[0] = dtable[igroup[0] >> 2];
1575             ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
1576             ogroup[2] =
1577                 dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
1578             ogroup[3] = dtable[igroup[2] & 0x3F];
1579
1580             if (n < 3) {
1581                 ogroup[3] = '=';
1582                 if (n < 2) {
1583                     ogroup[2] = '=';
1584                 }
1585             }
1586
1587             if (linelen >= B64LINELEN) {
1588                 count = xmlOutputBufferWrite(out, 2, B64CRLF);
1589                 if (count == -1)
1590                     return -1;
1591                 sum += count;
1592                 linelen = 0;
1593             }
1594             count = xmlOutputBufferWrite(out, 4, (const char *) ogroup);
1595             if (count == -1)
1596                 return -1;
1597             sum += count;
1598
1599             linelen += 4;
1600         }
1601
1602         if (i >= len)
1603             break;
1604     }
1605
1606     return sum;
1607 }
1608
1609 /**
1610  * xmlTextWriterWriteBase64:
1611  * @writer: the xmlTextWriterPtr
1612  * @data:   binary data
1613  * @start:  the position within the data of the first byte to encode
1614  * @len:  the number of bytes to encode
1615  *
1616  * Write an base64 encoded xml text.
1617  *
1618  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1619  */
1620 int
1621 xmlTextWriterWriteBase64(xmlTextWriterPtr writer, const char *data,
1622                          int start, int len)
1623 {
1624     int count;
1625     int sum;
1626     xmlLinkPtr lk;
1627     xmlTextWriterStackEntry *p;
1628
1629     if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
1630         return -1;
1631
1632     sum = 0;
1633     lk = xmlListFront(writer->nodes);
1634     if (lk != 0) {
1635         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1636         if (p != 0) {
1637             count = xmlTextWriterHandleStateDependencies(writer, p);
1638             if (count < 0)
1639                 return -1;
1640             sum += count;
1641         }
1642     }
1643
1644     if (writer->indent)
1645         writer->doindent = 0;
1646
1647     count =
1648         xmlOutputBufferWriteBase64(writer->out, len,
1649                                    (unsigned char *) data + start);
1650     if (count < 0)
1651         return -1;
1652     sum += count;
1653
1654     return sum;
1655 }
1656
1657 /**
1658  * xmlOutputBufferWriteBinHex:
1659  * @out: the xmlOutputBufferPtr
1660  * @data:   binary data
1661  * @len:  the number of bytes to encode
1662  *
1663  * Write hqx encoded data to an xmlOutputBuffer.
1664  * ::todo
1665  *
1666  * Returns the bytes written (may be 0 because of buffering)
1667  * or -1 in case of error
1668  */
1669 static int
1670 xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
1671                            int len, const unsigned char *data)
1672 {
1673     int count;
1674     int sum;
1675     static char hex[16] =
1676         {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
1677     int i;
1678
1679     if ((out == NULL) || (data == NULL) || (len < 0)) {
1680         return -1;
1681     }
1682
1683     sum = 0;
1684     for (i = 0; i < len; i++) {
1685         count =
1686             xmlOutputBufferWrite(out, 1,
1687                                  (const char *) &hex[data[i] >> 4]);
1688         if (count == -1)
1689             return -1;
1690         sum += count;
1691         count =
1692             xmlOutputBufferWrite(out, 1,
1693                                  (const char *) &hex[data[i] & 0xF]);
1694         if (count == -1)
1695             return -1;
1696         sum += count;
1697     }
1698
1699     return sum;
1700 }
1701
1702 /**
1703  * xmlTextWriterWriteBinHex:
1704  * @writer: the xmlTextWriterPtr
1705  * @data:   binary data
1706  * @start:  the position within the data of the first byte to encode
1707  * @len:  the number of bytes to encode
1708  *
1709  * Write a BinHex encoded xml text.
1710  *
1711  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1712  */
1713 int
1714 xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, const char *data,
1715                          int start, int len)
1716 {
1717     int count;
1718     int sum;
1719     xmlLinkPtr lk;
1720     xmlTextWriterStackEntry *p;
1721
1722     if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
1723         return -1;
1724
1725     sum = 0;
1726     lk = xmlListFront(writer->nodes);
1727     if (lk != 0) {
1728         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1729         if (p != 0) {
1730             count = xmlTextWriterHandleStateDependencies(writer, p);
1731             if (count < 0)
1732                 return -1;
1733             sum += count;
1734         }
1735     }
1736
1737     if (writer->indent)
1738         writer->doindent = 0;
1739
1740     count =
1741         xmlOutputBufferWriteBinHex(writer->out, len,
1742                                    (unsigned char *) data + start);
1743     if (count < 0)
1744         return -1;
1745     sum += count;
1746
1747     return sum;
1748 }
1749
1750 /**
1751  * xmlTextWriterStartAttribute:
1752  * @writer:  the xmlTextWriterPtr
1753  * @name:  element name
1754  *
1755  * Start an xml attribute.
1756  *
1757  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1758  */
1759 int
1760 xmlTextWriterStartAttribute(xmlTextWriterPtr writer, const xmlChar * name)
1761 {
1762     int count;
1763     int sum;
1764     xmlLinkPtr lk;
1765     xmlTextWriterStackEntry *p;
1766
1767     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1768         return -1;
1769
1770     sum = 0;
1771     lk = xmlListFront(writer->nodes);
1772     if (lk == 0)
1773         return -1;
1774
1775     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1776     if (p == 0)
1777         return -1;
1778
1779     switch (p->state) {
1780         case XML_TEXTWRITER_ATTRIBUTE:
1781             count = xmlTextWriterEndAttribute(writer);
1782             if (count < 0)
1783                 return -1;
1784             sum += count;
1785             /* fallthrough */
1786         case XML_TEXTWRITER_NAME:
1787             count = xmlOutputBufferWriteString(writer->out, " ");
1788             if (count < 0)
1789                 return -1;
1790             sum += count;
1791             count =
1792                 xmlOutputBufferWriteString(writer->out,
1793                                            (const char *) name);
1794             if (count < 0)
1795                 return -1;
1796             sum += count;
1797             count = xmlOutputBufferWriteString(writer->out, "=");
1798             if (count < 0)
1799                 return -1;
1800             sum += count;
1801             count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
1802             if (count < 0)
1803                 return -1;
1804             sum += count;
1805             p->state = XML_TEXTWRITER_ATTRIBUTE;
1806             break;
1807         default:
1808             return -1;
1809     }
1810
1811     return sum;
1812 }
1813
1814 /**
1815  * xmlTextWriterStartAttributeNS:
1816  * @writer:  the xmlTextWriterPtr
1817  * @prefix:  namespace prefix or NULL
1818  * @name:  element local name
1819  * @namespaceURI:  namespace URI or NULL
1820  *
1821  * Start an xml attribute with namespace support.
1822  *
1823  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1824  */
1825 int
1826 xmlTextWriterStartAttributeNS(xmlTextWriterPtr writer,
1827                               const xmlChar * prefix, const xmlChar * name,
1828                               const xmlChar * namespaceURI)
1829 {
1830     int count;
1831     int sum;
1832     xmlChar *buf;
1833     xmlTextWriterNsStackEntry *p;
1834
1835     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1836         return -1;
1837
1838     /* Handle namespace first in case of error */
1839     if (namespaceURI != 0) {
1840         xmlTextWriterNsStackEntry nsentry, *curns;
1841
1842         buf = xmlStrdup(BAD_CAST "xmlns");
1843         if (prefix != 0) {
1844             buf = xmlStrcat(buf, BAD_CAST ":");
1845             buf = xmlStrcat(buf, prefix);
1846         }
1847
1848         nsentry.prefix = buf;
1849         nsentry.uri = (xmlChar *)namespaceURI;
1850         nsentry.elem = xmlListFront(writer->nodes);
1851
1852         curns = (xmlTextWriterNsStackEntry *)xmlListSearch(writer->nsstack,
1853                                                            (void *)&nsentry);
1854         if ((curns != NULL)) {
1855             xmlFree(buf);
1856             if (xmlStrcmp(curns->uri, namespaceURI) == 0) {
1857                 /* Namespace already defined on element skip */
1858                 buf = NULL;
1859             } else {
1860                 /* Prefix mismatch so error out */
1861                 return -1;
1862             }
1863         }
1864
1865         /* Do not add namespace decl to list - it is already there */
1866         if (buf != NULL) {
1867             p = (xmlTextWriterNsStackEntry *)
1868                 xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
1869             if (p == 0) {
1870                 xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1871                                                                         "xmlTextWriterStartAttributeNS : out of memory!\n");
1872                 return -1;
1873             }
1874
1875             p->prefix = buf;
1876             p->uri = xmlStrdup(namespaceURI);
1877             if (p->uri == 0) {
1878                 xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1879                         "xmlTextWriterStartAttributeNS : out of memory!\n");
1880                 xmlFree(p);
1881                 return -1;
1882             }
1883             p->elem = xmlListFront(writer->nodes);
1884
1885             xmlListPushFront(writer->nsstack, p);
1886         }
1887     }
1888
1889     buf = NULL;
1890     if (prefix != 0) {
1891         buf = xmlStrdup(prefix);
1892         buf = xmlStrcat(buf, BAD_CAST ":");
1893     }
1894     buf = xmlStrcat(buf, name);
1895
1896     sum = 0;
1897     count = xmlTextWriterStartAttribute(writer, buf);
1898     xmlFree(buf);
1899     if (count < 0)
1900         return -1;
1901     sum += count;
1902
1903     return sum;
1904 }
1905
1906 /**
1907  * xmlTextWriterEndAttribute:
1908  * @writer:  the xmlTextWriterPtr
1909  *
1910  * End the current xml element.
1911  *
1912  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1913  */
1914 int
1915 xmlTextWriterEndAttribute(xmlTextWriterPtr writer)
1916 {
1917     int count;
1918     int sum;
1919     xmlLinkPtr lk;
1920     xmlTextWriterStackEntry *p;
1921
1922     if (writer == NULL)
1923         return -1;
1924
1925     lk = xmlListFront(writer->nodes);
1926     if (lk == 0) {
1927         return -1;
1928     }
1929
1930     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1931     if (p == 0) {
1932         return -1;
1933     }
1934
1935     sum = 0;
1936     switch (p->state) {
1937         case XML_TEXTWRITER_ATTRIBUTE:
1938             p->state = XML_TEXTWRITER_NAME;
1939
1940             count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
1941             if (count < 0) {
1942                 return -1;
1943             }
1944             sum += count;
1945             break;
1946         default:
1947             return -1;
1948     }
1949
1950     return sum;
1951 }
1952
1953 /**
1954  * xmlTextWriterWriteFormatAttribute:
1955  * @writer:  the xmlTextWriterPtr
1956  * @name:  attribute name
1957  * @format:  format string (see printf)
1958  * @...:  extra parameters for the format
1959  *
1960  * Write a formatted xml attribute.
1961  *
1962  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1963  */
1964 int XMLCDECL
1965 xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
1966                                   const xmlChar * name, const char *format,
1967                                   ...)
1968 {
1969     int rc;
1970     va_list ap;
1971
1972     va_start(ap, format);
1973
1974     rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);
1975
1976     va_end(ap);
1977     return rc;
1978 }
1979
1980 /**
1981  * xmlTextWriterWriteVFormatAttribute:
1982  * @writer:  the xmlTextWriterPtr
1983  * @name:  attribute name
1984  * @format:  format string (see printf)
1985  * @argptr:  pointer to the first member of the variable argument list.
1986  *
1987  * Write a formatted xml attribute.
1988  *
1989  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1990  */
1991 int
1992 xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
1993                                    const xmlChar * name,
1994                                    const char *format, va_list argptr)
1995 {
1996     int rc;
1997     xmlChar *buf;
1998
1999     if (writer == NULL)
2000         return -1;
2001
2002     buf = xmlTextWriterVSprintf(format, argptr);
2003     if (buf == NULL)
2004         return -1;
2005
2006     rc = xmlTextWriterWriteAttribute(writer, name, buf);
2007
2008     xmlFree(buf);
2009     return rc;
2010 }
2011
2012 /**
2013  * xmlTextWriterWriteAttribute:
2014  * @writer:  the xmlTextWriterPtr
2015  * @name:  attribute name
2016  * @content:  attribute content
2017  *
2018  * Write an xml attribute.
2019  *
2020  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2021  */
2022 int
2023 xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, const xmlChar * name,
2024                             const xmlChar * content)
2025 {
2026     int count;
2027     int sum;
2028
2029     sum = 0;
2030     count = xmlTextWriterStartAttribute(writer, name);
2031     if (count < 0)
2032         return -1;
2033     sum += count;
2034     count = xmlTextWriterWriteString(writer, content);
2035     if (count < 0)
2036         return -1;
2037     sum += count;
2038     count = xmlTextWriterEndAttribute(writer);
2039     if (count < 0)
2040         return -1;
2041     sum += count;
2042
2043     return sum;
2044 }
2045
2046 /**
2047  * xmlTextWriterWriteFormatAttributeNS:
2048  * @writer:  the xmlTextWriterPtr
2049  * @prefix:  namespace prefix
2050  * @name:  attribute local name
2051  * @namespaceURI:  namespace URI
2052  * @format:  format string (see printf)
2053  * @...:  extra parameters for the format
2054  *
2055  * Write a formatted xml attribute.with namespace support
2056  *
2057  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2058  */
2059 int XMLCDECL
2060 xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
2061                                     const xmlChar * prefix,
2062                                     const xmlChar * name,
2063                                     const xmlChar * namespaceURI,
2064                                     const char *format, ...)
2065 {
2066     int rc;
2067     va_list ap;
2068
2069     va_start(ap, format);
2070
2071     rc = xmlTextWriterWriteVFormatAttributeNS(writer, prefix, name,
2072                                               namespaceURI, format, ap);
2073
2074     va_end(ap);
2075     return rc;
2076 }
2077
2078 /**
2079  * xmlTextWriterWriteVFormatAttributeNS:
2080  * @writer:  the xmlTextWriterPtr
2081  * @prefix:  namespace prefix
2082  * @name:  attribute local name
2083  * @namespaceURI:  namespace URI
2084  * @format:  format string (see printf)
2085  * @argptr:  pointer to the first member of the variable argument list.
2086  *
2087  * Write a formatted xml attribute.with namespace support
2088  *
2089  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2090  */
2091 int
2092 xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
2093                                      const xmlChar * prefix,
2094                                      const xmlChar * name,
2095                                      const xmlChar * namespaceURI,
2096                                      const char *format, va_list argptr)
2097 {
2098     int rc;
2099     xmlChar *buf;
2100
2101     if (writer == NULL)
2102         return -1;
2103
2104     buf = xmlTextWriterVSprintf(format, argptr);
2105     if (buf == NULL)
2106         return -1;
2107
2108     rc = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI,
2109                                        buf);
2110
2111     xmlFree(buf);
2112     return rc;
2113 }
2114
2115 /**
2116  * xmlTextWriterWriteAttributeNS:
2117  * @writer:  the xmlTextWriterPtr
2118  * @prefix:  namespace prefix
2119  * @name:  attribute local name
2120  * @namespaceURI:  namespace URI
2121  * @content:  attribute content
2122  *
2123  * Write an xml attribute.
2124  *
2125  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2126  */
2127 int
2128 xmlTextWriterWriteAttributeNS(xmlTextWriterPtr writer,
2129                               const xmlChar * prefix, const xmlChar * name,
2130                               const xmlChar * namespaceURI,
2131                               const xmlChar * content)
2132 {
2133     int count;
2134     int sum;
2135
2136     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
2137         return -1;
2138
2139     sum = 0;
2140     count = xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
2141     if (count < 0)
2142         return -1;
2143     sum += count;
2144     count = xmlTextWriterWriteString(writer, content);
2145     if (count < 0)
2146         return -1;
2147     sum += count;
2148     count = xmlTextWriterEndAttribute(writer);
2149     if (count < 0)
2150         return -1;
2151     sum += count;
2152
2153     return sum;
2154 }
2155
2156 /**
2157  * xmlTextWriterWriteFormatElement:
2158  * @writer:  the xmlTextWriterPtr
2159  * @name:  element name
2160  * @format:  format string (see printf)
2161  * @...:  extra parameters for the format
2162  *
2163  * Write a formatted xml element.
2164  *
2165  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2166  */
2167 int XMLCDECL
2168 xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
2169                                 const xmlChar * name, const char *format,
2170                                 ...)
2171 {
2172     int rc;
2173     va_list ap;
2174
2175     va_start(ap, format);
2176
2177     rc = xmlTextWriterWriteVFormatElement(writer, name, format, ap);
2178
2179     va_end(ap);
2180     return rc;
2181 }
2182
2183 /**
2184  * xmlTextWriterWriteVFormatElement:
2185  * @writer:  the xmlTextWriterPtr
2186  * @name:  element name
2187  * @format:  format string (see printf)
2188  * @argptr:  pointer to the first member of the variable argument list.
2189  *
2190  * Write a formatted xml element.
2191  *
2192  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2193  */
2194 int
2195 xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
2196                                  const xmlChar * name, const char *format,
2197                                  va_list argptr)
2198 {
2199     int rc;
2200     xmlChar *buf;
2201
2202     if (writer == NULL)
2203         return -1;
2204
2205     buf = xmlTextWriterVSprintf(format, argptr);
2206     if (buf == NULL)
2207         return -1;
2208
2209     rc = xmlTextWriterWriteElement(writer, name, buf);
2210
2211     xmlFree(buf);
2212     return rc;
2213 }
2214
2215 /**
2216  * xmlTextWriterWriteElement:
2217  * @writer:  the xmlTextWriterPtr
2218  * @name:  element name
2219  * @content:  element content
2220  *
2221  * Write an xml element.
2222  *
2223  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2224  */
2225 int
2226 xmlTextWriterWriteElement(xmlTextWriterPtr writer, const xmlChar * name,
2227                           const xmlChar * content)
2228 {
2229     int count;
2230     int sum;
2231
2232     sum = 0;
2233     count = xmlTextWriterStartElement(writer, name);
2234     if (count == -1)
2235         return -1;
2236     sum += count;
2237     count = xmlTextWriterWriteString(writer, content);
2238     if (count == -1)
2239         return -1;
2240     sum += count;
2241     count = xmlTextWriterEndElement(writer);
2242     if (count == -1)
2243         return -1;
2244     sum += count;
2245
2246     return sum;
2247 }
2248
2249 /**
2250  * xmlTextWriterWriteFormatElementNS:
2251  * @writer:  the xmlTextWriterPtr
2252  * @prefix:  namespace prefix
2253  * @name:  element local name
2254  * @namespaceURI:  namespace URI
2255  * @format:  format string (see printf)
2256  * @...:  extra parameters for the format
2257  *
2258  * Write a formatted xml element with namespace support.
2259  *
2260  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2261  */
2262 int XMLCDECL
2263 xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
2264                                   const xmlChar * prefix,
2265                                   const xmlChar * name,
2266                                   const xmlChar * namespaceURI,
2267                                   const char *format, ...)
2268 {
2269     int rc;
2270     va_list ap;
2271
2272     va_start(ap, format);
2273
2274     rc = xmlTextWriterWriteVFormatElementNS(writer, prefix, name,
2275                                             namespaceURI, format, ap);
2276
2277     va_end(ap);
2278     return rc;
2279 }
2280
2281 /**
2282  * xmlTextWriterWriteVFormatElementNS:
2283  * @writer:  the xmlTextWriterPtr
2284  * @prefix:  namespace prefix
2285  * @name:  element local name
2286  * @namespaceURI:  namespace URI
2287  * @format:  format string (see printf)
2288  * @argptr:  pointer to the first member of the variable argument list.
2289  *
2290  * Write a formatted xml element with namespace support.
2291  *
2292  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2293  */
2294 int
2295 xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
2296                                    const xmlChar * prefix,
2297                                    const xmlChar * name,
2298                                    const xmlChar * namespaceURI,
2299                                    const char *format, va_list argptr)
2300 {
2301     int rc;
2302     xmlChar *buf;
2303
2304     if (writer == NULL)
2305         return -1;
2306
2307     buf = xmlTextWriterVSprintf(format, argptr);
2308     if (buf == NULL)
2309         return -1;
2310
2311     rc = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI,
2312                                      buf);
2313
2314     xmlFree(buf);
2315     return rc;
2316 }
2317
2318 /**
2319  * xmlTextWriterWriteElementNS:
2320  * @writer:  the xmlTextWriterPtr
2321  * @prefix:  namespace prefix
2322  * @name:  element local name
2323  * @namespaceURI:  namespace URI
2324  * @content:  element content
2325  *
2326  * Write an xml element with namespace support.
2327  *
2328  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2329  */
2330 int
2331 xmlTextWriterWriteElementNS(xmlTextWriterPtr writer,
2332                             const xmlChar * prefix, const xmlChar * name,
2333                             const xmlChar * namespaceURI,
2334                             const xmlChar * content)
2335 {
2336     int count;
2337     int sum;
2338
2339     if ((writer == NULL) || (name == NULL) || (*name == '\0'))
2340         return -1;
2341
2342     sum = 0;
2343     count =
2344         xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
2345     if (count < 0)
2346         return -1;
2347     sum += count;
2348     count = xmlTextWriterWriteString(writer, content);
2349     if (count == -1)
2350         return -1;
2351     sum += count;
2352     count = xmlTextWriterEndElement(writer);
2353     if (count == -1)
2354         return -1;
2355     sum += count;
2356
2357     return sum;
2358 }
2359
2360 /**
2361  * xmlTextWriterStartPI:
2362  * @writer:  the xmlTextWriterPtr
2363  * @target:  PI target
2364  *
2365  * Start an xml PI.
2366  *
2367  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2368  */
2369 int
2370 xmlTextWriterStartPI(xmlTextWriterPtr writer, const xmlChar * target)
2371 {
2372     int count;
2373     int sum;
2374     xmlLinkPtr lk;
2375     xmlTextWriterStackEntry *p;
2376
2377     if ((writer == NULL) || (target == NULL) || (*target == '\0'))
2378         return -1;
2379
2380     if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
2381         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2382                         "xmlTextWriterStartPI : target name [Xx][Mm][Ll] is reserved for xml standardization!\n");
2383         return -1;
2384     }
2385
2386     sum = 0;
2387     lk = xmlListFront(writer->nodes);
2388     if (lk != 0) {
2389         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2390         if (p != 0) {
2391             switch (p->state) {
2392                 case XML_TEXTWRITER_ATTRIBUTE:
2393                     count = xmlTextWriterEndAttribute(writer);
2394                     if (count < 0)
2395                         return -1;
2396                     sum += count;
2397                     /* fallthrough */
2398                 case XML_TEXTWRITER_NAME:
2399                     /* Output namespace declarations */
2400                     count = xmlTextWriterOutputNSDecl(writer);
2401                     if (count < 0)
2402                         return -1;
2403                     sum += count;
2404                     count = xmlOutputBufferWriteString(writer->out, ">");
2405                     if (count < 0)
2406                         return -1;
2407                     sum += count;
2408                     p->state = XML_TEXTWRITER_TEXT;
2409                     break;
2410                 case XML_TEXTWRITER_NONE:
2411                 case XML_TEXTWRITER_TEXT:
2412                 case XML_TEXTWRITER_DTD:
2413                     break;
2414                 case XML_TEXTWRITER_PI:
2415                 case XML_TEXTWRITER_PI_TEXT:
2416                     xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2417                                     "xmlTextWriterStartPI : nested PI!\n");
2418                     return -1;
2419                 default:
2420                     return -1;
2421             }
2422         }
2423     }
2424
2425     p = (xmlTextWriterStackEntry *)
2426         xmlMalloc(sizeof(xmlTextWriterStackEntry));
2427     if (p == 0) {
2428         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2429                         "xmlTextWriterStartPI : out of memory!\n");
2430         return -1;
2431     }
2432
2433     p->name = xmlStrdup(target);
2434     if (p->name == 0) {
2435         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2436                         "xmlTextWriterStartPI : out of memory!\n");
2437         xmlFree(p);
2438         return -1;
2439     }
2440     p->state = XML_TEXTWRITER_PI;
2441
2442     xmlListPushFront(writer->nodes, p);
2443
2444     count = xmlOutputBufferWriteString(writer->out, "<?");
2445     if (count < 0)
2446         return -1;
2447     sum += count;
2448     count =
2449         xmlOutputBufferWriteString(writer->out, (const char *) p->name);
2450     if (count < 0)
2451         return -1;
2452     sum += count;
2453
2454     return sum;
2455 }
2456
2457 /**
2458  * xmlTextWriterEndPI:
2459  * @writer:  the xmlTextWriterPtr
2460  *
2461  * End the current xml PI.
2462  *
2463  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2464  */
2465 int
2466 xmlTextWriterEndPI(xmlTextWriterPtr writer)
2467 {
2468     int count;
2469     int sum;
2470     xmlLinkPtr lk;
2471     xmlTextWriterStackEntry *p;
2472
2473     if (writer == NULL)
2474         return -1;
2475
2476     lk = xmlListFront(writer->nodes);
2477     if (lk == 0)
2478         return 0;
2479
2480     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2481     if (p == 0)
2482         return 0;
2483
2484     sum = 0;
2485     switch (p->state) {
2486         case XML_TEXTWRITER_PI:
2487         case XML_TEXTWRITER_PI_TEXT:
2488             count = xmlOutputBufferWriteString(writer->out, "?>");
2489             if (count < 0)
2490                 return -1;
2491             sum += count;
2492             break;
2493         default:
2494             return -1;
2495     }
2496
2497     if (writer->indent) {
2498         count = xmlOutputBufferWriteString(writer->out, "\n");
2499         if (count < 0)
2500         return -1;
2501         sum += count;
2502     }
2503
2504     xmlListPopFront(writer->nodes);
2505     return sum;
2506 }
2507
2508 /**
2509  * xmlTextWriterWriteFormatPI:
2510  * @writer:  the xmlTextWriterPtr
2511  * @target:  PI target
2512  * @format:  format string (see printf)
2513  * @...:  extra parameters for the format
2514  *
2515  * Write a formatted PI.
2516  *
2517  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2518  */
2519 int XMLCDECL
2520 xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, const xmlChar * target,
2521                            const char *format, ...)
2522 {
2523     int rc;
2524     va_list ap;
2525
2526     va_start(ap, format);
2527
2528     rc = xmlTextWriterWriteVFormatPI(writer, target, format, ap);
2529
2530     va_end(ap);
2531     return rc;
2532 }
2533
2534 /**
2535  * xmlTextWriterWriteVFormatPI:
2536  * @writer:  the xmlTextWriterPtr
2537  * @target:  PI target
2538  * @format:  format string (see printf)
2539  * @argptr:  pointer to the first member of the variable argument list.
2540  *
2541  * Write a formatted xml PI.
2542  *
2543  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2544  */
2545 int
2546 xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
2547                             const xmlChar * target, const char *format,
2548                             va_list argptr)
2549 {
2550     int rc;
2551     xmlChar *buf;
2552
2553     if (writer == NULL)
2554         return -1;
2555
2556     buf = xmlTextWriterVSprintf(format, argptr);
2557     if (buf == NULL)
2558         return -1;
2559
2560     rc = xmlTextWriterWritePI(writer, target, buf);
2561
2562     xmlFree(buf);
2563     return rc;
2564 }
2565
2566 /**
2567  * xmlTextWriterWritePI:
2568  * @writer:  the xmlTextWriterPtr
2569  * @target:  PI target
2570  * @content:  PI content
2571  *
2572  * Write an xml PI.
2573  *
2574  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2575  */
2576 int
2577 xmlTextWriterWritePI(xmlTextWriterPtr writer, const xmlChar * target,
2578                      const xmlChar * content)
2579 {
2580     int count;
2581     int sum;
2582
2583     sum = 0;
2584     count = xmlTextWriterStartPI(writer, target);
2585     if (count == -1)
2586         return -1;
2587     sum += count;
2588     if (content != 0) {
2589         count = xmlTextWriterWriteString(writer, content);
2590         if (count == -1)
2591             return -1;
2592         sum += count;
2593     }
2594     count = xmlTextWriterEndPI(writer);
2595     if (count == -1)
2596         return -1;
2597     sum += count;
2598
2599     return sum;
2600 }
2601
2602 /**
2603  * xmlTextWriterStartCDATA:
2604  * @writer:  the xmlTextWriterPtr
2605  *
2606  * Start an xml CDATA section.
2607  *
2608  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2609  */
2610 int
2611 xmlTextWriterStartCDATA(xmlTextWriterPtr writer)
2612 {
2613     int count;
2614     int sum;
2615     xmlLinkPtr lk;
2616     xmlTextWriterStackEntry *p;
2617
2618     if (writer == NULL)
2619         return -1;
2620
2621     sum = 0;
2622     lk = xmlListFront(writer->nodes);
2623     if (lk != 0) {
2624         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2625         if (p != 0) {
2626             switch (p->state) {
2627                 case XML_TEXTWRITER_NONE:
2628                 case XML_TEXTWRITER_TEXT:
2629                 case XML_TEXTWRITER_PI:
2630                 case XML_TEXTWRITER_PI_TEXT:
2631                     break;
2632                 case XML_TEXTWRITER_ATTRIBUTE:
2633                     count = xmlTextWriterEndAttribute(writer);
2634                     if (count < 0)
2635                         return -1;
2636                     sum += count;
2637                     /* fallthrough */
2638                 case XML_TEXTWRITER_NAME:
2639                     /* Output namespace declarations */
2640                     count = xmlTextWriterOutputNSDecl(writer);
2641                     if (count < 0)
2642                         return -1;
2643                     sum += count;
2644                     count = xmlOutputBufferWriteString(writer->out, ">");
2645                     if (count < 0)
2646                         return -1;
2647                     sum += count;
2648                     p->state = XML_TEXTWRITER_TEXT;
2649                     break;
2650                 case XML_TEXTWRITER_CDATA:
2651                     xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2652                                     "xmlTextWriterStartCDATA : CDATA not allowed in this context!\n");
2653                     return -1;
2654                 default:
2655                     return -1;
2656             }
2657         }
2658     }
2659
2660     p = (xmlTextWriterStackEntry *)
2661         xmlMalloc(sizeof(xmlTextWriterStackEntry));
2662     if (p == 0) {
2663         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2664                         "xmlTextWriterStartCDATA : out of memory!\n");
2665         return -1;
2666     }
2667
2668     p->name = NULL;
2669     p->state = XML_TEXTWRITER_CDATA;
2670
2671     xmlListPushFront(writer->nodes, p);
2672
2673     count = xmlOutputBufferWriteString(writer->out, "<![CDATA[");
2674     if (count < 0)
2675         return -1;
2676     sum += count;
2677
2678     return sum;
2679 }
2680
2681 /**
2682  * xmlTextWriterEndCDATA:
2683  * @writer:  the xmlTextWriterPtr
2684  *
2685  * End an xml CDATA section.
2686  *
2687  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2688  */
2689 int
2690 xmlTextWriterEndCDATA(xmlTextWriterPtr writer)
2691 {
2692     int count;
2693     int sum;
2694     xmlLinkPtr lk;
2695     xmlTextWriterStackEntry *p;
2696
2697     if (writer == NULL)
2698         return -1;
2699
2700     lk = xmlListFront(writer->nodes);
2701     if (lk == 0)
2702         return -1;
2703
2704     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2705     if (p == 0)
2706         return -1;
2707
2708     sum = 0;
2709     switch (p->state) {
2710         case XML_TEXTWRITER_CDATA:
2711             count = xmlOutputBufferWriteString(writer->out, "]]>");
2712             if (count < 0)
2713                 return -1;
2714             sum += count;
2715             break;
2716         default:
2717             return -1;
2718     }
2719
2720     xmlListPopFront(writer->nodes);
2721     return sum;
2722 }
2723
2724 /**
2725  * xmlTextWriterWriteFormatCDATA:
2726  * @writer:  the xmlTextWriterPtr
2727  * @format:  format string (see printf)
2728  * @...:  extra parameters for the format
2729  *
2730  * Write a formatted xml CDATA.
2731  *
2732  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2733  */
2734 int XMLCDECL
2735 xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, const char *format,
2736                               ...)
2737 {
2738     int rc;
2739     va_list ap;
2740
2741     va_start(ap, format);
2742
2743     rc = xmlTextWriterWriteVFormatCDATA(writer, format, ap);
2744
2745     va_end(ap);
2746     return rc;
2747 }
2748
2749 /**
2750  * xmlTextWriterWriteVFormatCDATA:
2751  * @writer:  the xmlTextWriterPtr
2752  * @format:  format string (see printf)
2753  * @argptr:  pointer to the first member of the variable argument list.
2754  *
2755  * Write a formatted xml CDATA.
2756  *
2757  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2758  */
2759 int
2760 xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, const char *format,
2761                                va_list argptr)
2762 {
2763     int rc;
2764     xmlChar *buf;
2765
2766     if (writer == NULL)
2767         return -1;
2768
2769     buf = xmlTextWriterVSprintf(format, argptr);
2770     if (buf == NULL)
2771         return -1;
2772
2773     rc = xmlTextWriterWriteCDATA(writer, buf);
2774
2775     xmlFree(buf);
2776     return rc;
2777 }
2778
2779 /**
2780  * xmlTextWriterWriteCDATA:
2781  * @writer:  the xmlTextWriterPtr
2782  * @content:  CDATA content
2783  *
2784  * Write an xml CDATA.
2785  *
2786  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2787  */
2788 int
2789 xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, const xmlChar * content)
2790 {
2791     int count;
2792     int sum;
2793
2794     sum = 0;
2795     count = xmlTextWriterStartCDATA(writer);
2796     if (count == -1)
2797         return -1;
2798     sum += count;
2799     if (content != 0) {
2800         count = xmlTextWriterWriteString(writer, content);
2801         if (count == -1)
2802             return -1;
2803         sum += count;
2804     }
2805     count = xmlTextWriterEndCDATA(writer);
2806     if (count == -1)
2807         return -1;
2808     sum += count;
2809
2810     return sum;
2811 }
2812
2813 /**
2814  * xmlTextWriterStartDTD:
2815  * @writer:  the xmlTextWriterPtr
2816  * @name:  the name of the DTD
2817  * @pubid:  the public identifier, which is an alternative to the system identifier
2818  * @sysid:  the system identifier, which is the URI of the DTD
2819  *
2820  * Start an xml DTD.
2821  *
2822  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2823  */
2824 int
2825 xmlTextWriterStartDTD(xmlTextWriterPtr writer,
2826                       const xmlChar * name,
2827                       const xmlChar * pubid, const xmlChar * sysid)
2828 {
2829     int count;
2830     int sum;
2831     xmlLinkPtr lk;
2832     xmlTextWriterStackEntry *p;
2833
2834     if (writer == NULL || name == NULL || *name == '\0')
2835         return -1;
2836
2837     sum = 0;
2838     lk = xmlListFront(writer->nodes);
2839     if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
2840         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2841                         "xmlTextWriterStartDTD : DTD allowed only in prolog!\n");
2842         return -1;
2843     }
2844
2845     p = (xmlTextWriterStackEntry *)
2846         xmlMalloc(sizeof(xmlTextWriterStackEntry));
2847     if (p == 0) {
2848         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2849                         "xmlTextWriterStartDTD : out of memory!\n");
2850         return -1;
2851     }
2852
2853     p->name = xmlStrdup(name);
2854     if (p->name == 0) {
2855         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2856                         "xmlTextWriterStartDTD : out of memory!\n");
2857         xmlFree(p);
2858         return -1;
2859     }
2860     p->state = XML_TEXTWRITER_DTD;
2861
2862     xmlListPushFront(writer->nodes, p);
2863
2864     count = xmlOutputBufferWriteString(writer->out, "<!DOCTYPE ");
2865     if (count < 0)
2866         return -1;
2867     sum += count;
2868     count = xmlOutputBufferWriteString(writer->out, (const char *) name);
2869     if (count < 0)
2870         return -1;
2871     sum += count;
2872
2873     if (pubid != 0) {
2874         if (sysid == 0) {
2875             xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2876                             "xmlTextWriterStartDTD : system identifier needed!\n");
2877             return -1;
2878         }
2879
2880         if (writer->indent)
2881             count = xmlOutputBufferWrite(writer->out, 1, "\n");
2882         else
2883             count = xmlOutputBufferWrite(writer->out, 1, " ");
2884         if (count < 0)
2885             return -1;
2886         sum += count;
2887
2888         count = xmlOutputBufferWriteString(writer->out, "PUBLIC ");
2889         if (count < 0)
2890             return -1;
2891         sum += count;
2892
2893         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2894         if (count < 0)
2895             return -1;
2896         sum += count;
2897
2898         count =
2899             xmlOutputBufferWriteString(writer->out, (const char *) pubid);
2900         if (count < 0)
2901             return -1;
2902         sum += count;
2903
2904         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2905         if (count < 0)
2906             return -1;
2907         sum += count;
2908     }
2909
2910     if (sysid != 0) {
2911         if (pubid == 0) {
2912             if (writer->indent)
2913                 count = xmlOutputBufferWrite(writer->out, 1, "\n");
2914             else
2915                 count = xmlOutputBufferWrite(writer->out, 1, " ");
2916             if (count < 0)
2917                 return -1;
2918             sum += count;
2919             count = xmlOutputBufferWriteString(writer->out, "SYSTEM ");
2920             if (count < 0)
2921                 return -1;
2922             sum += count;
2923         } else {
2924                         if (writer->indent)
2925             count = xmlOutputBufferWriteString(writer->out, "\n       ");
2926             else
2927                 count = xmlOutputBufferWrite(writer->out, 1, " ");
2928             if (count < 0)
2929                 return -1;
2930             sum += count;
2931         }
2932
2933         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2934         if (count < 0)
2935             return -1;
2936         sum += count;
2937
2938         count =
2939             xmlOutputBufferWriteString(writer->out, (const char *) sysid);
2940         if (count < 0)
2941             return -1;
2942         sum += count;
2943
2944         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2945         if (count < 0)
2946             return -1;
2947         sum += count;
2948     }
2949
2950     return sum;
2951 }
2952
2953 /**
2954  * xmlTextWriterEndDTD:
2955  * @writer:  the xmlTextWriterPtr
2956  *
2957  * End an xml DTD.
2958  *
2959  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2960  */
2961 int
2962 xmlTextWriterEndDTD(xmlTextWriterPtr writer)
2963 {
2964     int loop;
2965     int count;
2966     int sum;
2967     xmlLinkPtr lk;
2968     xmlTextWriterStackEntry *p;
2969
2970     if (writer == NULL)
2971         return -1;
2972
2973     sum = 0;
2974     loop = 1;
2975     while (loop) {
2976         lk = xmlListFront(writer->nodes);
2977         if (lk == NULL)
2978             break;
2979         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2980         if (p == 0)
2981             break;
2982         switch (p->state) {
2983             case XML_TEXTWRITER_DTD_TEXT:
2984                 count = xmlOutputBufferWriteString(writer->out, "]");
2985                 if (count < 0)
2986                     return -1;
2987                 sum += count;
2988                 /* fallthrough */
2989             case XML_TEXTWRITER_DTD:
2990                 count = xmlOutputBufferWriteString(writer->out, ">");
2991
2992                 if (writer->indent) {
2993                     if (count < 0)
2994                         return -1;
2995                     sum += count;
2996                     count = xmlOutputBufferWriteString(writer->out, "\n");
2997                 }
2998
2999                 xmlListPopFront(writer->nodes);
3000                 break;
3001             case XML_TEXTWRITER_DTD_ELEM:
3002             case XML_TEXTWRITER_DTD_ELEM_TEXT:
3003                 count = xmlTextWriterEndDTDElement(writer);
3004                 break;
3005             case XML_TEXTWRITER_DTD_ATTL:
3006             case XML_TEXTWRITER_DTD_ATTL_TEXT:
3007                 count = xmlTextWriterEndDTDAttlist(writer);
3008                 break;
3009             case XML_TEXTWRITER_DTD_ENTY:
3010             case XML_TEXTWRITER_DTD_PENT:
3011             case XML_TEXTWRITER_DTD_ENTY_TEXT:
3012                 count = xmlTextWriterEndDTDEntity(writer);
3013                 break;
3014             case XML_TEXTWRITER_COMMENT:
3015                 count = xmlTextWriterEndComment(writer);
3016                 break;
3017             default:
3018                 loop = 0;
3019                 continue;
3020         }
3021
3022         if (count < 0)
3023             return -1;
3024         sum += count;
3025     }
3026
3027     return sum;
3028 }
3029
3030 /**
3031  * xmlTextWriterWriteFormatDTD:
3032  * @writer:  the xmlTextWriterPtr
3033  * @name:  the name of the DTD
3034  * @pubid:  the public identifier, which is an alternative to the system identifier
3035  * @sysid:  the system identifier, which is the URI of the DTD
3036  * @format:  format string (see printf)
3037  * @...:  extra parameters for the format
3038  *
3039  * Write a DTD with a formatted markup declarations part.
3040  *
3041  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3042  */
3043 int XMLCDECL
3044 xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
3045                             const xmlChar * name,
3046                             const xmlChar * pubid,
3047                             const xmlChar * sysid, const char *format, ...)
3048 {
3049     int rc;
3050     va_list ap;
3051
3052     va_start(ap, format);
3053
3054     rc = xmlTextWriterWriteVFormatDTD(writer, name, pubid, sysid, format,
3055                                       ap);
3056
3057     va_end(ap);
3058     return rc;
3059 }
3060
3061 /**
3062  * xmlTextWriterWriteVFormatDTD:
3063  * @writer:  the xmlTextWriterPtr
3064  * @name:  the name of the DTD
3065  * @pubid:  the public identifier, which is an alternative to the system identifier
3066  * @sysid:  the system identifier, which is the URI of the DTD
3067  * @format:  format string (see printf)
3068  * @argptr:  pointer to the first member of the variable argument list.
3069  *
3070  * Write a DTD with a formatted markup declarations part.
3071  *
3072  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3073  */
3074 int
3075 xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
3076                              const xmlChar * name,
3077                              const xmlChar * pubid,
3078                              const xmlChar * sysid,
3079                              const char *format, va_list argptr)
3080 {
3081     int rc;
3082     xmlChar *buf;
3083
3084     if (writer == NULL)
3085         return -1;
3086
3087     buf = xmlTextWriterVSprintf(format, argptr);
3088     if (buf == NULL)
3089         return -1;
3090
3091     rc = xmlTextWriterWriteDTD(writer, name, pubid, sysid, buf);
3092
3093     xmlFree(buf);
3094     return rc;
3095 }
3096
3097 /**
3098  * xmlTextWriterWriteDTD:
3099  * @writer:  the xmlTextWriterPtr
3100  * @name:  the name of the DTD
3101  * @pubid:  the public identifier, which is an alternative to the system identifier
3102  * @sysid:  the system identifier, which is the URI of the DTD
3103  * @subset:  string content of the DTD
3104  *
3105  * Write a DTD.
3106  *
3107  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3108  */
3109 int
3110 xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
3111                       const xmlChar * name,
3112                       const xmlChar * pubid,
3113                       const xmlChar * sysid, const xmlChar * subset)
3114 {
3115     int count;
3116     int sum;
3117
3118     sum = 0;
3119     count = xmlTextWriterStartDTD(writer, name, pubid, sysid);
3120     if (count == -1)
3121         return -1;
3122     sum += count;
3123     if (subset != 0) {
3124         count = xmlTextWriterWriteString(writer, subset);
3125         if (count == -1)
3126             return -1;
3127         sum += count;
3128     }
3129     count = xmlTextWriterEndDTD(writer);
3130     if (count == -1)
3131         return -1;
3132     sum += count;
3133
3134     return sum;
3135 }
3136
3137 /**
3138  * xmlTextWriterStartDTDElement:
3139  * @writer:  the xmlTextWriterPtr
3140  * @name:  the name of the DTD element
3141  *
3142  * Start an xml DTD element.
3143  *
3144  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3145  */
3146 int
3147 xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, const xmlChar * name)
3148 {
3149     int count;
3150     int sum;
3151     xmlLinkPtr lk;
3152     xmlTextWriterStackEntry *p;
3153
3154     if (writer == NULL || name == NULL || *name == '\0')
3155         return -1;
3156
3157     sum = 0;
3158     lk = xmlListFront(writer->nodes);
3159     if (lk == 0) {
3160         return -1;
3161     }
3162
3163     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3164     if (p != 0) {
3165         switch (p->state) {
3166             case XML_TEXTWRITER_DTD:
3167                 count = xmlOutputBufferWriteString(writer->out, " [");
3168                 if (count < 0)
3169                     return -1;
3170                 sum += count;
3171                 if (writer->indent) {
3172                     count = xmlOutputBufferWriteString(writer->out, "\n");
3173                     if (count < 0)
3174                         return -1;
3175                     sum += count;
3176                 }
3177                 p->state = XML_TEXTWRITER_DTD_TEXT;
3178                 /* fallthrough */
3179             case XML_TEXTWRITER_DTD_TEXT:
3180             case XML_TEXTWRITER_NONE:
3181                 break;
3182             default:
3183                 return -1;
3184         }
3185     }
3186
3187     p = (xmlTextWriterStackEntry *)
3188         xmlMalloc(sizeof(xmlTextWriterStackEntry));
3189     if (p == 0) {
3190         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3191                         "xmlTextWriterStartDTDElement : out of memory!\n");
3192         return -1;
3193     }
3194
3195     p->name = xmlStrdup(name);
3196     if (p->name == 0) {
3197         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3198                         "xmlTextWriterStartDTDElement : out of memory!\n");
3199         xmlFree(p);
3200         return -1;
3201     }
3202     p->state = XML_TEXTWRITER_DTD_ELEM;
3203
3204     xmlListPushFront(writer->nodes, p);
3205
3206     if (writer->indent) {
3207         count = xmlTextWriterWriteIndent(writer);
3208         if (count < 0)
3209             return -1;
3210         sum += count;
3211     }
3212
3213     count = xmlOutputBufferWriteString(writer->out, "<!ELEMENT ");
3214     if (count < 0)
3215         return -1;
3216     sum += count;
3217     count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3218     if (count < 0)
3219         return -1;
3220     sum += count;
3221
3222     return sum;
3223 }
3224
3225 /**
3226  * xmlTextWriterEndDTDElement:
3227  * @writer:  the xmlTextWriterPtr
3228  *
3229  * End an xml DTD element.
3230  *
3231  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3232  */
3233 int
3234 xmlTextWriterEndDTDElement(xmlTextWriterPtr writer)
3235 {
3236     int count;
3237     int sum;
3238     xmlLinkPtr lk;
3239     xmlTextWriterStackEntry *p;
3240
3241     if (writer == NULL)
3242         return -1;
3243
3244     sum = 0;
3245     lk = xmlListFront(writer->nodes);
3246     if (lk == 0)
3247         return -1;
3248
3249     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3250     if (p == 0)
3251         return -1;
3252
3253     switch (p->state) {
3254         case XML_TEXTWRITER_DTD_ELEM:
3255         case XML_TEXTWRITER_DTD_ELEM_TEXT:
3256             count = xmlOutputBufferWriteString(writer->out, ">");
3257             if (count < 0)
3258                 return -1;
3259             sum += count;
3260             break;
3261         default:
3262             return -1;
3263     }
3264
3265     if (writer->indent) {
3266         count = xmlOutputBufferWriteString(writer->out, "\n");
3267         if (count < 0)
3268             return -1;
3269         sum += count;
3270     }
3271
3272     xmlListPopFront(writer->nodes);
3273     return sum;
3274 }
3275
3276 /**
3277  * xmlTextWriterWriteFormatDTDElement:
3278  * @writer:  the xmlTextWriterPtr
3279  * @name:  the name of the DTD element
3280  * @format:  format string (see printf)
3281  * @...:  extra parameters for the format
3282  *
3283  * Write a formatted DTD element.
3284  *
3285  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3286  */
3287 int XMLCDECL
3288 xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
3289                                    const xmlChar * name,
3290                                    const char *format, ...)
3291 {
3292     int rc;
3293     va_list ap;
3294
3295     va_start(ap, format);
3296
3297     rc = xmlTextWriterWriteVFormatDTDElement(writer, name, format, ap);
3298
3299     va_end(ap);
3300     return rc;
3301 }
3302
3303 /**
3304  * xmlTextWriterWriteVFormatDTDElement:
3305  * @writer:  the xmlTextWriterPtr
3306  * @name:  the name of the DTD element
3307  * @format:  format string (see printf)
3308  * @argptr:  pointer to the first member of the variable argument list.
3309  *
3310  * Write a formatted DTD element.
3311  *
3312  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3313  */
3314 int
3315 xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
3316                                     const xmlChar * name,
3317                                     const char *format, va_list argptr)
3318 {
3319     int rc;
3320     xmlChar *buf;
3321
3322     if (writer == NULL)
3323         return -1;
3324
3325     buf = xmlTextWriterVSprintf(format, argptr);
3326     if (buf == NULL)
3327         return -1;
3328
3329     rc = xmlTextWriterWriteDTDElement(writer, name, buf);
3330
3331     xmlFree(buf);
3332     return rc;
3333 }
3334
3335 /**
3336  * xmlTextWriterWriteDTDElement:
3337  * @writer:  the xmlTextWriterPtr
3338  * @name:  the name of the DTD element
3339  * @content:  content of the element
3340  *
3341  * Write a DTD element.
3342  *
3343  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3344  */
3345 int
3346 xmlTextWriterWriteDTDElement(xmlTextWriterPtr writer,
3347                              const xmlChar * name, const xmlChar * content)
3348 {
3349     int count;
3350     int sum;
3351
3352     if (content == NULL)
3353         return -1;
3354
3355     sum = 0;
3356     count = xmlTextWriterStartDTDElement(writer, name);
3357     if (count == -1)
3358         return -1;
3359     sum += count;
3360
3361     count = xmlTextWriterWriteString(writer, content);
3362     if (count == -1)
3363         return -1;
3364     sum += count;
3365
3366     count = xmlTextWriterEndDTDElement(writer);
3367     if (count == -1)
3368         return -1;
3369     sum += count;
3370
3371     return sum;
3372 }
3373
3374 /**
3375  * xmlTextWriterStartDTDAttlist:
3376  * @writer:  the xmlTextWriterPtr
3377  * @name:  the name of the DTD ATTLIST
3378  *
3379  * Start an xml DTD ATTLIST.
3380  *
3381  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3382  */
3383 int
3384 xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, const xmlChar * name)
3385 {
3386     int count;
3387     int sum;
3388     xmlLinkPtr lk;
3389     xmlTextWriterStackEntry *p;
3390
3391     if (writer == NULL || name == NULL || *name == '\0')
3392         return -1;
3393
3394     sum = 0;
3395     lk = xmlListFront(writer->nodes);
3396     if (lk == 0) {
3397         return -1;
3398     }
3399
3400     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3401     if (p != 0) {
3402         switch (p->state) {
3403             case XML_TEXTWRITER_DTD:
3404                 count = xmlOutputBufferWriteString(writer->out, " [");
3405                 if (count < 0)
3406                     return -1;
3407                 sum += count;
3408                 if (writer->indent) {
3409                     count = xmlOutputBufferWriteString(writer->out, "\n");
3410                     if (count < 0)
3411                         return -1;
3412                     sum += count;
3413                 }
3414                 p->state = XML_TEXTWRITER_DTD_TEXT;
3415                 /* fallthrough */
3416             case XML_TEXTWRITER_DTD_TEXT:
3417             case XML_TEXTWRITER_NONE:
3418                 break;
3419             default:
3420                 return -1;
3421         }
3422     }
3423
3424     p = (xmlTextWriterStackEntry *)
3425         xmlMalloc(sizeof(xmlTextWriterStackEntry));
3426     if (p == 0) {
3427         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3428                         "xmlTextWriterStartDTDAttlist : out of memory!\n");
3429         return -1;
3430     }
3431
3432     p->name = xmlStrdup(name);
3433     if (p->name == 0) {
3434         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3435                         "xmlTextWriterStartDTDAttlist : out of memory!\n");
3436         xmlFree(p);
3437         return -1;
3438     }
3439     p->state = XML_TEXTWRITER_DTD_ATTL;
3440
3441     xmlListPushFront(writer->nodes, p);
3442
3443     if (writer->indent) {
3444         count = xmlTextWriterWriteIndent(writer);
3445         if (count < 0)
3446             return -1;
3447         sum += count;
3448     }
3449
3450     count = xmlOutputBufferWriteString(writer->out, "<!ATTLIST ");
3451     if (count < 0)
3452         return -1;
3453     sum += count;
3454     count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3455     if (count < 0)
3456         return -1;
3457     sum += count;
3458
3459     return sum;
3460 }
3461
3462 /**
3463  * xmlTextWriterEndDTDAttlist:
3464  * @writer:  the xmlTextWriterPtr
3465  *
3466  * End an xml DTD attribute list.
3467  *
3468  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3469  */
3470 int
3471 xmlTextWriterEndDTDAttlist(xmlTextWriterPtr writer)
3472 {
3473     int count;
3474     int sum;
3475     xmlLinkPtr lk;
3476     xmlTextWriterStackEntry *p;
3477
3478     if (writer == NULL)
3479         return -1;
3480
3481     sum = 0;
3482     lk = xmlListFront(writer->nodes);
3483     if (lk == 0)
3484         return -1;
3485
3486     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3487     if (p == 0)
3488         return -1;
3489
3490     switch (p->state) {
3491         case XML_TEXTWRITER_DTD_ATTL:
3492         case XML_TEXTWRITER_DTD_ATTL_TEXT:
3493             count = xmlOutputBufferWriteString(writer->out, ">");
3494             if (count < 0)
3495                 return -1;
3496             sum += count;
3497             break;
3498         default:
3499             return -1;
3500     }
3501
3502     if (writer->indent) {
3503         count = xmlOutputBufferWriteString(writer->out, "\n");
3504         if (count < 0)
3505             return -1;
3506         sum += count;
3507     }
3508
3509     xmlListPopFront(writer->nodes);
3510     return sum;
3511 }
3512
3513 /**
3514  * xmlTextWriterWriteFormatDTDAttlist:
3515  * @writer:  the xmlTextWriterPtr
3516  * @name:  the name of the DTD ATTLIST
3517  * @format:  format string (see printf)
3518  * @...:  extra parameters for the format
3519  *
3520  * Write a formatted DTD ATTLIST.
3521  *
3522  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3523  */
3524 int XMLCDECL
3525 xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
3526                                    const xmlChar * name,
3527                                    const char *format, ...)
3528 {
3529     int rc;
3530     va_list ap;
3531
3532     va_start(ap, format);
3533
3534     rc = xmlTextWriterWriteVFormatDTDAttlist(writer, name, format, ap);
3535
3536     va_end(ap);
3537     return rc;
3538 }
3539
3540 /**
3541  * xmlTextWriterWriteVFormatDTDAttlist:
3542  * @writer:  the xmlTextWriterPtr
3543  * @name:  the name of the DTD ATTLIST
3544  * @format:  format string (see printf)
3545  * @argptr:  pointer to the first member of the variable argument list.
3546  *
3547  * Write a formatted DTD ATTLIST.
3548  *
3549  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3550  */
3551 int
3552 xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
3553                                     const xmlChar * name,
3554                                     const char *format, va_list argptr)
3555 {
3556     int rc;
3557     xmlChar *buf;
3558
3559     if (writer == NULL)
3560         return -1;
3561
3562     buf = xmlTextWriterVSprintf(format, argptr);
3563     if (buf == NULL)
3564         return -1;
3565
3566     rc = xmlTextWriterWriteDTDAttlist(writer, name, buf);
3567
3568     xmlFree(buf);
3569     return rc;
3570 }
3571
3572 /**
3573  * xmlTextWriterWriteDTDAttlist:
3574  * @writer:  the xmlTextWriterPtr
3575  * @name:  the name of the DTD ATTLIST
3576  * @content:  content of the ATTLIST
3577  *
3578  * Write a DTD ATTLIST.
3579  *
3580  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3581  */
3582 int
3583 xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr writer,
3584                              const xmlChar * name, const xmlChar * content)
3585 {
3586     int count;
3587     int sum;
3588
3589     if (content == NULL)
3590         return -1;
3591
3592     sum = 0;
3593     count = xmlTextWriterStartDTDAttlist(writer, name);
3594     if (count == -1)
3595         return -1;
3596     sum += count;
3597
3598     count = xmlTextWriterWriteString(writer, content);
3599     if (count == -1)
3600         return -1;
3601     sum += count;
3602
3603     count = xmlTextWriterEndDTDAttlist(writer);
3604     if (count == -1)
3605         return -1;
3606     sum += count;
3607
3608     return sum;
3609 }
3610
3611 /**
3612  * xmlTextWriterStartDTDEntity:
3613  * @writer:  the xmlTextWriterPtr
3614  * @pe:  TRUE if this is a parameter entity, FALSE if not
3615  * @name:  the name of the DTD ATTLIST
3616  *
3617  * Start an xml DTD ATTLIST.
3618  *
3619  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3620  */
3621 int
3622 xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
3623                             int pe, const xmlChar * name)
3624 {
3625     int count;
3626     int sum;
3627     xmlLinkPtr lk;
3628     xmlTextWriterStackEntry *p;
3629
3630     if (writer == NULL || name == NULL || *name == '\0')
3631         return -1;
3632
3633     sum = 0;
3634     lk = xmlListFront(writer->nodes);
3635     if (lk != 0) {
3636
3637         p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3638         if (p != 0) {
3639             switch (p->state) {
3640                 case XML_TEXTWRITER_DTD:
3641                     count = xmlOutputBufferWriteString(writer->out, " [");
3642                     if (count < 0)
3643                         return -1;
3644                     sum += count;
3645                     if (writer->indent) {
3646                         count =
3647                             xmlOutputBufferWriteString(writer->out, "\n");
3648                         if (count < 0)
3649                             return -1;
3650                         sum += count;
3651                     }
3652                     p->state = XML_TEXTWRITER_DTD_TEXT;
3653                     /* fallthrough */
3654                 case XML_TEXTWRITER_DTD_TEXT:
3655                 case XML_TEXTWRITER_NONE:
3656                     break;
3657                 default:
3658                     return -1;
3659             }
3660         }
3661     }
3662
3663     p = (xmlTextWriterStackEntry *)
3664         xmlMalloc(sizeof(xmlTextWriterStackEntry));
3665     if (p == 0) {
3666         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3667                         "xmlTextWriterStartDTDElement : out of memory!\n");
3668         return -1;
3669     }
3670
3671     p->name = xmlStrdup(name);
3672     if (p->name == 0) {
3673         xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3674                         "xmlTextWriterStartDTDElement : out of memory!\n");
3675         xmlFree(p);
3676         return -1;
3677     }
3678
3679     if (pe != 0)
3680         p->state = XML_TEXTWRITER_DTD_PENT;
3681     else
3682         p->state = XML_TEXTWRITER_DTD_ENTY;
3683
3684     xmlListPushFront(writer->nodes, p);
3685
3686     if (writer->indent) {
3687         count = xmlTextWriterWriteIndent(writer);
3688         if (count < 0)
3689             return -1;
3690         sum += count;
3691     }
3692
3693     count = xmlOutputBufferWriteString(writer->out, "<!ENTITY ");
3694     if (count < 0)
3695         return -1;
3696     sum += count;
3697
3698     if (pe != 0) {
3699         count = xmlOutputBufferWriteString(writer->out, "% ");
3700         if (count < 0)
3701             return -1;
3702         sum += count;
3703     }
3704
3705     count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3706     if (count < 0)
3707         return -1;
3708     sum += count;
3709
3710     return sum;
3711 }
3712
3713 /**
3714  * xmlTextWriterEndDTDEntity:
3715  * @writer:  the xmlTextWriterPtr
3716  *
3717  * End an xml DTD entity.
3718  *
3719  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3720  */
3721 int
3722 xmlTextWriterEndDTDEntity(xmlTextWriterPtr writer)
3723 {
3724     int count;
3725     int sum;
3726     xmlLinkPtr lk;
3727     xmlTextWriterStackEntry *p;
3728
3729     if (writer == NULL)
3730         return -1;
3731
3732     sum = 0;
3733     lk = xmlListFront(writer->nodes);
3734     if (lk == 0)
3735         return -1;
3736
3737     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3738     if (p == 0)
3739         return -1;
3740
3741     switch (p->state) {
3742         case XML_TEXTWRITER_DTD_ENTY_TEXT:
3743             count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
3744             if (count < 0)
3745                 return -1;
3746             sum += count;
3747         case XML_TEXTWRITER_DTD_ENTY:
3748         case XML_TEXTWRITER_DTD_PENT:
3749             count = xmlOutputBufferWriteString(writer->out, ">");
3750             if (count < 0)
3751                 return -1;
3752             sum += count;
3753             break;
3754         default:
3755             return -1;
3756     }
3757
3758     if (writer->indent) {
3759         count = xmlOutputBufferWriteString(writer->out, "\n");
3760         if (count < 0)
3761             return -1;
3762         sum += count;
3763     }
3764
3765     xmlListPopFront(writer->nodes);
3766     return sum;
3767 }
3768
3769 /**
3770  * xmlTextWriterWriteFormatDTDInternalEntity:
3771  * @writer:  the xmlTextWriterPtr
3772  * @pe:  TRUE if this is a parameter entity, FALSE if not
3773  * @name:  the name of the DTD entity
3774  * @format:  format string (see printf)
3775  * @...:  extra parameters for the format
3776  *
3777  * Write a formatted DTD internal entity.
3778  *
3779  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3780  */
3781 int XMLCDECL
3782 xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
3783                                           int pe,
3784                                           const xmlChar * name,
3785                                           const char *format, ...)
3786 {
3787     int rc;
3788     va_list ap;
3789
3790     va_start(ap, format);
3791
3792     rc = xmlTextWriterWriteVFormatDTDInternalEntity(writer, pe, name,
3793                                                     format, ap);
3794
3795     va_end(ap);
3796     return rc;
3797 }
3798
3799 /**
3800  * xmlTextWriterWriteVFormatDTDInternalEntity:
3801  * @writer:  the xmlTextWriterPtr
3802  * @pe:  TRUE if this is a parameter entity, FALSE if not
3803  * @name:  the name of the DTD entity
3804  * @format:  format string (see printf)
3805  * @argptr:  pointer to the first member of the variable argument list.
3806  *
3807  * Write a formatted DTD internal entity.
3808  *
3809  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3810  */
3811 int
3812 xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
3813                                            int pe,
3814                                            const xmlChar * name,
3815                                            const char *format,
3816                                            va_list argptr)
3817 {
3818     int rc;
3819     xmlChar *buf;
3820
3821     if (writer == NULL)
3822         return -1;
3823
3824     buf = xmlTextWriterVSprintf(format, argptr);
3825     if (buf == NULL)
3826         return -1;
3827
3828     rc = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, buf);
3829
3830     xmlFree(buf);
3831     return rc;
3832 }
3833
3834 /**
3835  * xmlTextWriterWriteDTDEntity:
3836  * @writer:  the xmlTextWriterPtr
3837  * @pe:  TRUE if this is a parameter entity, FALSE if not
3838  * @name:  the name of the DTD entity
3839  * @pubid:  the public identifier, which is an alternative to the system identifier
3840  * @sysid:  the system identifier, which is the URI of the DTD
3841  * @ndataid:  the xml notation name.
3842  * @content:  content of the entity
3843  *
3844  * Write a DTD entity.
3845  *
3846  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3847  */
3848 int
3849 xmlTextWriterWriteDTDEntity(xmlTextWriterPtr writer,
3850                             int pe,
3851                             const xmlChar * name,
3852                             const xmlChar * pubid,
3853                             const xmlChar * sysid,
3854                             const xmlChar * ndataid,
3855                             const xmlChar * content)
3856 {
3857     if ((content == NULL) && (pubid == NULL) && (sysid == NULL))
3858         return -1;
3859     if ((pe != 0) && (ndataid != NULL))
3860         return -1;
3861
3862     if ((pubid == NULL) && (sysid == NULL))
3863         return xmlTextWriterWriteDTDInternalEntity(writer, pe, name,
3864                                                    content);
3865
3866     return xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid,
3867                                                sysid, ndataid);
3868 }
3869
3870 /**
3871  * xmlTextWriterWriteDTDInternalEntity:
3872  * @writer:  the xmlTextWriterPtr
3873  * @pe:  TRUE if this is a parameter entity, FALSE if not
3874  * @name:  the name of the DTD entity
3875  * @content:  content of the entity
3876  *
3877  * Write a DTD internal entity.
3878  *
3879  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3880  */
3881 int
3882 xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
3883                                     int pe,
3884                                     const xmlChar * name,
3885                                     const xmlChar * content)
3886 {
3887     int count;
3888     int sum;
3889
3890     if ((name == NULL) || (*name == '\0') || (content == NULL))
3891         return -1;
3892
3893     sum = 0;
3894     count = xmlTextWriterStartDTDEntity(writer, pe, name);
3895     if (count == -1)
3896         return -1;
3897     sum += count;
3898
3899     count = xmlTextWriterWriteString(writer, content);
3900     if (count == -1)
3901         return -1;
3902     sum += count;
3903
3904     count = xmlTextWriterEndDTDEntity(writer);
3905     if (count == -1)
3906         return -1;
3907     sum += count;
3908
3909     return sum;
3910 }
3911
3912 /**
3913  * xmlTextWriterWriteDTDExternalEntity:
3914  * @writer:  the xmlTextWriterPtr
3915  * @pe:  TRUE if this is a parameter entity, FALSE if not
3916  * @name:  the name of the DTD entity
3917  * @pubid:  the public identifier, which is an alternative to the system identifier
3918  * @sysid:  the system identifier, which is the URI of the DTD
3919  * @ndataid:  the xml notation name.
3920  *
3921  * Write a DTD external entity. The entity must have been started with xmlTextWriterStartDTDEntity
3922  *
3923  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3924  */
3925 int
3926 xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
3927                                     int pe,
3928                                     const xmlChar * name,
3929                                     const xmlChar * pubid,
3930                                     const xmlChar * sysid,
3931                                     const xmlChar * ndataid)
3932 {
3933     int count;
3934     int sum;
3935
3936     if (((pubid == NULL) && (sysid == NULL)))
3937         return -1;
3938     if ((pe != 0) && (ndataid != NULL))
3939         return -1;
3940
3941     sum = 0;
3942     count = xmlTextWriterStartDTDEntity(writer, pe, name);
3943     if (count == -1)
3944         return -1;
3945     sum += count;
3946
3947     count =
3948         xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid,
3949                                                     ndataid);
3950     if (count < 0)
3951         return -1;
3952     sum += count;
3953
3954     count = xmlTextWriterEndDTDEntity(writer);
3955     if (count == -1)
3956         return -1;
3957     sum += count;
3958
3959     return sum;
3960 }
3961
3962 /**
3963  * xmlTextWriterWriteDTDExternalEntityContents:
3964  * @writer:  the xmlTextWriterPtr
3965  * @pubid:  the public identifier, which is an alternative to the system identifier
3966  * @sysid:  the system identifier, which is the URI of the DTD
3967  * @ndataid:  the xml notation name.
3968  *
3969  * Write the contents of a DTD external entity.
3970  *
3971  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3972  */
3973 int
3974 xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr writer,
3975                                             const xmlChar * pubid,
3976                                             const xmlChar * sysid,
3977                                             const xmlChar * ndataid)
3978 {
3979     int count;
3980     int sum;
3981     xmlLinkPtr lk;
3982     xmlTextWriterStackEntry *p;
3983
3984     if (writer == NULL) {
3985         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3986                         "xmlTextWriterWriteDTDExternalEntityContents: xmlTextWriterPtr invalid!\n");
3987         return -1;
3988     }
3989
3990     sum = 0;
3991     lk = xmlListFront(writer->nodes);
3992     if (lk == 0) {
3993         xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3994                         "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
3995         return -1;
3996     }
3997
3998     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3999     if (p == 0)
4000         return -1;
4001
4002     switch (p->state) {
4003         case XML_TEXTWRITER_DTD_ENTY:
4004             break;
4005         case XML_TEXTWRITER_DTD_PENT:
4006             if (ndataid != NULL) {
4007                 xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
4008                                 "xmlTextWriterWriteDTDExternalEntityContents: notation not allowed with parameter entities!\n");
4009                 return -1;
4010             }
4011             break;
4012         default:
4013             xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
4014                             "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
4015             return -1;
4016     }
4017
4018     if (pubid != 0) {
4019         if (sysid == 0) {
4020             xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
4021                             "xmlTextWriterWriteDTDExternalEntityContents: system identifier needed!\n");
4022             return -1;
4023         }
4024
4025         count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
4026         if (count < 0)
4027             return -1;
4028         sum += count;
4029
4030         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4031         if (count < 0)
4032             return -1;
4033         sum += count;
4034
4035         count =
4036             xmlOutputBufferWriteString(writer->out, (const char *) pubid);
4037         if (count < 0)
4038             return -1;
4039         sum += count;
4040
4041         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4042         if (count < 0)
4043             return -1;
4044         sum += count;
4045     }
4046
4047     if (sysid != 0) {
4048         if (pubid == 0) {
4049             count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
4050             if (count < 0)
4051                 return -1;
4052             sum += count;
4053         }
4054
4055         count = xmlOutputBufferWriteString(writer->out, " ");
4056         if (count < 0)
4057             return -1;
4058         sum += count;
4059
4060         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4061         if (count < 0)
4062             return -1;
4063         sum += count;
4064
4065         count =
4066             xmlOutputBufferWriteString(writer->out, (const char *) sysid);
4067         if (count < 0)
4068             return -1;
4069         sum += count;
4070
4071         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4072         if (count < 0)
4073             return -1;
4074         sum += count;
4075     }
4076
4077     if (ndataid != NULL) {
4078         count = xmlOutputBufferWriteString(writer->out, " NDATA ");
4079         if (count < 0)
4080             return -1;
4081         sum += count;
4082
4083         count =
4084             xmlOutputBufferWriteString(writer->out,
4085                                        (const char *) ndataid);
4086         if (count < 0)
4087             return -1;
4088         sum += count;
4089     }
4090
4091     return sum;
4092 }
4093
4094 /**
4095  * xmlTextWriterWriteDTDNotation:
4096  * @writer:  the xmlTextWriterPtr
4097  * @name:  the name of the xml notation
4098  * @pubid:  the public identifier, which is an alternative to the system identifier
4099  * @sysid:  the system identifier, which is the URI of the DTD
4100  *
4101  * Write a DTD entity.
4102  *
4103  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
4104  */
4105 int
4106 xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
4107                               const xmlChar * name,
4108                               const xmlChar * pubid, const xmlChar * sysid)
4109 {
4110     int count;
4111     int sum;
4112     xmlLinkPtr lk;
4113     xmlTextWriterStackEntry *p;
4114
4115     if (writer == NULL || name == NULL || *name == '\0')
4116         return -1;
4117
4118     sum = 0;
4119     lk = xmlListFront(writer->nodes);
4120     if (lk == 0) {
4121         return -1;
4122     }
4123
4124     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
4125     if (p != 0) {
4126         switch (p->state) {
4127             case XML_TEXTWRITER_DTD:
4128                 count = xmlOutputBufferWriteString(writer->out, " [");
4129                 if (count < 0)
4130                     return -1;
4131                 sum += count;
4132                 if (writer->indent) {
4133                     count = xmlOutputBufferWriteString(writer->out, "\n");
4134                     if (count < 0)
4135                         return -1;
4136                     sum += count;
4137                 }
4138                 p->state = XML_TEXTWRITER_DTD_TEXT;
4139                 /* fallthrough */
4140             case XML_TEXTWRITER_DTD_TEXT:
4141                 break;
4142             default:
4143                 return -1;
4144         }
4145     }
4146
4147     if (writer->indent) {
4148         count = xmlTextWriterWriteIndent(writer);
4149         if (count < 0)
4150             return -1;
4151         sum += count;
4152     }
4153
4154     count = xmlOutputBufferWriteString(writer->out, "<!NOTATION ");
4155     if (count < 0)
4156         return -1;
4157     sum += count;
4158     count = xmlOutputBufferWriteString(writer->out, (const char *) name);
4159     if (count < 0)
4160         return -1;
4161     sum += count;
4162
4163     if (pubid != 0) {
4164         count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
4165         if (count < 0)
4166             return -1;
4167         sum += count;
4168         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4169         if (count < 0)
4170             return -1;
4171         sum += count;
4172         count =
4173             xmlOutputBufferWriteString(writer->out, (const char *) pubid);
4174         if (count < 0)
4175             return -1;
4176         sum += count;
4177         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4178         if (count < 0)
4179             return -1;
4180         sum += count;
4181     }
4182
4183     if (sysid != 0) {
4184         if (pubid == 0) {
4185             count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
4186             if (count < 0)
4187                 return -1;
4188             sum += count;
4189         }
4190         count = xmlOutputBufferWriteString(writer->out, " ");
4191         if (count < 0)
4192             return -1;
4193         sum += count;
4194         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4195         if (count < 0)
4196             return -1;
4197         sum += count;
4198         count =
4199             xmlOutputBufferWriteString(writer->out, (const char *) sysid);
4200         if (count < 0)
4201             return -1;
4202         sum += count;
4203         count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4204         if (count < 0)
4205             return -1;
4206         sum += count;
4207     }
4208
4209     count = xmlOutputBufferWriteString(writer->out, ">");
4210     if (count < 0)
4211         return -1;
4212     sum += count;
4213
4214     return sum;
4215 }
4216
4217 /**
4218  * xmlTextWriterFlush:
4219  * @writer:  the xmlTextWriterPtr
4220  *
4221  * Flush the output buffer.
4222  *
4223  * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
4224  */
4225 int
4226 xmlTextWriterFlush(xmlTextWriterPtr writer)
4227 {
4228     int count;
4229
4230     if (writer == NULL)
4231         return -1;
4232
4233     if (writer->out == NULL)
4234         count = 0;
4235     else
4236         count = xmlOutputBufferFlush(writer->out);
4237
4238     return count;
4239 }
4240
4241 /**
4242  * misc
4243  */
4244
4245 /**
4246  * xmlFreeTextWriterStackEntry:
4247  * @lk:  the xmlLinkPtr
4248  *
4249  * Free callback for the xmlList.
4250  */
4251 static void
4252 xmlFreeTextWriterStackEntry(xmlLinkPtr lk)
4253 {
4254     xmlTextWriterStackEntry *p;
4255
4256     p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
4257     if (p == 0)
4258         return;
4259
4260     if (p->name != 0)
4261         xmlFree(p->name);
4262     xmlFree(p);
4263 }
4264
4265 /**
4266  * xmlCmpTextWriterStackEntry:
4267  * @data0:  the first data
4268  * @data1:  the second data
4269  *
4270  * Compare callback for the xmlList.
4271  *
4272  * Returns -1, 0, 1
4273  */
4274 static int
4275 xmlCmpTextWriterStackEntry(const void *data0, const void *data1)
4276 {
4277     xmlTextWriterStackEntry *p0;
4278     xmlTextWriterStackEntry *p1;
4279
4280     if (data0 == data1)
4281         return 0;
4282
4283     if (data0 == 0)
4284         return -1;
4285
4286     if (data1 == 0)
4287         return 1;
4288
4289     p0 = (xmlTextWriterStackEntry *) data0;
4290     p1 = (xmlTextWriterStackEntry *) data1;
4291
4292     return xmlStrcmp(p0->name, p1->name);
4293 }
4294
4295 /**
4296  * misc
4297  */
4298
4299 /**
4300  * xmlTextWriterOutputNSDecl:
4301  * @writer:  the xmlTextWriterPtr
4302  *
4303  * Output the current namespace declarations.
4304  */
4305 static int
4306 xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer)
4307 {
4308     xmlLinkPtr lk;
4309     xmlTextWriterNsStackEntry *np;
4310     int count;
4311     int sum;
4312
4313     sum = 0;
4314     while (!xmlListEmpty(writer->nsstack)) {
4315         xmlChar *namespaceURI = NULL;
4316         xmlChar *prefix = NULL;
4317
4318         lk = xmlListFront(writer->nsstack);
4319         np = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
4320
4321         if (np != 0) {
4322             namespaceURI = xmlStrdup(np->uri);
4323             prefix = xmlStrdup(np->prefix);
4324         }
4325
4326         xmlListPopFront(writer->nsstack);
4327
4328         if (np != 0) {
4329             count = xmlTextWriterWriteAttribute(writer, prefix, namespaceURI);
4330             xmlFree(namespaceURI);
4331             xmlFree(prefix);
4332
4333             if (count < 0) {
4334                 xmlListDelete(writer->nsstack);
4335                 writer->nsstack = NULL;
4336                 return -1;
4337             }
4338             sum += count;
4339         }
4340     }
4341     return sum;
4342 }
4343
4344 /**
4345  * xmlFreeTextWriterNsStackEntry:
4346  * @lk:  the xmlLinkPtr
4347  *
4348  * Free callback for the xmlList.
4349  */
4350 static void
4351 xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk)
4352 {
4353     xmlTextWriterNsStackEntry *p;
4354
4355     p = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
4356     if (p == 0)
4357         return;
4358
4359     if (p->prefix != 0)
4360         xmlFree(p->prefix);
4361     if (p->uri != 0)
4362         xmlFree(p->uri);
4363
4364     xmlFree(p);
4365 }
4366
4367 /**
4368  * xmlCmpTextWriterNsStackEntry:
4369  * @data0:  the first data
4370  * @data1:  the second data
4371  *
4372  * Compare callback for the xmlList.
4373  *
4374  * Returns -1, 0, 1
4375  */
4376 static int
4377 xmlCmpTextWriterNsStackEntry(const void *data0, const void *data1)
4378 {
4379     xmlTextWriterNsStackEntry *p0;
4380     xmlTextWriterNsStackEntry *p1;
4381     int rc;
4382
4383     if (data0 == data1)
4384         return 0;
4385
4386     if (data0 == 0)
4387         return -1;
4388
4389     if (data1 == 0)
4390         return 1;
4391
4392     p0 = (xmlTextWriterNsStackEntry *) data0;
4393     p1 = (xmlTextWriterNsStackEntry *) data1;
4394
4395     rc = xmlStrcmp(p0->prefix, p1->prefix);
4396
4397     if ((rc != 0) || (p0->elem != p1->elem))
4398         rc = -1;
4399
4400     return rc;
4401 }
4402
4403 /**
4404  * xmlTextWriterWriteDocCallback:
4405  * @context:  the xmlBufferPtr
4406  * @str:  the data to write
4407  * @len:  the length of the data
4408  *
4409  * Write callback for the xmlOutputBuffer with target xmlBuffer
4410  *
4411  * Returns -1, 0, 1
4412  */
4413 static int
4414 xmlTextWriterWriteDocCallback(void *context, const xmlChar * str, int len)
4415 {
4416     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
4417     int rc;
4418
4419     if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) {
4420         xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
4421                         "xmlTextWriterWriteDocCallback : XML error %d !\n",
4422                         rc);
4423         return -1;
4424     }
4425
4426     return len;
4427 }
4428
4429 /**
4430  * xmlTextWriterCloseDocCallback:
4431  * @context:  the xmlBufferPtr
4432  *
4433  * Close callback for the xmlOutputBuffer with target xmlBuffer
4434  *
4435  * Returns -1, 0, 1
4436  */
4437 static int
4438 xmlTextWriterCloseDocCallback(void *context)
4439 {
4440     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
4441     int rc;
4442
4443     if ((rc = xmlParseChunk(ctxt, NULL, 0, 1)) != 0) {
4444         xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
4445                         "xmlTextWriterWriteDocCallback : XML error %d !\n",
4446                         rc);
4447         return -1;
4448     }
4449
4450     return 0;
4451 }
4452
4453 /**
4454  * xmlTextWriterVSprintf:
4455  * @format:  see printf
4456  * @argptr:  pointer to the first member of the variable argument list.
4457  *
4458  * Utility function for formatted output
4459  *
4460  * Returns a new xmlChar buffer with the data or NULL on error. This buffer must be freed.
4461  */
4462 static xmlChar *
4463 xmlTextWriterVSprintf(const char *format, va_list argptr)
4464 {
4465     int size;
4466     int count;
4467     xmlChar *buf;
4468     va_list locarg;
4469
4470     size = BUFSIZ;
4471     buf = (xmlChar *) xmlMalloc(size);
4472     if (buf == NULL) {
4473         xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
4474                         "xmlTextWriterVSprintf : out of memory!\n");
4475         return NULL;
4476     }
4477
4478     VA_COPY(locarg, argptr);
4479     while (((count = vsnprintf((char *) buf, size, format, locarg)) < 0)
4480            || (count == size - 1) || (count == size) || (count > size)) {
4481         va_end(locarg);
4482         xmlFree(buf);
4483         size += BUFSIZ;
4484         buf = (xmlChar *) xmlMalloc(size);
4485         if (buf == NULL) {
4486             xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
4487                             "xmlTextWriterVSprintf : out of memory!\n");
4488             return NULL;
4489         }
4490         VA_COPY(locarg, argptr);
4491     }
4492     va_end(locarg);
4493
4494     return buf;
4495 }
4496
4497 /**
4498  * xmlTextWriterStartDocumentCallback:
4499  * @ctx: the user data (XML parser context)
4500  *
4501  * called at the start of document processing.
4502  */
4503 static void
4504 xmlTextWriterStartDocumentCallback(void *ctx)
4505 {
4506     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
4507     xmlDocPtr doc;
4508
4509     if (ctxt->html) {
4510 #ifdef LIBXML_HTML_ENABLED
4511         if (ctxt->myDoc == NULL)
4512             ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
4513         if (ctxt->myDoc == NULL) {
4514             if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
4515                 ctxt->sax->error(ctxt->userData,
4516                                  "SAX.startDocument(): out of memory\n");
4517             ctxt->errNo = XML_ERR_NO_MEMORY;
4518             ctxt->instate = XML_PARSER_EOF;
4519             ctxt->disableSAX = 1;
4520             return;
4521         }
4522 #else
4523         xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
4524                         "libxml2 built without HTML support\n");
4525         ctxt->errNo = XML_ERR_INTERNAL_ERROR;
4526         ctxt->instate = XML_PARSER_EOF;
4527         ctxt->disableSAX = 1;
4528         return;
4529 #endif
4530     } else {
4531         doc = ctxt->myDoc;
4532         if (doc == NULL)
4533             doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
4534         if (doc != NULL) {
4535             if (doc->children == NULL) {
4536                 if (ctxt->encoding != NULL)
4537                     doc->encoding = xmlStrdup(ctxt->encoding);
4538                 else
4539                     doc->encoding = NULL;
4540                 doc->standalone = ctxt->standalone;
4541             }
4542         } else {
4543             if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
4544                 ctxt->sax->error(ctxt->userData,
4545                                  "SAX.startDocument(): out of memory\n");
4546             ctxt->errNo = XML_ERR_NO_MEMORY;
4547             ctxt->instate = XML_PARSER_EOF;
4548             ctxt->disableSAX = 1;
4549             return;
4550         }
4551     }
4552     if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
4553         (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
4554         ctxt->myDoc->URL =
4555             xmlCanonicPath((const xmlChar *) ctxt->input->filename);
4556         if (ctxt->myDoc->URL == NULL)
4557             ctxt->myDoc->URL =
4558                 xmlStrdup((const xmlChar *) ctxt->input->filename);
4559     }
4560 }
4561
4562 /**
4563  * xmlTextWriterSetIndent:
4564  * @writer:  the xmlTextWriterPtr
4565  * @indent:  do indentation?
4566  *
4567  * Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
4568  *
4569  * Returns -1 on error or 0 otherwise.
4570  */
4571 int
4572 xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent)
4573 {
4574     if ((writer == NULL) || (indent < 0))
4575         return -1;
4576
4577     writer->indent = indent;
4578     writer->doindent = 1;
4579
4580     return 0;
4581 }
4582
4583 /**
4584  * xmlTextWriterSetIndentString:
4585  * @writer:  the xmlTextWriterPtr
4586  * @str:  the xmlChar string
4587  *
4588  * Set string indentation.
4589  *
4590  * Returns -1 on error or 0 otherwise.
4591  */
4592 int
4593 xmlTextWriterSetIndentString(xmlTextWriterPtr writer, const xmlChar * str)
4594 {
4595     if ((writer == NULL) || (!str))
4596         return -1;
4597
4598     if (writer->ichar != NULL)
4599         xmlFree(writer->ichar);
4600     writer->ichar = xmlStrdup(str);
4601
4602     if (!writer->ichar)
4603         return -1;
4604     else
4605         return 0;
4606 }
4607
4608 /**
4609  * xmlTextWriterWriteIndent:
4610  * @writer:  the xmlTextWriterPtr
4611  *
4612  * Write indent string.
4613  *
4614  * Returns -1 on error or the number of strings written.
4615  */
4616 static int
4617 xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
4618 {
4619     int lksize;
4620     int i;
4621     int ret;
4622
4623     lksize = xmlListSize(writer->nodes);
4624     if (lksize < 1)
4625         return (-1);            /* list is empty */
4626     for (i = 0; i < (lksize - 1); i++) {
4627         ret = xmlOutputBufferWriteString(writer->out,
4628                                          (const char *) writer->ichar);
4629         if (ret == -1)
4630             return (-1);
4631     }
4632
4633     return (lksize - 1);
4634 }
4635
4636 /**
4637  * xmlTextWriterHandleStateDependencies:
4638  * @writer:  the xmlTextWriterPtr
4639  * @p:  the xmlTextWriterStackEntry
4640  *
4641  * Write state dependent strings.
4642  *
4643  * Returns -1 on error or the number of characters written.
4644  */
4645 static int
4646 xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
4647                                      xmlTextWriterStackEntry * p)
4648 {
4649     int count;
4650     int sum;
4651     char extra[3];
4652
4653     if (writer == NULL)
4654         return -1;
4655
4656     if (p == NULL)
4657         return 0;
4658
4659     sum = 0;
4660     extra[0] = extra[1] = extra[2] = '\0';
4661     if (p != 0) {
4662         sum = 0;
4663         switch (p->state) {
4664             case XML_TEXTWRITER_NAME:
4665                 /* Output namespace declarations */
4666                 count = xmlTextWriterOutputNSDecl(writer);
4667                 if (count < 0)
4668                     return -1;
4669                 sum += count;
4670                 extra[0] = '>';
4671                 p->state = XML_TEXTWRITER_TEXT;
4672                 break;
4673             case XML_TEXTWRITER_PI:
4674                 extra[0] = ' ';
4675                 p->state = XML_TEXTWRITER_PI_TEXT;
4676                 break;
4677             case XML_TEXTWRITER_DTD:
4678                 extra[0] = ' ';
4679                 extra[1] = '[';
4680                 p->state = XML_TEXTWRITER_DTD_TEXT;
4681                 break;
4682             case XML_TEXTWRITER_DTD_ELEM:
4683                 extra[0] = ' ';
4684                 p->state = XML_TEXTWRITER_DTD_ELEM_TEXT;
4685                 break;
4686             case XML_TEXTWRITER_DTD_ATTL:
4687                 extra[0] = ' ';
4688                 p->state = XML_TEXTWRITER_DTD_ATTL_TEXT;
4689                 break;
4690             case XML_TEXTWRITER_DTD_ENTY:
4691             case XML_TEXTWRITER_DTD_PENT:
4692                 extra[0] = ' ';
4693                 extra[1] = writer->qchar;
4694                 p->state = XML_TEXTWRITER_DTD_ENTY_TEXT;
4695                 break;
4696             default:
4697                 break;
4698         }
4699     }
4700
4701     if (*extra != '\0') {
4702         count = xmlOutputBufferWriteString(writer->out, extra);
4703         if (count < 0)
4704             return -1;
4705         sum += count;
4706     }
4707
4708     return sum;
4709 }
4710
4711 #define bottom_xmlwriter
4712 #include "elfgcchack.h"
4713 #endif