encoding.h File Reference

#include <libxml/xmlversion.h>
#include <libxml/tree.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	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 XMLCALL	xmlInitCharEncodingHandlers (void)
XML_DEPRECATED XMLPUBFUN void XMLCALL	xmlCleanupCharEncodingHandlers (void)
XMLPUBFUN void XMLCALL	xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler)
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL	xmlGetCharEncodingHandler (xmlCharEncoding enc)
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL	xmlFindCharEncodingHandler (const char *name)
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL	xmlNewCharEncodingHandler (const char *name, xmlCharEncodingInputFunc input, xmlCharEncodingOutputFunc output)
XMLPUBFUN int XMLCALL	xmlAddEncodingAlias (const char *name, const char *alias)
XMLPUBFUN int XMLCALL	xmlDelEncodingAlias (const char *alias)
XMLPUBFUN const char *XMLCALL	xmlGetEncodingAlias (const char *alias)
XMLPUBFUN void XMLCALL	xmlCleanupEncodingAliases (void)
XMLPUBFUN xmlCharEncoding XMLCALL	xmlParseCharEncoding (const char *name)
XMLPUBFUN const char *XMLCALL	xmlGetCharEncodingName (xmlCharEncoding enc)
XMLPUBFUN xmlCharEncoding XMLCALL	xmlDetectCharEncoding (const unsigned char *in, int len)
XMLPUBFUN int XMLCALL	xmlCharEncOutFunc (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in)
XMLPUBFUN int XMLCALL	xmlCharEncInFunc (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in)
XMLPUBFUN int XMLCALL	xmlCharEncFirstLine (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in)
XMLPUBFUN int XMLCALL	xmlCharEncCloseFunc (xmlCharEncodingHandler *handler)
XMLPUBFUN int XMLCALL	isolat1ToUTF8 (unsigned char *out, int *outlen, const unsigned char *in, int *inlen)

Typedef Documentation

xmlCharEncodingHandler

typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler

Definition at line 129 of file encoding.h.

xmlCharEncodingHandlerPtr

typedef xmlCharEncodingHandler* xmlCharEncodingHandlerPtr

Definition at line 130 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 99 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 121 of file encoding.h.

Enumeration Type Documentation

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 56 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 XMLCALL 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 if success, or -1 otherwise 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 316 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(-1);
 
    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);
}

Referenced by xmlInitCharEncodingHandlers().

xmlAddEncodingAlias()

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

