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