xmlstring.c File Reference

#include "libxml.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <libxml/xmlmemory.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlstring.h>
#include "private/parser.h"
#include "private/string.h"

Include dependency graph for xmlstring.c:

Go to the source code of this file.

Macros
#define	IN_LIBXML

Functions
xmlChar *	xmlStrndup (const xmlChar *cur, int len)
xmlChar *	xmlStrdup (const xmlChar *cur)
xmlChar *	xmlCharStrndup (const char *cur, int len)
xmlChar *	xmlCharStrdup (const char *cur)
int	xmlStrcmp (const xmlChar *str1, const xmlChar *str2)
int	xmlStrEqual (const xmlChar *str1, const xmlChar *str2)

: the localname of the QName
xmlStrQEqual: @pref: the prefix of the QName @str: the second xmlChar * Check if a QName is Equal to a given string Returns 1 if they are equal, 0 if they are different
static const xmlChar	casemap [256]
int	xmlStrQEqual (const xmlChar *pref, const xmlChar *name, const xmlChar *str)
int	xmlStrncmp (const xmlChar *str1, const xmlChar *str2, int len)
int	xmlStrcasecmp (const xmlChar *str1, const xmlChar *str2)
int	xmlStrncasecmp (const xmlChar *str1, const xmlChar *str2, int len)
const xmlChar *	xmlStrchr (const xmlChar *str, xmlChar val)
const xmlChar *	xmlStrstr (const xmlChar *str, const xmlChar *val)
const xmlChar *	xmlStrcasestr (const xmlChar *str, const xmlChar *val)
xmlChar *	xmlStrsub (const xmlChar *str, int start, int len)
int	xmlStrlen (const xmlChar *str)
xmlChar *	xmlStrncat (xmlChar *cur, const xmlChar *add, int len)
xmlChar *	xmlStrncatNew (const xmlChar *str1, const xmlChar *str2, int len)
xmlChar *	xmlStrcat (xmlChar *cur, const xmlChar *add)
int	xmlStrPrintf (xmlChar *buf, int len, const char *msg,...)
int	xmlStrVPrintf (xmlChar *buf, int len, const char *msg, va_list ap)
int	xmlUTF8Size (const xmlChar *utf)
int	xmlUTF8Charcmp (const xmlChar *utf1, const xmlChar *utf2)
int	xmlUTF8Strlen (const xmlChar *utf)
int	xmlGetUTF8Char (const unsigned char *utf, int *len)
int	xmlCheckUTF8 (const unsigned char *utf)
int	xmlUTF8Strsize (const xmlChar *utf, int len)
xmlChar *	xmlUTF8Strndup (const xmlChar *utf, int len)
const xmlChar *	xmlUTF8Strpos (const xmlChar *utf, int pos)
int	xmlUTF8Strloc (const xmlChar *utf, const xmlChar *utfchar)
xmlChar *	xmlUTF8Strsub (const xmlChar *utf, int start, int len)
xmlChar *	xmlEscapeFormatString (xmlChar **msg)

Macro Definition Documentation

IN_LIBXML

#define IN_LIBXML

Definition at line 16 of file xmlstring.c.

Function Documentation

xmlCharStrdup()

xmlChar * xmlCharStrdup

(

const char *

cur

)

xmlCharStrdup: @cur: the input char *

a strdup for char's to xmlChar's

Returns a new xmlChar * or NULL

Definition at line 116 of file xmlstring.c.

                               {
    const char *p = cur;
 
    if (cur == NULL) return(NULL);
    while (*p != '\0') p++; /* non input consuming */
    return(xmlCharStrndup(cur, p - cur));
}

Referenced by xmlParseDocument(), xmlParseExtParsedEnt(), xmlParseTextDecl(), and xmlPosixStrdup().

xmlCharStrndup()

xmlChar * xmlCharStrndup	(	const char *	cur,
		int	len
	)

xmlCharStrndup: @cur: the input char * @len: the len of @cur

a strndup for char's to xmlChar's

Returns a new xmlChar * or NULL

Definition at line 88 of file xmlstring.c.

                                         {
    int i;
    xmlChar *ret;
 
    if ((cur == NULL) || (len < 0)) return(NULL);
    ret = (xmlChar *) xmlMallocAtomic((size_t) len + 1);
    if (ret == NULL) {
        return(NULL);
    }
    for (i = 0;i < len;i++) {
        /* Explicit sign change */
        ret[i] = (xmlChar) cur[i];
        if (ret[i] == 0) return(ret);
    }
    ret[len] = 0;
    return(ret);
}

Referenced by xmlCharStrdup().

xmlCheckUTF8()

int xmlCheckUTF8

(

const unsigned char *

utf

)

xmlCheckUTF8: @utf: Pointer to putative UTF-8 encoded string.

Checks @utf for being valid UTF-8. @utf is assumed to be null-terminated. This function is not super-strict, as it will allow longer UTF-8 sequences than necessary. Note that Java is capable of producing these sequences if provoked. Also note, this routine checks for the 4-byte maximum size, but does not check for 0x10ffff maximum value.

