#include "libxml.h"
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <stdlib.h>
#include <libxml/encoding.h>
#include <libxml/xmlmemory.h>
#include <libxml/globals.h>
#include <libxml/xmlerror.h>
#include "buf.h"
#include "enc.h"
#include "elfgcchack.h"

Include dependency graph for encoding.c:

Classes
struct	_xmlCharEncodingAlias

Macros
#define	IN_LIBXML

Typedefs
typedef struct _xmlCharEncodingAlias	xmlCharEncodingAlias

typedef xmlCharEncodingAlias *	xmlCharEncodingAliasPtr

Functions
static void	xmlEncodingErrMemory (const char *extra)

static void	LIBXML_ATTR_FORMAT (2, 0)

static int	asciiToUTF8 (unsigned char out, int outlen, const unsigned char in, int inlen)

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

static int	UTF8ToUTF8 (unsigned char out, int outlen, const unsigned char inb, int inlenb)

static int	UTF16LEToUTF8 (unsigned char out, int outlen, const unsigned char inb, int inlenb)

static int	UTF16BEToUTF8 (unsigned char out, int outlen, const unsigned char inb, int inlenb)

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

void	xmlCleanupEncodingAliases (void)

const char *	xmlGetEncodingAlias (const char *alias)

. Existing alias
will be overwritten. Returns 0 in case of success, -1 in case of error
int	xmlAddEncodingAlias (const char name, const char alias)

int	xmlDelEncodingAlias (const char *alias)

: the encoding name, in UTF-8 format (ASCII actually)
xmlNewCharEncodingHandler: @input: the xmlCharEncodingInputFunc to read that encoding @output: the xmlCharEncodingOutputFunc to write that encoding Create and registers an xmlCharEncodingHandler. Returns the xmlCharEncodingHandlerPtr created (or NULL in case of error).
xmlCharEncodingHandlerPtr	xmlNewCharEncodingHandler (const char *name, xmlCharEncodingInputFunc input, xmlCharEncodingOutputFunc output)

void	xmlInitCharEncodingHandlers (void)

void	xmlCleanupCharEncodingHandlers (void)

void	xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler)

xmlCharEncodingHandlerPtr	xmlGetCharEncodingHandler (xmlCharEncoding enc)

Variables
static xmlCharEncodingHandlerPtr	xmlUTF16LEHandler = NULL

static xmlCharEncodingHandlerPtr	xmlUTF16BEHandler = NULL

static xmlCharEncodingAliasPtr	xmlCharEncodingAliases = NULL

static int	xmlCharEncodingAliasesNb = 0

static int	xmlCharEncodingAliasesMax = 0

static int	xmlLittleEndian = 1

: the encoding name as parsed, in UTF-8 format (ASCII actually)
xmlParseCharEncoding: Compare the string to the encoding schemes already known. Note that the comparison is case insensitive accordingly to the section [XML] 4.3.3 Character Encoding in Entities. Returns one of the XML_CHAR_ENCODING_... values or XML_CHAR_ENCODING_NONE if not recognized.
#define	MAX_ENCODING_HANDLERS 50

static xmlCharEncodingHandlerPtr *	handlers = NULL

static int	nbCharEncodingHandler = 0

static xmlCharEncodingHandlerPtr	xmlDefaultCharEncodingHandler = NULL

xmlCharEncoding	xmlParseCharEncoding (const char *name)

const char *	xmlGetCharEncodingName (xmlCharEncoding enc)

: a string describing the char encoding.
xmlFindCharEncodingHandler: Search in the registered set the handler able to read/write that encoding. Returns the handler or NULL if not found
#define	bottom_encoding

xmlCharEncodingHandlerPtr	xmlFindCharEncodingHandler (const char *name)

static int	xmlEncInputChunk (xmlCharEncodingHandler handler, unsigned char out, int outlen, const unsigned char in, int *inlen, int flush)

static int	xmlEncOutputChunk (xmlCharEncodingHandler handler, unsigned char out, int outlen, const unsigned char in, int *inlen)

int	xmlCharEncFirstLineInt (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in, int len)

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

int	xmlCharEncFirstLineInput (xmlParserInputBufferPtr input, int len)

int	xmlCharEncInput (xmlParserInputBufferPtr input, int flush)

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

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

