Lines Matching defs:content
1346 node = xmlNewDocText(doc, ent->content);
1349 node = xmlNewDocText(doc, ent->content);
1352 xmlNodeAddContent(last, ent->content);
1367 (const xmlChar*)node->content);
1531 node = xmlNewDocText(doc, ent->content);
1534 node = xmlNewDocText(doc, ent->content);
1537 xmlNodeAddContent(last, ent->content);
1552 (const xmlChar*)node->content);
1635 ret = xmlStrcat(ret, node->content);
1639 buffer = xmlEncodeEntitiesReentrant(doc, node->content);
1651 /* an entity content can be any "well balanced chunk",
1652 * i.e. the result of the content [43] production:
1653 * http://www.w3.org/TR/REC-xml#NT-content.
1664 ret = xmlStrcat(ret, node->content);
1717 ret = xmlStrcat(ret, node->content);
1721 buffer = xmlEncodeSpecialChars(doc, node->content);
1733 /* an entity content can be any "well balanced chunk",
1734 * i.e. the result of the content [43] production:
1735 * http://www.w3.org/TR/REC-xml#NT-content.
1747 ret = xmlStrcat(ret, node->content);
2011 * Free one attribute, all the content is freed too
2036 * Unlink and free one attribute, all the content is freed too
2087 * @content: the PI content
2093 xmlNewDocPI(xmlDocPtr doc, const xmlChar *name, const xmlChar *content) {
2119 if (content != NULL) {
2120 cur->content = xmlStrdup(content);
2132 * @content: the PI content
2140 xmlNewPI(const xmlChar *name, const xmlChar *content) {
2141 return(xmlNewDocPI(NULL, name, content));
2233 * @content: the XML text content if any
2235 * Creation of a new node element within a document. @ns and @content
2237 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
2246 const xmlChar *name, const xmlChar *content) {
2256 if (content != NULL) {
2257 cur->children = xmlStringGetNodeList(doc, content);
2270 * @content: the XML text content if any
2272 * Creation of a new node element within a document. @ns and @content
2274 * NOTE: @content is supposed to be a piece of XML CDATA, so it allow entities
2283 xmlChar *name, const xmlChar *content) {
2289 if (content != NULL) {
2290 cur->children = xmlStringGetNodeList(doc, content);
2303 * @content: the text content if any
2305 * Creation of a new node element within a document. @ns and @content
2312 const xmlChar *name, const xmlChar *content) {
2318 if (content != NULL) {
2319 cur->children = xmlNewDocText(doc, content);
2358 * @content: the text content
2364 xmlNewText(const xmlChar *content) {
2379 if (content != NULL) {
2380 cur->content = xmlStrdup(content);
2394 * @content: the text content of the child if any.
2397 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
2398 * created element inherits the namespace of @parent. If @content is non NULL,
2399 * a child TEXT node will be created containing the string @content.
2400 * NOTE: Use xmlNewChild() if @content will contain entities that need to be
2402 * reserved XML chars that might appear in @content, such as the ampersand,
2410 const xmlChar *name, const xmlChar *content) {
2434 cur = xmlNewDocRawNode(parent->doc, parent->ns, name, content);
2436 cur = xmlNewDocRawNode(parent->doc, ns, name, content);
2440 cur = xmlNewDocRawNode((xmlDocPtr) parent, NULL, name, content);
2442 cur = xmlNewDocRawNode((xmlDocPtr) parent, ns, name, content);
2444 cur = xmlNewDocRawNode( parent->doc, ns, name, content);
2554 cur->content = ent->content;
2572 * @content: the text content
2578 xmlNewDocText(xmlDocPtr doc, const xmlChar *content) {
2581 cur = xmlNewText(content);
2588 * @content: the text content
2591 * Creation of a new text node with an extra parameter for the content's length
2595 xmlNewTextLen(const xmlChar *content, int len) {
2610 if (content != NULL) {
2611 cur->content = xmlStrndup(content, len);
2622 * @content: the text content
2625 * Creation of a new text node with an extra content length parameter. The
2630 xmlNewDocTextLen(xmlDocPtr doc, const xmlChar *content, int len) {
2633 cur = xmlNewTextLen(content, len);
2640 * @content: the comment content
2646 xmlNewComment(const xmlChar *content) {
2661 if (content != NULL) {
2662 cur->content = xmlStrdup(content);
2673 * @content: the CDATA block content content
2680 xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
2695 if (content != NULL) {
2696 cur->content = xmlStrndup(content, len);
2707 * @content: the comment content
2713 xmlNewDocComment(xmlDocPtr doc, const xmlChar *content) {
2716 cur = xmlNewComment(content);
2776 * @content: the XML content of the child if any.
2779 * @ns and @content parameters are optional (NULL). If @ns is NULL, the newly
2780 * created element inherits the namespace of @parent. If @content is non NULL,
2782 * NOTE: @content is supposed to be a piece of XML CDATA, so it allows entity
2790 const xmlChar *name, const xmlChar *content) {
2814 cur = xmlNewDocNode(parent->doc, parent->ns, name, content);
2816 cur = xmlNewDocNode(parent->doc, ns, name, content);
2820 cur = xmlNewDocNode((xmlDocPtr) parent, NULL, name, content);
2822 cur = xmlNewDocNode((xmlDocPtr) parent, ns, name, content);
2824 cur = xmlNewDocNode( parent->doc, ns, name, content);
2942 xmlNodeAddContent(cur, elem->content);
2950 tmp = xmlStrdup(elem->content);
2951 tmp = xmlStrcat(tmp, cur->next->content);
3022 tmp = xmlStrdup(elem->content);
3023 tmp = xmlStrcat(tmp, cur->content);
3031 xmlNodeAddContent(cur->prev, elem->content);
3104 xmlNodeAddContent(cur, elem->content);
3176 xmlNodeAddContent(parent->last, cur->content);
3246 * If cur is a TEXT node, merge its content with adjacent TEXT nodes
3251 (parent->content != NULL) &&
3253 xmlNodeAddContent(parent, cur->content);
3260 xmlNodeAddContent(parent->last, cur->content);
3284 (parent->content != NULL) &&
3286 xmlNodeAddContent(parent, cur->content);
3396 (cur->content != (xmlChar *) &(cur->properties))) {
3397 DICT_FREE(cur->content)
3462 (cur->content != NULL) &&
3466 (cur->content != (xmlChar *) &(cur->properties))) {
3467 DICT_FREE(cur->content)
3890 (node->content != NULL) &&
3894 ret->content = xmlStrdup(node->content);
4172 * Do a copy of the document info. If recursive, the content tree will
4965 xmlBufferCat(buffer, cur->content);
4975 if (tmp->content != NULL)
4976 xmlBufferCat(buffer, tmp->content);
5023 xmlBufferCat(buffer, tmp->content);
5032 xmlBufferCat(buffer, cur->content);
5043 /* an entity content can be any "well balanced chunk",
5044 * i.e. the result of the content [43] production:
5045 * http://www.w3.org/TR/REC-xml#NT-content
5095 * Returns a new #xmlChar * or NULL if no content is available.
5113 ret = buffer->content;
5114 buffer->content = NULL;
5122 if (cur->content != NULL)
5123 return (xmlStrdup(cur->content));
5141 ret = buffer->content;
5142 buffer->content = NULL;
5167 ret = buffer->content;
5168 buffer->content = NULL;
5189 if (cur->content != NULL)
5190 return (xmlStrdup(cur->content));
5199 * @content: the new value of the content
5201 * Replace the content of a node.
5204 xmlNodeSetContent(xmlNodePtr cur, const xmlChar *content) {
5217 cur->children = xmlStringGetNodeList(cur->doc, content);
5226 if ((cur->content != NULL) &&
5227 (cur->content != (xmlChar *) &(cur->properties))) {
5229 (xmlDictOwns(cur->doc->dict, cur->content))))
5230 xmlFree(cur->content);
5234 if (content != NULL) {
5235 cur->content = xmlStrdup(content);
5237 cur->content = NULL;
5272 * @content: the new value of the content
5273 * @len: the size of @content
5275 * Replace the content of a node.
5278 xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5291 cur->children = xmlStringLenGetNodeList(cur->doc, content, len);
5301 if ((cur->content != NULL) &&
5302 (cur->content != (xmlChar *) &(cur->properties))) {
5304 (xmlDictOwns(cur->doc->dict, cur->content))))
5305 xmlFree(cur->content);
5309 if (content != NULL) {
5310 cur->content = xmlStrndup(content, len);
5312 cur->content = NULL;
5343 * @content: extra content
5344 * @len: the size of @content
5346 * Append the extra substring to the node content.
5349 xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar *content, int len) {
5364 newNode = xmlNewTextLen(content, len);
5384 if (content != NULL) {
5385 if ((cur->content == (xmlChar *) &(cur->properties)) ||
5387 xmlDictOwns(cur->doc->dict, cur->content))) {
5388 cur->content = xmlStrncatNew(cur->content, content, len);
5393 cur->content = xmlStrncat(cur->content, content, len);
5416 * @content: extra content
5418 * Append the extra substring to the node content.
5421 xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content) {
5431 if (content == NULL) return;
5432 len = xmlStrlen(content);
5433 xmlNodeAddContentLen(cur, content, len);
5452 xmlNodeAddContent(first, second->content);
6174 return(xmlStrdup(prop->children->content));
6516 if (node->content == NULL) return(1);
6517 cur = node->content;
6529 * @content: the content
6530 * @len: @content length
6532 * Concat the given string at the end of the existing node content
6538 xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) {
6551 /* need to check if content is currently in the dictionary */
6552 if ((node->content == (xmlChar *) &(node->properties)) ||
6554 xmlDictOwns(node->doc->dict, node->content))) {
6555 node->content = xmlStrncatNew(node->content, content, len);
6557 node->content = xmlStrncat(node->content, content, len);
6560 if (node->content == NULL)
6589 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
6590 if (ret->content == NULL) {
6595 ret->content[0] = 0;
6619 ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
6620 if (ret->content == NULL) {
6625 ret->content[0] = 0;
6627 ret->content = NULL;
6657 ret->content = (xmlChar *) mem;
6687 * Frees an XML buffer. It frees both the content and the structure which
6700 if ((buf->content != NULL) &&
6702 xmlFree(buf->content);
6716 if (buf->content == NULL) return;
6719 buf->content = BAD_CAST "";
6721 memset(buf->content, 0, buf->size);
6742 buf->content += len;
6744 memmove(buf->content, &buf->content[len], buf->use * sizeof(xmlChar));
6745 buf->content[buf->use] = 0;
6782 newbuf = (xmlChar *) xmlRealloc(buf->content, size);
6787 buf->content = newbuf;
6811 if (buf->content == NULL) {
6814 "xmlBufferDump: buf->content == NULL\n");
6820 ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file);
6828 * Function to extract the content of a buffer
6830 * Returns the internal content
6839 return buf->content;
6848 * Returns the length of data in the internal content
6899 if (buf->content == NULL)
6902 rebuf = (xmlChar *) xmlRealloc(buf->content,
6912 memcpy(rebuf, buf->content, buf->use);
6913 xmlFree(buf->content);
6921 buf->content = rebuf;
6969 memmove(&buf->content[buf->use], str, len*sizeof(xmlChar));
6971 buf->content[buf->use] = 0;
7023 memmove(&buf->content[len], &buf->content[0], buf->use * sizeof(xmlChar));
7024 memmove(&buf->content[0], str, len * sizeof(xmlChar));
7026 buf->content[buf->use] = 0;
7080 buf->content[buf->use++] = *cur;
7082 buf->content[buf->use] = 0;
7578 xmlDictOwns(sourceDoc->dict, cur->content)) { \
7580 cur->content = (xmlChar *) \
7581 xmlDictLookup(destDoc->dict, cur->content, -1); \
7583 cur->content = xmlStrdup(BAD_CAST cur->content); \
8146 * attribute values or element content.
8338 * Process content of element-nodes only.
8410 * values or element content.
8642 * This puts the content in the dest dict, only if
8645 XML_TREE_ADOPT_STR_2(cur->content)
8651 cur->content = NULL;
8661 cur->content = ent->content;
8669 XML_TREE_ADOPT_STR_2(cur->content)
8772 * values or element content.
9041 DICT_COPY(cur->content, clone->content);
9055 clone->content = ent->content;
9065 clone->content = cur->content;
9071 DICT_COPY(cur->content, clone->content);
9074 DICT_COPY(cur->content, clone->content);
9200 * At this point we are done with the node, its content
9354 * Walk content.
9364 XML_TREE_ADOPT_STR_2(cur->content)
9370 cur->content = NULL;
9380 cur->content = ent->content;
9427 * values or element content.
9501 XML_TREE_ADOPT_STR_2(node->content)
9507 node->content = NULL;
9517 node->content = ent->content;
9526 XML_TREE_ADOPT_STR_2(node->content)