Definition at line 1077 of file encoding.c.

                                                         {
    int i;
    char upper[100];
 
    if ((name == NULL) || (alias == NULL))
    return(-1);
 
    for (i = 0;i < 99;i++) {
        upper[i] = toupper(alias[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    if (xmlCharEncodingAliases == NULL) {
    xmlCharEncodingAliasesNb = 0;
    xmlCharEncodingAliasesMax = 20;
    xmlCharEncodingAliases = (xmlCharEncodingAliasPtr)
          xmlMalloc(xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
    if (xmlCharEncodingAliases == NULL)
        return(-1);
    } else if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) {
    xmlCharEncodingAliasesMax *= 2;
    xmlCharEncodingAliases = (xmlCharEncodingAliasPtr)
          xmlRealloc(xmlCharEncodingAliases,
                 xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
    }
    /*
     * 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.
         */
        xmlFree((char *) xmlCharEncodingAliases[i].name);
        xmlCharEncodingAliases[i].name = xmlMemStrdup(name);
        return(0);
    }
    }
    /*
     * Add the definition
     */
    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = xmlMemStrdup(name);
    xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = xmlMemStrdup(upper);
    xmlCharEncodingAliasesNb++;
    return(0);
}

Referenced by main().

xmlCharEncCloseFunc()

XMLPUBFUN int XMLCALL xmlCharEncCloseFunc

(

xmlCharEncodingHandler *

handler

)

xmlCharEncCloseFunc: @handler: char encoding transformation data structure

Generic front-end for encoding handler close function

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

Definition at line 2796 of file encoding.c.

                                                     {
    int ret = 0;
    int tofree = 0;
    int i, handler_in_list = 0;
 
    /* Avoid unused variable warning if features are disabled. */
    (void) handler_in_list;
 
    if (handler == NULL) return(-1);
    if (handler->name == NULL) return(-1);
    if (handlers != NULL) {
        for (i = 0;i < nbCharEncodingHandler; i++) {
            if (handler == handlers[i]) {
            handler_in_list = 1;
        break;
        }
    }
    }
#ifdef LIBXML_ICONV_ENABLED
    /*
     * Iconv handlers can be used only once, free the whole block.
     * and the associated icon resources.
     */
    if ((handler_in_list == 0) &&
        ((handler->iconv_out != NULL) || (handler->iconv_in != NULL))) {
        tofree = 1;
    if (handler->iconv_out != NULL) {
        if (iconv_close(handler->iconv_out))
        ret = -1;
        handler->iconv_out = NULL;
    }
    if (handler->iconv_in != NULL) {
        if (iconv_close(handler->iconv_in))
        ret = -1;
        handler->iconv_in = NULL;
    }
    }
#endif /* LIBXML_ICONV_ENABLED */
#ifdef LIBXML_ICU_ENABLED
    if ((handler_in_list == 0) &&
        ((handler->uconv_out != NULL) || (handler->uconv_in != NULL))) {
        tofree = 1;
    if (handler->uconv_out != NULL) {
        closeIcuConverter(handler->uconv_out);
        handler->uconv_out = NULL;
    }
    if (handler->uconv_in != NULL) {
        closeIcuConverter(handler->uconv_in);
        handler->uconv_in = NULL;
    }
    }
#endif
    if (tofree) {
        /* free up only dynamic handlers iconv/uconv */
        if (handler->name != NULL)
            xmlFree(handler->name);
        handler->name = NULL;
        xmlFree(handler);
    }
#ifdef DEBUG_ENCODING
    if (ret)
        xmlGenericError(xmlGenericErrorContext,
        "failed to close the encoding handler\n");
    else
        xmlGenericError(xmlGenericErrorContext,
        "closed the encoding handler\n");
#endif
 
    return(ret);
}

Referenced by xmlSwitchInputEncodingInt().

xmlCharEncFirstLine()

XMLPUBFUN int XMLCALL xmlCharEncFirstLine	(	xmlCharEncodingHandler *	handler,
		xmlBufferPtr	out,
		xmlBufferPtr	in
	)

xmlCharEncFirstLine: @handler: char encoding transformation data structure @out: an xmlBuffer for the output. @in: an xmlBuffer for the input

Front-end for the encoding handler input function, but handle only the very first line, i.e. limit itself to 45 chars.

Returns the number of byte written if success, or -1 general error -2 if the transcoding fails (for *in is not valid utf8 string or the result of transformation can't fit into the encoding we want), or

Definition at line 2160 of file encoding.c.

                                  {
    return(xmlCharEncFirstLineInt(handler, out, in, -1));
}

xmlCharEncInFunc()

XMLPUBFUN int XMLCALL xmlCharEncInFunc	(	xmlCharEncodingHandler *	handler,
		xmlBufferPtr	out,
		xmlBufferPtr	in
	)

xmlCharEncInFunc: @handler: char encoding transformation data structure @out: an xmlBuffer for the output. @in: an xmlBuffer for the input

Generic front-end for the encoding handler input function

Returns the number of byte written if success, or -1 general error -2 if the transcoding fails (for *in is not valid utf8 string or the result of transformation can't fit into the encoding we want), or

Definition at line 2383 of file encoding.c.

{
    int ret;
    int written;
    int toconv;
 
    if (handler == NULL)
        return (-1);
    if (out == NULL)
        return (-1);
    if (in == NULL)
        return (-1);
 
    toconv = in->use;
    if (toconv == 0)
        return (0);
    written = out->size - out->use -1; /* count '\0' */
    if (toconv * 2 >= written) {
        xmlBufferGrow(out, out->size + toconv * 2);
        written = out->size - out->use - 1;
    }
    ret = xmlEncInputChunk(handler, &out->content[out->use], &written,
                           in->content, &toconv, 1);
    xmlBufferShrink(in, toconv);
    out->use += written;
    out->content[out->use] = 0;
    if (ret == -1)
        ret = -3;
 
    switch (ret) {
        case 0:
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
                            "converted %d bytes to %d bytes of input\n",
                            toconv, written);
#endif
            break;
        case -1:
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
                         "converted %d bytes to %d bytes of input, %d left\n",
                            toconv, written, in->use);
#endif
            break;
        case -3:
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
                        "converted %d bytes to %d bytes of input, %d left\n",
                            toconv, written, in->use);
#endif
            break;
        case -2: {
            char buf[50];
 
        snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
             in->content[0], in->content[1],
             in->content[2], in->content[3]);
        buf[49] = 0;
        xmlEncodingErr(XML_I18N_CONV_FAILED,
            "input conversion failed due to input error, bytes %s\n",
                   buf);
        }
    }
    /*
     * Ignore when input buffer is not on a boundary
     */
    if (ret == -3)
        ret = 0;
    return (written? written : ret);
}