Return value: true if @utf is valid.

Definition at line 779 of file xmlstring.c.

{
    int ix;
    unsigned char c;
 
    if (utf == NULL)
        return(0);
    /*
     * utf is a string of 1, 2, 3 or 4 bytes.  The valid strings
     * are as follows (in "bit format"):
     *    0xxxxxxx                                      valid 1-byte
     *    110xxxxx 10xxxxxx                             valid 2-byte
     *    1110xxxx 10xxxxxx 10xxxxxx                    valid 3-byte
     *    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx           valid 4-byte
     */
    while ((c = utf[0])) {      /* string is 0-terminated */
        ix = 0;
        if ((c & 0x80) == 0x00) {   /* 1-byte code, starts with 10 */
            ix = 1;
    } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
        if ((utf[1] & 0xc0 ) != 0x80)
            return 0;
        ix = 2;
    } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
        if (((utf[1] & 0xc0) != 0x80) ||
            ((utf[2] & 0xc0) != 0x80))
            return 0;
        ix = 3;
    } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
        if (((utf[1] & 0xc0) != 0x80) ||
            ((utf[2] & 0xc0) != 0x80) ||
        ((utf[3] & 0xc0) != 0x80))
            return 0;
        ix = 4;
    } else              /* unknown encoding */
        return 0;
        utf += ix;
      }
      return(1);
}

xmlEscapeFormatString()

xmlChar * xmlEscapeFormatString

(

xmlChar **

msg

)

xmlEscapeFormatString: @msg: a pointer to the string in which to escape '' characters. Must be a heap-allocated buffer created by libxml2 that may be returned, or that may be freed and replaced.

Replaces the string pointed to by 'msg' with an escaped string. Returns the same string with all '' characters escaped.

Definition at line 1001 of file xmlstring.c.

{
    xmlChar *msgPtr = NULL;
    xmlChar *result = NULL;
    xmlChar *resultPtr = NULL;
    size_t count = 0;
    size_t msgLen = 0;
    size_t resultLen = 0;
 
    if (!msg || !*msg)
        return(NULL);
 
    for (msgPtr = *msg; *msgPtr != '\0'; ++msgPtr) {
        ++msgLen;
        if (*msgPtr == '%')
            ++count;
    }
 
    if (count == 0)
        return(*msg);
 
    if ((count > INT_MAX) || (msgLen > INT_MAX - count))
        return(NULL);
    resultLen = msgLen + count + 1;
    result = (xmlChar *) xmlMallocAtomic(resultLen);
    if (result == NULL) {
        /* Clear *msg to prevent format string vulnerabilities in
           out-of-memory situations. */
        xmlFree(*msg);
        *msg = NULL;
        return(NULL);
    }
 
    for (msgPtr = *msg, resultPtr = result; *msgPtr != '\0'; ++msgPtr, ++resultPtr) {
        *resultPtr = *msgPtr;
        if (*msgPtr == '%')
            *(++resultPtr) = '%';
    }
    result[resultLen - 1] = '\0';
 
    xmlFree(*msg);
    *msg = result;
 
    return *msg;
}

xmlGetUTF8Char()

int xmlGetUTF8Char	(	const unsigned char *	utf,
		int *	len
	)

xmlGetUTF8Char: @utf: a sequence of UTF-8 encoded bytes @len: a pointer to the minimum number of bytes present in the sequence. This is used to assure the next character is completely contained within the sequence.

Read the first UTF8 character from @utf

Returns the char value or -1 in case of error, and sets *len to the actual number of bytes consumed (0 in case of error)

Definition at line 708 of file xmlstring.c.

                                                   {
    unsigned int c;
 
    if (utf == NULL)
        goto error;
    if (len == NULL)
        goto error;
 
    c = utf[0];
    if (c < 0x80) {
        if (*len < 1)
            goto error;
        /* 1-byte code */
        *len = 1;
    } else {
        if ((*len < 2) || ((utf[1] & 0xc0) != 0x80))
            goto error;
        if (c < 0xe0) {
            if (c < 0xc2)
                goto error;
            /* 2-byte code */
            *len = 2;
            c = (c & 0x1f) << 6;
            c |= utf[1] & 0x3f;
        } else {
            if ((*len < 3) || ((utf[2] & 0xc0) != 0x80))
                goto error;
            if (c < 0xf0) {
                /* 3-byte code */
                *len = 3;
                c = (c & 0xf) << 12;
                c |= (utf[1] & 0x3f) << 6;
                c |= utf[2] & 0x3f;
                if ((c < 0x800) || ((c >= 0xd800) && (c < 0xe000)))
                    goto error;
            } else {
                if ((*len < 4) || ((utf[3] & 0xc0) != 0x80))
                    goto error;
                *len = 4;
                /* 4-byte code */
                c = (c & 0x7) << 18;
                c |= (utf[1] & 0x3f) << 12;
                c |= (utf[2] & 0x3f) << 6;
                c |= utf[3] & 0x3f;
                if ((c < 0x10000) || (c >= 0x110000))
                    goto error;
            }
        }
    }
    return(c);
 
error:
    if (len != NULL)
    *len = 0;
    return(-1);
}

