xmlstring.h File Reference

#include <stdarg.h>
#include <libxml/xmlversion.h>

Include dependency graph for xmlstring.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	BAD_CAST   (xmlChar *)

Typedefs
typedef unsigned char	xmlChar

Functions
XMLPUBFUN xmlChar *XMLCALL	xmlStrdup (const xmlChar *cur)
XMLPUBFUN xmlChar *XMLCALL	xmlStrndup (const xmlChar *cur, int len)
XMLPUBFUN xmlChar *XMLCALL	xmlCharStrndup (const char *cur, int len)
XMLPUBFUN xmlChar *XMLCALL	xmlCharStrdup (const char *cur)
XMLPUBFUN xmlChar *XMLCALL	xmlStrsub (const xmlChar *str, int start, int len)
XMLPUBFUN const xmlChar *XMLCALL	xmlStrchr (const xmlChar *str, xmlChar val)
XMLPUBFUN const xmlChar *XMLCALL	xmlStrstr (const xmlChar *str, const xmlChar *val)
XMLPUBFUN const xmlChar *XMLCALL	xmlStrcasestr (const xmlChar *str, const xmlChar *val)
XMLPUBFUN int XMLCALL	xmlStrcmp (const xmlChar *str1, const xmlChar *str2)
XMLPUBFUN int XMLCALL	xmlStrncmp (const xmlChar *str1, const xmlChar *str2, int len)
XMLPUBFUN int XMLCALL	xmlStrcasecmp (const xmlChar *str1, const xmlChar *str2)
XMLPUBFUN int XMLCALL	xmlStrncasecmp (const xmlChar *str1, const xmlChar *str2, int len)
XMLPUBFUN int XMLCALL	xmlStrEqual (const xmlChar *str1, const xmlChar *str2)
XMLPUBFUN int XMLCALL	xmlStrQEqual (const xmlChar *pref, const xmlChar *name, const xmlChar *str)
XMLPUBFUN int XMLCALL	xmlStrlen (const xmlChar *str)
XMLPUBFUN xmlChar *XMLCALL	xmlStrcat (xmlChar *cur, const xmlChar *add)
XMLPUBFUN xmlChar *XMLCALL	xmlStrncat (xmlChar *cur, const xmlChar *add, int len)
XMLPUBFUN xmlChar *XMLCALL	xmlStrncatNew (const xmlChar *str1, const xmlChar *str2, int len)
XMLPUBFUN int XMLCALL	xmlStrPrintf (xmlChar *buf, int len, const char *msg,...) LIBXML_ATTR_FORMAT(3
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL	xmlStrVPrintf (xmlChar *buf, int len, const char *msg, va_list ap) LIBXML_ATTR_FORMAT(3
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL	xmlGetUTF8Char (const unsigned char *utf, int *len)
XMLPUBFUN int XMLCALL	xmlCheckUTF8 (const unsigned char *utf)
XMLPUBFUN int XMLCALL	xmlUTF8Strsize (const xmlChar *utf, int len)
XMLPUBFUN xmlChar *XMLCALL	xmlUTF8Strndup (const xmlChar *utf, int len)
XMLPUBFUN const xmlChar *XMLCALL	xmlUTF8Strpos (const xmlChar *utf, int pos)
XMLPUBFUN int XMLCALL	xmlUTF8Strloc (const xmlChar *utf, const xmlChar *utfchar)
XMLPUBFUN xmlChar *XMLCALL	xmlUTF8Strsub (const xmlChar *utf, int start, int len)
XMLPUBFUN int XMLCALL	xmlUTF8Strlen (const xmlChar *utf)
XMLPUBFUN int XMLCALL	xmlUTF8Size (const xmlChar *utf)
XMLPUBFUN int XMLCALL	xmlUTF8Charcmp (const xmlChar *utf1, const xmlChar *utf2)

Macro Definition Documentation

BAD_CAST

#define BAD_CAST   (xmlChar *)

BAD_CAST:

Macro to cast a string to an xmlChar * when one know its safe.

Definition at line 35 of file xmlstring.h.

Typedef Documentation

xmlChar

typedef unsigned char xmlChar

xmlChar:

This is a basic byte in an UTF-8 encoded string. It's unsigned allowing to pinpoint case where char * are assigned to xmlChar * (possibly making serialization back impossible).

Definition at line 28 of file xmlstring.h.

Function Documentation

xmlCharStrdup()

XMLPUBFUN xmlChar *XMLCALL 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 114 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()

XMLPUBFUN xmlChar *XMLCALL 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 86 of file xmlstring.c.

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

Referenced by xmlCharStrdup().

xmlCheckUTF8()

XMLPUBFUN int XMLCALL 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);
}