xmlCharEncOutFunc()

XMLPUBFUN int XMLCALL xmlCharEncOutFunc	(	xmlCharEncodingHandler *	handler,
		xmlBufferPtr	out,
		xmlBufferPtr	in
	)

xmlCharEncOutFunc: @handler: char encoding transformation data structure @out: an xmlBuffer for the output. @in: an xmlBuffer for the input

Generic front-end for the encoding handler output function a first call with @in == NULL has to be made firs to initiate the output in case of non-stateless encoding needing to initiate their state or the output (like the BOM in UTF16). In case of UTF8 sequence conversion errors for the given encoder, the content will be automatically remapped to a CharRef sequence.

Returns the number of byte written if success, or -1 general error -2 if the transcoding fails (for *in is not valid utf8 string or the result of transformation can't fit into the encoding we want), or

Definition at line 2645 of file encoding.c.

                                   {
    int ret;
    int written;
    int writtentot = 0;
    int toconv;
 
    if (handler == NULL) return(-1);
    if (out == NULL) return(-1);
 
retry:
 
    written = out->size - out->use;
 
    if (written > 0)
    written--; /* Gennady: count '/0' */
 
    /*
     * First specific handling of in = NULL, i.e. the initialization call
     */
    if (in == NULL) {
        toconv = 0;
        /* TODO: Check return value. */
        xmlEncOutputChunk(handler, &out->content[out->use], &written,
                          NULL, &toconv);
        out->use += written;
        out->content[out->use] = 0;
#ifdef DEBUG_ENCODING
    xmlGenericError(xmlGenericErrorContext,
        "initialized encoder\n");
#endif
        return(0);
    }
 
    /*
     * Conversion itself.
     */
    toconv = in->use;
    if (toconv == 0)
    return(0);
    if (toconv * 4 >= written) {
        xmlBufferGrow(out, toconv * 4);
    written = out->size - out->use - 1;
    }
    ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
                            in->content, &toconv);
    xmlBufferShrink(in, toconv);
    out->use += written;
    writtentot += written;
    out->content[out->use] = 0;
    if (ret == -1) {
        if (written > 0) {
            /* Can be a limitation of iconv or uconv */
            goto retry;
        }
        ret = -3;
    }
 
    /*
     * Attempt to handle error cases
     */
    switch (ret) {
        case 0:
#ifdef DEBUG_ENCODING
        xmlGenericError(xmlGenericErrorContext,
            "converted %d bytes to %d bytes of output\n",
                toconv, written);
#endif
        break;
        case -1:
#ifdef DEBUG_ENCODING
        xmlGenericError(xmlGenericErrorContext,
            "output conversion failed by lack of space\n");
#endif
        break;
        case -3:
#ifdef DEBUG_ENCODING
        xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n",
                toconv, written, in->use);
#endif
        break;
        case -4:
        xmlEncodingErr(XML_I18N_NO_OUTPUT,
                   "xmlCharEncOutFunc: no output function !\n", NULL);
        ret = -1;
            break;
        case -2: {
        xmlChar charref[20];
        int len = in->use;
        const xmlChar *utf = (const xmlChar *) in->content;
        int cur, charrefLen;
 
        cur = xmlGetUTF8Char(utf, &len);
        if (cur <= 0)
                break;
 
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
                    "handling output conversion error\n");
            xmlGenericError(xmlGenericErrorContext,
                    "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
                    in->content[0], in->content[1],
                    in->content[2], in->content[3]);
#endif
            /*
             * Removes the UTF8 sequence, and replace it by a charref
             * and continue the transcoding phase, hoping the error
             * did not mangle the encoder state.
             */
            charrefLen = snprintf((char *) &charref[0], sizeof(charref),
                             "&#%d;", cur);
            xmlBufferShrink(in, len);
            xmlBufferGrow(out, charrefLen * 4);
        written = out->size - out->use - 1;
            toconv = charrefLen;
            ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
                                    charref, &toconv);
 
        if ((ret < 0) || (toconv != charrefLen)) {
        char buf[50];
 
        snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
             in->content[0], in->content[1],
             in->content[2], in->content[3]);
        buf[49] = 0;
        xmlEncodingErr(XML_I18N_CONV_FAILED,
            "output conversion failed due to conv error, bytes %s\n",
                   buf);
        if (in->alloc != XML_BUFFER_ALLOC_IMMUTABLE)
            in->content[0] = ' ';
            break;
        }
 
            out->use += written;
            writtentot += written;
            out->content[out->use] = 0;
            goto retry;
    }
    }
    return(writtentot ? writtentot : ret);
}

