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