lib/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2025-10-26 00:37:43 +03:00
Code Activity

Fix and add const qualifiers

Browse Source 
For https://bugzilla.gnome.org/show_bug.cgi?id=689483

It seems there are functions that do use the const qualifier for some of the
arguments, but it seems that there are a lot of functions that don't use it and
probably should.

So I created a patch against 2.9.0 that makes as much as possible const in
tree.h, and changed other files as needed.

There were a lot of cases like "const xmlNodePtr node".  This doesn't actually
do anything, there the *pointer* is constant not the object it points to. So I
changed those to "const xmlNode *node".

I also removed some consts, mostly in the Copy functions, because those
functions can actually modify the doc or node they copy from
This commit is contained in:
Kurt Roeckx
2014-10-13 16:06:21 +08:00
committed by Daniel Veillard
parent 12fd654340
commit 95ebe53b50
6 changed files with 92 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
buf.c
View File

@@ -565,7 +565,7 @@ xmlBufDump(FILE *file, xmlBufPtr buf) {
*/ */
xmlChar * xmlChar *
xmlBufContent(const xmlBufPtr buf) xmlBufContent(const xmlBuf *buf)
{ {
if ((!buf) || (buf->error)) if ((!buf) || (buf->error))
return NULL; return NULL;
@@ -583,7 +583,7 @@ xmlBufContent(const xmlBufPtr buf)
*/ */
xmlChar * xmlChar *
xmlBufEnd(const xmlBufPtr buf) xmlBufEnd(xmlBufPtr buf)
{ {
if ((!buf) || (buf->error)) if ((!buf) || (buf->error))
return NULL; return NULL;

4
buf.h
View File

@@ -50,8 +50,8 @@ int xmlBufIsEmpty(const xmlBufPtr buf);
int xmlBufAddLen(xmlBufPtr buf, size_t len); int xmlBufAddLen(xmlBufPtr buf, size_t len);
int xmlBufErase(xmlBufPtr buf, size_t len); int xmlBufErase(xmlBufPtr buf, size_t len);
/* const xmlChar * xmlBufContent(const xmlBufPtr buf); */ /* const xmlChar * xmlBufContent(const xmlBuf *buf); */
/* const xmlChar * xmlBufEnd(const xmlBufPtr buf); */ /* const xmlChar * xmlBufEnd(xmlBufPtr buf); */
xmlChar * xmlBufDetach(xmlBufPtr buf); xmlChar * xmlBufDetach(xmlBufPtr buf);

4
entities.c
View File

@@ -502,7 +502,7 @@ xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
* Returns A pointer to the entity structure or NULL if not found. * Returns A pointer to the entity structure or NULL if not found.
*/ */
xmlEntityPtr xmlEntityPtr
xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) { xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
xmlEntityPtr cur; xmlEntityPtr cur;
xmlEntitiesTablePtr table; xmlEntitiesTablePtr table;
@@ -783,7 +783,7 @@ xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
* Returns A newly allocated string with the substitution done. * Returns A newly allocated string with the substitution done.
*/ */
xmlChar * xmlChar *
xmlEncodeSpecialChars(xmlDocPtr doc ATTRIBUTE_UNUSED, const xmlChar *input) { xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
const xmlChar *cur = input; const xmlChar *cur = input;
xmlChar *buffer = NULL; xmlChar *buffer = NULL;
xmlChar *out = NULL; xmlChar *out = NULL;

4
include/libxml/entities.h
View File

@@ -103,7 +103,7 @@ XMLPUBFUN xmlEntityPtr XMLCALL
XMLPUBFUN xmlEntityPtr XMLCALL XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetPredefinedEntity (const xmlChar *name); xmlGetPredefinedEntity (const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDocEntity (xmlDocPtr doc, xmlGetDocEntity (const xmlDoc *doc,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDtdEntity (xmlDocPtr doc, xmlGetDtdEntity (xmlDocPtr doc,
@@ -120,7 +120,7 @@ XMLPUBFUN xmlChar * XMLCALL
xmlEncodeEntitiesReentrant(xmlDocPtr doc, xmlEncodeEntitiesReentrant(xmlDocPtr doc,
const xmlChar *input); const xmlChar *input);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlEncodeSpecialChars (xmlDocPtr doc, xmlEncodeSpecialChars (const xmlDoc *doc,
const xmlChar *input); const xmlChar *input);
XMLPUBFUN xmlEntitiesTablePtr XMLCALL XMLPUBFUN xmlEntitiesTablePtr XMLCALL
xmlCreateEntitiesTable (void); xmlCreateEntitiesTable (void);

74
include/libxml/tree.h
View File

@@ -116,8 +116,8 @@ typedef xmlBuf *xmlBufPtr;
* A few public routines for xmlBuf. As those are expected to be used * A few public routines for xmlBuf. As those are expected to be used
* mostly internally the bulk of the routines are internal in buf.h * mostly internally the bulk of the routines are internal in buf.h
*/ */
XMLPUBFUN xmlChar* XMLCALL xmlBufContent (const xmlBufPtr buf); XMLPUBFUN xmlChar* XMLCALL xmlBufContent (const xmlBuf* buf);
XMLPUBFUN xmlChar* XMLCALL xmlBufEnd (const xmlBufPtr buf); XMLPUBFUN xmlChar* XMLCALL xmlBufEnd (xmlBufPtr buf);
XMLPUBFUN size_t XMLCALL xmlBufUse (const xmlBufPtr buf); XMLPUBFUN size_t XMLCALL xmlBufUse (const xmlBufPtr buf);
XMLPUBFUN size_t XMLCALL xmlBufShrink (xmlBufPtr buf, size_t len); XMLPUBFUN size_t XMLCALL xmlBufShrink (xmlBufPtr buf, size_t len);
@@ -735,14 +735,14 @@ XMLPUBFUN int XMLCALL
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlBufferEmpty (xmlBufferPtr buf); xmlBufferEmpty (xmlBufferPtr buf);
XMLPUBFUN const xmlChar* XMLCALL XMLPUBFUN const xmlChar* XMLCALL
xmlBufferContent (const xmlBufferPtr buf); xmlBufferContent (const xmlBuffer *buf);
XMLPUBFUN xmlChar* XMLCALL XMLPUBFUN xmlChar* XMLCALL
xmlBufferDetach (xmlBufferPtr buf); xmlBufferDetach (xmlBufferPtr buf);
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlBufferSetAllocationScheme(xmlBufferPtr buf, xmlBufferSetAllocationScheme(xmlBufferPtr buf,
xmlBufferAllocationScheme scheme); xmlBufferAllocationScheme scheme);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlBufferLength (const xmlBufferPtr buf); xmlBufferLength (const xmlBuffer *buf);
/* /*
* Creating/freeing new structures. * Creating/freeing new structures.
@@ -758,7 +758,7 @@ XMLPUBFUN xmlDtdPtr XMLCALL
const xmlChar *ExternalID, const xmlChar *ExternalID,
const xmlChar *SystemID); const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL XMLPUBFUN xmlDtdPtr XMLCALL
xmlGetIntSubset (xmlDocPtr doc); xmlGetIntSubset (const xmlDoc *doc);
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlFreeDtd (xmlDtdPtr cur); xmlFreeDtd (xmlDtdPtr cur);
#ifdef LIBXML_LEGACY_ENABLED #ifdef LIBXML_LEGACY_ENABLED
@@ -846,7 +846,7 @@ XMLPUBFUN xmlNodePtr XMLCALL
const xmlChar *content); const xmlChar *content);
#endif #endif
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocText (xmlDocPtr doc, xmlNewDocText (const xmlDoc *doc,
const xmlChar *content); const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlNewText (const xmlChar *content); xmlNewText (const xmlChar *content);
@@ -877,20 +877,20 @@ XMLPUBFUN xmlNodePtr XMLCALL
xmlNewCharRef (xmlDocPtr doc, xmlNewCharRef (xmlDocPtr doc,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlNewReference (xmlDocPtr doc, xmlNewReference (const xmlDoc *doc,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlCopyNode (const xmlNodePtr node, xmlCopyNode (xmlNodePtr node,
int recursive); int recursive);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlDocCopyNode (const xmlNodePtr node, xmlDocCopyNode (xmlNodePtr node,
xmlDocPtr doc, xmlDocPtr doc,
int recursive); int recursive);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlDocCopyNodeList (xmlDocPtr doc, xmlDocCopyNodeList (xmlDocPtr doc,
const xmlNodePtr node); xmlNodePtr node);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlCopyNodeList (const xmlNodePtr node); xmlCopyNodeList (xmlNodePtr node);
#ifdef LIBXML_TREE_ENABLED #ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlNewTextChild (xmlNodePtr parent, xmlNewTextChild (xmlNodePtr parent,
@@ -910,19 +910,19 @@ XMLPUBFUN xmlNodePtr XMLCALL
* Navigating. * Navigating.
*/ */
XMLPUBFUN long XMLCALL XMLPUBFUN long XMLCALL
xmlGetLineNo (xmlNodePtr node); xmlGetLineNo (const xmlNode *node);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlGetNodePath (xmlNodePtr node); xmlGetNodePath (const xmlNode *node);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlDocGetRootElement (xmlDocPtr doc); xmlDocGetRootElement (const xmlDoc *doc);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlGetLastChild (xmlNodePtr parent); xmlGetLastChild (const xmlNode *parent);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlNodeIsText (xmlNodePtr node); xmlNodeIsText (const xmlNode *node);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlIsBlankNode (xmlNodePtr node); xmlIsBlankNode (const xmlNode *node);
/* /*
* Changing the structure. * Changing the structure.
@@ -993,8 +993,8 @@ XMLPUBFUN xmlNsPtr XMLCALL
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || \ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN xmlNsPtr * XMLCALL XMLPUBFUN xmlNsPtr * XMLCALL
xmlGetNsList (xmlDocPtr doc, xmlGetNsList (const xmlDoc *doc,
xmlNodePtr node); const xmlNode *node);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
@@ -1022,37 +1022,37 @@ XMLPUBFUN xmlAttrPtr XMLCALL
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \ #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */ defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlGetNoNsProp (xmlNodePtr node, xmlGetNoNsProp (const xmlNode *node,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlGetProp (xmlNodePtr node, xmlGetProp (const xmlNode *node,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlAttrPtr XMLCALL XMLPUBFUN xmlAttrPtr XMLCALL
xmlHasProp (xmlNodePtr node, xmlHasProp (const xmlNode *node,
const xmlChar *name); const xmlChar *name);
XMLPUBFUN xmlAttrPtr XMLCALL XMLPUBFUN xmlAttrPtr XMLCALL
xmlHasNsProp (xmlNodePtr node, xmlHasNsProp (const xmlNode *node,
const xmlChar *name, const xmlChar *name,
const xmlChar *nameSpace); const xmlChar *nameSpace);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlGetNsProp (xmlNodePtr node, xmlGetNsProp (const xmlNode *node,
const xmlChar *name, const xmlChar *name,
const xmlChar *nameSpace); const xmlChar *nameSpace);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlStringGetNodeList (xmlDocPtr doc, xmlStringGetNodeList (const xmlDoc *doc,
const xmlChar *value); const xmlChar *value);
XMLPUBFUN xmlNodePtr XMLCALL XMLPUBFUN xmlNodePtr XMLCALL
xmlStringLenGetNodeList (xmlDocPtr doc, xmlStringLenGetNodeList (const xmlDoc *doc,
const xmlChar *value, const xmlChar *value,
int len); int len);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlNodeListGetString (xmlDocPtr doc, xmlNodeListGetString (xmlDocPtr doc,
xmlNodePtr list, const xmlNode *list,
int inLine); int inLine);
#ifdef LIBXML_TREE_ENABLED #ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlNodeListGetRawString (xmlDocPtr doc, xmlNodeListGetRawString (const xmlDoc *doc,
xmlNodePtr list, const xmlNode *list,
int inLine); int inLine);
#endif /* LIBXML_TREE_ENABLED */ #endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
@@ -1072,19 +1072,19 @@ XMLPUBFUN void XMLCALL
const xmlChar *content, const xmlChar *content,
int len); int len);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetContent (xmlNodePtr cur); xmlNodeGetContent (const xmlNode *cur);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlNodeBufGetContent (xmlBufferPtr buffer, xmlNodeBufGetContent (xmlBufferPtr buffer,
xmlNodePtr cur); const xmlNode *cur);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlBufGetNodeContent (xmlBufPtr buf, xmlBufGetNodeContent (xmlBufPtr buf,
xmlNodePtr cur); const xmlNode *cur);
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetLang (xmlNodePtr cur); xmlNodeGetLang (const xmlNode *cur);
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlNodeGetSpacePreserve (xmlNodePtr cur); xmlNodeGetSpacePreserve (const xmlNode *cur);
#ifdef LIBXML_TREE_ENABLED #ifdef LIBXML_TREE_ENABLED
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlNodeSetLang (xmlNodePtr cur, xmlNodeSetLang (xmlNodePtr cur,
@@ -1094,8 +1094,8 @@ XMLPUBFUN void XMLCALL
int val); int val);
#endif /* LIBXML_TREE_ENABLED */ #endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN xmlChar * XMLCALL XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetBase (xmlDocPtr doc, xmlNodeGetBase (const xmlDoc *doc,
xmlNodePtr cur); const xmlNode *cur);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlNodeSetBase (xmlNodePtr cur, xmlNodeSetBase (xmlNodePtr cur,
@@ -1241,7 +1241,7 @@ XMLPUBFUN int XMLCALL
* Compression. * Compression.
*/ */
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL
xmlGetDocCompressMode (xmlDocPtr doc); xmlGetDocCompressMode (const xmlDoc *doc);
XMLPUBFUN void XMLCALL XMLPUBFUN void XMLCALL
xmlSetDocCompressMode (xmlDocPtr doc, xmlSetDocCompressMode (xmlDocPtr doc,
int mode); int mode);

94
tree.c
View File

@@ -55,7 +55,7 @@ int __xmlRegisterCallbacks = 0;
static xmlNsPtr static xmlNsPtr
xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns); xmlNewReconciliedNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns);
static xmlChar* xmlGetPropNodeValueInternal(xmlAttrPtr prop); static xmlChar* xmlGetPropNodeValueInternal(const xmlAttr *prop);
/************************************************************************ /************************************************************************
* * * *
@@ -160,7 +160,7 @@ static int xmlCheckDTD = 1;
* Returns A pointer to the entity structure or NULL if not found. * Returns A pointer to the entity structure or NULL if not found.
*/ */
static xmlEntityPtr static xmlEntityPtr
xmlGetEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) { xmlGetEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) {
xmlEntitiesTablePtr table; xmlEntitiesTablePtr table;
if((dtd != NULL) && (dtd->entities != NULL)) { if((dtd != NULL) && (dtd->entities != NULL)) {
@@ -181,7 +181,7 @@ xmlGetEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) {
* Returns A pointer to the entity structure or NULL if not found. * Returns A pointer to the entity structure or NULL if not found.
*/ */
static xmlEntityPtr static xmlEntityPtr
xmlGetParameterEntityFromDtd(xmlDtdPtr dtd, const xmlChar *name) { xmlGetParameterEntityFromDtd(const xmlDtd *dtd, const xmlChar *name) {
xmlEntitiesTablePtr table; xmlEntitiesTablePtr table;
if ((dtd != NULL) && (dtd->pentities != NULL)) { if ((dtd != NULL) && (dtd->pentities != NULL)) {
@@ -916,7 +916,7 @@ xmlNewDtd(xmlDocPtr doc, const xmlChar *name,
*/ */
xmlDtdPtr xmlDtdPtr
xmlGetIntSubset(xmlDocPtr doc) { xmlGetIntSubset(const xmlDoc *doc) {
xmlNodePtr cur; xmlNodePtr cur;
if (doc == NULL) if (doc == NULL)
@@ -1266,7 +1266,7 @@ xmlFreeDoc(xmlDocPtr cur) {
* Returns a pointer to the first child * Returns a pointer to the first child
*/ */
xmlNodePtr xmlNodePtr
xmlStringLenGetNodeList(xmlDocPtr doc, const xmlChar *value, int len) { xmlStringLenGetNodeList(const xmlDoc *doc, const xmlChar *value, int len) {
xmlNodePtr ret = NULL, last = NULL; xmlNodePtr ret = NULL, last = NULL;
xmlNodePtr node; xmlNodePtr node;
xmlChar *val; xmlChar *val;
@@ -1474,7 +1474,7 @@ out:
* Returns a pointer to the first child * Returns a pointer to the first child
*/ */
xmlNodePtr xmlNodePtr
xmlStringGetNodeList(xmlDocPtr doc, const xmlChar *value) { xmlStringGetNodeList(const xmlDoc *doc, const xmlChar *value) {
xmlNodePtr ret = NULL, last = NULL; xmlNodePtr ret = NULL, last = NULL;
xmlNodePtr node; xmlNodePtr node;
xmlChar *val; xmlChar *val;
@@ -1662,9 +1662,9 @@ out:
* Returns a pointer to the string copy, the caller must free it with xmlFree(). * Returns a pointer to the string copy, the caller must free it with xmlFree().
*/ */
xmlChar * xmlChar *
xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
{ {
xmlNodePtr node = list; const xmlNode *node = list;
xmlChar *ret = NULL; xmlChar *ret = NULL;
xmlEntityPtr ent; xmlEntityPtr ent;
int attr; int attr;
@@ -1752,9 +1752,9 @@ xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine)
* Returns a pointer to the string copy, the caller must free it with xmlFree(). * Returns a pointer to the string copy, the caller must free it with xmlFree().
*/ */
xmlChar * xmlChar *
xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list, int inLine) xmlNodeListGetRawString(const xmlDoc *doc, const xmlNode *list, int inLine)
{ {
xmlNodePtr node = list; const xmlNode *node = list;
xmlChar *ret = NULL; xmlChar *ret = NULL;
xmlEntityPtr ent; xmlEntityPtr ent;
@@ -2583,7 +2583,7 @@ xmlNewCharRef(xmlDocPtr doc, const xmlChar *name) {
* Returns a pointer to the new node object. * Returns a pointer to the new node object.
*/ */
xmlNodePtr xmlNodePtr
xmlNewReference(xmlDocPtr doc, const xmlChar *name) { xmlNewReference(const xmlDoc *doc, const xmlChar *name) {
xmlNodePtr cur; xmlNodePtr cur;
xmlEntityPtr ent; xmlEntityPtr ent;
@@ -2601,7 +2601,7 @@ xmlNewReference(xmlDocPtr doc, const xmlChar *name) {
memset(cur, 0, sizeof(xmlNode)); memset(cur, 0, sizeof(xmlNode));
cur->type = XML_ENTITY_REF_NODE; cur->type = XML_ENTITY_REF_NODE;
cur->doc = doc; cur->doc = (xmlDoc *)doc;
if (name[0] == '&') { if (name[0] == '&') {
int len; int len;
name++; name++;
@@ -2639,11 +2639,11 @@ xmlNewReference(xmlDocPtr doc, const xmlChar *name) {
* Returns a pointer to the new node object. * Returns a pointer to the new node object.
*/ */
xmlNodePtr xmlNodePtr
xmlNewDocText(xmlDocPtr doc, const xmlChar *content) { xmlNewDocText(const xmlDoc *doc, const xmlChar *content) {
xmlNodePtr cur; xmlNodePtr cur;
cur = xmlNewText(content); cur = xmlNewText(content);
if (cur != NULL) cur->doc = doc; if (cur != NULL) cur->doc = (xmlDoc *)doc;
return(cur); return(cur);
} }
@@ -3417,7 +3417,7 @@ xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
* Returns the last child or NULL if none. * Returns the last child or NULL if none.
*/ */
xmlNodePtr xmlNodePtr
xmlGetLastChild(xmlNodePtr parent) { xmlGetLastChild(const xmlNode *parent) {
if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) { if ((parent == NULL) || (parent->type == XML_NAMESPACE_DECL)) {
#ifdef DEBUG_TREE #ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext, xmlGenericError(xmlGenericErrorContext,
@@ -4136,7 +4136,7 @@ xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur) {
*/ */
static xmlNodePtr static xmlNodePtr
xmlStaticCopyNode(const xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent, xmlStaticCopyNode(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
int extended) { int extended) {
xmlNodePtr ret; xmlNodePtr ret;
@@ -4341,7 +4341,7 @@ xmlStaticCopyNodeList(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent) {
* Returns: a new #xmlNodePtr, or NULL in case of error. * Returns: a new #xmlNodePtr, or NULL in case of error.
*/ */
xmlNodePtr xmlNodePtr
xmlCopyNode(const xmlNodePtr node, int extended) { xmlCopyNode(xmlNodePtr node, int extended) {
xmlNodePtr ret; xmlNodePtr ret;
ret = xmlStaticCopyNode(node, NULL, NULL, extended); ret = xmlStaticCopyNode(node, NULL, NULL, extended);
@@ -4361,7 +4361,7 @@ xmlCopyNode(const xmlNodePtr node, int extended) {
* Returns: a new #xmlNodePtr, or NULL in case of error. * Returns: a new #xmlNodePtr, or NULL in case of error.
*/ */
xmlNodePtr xmlNodePtr
xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc, int extended) { xmlDocCopyNode(xmlNodePtr node, xmlDocPtr doc, int extended) {
xmlNodePtr ret; xmlNodePtr ret;
ret = xmlStaticCopyNode(node, doc, NULL, extended); ret = xmlStaticCopyNode(node, doc, NULL, extended);
@@ -4377,7 +4377,7 @@ xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc, int extended) {
* *
* Returns: a new #xmlNodePtr, or NULL in case of error. * Returns: a new #xmlNodePtr, or NULL in case of error.
*/ */
xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, const xmlNodePtr node) { xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, xmlNodePtr node) {
xmlNodePtr ret = xmlStaticCopyNodeList(node, doc, NULL); xmlNodePtr ret = xmlStaticCopyNodeList(node, doc, NULL);
return(ret); return(ret);
} }
@@ -4391,7 +4391,7 @@ xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, const xmlNodePtr node) {
* *
* Returns: a new #xmlNodePtr, or NULL in case of error. * Returns: a new #xmlNodePtr, or NULL in case of error.
*/ */
xmlNodePtr xmlCopyNodeList(const xmlNodePtr node) { xmlNodePtr xmlCopyNodeList(xmlNodePtr node) {
xmlNodePtr ret = xmlStaticCopyNodeList(node, NULL, NULL); xmlNodePtr ret = xmlStaticCopyNodeList(node, NULL, NULL);
return(ret); return(ret);
} }
@@ -4561,7 +4561,7 @@ xmlCopyDoc(xmlDocPtr doc, int recursive) {
* Returns the line number if successful, -1 otherwise * Returns the line number if successful, -1 otherwise
*/ */
static long static long
xmlGetLineNoInternal(xmlNodePtr node, int depth) xmlGetLineNoInternal(const xmlNode *node, int depth)
{ {
long result = -1; long result = -1;
@@ -4611,7 +4611,7 @@ xmlGetLineNoInternal(xmlNodePtr node, int depth)
* Returns the line number if successful, -1 otherwise * Returns the line number if successful, -1 otherwise
*/ */
long long
xmlGetLineNo(xmlNodePtr node) xmlGetLineNo(const xmlNode *node)
{ {
return(xmlGetLineNoInternal(node, 0)); return(xmlGetLineNoInternal(node, 0));
} }
@@ -4627,9 +4627,9 @@ xmlGetLineNo(xmlNodePtr node)
* the returned string * the returned string
*/ */
xmlChar * xmlChar *
xmlGetNodePath(xmlNodePtr node) xmlGetNodePath(const xmlNode *node)
{ {
xmlNodePtr cur, tmp, next; const xmlNode *cur, *tmp, *next;
xmlChar *buffer = NULL, *temp; xmlChar *buffer = NULL, *temp;
size_t buf_len; size_t buf_len;
xmlChar *buf; xmlChar *buf;
@@ -4873,7 +4873,7 @@ xmlGetNodePath(xmlNodePtr node)
* Returns the #xmlNodePtr for the root or NULL * Returns the #xmlNodePtr for the root or NULL
*/ */
xmlNodePtr xmlNodePtr
xmlDocGetRootElement(xmlDocPtr doc) { xmlDocGetRootElement(const xmlDoc *doc) {
xmlNodePtr ret; xmlNodePtr ret;
if (doc == NULL) return(NULL); if (doc == NULL) return(NULL);
@@ -4987,7 +4987,7 @@ xmlNodeSetLang(xmlNodePtr cur, const xmlChar *lang) {
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlNodeGetLang(xmlNodePtr cur) { xmlNodeGetLang(const xmlNode *cur) {
xmlChar *lang; xmlChar *lang;
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
@@ -5068,7 +5068,7 @@ xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) {
* Returns -1 if xml:space is not inherited, 0 if "default", 1 if "preserve" * Returns -1 if xml:space is not inherited, 0 if "default", 1 if "preserve"
*/ */
int int
xmlNodeGetSpacePreserve(xmlNodePtr cur) { xmlNodeGetSpacePreserve(const xmlNode *cur) {
xmlChar *space; xmlChar *space;
if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE)) if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE))
@@ -5238,7 +5238,7 @@ xmlNodeSetBase(xmlNodePtr cur, const xmlChar* uri) {
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) { xmlNodeGetBase(const xmlDoc *doc, const xmlNode *cur) {
xmlChar *oldbase = NULL; xmlChar *oldbase = NULL;
xmlChar *base, *newbase; xmlChar *base, *newbase;
@@ -5323,7 +5323,7 @@ xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur) {
* Returns 0 in case of success and -1 in case of error. * Returns 0 in case of success and -1 in case of error.
*/ */
int int
xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur) xmlNodeBufGetContent(xmlBufferPtr buffer, const xmlNode *cur)
{ {
xmlBufPtr buf; xmlBufPtr buf;
int ret; int ret;
@@ -5346,12 +5346,12 @@ xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur)
* directly by this node if it's a TEXT node or the aggregate string * directly by this node if it's a TEXT node or the aggregate string
* of the values carried by this node child's (TEXT and ENTITY_REF). * of the values carried by this node child's (TEXT and ENTITY_REF).
* Entity references are substituted. * Entity references are substituted.
* Fills up the buffer @buffer with this value * Fills up the buffer @buf with this value
* *
* Returns 0 in case of success and -1 in case of error. * Returns 0 in case of success and -1 in case of error.
*/ */
int int
xmlBufGetNodeContent(xmlBufPtr buf, xmlNodePtr cur) xmlBufGetNodeContent(xmlBufPtr buf, const xmlNode *cur)
{ {
if ((cur == NULL) || (buf == NULL)) return(-1); if ((cur == NULL) || (buf == NULL)) return(-1);
switch (cur->type) { switch (cur->type) {
@@ -5361,7 +5361,7 @@ xmlBufGetNodeContent(xmlBufPtr buf, xmlNodePtr cur)
break; break;
case XML_DOCUMENT_FRAG_NODE: case XML_DOCUMENT_FRAG_NODE:
case XML_ELEMENT_NODE:{ case XML_ELEMENT_NODE:{
xmlNodePtr tmp = cur; const xmlNode *tmp = cur;
while (tmp != NULL) { while (tmp != NULL) {
switch (tmp->type) { switch (tmp->type) {
@@ -5492,7 +5492,7 @@ xmlBufGetNodeContent(xmlBufPtr buf, xmlNodePtr cur)
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlNodeGetContent(xmlNodePtr cur) xmlNodeGetContent(const xmlNode *cur)
{ {
if (cur == NULL) if (cur == NULL)
return (NULL); return (NULL);
@@ -5872,7 +5872,7 @@ xmlTextMerge(xmlNodePtr first, xmlNodePtr second) {
* namespace if defined * namespace if defined
*/ */
xmlNsPtr * xmlNsPtr *
xmlGetNsList(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node) xmlGetNsList(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlNode *node)
{ {
xmlNsPtr cur; xmlNsPtr cur;
xmlNsPtr *ret = NULL; xmlNsPtr *ret = NULL;
@@ -5979,7 +5979,7 @@ xmlNsPtr
xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) { xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) {
xmlNsPtr cur; xmlNsPtr cur;
xmlNodePtr orig = node; const xmlNode *orig = node;
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL); if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL);
if ((nameSpace != NULL) && if ((nameSpace != NULL) &&
@@ -6448,7 +6448,7 @@ xmlReconciliateNs(xmlDocPtr doc, xmlNodePtr tree) {
#endif /* LIBXML_TREE_ENABLED */ #endif /* LIBXML_TREE_ENABLED */
static xmlAttrPtr static xmlAttrPtr
xmlGetPropNodeInternal(xmlNodePtr node, const xmlChar *name, xmlGetPropNodeInternal(const xmlNode *node, const xmlChar *name,
const xmlChar *nsName, int useDTD) const xmlChar *nsName, int useDTD)
{ {
xmlAttrPtr prop; xmlAttrPtr prop;
@@ -6562,7 +6562,7 @@ xmlGetPropNodeInternal(xmlNodePtr node, const xmlChar *name,
} }
static xmlChar* static xmlChar*
xmlGetPropNodeValueInternal(xmlAttrPtr prop) xmlGetPropNodeValueInternal(const xmlAttr *prop)
{ {
if (prop == NULL) if (prop == NULL)
return(NULL); return(NULL);
@@ -6608,7 +6608,7 @@ xmlGetPropNodeValueInternal(xmlAttrPtr prop)
* neither was found. * neither was found.
*/ */
xmlAttrPtr xmlAttrPtr
xmlHasProp(xmlNodePtr node, const xmlChar *name) { xmlHasProp(const xmlNode *node, const xmlChar *name) {
xmlAttrPtr prop; xmlAttrPtr prop;
xmlDocPtr doc; xmlDocPtr doc;
@@ -6663,7 +6663,7 @@ xmlHasProp(xmlNodePtr node, const xmlChar *name) {
* if neither was found. * if neither was found.
*/ */
xmlAttrPtr xmlAttrPtr
xmlHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) { xmlHasNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) {
return(xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD)); return(xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD));
} }
@@ -6685,7 +6685,7 @@ xmlHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) {
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlGetProp(xmlNodePtr node, const xmlChar *name) { xmlGetProp(const xmlNode *node, const xmlChar *name) {
xmlAttrPtr prop; xmlAttrPtr prop;
prop = xmlHasProp(node, name); prop = xmlHasProp(node, name);
@@ -6710,7 +6710,7 @@ xmlGetProp(xmlNodePtr node, const xmlChar *name) {
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlGetNoNsProp(xmlNodePtr node, const xmlChar *name) { xmlGetNoNsProp(const xmlNode *node, const xmlChar *name) {
xmlAttrPtr prop; xmlAttrPtr prop;
prop = xmlGetPropNodeInternal(node, name, NULL, xmlCheckDTD); prop = xmlGetPropNodeInternal(node, name, NULL, xmlCheckDTD);
@@ -6735,7 +6735,7 @@ xmlGetNoNsProp(xmlNodePtr node, const xmlChar *name) {
* It's up to the caller to free the memory with xmlFree(). * It's up to the caller to free the memory with xmlFree().
*/ */
xmlChar * xmlChar *
xmlGetNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace) { xmlGetNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace) {
xmlAttrPtr prop; xmlAttrPtr prop;
prop = xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD); prop = xmlGetPropNodeInternal(node, name, nameSpace, xmlCheckDTD);
@@ -6900,7 +6900,7 @@ xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name,
* Returns 1 yes, 0 no * Returns 1 yes, 0 no
*/ */
int int
xmlNodeIsText(xmlNodePtr node) { xmlNodeIsText(const xmlNode *node) {
if (node == NULL) return(0); if (node == NULL) return(0);
if (node->type == XML_TEXT_NODE) return(1); if (node->type == XML_TEXT_NODE) return(1);
@@ -6917,7 +6917,7 @@ xmlNodeIsText(xmlNodePtr node) {
* Returns 1 yes, 0 no * Returns 1 yes, 0 no
*/ */
int int
xmlIsBlankNode(xmlNodePtr node) { xmlIsBlankNode(const xmlNode *node) {
const xmlChar *cur; const xmlChar *cur;
if (node == NULL) return(0); if (node == NULL) return(0);
@@ -7320,7 +7320,7 @@ xmlBufferDump(FILE *file, xmlBufferPtr buf) {
*/ */
const xmlChar * const xmlChar *
xmlBufferContent(const xmlBufferPtr buf) xmlBufferContent(const xmlBuffer *buf)
{ {
if(!buf) if(!buf)
return NULL; return NULL;
@@ -7338,7 +7338,7 @@ xmlBufferContent(const xmlBufferPtr buf)
*/ */
int int
xmlBufferLength(const xmlBufferPtr buf) xmlBufferLength(const xmlBuffer *buf)
{ {
if(!buf) if(!buf)
return 0; return 0;
@@ -7722,7 +7722,7 @@ xmlBufferWriteQuotedString(xmlBufferPtr buf, const xmlChar *string) {
* Returns 0 (uncompressed) to 9 (max compression) * Returns 0 (uncompressed) to 9 (max compression)
*/ */
int int
xmlGetDocCompressMode (xmlDocPtr doc) { xmlGetDocCompressMode (const xmlDoc *doc) {
if (doc == NULL) return(-1); if (doc == NULL) return(-1);
return(doc->compression); return(doc->compression);
} }