xmlCleanupCharEncodingHandlers()

XML_DEPRECATED XMLPUBFUN void XMLCALL 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 1483 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;
    xmlDefaultCharEncodingHandler = NULL;
}

Referenced by xmlCleanupParser().

xmlCleanupEncodingAliases()

XMLPUBFUN void XMLCALL xmlCleanupEncodingAliases

(

void

)

xmlCleanupEncodingAliases:

Unregisters all aliases

Definition at line 1012 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 XMLCALL 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 1134 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 XMLCALL 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 952 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 xmlCtxtResetPush(), xmlParseDocument(), xmlParseExternalEntityPrivate(), xmlParseExternalSubset(), xmlParseExtParsedEnt(), xmlParsePEReference(), and xmlSAX2ExternalSubset().

xmlFindCharEncodingHandler()

XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler

(

const char *

name

)

Definition at line 1678 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 (handlers == NULL) xmlInitCharEncodingHandlers();
    if (name == NULL) return(xmlDefaultCharEncodingHandler);
    if (name[0] == 0) return(xmlDefaultCharEncodingHandler);
 
    /*
     * 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] = toupper(name[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
 
    if (handlers != NULL) {
        for (i = 0;i < nbCharEncodingHandler; i++) {
            if (!strcmp(upper, handlers[i]->name)) {
#ifdef DEBUG_ENCODING
                xmlGenericError(xmlGenericErrorContext,
                        "Found registered handler for encoding %s\n", name);
#endif
                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);
        enc->input = NULL;
        enc->output = NULL;
        enc->iconv_in = icv_in;
        enc->iconv_out = icv_out;
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
            "Found iconv handler for encoding %s\n", name);
#endif
        return enc;
    } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) {
        xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
            "iconv : problems with filters for '%s'\n", name);
        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);
        encu->input = NULL;
        encu->output = NULL;
        encu->uconv_in = ucv_in;
        encu->uconv_out = ucv_out;
#ifdef DEBUG_ENCODING
            xmlGenericError(xmlGenericErrorContext,
            "Found ICU converter handler for encoding %s\n", name);
#endif
        return encu;
    } else if (ucv_in != NULL || ucv_out != NULL) {
            closeIcuConverter(ucv_in);
            closeIcuConverter(ucv_out);
        xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
            "ICU converter : problems with filters for '%s'\n", name);
    }
#endif /* LIBXML_ICU_ENABLED */
 
#ifdef DEBUG_ENCODING
    xmlGenericError(xmlGenericErrorContext,
        "No handler found for encoding %s\n", name);