Referenced by xmlLoadEntityContent(), xmlParserPrintFileContextInternal(), and xmlStringCurrentChar().

xmlStrcasecmp()

int xmlStrcasecmp	(	const xmlChar *	str1,
		const xmlChar *	str2
	)

xmlStrcasecmp: @str1: the first xmlChar * @str2: the second xmlChar *

a strcasecmp for xmlChar's

Returns the integer result of the comparison

Definition at line 277 of file xmlstring.c.

                                                        {
    register int tmp;
 
    if (str1 == str2) return(0);
    if (str1 == NULL) return(-1);
    if (str2 == NULL) return(1);
    do {
        tmp = casemap[*str1++] - casemap[*str2];
        if (tmp != 0) return(tmp);
    } while (*str2++ != 0);
    return 0;
}

Referenced by str_to_dt(), xmlSetDeclaredEncoding(), xmlSwitchInputEncoding(), XSLPattern_OP_IEq(), XSLPattern_OP_IGEq(), XSLPattern_OP_IGt(), XSLPattern_OP_ILEq(), XSLPattern_OP_ILt(), XSLPattern_OP_INEq(), xsltApplyStylesheetInternal(), xsltDocumentElem(), xsltGetHTMLIDs(), xsltParseStylesheetPI(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

xmlStrcasestr()

const xmlChar * xmlStrcasestr	(	const xmlChar *	str,
		const xmlChar *	val
	)

xmlStrcasestr: @str: the xmlChar * array (haystack) @val: the xmlChar to search (needle)

a case-ignoring strstr for xmlChar's

Returns the xmlChar * for the first occurrence or NULL.

Definition at line 375 of file xmlstring.c.

                                                      {
    int n;
 
    if (str == NULL) return(NULL);
    if (val == NULL) return(NULL);
    n = xmlStrlen(val);
 
    if (n == 0) return(str);
    while (*str != 0) { /* non input consuming */
        if (casemap[*str] == casemap[*val])
            if (!xmlStrncasecmp(str, val, n)) return(str);
        str++;
    }
    return(NULL);
}

xmlStrcat()

xmlChar * xmlStrcat	(	xmlChar *	cur,
		const xmlChar *	add
	)

xmlStrcat: @cur: the original xmlChar * array @add: the xmlChar * array added

a strcat for array of xmlChar's. Since they are supposed to be encoded in UTF-8 or an encoding with 8bit based chars, we assume a termination mark of '0'.

Returns a new xmlChar * containing the concatenated string. The original @cur is reallocated and should not be freed.

Definition at line 524 of file xmlstring.c.

                                            {
    const xmlChar *p = add;
 
    if (add == NULL) return(cur);
    if (cur == NULL)
        return(xmlStrdup(add));
 
    while (*p != 0) p++; /* non input consuming */
    return(xmlStrncat(cur, add, p - add));
}

Referenced by do_get_text(), tagName_to_XPath(), XDR_E_AttributeType(), XDR_E_ElementType(), xmlURIEscape(), xsltAddKey(), xsltAttrTemplateValueProcessNode(), xsltEvalAVT(), xsltFormatNumberConversion(), and xsltReverseCompMatch().

xmlStrchr()

const xmlChar * xmlStrchr	(	const xmlChar *	str,
		xmlChar	val
	)

xmlStrchr: @str: the xmlChar * array @val: the xmlChar to search

a strchr for xmlChar's

Returns the xmlChar * for the first occurrence or NULL.

Definition at line 327 of file xmlstring.c.

                                           {
    if (str == NULL) return(NULL);
    while (*str != 0) { /* non input consuming */
        if (*str == val) return((xmlChar *) str);
        str++;
    }
    return(NULL);
}

Referenced by xml_write_quotedstring(), xmlBufWriteQuotedString(), xmlParseEntityDecl(), xmlParseEntityRef(), xmlParseNotationDecl(), xmlParsePITarget(), xmlParseStringEntityRef(), xmlURIEscapeStr(), xsltCompileAttr(), and xsltEvalStaticAttrValueTemplate().

xmlStrcmp()

int xmlStrcmp	(	const xmlChar *	str1,
		const xmlChar *	str2
	)

xmlStrcmp: @str1: the first xmlChar * @str2: the second xmlChar *

a strcmp for xmlChar's

Returns the integer result of the comparison

Definition at line 135 of file xmlstring.c.

                                                    {
    if (str1 == str2) return(0);
    if (str1 == NULL) return(-1);
    if (str2 == NULL) return(1);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    return(strcmp((const char *)str1, (const char *)str2));
#else
    do {
        int tmp = *str1++ - *str2;
        if (tmp != 0) return(tmp);
    } while (*str2++ != 0);
    return 0;
#endif
}

Referenced by xmlBuildRelativeURI(), xmlCreateEntityParserCtxtInternal(), xsltDefaultSortFunction(), and xsltLocaleStrcmp().

xmlStrdup()

xmlChar * xmlStrdup

(

const xmlChar *

cur

)

xmlStrdup: @cur: the input xmlChar *

a strdup for array of xmlChar's. Since they are supposed to be encoded in UTF-8 or an encoding with 8bit based chars, we assume a termination mark of '0'.

Returns a new xmlChar * or NULL

Definition at line 69 of file xmlstring.c.

                              {
    const xmlChar *p = cur;
 
    if (cur == NULL) return(NULL);
    while (*p != 0) p++; /* non input consuming */
    return(xmlStrndup(cur, p - cur));
}

Referenced by do_get_text(), domelem_getAttribute(), internal_parseBuffer(), tagName_to_XPath(), XDR_E_AttributeType(), XDR_E_ElementType(), xmlAddAttributeDecl(), xmlAddElementDecl(), xmlAddID(), xmlAddNotationDecl(), xmlAddRef(), xmlBuildRelativeURI(), xmlBuildURI(), xmlCanonicPath(), xmlCopyDocElementContent(), xmlCreateEnumeration(), xmlDoRead(), xmlGetDtdElementDesc2(), xmlNewDocElementContent(), xmlNewEntityInputStream(), xmlNewInputFromFile(), xmlParseExternalEntityPrivate(), xmlPathToURI(), xmlSAX2AttributeNs(), xmlSAX2EndDocument(), xmlSAX2StartElementNs(), xmlSAX2Text(), xmlSplitQName(), xmlStrcat(), xmlStrncatNew(), xmlURIEscapeStr(), xsltAddKey(), xsltApplyStylesheetInternal(), xsltAttribute(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), xsltCheckWrite(), xsltCompileStepPattern(), xsltCopyText(), xsltDocumentElem(), xsltElement(), xsltElementAvailableFunction(), xsltFormatNumberConversion(), xsltFunctionAvailableFunction(), xsltGetNsProp(), xsltGetQNameURI(), xsltKeyFunction(), xsltNewDecimalFormat(), xsltNewExtDef(), xsltNewKeyDef(), xsltNewKeyTable(), xsltParseStylesheetKey(), xsltParseStylesheetOutput(), xsltParseStylesheetProcess(), xsltParseStylesheetTemplate(), xsltReverseCompMatch(), and xsltSystemPropertyFunction().

xmlStrEqual()

int xmlStrEqual	(	const xmlChar *	str1,
		const xmlChar *	str2
	)

xmlStrEqual: @str1: the first xmlChar * @str2: the second xmlChar *

Check if both strings are equal of have same content. Should be a bit more readable and faster than xmlStrcmp()

Returns 1 if they are equal, 0 if they are different

Definition at line 162 of file xmlstring.c.

                                                      {
    if (str1 == str2) return(1);
    if (str1 == NULL) return(0);
    if (str2 == NULL) return(0);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    return(strcmp((const char *)str1, (const char *)str2) == 0);
#else
    do {
        if (*str1++ != *str2) return(0);
    } while (*str2++);
    return(1);
#endif
}

Referenced by cache_free_uri(), cache_from_doc_ns(), cache_type_from_xmlDocPtr(), domattr_get_prefix(), domelem_getAttribute(), domelem_setAttribute(), element_get_dt(), exclPrefixPush(), get_child(), get_child_with_attr(), get_dt_ns(), link_datatypes(), lookup_schema_elemDecl(), node_get_base_name(), node_has_prop(), node_transform_write(), node_transform_write_to_stream(), SAXAttributes_populate(), SchemaCache_get_node_dt(), transform_is_valid_method(), XDR_A_dt_type(), XDR_A_maxOccurs(), XDR_A_required(), XDR_E_attribute(), XDR_E_AttributeType(), XDR_E_element(), XDR_E_ElementType(), XDR_E_group(), XDR_E_Schema(), xmlAddAttributeDecl(), xmlBuildRelativeURI(), xmldoc_unlink_xmldecl(), xmlIsID(), xmlLoadEntityContent(), xmlParseAttribute2(), xmlParseDocument(), xmlParseEntityDecl(), xmlParseEnumerationType(), xmlParseExternalEntityPrivate(), xmlParseNotationType(), xmlParsePI(), xmlParsePITarget(), xmlParseStartTag2(), xmlParseXMLDecl(), xmlSaveUri(), xmlSAX2AttributeDecl(), xmlSAX2AttributeNs(), xmlSAX2StartElementNs(), xmlStrQEqual(), xsltApplyFallbacks(), xsltApplySequenceConstructor(), xsltApplyStylesheetInternal(), xsltApplyXSLTTemplate(), xsltAttribute(), xsltAttributeComp(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), xsltCheckCycle(), xsltCheckExtPrefix(), xsltCheckExtURI(), xsltCheckInstructionElement(), xsltCheckParentElement(), xsltCheckRead(), xsltCheckTopLevelElement(), xsltCheckWrite(), xsltCompileIdKeyPattern(), xsltCompileStepPattern(), xsltCopyNamespaceList(), xsltCopyNamespaceListInternal(), xsltCopyTree(), xsltDecimalFormatGetByName(), xsltDecimalFormatGetByQName(), xsltDefaultSortFunction(), xsltDocumentComp(), xsltDocumentElem(), xsltDocumentFunction(), xsltDocumentFunctionLoadDocument(), xsltElement(), xsltFindElemSpaceHandling(), xsltGatherNamespaces(), xsltGetCNsProp(), xsltGetInheritedNsList(), xsltGetKey(), xsltGetNsProp(), xsltGetSpecialNamespace(), xsltInitAllDocKeys(), xsltInitCtxtKey(), xsltInitDocKeyTable(), xsltLoadDocument(), xsltLoadStyleDocument(), xsltLoadStylesheetPI(), xsltMessage(), xsltNamespaceAlias(), xsltNumberComp(), xsltNumberFormat(), xsltParseStylesheetExcludePrefix(), xsltParseStylesheetExtPrefix(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetProcess(), xsltParseStylesheetStripSpace(), xsltParseStylesheetTop(), xsltParseTemplateContent(), xsltPreprocessStylesheet(), xsltProcessUserParamInternal(), xsltRegisterExtPrefix(), xsltRegisterGlobalVariable(), xsltSaveResultTo(), xsltShallowCopyNsNode(), xsltSortComp(), xsltStylePreCompute(), xsltSystemPropertyFunction(), xsltTestCompMatch(), xsltTestCompMatchCount(), xsltTestStepMatch(), xsltTextComp(), and xsltValueOfComp().

xmlStrlen()

int xmlStrlen

(

const xmlChar *

str

)

xmlStrlen: @str: the xmlChar * array

length of a xmlChar's string

Returns the number of xmlChar contained in the ARRAY.

Definition at line 428 of file xmlstring.c.

                              {
    size_t len = str ? strlen((const char *)str) : 0;
    return(len > INT_MAX ? 0 : len);
}

Referenced by do_get_text(), domdoc_setProperty(), dt_hash(), dt_validate(), strdupxmlChar(), variant_from_dt(), xmlBufAdd(), xmlBuildRelativeURI(), xmlCanonicPath(), xmlNewEntityInputStream(), xmlParseAttValueComplex(), xmlParseReference(), xmlParseStartTag2(), xmlReportError(), xmlSAX2Text(), xmlSnprintfElementContent(), xmlStrcasestr(), xmlStringDecodeEntities(), xmlStringDecodeEntitiesInt(), xmlStrncat(), xmlStrncatNew(), xmlStrstr(), xmlURIEscapeStr(), xsltAddTextString(), xsltComment(), xsltCopyText(), xsltCopyTextString(), xsltFormatNumberConversion(), xsltGenerateIdFunction(), xsltMessage(), and xsltNumberComp().

xmlStrncasecmp()

int xmlStrncasecmp	(	const xmlChar *	str1,
		const xmlChar *	str2,
		int	len
	)

xmlStrncasecmp: @str1: the first xmlChar * @str2: the second xmlChar * @len: the max comparison length

a strncasecmp for xmlChar's

Returns the integer result of the comparison

Definition at line 302 of file xmlstring.c.

                                                                  {
    register int tmp;
 
    if (len <= 0) return(0);
    if (str1 == str2) return(0);
    if (str1 == NULL) return(-1);
    if (str2 == NULL) return(1);
    do {
        tmp = casemap[*str1++] - casemap[*str2];
        if (tmp != 0 || --len == 0) return(tmp);
    } while (*str2++ != 0);
    return 0;
}

Referenced by xmlStrcasestr(), and xsltElementComp().

xmlStrncat()

xmlChar * xmlStrncat	(	xmlChar *	cur,
		const xmlChar *	add,
		int	len
	)

xmlStrncat: @cur: the original xmlChar * array @add: the xmlChar * array added @len: the length of @add

a strncat for array of xmlChar's, it will extend @cur with the len first bytes of @add. Note that if @len < 0 then this is an API error and NULL will be returned.

Returns a new xmlChar *, the original @cur is reallocated and should not be freed.

Definition at line 448 of file xmlstring.c.

                                                      {
    int size;
    xmlChar *ret;
 
    if ((add == NULL) || (len == 0))
        return(cur);
    if (len < 0)
    return(NULL);
    if (cur == NULL)
        return(xmlStrndup(add, len));
 
    size = xmlStrlen(cur);
    if ((size < 0) || (size > INT_MAX - len))
        return(NULL);
    ret = (xmlChar *) xmlRealloc(cur, (size_t) size + len + 1);
    if (ret == NULL) {
        return(cur);
    }
    memcpy(&ret[size], add, len);
    ret[size + len] = 0;
    return(ret);
}

Referenced by tagName_to_XPath(), xmlStrcat(), xsltAddKey(), xsltAttrTemplateValueProcessNode(), and xsltCompileAttr().

xmlStrncatNew()

xmlChar * xmlStrncatNew	(	const xmlChar *	str1,
		const xmlChar *	str2,
		int	len
	)

xmlStrncatNew: @str1: first xmlChar string @str2: second xmlChar string @len: the len of @str2 or < 0

same as xmlStrncat, but creates a new string. The original two strings are not freed. If @len is < 0 then the length will be calculated automatically.

Returns a new xmlChar * or NULL

Definition at line 484 of file xmlstring.c.

                                                                 {
    int size;
    xmlChar *ret;
 
    if (len < 0) {
        len = xmlStrlen(str2);
        if (len < 0)
            return(NULL);
    }
    if ((str2 == NULL) || (len == 0))
        return(xmlStrdup(str1));
    if (str1 == NULL)
        return(xmlStrndup(str2, len));
 
    size = xmlStrlen(str1);
    if ((size < 0) || (size > INT_MAX - len))
        return(NULL);
    ret = (xmlChar *) xmlMalloc((size_t) size + len + 1);
    if (ret == NULL) {
        return(xmlStrndup(str1, size));
    }
    memcpy(ret, str1, size);
    memcpy(&ret[size], str2, len);
    ret[size + len] = 0;
    return(ret);
}

xmlStrncmp()

int xmlStrncmp	(	const xmlChar *	str1,
		const xmlChar *	str2,
		int	len
	)

xmlStrncmp: @str1: the first xmlChar * @str2: the second xmlChar * @len: the max comparison length

a strncmp for xmlChar's

Returns the integer result of the comparison

Definition at line 215 of file xmlstring.c.

                                                              {
    if (len <= 0) return(0);
    if (str1 == str2) return(0);
    if (str1 == NULL) return(-1);
    if (str2 == NULL) return(1);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    return(strncmp((const char *)str1, (const char *)str2, len));
#else
    do {
        int tmp = *str1++ - *str2;
        if (tmp != 0 || --len == 0) return(tmp);
    } while (*str2++ != 0);
    return 0;
#endif
}

Referenced by domdoc_setProperty(), xmlDetectEBCDIC(), xmlStrstr(), xmlUTF8Charcmp(), xmlUTF8Strloc(), xsltFormatNumberConversion(), and xsltUTF8Charcmp().

xmlStrndup()

xmlChar * xmlStrndup	(	const xmlChar *	cur,
		int	len
	)

xmlStrndup: @cur: the input xmlChar * @len: the len of @cur

a strndup for array of xmlChar's

Returns a new xmlChar * or NULL

Definition at line 45 of file xmlstring.c.

                                        {
    xmlChar *ret;
 
    if ((cur == NULL) || (len < 0)) return(NULL);
    ret = (xmlChar *) xmlMallocAtomic((size_t) len + 1);
    if (ret == NULL) {
        return(NULL);
    }
    memcpy(ret, cur, len);
    ret[len] = 0;
    return(ret);
}

Referenced by do_get_text(), XDR_E_AttributeType(), xmlAttrNormalizeSpace2(), xmlNewDocElementContent(), xmlParseAttribute2(), xmlParseAttValueInternal(), xmlParseNmtoken(), xmlParseStringName(), xmlSAX2AttributeNs(), xmlSAX2TextNode(), xmlSplitQName(), xmlStrdup(), xmlStrncat(), xmlStrncatNew(), xmlStrsub(), xsltAttrTemplateValueProcessNode(), xsltCompileAttr(), xsltCompilePatternInternal(), xsltCompileStepPattern(), xsltDocumentElem(), xsltGetQNameURI2(), xsltNumberFormatTokenize(), xsltParseStylesheetExcludePrefix(), xsltParseStylesheetExtPrefix(), xsltParseStylesheetOutput(), xsltParseStylesheetPI(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetStripSpace(), xsltSaveResultToString(), xsltScanLiteral(), and xsltScanNCName().

xmlStrPrintf()

int xmlStrPrintf	(	xmlChar *	buf,
		int	len,
		const char *	msg,
			...
	)

xmlStrPrintf: @buf: the result buffer. @len: the result buffer length. @msg: the message with printf formatting. ...: extra parameters for the message.

Formats @msg and places result into @buf.

Returns the number of characters written to @buf or -1 if an error occurs.

Definition at line 547 of file xmlstring.c.

                                                          {
    va_list args;
    int ret;
 
    if((buf == NULL) || (msg == NULL)) {
        return(-1);
    }
 
    va_start(args, msg);
    ret = vsnprintf((char *) buf, len, (const char *) msg, args);
    va_end(args);
    buf[len - 1] = 0; /* be safe ! */
 
    return(ret);
}

xmlStrQEqual()

int xmlStrQEqual	(	const xmlChar *	pref,
		const xmlChar *	name,
		const xmlChar *	str
	)

Definition at line 188 of file xmlstring.c.

                                                                           {
    if (pref == NULL) return(xmlStrEqual(name, str));
    if (name == NULL) return(0);
    if (str == NULL) return(0);
 
    do {
        if (*pref++ != *str) return(0);
    } while ((*str++) && (*pref));
    if (*str++ != ':') return(0);
    do {
        if (*name++ != *str) return(0);
    } while (*str++);
    return(1);
}

Referenced by xmlDictFindEntry(), and xmlHashQLookup3().

xmlStrstr()

const xmlChar * xmlStrstr	(	const xmlChar *	str,
		const xmlChar *	val
	)

xmlStrstr: @str: the xmlChar * array (haystack) @val: the xmlChar to search (needle)

a strstr for xmlChar's

Returns the xmlChar * for the first occurrence or NULL.

Definition at line 347 of file xmlstring.c.

                                                  {
    int n;
 
    if (str == NULL) return(NULL);
    if (val == NULL) return(NULL);
    n = xmlStrlen(val);
 
    if (n == 0) return(str);
    while (*str != 0) { /* non input consuming */
        if (*str == *val) {
            if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
        }
        str++;
    }
    return(NULL);
}

Referenced by xmlCanonicPath(), xsltCheckRead(), xsltComment(), xsltProcessingInstruction(), and xsltSystemPropertyFunction().

xmlStrsub()

xmlChar * xmlStrsub	(	const xmlChar *	str,
		int	start,
		int	len
	)

xmlStrsub: @str: the xmlChar * array (haystack) @start: the index of the first char (zero based) @len: the length of the substring

Extract a substring of a given string

Returns the xmlChar * for the first occurrence or NULL.

Definition at line 403 of file xmlstring.c.

                                                  {
    int i;
 
    if (str == NULL) return(NULL);
    if (start < 0) return(NULL);
    if (len < 0) return(NULL);
 
    for (i = 0;i < start;i++) {
        if (*str == 0) return(NULL);
        str++;
    }
    if (*str == 0) return(NULL);
    return(xmlStrndup(str, len));
}

xmlStrVPrintf()

int xmlStrVPrintf	(	xmlChar *	buf,
		int	len,
		const char *	msg,
		va_list	ap
	)

xmlStrVPrintf: @buf: the result buffer. @len: the result buffer length. @msg: the message with printf formatting. @ap: extra parameters for the message.

Formats @msg and places result into @buf.

Returns the number of characters written to @buf or -1 if an error occurs.

Definition at line 575 of file xmlstring.c.

                                                                  {
    int ret;
 
    if((buf == NULL) || (msg == NULL)) {
        return(-1);
    }
 
    ret = vsnprintf((char *) buf, len, (const char *) msg, ap);
    buf[len - 1] = 0; /* be safe ! */
 
    return(ret);
}

xmlUTF8Charcmp()

int xmlUTF8Charcmp	(	const xmlChar *	utf1,
		const xmlChar *	utf2
	)

xmlUTF8Charcmp: @utf1: pointer to first UTF8 char @utf2: pointer to second UTF8 char

compares the two UCS4 values

returns result of the compare as with xmlStrncmp

Definition at line 644 of file xmlstring.c.

                                                         {
 
    if (utf1 == NULL ) {
        if (utf2 == NULL)
            return 0;
        return -1;
    }
    return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
}

xmlUTF8Size()

int xmlUTF8Size

(

const xmlChar *

utf

)

xmlUTF8Size: @utf: pointer to the UTF8 character

calculates the internal size of a UTF8 character

returns the numbers of bytes in the character, -1 on format error

Definition at line 613 of file xmlstring.c.

                                {
    xmlChar mask;
    int len;
 
    if (utf == NULL)
        return -1;
    if (*utf < 0x80)
        return 1;
    /* check valid UTF8 character */
    if (!(*utf & 0x40))
        return -1;
    /* determine number of bytes in char */
    len = 2;
    for (mask=0x20; mask != 0; mask>>=1) {
        if (!(*utf & mask))
            return len;
        len++;
    }
    return -1;
}

Referenced by xmlUTF8Charcmp().

xmlUTF8Strlen()

int xmlUTF8Strlen

(

const xmlChar *

utf

)

xmlUTF8Strlen: @utf: a sequence of UTF-8 encoded bytes

compute the length of an UTF8 string, it doesn't do a full UTF8 checking of the content of the string.

Returns the number of characters in the string or -1 in case of error

Definition at line 664 of file xmlstring.c.

                                  {
    size_t ret = 0;
 
    if (utf == NULL)
        return(-1);
 
    while (*utf != 0) {
        if (utf[0] & 0x80) {
            if ((utf[1] & 0xc0) != 0x80)
                return(-1);
            if ((utf[0] & 0xe0) == 0xe0) {
                if ((utf[2] & 0xc0) != 0x80)
                    return(-1);
                if ((utf[0] & 0xf0) == 0xf0) {
                    if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
                        return(-1);
                    utf += 4;
                } else {
                    utf += 3;
                }
            } else {
                utf += 2;
            }
        } else {
            utf++;
        }
        ret++;
    }
    return(ret > INT_MAX ? 0 : ret);
}

xmlUTF8Strloc()

int xmlUTF8Strloc	(	const xmlChar *	utf,
		const xmlChar *	utfchar
	)

xmlUTF8Strloc: @utf: the input UTF8 * @utfchar: the UTF8 character to be found

a function to provide the relative location of a UTF8 char

Returns the relative character position of the desired char or -1 if not found

Definition at line 926 of file xmlstring.c.

                                                          {
    size_t i;
    int size;
    int ch;
 
    if (utf==NULL || utfchar==NULL) return -1;
    size = xmlUTF8Strsize(utfchar, 1);
        for(i=0; (ch=*utf) != 0; i++) {
            if (xmlStrncmp(utf, utfchar, size)==0)
                return(i > INT_MAX ? 0 : i);
            utf++;
            if ( ch & 0x80 ) {
                /* if not simple ascii, verify proper format */
                if ( (ch & 0xc0) != 0xc0 )
                    return(-1);
                /* then skip over remaining bytes for this char */
                while ( (ch <<= 1) & 0x80 )
                    if ( (*utf++ & 0xc0) != 0x80 )
                        return(-1);
            }
        }
 
    return(-1);
}

Referenced by xsltFormatNumberConversion().

xmlUTF8Strndup()

xmlChar * xmlUTF8Strndup	(	const xmlChar *	utf,
		int	len
	)

xmlUTF8Strndup: @utf: the input UTF8 * @len: the len of @utf (in chars)

a strndup for array of UTF8's

Returns a new UTF8 * or NULL

Definition at line 868 of file xmlstring.c.

                                            {
    xmlChar *ret;
    int i;
 
    if ((utf == NULL) || (len < 0)) return(NULL);
    i = xmlUTF8Strsize(utf, len);
    ret = (xmlChar *) xmlMallocAtomic((size_t) i + 1);
    if (ret == NULL) {
        return(NULL);
    }
    memcpy(ret, utf, i);
    ret[i] = 0;
    return(ret);
}

Referenced by xmlUTF8Strsub().

xmlUTF8Strpos()

const xmlChar * xmlUTF8Strpos	(	const xmlChar *	utf,
		int	pos
	)

xmlUTF8Strpos: @utf: the input UTF8 * @pos: the position of the desired UTF8 char (in chars)

a function to provide the equivalent of fetching a character from a string array

Returns a pointer to the UTF8 character or NULL

Definition at line 894 of file xmlstring.c.

                                           {
    int ch;
 
    if (utf == NULL) return(NULL);
    if (pos < 0)
        return(NULL);
    while (pos--) {
        if ((ch=*utf++) == 0) return(NULL);
        if ( ch & 0x80 ) {
            /* if not simple ascii, verify proper format */
            if ( (ch & 0xc0) != 0xc0 )
                return(NULL);
            /* then skip over remaining bytes for this char */
            while ( (ch <<= 1) & 0x80 )
                if ( (*utf++ & 0xc0) != 0x80 )
                    return(NULL);
        }
    }
    return((xmlChar *)utf);
}

Referenced by xsltFormatNumberConversion().

xmlUTF8Strsize()

int xmlUTF8Strsize	(	const xmlChar *	utf,
		int	len
	)

xmlUTF8Strsize: @utf: a sequence of UTF-8 encoded bytes @len: the number of characters in the array

storage size of an UTF8 string the behaviour is not guaranteed if the input string is not UTF-8

Returns the storage size of the first 'len' characters of ARRAY

Definition at line 833 of file xmlstring.c.

                                            {
    const xmlChar *ptr=utf;
    int ch;
    size_t ret;
 
    if (utf == NULL)
        return(0);
 
    if (len <= 0)
        return(0);
 
    while ( len-- > 0) {
        if ( !*ptr )
            break;
        if ( (ch = *ptr++) & 0x80)
            while ((ch<<=1) & 0x80 ) {
        if (*ptr == 0) break;
                ptr++;
        }
    }
    ret = ptr - utf;
    return (ret > INT_MAX ? 0 : ret);
}

Referenced by xmlUTF8Strloc(), xmlUTF8Strndup(), xsltFormatNumberConversion(), xsltFormatNumberPreSuffix(), and xsltUTF8Charcmp().

xmlUTF8Strsub()

xmlChar * xmlUTF8Strsub	(	const xmlChar *	utf,
		int	start,
		int	len
	)

xmlUTF8Strsub: @utf: a sequence of UTF-8 encoded bytes @start: relative pos of first char @len: total number to copy

Create a substring from a given UTF-8 string Note: positions are given in units of UTF-8 chars

Returns a pointer to a newly created string or NULL if any problem

Definition at line 964 of file xmlstring.c.

                                                      {
    int i;
    int ch;
 
    if (utf == NULL) return(NULL);
    if (start < 0) return(NULL);
    if (len < 0) return(NULL);
 
    /*
     * Skip over any leading chars
     */
    for (i = 0;i < start;i++) {
        if ((ch=*utf++) == 0) return(NULL);
        if ( ch & 0x80 ) {
            /* if not simple ascii, verify proper format */
            if ( (ch & 0xc0) != 0xc0 )
                return(NULL);
            /* then skip over remaining bytes for this char */
            while ( (ch <<= 1) & 0x80 )
                if ( (*utf++ & 0xc0) != 0x80 )
                    return(NULL);
        }
    }
 
    return(xmlUTF8Strndup(utf, len));
}

Variable Documentation

casemap

const xmlChar casemap[256]

static

Definition at line 231 of file xmlstring.c.

Referenced by xmlStrcasecmp(), xmlStrcasestr(), and xmlStrncasecmp().