encoding.h File Reference

#include <libxml/xmlversion.h>

Include dependency graph for encoding.h:

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

Go to the source code of this file.

Classes
struct	_xmlCharEncodingHandler

Typedefs
typedef int(*	xmlCharEncodingInputFunc) (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
typedef int(*	xmlCharEncodingOutputFunc) (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
typedef struct _xmlCharEncodingHandler	xmlCharEncodingHandler
typedef xmlCharEncodingHandler *	xmlCharEncodingHandlerPtr

Enumerations
enum	xmlCharEncError {   XML_ENC_ERR_SUCCESS = 0 , XML_ENC_ERR_SPACE = -1 , XML_ENC_ERR_INPUT = -2 , XML_ENC_ERR_PARTIAL = -3 ,   XML_ENC_ERR_INTERNAL = -4 , XML_ENC_ERR_MEMORY = -5 }
enum	xmlCharEncoding {   XML_CHAR_ENCODING_ERROR = -1 , XML_CHAR_ENCODING_NONE = 0 , XML_CHAR_ENCODING_UTF8 = 1 , XML_CHAR_ENCODING_UTF16LE = 2 ,   XML_CHAR_ENCODING_UTF16BE = 3 , XML_CHAR_ENCODING_UCS4LE = 4 , XML_CHAR_ENCODING_UCS4BE = 5 , XML_CHAR_ENCODING_EBCDIC = 6 ,   XML_CHAR_ENCODING_UCS4_2143 =7 , XML_CHAR_ENCODING_UCS4_3412 =8 , XML_CHAR_ENCODING_UCS2 = 9 , XML_CHAR_ENCODING_8859_1 = 10 ,   XML_CHAR_ENCODING_8859_2 = 11 , XML_CHAR_ENCODING_8859_3 = 12 , XML_CHAR_ENCODING_8859_4 = 13 , XML_CHAR_ENCODING_8859_5 = 14 ,   XML_CHAR_ENCODING_8859_6 = 15 , XML_CHAR_ENCODING_8859_7 = 16 , XML_CHAR_ENCODING_8859_8 = 17 , XML_CHAR_ENCODING_8859_9 = 18 ,   XML_CHAR_ENCODING_2022_JP = 19 , XML_CHAR_ENCODING_SHIFT_JIS =20 , XML_CHAR_ENCODING_EUC_JP = 21 , XML_CHAR_ENCODING_ASCII = 22 }

Functions
XML_DEPRECATED XMLPUBFUN void	xmlInitCharEncodingHandlers (void)
XML_DEPRECATED XMLPUBFUN void	xmlCleanupCharEncodingHandlers (void)
XMLPUBFUN void	xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler)
XMLPUBFUN xmlCharEncodingHandlerPtr	xmlGetCharEncodingHandler (xmlCharEncoding enc)
XMLPUBFUN xmlCharEncodingHandlerPtr	xmlFindCharEncodingHandler (const char *name)
XMLPUBFUN xmlCharEncodingHandlerPtr	xmlNewCharEncodingHandler (const char *name, xmlCharEncodingInputFunc input, xmlCharEncodingOutputFunc output)
XMLPUBFUN int	xmlAddEncodingAlias (const char *name, const char *alias)
XMLPUBFUN int	xmlDelEncodingAlias (const char *alias)
XMLPUBFUN const char *	xmlGetEncodingAlias (const char *alias)
XMLPUBFUN void	xmlCleanupEncodingAliases (void)
XMLPUBFUN xmlCharEncoding	xmlParseCharEncoding (const char *name)
XMLPUBFUN const char *	xmlGetCharEncodingName (xmlCharEncoding enc)
XMLPUBFUN xmlCharEncoding	xmlDetectCharEncoding (const unsigned char *in, int len)
XMLPUBFUN int	xmlCharEncOutFunc (xmlCharEncodingHandler *handler, struct _xmlBuffer *out, struct _xmlBuffer *in)
XMLPUBFUN int	xmlCharEncInFunc (xmlCharEncodingHandler *handler, struct _xmlBuffer *out, struct _xmlBuffer *in)
XML_DEPRECATED XMLPUBFUN int	xmlCharEncFirstLine (xmlCharEncodingHandler *handler, struct _xmlBuffer *out, struct _xmlBuffer *in)
XMLPUBFUN int	xmlCharEncCloseFunc (xmlCharEncodingHandler *handler)
XMLPUBFUN int	isolat1ToUTF8 (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)

Typedef Documentation

xmlCharEncodingHandler

typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler

Definition at line 138 of file encoding.h.

xmlCharEncodingHandlerPtr

typedef xmlCharEncodingHandler* xmlCharEncodingHandlerPtr

Definition at line 139 of file encoding.h.

xmlCharEncodingInputFunc

typedef int(* xmlCharEncodingInputFunc) (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)

xmlCharEncodingInputFunc: @out: a pointer to an array of bytes to store the UTF-8 result @outlen: the length of @out @in: a pointer to an array of chars in the original encoding @inlen: the length of @in

Take a block of chars in the original encoding and try to convert it to an UTF-8 block of chars out.

Returns the number of bytes written, -1 if lack of space, or -2 if the transcoding failed. The value of @inlen after return is the number of octets consumed if the return value is positive, else unpredictiable. The value of @outlen after return is the number of octets consumed.

Definition at line 108 of file encoding.h.

xmlCharEncodingOutputFunc

typedef int(* xmlCharEncodingOutputFunc) (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)

xmlCharEncodingOutputFunc: @out: a pointer to an array of bytes to store the result @outlen: the length of @out @in: a pointer to an array of UTF-8 chars @inlen: the length of @in

Take a block of UTF-8 chars in and try to convert it to another encoding. Note: a first call designed to produce heading info is called with in = NULL. If stateful this should also initialize the encoder state.

Returns the number of bytes written, -1 if lack of space, or -2 if the transcoding failed. The value of @inlen after return is the number of octets consumed if the return value is positive, else unpredictiable. The value of @outlen after return is the number of octets produced.

Definition at line 130 of file encoding.h.

Enumeration Type Documentation

xmlCharEncError

enum xmlCharEncError

Enumerator
XML_ENC_ERR_SUCCESS
XML_ENC_ERR_SPACE
XML_ENC_ERR_INPUT
XML_ENC_ERR_PARTIAL
XML_ENC_ERR_INTERNAL
XML_ENC_ERR_MEMORY

Definition at line 35 of file encoding.h.

             {
    XML_ENC_ERR_SUCCESS     =  0,
    XML_ENC_ERR_SPACE       = -1,
    XML_ENC_ERR_INPUT       = -2,
    XML_ENC_ERR_PARTIAL     = -3,
    XML_ENC_ERR_INTERNAL    = -4,
    XML_ENC_ERR_MEMORY      = -5
} xmlCharEncError;

xmlCharEncoding

enum xmlCharEncoding

Enumerator
XML_CHAR_ENCODING_ERROR
XML_CHAR_ENCODING_NONE
XML_CHAR_ENCODING_UTF8
XML_CHAR_ENCODING_UTF16LE
XML_CHAR_ENCODING_UTF16BE
XML_CHAR_ENCODING_UCS4LE
XML_CHAR_ENCODING_UCS4BE
XML_CHAR_ENCODING_EBCDIC
XML_CHAR_ENCODING_UCS4_2143
XML_CHAR_ENCODING_UCS4_3412
XML_CHAR_ENCODING_UCS2
XML_CHAR_ENCODING_8859_1
XML_CHAR_ENCODING_8859_2
XML_CHAR_ENCODING_8859_3
XML_CHAR_ENCODING_8859_4
XML_CHAR_ENCODING_8859_5
XML_CHAR_ENCODING_8859_6
XML_CHAR_ENCODING_8859_7
XML_CHAR_ENCODING_8859_8
XML_CHAR_ENCODING_8859_9
XML_CHAR_ENCODING_2022_JP
XML_CHAR_ENCODING_SHIFT_JIS
XML_CHAR_ENCODING_EUC_JP
XML_CHAR_ENCODING_ASCII

Definition at line 65 of file encoding.h.

             {
    XML_CHAR_ENCODING_ERROR=   -1, /* No char encoding detected */
    XML_CHAR_ENCODING_NONE= 0, /* No char encoding detected */
    XML_CHAR_ENCODING_UTF8= 1, /* UTF-8 */
    XML_CHAR_ENCODING_UTF16LE=  2, /* UTF-16 little endian */
    XML_CHAR_ENCODING_UTF16BE=  3, /* UTF-16 big endian */
    XML_CHAR_ENCODING_UCS4LE=   4, /* UCS-4 little endian */
    XML_CHAR_ENCODING_UCS4BE=   5, /* UCS-4 big endian */
    XML_CHAR_ENCODING_EBCDIC=   6, /* EBCDIC uh! */
    XML_CHAR_ENCODING_UCS4_2143=7, /* UCS-4 unusual ordering */
    XML_CHAR_ENCODING_UCS4_3412=8, /* UCS-4 unusual ordering */
    XML_CHAR_ENCODING_UCS2= 9, /* UCS-2 */
    XML_CHAR_ENCODING_8859_1=   10,/* ISO-8859-1 ISO Latin 1 */
    XML_CHAR_ENCODING_8859_2=   11,/* ISO-8859-2 ISO Latin 2 */
    XML_CHAR_ENCODING_8859_3=   12,/* ISO-8859-3 */
    XML_CHAR_ENCODING_8859_4=   13,/* ISO-8859-4 */
    XML_CHAR_ENCODING_8859_5=   14,/* ISO-8859-5 */
    XML_CHAR_ENCODING_8859_6=   15,/* ISO-8859-6 */
    XML_CHAR_ENCODING_8859_7=   16,/* ISO-8859-7 */
    XML_CHAR_ENCODING_8859_8=   17,/* ISO-8859-8 */
    XML_CHAR_ENCODING_8859_9=   18,/* ISO-8859-9 */
    XML_CHAR_ENCODING_2022_JP=  19,/* ISO-2022-JP */
    XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */
    XML_CHAR_ENCODING_EUC_JP=   21,/* EUC-JP */
    XML_CHAR_ENCODING_ASCII=    22 /* pure ASCII */
} xmlCharEncoding;

Function Documentation

isolat1ToUTF8()

XMLPUBFUN int isolat1ToUTF8	(	unsigned char *	out,
		int *	outlen,
		const unsigned char *	in,
		int *	inlen
	)

isolat1ToUTF8: @out: a pointer to an array of bytes to store the result @outlen: the length of @out @in: a pointer to an array of ISO Latin 1 chars @inlen: the length of @in

Take a block of ISO Latin 1 chars in and try to convert it to an UTF-8 block of chars out.

Returns the number of bytes written or an XML_ENC_ERR code.

The value of @inlen after return is the number of octets consumed if the return value is positive, else unpredictable. The value of @outlen after return is the number of octets produced.

Definition at line 283 of file encoding.c.

                                                   {
    unsigned char* outstart = out;
    const unsigned char* base = in;
    unsigned char* outend;
    const unsigned char* inend;
    const unsigned char* instop;
 
    if ((out == NULL) || (in == NULL) || (outlen == NULL) || (inlen == NULL))
    return(XML_ENC_ERR_INTERNAL);
 
    outend = out + *outlen;
    inend = in + (*inlen);
    instop = inend;
 
    while ((in < inend) && (out < outend - 1)) {
    if (*in >= 0x80) {
        *out++ = (((*in) >>  6) & 0x1F) | 0xC0;
            *out++ = ((*in) & 0x3F) | 0x80;
        ++in;
    }
    if ((instop - in) > (outend - out)) instop = in + (outend - out);
    while ((in < instop) && (*in < 0x80)) {
        *out++ = *in++;
    }
    }
    if ((in < inend) && (out < outend) && (*in < 0x80)) {
        *out++ = *in++;
    }
    *outlen = out - outstart;
    *inlen = in - base;
    return(*outlen);
}

xmlAddEncodingAlias()

XMLPUBFUN int xmlAddEncodingAlias	(	const char *	name,
		const char *	alias
	)

Definition at line 1041 of file encoding.c.

                                                         {
    int i;
    char upper[100];
    char *nameCopy, *aliasCopy;
 
    if ((name == NULL) || (alias == NULL))
    return(-1);
 
    for (i = 0;i < 99;i++) {
        upper[i] = (char) toupper((unsigned char) alias[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) {
        xmlCharEncodingAliasPtr tmp;
        size_t newSize = xmlCharEncodingAliasesMax ?
                         xmlCharEncodingAliasesMax * 2 :
                         20;
 
        tmp = (xmlCharEncodingAliasPtr)
              xmlRealloc(xmlCharEncodingAliases,
                         newSize * sizeof(xmlCharEncodingAlias));
        if (tmp == NULL)
            return(-1);
        xmlCharEncodingAliases = tmp;
        xmlCharEncodingAliasesMax = newSize;
    }
 
    /*
     * Walk down the list looking for a definition of the alias
     */
    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
    if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
        /*
         * Replace the definition.
         */
        nameCopy = xmlMemStrdup(name);
            if (nameCopy == NULL)
                return(-1);
        xmlFree((char *) xmlCharEncodingAliases[i].name);
        xmlCharEncodingAliases[i].name = nameCopy;
        return(0);
    }
    }
    /*
     * Add the definition
     */
    nameCopy = xmlMemStrdup(name);
    if (nameCopy == NULL)
        return(-1);
    aliasCopy = xmlMemStrdup(upper);
    if (aliasCopy == NULL) {
        xmlFree(nameCopy);
        return(-1);
    }
    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = nameCopy;
    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = aliasCopy;
    xmlCharEncodingAliasesNb++;
    return(0);
}

xmlCharEncCloseFunc()

XMLPUBFUN int xmlCharEncCloseFunc

(

xmlCharEncodingHandler *

handler

)

Referenced by xmlDetectEBCDIC(), xmlSwitchInputEncoding(), and xsltSaveResultToString().

xmlCharEncFirstLine()

XML_DEPRECATED XMLPUBFUN int xmlCharEncFirstLine	(	xmlCharEncodingHandler *	handler,
		struct _xmlBuffer *	out,
		struct _xmlBuffer *	in
	)

xmlCharEncInFunc()

XMLPUBFUN int xmlCharEncInFunc	(	xmlCharEncodingHandler *	handler,
		struct _xmlBuffer *	out,
		struct _xmlBuffer *	in
	)

xmlCharEncOutFunc()

XMLPUBFUN int xmlCharEncOutFunc	(	xmlCharEncodingHandler *	handler,
		struct _xmlBuffer *	out,
		struct _xmlBuffer *	in
	)

xmlCleanupCharEncodingHandlers()

XML_DEPRECATED XMLPUBFUN void xmlCleanupCharEncodingHandlers

(

void

)

xmlCleanupCharEncodingHandlers:

DEPRECATED: This function will be made private. Call xmlCleanupParser to free global state but see the warnings there. xmlCleanupParser should be only called once at program exit. In most cases, you don't have call cleanup functions at all.

Cleanup the memory allocated for the char encoding support, it unregisters all the encoding handlers and the aliases.

Definition at line 1490 of file encoding.c.

                                     {
    xmlCleanupEncodingAliases();
 
    if (handlers == NULL) return;
 
    for (;nbCharEncodingHandler > 0;) {
        nbCharEncodingHandler--;
    if (handlers[nbCharEncodingHandler] != NULL) {
        if (handlers[nbCharEncodingHandler]->name != NULL)
        xmlFree(handlers[nbCharEncodingHandler]->name);
        xmlFree(handlers[nbCharEncodingHandler]);
    }
    }
    xmlFree(handlers);
    handlers = NULL;
    nbCharEncodingHandler = 0;
}

Referenced by xmlCleanupParser().

xmlCleanupEncodingAliases()

XMLPUBFUN void xmlCleanupEncodingAliases

(

void

)

xmlCleanupEncodingAliases:

Unregisters all aliases

Definition at line 976 of file encoding.c.

                                {
    int i;
 
    if (xmlCharEncodingAliases == NULL)
    return;
 
    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
    if (xmlCharEncodingAliases[i].name != NULL)
        xmlFree((char *) xmlCharEncodingAliases[i].name);
    if (xmlCharEncodingAliases[i].alias != NULL)
        xmlFree((char *) xmlCharEncodingAliases[i].alias);
    }
    xmlCharEncodingAliasesNb = 0;
    xmlCharEncodingAliasesMax = 0;
    xmlFree(xmlCharEncodingAliases);
    xmlCharEncodingAliases = NULL;
}