#endif
 
    /*
     * 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 xmlCtxtResetPush(), xmlDoRead(), xmlFindCharEncodingHandler(), xmlGetCharEncodingHandler(), xmlParseEncodingDecl(), xmlParseInNodeContext(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

xmlGetCharEncodingHandler()

XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL 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 1544 of file encoding.c.

                                               {
    xmlCharEncodingHandlerPtr handler;
 
    if (handlers == NULL) xmlInitCharEncodingHandlers();
    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(xmlUTF16LEHandler);
        case XML_CHAR_ENCODING_UTF16BE:
        return(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;
    }
 
#ifdef DEBUG_ENCODING
    xmlGenericError(xmlGenericErrorContext,
        "No handler found for encoding %d\n", enc);
#endif
    return(NULL);
}

Referenced by xmlSwitchEncoding().

xmlGetCharEncodingName()

XMLPUBFUN const char *XMLCALL 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 1254 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 xmlFindCharEncodingHandler(), xmlSwitchEncoding(), and xsltSaveResultTo().

xmlGetEncodingAlias()

XMLPUBFUN const char *XMLCALL 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 1039 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] = toupper(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 XMLCALL xmlInitCharEncodingHandlers

(

void

)

xmlInitCharEncodingHandlers:

DEPRECATED: This function will be made private. Call xmlInitParser to initialize the library.

Initialize the char encoding support, it registers the default encoding supported. NOTE: while public, this function usually doesn't need to be called in normal processing.

Definition at line 1420 of file encoding.c.

                                  {
    unsigned short int tst = 0x1234;
    unsigned char *ptr = (unsigned char *) &tst;
 
    if (handlers != NULL) return;
 
    handlers = (xmlCharEncodingHandlerPtr *)
        xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(xmlCharEncodingHandlerPtr));
 
    if (*ptr == 0x12) xmlLittleEndian = 0;
    else if (*ptr == 0x34) xmlLittleEndian = 1;
    else {
        xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
                   "Odd problem at endianness detection\n", NULL);
    }
 
    if (handlers == NULL) {
        xmlEncodingErrMemory("xmlInitCharEncodingHandlers : out of memory !\n");
    return;
    }
    xmlNewCharEncodingHandler("UTF-8", UTF8ToUTF8, UTF8ToUTF8);
#ifdef LIBXML_OUTPUT_ENABLED
    xmlUTF16LEHandler =
          xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE);
    xmlUTF16BEHandler =
          xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE);
    xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, UTF8ToUTF16);
    xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, UTF8Toisolat1);
    xmlNewCharEncodingHandler("ASCII", asciiToUTF8, UTF8Toascii);
    xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, UTF8Toascii);
#ifdef LIBXML_HTML_ENABLED
    xmlNewCharEncodingHandler("HTML", NULL, UTF8ToHtml);
#endif
#else
    xmlUTF16LEHandler =
          xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, NULL);
    xmlUTF16BEHandler =
          xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, NULL);
    xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, NULL);
    xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, NULL);
    xmlNewCharEncodingHandler("ASCII", asciiToUTF8, NULL);
    xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, NULL);
#endif /* LIBXML_OUTPUT_ENABLED */
#if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED)
#ifdef LIBXML_ISO8859X_ENABLED
    xmlRegisterCharEncodingHandlersISO8859x ();
#endif
#endif
 
}

Referenced by xmlFindCharEncodingHandler(), xmlGetCharEncodingHandler(), xmlInitParser(), and xmlRegisterCharEncodingHandler().

xmlNewCharEncodingHandler()

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

Definition at line 1338 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) {
        xmlEncodingErr(XML_I18N_NO_NAME,
               "xmlNewCharEncodingHandler : no name !\n", NULL);
    return(NULL);
    }
    for (i = 0;i < 499;i++) {
        upper[i] = toupper(name[i]);
    if (upper[i] == 0) break;
    }
    upper[i] = 0;
    up = xmlMemStrdup(upper);
    if (up == NULL) {
        xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n");
    return(NULL);
    }
 
    /*
     * allocate and fill-up an handler block.
     */
    handler = (xmlCharEncodingHandlerPtr)
              xmlMalloc(sizeof(xmlCharEncodingHandler));
    if (handler == NULL) {
        xmlFree(up);
        xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n");
    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);
#ifdef DEBUG_ENCODING
    xmlGenericError(xmlGenericErrorContext,
        "Registered encoding handler for %s\n", name);
#endif
    return(handler);
}

Referenced by xmlInitCharEncodingHandlers().

xmlParseCharEncoding()

XMLPUBFUN xmlCharEncoding XMLCALL xmlParseCharEncoding

(

const char *

name

)

Definition at line 1170 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] = toupper(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);
 
#ifdef DEBUG_ENCODING
    xmlGenericError(xmlGenericErrorContext, "Unknown encoding %s\n", name);
#endif
    return(XML_CHAR_ENCODING_ERROR);
}

Referenced by xmlFindCharEncodingHandler().

xmlRegisterCharEncodingHandler()

XMLPUBFUN void XMLCALL xmlRegisterCharEncodingHandler

(

xmlCharEncodingHandlerPtr

handler

)

xmlRegisterCharEncodingHandler: @handler: the xmlCharEncodingHandlerPtr handler block

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

Definition at line 1509 of file encoding.c.

                                                                  {
    if (handlers == NULL) xmlInitCharEncodingHandlers();
    if ((handler == NULL) || (handlers == NULL)) {
        xmlEncodingErr(XML_I18N_NO_HANDLER,
        "xmlRegisterCharEncodingHandler: NULL handler !\n", NULL);
        goto free_handler;
    }
 
    if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {
        xmlEncodingErr(XML_I18N_EXCESS_HANDLER,
    "xmlRegisterCharEncodingHandler: Too many handler registered, see %s\n",
                   "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().