Lines Matching defs:content
1354 node = xmlNewDocText(doc, ent->content);
1357 node = xmlNewDocText(doc, ent->content);
1360 xmlNodeAddContent(last, ent->content);
1375 (const xmlChar*)node->content);
1539 node = xmlNewDocText(doc, ent->content);
1542 node = xmlNewDocText(doc, ent->content);
1545 xmlNodeAddContent(last, ent->content);
1560 (const xmlChar*)node->content);
1641 ret = xmlStrcat(ret, node->content);
1645 buffer = xmlEncodeEntitiesReentrant(doc, node->content);
1657 /* an entity content can be any "well balanced chunk",
1658 * i.e. the result of the content [43] production:
1659 * http://www.w3.org/TR/REC-xml#NT-content.
1670 ret = xmlStrcat(ret, node->content);
1723 ret = xmlStrcat(ret, node->content);
1727 buffer = xmlEncodeSpecialChars(doc, node->content);
1739 /* an entity content can be any "well balanced chunk",
1740 * i.e. the result of the content [43] production:
1741 * http://www.w3.org/TR/REC-xml#NT-content.
1753 ret = xmlStrcat(ret, node->content);
2025 * Free one attribute, all the content is freed too
2050 * Unlink and free one attribute, all the content is freed too
2101 * @content: the PI content
2107 xmlNewDocPI(xmlDocPtr doc, const xmlChar *name, const xmlChar *content) {
2133 if (content != NULL) {
2134 cur->content = xmlStrdup(content);
2146 * @content: the PI content
2154 xmlNewPI(const xmlChar *name, const xmlChar *content) {
2155 return(xmlNewDocPI(NULL, name, content));
2247 * @content: the XML text content if any
2249 * Creation of a new node element within a document. @ns and @content
2251 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
2260 const xmlChar *name, const xmlChar *content) {
2270 if (content != NULL) {
2271 cur->children = xmlStringGetNodeList(doc, content);
2284 * @content: the XML text content if any
2286 * Creation of a new node element within a document. @ns and @content
2288 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
2297 xmlChar *name, const xmlChar *content) {
2303 if (content != NULL) {
2304 cur->children = xmlStringGetNodeList(doc, content);
2322 * @content: the text content if any
2324 * Creation of a new node element within a document. @ns and @content
2331 const xmlChar *name, const xmlChar *content) {
2337 if (content != NULL) {
2338 cur->children = xmlNewDocText(doc, content);
2377 * @content: the text content
2383 xmlNewText(const xmlChar *content) {
2398 if (content != NULL) {
2399 cur->content = xmlStrdup(content);
2413 * @content: the text content of the child if any.
2416 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
2417 * created element inherits the namespace of @parent. If @content is non NULL,
2418 * a child TEXT node will be created containing the string @content.
2419 * NOTE: Use xmlNewChild() if @content will contain entities that need to be
2421 * reserved XML chars that might appear in @content, such as the ampersand,
2429 const xmlChar *name, const xmlChar *content) {
2453 cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content);
2455 cur = xmlNewDocRawNode(parent->doc, ns, name, content);
2459 cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content);
2461 cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content);
2463 cur = xmlNewDocRawNode( parent->doc, ns, name, content);
2573 cur->content = ent->content;
2591 * @content: the text content
2597 xmlNewDocText(xmlDocPtr doc, const xmlChar *content) {
2600 cur = xmlNewText(content);
2607 * @content: the text content
2610 * Creation of a new text node with an extra parameter for the content's length
2614 xmlNewTextLen(const xmlChar *content, int len) {
2629 if (content != NULL) {
2630 cur->content = xmlStrndup(content, len);
2641 * @content: the text content
2644 * Creation of a new text node with an extra content length parameter. The
2649 xmlNewDocTextLen(xmlDocPtr doc, const xmlChar *content, int len) {
2652 cur = xmlNewTextLen(content, len);
2659 * @content: the comment content
2665 xmlNewComment(const xmlChar *content) {
2680 if (content != NULL) {
2681 cur->content = xmlStrdup(content);
2692 * @content: the CDATA block content content
2699 xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
2714 if (content != NULL) {
2715 cur->content = xmlStrndup(content, len);
2726 * @content: the comment content
2732 xmlNewDocComment(xmlDocPtr doc, const xmlChar *content) {
2735 cur = xmlNewComment(content);
2795 * @content: the XML content of the child if any.
2798 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
2799 * created element inherits the namespace of @parent. If @content is non NULL,
2801 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity
2809 const xmlChar *name, const xmlChar *content) {
2833 cur = xmlNewDocNode(parent->doc, parent->ns, name, content);
2835 cur = xmlNewDocNode(parent->doc, ns, name, content);
2839 cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content);
2841 cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content);
2843 cur = xmlNewDocNode( parent->doc, ns, name, content);
2961 xmlNodeAddContent(cur, elem->content);
2969 tmp = xmlStrdup(elem->content);
2970 tmp = xmlStrcat(tmp, cur->next->content);
3041 tmp = xmlStrdup(elem->content);
3042 tmp = xmlStrcat(tmp, cur->content);
3050 xmlNodeAddContent(cur->prev, elem->content);
3131 xmlNodeAddContent(cur, elem->content);
3203 xmlNodeAddContent(parent->last, cur->content);
3276 * If cur is a TEXT node, merge its content with adjacent TEXT nodes
3281 (parent->content != NULL) &&
3283 xmlNodeAddContent(parent, cur->content);
3290 xmlNodeAddContent(parent->last, cur->content);
3314 (parent->content != NULL) &&
3316 xmlNodeAddContent(parent, cur->content);
3397 * from entities content to entities references.
3433 * from entities content to entities references.
3468 * from entities content to entities references.
3504 * from entities content to entities references.
3543 * from entities content to entities references.
3622 (cur->content != (xmlChar *) &(cur->properties))) {
3623 DICT_FREE(cur->content)
3693 (cur->content != NULL) &&
3697 (cur->content != (xmlChar *) &(cur->properties))) {
3698 DICT_FREE(cur->content)
4143 (node->content != NULL) &&
4147 ret->content = xmlStrdup(node->content);
4429 * Do a copy of the document info. If recursive, the content tree will
5222 xmlBufferCat(buffer, cur->content);
5232 if (tmp->content != NULL)
5233 xmlBufferCat(buffer, tmp->content);
5280 xmlBufferCat(buffer, tmp->content);
5289 xmlBufferCat(buffer, cur->content);
5300 /* an entity content can be any "well balanced chunk",
5301 * i.e. the result of the content [43] production:
5302 * http://www.w3.org/TR/REC-xml#NT-content
5352 * Returns a new #xmlChar * or NULL if no content is available.
5370 ret = buffer->content;
5371 buffer->content = NULL;
5379 if (cur->content != NULL)
5380 return (xmlStrdup(cur->content));
5398 ret = buffer->content;
5399 buffer->content = NULL;
5424 ret = buffer->content;
5425 buffer->content = NULL;
5446 if (cur->content != NULL)
5447 return (xmlStrdup(cur->content));
5456 * @content: the new value of the content
5458 * Replace the content of a node.
5459 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity
5464 xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
5477 cur->children = xmlStringGetNodeList(cur->doc, content);
5486 if ((cur->content != NULL) &&
5487 (cur->content != (xmlChar *) &(cur->properties))) {
5489 (xmlDictOwns(cur->doc->dict, cur->content))))
5490 xmlFree(cur->content);
5494 if (content != NULL) {
5495 cur->content = xmlStrdup(content);
5497 cur->content = NULL;
5532 * @content: the new value of the content
5533 * @len: the size of @content
5535 * Replace the content of a node.
5536 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity
5541 xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5554 cur->children = xmlStringLenGetNodeList(cur->doc, content, len);
5564 if ((cur->content != NULL) &&
5565 (cur->content != (xmlChar *) &(cur->properties))) {
5567 (xmlDictOwns(cur->doc->dict, cur->content))))
5568 xmlFree(cur->content);
5572 if (content != NULL) {
5573 cur->content = xmlStrndup(content, len);
5575 cur->content = NULL;
5606 * @content: extra content
5607 * @len: the size of @content
5609 * Append the extra substring to the node content.
5610 * NOTE: In contrast to xmlNodeSetContentLen(), @content is supposed to be
5615 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5630 newNode = xmlNewTextLen(content, len);
5650 if (content != NULL) {
5651 if ((cur->content == (xmlChar *) &(cur->properties)) ||
5653 xmlDictOwns(cur->doc->dict, cur->content))) {
5654 cur->content = xmlStrncatNew(cur->content, content, len);
5659 cur->content = xmlStrncat(cur->content, content, len);
5682 * @content: extra content
5684 * Append the extra substring to the node content.
5685 * NOTE: In contrast to xmlNodeSetContent(), @content is supposed to be
5690 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
5700 if (content == NULL) return;
5701 len = xmlStrlen(content);
5702 xmlNodeAddContentLen(cur, content, len);
5721 xmlNodeAddContent(first, second->content);
6443 return(xmlStrdup(prop->children->content));
6788 if (node->content == NULL) return(1);
6789 cur = node->content;
6801 * @content: the content
6802 * @len: @content length
6804 * Concat the given string at the end of the existing node content
6810 xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) {
6823 /* need to check if content is currently in the dictionary */
6824 if ((node->content == (xmlChar *) &(node->properties)) ||
6826 xmlDictOwns(node->doc->dict, node->content))) {
6827 node->content = xmlStrncatNew(node->content, content, len);
6829 node->content = xmlStrncat(node->content, content, len);
6832 if (node->content == NULL)
6861 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
6862 if (ret->content == NULL) {
6867 ret->content[0] = 0;
6892 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
6893 if (ret->content == NULL) {
6898 ret->content[0] = 0;
6900 ret->content = NULL;
6931 ret->content = (xmlChar *) mem;
6964 * Frees an XML buffer. It frees both the content and the structure which
6980 } else if ((buf->content != NULL) &&
6982 xmlFree(buf->content);
6996 if (buf->content == NULL) return;
6999 buf->content = BAD_CAST "";
7002 size_t start_buf = buf->content - buf->contentIO;
7005 buf->content = buf->contentIO;
7006 buf->content[0] = 0;
7008 buf->content[0] = 0;
7031 * we just move the content pointer, but also make sure
7034 buf->content += len;
7042 size_t start_buf = buf->content - buf->contentIO;
7044 memmove(buf->contentIO, &buf->content[0], buf->use);
7045 buf->content = buf->contentIO;
7046 buf->content[buf->use] = 0;
7051 memmove(buf->content, &buf->content[len], buf->use);
7052 buf->content[buf->use] = 0;
7092 size_t start_buf = buf->content - buf->contentIO;
7100 buf->content = newbuf + start_buf;
7102 newbuf = (xmlChar *) xmlRealloc(buf->content, size);
7107 buf->content = newbuf;
7132 if (buf->content == NULL) {
7135 "xmlBufferDump: buf->content == NULL\n");
7141 ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file);
7149 * Function to extract the content of a buffer
7151 * Returns the internal content
7160 return buf->content;
7169 * Returns the length of data in the internal content
7229 start_buf = buf->content - buf->contentIO;
7233 memmove(buf->contentIO, buf->content, buf->use);
7234 buf->content = buf->contentIO;
7235 buf->content[buf->use] = 0;
7244 buf->content = rebuf + start_buf;
7247 if (buf->content == NULL) {
7250 rebuf = (xmlChar *) xmlRealloc(buf->content, newSize);
7259 memcpy(rebuf, buf->content, buf->use);
7260 xmlFree(buf->content);
7268 buf->content = rebuf;
7318 memmove(&buf->content[buf->use], str, len*sizeof(xmlChar));
7320 buf->content[buf->use] = 0;
7365 size_t start_buf = buf->content - buf->contentIO;
7371 buf->content -= len;
7372 memmove(&buf->content[0], str, len);
7386 memmove(&buf->content[len], &buf->content[0], buf->use);
7387 memmove(&buf->content[0], str, len);
7389 buf->content[buf->use] = 0;
7443 buf->content[buf->use++] = *cur;
7445 buf->content[buf->use] = 0;
7944 xmlDictOwns(sourceDoc->dict, cur->content)) { \
7946 cur->content = (xmlChar *) \
7947 xmlDictLookup(destDoc->dict, cur->content, -1); \
7949 cur->content = xmlStrdup(BAD_CAST cur->content); \
8512 * attribute values or element content.
8704 * Process content of element-nodes only.
8776 * values or element content.
9008 * This puts the content in the dest dict, only if
9011 XML_TREE_ADOPT_STR_2(cur->content)
9017 cur->content = NULL;
9027 cur->content = ent->content;
9035 XML_TREE_ADOPT_STR_2(cur->content)
9138 * values or element content.
9407 DICT_COPY(cur->content, clone->content);
9421 clone->content = ent->content;
9431 clone->content = cur->content;
9437 DICT_COPY(cur->content, clone->content);
9440 DICT_COPY(cur->content, clone->content);
9566 * At this point we are done with the node, its content
9720 * Walk content.
9730 XML_TREE_ADOPT_STR_2(cur->content)
9736 cur->content = NULL;
9746 cur->content = ent->content;
9793 * values or element content.
9867 XML_TREE_ADOPT_STR_2(node->content)
9873 node->content = NULL;
9883 node->content = ent->content;
9892 XML_TREE_ADOPT_STR_2(node->content)