int	xmlCharEncCloseFunc (xmlCharEncodingHandler *handler)

long	xmlByteConsumed (xmlParserCtxtPtr ctxt)

Macro Definition Documentation

◆ bottom_encoding

#define bottom_encoding

Definition at line 3917 of file encoding.c.

◆ IN_LIBXML

#define IN_LIBXML

Definition at line 23 of file encoding.c.

◆ MAX_ENCODING_HANDLERS

#define MAX_ENCODING_HANDLERS 50

Definition at line 1296 of file encoding.c.

Typedef Documentation

◆ xmlCharEncodingAlias

typedef struct _xmlCharEncodingAlias xmlCharEncodingAlias

Definition at line 54 of file encoding.c.

◆ xmlCharEncodingAliasPtr

typedef xmlCharEncodingAlias* xmlCharEncodingAliasPtr

Definition at line 55 of file encoding.c.

Function Documentation

◆ asciiToUTF8()

static int asciiToUTF8	(	unsigned char *	out,
		int *	outlen,
		const unsigned char *	in,
		int *	inlen
	)

static

asciiToUTF8: @out: a pointer to an array of bytes to store the result @outlen: the length of @out @in: a pointer to an array of ASCII chars @inlen: the length of @in

Take a block of ASCII chars in and try to convert it to an UTF-8 block of chars out. Returns 0 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 consumed.

Definition at line 176 of file encoding.c.

                                                    {
     unsigned char* outstart = out;
     const unsigned char* base = in;
     const unsigned char* processed = in;
     unsigned char* outend = out + *outlen;
     const unsigned char* inend;
     unsigned int c;
 
     inend = in + (*inlen);
     while ((in < inend) && (out - outstart + 5 < *outlen)) {
     c= *in++;
 
         if (out >= outend)
         break;
         if (c < 0x80) {
         *out++ = c;
     } else {
         *outlen = out - outstart;
         *inlen = processed - base;
         return(-1);
     }
 
     processed = (const unsigned char*) in;
     }
     *outlen = out - outstart;
     *inlen = processed - base;
     return(*outlen);
 }

Referenced by xmlInitCharEncodingHandlers().

◆ isolat1ToUTF8()

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 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 consumed.

Definition at line 307 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().

◆ LIBXML_ATTR_FORMAT()

static void LIBXML_ATTR_FORMAT	(	2	,
		0
	)

static

xmlErrEncoding: @error: the error number @msg: the error message

n encoding error

Definition at line 96 of file encoding.c.

 {
     __xmlRaiseError(NULL, NULL, NULL, NULL, NULL,
                     XML_FROM_I18N, error, XML_ERR_FATAL,
                     NULL, 0, val, NULL, NULL, 0, 0, msg, val);
 }

◆ UTF16BEToUTF8()

static int UTF16BEToUTF8	(	unsigned char *	out,
		int *	outlen,
		const unsigned char *	inb,
		int *	inlenb
	)

static

UTF16BEToUTF8: @out: a pointer to an array of bytes to store the result @outlen: the length of @out @inb: a pointer to an array of UTF-16 passed as a byte array @inlenb: the length of @in in UTF-16 chars

Take a block of UTF-16 ushorts in and try to convert it to an UTF-8 block of chars out. This function assumes the endian property is the same between the native type of this machine and the inputed one.

Returns the number of bytes written, or -1 if lack of space, or -2 if the transcoding fails (if *in is not a valid utf16 string) The value of *inlen after return is the number of octets consumed if the return value is positive, else unpredictable.

