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