Referenced by xmlCleanupCharEncodingHandlers().

xmlDelEncodingAlias()

XMLPUBFUN int xmlDelEncodingAlias

(

const char *

alias

)

xmlDelEncodingAlias: @alias: the alias name as parsed, in UTF-8 format (ASCII actually)

Unregisters an encoding alias @alias

Returns 0 in case of success, -1 in case of error

Definition at line 1112 of file encoding.c.

                                       {
    int i;
 
    if (alias == NULL)
    return(-1);
 
    if (xmlCharEncodingAliases == NULL)
    return(-1);
    /*
     * Walk down the list looking for a definition of the alias
     */
    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
    if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) {
        xmlFree((char *) xmlCharEncodingAliases[i].name);
        xmlFree((char *) xmlCharEncodingAliases[i].alias);
        xmlCharEncodingAliasesNb--;
        memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1],
            sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i));
        return(0);
    }
    }
    return(-1);
}

xmlDetectCharEncoding()

XMLPUBFUN xmlCharEncoding xmlDetectCharEncoding	(	const unsigned char *	in,
		int	len
	)

xmlDetectCharEncoding: @in: a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). @len: pointer to the length of the buffer

Guess the encoding of the entity using the first bytes of the entity content according to the non-normative appendix F of the XML-1.0 recommendation.