xmlGetUTF8Char()

XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL 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;
    if (*len < 1)
        goto error;
 
    c = utf[0];
    if (c & 0x80) {
        if (*len < 2)
            goto error;
        if ((utf[1] & 0xc0) != 0x80)
            goto error;
        if ((c & 0xe0) == 0xe0) {
            if (*len < 3)
                goto error;
            if ((utf[2] & 0xc0) != 0x80)
                goto error;
            if ((c & 0xf0) == 0xf0) {
                if (*len < 4)
                    goto error;
                if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
                    goto error;
                *len = 4;
                /* 4-byte code */
                c = (utf[0] & 0x7) << 18;
                c |= (utf[1] & 0x3f) << 12;
                c |= (utf[2] & 0x3f) << 6;
                c |= utf[3] & 0x3f;
            } else {
              /* 3-byte code */
                *len = 3;
                c = (utf[0] & 0xf) << 12;
                c |= (utf[1] & 0x3f) << 6;
                c |= utf[2] & 0x3f;
            }
        } else {
          /* 2-byte code */
            *len = 2;
            c = (utf[0] & 0x1f) << 6;
            c |= utf[1] & 0x3f;
        }
    } else {
        /* 1-byte code */
        *len = 1;
    }
    return(c);
 
error:
    if (len != NULL)
    *len = 0;
    return(-1);
}

Referenced by xmlCharEncOutFunc().

xmlStrcasecmp()

XMLPUBFUN int XMLCALL 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 275 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 xmlParseEncodingDecl(), xsltApplyStylesheetInternal(), xsltDocumentElem(), xsltGetHTMLIDs(), and xsltParseStylesheetPI().

xmlStrcasestr()

XMLPUBFUN const xmlChar *XMLCALL 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 373 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()

XMLPUBFUN xmlChar *XMLCALL 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 xmllintExternalEntityLoader(), xmlURIEscape(), xsltAddKey(), xsltAttrTemplateValueProcessNode(), xsltEvalAVT(), xsltFormatNumberConversion(), and xsltReverseCompMatch().

xmlStrchr()

XMLPUBFUN const xmlChar *XMLCALL 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 325 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 xmlBufWriteQuotedString(), xmlParseAttValueComplex(), xmlParseEntityDecl(), xmlParseEntityRef(), xmlParseNotationDecl(), xmlParsePITarget(), xmlParseReference(), xmlParserEntityCheck(), xmlParseStringEntityRef(), xmlURIEscapeStr(), xsltCompileAttr(), and xsltEvalStaticAttrValueTemplate().

xmlStrcmp()

XMLPUBFUN int XMLCALL 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 133 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()

XMLPUBFUN xmlChar *XMLCALL 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 67 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 xmlAddAttributeDecl(), xmlAddElementDecl(), xmlAddID(), xmlAddNotationDecl(), xmlAddRef(), xmlBuildRelativeURI(), xmlBuildURI(), xmlCanonicPath(), xmlCopyDocElementContent(), xmlCreateEnumeration(), xmlCtxtResetPush(), xmlCtxtUseOptionsInternal(), xmlDoRead(), xmlGetDtdElementDesc2(), xmlHashAddEntry3(), xmlHashUpdateEntry3(), xmlInitializeGlobalState(), xmllintExternalEntityLoader(), xmlNewDocElementContent(), xmlNewEntityInputStream(), xmlNewInputFromFile(), xmlParseExternalEntityPrivate(), xmlParseInNodeContext(), xmlPathToURI(), xmlSAX2AttributeNs(), xmlSAX2EndDocument(), xmlSAX2StartDocument(), xmlSAX2StartElementNs(), xmlSAX2Text(), xmlSplitQName(), xmlStrcat(), xmlStrncatNew(), xmlSwitchEncoding(), 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()