Definition at line 732 of file encoding.c.

 {
     unsigned char* outstart = out;
     const unsigned char* processed = inb;
     unsigned char* outend = out + *outlen;
     unsigned short* in = (unsigned short*) inb;
     unsigned short* inend;
     unsigned int c, d, inlen;
     unsigned char *tmp;
     int bits;
 
     if ((*inlenb % 2) == 1)
         (*inlenb)--;
     inlen = *inlenb / 2;
     inend= in + inlen;
     while (in < inend) {
     if (xmlLittleEndian) {
         tmp = (unsigned char *) in;
         c = *tmp++;
         c = c << 8;
         c = c | (unsigned int) *tmp;
         in++;
     } else {
         c= *in++;
     }
         if ((c & 0xFC00) == 0xD800) {    /* surrogates */
         if (in >= inend) {           /* (in > inend) shouldn't happens */
         *outlen = out - outstart;
         *inlenb = processed - inb;
             return(-2);
         }
         if (xmlLittleEndian) {
         tmp = (unsigned char *) in;
         d = *tmp++;
         d = d << 8;
         d = d | (unsigned int) *tmp;
         in++;
         } else {
         d= *in++;
         }
             if ((d & 0xFC00) == 0xDC00) {
                 c &= 0x03FF;
                 c <<= 10;
                 c |= d & 0x03FF;
                 c += 0x10000;
             }
             else {
         *outlen = out - outstart;
         *inlenb = processed - inb;
             return(-2);
         }
         }
 
     /* assertion: c is a single UTF-4 value */
         if (out >= outend)
         break;
         if      (c <    0x80) {  *out++=  c;                bits= -6; }
         else if (c <   0x800) {  *out++= ((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
         else if (c < 0x10000) {  *out++= ((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
         else                  {  *out++= ((c >> 18) & 0x07) | 0xF0;  bits= 12; }
 
         for ( ; bits >= 0; bits-= 6) {
             if (out >= outend)
             break;
             *out++= ((c >> bits) & 0x3F) | 0x80;
         }
     processed = (const unsigned char*) in;
     }
     *outlen = out - outstart;
     *inlenb = processed - inb;
     return(*outlen);
 }

Referenced by xmlInitCharEncodingHandlers().

◆ UTF16LEToUTF8()

static int UTF16LEToUTF8	(	unsigned char *	out,
		int *	outlen,
		const unsigned char *	inb,
		int *	inlenb
	)

static

UTF16LEToUTF8: @out: a pointer to an array of bytes to store the result @outlen: the length of @out @inb: a pointer to an array of UTF-16LE passwd as a byte array @inlenb: the length of @in in UTF-16LE chars

Take a block of UTF-16LE ushorts in and try to convert it to an UTF-8 block of chars out. This function assumes the endian property is the same between the native type of this machine and the inputed one.

Returns the number of bytes written, or -1 if lack of space, or -2 if the transcoding fails (if *in is not a valid utf16 string) The value of *inlen after return is the number of octets consumed if the return value is positive, else unpredictable.

Definition at line 494 of file encoding.c.

 {
     unsigned char* outstart = out;
     const unsigned char* processed = inb;
     unsigned char* outend = out + *outlen;
     unsigned short* in = (unsigned short*) inb;
     unsigned short* inend;
     unsigned int c, d, inlen;
     unsigned char *tmp;
     int bits;
 
     if ((*inlenb % 2) == 1)
         (*inlenb)--;
     inlen = *inlenb / 2;
     inend = in + inlen;
     while ((in < inend) && (out - outstart + 5 < *outlen)) {
         if (xmlLittleEndian) {
         c= *in++;
     } else {
         tmp = (unsigned char *) in;
         c = *tmp++;
         c = c | (((unsigned int)*tmp) << 8);
         in++;
     }
         if ((c & 0xFC00) == 0xD800) {    /* surrogates */
         if (in >= inend) {           /* (in > inend) shouldn't happens */
         break;
         }
         if (xmlLittleEndian) {
         d = *in++;
         } else {
         tmp = (unsigned char *) in;
         d = *tmp++;
         d = d | (((unsigned int)*tmp) << 8);
         in++;
         }
             if ((d & 0xFC00) == 0xDC00) {
                 c &= 0x03FF;
                 c <<= 10;
                 c |= d & 0x03FF;
                 c += 0x10000;
             }
             else {
         *outlen = out - outstart;
         *inlenb = processed - inb;
             return(-2);
         }
         }
 
     /* assertion: c is a single UTF-4 value */
         if (out >= outend)
         break;
         if      (c <    0x80) {  *out++=  c;                bits= -6; }
         else if (c <   0x800) {  *out++= ((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
         else if (c < 0x10000) {  *out++= ((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
         else                  {  *out++= ((c >> 18) & 0x07) | 0xF0;  bits= 12; }
 
         for ( ; bits >= 0; bits-= 6) {
             if (out >= outend)
             break;
             *out++= ((c >> bits) & 0x3F) | 0x80;
         }
     processed = (const unsigned char*) in;
     }
     *outlen = out - outstart;
     *inlenb = processed - inb;
     return(*outlen);
 }

Referenced by xmlInitCharEncodingHandlers().

◆ UTF8ToUTF8()

static int UTF8ToUTF8	(	unsigned char *	out,
		int *	outlen,
		const unsigned char *	inb,
		int *	inlenb
	)

static

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

No op copy operation for UTF8 handling.

Returns the number of bytes written, or -1 if lack of space. The value of *inlen after return is the number of octets consumed if the return value is positive, else unpredictable.

Definition at line 355 of file encoding.c.

 {
     int len;
 
     if ((out == NULL) || (outlen == NULL) || (inlenb == NULL))
     return(-1);
     if (inb == NULL) {
         /* inb == NULL means output is initialized. */
         *outlen = 0;
         *inlenb = 0;
         return(0);
     }
     if (*outlen > *inlenb) {
     len = *inlenb;
     } else {
     len = *outlen;
     }
     if (len < 0)
     return(-1);
 
     memcpy(out, inb, len);
 
     *outlen = len;
     *inlenb = len;
     return(*outlen);
 }

Referenced by xmlInitCharEncodingHandlers().

◆ xmlAddEncodingAlias()

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

Definition at line 1057 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().

◆ xmlByteConsumed()

long xmlByteConsumed ( xmlParserCtxtPtr ctxt )

xmlByteConsumed: @ctxt: an XML parser context

This function provides the current index of the parser relative to the start of the current entity. This function is computed in bytes from the beginning starting at zero and finishing at the size in byte of the file if parsing a file. The function is of constant cost if the input is UTF-8 but can be costly if run on non-UTF-8 input.

Returns the index in bytes from the beginning of the entity or -1 in case the index could not be computed.

Definition at line 2803 of file encoding.c.

                                        {
     xmlParserInputPtr in;
 
     if (ctxt == NULL) return(-1);
     in = ctxt->input;
     if (in == NULL)  return(-1);
     if ((in->buf != NULL) && (in->buf->encoder != NULL)) {
         unsigned int unused = 0;
     xmlCharEncodingHandler * handler = in->buf->encoder;
         /*
      * Encoding conversion, compute the number of unused original
      * bytes from the input not consumed and substract that from
      * the raw consumed value, this is not a cheap operation
      */
         if (in->end - in->cur > 0) {
         unsigned char convbuf[32000];
         const unsigned char *cur = (const unsigned char *)in->cur;
         int toconv = in->end - in->cur, written = 32000;
 
         int ret;
 
             do {
                 toconv = in->end - cur;
                 written = 32000;
                 ret = xmlEncOutputChunk(handler, &convbuf[0], &written,
                                         cur, &toconv);
                 if (ret < 0) {
                     if (written > 0)
                         ret = -2;
                     else
                         return(-1);
                 }
                 unused += written;
                 cur += toconv;
             } while (ret == -2);
     }
     if (in->buf->rawconsumed < unused)
         return(-1);
     return(in->buf->rawconsumed - unused);
     }
     return(in->consumed + (in->cur - in->base));
 }

◆ xmlCharEncCloseFunc()

int xmlCharEncCloseFunc ( xmlCharEncodingHandler * handler )

xmlCharEncCloseFunc: @handler: char enconding transformation data structure

Generic front-end for encoding handler close function

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

Definition at line 2720 of file encoding.c.

                                                      {
     int ret = 0;
     int tofree = 0;
     int i, handler_in_list = 0;
 
     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()

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

xmlCharEncFirstLine: @handler: char enconding 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 2075 of file encoding.c.

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

◆ xmlCharEncFirstLineInput()

int xmlCharEncFirstLineInput	(	xmlParserInputBufferPtr	input,
		int	len
	)

xmlCharEncFirstLineInput: @input: a parser input buffer @len: number of bytes to convert for the first line, or -1

Front-end for the encoding handler input function, but handle only the very first line. Point is that this is based on autodetection of the encoding and once that first line is converted we may find out that a different decoder is needed to process the input.

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 2096 of file encoding.c.

 {
     int ret;
     size_t written;
     size_t toconv;
     int c_in;
     int c_out;
     xmlBufPtr in;
     xmlBufPtr out;
 
     if ((input == NULL) || (input->encoder == NULL) ||
         (input->buffer == NULL) || (input->raw == NULL))
         return (-1);
     out = input->buffer;
     in = input->raw;
 
     toconv = xmlBufUse(in);
     if (toconv == 0)
         return (0);
     written = xmlBufAvail(out) - 1; /* count '\0' */
     /*
      * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
      * 45 chars should be sufficient to reach the end of the encoding
      * declaration without going too far inside the document content.
      * on UTF-16 this means 90bytes, on UCS4 this means 180
      * The actual value depending on guessed encoding is passed as @len
      * if provided
      */
     if (len >= 0) {
         if (toconv > (unsigned int) len)
             toconv = len;
     } else {
         if (toconv > 180)
             toconv = 180;
     }
     if (toconv * 2 >= written) {
         xmlBufGrow(out, toconv * 2);
         written = xmlBufAvail(out) - 1;
     }
     if (written > 360)
         written = 360;
 
     c_in = toconv;
     c_out = written;
     ret = xmlEncInputChunk(input->encoder, xmlBufEnd(out), &c_out,
                            xmlBufContent(in), &c_in, 0);
     xmlBufShrink(in, c_in);
     xmlBufAddLen(out, c_out);
     if (ret == -1)
         ret = -3;
 
     switch (ret) {
         case 0:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                             "converted %d bytes to %d bytes of input\n",
                             c_in, c_out);
 #endif
             break;
         case -1:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                          "converted %d bytes to %d bytes of input, %d left\n",
                             c_in, c_out, (int)xmlBufUse(in));
 #endif
             break;
         case -3:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                         "converted %d bytes to %d bytes of input, %d left\n",
                             c_in, c_out, (int)xmlBufUse(in));
 #endif
             break;
         case -2: {
             char buf[50];
             const xmlChar *content = xmlBufContent(in);
 
         snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
              content[0], content[1],
              content[2], 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;
     if (ret == -1) ret = 0;
     return(ret);
 }

Referenced by xmlSwitchInputEncodingInt().

◆ xmlCharEncFirstLineInt()

int xmlCharEncFirstLineInt	(	xmlCharEncodingHandler *	handler,
		xmlBufferPtr	out,
		xmlBufferPtr	in,
		int	len
	)

xmlCharEncFirstLineInt: @handler: char enconding transformation data structure @out: an xmlBuffer for the output. @in: an xmlBuffer for the input @len: number of bytes to convert for the first line, or -1

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 1989 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);
 
     /* calculate space available */
     written = out->size - out->use - 1; /* count '\0' */
     toconv = in->use;
     /*
      * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
      * 45 chars should be sufficient to reach the end of the encoding
      * declaration without going too far inside the document content.
      * on UTF-16 this means 90bytes, on UCS4 this means 180
      * The actual value depending on guessed encoding is passed as @len
      * if provided
      */
     if (len >= 0) {
         if (toconv > len)
             toconv = len;
     } else {
         if (toconv > 180)
             toconv = 180;
     }
     if (toconv * 2 >= written) {
         xmlBufferGrow(out, toconv * 2);
     written = out->size - out->use - 1;
     }
 
     ret = xmlEncInputChunk(handler, &out->content[out->use], &written,
                            in->content, &toconv, 0);
     xmlBufferShrink(in, toconv);
     out->use += written;
     out->content[out->use] = 0;
     if (ret == -1) ret = -3;
 
 #ifdef DEBUG_ENCODING
     switch (ret) {
         case 0:
         xmlGenericError(xmlGenericErrorContext,
             "converted %d bytes to %d bytes of input\n",
                 toconv, written);
         break;
         case -1:
         xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
                 toconv, written, in->use);
         break;
         case -2:
         xmlGenericError(xmlGenericErrorContext,
             "input conversion failed due to input error\n");
         break;
         case -3:
         xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
                 toconv, written, in->use);
         break;
     default:
         xmlGenericError(xmlGenericErrorContext,"Unknown input conversion failed %d\n", ret);
     }
 #endif /* DEBUG_ENCODING */
     /*
      * Ignore when input buffer is not on a boundary
      */
     if (ret == -3) ret = 0;
     if (ret == -1) ret = 0;
     return(ret);
 }

Referenced by xmlCharEncFirstLine().

◆ xmlCharEncInFunc()

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

◆ xmlCharEncInput()

int xmlCharEncInput	(	xmlParserInputBufferPtr	input,
		int	flush
	)

xmlCharEncInput: @input: a parser input buffer @flush: try to flush all the raw buffer

Generic front-end for the encoding handler on parser input

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 2203 of file encoding.c.

 {
     int ret;
     size_t written;
     size_t toconv;
     int c_in;
     int c_out;
     xmlBufPtr in;
     xmlBufPtr out;
 
     if ((input == NULL) || (input->encoder == NULL) ||
         (input->buffer == NULL) || (input->raw == NULL))
         return (-1);
     out = input->buffer;
     in = input->raw;
 
     toconv = xmlBufUse(in);
     if (toconv == 0)
         return (0);
     if ((toconv > 64 * 1024) && (flush == 0))
         toconv = 64 * 1024;
     written = xmlBufAvail(out);
     if (written > 0)
         written--; /* count '\0' */
     if (toconv * 2 >= written) {
         xmlBufGrow(out, toconv * 2);
         written = xmlBufAvail(out);
         if (written > 0)
             written--; /* count '\0' */
     }
     if ((written > 128 * 1024) && (flush == 0))
         written = 128 * 1024;
 
     c_in = toconv;
     c_out = written;
     ret = xmlEncInputChunk(input->encoder, xmlBufEnd(out), &c_out,
                            xmlBufContent(in), &c_in, flush);
     xmlBufShrink(in, c_in);
     xmlBufAddLen(out, c_out);
     if (ret == -1)
         ret = -3;
 
     switch (ret) {
         case 0:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                             "converted %d bytes to %d bytes of input\n",
                             c_in, c_out);
 #endif
             break;
         case -1:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                          "converted %d bytes to %d bytes of input, %d left\n",
                             c_in, c_out, (int)xmlBufUse(in));
 #endif
             break;
         case -3:
 #ifdef DEBUG_ENCODING
             xmlGenericError(xmlGenericErrorContext,
                         "converted %d bytes to %d bytes of input, %d left\n",
                             c_in, c_out, (int)xmlBufUse(in));
 #endif
             break;
         case -2: {
             char buf[50];
             const xmlChar *content = xmlBufContent(in);
 
         snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
              content[0], content[1],
              content[2], 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 (c_out? c_out : ret);
 }

Referenced by xmlSwitchInputEncodingInt().

◆ xmlCharEncOutFunc()

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

xmlCharEncOutFunc: @handler: char enconding 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 2566 of file encoding.c.

                                    {
     int ret;
     int written;
     int writtentot = 0;
     int toconv;
     int output = 0;
 
     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;
     }
 
     if (ret >= 0) output += ret;
 
     /*
      * 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(ret);
 }

◆ xmlCleanupCharEncodingHandlers()

void xmlCleanupCharEncodingHandlers ( void )

xmlCleanupCharEncodingHandlers:

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

Definition at line 1455 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()

void xmlCleanupEncodingAliases ( void )

xmlCleanupEncodingAliases:

Unregisters all aliases

Definition at line 992 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()

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 1114 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()

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 932 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(), xmlParseCtxtExternalEntity(), xmlParseDocument(), xmlParseExternalEntityPrivate(), xmlParseExternalSubset(), xmlParseExtParsedEnt(), xmlParsePEReference(), and xmlSAX2ExternalSubset().

◆ xmlEncInputChunk()

static int xmlEncInputChunk	(	xmlCharEncodingHandler *	handler,
		unsigned char *	out,
		int *	outlen,
		const unsigned char *	in,
		int *	inlen,
		int	flush
	)

static

Definition at line 1916 of file encoding.c.

                                                                               {
     int ret;
     (void)flush;
 
     if (handler->input != NULL) {
         ret = handler->input(out, outlen, in, inlen);
     }
 #ifdef LIBXML_ICONV_ENABLED
     else if (handler->iconv_in != NULL) {
         ret = xmlIconvWrapper(handler->iconv_in, out, outlen, in, inlen);
     }
 #endif /* LIBXML_ICONV_ENABLED */
 #ifdef LIBXML_ICU_ENABLED
     else if (handler->uconv_in != NULL) {
         ret = xmlUconvWrapper(handler->uconv_in, 1, out, outlen, in, inlen,
                               flush);
     }
 #endif /* LIBXML_ICU_ENABLED */
     else {
         *outlen = 0;
         *inlen = 0;
         ret = -2;
     }
 
     return(ret);
 }

Referenced by xmlCharEncFirstLineInput(), xmlCharEncFirstLineInt(), xmlCharEncInFunc(), and xmlCharEncInput().

◆ xmlEncodingErrMemory()

static void xmlEncodingErrMemory ( const char * extra )

static

xmlEncodingErrMemory: @extra: extra informations

Handle an out of memory condition

Definition at line 84 of file encoding.c.

 {
     __xmlSimpleError(XML_FROM_I18N, XML_ERR_NO_MEMORY, NULL, NULL, extra);
 }

Referenced by xmlInitCharEncodingHandlers(), and xmlNewCharEncodingHandler().

◆ xmlEncOutputChunk()

static int xmlEncOutputChunk	(	xmlCharEncodingHandler *	handler,
		unsigned char *	out,
		int *	outlen,
		const unsigned char *	in,
		int *	inlen
	)

static

Definition at line 1946 of file encoding.c.

                                                                     {
     int ret;
 
     if (handler->output != NULL) {
         ret = handler->output(out, outlen, in, inlen);
     }
 #ifdef LIBXML_ICONV_ENABLED
     else if (handler->iconv_out != NULL) {
         ret = xmlIconvWrapper(handler->iconv_out, out, outlen, in, inlen);
     }
 #endif /* LIBXML_ICONV_ENABLED */
 #ifdef LIBXML_ICU_ENABLED
     else if (handler->uconv_out != NULL) {
         ret = xmlUconvWrapper(handler->uconv_out, 0, out, outlen, in, inlen,
                               TRUE);
     }
 #endif /* LIBXML_ICU_ENABLED */
     else {
         *outlen = 0;
         *inlen = 0;
         ret = -4;
     }
 
     return(ret);
 }

Referenced by xmlByteConsumed(), and xmlCharEncOutFunc().

◆ xmlFindCharEncodingHandler()

xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler ( const char * name )

Definition at line 1641 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);
     }
 #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(), xmlGetCharEncodingHandler(), xmlParseEncodingDecl(), xmlParseInNodeContext(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

◆ xmlGetCharEncodingHandler()

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 1507 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()

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 1234 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(), and xsltSaveResultTo().

◆ xmlGetEncodingAlias()

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 1019 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()

void xmlInitCharEncodingHandlers ( void )

xmlInitCharEncodingHandlers:

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 1397 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()

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

Definition at line 1318 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()

xmlCharEncoding xmlParseCharEncoding ( const char * name )

Definition at line 1150 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()

void xmlRegisterCharEncodingHandler ( xmlCharEncodingHandlerPtr handler )

xmlRegisterCharEncodingHandler: @handler: the xmlCharEncodingHandlerPtr handler block

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

Definition at line 1481 of file encoding.c.

                                                                   {
     if (handlers == NULL) xmlInitCharEncodingHandlers();
     if ((handler == NULL) || (handlers == NULL)) {
         xmlEncodingErr(XML_I18N_NO_HANDLER,
         "xmlRegisterCharEncodingHandler: NULL handler !\n", NULL);
     return;
     }
 
     if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {
         xmlEncodingErr(XML_I18N_EXCESS_HANDLER,
     "xmlRegisterCharEncodingHandler: Too many handler registered, see %s\n",
                    "MAX_ENCODING_HANDLERS");
     return;
     }
     handlers[nbCharEncodingHandler++] = handler;
 }

Referenced by xmlNewCharEncodingHandler().

Variable Documentation

◆ handlers

xmlCharEncodingHandlerPtr* handlers = NULL

static

Definition at line 1297 of file encoding.c.

Referenced by compile_state_table(), find_sink_entry(), notify_DllMain(), notify_TlsCallback(), xmlCharEncCloseFunc(), xmlCleanupCharEncodingHandlers(), xmlFindCharEncodingHandler(), xmlGetCharEncodingHandler(), xmlInitCharEncodingHandlers(), and xmlRegisterCharEncodingHandler().

◆ nbCharEncodingHandler

int nbCharEncodingHandler = 0

static

Definition at line 1298 of file encoding.c.

Referenced by xmlCharEncCloseFunc(), xmlCleanupCharEncodingHandlers(), xmlFindCharEncodingHandler(), and xmlRegisterCharEncodingHandler().

◆ xmlCharEncodingAliases

xmlCharEncodingAliasPtr xmlCharEncodingAliases = NULL

static

Definition at line 61 of file encoding.c.

Referenced by xmlAddEncodingAlias(), xmlCleanupEncodingAliases(), xmlDelEncodingAlias(), and xmlGetEncodingAlias().

◆ xmlCharEncodingAliasesMax

int xmlCharEncodingAliasesMax = 0

static

Definition at line 63 of file encoding.c.

Referenced by xmlAddEncodingAlias(), and xmlCleanupEncodingAliases().

◆ xmlCharEncodingAliasesNb

int xmlCharEncodingAliasesNb = 0

static

Definition at line 62 of file encoding.c.

Referenced by xmlAddEncodingAlias(), xmlCleanupEncodingAliases(), xmlDelEncodingAlias(), and xmlGetEncodingAlias().

◆ xmlDefaultCharEncodingHandler

xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler = NULL

static

Definition at line 1305 of file encoding.c.

Referenced by xmlCleanupCharEncodingHandlers(), and xmlFindCharEncodingHandler().

◆ xmlLittleEndian

int xmlLittleEndian = 1

static

Definition at line 75 of file encoding.c.

Referenced by UTF16BEToUTF8(), UTF16LEToUTF8(), and xmlInitCharEncodingHandlers().

◆ xmlUTF16BEHandler

xmlCharEncodingHandlerPtr xmlUTF16BEHandler = NULL

static

Definition at line 52 of file encoding.c.

Referenced by xmlGetCharEncodingHandler(), and xmlInitCharEncodingHandlers().

◆ xmlUTF16LEHandler

xmlCharEncodingHandlerPtr xmlUTF16LEHandler = NULL

static

Definition at line 51 of file encoding.c.

Referenced by xmlGetCharEncodingHandler(), and xmlInitCharEncodingHandlers().

Classes

Macros

Typedefs

Functions

Variables

: the encoding name as parsed, in UTF-8 format (ASCII actually)

: a string describing the char encoding.

Macro Definition Documentation

◆ bottom_encoding

◆ IN_LIBXML

◆ MAX_ENCODING_HANDLERS

Typedef Documentation

◆ xmlCharEncodingAlias

◆ xmlCharEncodingAliasPtr

Function Documentation

◆ asciiToUTF8()

◆ isolat1ToUTF8()

◆ LIBXML_ATTR_FORMAT()

◆ UTF16BEToUTF8()

◆ UTF16LEToUTF8()

◆ UTF8ToUTF8()

◆ xmlAddEncodingAlias()

◆ xmlByteConsumed()

◆ xmlCharEncCloseFunc()

◆ xmlCharEncFirstLine()

◆ xmlCharEncFirstLineInput()

◆ xmlCharEncFirstLineInt()

◆ xmlCharEncInFunc()

◆ xmlCharEncInput()

◆ xmlCharEncOutFunc()

◆ xmlCleanupCharEncodingHandlers()

◆ xmlCleanupEncodingAliases()

◆ xmlDelEncodingAlias()

◆ xmlDetectCharEncoding()

◆ xmlEncInputChunk()

◆ xmlEncodingErrMemory()

◆ xmlEncOutputChunk()

◆ xmlFindCharEncodingHandler()

◆ xmlGetCharEncodingHandler()

◆ xmlGetCharEncodingName()

◆ xmlGetEncodingAlias()

◆ xmlInitCharEncodingHandlers()

◆ xmlNewCharEncodingHandler()

◆ xmlParseCharEncoding()

◆ xmlRegisterCharEncodingHandler()

Variable Documentation

◆ handlers

◆ nbCharEncodingHandler

◆ xmlCharEncodingAliases

◆ xmlCharEncodingAliasesMax

◆ xmlCharEncodingAliasesNb

◆ xmlDefaultCharEncodingHandler

◆ xmlLittleEndian

◆ xmlUTF16BEHandler

◆ xmlUTF16LEHandler