Returns one of the XML_CHAR_ENCODING_... values.

Definition at line 916 of file encoding.c.

{
    if (in == NULL)
        return(XML_CHAR_ENCODING_NONE);
    if (len >= 4) {
    if ((in[0] == 0x00) && (in[1] == 0x00) &&
        (in[2] == 0x00) && (in[3] == 0x3C))
        return(XML_CHAR_ENCODING_UCS4BE);
    if ((in[0] == 0x3C) && (in[1] == 0x00) &&
        (in[2] == 0x00) && (in[3] == 0x00))
        return(XML_CHAR_ENCODING_UCS4LE);
    if ((in[0] == 0x00) && (in[1] == 0x00) &&
        (in[2] == 0x3C) && (in[3] == 0x00))
        return(XML_CHAR_ENCODING_UCS4_2143);
    if ((in[0] == 0x00) && (in[1] == 0x3C) &&
        (in[2] == 0x00) && (in[3] == 0x00))
        return(XML_CHAR_ENCODING_UCS4_3412);
    if ((in[0] == 0x4C) && (in[1] == 0x6F) &&
        (in[2] == 0xA7) && (in[3] == 0x94))
        return(XML_CHAR_ENCODING_EBCDIC);
    if ((in[0] == 0x3C) && (in[1] == 0x3F) &&
        (in[2] == 0x78) && (in[3] == 0x6D))
        return(XML_CHAR_ENCODING_UTF8);
    /*
     * Although not part of the recommendation, we also
     * attempt an "auto-recognition" of UTF-16LE and
     * UTF-16BE encodings.
     */
    if ((in[0] == 0x3C) && (in[1] == 0x00) &&
        (in[2] == 0x3F) && (in[3] == 0x00))
        return(XML_CHAR_ENCODING_UTF16LE);
    if ((in[0] == 0x00) && (in[1] == 0x3C) &&
        (in[2] == 0x00) && (in[3] == 0x3F))
        return(XML_CHAR_ENCODING_UTF16BE);
    }
    if (len >= 3) {
    /*
     * Errata on XML-1.0 June 20 2001
     * We now allow an UTF8 encoded BOM
     */
    if ((in[0] == 0xEF) && (in[1] == 0xBB) &&
        (in[2] == 0xBF))
        return(XML_CHAR_ENCODING_UTF8);
    }
    /* For UTF-16 we can recognize by the BOM */
    if (len >= 2) {
    if ((in[0] == 0xFE) && (in[1] == 0xFF))
        return(XML_CHAR_ENCODING_UTF16BE);
    if ((in[0] == 0xFF) && (in[1] == 0xFE))
        return(XML_CHAR_ENCODING_UTF16LE);
    }
    return(XML_CHAR_ENCODING_NONE);
}