XMLPUBFUN int XMLCALL 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 160 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 exclPrefixPush(), xmlAddAttributeDecl(), xmlBuildRelativeURI(), xmlHashAddEntry3(), xmlHashLookup3(), xmlHashRemoveEntry3(), xmlHashScanFull3(), xmlHashUpdateEntry3(), xmlIsID(), xmlIsXHTML(), xmlParseAttribute2(), xmlParseDocument(), xmlParseEntityDecl(), xmlParseEnumerationType(), xmlParseExternalEntityPrivate(), xmlParseNotationType(), xmlParsePI(), xmlParsePITarget(), xmlParseStartTag2(), xmlParseXMLDecl(), xmlSaveUri(), xmlSAX2AttributeDecl(), xmlSAX2StartElementNs(), xmlStrQEqual(), xsltApplyFallbacks(), xsltApplySequenceConstructor(), xsltApplyStylesheetInternal(), xsltApplyXSLTTemplate(), xsltAttribute(), xsltAttributeComp(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), 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(), xsltParseStylesheetImport(), xsltParseStylesheetInclude(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetProcess(), xsltParseStylesheetStripSpace(), xsltParseStylesheetTop(), xsltParseTemplateContent(), xsltPreprocessStylesheet(), xsltProcessUserParamInternal(), xsltRegisterExtPrefix(), xsltRegisterGlobalVariable(), xsltSaveResultTo(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), xsltSaveResultToString(), xsltShallowCopyNsNode(), xsltSortComp(), xsltStylePreCompute(), xsltSystemPropertyFunction(), xsltTestCompMatch(), xsltTestCompMatchCount(), xsltTestStepMatch(), xsltTextComp(), and xsltValueOfComp().

xmlStrlen()

XMLPUBFUN int XMLCALL 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 426 of file xmlstring.c.

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

Referenced by xmlAddDefAttrs(), xmlBufAdd(), xmlBuildRelativeURI(), xmlCanonicPath(), xmlCreateDocParserCtxt(), xmlCtxtReadDoc(), xmlNewEntityInputStream(), xmlNewStringInputStream(), xmlParseAttValueComplex(), xmlParseBalancedChunkMemoryInternal(), xmlParseReference(), xmlParseStartTag2(), xmlReportError(), xmlSAX2Text(), xmlSnprintfElementContent(), xmlStrcasestr(), xmlStringDecodeEntities(), xmlStringLenDecodeEntities(), xmlStrncat(), xmlStrncatNew(), xmlStrstr(), xmlURIEscapeStr(), xsltAddTextString(), xsltComment(), xsltCopyText(), xsltCopyTextString(), xsltFormatNumberConversion(), xsltMessage(), and xsltNumberComp().

xmlStrncasecmp()

XMLPUBFUN int XMLCALL 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 300 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()

XMLPUBFUN xmlChar *XMLCALL 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 446 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) * sizeof(xmlChar));
    if (ret == NULL) {
        xmlErrMemory(NULL, NULL);
        return(cur);
    }
    memcpy(&ret[size], add, len * sizeof(xmlChar));
    ret[size + len] = 0;
    return(ret);
}

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

xmlStrncatNew()

XMLPUBFUN xmlChar *XMLCALL 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 483 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) * sizeof(xmlChar));
    if (ret == NULL) {
        xmlErrMemory(NULL, NULL);
        return(xmlStrndup(str1, size));
    }
    memcpy(ret, str1, size * sizeof(xmlChar));
    memcpy(&ret[size], str2, len * sizeof(xmlChar));
    ret[size + len] = 0;
    return(ret);
}

xmlStrncmp()

XMLPUBFUN int XMLCALL 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 213 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 xmlDictExists(), xmlDictLookup(), xmlStrstr(), xmlUTF8Charcmp(), xmlUTF8Strloc(), xsltFormatNumberConversion(), and xsltUTF8Charcmp().

xmlStrndup()

XMLPUBFUN xmlChar *XMLCALL 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 42 of file xmlstring.c.

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

Referenced by parsePath(), 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()

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

xmlStrQEqual()

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

Definition at line 186 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 xmlDictQLookup(), and xmlHashQLookup3().

xmlStrstr()

XMLPUBFUN const xmlChar *XMLCALL 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 345 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(), xsltComment(), xsltProcessingInstruction(), and xsltSystemPropertyFunction().

xmlStrsub()

XMLPUBFUN xmlChar *XMLCALL 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 401 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()

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

xmlUTF8Charcmp()

XMLPUBFUN int XMLCALL 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()

XMLPUBFUN int XMLCALL 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()

XMLPUBFUN int XMLCALL 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()

XMLPUBFUN int XMLCALL 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()

XMLPUBFUN xmlChar *XMLCALL 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) * sizeof(xmlChar));
    if (ret == NULL) {
        return(NULL);
    }
    memcpy(ret, utf, i * sizeof(xmlChar));
    ret[i] = 0;
    return(ret);
}

Referenced by xmlUTF8Strsub().

xmlUTF8Strpos()

XMLPUBFUN const xmlChar *XMLCALL 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()

XMLPUBFUN int XMLCALL 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()

XMLPUBFUN xmlChar *XMLCALL 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));
}