Referenced by internal_parseBuffer().

xmlFindCharEncodingHandler()

XMLPUBFUN xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler

(

const char *

name

)

Definition at line 1677 of file encoding.c.

                                             {
    const char *nalias;
    const char *norig;
    xmlCharEncoding alias;
#ifdef LIBXML_ICONV_ENABLED
    xmlCharEncodingHandlerPtr enc;
    iconv_t icv_in, icv_out;
#endif /* LIBXML_ICONV_ENABLED */
#ifdef LIBXML_ICU_ENABLED
    xmlCharEncodingHandlerPtr encu;
    uconv_t *ucv_in, *ucv_out;
#endif /* LIBXML_ICU_ENABLED */
    char upper[100];
    int i;
 
    if (name == NULL) return(NULL);
    if (name[0] == 0) return(NULL);
 
    /*
     * Do the alias resolution
     */
    norig = name;
    nalias = xmlGetEncodingAlias(name);
    if (nalias != NULL)
    name = nalias;
 
    /*
     * Check first for directly registered encoding names
     */
    for (i = 0;i < 99;i++) {
        upper[i] = (char) toupper((unsigned char) name[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    for (i = 0; i < (int) NUM_DEFAULT_HANDLERS; i++) {
        if (strcmp(upper, defaultHandlers[i].name) == 0)
            return((xmlCharEncodingHandlerPtr) &defaultHandlers[i]);
    }
 
    if (handlers != NULL) {
        for (i = 0;i < nbCharEncodingHandler; i++) {
            if (!strcmp(upper, handlers[i]->name)) {
                return(handlers[i]);
            }
        }
    }
 
#ifdef LIBXML_ICONV_ENABLED
    /* check whether iconv can handle this */
    icv_in = iconv_open("UTF-8", name);
    icv_out = iconv_open(name, "UTF-8");
    if (icv_in == (iconv_t) -1) {
        icv_in = iconv_open("UTF-8", upper);
    }
    if (icv_out == (iconv_t) -1) {
    icv_out = iconv_open(upper, "UTF-8");
    }
    if ((icv_in != (iconv_t) -1) && (icv_out != (iconv_t) -1)) {
        enc = (xmlCharEncodingHandlerPtr)
              xmlMalloc(sizeof(xmlCharEncodingHandler));
        if (enc == NULL) {
            iconv_close(icv_in);
            iconv_close(icv_out);
        return(NULL);
        }
            memset(enc, 0, sizeof(xmlCharEncodingHandler));
        enc->name = xmlMemStrdup(name);
            if (enc->name == NULL) {
                xmlFree(enc);
                iconv_close(icv_in);
                iconv_close(icv_out);
                return(NULL);
            }
        enc->input = NULL;
        enc->output = NULL;
        enc->iconv_in = icv_in;
        enc->iconv_out = icv_out;
        return enc;
    } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) {
        if (icv_in != (iconv_t) -1)
        iconv_close(icv_in);
        else
        iconv_close(icv_out);
    }
#endif /* LIBXML_ICONV_ENABLED */
#ifdef LIBXML_ICU_ENABLED
    /* check whether icu can handle this */
    ucv_in = openIcuConverter(name, 1);
    ucv_out = openIcuConverter(name, 0);
    if (ucv_in != NULL && ucv_out != NULL) {
        encu = (xmlCharEncodingHandlerPtr)
               xmlMalloc(sizeof(xmlCharEncodingHandler));
        if (encu == NULL) {
                closeIcuConverter(ucv_in);
                closeIcuConverter(ucv_out);
        return(NULL);
        }
            memset(encu, 0, sizeof(xmlCharEncodingHandler));
        encu->name = xmlMemStrdup(name);
            if (encu->name == NULL) {
                xmlFree(encu);
                closeIcuConverter(ucv_in);
                closeIcuConverter(ucv_out);
                return(NULL);
            }
        encu->input = NULL;
        encu->output = NULL;
        encu->uconv_in = ucv_in;
        encu->uconv_out = ucv_out;
        return encu;
    } else if (ucv_in != NULL || ucv_out != NULL) {
            closeIcuConverter(ucv_in);
            closeIcuConverter(ucv_out);
    }
#endif /* LIBXML_ICU_ENABLED */
 
    /*
     * Fallback using the canonical names
     */
    alias = xmlParseCharEncoding(norig);
    if (alias != XML_CHAR_ENCODING_ERROR) {
        const char* canon;
        canon = xmlGetCharEncodingName(alias);
        if ((canon != NULL) && (strcmp(name, canon))) {
        return(xmlFindCharEncodingHandler(canon));
        }
    }
 
    /* If "none of the above", give up */
    return(NULL);
}

Referenced by init_char_encoders(), node_transform_write_to_bstr(), node_transform_write_to_stream(), xmlCtxtResetPush(), xmlDetectEBCDIC(), xmlDoRead(), xmlFindCharEncodingHandler(), xmlGetCharEncodingHandler(), xmlParseInNodeContext(), xmlSetDeclaredEncoding(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

xmlGetCharEncodingHandler()

XMLPUBFUN xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler

(

xmlCharEncoding

enc

)

xmlGetCharEncodingHandler: @enc: an xmlCharEncoding value.

Search in the registered set the handler able to read/write that encoding.

Returns the handler or NULL if not found

Definition at line 1547 of file encoding.c.

                                               {
    xmlCharEncodingHandlerPtr handler;
 
    switch (enc) {
        case XML_CHAR_ENCODING_ERROR:
        return(NULL);
        case XML_CHAR_ENCODING_NONE:
        return(NULL);
        case XML_CHAR_ENCODING_UTF8:
        return(NULL);
        case XML_CHAR_ENCODING_UTF16LE:
        return((xmlCharEncodingHandlerPtr) xmlUTF16LEHandler);
        case XML_CHAR_ENCODING_UTF16BE:
        return((xmlCharEncodingHandlerPtr) xmlUTF16BEHandler);
        case XML_CHAR_ENCODING_EBCDIC:
            handler = xmlFindCharEncodingHandler("EBCDIC");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("ebcdic");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("EBCDIC-US");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("IBM-037");
            if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_UCS4BE:
            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS-4");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS4");
            if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_UCS4LE:
            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS-4");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS4");
            if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_UCS4_2143:
        break;
        case XML_CHAR_ENCODING_UCS4_3412:
        break;
        case XML_CHAR_ENCODING_UCS2:
            handler = xmlFindCharEncodingHandler("ISO-10646-UCS-2");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS-2");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("UCS2");
            if (handler != NULL) return(handler);
        break;
 
        /*
         * We used to keep ISO Latin encodings native in the
         * generated data. This led to so many problems that
         * this has been removed. One can still change this
         * back by registering no-ops encoders for those
         */
        case XML_CHAR_ENCODING_8859_1:
        handler = xmlFindCharEncodingHandler("ISO-8859-1");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_2:
        handler = xmlFindCharEncodingHandler("ISO-8859-2");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_3:
        handler = xmlFindCharEncodingHandler("ISO-8859-3");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_4:
        handler = xmlFindCharEncodingHandler("ISO-8859-4");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_5:
        handler = xmlFindCharEncodingHandler("ISO-8859-5");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_6:
        handler = xmlFindCharEncodingHandler("ISO-8859-6");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_7:
        handler = xmlFindCharEncodingHandler("ISO-8859-7");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_8:
        handler = xmlFindCharEncodingHandler("ISO-8859-8");
        if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_8859_9:
        handler = xmlFindCharEncodingHandler("ISO-8859-9");
        if (handler != NULL) return(handler);
        break;
 
 
        case XML_CHAR_ENCODING_2022_JP:
            handler = xmlFindCharEncodingHandler("ISO-2022-JP");
            if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_SHIFT_JIS:
            handler = xmlFindCharEncodingHandler("SHIFT-JIS");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("SHIFT_JIS");
            if (handler != NULL) return(handler);
            handler = xmlFindCharEncodingHandler("Shift_JIS");
            if (handler != NULL) return(handler);
        break;
        case XML_CHAR_ENCODING_EUC_JP:
            handler = xmlFindCharEncodingHandler("EUC-JP");
            if (handler != NULL) return(handler);
        break;
    default:
        break;
    }
 
    return(NULL);
}

Referenced by xmlDetectEBCDIC(), and xmlSwitchEncoding().

xmlGetCharEncodingName()

XMLPUBFUN const char * xmlGetCharEncodingName

(

xmlCharEncoding

enc

)

xmlGetCharEncodingName: @enc: the encoding

The "canonical" name for XML encoding. C.f. http://www.w3.org/TR/REC-xml#charencoding Section 4.3.3 Character Encoding in Entities

Returns the canonical name for the given encoding

Definition at line 1229 of file encoding.c.

                                            {
    switch (enc) {
        case XML_CHAR_ENCODING_ERROR:
        return(NULL);
        case XML_CHAR_ENCODING_NONE:
        return(NULL);
        case XML_CHAR_ENCODING_UTF8:
        return("UTF-8");
        case XML_CHAR_ENCODING_UTF16LE:
        return("UTF-16");
        case XML_CHAR_ENCODING_UTF16BE:
        return("UTF-16");
        case XML_CHAR_ENCODING_EBCDIC:
            return("EBCDIC");
        case XML_CHAR_ENCODING_UCS4LE:
            return("ISO-10646-UCS-4");
        case XML_CHAR_ENCODING_UCS4BE:
            return("ISO-10646-UCS-4");
        case XML_CHAR_ENCODING_UCS4_2143:
            return("ISO-10646-UCS-4");
        case XML_CHAR_ENCODING_UCS4_3412:
            return("ISO-10646-UCS-4");
        case XML_CHAR_ENCODING_UCS2:
            return("ISO-10646-UCS-2");
        case XML_CHAR_ENCODING_8859_1:
        return("ISO-8859-1");
        case XML_CHAR_ENCODING_8859_2:
        return("ISO-8859-2");
        case XML_CHAR_ENCODING_8859_3:
        return("ISO-8859-3");
        case XML_CHAR_ENCODING_8859_4:
        return("ISO-8859-4");
        case XML_CHAR_ENCODING_8859_5:
        return("ISO-8859-5");
        case XML_CHAR_ENCODING_8859_6:
        return("ISO-8859-6");
        case XML_CHAR_ENCODING_8859_7:
        return("ISO-8859-7");
        case XML_CHAR_ENCODING_8859_8:
        return("ISO-8859-8");
        case XML_CHAR_ENCODING_8859_9:
        return("ISO-8859-9");
        case XML_CHAR_ENCODING_2022_JP:
            return("ISO-2022-JP");
        case XML_CHAR_ENCODING_SHIFT_JIS:
            return("Shift-JIS");
        case XML_CHAR_ENCODING_EUC_JP:
            return("EUC-JP");
    case XML_CHAR_ENCODING_ASCII:
        return(NULL);
    }
    return(NULL);
}

Referenced by internal_parseBuffer(), xmlFindCharEncodingHandler(), xmlSwitchEncoding(), and xsltSaveResultTo().

xmlGetEncodingAlias()

XMLPUBFUN const char * xmlGetEncodingAlias

(

const char *

alias

)

xmlGetEncodingAlias: @alias: the alias name as parsed, in UTF-8 format (ASCII actually)

Lookup an encoding name for the given alias.

Returns NULL if not found, otherwise the original name

Definition at line 1003 of file encoding.c.

                                       {
    int i;
    char upper[100];
 
    if (alias == NULL)
    return(NULL);
 
    if (xmlCharEncodingAliases == NULL)
    return(NULL);
 
    for (i = 0;i < 99;i++) {
        upper[i] = (char) toupper((unsigned char) alias[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    /*
     * Walk down the list looking for a definition of the alias
     */
    for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
    if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
        return(xmlCharEncodingAliases[i].name);
    }
    }
    return(NULL);
}

Referenced by xmlFindCharEncodingHandler(), xmlNewCharEncodingHandler(), and xmlParseCharEncoding().

xmlInitCharEncodingHandlers()

XML_DEPRECATED XMLPUBFUN void xmlInitCharEncodingHandlers

(

void

)

xmlInitCharEncodingHandlers:

DEPRECATED: Alias for xmlInitParser.

Definition at line 1460 of file encoding.c.

                                  {
    xmlInitParser();
}

xmlNewCharEncodingHandler()

XMLPUBFUN xmlCharEncodingHandlerPtr xmlNewCharEncodingHandler	(	const char *	name,
		xmlCharEncodingInputFunc	input,
		xmlCharEncodingOutputFunc	output
	)

Definition at line 1394 of file encoding.c.

                                                            {
    xmlCharEncodingHandlerPtr handler;
    const char *alias;
    char upper[500];
    int i;
    char *up = NULL;
 
    /*
     * Do the alias resolution
     */
    alias = xmlGetEncodingAlias(name);
    if (alias != NULL)
    name = alias;
 
    /*
     * Keep only the uppercase version of the encoding.
     */
    if (name == NULL)
    return(NULL);
    for (i = 0;i < 499;i++) {
        upper[i] = (char) toupper((unsigned char) name[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
    up = xmlMemStrdup(upper);
    if (up == NULL)
    return(NULL);
 
    /*
     * allocate and fill-up an handler block.
     */
    handler = (xmlCharEncodingHandlerPtr)
              xmlMalloc(sizeof(xmlCharEncodingHandler));
    if (handler == NULL) {
        xmlFree(up);
    return(NULL);
    }
    memset(handler, 0, sizeof(xmlCharEncodingHandler));
    handler->input = input;
    handler->output = output;
    handler->name = up;
 
#ifdef LIBXML_ICONV_ENABLED
    handler->iconv_in = NULL;
    handler->iconv_out = NULL;
#endif
#ifdef LIBXML_ICU_ENABLED
    handler->uconv_in = NULL;
    handler->uconv_out = NULL;
#endif
 
    /*
     * registers and returns the handler.
     */
    xmlRegisterCharEncodingHandler(handler);
    return(handler);
}

Referenced by init_char_encoders().

xmlParseCharEncoding()

XMLPUBFUN xmlCharEncoding xmlParseCharEncoding

(

const char *

name

)

Definition at line 1148 of file encoding.c.

{
    const char *alias;
    char upper[500];
    int i;
 
    if (name == NULL)
    return(XML_CHAR_ENCODING_NONE);
 
    /*
     * Do the alias resolution
     */
    alias = xmlGetEncodingAlias(name);
    if (alias != NULL)
    name = alias;
 
    for (i = 0;i < 499;i++) {
        upper[i] = (char) toupper((unsigned char) name[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    if (!strcmp(upper, "")) return(XML_CHAR_ENCODING_NONE);
    if (!strcmp(upper, "UTF-8")) return(XML_CHAR_ENCODING_UTF8);
    if (!strcmp(upper, "UTF8")) return(XML_CHAR_ENCODING_UTF8);
 
    /*
     * NOTE: if we were able to parse this, the endianness of UTF16 is
     *       already found and in use
     */
    if (!strcmp(upper, "UTF-16")) return(XML_CHAR_ENCODING_UTF16LE);
    if (!strcmp(upper, "UTF16")) return(XML_CHAR_ENCODING_UTF16LE);
 
    if (!strcmp(upper, "ISO-10646-UCS-2")) return(XML_CHAR_ENCODING_UCS2);
    if (!strcmp(upper, "UCS-2")) return(XML_CHAR_ENCODING_UCS2);
    if (!strcmp(upper, "UCS2")) return(XML_CHAR_ENCODING_UCS2);
 
    /*
     * NOTE: if we were able to parse this, the endianness of UCS4 is
     *       already found and in use
     */
    if (!strcmp(upper, "ISO-10646-UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
    if (!strcmp(upper, "UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
    if (!strcmp(upper, "UCS4")) return(XML_CHAR_ENCODING_UCS4LE);
 
 
    if (!strcmp(upper,  "ISO-8859-1")) return(XML_CHAR_ENCODING_8859_1);
    if (!strcmp(upper,  "ISO-LATIN-1")) return(XML_CHAR_ENCODING_8859_1);
    if (!strcmp(upper,  "ISO LATIN 1")) return(XML_CHAR_ENCODING_8859_1);
 
    if (!strcmp(upper,  "ISO-8859-2")) return(XML_CHAR_ENCODING_8859_2);
    if (!strcmp(upper,  "ISO-LATIN-2")) return(XML_CHAR_ENCODING_8859_2);
    if (!strcmp(upper,  "ISO LATIN 2")) return(XML_CHAR_ENCODING_8859_2);
 
    if (!strcmp(upper,  "ISO-8859-3")) return(XML_CHAR_ENCODING_8859_3);
    if (!strcmp(upper,  "ISO-8859-4")) return(XML_CHAR_ENCODING_8859_4);
    if (!strcmp(upper,  "ISO-8859-5")) return(XML_CHAR_ENCODING_8859_5);
    if (!strcmp(upper,  "ISO-8859-6")) return(XML_CHAR_ENCODING_8859_6);
    if (!strcmp(upper,  "ISO-8859-7")) return(XML_CHAR_ENCODING_8859_7);
    if (!strcmp(upper,  "ISO-8859-8")) return(XML_CHAR_ENCODING_8859_8);
    if (!strcmp(upper,  "ISO-8859-9")) return(XML_CHAR_ENCODING_8859_9);
 
    if (!strcmp(upper, "ISO-2022-JP")) return(XML_CHAR_ENCODING_2022_JP);
    if (!strcmp(upper, "SHIFT_JIS")) return(XML_CHAR_ENCODING_SHIFT_JIS);
    if (!strcmp(upper, "EUC-JP")) return(XML_CHAR_ENCODING_EUC_JP);
 
    return(XML_CHAR_ENCODING_ERROR);
}

Referenced by xmlFindCharEncodingHandler().

xmlRegisterCharEncodingHandler()

XMLPUBFUN void xmlRegisterCharEncodingHandler

(

xmlCharEncodingHandlerPtr

handler

)

xmlRegisterCharEncodingHandler: @handler: the xmlCharEncodingHandlerPtr handler block

Register the char encoding handler, surprising, isn't it ?

Definition at line 1515 of file encoding.c.

                                                                  {
    if (handler == NULL)
        return;
    if (handlers == NULL) {
        handlers = xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(handlers[0]));
        if (handlers == NULL)
            goto free_handler;
    }
 
    if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS)
        goto free_handler;
    handlers[nbCharEncodingHandler++] = handler;
    return;
 
free_handler:
    if (handler != NULL) {
        if (handler->name != NULL) {
            xmlFree(handler->name);
        }
        xmlFree(handler);
    }
}

Referenced by xmlNewCharEncodingHandler().