ReactOS  0.4.15-dev-5109-g2469ce2
Classes | Macros | Typedefs | Functions | Variables
encoding.c File Reference
#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:

Go to the source code of this file.

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 3977 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 1306 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 produced.

Definition at line 176 of file encoding.c.

177  {
178  unsigned char* outstart = out;
179  const unsigned char* base = in;
180  const unsigned char* processed = in;
181  unsigned char* outend = out + *outlen;
182  const unsigned char* inend;
183  unsigned int c;
184 
185  inend = in + (*inlen);
186  while ((in < inend) && (out - outstart + 5 < *outlen)) {
187  c= *in++;
188 
189  if (out >= outend)
190  break;
191  if (c < 0x80) {
192  *out++ = c;
193  } else {
194  *outlen = out - outstart;
195  *inlen = processed - base;
196  return(-1);
197  }
198 
199  processed = (const unsigned char*) in;
200  }
201  *outlen = out - outstart;
202  *inlen = processed - base;
203  return(*outlen);
204 }
base
GLuint base
Definition: 3dtext.c:35
c
const GLubyte * c
Definition: glext.h:8905
out
static FILE * out
Definition: regtests2xml.c:44
in
GLuint in
Definition: glext.h:9616
processed
static int processed(const type_t *type)
Definition: typegen.c:2254
c
#define c
Definition: ke_i.h:80

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

Definition at line 307 of file encoding.c.

308  {
309  unsigned char* outstart = out;
310  const unsigned char* base = in;
311  unsigned char* outend;
312  const unsigned char* inend;
313  const unsigned char* instop;
314 
315  if ((out == NULL) || (in == NULL) || (outlen == NULL) || (inlen == NULL))
316  return(-1);
317 
318  outend = out + *outlen;
319  inend = in + (*inlen);
320  instop = inend;
321 
322  while ((in < inend) && (out < outend - 1)) {
323  if (*in >= 0x80) {
324  *out++ = (((*in) >> 6) & 0x1F) | 0xC0;
325  *out++ = ((*in) & 0x3F) | 0x80;
326  ++in;
327  }
328  if ((instop - in) > (outend - out)) instop = in + (outend - out);
329  while ((in < instop) && (*in < 0x80)) {
330  *out++ = *in++;
331  }
332  }
333  if ((in < inend) && (out < outend) && (*in < 0x80)) {
334  *out++ = *in++;
335  }
336  *outlen = out - outstart;
337  *inlen = in - base;
338  return(*outlen);
339 }
base
GLuint base
Definition: 3dtext.c:35
out
static FILE * out
Definition: regtests2xml.c:44
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112

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.

98 {
99  __xmlRaiseError(NULL, NULL, NULL, NULL, NULL,
100  XML_FROM_I18N, error, XML_ERR_FATAL,
101  NULL, 0, val, NULL, NULL, 0, 0, msg, val);
102 }
error
#define error(str)
Definition: mkdosfs.c:1605
val
GLuint GLfloat * val
Definition: glext.h:7180
NULL
#define NULL
Definition: types.h:112
msg
#define msg(x)
Definition: auth_time.c:54

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

744 {
745  unsigned char* outstart = out;
746  const unsigned char* processed = inb;
747  unsigned char* outend = out + *outlen;
748  unsigned short* in = (unsigned short*) inb;
749  unsigned short* inend;
750  unsigned int c, d, inlen;
751  unsigned char *tmp;
752  int bits;
753 
754  if ((*inlenb % 2) == 1)
755  (*inlenb)--;
756  inlen = *inlenb / 2;
757  inend= in + inlen;
758  while (in < inend) {
759  if (xmlLittleEndian) {
760  tmp = (unsigned char *) in;
761  c = *tmp++;
762  c = c << 8;
763  c = c | (unsigned int) *tmp;
764  in++;
765  } else {
766  c= *in++;
767  }
768  if ((c & 0xFC00) == 0xD800) { /* surrogates */
769  if (in >= inend) { /* (in > inend) shouldn't happens */
770  *outlen = out - outstart;
771  *inlenb = processed - inb;
772  return(-2);
773  }
774  if (xmlLittleEndian) {
775  tmp = (unsigned char *) in;
776  d = *tmp++;
777  d = d << 8;
778  d = d | (unsigned int) *tmp;
779  in++;
780  } else {
781  d= *in++;
782  }
783  if ((d & 0xFC00) == 0xDC00) {
784  c &= 0x03FF;
785  c <<= 10;
786  c |= d & 0x03FF;
787  c += 0x10000;
788  }
789  else {
790  *outlen = out - outstart;
791  *inlenb = processed - inb;
792  return(-2);
793  }
794  }
795 
796  /* assertion: c is a single UTF-4 value */
797  if (out >= outend)
798  break;
799  if (c < 0x80) { *out++= c; bits= -6; }
800  else if (c < 0x800) { *out++= ((c >> 6) & 0x1F) | 0xC0; bits= 0; }
801  else if (c < 0x10000) { *out++= ((c >> 12) & 0x0F) | 0xE0; bits= 6; }
802  else { *out++= ((c >> 18) & 0x07) | 0xF0; bits= 12; }
803 
804  for ( ; bits >= 0; bits-= 6) {
805  if (out >= outend)
806  break;
807  *out++= ((c >> bits) & 0x3F) | 0x80;
808  }
809  processed = (const unsigned char*) in;
810  }
811  *outlen = out - outstart;
812  *inlenb = processed - inb;
813  return(*outlen);
814 }
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
xmlLittleEndian
static int xmlLittleEndian
Definition: encoding.c:75
c
const GLubyte * c
Definition: glext.h:8905
out
static FILE * out
Definition: regtests2xml.c:44
in
GLuint in
Definition: glext.h:9616
processed
static int processed(const type_t *type)
Definition: typegen.c:2254
c
#define c
Definition: ke_i.h:80
d
#define d
Definition: ke_i.h:81
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

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

501 {
502  unsigned char* outstart = out;
503  const unsigned char* processed = inb;
504  unsigned char* outend;
505  unsigned short* in = (unsigned short*) inb;
506  unsigned short* inend;
507  unsigned int c, d, inlen;
508  unsigned char *tmp;
509  int bits;
510 
511  if (*outlen == 0) {
512  *inlenb = 0;
513  return(0);
514  }
515  outend = out + *outlen;
516  if ((*inlenb % 2) == 1)
517  (*inlenb)--;
518  inlen = *inlenb / 2;
519  inend = in + inlen;
520  while ((in < inend) && (out - outstart + 5 < *outlen)) {
521  if (xmlLittleEndian) {
522  c= *in++;
523  } else {
524  tmp = (unsigned char *) in;
525  c = *tmp++;
526  c = c | (((unsigned int)*tmp) << 8);
527  in++;
528  }
529  if ((c & 0xFC00) == 0xD800) { /* surrogates */
530  if (in >= inend) { /* (in > inend) shouldn't happens */
531  break;
532  }
533  if (xmlLittleEndian) {
534  d = *in++;
535  } else {
536  tmp = (unsigned char *) in;
537  d = *tmp++;
538  d = d | (((unsigned int)*tmp) << 8);
539  in++;
540  }
541  if ((d & 0xFC00) == 0xDC00) {
542  c &= 0x03FF;
543  c <<= 10;
544  c |= d & 0x03FF;
545  c += 0x10000;
546  }
547  else {
548  *outlen = out - outstart;
549  *inlenb = processed - inb;
550  return(-2);
551  }
552  }
553 
554  /* assertion: c is a single UTF-4 value */
555  if (out >= outend)
556  break;
557  if (c < 0x80) { *out++= c; bits= -6; }
558  else if (c < 0x800) { *out++= ((c >> 6) & 0x1F) | 0xC0; bits= 0; }
559  else if (c < 0x10000) { *out++= ((c >> 12) & 0x0F) | 0xE0; bits= 6; }
560  else { *out++= ((c >> 18) & 0x07) | 0xF0; bits= 12; }
561 
562  for ( ; bits >= 0; bits-= 6) {
563  if (out >= outend)
564  break;
565  *out++= ((c >> bits) & 0x3F) | 0x80;
566  }
567  processed = (const unsigned char*) in;
568  }
569  *outlen = out - outstart;
570  *inlenb = processed - inb;
571  return(*outlen);
572 }
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
xmlLittleEndian
static int xmlLittleEndian
Definition: encoding.c:75
c
const GLubyte * c
Definition: glext.h:8905
out
static FILE * out
Definition: regtests2xml.c:44
in
GLuint in
Definition: glext.h:9616
processed
static int processed(const type_t *type)
Definition: typegen.c:2254
c
#define c
Definition: ke_i.h:80
d
#define d
Definition: ke_i.h:81
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

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.

357 {
358  int len;
359 
360  if ((out == NULL) || (outlen == NULL) || (inlenb == NULL))
361  return(-1);
362  if (inb == NULL) {
363  /* inb == NULL means output is initialized. */
364  *outlen = 0;
365  *inlenb = 0;
366  return(0);
367  }
368  if (*outlen > *inlenb) {
369  len = *inlenb;
370  } else {
371  len = *outlen;
372  }
373  if (len < 0)
374  return(-1);
375 
376  /*
377  * FIXME: Conversion functions must assure valid UTF-8, so we have
378  * to check for UTF-8 validity. Preferably, this converter shouldn't
379  * be used at all.
380  */
381  memcpy(out, inb, len);
382 
383  *outlen = len;
384  *inlenb = len;
385  return(*outlen);
386 }
out
static FILE * out
Definition: regtests2xml.c:44
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
len
GLenum GLsizei len
Definition: glext.h:6722
NULL
#define NULL
Definition: types.h:112

Referenced by xmlInitCharEncodingHandlers().

◆ xmlAddEncodingAlias()

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

Definition at line 1067 of file encoding.c.

1067  {
1068  int i;
1069  char upper[100];
1070 
1071  if ((name == NULL) || (alias == NULL))
1072  return(-1);
1073 
1074  for (i = 0;i < 99;i++) {
1075  upper[i] = toupper(alias[i]);
1076  if (upper[i] == 0) break;
1077  }
1078  upper[i] = 0;
1079 
1080  if (xmlCharEncodingAliases == NULL) {
1081  xmlCharEncodingAliasesNb = 0;
1082  xmlCharEncodingAliasesMax = 20;
1083  xmlCharEncodingAliases = (xmlCharEncodingAliasPtr)
1084  xmlMalloc(xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
1085  if (xmlCharEncodingAliases == NULL)
1086  return(-1);
1087  } else if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) {
1088  xmlCharEncodingAliasesMax *= 2;
1089  xmlCharEncodingAliases = (xmlCharEncodingAliasPtr)
1090  xmlRealloc(xmlCharEncodingAliases,
1091  xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias));
1092  }
1093  /*
1094  * Walk down the list looking for a definition of the alias
1095  */
1096  for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
1097  if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
1098  /*
1099  * Replace the definition.
1100  */
1101  xmlFree((char *) xmlCharEncodingAliases[i].name);
1102  xmlCharEncodingAliases[i].name = xmlMemStrdup(name);
1103  return(0);
1104  }
1105  }
1106  /*
1107  * Add the definition
1108  */
1109  xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = xmlMemStrdup(name);
1110  xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = xmlMemStrdup(upper);
1111  xmlCharEncodingAliasesNb++;
1112  return(0);
1113 }
_xmlCharEncodingAlias::name
const char * name
Definition: encoding.c:57
xmlCharEncodingAliases
static xmlCharEncodingAliasPtr xmlCharEncodingAliases
Definition: encoding.c:61
xmlCharEncodingAliasesMax
static int xmlCharEncodingAliasesMax
Definition: encoding.c:63
xmlRealloc
XMLPUBVAR xmlReallocFunc xmlRealloc
Definition: globals.h:249
toupper
int toupper(int c)
Definition: utclib.c:881
_xmlCharEncodingAlias::alias
const char * alias
Definition: encoding.c:58
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlCharEncodingAliasesNb
static int xmlCharEncodingAliasesNb
Definition: encoding.c:62
xmlCharEncodingAliasPtr
xmlCharEncodingAlias * xmlCharEncodingAliasPtr
Definition: encoding.c:55
alias
const WCHAR * alias
Definition: main.c:67
xmlMemStrdup
XMLPUBVAR xmlStrdupFunc xmlMemStrdup
Definition: globals.h:251
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_xmlCharEncodingAlias
Definition: encoding.c:56
NULL
#define NULL
Definition: types.h:112
xmlMalloc
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
name
Definition: name.c:38
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

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

2863  {
2864  xmlParserInputPtr in;
2865 
2866  if (ctxt == NULL) return(-1);
2867  in = ctxt->input;
2868  if (in == NULL) return(-1);
2869  if ((in->buf != NULL) && (in->buf->encoder != NULL)) {
2870  unsigned int unused = 0;
2871  xmlCharEncodingHandler * handler = in->buf->encoder;
2872  /*
2873  * Encoding conversion, compute the number of unused original
2874  * bytes from the input not consumed and subtract that from
2875  * the raw consumed value, this is not a cheap operation
2876  */
2877  if (in->end - in->cur > 0) {
2878  unsigned char convbuf[32000];
2879  const unsigned char *cur = (const unsigned char *)in->cur;
2880  int toconv = in->end - in->cur, written = 32000;
2881 
2882  int ret;
2883 
2884  do {
2885  toconv = in->end - cur;
2886  written = 32000;
2887  ret = xmlEncOutputChunk(handler, &convbuf[0], &written,
2888  cur, &toconv);
2889  if (ret < 0) {
2890  if (written > 0)
2891  ret = -2;
2892  else
2893  return(-1);
2894  }
2895  unused += written;
2896  cur += toconv;
2897  } while (ret == -2);
2898  }
2899  if (in->buf->rawconsumed < unused)
2900  return(-1);
2901  return(in->buf->rawconsumed - unused);
2902  }
2903  return(in->consumed + (in->cur - in->base));
2904 }
_xmlParserInput
Definition: parser.h:54
_xmlParserCtxt::input
xmlParserInputPtr input
Definition: parser.h:201
xmlEncOutputChunk
static int xmlEncOutputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
Definition: encoding.c:2004
unused
WORD unused[29]
Definition: crypt.c:1155
_xmlCharEncodingHandler
Definition: encoding.h:146
ret
int ret
Definition: wcstombs-tests.c:31
cur
FxCollectionEntry * cur
Definition: fxresourceapi.cpp:412
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

◆ xmlCharEncCloseFunc()

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

2780  {
2781  int ret = 0;
2782  int tofree = 0;
2783  int i, handler_in_list = 0;
2784 
2785  if (handler == NULL) return(-1);
2786  if (handler->name == NULL) return(-1);
2787  if (handlers != NULL) {
2788  for (i = 0;i < nbCharEncodingHandler; i++) {
2789  if (handler == handlers[i]) {
2790  handler_in_list = 1;
2791  break;
2792  }
2793  }
2794  }
2795 #ifdef LIBXML_ICONV_ENABLED
2796  /*
2797  * Iconv handlers can be used only once, free the whole block.
2798  * and the associated icon resources.
2799  */
2800  if ((handler_in_list == 0) &&
2801  ((handler->iconv_out != NULL) || (handler->iconv_in != NULL))) {
2802  tofree = 1;
2803  if (handler->iconv_out != NULL) {
2804  if (iconv_close(handler->iconv_out))
2805  ret = -1;
2806  handler->iconv_out = NULL;
2807  }
2808  if (handler->iconv_in != NULL) {
2809  if (iconv_close(handler->iconv_in))
2810  ret = -1;
2811  handler->iconv_in = NULL;
2812  }
2813  }
2814 #endif /* LIBXML_ICONV_ENABLED */
2815 #ifdef LIBXML_ICU_ENABLED
2816  if ((handler_in_list == 0) &&
2817  ((handler->uconv_out != NULL) || (handler->uconv_in != NULL))) {
2818  tofree = 1;
2819  if (handler->uconv_out != NULL) {
2820  closeIcuConverter(handler->uconv_out);
2821  handler->uconv_out = NULL;
2822  }
2823  if (handler->uconv_in != NULL) {
2824  closeIcuConverter(handler->uconv_in);
2825  handler->uconv_in = NULL;
2826  }
2827  }
2828 #endif
2829  if (tofree) {
2830  /* free up only dynamic handlers iconv/uconv */
2831  if (handler->name != NULL)
2832  xmlFree(handler->name);
2833  handler->name = NULL;
2834  xmlFree(handler);
2835  }
2836 #ifdef DEBUG_ENCODING
2837  if (ret)
2838  xmlGenericError(xmlGenericErrorContext,
2839  "failed to close the encoding handler\n");
2840  else
2841  xmlGenericError(xmlGenericErrorContext,
2842  "closed the encoding handler\n");
2843 #endif
2844 
2845  return(ret);
2846 }
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
ret
int ret
Definition: wcstombs-tests.c:31
nbCharEncodingHandler
static int nbCharEncodingHandler
Definition: encoding.c:1308
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NULL
#define NULL
Definition: types.h:112
iconv_close
int iconv_close(iconv_t cd)
Definition: win_iconv.c:756
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlSwitchInputEncodingInt().

◆ xmlCharEncFirstLine()

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

2136  {
2137  return(xmlCharEncFirstLineInt(handler, out, in, -1));
2138 }
xmlCharEncFirstLineInt
int xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in, int len)
Definition: encoding.c:2049
out
static FILE * out
Definition: regtests2xml.c:44
in
GLuint in
Definition: glext.h:9616
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

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

2157 {
2158  int ret;
2159  size_t written;
2160  size_t toconv;
2161  int c_in;
2162  int c_out;
2163  xmlBufPtr in;
2164  xmlBufPtr out;
2165 
2166  if ((input == NULL) || (input->encoder == NULL) ||
2167  (input->buffer == NULL) || (input->raw == NULL))
2168  return (-1);
2169  out = input->buffer;
2170  in = input->raw;
2171 
2172  toconv = xmlBufUse(in);
2173  if (toconv == 0)
2174  return (0);
2175  written = xmlBufAvail(out) - 1; /* count '\0' */
2176  /*
2177  * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
2178  * 45 chars should be sufficient to reach the end of the encoding
2179  * declaration without going too far inside the document content.
2180  * on UTF-16 this means 90bytes, on UCS4 this means 180
2181  * The actual value depending on guessed encoding is passed as @len
2182  * if provided
2183  */
2184  if (len >= 0) {
2185  if (toconv > (unsigned int) len)
2186  toconv = len;
2187  } else {
2188  if (toconv > 180)
2189  toconv = 180;
2190  }
2191  if (toconv * 2 >= written) {
2192  xmlBufGrow(out, toconv * 2);
2193  written = xmlBufAvail(out) - 1;
2194  }
2195  if (written > 360)
2196  written = 360;
2197 
2198  c_in = toconv;
2199  c_out = written;
2200  ret = xmlEncInputChunk(input->encoder, xmlBufEnd(out), &c_out,
2201  xmlBufContent(in), &c_in, 0);
2202  xmlBufShrink(in, c_in);
2203  xmlBufAddLen(out, c_out);
2204  if (ret == -1)
2205  ret = -3;
2206 
2207  switch (ret) {
2208  case 0:
2209 #ifdef DEBUG_ENCODING
2210  xmlGenericError(xmlGenericErrorContext,
2211  "converted %d bytes to %d bytes of input\n",
2212  c_in, c_out);
2213 #endif
2214  break;
2215  case -1:
2216 #ifdef DEBUG_ENCODING
2217  xmlGenericError(xmlGenericErrorContext,
2218  "converted %d bytes to %d bytes of input, %d left\n",
2219  c_in, c_out, (int)xmlBufUse(in));
2220 #endif
2221  break;
2222  case -3:
2223 #ifdef DEBUG_ENCODING
2224  xmlGenericError(xmlGenericErrorContext,
2225  "converted %d bytes to %d bytes of input, %d left\n",
2226  c_in, c_out, (int)xmlBufUse(in));
2227 #endif
2228  break;
2229  case -2: {
2230  char buf[50];
2231  const xmlChar *content = xmlBufContent(in);
2232 
2233  snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2234  content[0], content[1],
2235  content[2], content[3]);
2236  buf[49] = 0;
2237  xmlEncodingErr(XML_I18N_CONV_FAILED,
2238  "input conversion failed due to input error, bytes %s\n",
2239  buf);
2240  }
2241  }
2242  /*
2243  * Ignore when input buffer is not on a boundary
2244  */
2245  if (ret == -3) ret = 0;
2246  if (ret == -1) ret = 0;
2247  return(c_out ? c_out : ret);
2248 }
xmlBufGrow
int xmlBufGrow(xmlBufPtr buf, int len)
Definition: buf.c:509
xmlBufContent
XMLPUBFUN xmlChar *XMLCALL xmlBufContent(const xmlBuf *buf)
Definition: buf.c:582
xmlBufAddLen
int xmlBufAddLen(xmlBufPtr buf, size_t len)
Definition: buf.c:621
xmlBufEnd
XMLPUBFUN xmlChar *XMLCALL xmlBufEnd(xmlBufPtr buf)
Definition: buf.c:600
snprintf
#define snprintf
Definition: wintirpc.h:48
xmlEncInputChunk
static int xmlEncInputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen, int flush)
Definition: encoding.c:1954
_xmlBuf
Definition: buf.c:43
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
content
content
Definition: atl_ax.c:993
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
xmlChar
unsigned char xmlChar
Definition: xmlstring.h:28
len
GLenum GLsizei len
Definition: glext.h:6722
xmlBufAvail
size_t xmlBufAvail(const xmlBufPtr buf)
Definition: buf.c:708
input
GLenum GLenum GLenum input
Definition: glext.h:9031
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
xmlBufUse
XMLPUBFUN size_t XMLCALL xmlBufUse(const xmlBufPtr buf)
Definition: buf.c:687
xmlBufShrink
XMLPUBFUN size_t XMLCALL xmlBufShrink(xmlBufPtr buf, size_t len)
Definition: buf.c:388
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlSwitchInputEncodingInt().

◆ xmlCharEncFirstLineInt()

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

xmlCharEncFirstLineInt: @handler: char encoding 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 2049 of file encoding.c.

2050  {
2051  int ret;
2052  int written;
2053  int toconv;
2054 
2055  if (handler == NULL) return(-1);
2056  if (out == NULL) return(-1);
2057  if (in == NULL) return(-1);
2058 
2059  /* calculate space available */
2060  written = out->size - out->use - 1; /* count '\0' */
2061  toconv = in->use;
2062  /*
2063  * echo '<?xml version="1.0" encoding="UCS4"?>' | wc -c => 38
2064  * 45 chars should be sufficient to reach the end of the encoding
2065  * declaration without going too far inside the document content.
2066  * on UTF-16 this means 90bytes, on UCS4 this means 180
2067  * The actual value depending on guessed encoding is passed as @len
2068  * if provided
2069  */
2070  if (len >= 0) {
2071  if (toconv > len)
2072  toconv = len;
2073  } else {
2074  if (toconv > 180)
2075  toconv = 180;
2076  }
2077  if (toconv * 2 >= written) {
2078  xmlBufferGrow(out, toconv * 2);
2079  written = out->size - out->use - 1;
2080  }
2081 
2082  ret = xmlEncInputChunk(handler, &out->content[out->use], &written,
2083  in->content, &toconv, 0);
2084  xmlBufferShrink(in, toconv);
2085  out->use += written;
2086  out->content[out->use] = 0;
2087  if (ret == -1) ret = -3;
2088 
2089 #ifdef DEBUG_ENCODING
2090  switch (ret) {
2091  case 0:
2092  xmlGenericError(xmlGenericErrorContext,
2093  "converted %d bytes to %d bytes of input\n",
2094  toconv, written);
2095  break;
2096  case -1:
2097  xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
2098  toconv, written, in->use);
2099  break;
2100  case -2:
2101  xmlGenericError(xmlGenericErrorContext,
2102  "input conversion failed due to input error\n");
2103  break;
2104  case -3:
2105  xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of input, %d left\n",
2106  toconv, written, in->use);
2107  break;
2108  default:
2109  xmlGenericError(xmlGenericErrorContext,"Unknown input conversion failed %d\n", ret);
2110  }
2111 #endif /* DEBUG_ENCODING */
2112  /*
2113  * Ignore when input buffer is not on a boundary
2114  */
2115  if (ret == -3) ret = 0;
2116  if (ret == -1) ret = 0;
2117  return(written ? written : ret);
2118 }
xmlEncInputChunk
static int xmlEncInputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen, int flush)
Definition: encoding.c:1954
xmlBufferGrow
XMLPUBFUN int XMLCALL xmlBufferGrow(xmlBufferPtr buf, unsigned int len)
xmlBufferShrink
XMLPUBFUN int XMLCALL xmlBufferShrink(xmlBufferPtr buf, unsigned int len)
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
len
GLenum GLsizei len
Definition: glext.h:6722
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

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

2364 {
2365  int ret;
2366  int written;
2367  int toconv;
2368 
2369  if (handler == NULL)
2370  return (-1);
2371  if (out == NULL)
2372  return (-1);
2373  if (in == NULL)
2374  return (-1);
2375 
2376  toconv = in->use;
2377  if (toconv == 0)
2378  return (0);
2379  written = out->size - out->use -1; /* count '\0' */
2380  if (toconv * 2 >= written) {
2381  xmlBufferGrow(out, out->size + toconv * 2);
2382  written = out->size - out->use - 1;
2383  }
2384  ret = xmlEncInputChunk(handler, &out->content[out->use], &written,
2385  in->content, &toconv, 1);
2386  xmlBufferShrink(in, toconv);
2387  out->use += written;
2388  out->content[out->use] = 0;
2389  if (ret == -1)
2390  ret = -3;
2391 
2392  switch (ret) {
2393  case 0:
2394 #ifdef DEBUG_ENCODING
2395  xmlGenericError(xmlGenericErrorContext,
2396  "converted %d bytes to %d bytes of input\n",
2397  toconv, written);
2398 #endif
2399  break;
2400  case -1:
2401 #ifdef DEBUG_ENCODING
2402  xmlGenericError(xmlGenericErrorContext,
2403  "converted %d bytes to %d bytes of input, %d left\n",
2404  toconv, written, in->use);
2405 #endif
2406  break;
2407  case -3:
2408 #ifdef DEBUG_ENCODING
2409  xmlGenericError(xmlGenericErrorContext,
2410  "converted %d bytes to %d bytes of input, %d left\n",
2411  toconv, written, in->use);
2412 #endif
2413  break;
2414  case -2: {
2415  char buf[50];
2416 
2417  snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2418  in->content[0], in->content[1],
2419  in->content[2], in->content[3]);
2420  buf[49] = 0;
2421  xmlEncodingErr(XML_I18N_CONV_FAILED,
2422  "input conversion failed due to input error, bytes %s\n",
2423  buf);
2424  }
2425  }
2426  /*
2427  * Ignore when input buffer is not on a boundary
2428  */
2429  if (ret == -3)
2430  ret = 0;
2431  return (written? written : ret);
2432 }
snprintf
#define snprintf
Definition: wintirpc.h:48
xmlEncInputChunk
static int xmlEncInputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen, int flush)
Definition: encoding.c:1954
xmlBufferGrow
XMLPUBFUN int XMLCALL xmlBufferGrow(xmlBufferPtr buf, unsigned int len)
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlBufferShrink
XMLPUBFUN int XMLCALL xmlBufferShrink(xmlBufferPtr buf, unsigned int len)
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

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

2264 {
2265  int ret;
2266  size_t written;
2267  size_t toconv;
2268  int c_in;
2269  int c_out;
2270  xmlBufPtr in;
2271  xmlBufPtr out;
2272 
2273  if ((input == NULL) || (input->encoder == NULL) ||
2274  (input->buffer == NULL) || (input->raw == NULL))
2275  return (-1);
2276  out = input->buffer;
2277  in = input->raw;
2278 
2279  toconv = xmlBufUse(in);
2280  if (toconv == 0)
2281  return (0);
2282  if ((toconv > 64 * 1024) && (flush == 0))
2283  toconv = 64 * 1024;
2284  written = xmlBufAvail(out);
2285  if (written > 0)
2286  written--; /* count '\0' */
2287  if (toconv * 2 >= written) {
2288  xmlBufGrow(out, toconv * 2);
2289  written = xmlBufAvail(out);
2290  if (written > 0)
2291  written--; /* count '\0' */
2292  }
2293  if ((written > 128 * 1024) && (flush == 0))
2294  written = 128 * 1024;
2295 
2296  c_in = toconv;
2297  c_out = written;
2298  ret = xmlEncInputChunk(input->encoder, xmlBufEnd(out), &c_out,
2299  xmlBufContent(in), &c_in, flush);
2300  xmlBufShrink(in, c_in);
2301  xmlBufAddLen(out, c_out);
2302  if (ret == -1)
2303  ret = -3;
2304 
2305  switch (ret) {
2306  case 0:
2307 #ifdef DEBUG_ENCODING
2308  xmlGenericError(xmlGenericErrorContext,
2309  "converted %d bytes to %d bytes of input\n",
2310  c_in, c_out);
2311 #endif
2312  break;
2313  case -1:
2314 #ifdef DEBUG_ENCODING
2315  xmlGenericError(xmlGenericErrorContext,
2316  "converted %d bytes to %d bytes of input, %d left\n",
2317  c_in, c_out, (int)xmlBufUse(in));
2318 #endif
2319  break;
2320  case -3:
2321 #ifdef DEBUG_ENCODING
2322  xmlGenericError(xmlGenericErrorContext,
2323  "converted %d bytes to %d bytes of input, %d left\n",
2324  c_in, c_out, (int)xmlBufUse(in));
2325 #endif
2326  break;
2327  case -2: {
2328  char buf[50];
2329  const xmlChar *content = xmlBufContent(in);
2330 
2331  snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2332  content[0], content[1],
2333  content[2], content[3]);
2334  buf[49] = 0;
2335  xmlEncodingErr(XML_I18N_CONV_FAILED,
2336  "input conversion failed due to input error, bytes %s\n",
2337  buf);
2338  }
2339  }
2340  /*
2341  * Ignore when input buffer is not on a boundary
2342  */
2343  if (ret == -3)
2344  ret = 0;
2345  return (c_out? c_out : ret);
2346 }
xmlBufGrow
int xmlBufGrow(xmlBufPtr buf, int len)
Definition: buf.c:509
xmlBufContent
XMLPUBFUN xmlChar *XMLCALL xmlBufContent(const xmlBuf *buf)
Definition: buf.c:582
xmlBufAddLen
int xmlBufAddLen(xmlBufPtr buf, size_t len)
Definition: buf.c:621
xmlBufEnd
XMLPUBFUN xmlChar *XMLCALL xmlBufEnd(xmlBufPtr buf)
Definition: buf.c:600
snprintf
#define snprintf
Definition: wintirpc.h:48
xmlEncInputChunk
static int xmlEncInputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen, int flush)
Definition: encoding.c:1954
_xmlBuf
Definition: buf.c:43
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
content
content
Definition: atl_ax.c:993
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
flush
int flush
Definition: zlib.h:309
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
xmlChar
unsigned char xmlChar
Definition: xmlstring.h:28
xmlBufAvail
size_t xmlBufAvail(const xmlBufPtr buf)
Definition: buf.c:708
input
GLenum GLenum GLenum input
Definition: glext.h:9031
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
xmlBufUse
XMLPUBFUN size_t XMLCALL xmlBufUse(const xmlBufPtr buf)
Definition: buf.c:687
xmlBufShrink
XMLPUBFUN size_t XMLCALL xmlBufShrink(xmlBufPtr buf, size_t len)
Definition: buf.c:388
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlSwitchInputEncodingInt().

◆ xmlCharEncOutFunc()

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

2627  {
2628  int ret;
2629  int written;
2630  int writtentot = 0;
2631  int toconv;
2632  int output = 0;
2633 
2634  if (handler == NULL) return(-1);
2635  if (out == NULL) return(-1);
2636 
2637 retry:
2638 
2639  written = out->size - out->use;
2640 
2641  if (written > 0)
2642  written--; /* Gennady: count '/0' */
2643 
2644  /*
2645  * First specific handling of in = NULL, i.e. the initialization call
2646  */
2647  if (in == NULL) {
2648  toconv = 0;
2649  /* TODO: Check return value. */
2650  xmlEncOutputChunk(handler, &out->content[out->use], &written,
2651  NULL, &toconv);
2652  out->use += written;
2653  out->content[out->use] = 0;
2654 #ifdef DEBUG_ENCODING
2655  xmlGenericError(xmlGenericErrorContext,
2656  "initialized encoder\n");
2657 #endif
2658  return(0);
2659  }
2660 
2661  /*
2662  * Conversion itself.
2663  */
2664  toconv = in->use;
2665  if (toconv == 0)
2666  return(0);
2667  if (toconv * 4 >= written) {
2668  xmlBufferGrow(out, toconv * 4);
2669  written = out->size - out->use - 1;
2670  }
2671  ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
2672  in->content, &toconv);
2673  xmlBufferShrink(in, toconv);
2674  out->use += written;
2675  writtentot += written;
2676  out->content[out->use] = 0;
2677  if (ret == -1) {
2678  if (written > 0) {
2679  /* Can be a limitation of iconv or uconv */
2680  goto retry;
2681  }
2682  ret = -3;
2683  }
2684 
2685  if (ret >= 0) output += ret;
2686 
2687  /*
2688  * Attempt to handle error cases
2689  */
2690  switch (ret) {
2691  case 0:
2692 #ifdef DEBUG_ENCODING
2693  xmlGenericError(xmlGenericErrorContext,
2694  "converted %d bytes to %d bytes of output\n",
2695  toconv, written);
2696 #endif
2697  break;
2698  case -1:
2699 #ifdef DEBUG_ENCODING
2700  xmlGenericError(xmlGenericErrorContext,
2701  "output conversion failed by lack of space\n");
2702 #endif
2703  break;
2704  case -3:
2705 #ifdef DEBUG_ENCODING
2706  xmlGenericError(xmlGenericErrorContext,"converted %d bytes to %d bytes of output %d left\n",
2707  toconv, written, in->use);
2708 #endif
2709  break;
2710  case -4:
2711  xmlEncodingErr(XML_I18N_NO_OUTPUT,
2712  "xmlCharEncOutFunc: no output function !\n", NULL);
2713  ret = -1;
2714  break;
2715  case -2: {
2716  xmlChar charref[20];
2717  int len = in->use;
2718  const xmlChar *utf = (const xmlChar *) in->content;
2719  int cur, charrefLen;
2720 
2721  cur = xmlGetUTF8Char(utf, &len);
2722  if (cur <= 0)
2723  break;
2724 
2725 #ifdef DEBUG_ENCODING
2726  xmlGenericError(xmlGenericErrorContext,
2727  "handling output conversion error\n");
2728  xmlGenericError(xmlGenericErrorContext,
2729  "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
2730  in->content[0], in->content[1],
2731  in->content[2], in->content[3]);
2732 #endif
2733  /*
2734  * Removes the UTF8 sequence, and replace it by a charref
2735  * and continue the transcoding phase, hoping the error
2736  * did not mangle the encoder state.
2737  */
2738  charrefLen = snprintf((char *) &charref[0], sizeof(charref),
2739  "&#%d;", cur);
2740  xmlBufferShrink(in, len);
2741  xmlBufferGrow(out, charrefLen * 4);
2742  written = out->size - out->use - 1;
2743  toconv = charrefLen;
2744  ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
2745  charref, &toconv);
2746 
2747  if ((ret < 0) || (toconv != charrefLen)) {
2748  char buf[50];
2749 
2750  snprintf(&buf[0], 49, "0x%02X 0x%02X 0x%02X 0x%02X",
2751  in->content[0], in->content[1],
2752  in->content[2], in->content[3]);
2753  buf[49] = 0;
2754  xmlEncodingErr(XML_I18N_CONV_FAILED,
2755  "output conversion failed due to conv error, bytes %s\n",
2756  buf);
2757  if (in->alloc != XML_BUFFER_ALLOC_IMMUTABLE)
2758  in->content[0] = ' ';
2759  break;
2760  }
2761 
2762  out->use += written;
2763  writtentot += written;
2764  out->content[out->use] = 0;
2765  goto retry;
2766  }
2767  }
2768  return(writtentot ? writtentot : ret);
2769 }
snprintf
#define snprintf
Definition: wintirpc.h:48
xmlBufferGrow
XMLPUBFUN int XMLCALL xmlBufferGrow(xmlBufferPtr buf, unsigned int len)
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlEncOutputChunk
static int xmlEncOutputChunk(xmlCharEncodingHandler *handler, unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
Definition: encoding.c:2004
xmlBufferShrink
XMLPUBFUN int XMLCALL xmlBufferShrink(xmlBufferPtr buf, unsigned int len)
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
xmlChar
unsigned char xmlChar
Definition: xmlstring.h:28
len
GLenum GLsizei len
Definition: glext.h:6722
cur
FxCollectionEntry * cur
Definition: fxresourceapi.cpp:412
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
xmlGetUTF8Char
XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL XMLPUBFUN int XMLCALL xmlGetUTF8Char(const unsigned char *utf, int *len)
Definition: xmlstring.c:713
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

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

1465  {
1466  xmlCleanupEncodingAliases();
1467 
1468  if (handlers == NULL) return;
1469 
1470  for (;nbCharEncodingHandler > 0;) {
1471  nbCharEncodingHandler--;
1472  if (handlers[nbCharEncodingHandler] != NULL) {
1473  if (handlers[nbCharEncodingHandler]->name != NULL)
1474  xmlFree(handlers[nbCharEncodingHandler]->name);
1475  xmlFree(handlers[nbCharEncodingHandler]);
1476  }
1477  }
1478  xmlFree(handlers);
1479  handlers = NULL;
1480  nbCharEncodingHandler = 0;
1481  xmlDefaultCharEncodingHandler = NULL;
1482 }
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlDefaultCharEncodingHandler
static xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler
Definition: encoding.c:1315
xmlCleanupEncodingAliases
void xmlCleanupEncodingAliases(void)
Definition: encoding.c:1002
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
nbCharEncodingHandler
static int nbCharEncodingHandler
Definition: encoding.c:1308
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38

Referenced by xmlCleanupParser().

◆ xmlCleanupEncodingAliases()

void xmlCleanupEncodingAliases ( void  )

xmlCleanupEncodingAliases:

Unregisters all aliases

Definition at line 1002 of file encoding.c.

1002  {
1003  int i;
1004 
1005  if (xmlCharEncodingAliases == NULL)
1006  return;
1007 
1008  for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
1009  if (xmlCharEncodingAliases[i].name != NULL)
1010  xmlFree((char *) xmlCharEncodingAliases[i].name);
1011  if (xmlCharEncodingAliases[i].alias != NULL)
1012  xmlFree((char *) xmlCharEncodingAliases[i].alias);
1013  }
1014  xmlCharEncodingAliasesNb = 0;
1015  xmlCharEncodingAliasesMax = 0;
1016  xmlFree(xmlCharEncodingAliases);
1017  xmlCharEncodingAliases = NULL;
1018 }
xmlCharEncodingAliases
static xmlCharEncodingAliasPtr xmlCharEncodingAliases
Definition: encoding.c:61
xmlCharEncodingAliasesMax
static int xmlCharEncodingAliasesMax
Definition: encoding.c:63
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlCharEncodingAliasesNb
static int xmlCharEncodingAliasesNb
Definition: encoding.c:62
alias
const WCHAR * alias
Definition: main.c:67
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38

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

1124  {
1125  int i;
1126 
1127  if (alias == NULL)
1128  return(-1);
1129 
1130  if (xmlCharEncodingAliases == NULL)
1131  return(-1);
1132  /*
1133  * Walk down the list looking for a definition of the alias
1134  */
1135  for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
1136  if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) {
1137  xmlFree((char *) xmlCharEncodingAliases[i].name);
1138  xmlFree((char *) xmlCharEncodingAliases[i].alias);
1139  xmlCharEncodingAliasesNb--;
1140  memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1],
1141  sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i));
1142  return(0);
1143  }
1144  }
1145  return(-1);
1146 }
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
xmlCharEncodingAliases
static xmlCharEncodingAliasPtr xmlCharEncodingAliases
Definition: encoding.c:61
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlCharEncodingAliasesNb
static int xmlCharEncodingAliasesNb
Definition: encoding.c:62
alias
const WCHAR * alias
Definition: main.c:67
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_xmlCharEncodingAlias
Definition: encoding.c:56
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

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

943 {
944  if (in == NULL)
945  return(XML_CHAR_ENCODING_NONE);
946  if (len >= 4) {
947  if ((in[0] == 0x00) && (in[1] == 0x00) &&
948  (in[2] == 0x00) && (in[3] == 0x3C))
949  return(XML_CHAR_ENCODING_UCS4BE);
950  if ((in[0] == 0x3C) && (in[1] == 0x00) &&
951  (in[2] == 0x00) && (in[3] == 0x00))
952  return(XML_CHAR_ENCODING_UCS4LE);
953  if ((in[0] == 0x00) && (in[1] == 0x00) &&
954  (in[2] == 0x3C) && (in[3] == 0x00))
955  return(XML_CHAR_ENCODING_UCS4_2143);
956  if ((in[0] == 0x00) && (in[1] == 0x3C) &&
957  (in[2] == 0x00) && (in[3] == 0x00))
958  return(XML_CHAR_ENCODING_UCS4_3412);
959  if ((in[0] == 0x4C) && (in[1] == 0x6F) &&
960  (in[2] == 0xA7) && (in[3] == 0x94))
961  return(XML_CHAR_ENCODING_EBCDIC);
962  if ((in[0] == 0x3C) && (in[1] == 0x3F) &&
963  (in[2] == 0x78) && (in[3] == 0x6D))
964  return(XML_CHAR_ENCODING_UTF8);
965  /*
966  * Although not part of the recommendation, we also
967  * attempt an "auto-recognition" of UTF-16LE and
968  * UTF-16BE encodings.
969  */
970  if ((in[0] == 0x3C) && (in[1] == 0x00) &&
971  (in[2] == 0x3F) && (in[3] == 0x00))
972  return(XML_CHAR_ENCODING_UTF16LE);
973  if ((in[0] == 0x00) && (in[1] == 0x3C) &&
974  (in[2] == 0x00) && (in[3] == 0x3F))
975  return(XML_CHAR_ENCODING_UTF16BE);
976  }
977  if (len >= 3) {
978  /*
979  * Errata on XML-1.0 June 20 2001
980  * We now allow an UTF8 encoded BOM
981  */
982  if ((in[0] == 0xEF) && (in[1] == 0xBB) &&
983  (in[2] == 0xBF))
984  return(XML_CHAR_ENCODING_UTF8);
985  }
986  /* For UTF-16 we can recognize by the BOM */
987  if (len >= 2) {
988  if ((in[0] == 0xFE) && (in[1] == 0xFF))
989  return(XML_CHAR_ENCODING_UTF16BE);
990  if ((in[0] == 0xFF) && (in[1] == 0xFE))
991  return(XML_CHAR_ENCODING_UTF16LE);
992  }
993  return(XML_CHAR_ENCODING_NONE);
994 }
len
GLenum GLsizei len
Definition: glext.h:6722
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112

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

xmlEncInputChunk: @handler: encoding handler @out: a pointer to an array of bytes to store the result @outlen: the length of @out @in: a pointer to an array of input bytes @inlen: the length of @in @flush: flush (ICU-related)

Returns 0 if success, or -1 by lack of space, or -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 -3 if there the last byte can't form a single output char.

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

Definition at line 1954 of file encoding.c.

1955  {
1956  int ret;
1957  (void)flush;
1958 
1959  if (handler->input != NULL) {
1960  ret = handler->input(out, outlen, in, inlen);
1961  if (ret > 0)
1962  ret = 0;
1963  }
1964 #ifdef LIBXML_ICONV_ENABLED
1965  else if (handler->iconv_in != NULL) {
1966  ret = xmlIconvWrapper(handler->iconv_in, out, outlen, in, inlen);
1967  }
1968 #endif /* LIBXML_ICONV_ENABLED */
1969 #ifdef LIBXML_ICU_ENABLED
1970  else if (handler->uconv_in != NULL) {
1971  ret = xmlUconvWrapper(handler->uconv_in, 1, out, outlen, in, inlen,
1972  flush);
1973  }
1974 #endif /* LIBXML_ICU_ENABLED */
1975  else {
1976  *outlen = 0;
1977  *inlen = 0;
1978  ret = -2;
1979  }
1980 
1981  return(ret);
1982 }
void
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
flush
int flush
Definition: zlib.h:309
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

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

◆ xmlEncodingErrMemory()

static void xmlEncodingErrMemory ( const char *  extra)
static

xmlEncodingErrMemory: @extra: extra information

Handle an out of memory condition

Definition at line 84 of file encoding.c.

85 {
86  __xmlSimpleError(XML_FROM_I18N, XML_ERR_NO_MEMORY, NULL, NULL, extra);
87 }
extra
Definition: id3.c:95
NULL
#define NULL
Definition: types.h:112

Referenced by xmlInitCharEncodingHandlers(), and xmlNewCharEncodingHandler().

◆ xmlEncOutputChunk()

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

xmlEncOutputChunk: @handler: encoding handler @out: a pointer to an array of bytes to store the result @outlen: the length of @out @in: a pointer to an array of input bytes @inlen: the length of @in

Returns 0 if success, or -1 by lack of space, or -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 -3 if there the last byte can't form a single output char. -4 if no output function was found.

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

Definition at line 2004 of file encoding.c.

2005  {
2006  int ret;
2007 
2008  if (handler->output != NULL) {
2009  ret = handler->output(out, outlen, in, inlen);
2010  if (ret > 0)
2011  ret = 0;
2012  }
2013 #ifdef LIBXML_ICONV_ENABLED
2014  else if (handler->iconv_out != NULL) {
2015  ret = xmlIconvWrapper(handler->iconv_out, out, outlen, in, inlen);
2016  }
2017 #endif /* LIBXML_ICONV_ENABLED */
2018 #ifdef LIBXML_ICU_ENABLED
2019  else if (handler->uconv_out != NULL) {
2020  ret = xmlUconvWrapper(handler->uconv_out, 0, out, outlen, in, inlen,
2021  1);
2022  }
2023 #endif /* LIBXML_ICU_ENABLED */
2024  else {
2025  *outlen = 0;
2026  *inlen = 0;
2027  ret = -4;
2028  }
2029 
2030  return(ret);
2031 }
out
static FILE * out
Definition: regtests2xml.c:44
ret
int ret
Definition: wcstombs-tests.c:31
in
GLuint in
Definition: glext.h:9616
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

Referenced by xmlByteConsumed(), and xmlCharEncOutFunc().

◆ xmlFindCharEncodingHandler()

xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler ( const char *  name)

Definition at line 1660 of file encoding.c.

1660  {
1661  const char *nalias;
1662  const char *norig;
1663  xmlCharEncoding alias;
1664 #ifdef LIBXML_ICONV_ENABLED
1665  xmlCharEncodingHandlerPtr enc;
1666  iconv_t icv_in, icv_out;
1667 #endif /* LIBXML_ICONV_ENABLED */
1668 #ifdef LIBXML_ICU_ENABLED
1669  xmlCharEncodingHandlerPtr encu;
1670  uconv_t *ucv_in, *ucv_out;
1671 #endif /* LIBXML_ICU_ENABLED */
1672  char upper[100];
1673  int i;
1674 
1675  if (handlers == NULL) xmlInitCharEncodingHandlers();
1676  if (name == NULL) return(xmlDefaultCharEncodingHandler);
1677  if (name[0] == 0) return(xmlDefaultCharEncodingHandler);
1678 
1679  /*
1680  * Do the alias resolution
1681  */
1682  norig = name;
1683  nalias = xmlGetEncodingAlias(name);
1684  if (nalias != NULL)
1685  name = nalias;
1686 
1687  /*
1688  * Check first for directly registered encoding names
1689  */
1690  for (i = 0;i < 99;i++) {
1691  upper[i] = toupper(name[i]);
1692  if (upper[i] == 0) break;
1693  }
1694  upper[i] = 0;
1695 
1696  if (handlers != NULL) {
1697  for (i = 0;i < nbCharEncodingHandler; i++) {
1698  if (!strcmp(upper, handlers[i]->name)) {
1699 #ifdef DEBUG_ENCODING
1700  xmlGenericError(xmlGenericErrorContext,
1701  "Found registered handler for encoding %s\n", name);
1702 #endif
1703  return(handlers[i]);
1704  }
1705  }
1706  }
1707 
1708 #ifdef LIBXML_ICONV_ENABLED
1709  /* check whether iconv can handle this */
1710  icv_in = iconv_open("UTF-8", name);
1711  icv_out = iconv_open(name, "UTF-8");
1712  if (icv_in == (iconv_t) -1) {
1713  icv_in = iconv_open("UTF-8", upper);
1714  }
1715  if (icv_out == (iconv_t) -1) {
1716  icv_out = iconv_open(upper, "UTF-8");
1717  }
1718  if ((icv_in != (iconv_t) -1) && (icv_out != (iconv_t) -1)) {
1719  enc = (xmlCharEncodingHandlerPtr)
1720  xmlMalloc(sizeof(xmlCharEncodingHandler));
1721  if (enc == NULL) {
1722  iconv_close(icv_in);
1723  iconv_close(icv_out);
1724  return(NULL);
1725  }
1726  memset(enc, 0, sizeof(xmlCharEncodingHandler));
1727  enc->name = xmlMemStrdup(name);
1728  enc->input = NULL;
1729  enc->output = NULL;
1730  enc->iconv_in = icv_in;
1731  enc->iconv_out = icv_out;
1732 #ifdef DEBUG_ENCODING
1733  xmlGenericError(xmlGenericErrorContext,
1734  "Found iconv handler for encoding %s\n", name);
1735 #endif
1736  return enc;
1737  } else if ((icv_in != (iconv_t) -1) || icv_out != (iconv_t) -1) {
1738  xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
1739  "iconv : problems with filters for '%s'\n", name);
1740  }
1741 #endif /* LIBXML_ICONV_ENABLED */
1742 #ifdef LIBXML_ICU_ENABLED
1743  /* check whether icu can handle this */
1744  ucv_in = openIcuConverter(name, 1);
1745  ucv_out = openIcuConverter(name, 0);
1746  if (ucv_in != NULL && ucv_out != NULL) {
1747  encu = (xmlCharEncodingHandlerPtr)
1748  xmlMalloc(sizeof(xmlCharEncodingHandler));
1749  if (encu == NULL) {
1750  closeIcuConverter(ucv_in);
1751  closeIcuConverter(ucv_out);
1752  return(NULL);
1753  }
1754  memset(encu, 0, sizeof(xmlCharEncodingHandler));
1755  encu->name = xmlMemStrdup(name);
1756  encu->input = NULL;
1757  encu->output = NULL;
1758  encu->uconv_in = ucv_in;
1759  encu->uconv_out = ucv_out;
1760 #ifdef DEBUG_ENCODING
1761  xmlGenericError(xmlGenericErrorContext,
1762  "Found ICU converter handler for encoding %s\n", name);
1763 #endif
1764  return encu;
1765  } else if (ucv_in != NULL || ucv_out != NULL) {
1766  closeIcuConverter(ucv_in);
1767  closeIcuConverter(ucv_out);
1768  xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
1769  "ICU converter : problems with filters for '%s'\n", name);
1770  }
1771 #endif /* LIBXML_ICU_ENABLED */
1772 
1773 #ifdef DEBUG_ENCODING
1774  xmlGenericError(xmlGenericErrorContext,
1775  "No handler found for encoding %s\n", name);
1776 #endif
1777 
1778  /*
1779  * Fallback using the canonical names
1780  */
1781  alias = xmlParseCharEncoding(norig);
1782  if (alias != XML_CHAR_ENCODING_ERROR) {
1783  const char* canon;
1784  canon = xmlGetCharEncodingName(alias);
1785  if ((canon != NULL) && (strcmp(name, canon))) {
1786  return(xmlFindCharEncodingHandler(canon));
1787  }
1788  }
1789 
1790  /* If "none of the above", give up */
1791  return(NULL);
1792 }
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlInitCharEncodingHandlers
void xmlInitCharEncodingHandlers(void)
Definition: encoding.c:1407
xmlCharEncoding
xmlCharEncoding
Definition: encoding.h:58
xmlDefaultCharEncodingHandler
static xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler
Definition: encoding.c:1315
xmlFindCharEncodingHandler
xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1660
_xmlCharEncodingHandler::output
xmlCharEncodingOutputFunc output
Definition: encoding.h:149
_xmlCharEncodingHandler::input
xmlCharEncodingInputFunc input
Definition: encoding.h:148
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
toupper
int toupper(int c)
Definition: utclib.c:881
_xmlCharEncodingHandler
Definition: encoding.h:146
_xmlCharEncodingHandler::name
char * name
Definition: encoding.h:147
iconv_open
iconv_t iconv_open(const char *tocode, const char *fromcode)
Definition: win_iconv.c:730
xmlGetEncodingAlias
const char * xmlGetEncodingAlias(const char *alias)
Definition: encoding.c:1029
alias
const WCHAR * alias
Definition: main.c:67
nbCharEncodingHandler
static int nbCharEncodingHandler
Definition: encoding.c:1308
xmlMemStrdup
XMLPUBVAR xmlStrdupFunc xmlMemStrdup
Definition: globals.h:251
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
xmlCharEncodingHandlerPtr
xmlCharEncodingHandler * xmlCharEncodingHandlerPtr
Definition: encoding.h:145
NULL
#define NULL
Definition: types.h:112
xmlMalloc
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
name
Definition: name.c:38
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
xmlParseCharEncoding
xmlCharEncoding xmlParseCharEncoding(const char *name)
Definition: encoding.c:1160
iconv_close
int iconv_close(iconv_t cd)
Definition: win_iconv.c:756
memset
#define memset(x, y, z)
Definition: compat.h:39
xmlGetCharEncodingName
const char * xmlGetCharEncodingName(xmlCharEncoding enc)
Definition: encoding.c:1244
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362
name
GLuint const GLchar * name
Definition: glext.h:6031

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

1526  {
1527  xmlCharEncodingHandlerPtr handler;
1528 
1529  if (handlers == NULL) xmlInitCharEncodingHandlers();
1530  switch (enc) {
1531  case XML_CHAR_ENCODING_ERROR:
1532  return(NULL);
1533  case XML_CHAR_ENCODING_NONE:
1534  return(NULL);
1535  case XML_CHAR_ENCODING_UTF8:
1536  return(NULL);
1537  case XML_CHAR_ENCODING_UTF16LE:
1538  return(xmlUTF16LEHandler);
1539  case XML_CHAR_ENCODING_UTF16BE:
1540  return(xmlUTF16BEHandler);
1541  case XML_CHAR_ENCODING_EBCDIC:
1542  handler = xmlFindCharEncodingHandler("EBCDIC");
1543  if (handler != NULL) return(handler);
1544  handler = xmlFindCharEncodingHandler("ebcdic");
1545  if (handler != NULL) return(handler);
1546  handler = xmlFindCharEncodingHandler("EBCDIC-US");
1547  if (handler != NULL) return(handler);
1548  handler = xmlFindCharEncodingHandler("IBM-037");
1549  if (handler != NULL) return(handler);
1550  break;
1551  case XML_CHAR_ENCODING_UCS4BE:
1552  handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
1553  if (handler != NULL) return(handler);
1554  handler = xmlFindCharEncodingHandler("UCS-4");
1555  if (handler != NULL) return(handler);
1556  handler = xmlFindCharEncodingHandler("UCS4");
1557  if (handler != NULL) return(handler);
1558  break;
1559  case XML_CHAR_ENCODING_UCS4LE:
1560  handler = xmlFindCharEncodingHandler("ISO-10646-UCS-4");
1561  if (handler != NULL) return(handler);
1562  handler = xmlFindCharEncodingHandler("UCS-4");
1563  if (handler != NULL) return(handler);
1564  handler = xmlFindCharEncodingHandler("UCS4");
1565  if (handler != NULL) return(handler);
1566  break;
1567  case XML_CHAR_ENCODING_UCS4_2143:
1568  break;
1569  case XML_CHAR_ENCODING_UCS4_3412:
1570  break;
1571  case XML_CHAR_ENCODING_UCS2:
1572  handler = xmlFindCharEncodingHandler("ISO-10646-UCS-2");
1573  if (handler != NULL) return(handler);
1574  handler = xmlFindCharEncodingHandler("UCS-2");
1575  if (handler != NULL) return(handler);
1576  handler = xmlFindCharEncodingHandler("UCS2");
1577  if (handler != NULL) return(handler);
1578  break;
1579 
1580  /*
1581  * We used to keep ISO Latin encodings native in the
1582  * generated data. This led to so many problems that
1583  * this has been removed. One can still change this
1584  * back by registering no-ops encoders for those
1585  */
1586  case XML_CHAR_ENCODING_8859_1:
1587  handler = xmlFindCharEncodingHandler("ISO-8859-1");
1588  if (handler != NULL) return(handler);
1589  break;
1590  case XML_CHAR_ENCODING_8859_2:
1591  handler = xmlFindCharEncodingHandler("ISO-8859-2");
1592  if (handler != NULL) return(handler);
1593  break;
1594  case XML_CHAR_ENCODING_8859_3:
1595  handler = xmlFindCharEncodingHandler("ISO-8859-3");
1596  if (handler != NULL) return(handler);
1597  break;
1598  case XML_CHAR_ENCODING_8859_4:
1599  handler = xmlFindCharEncodingHandler("ISO-8859-4");
1600  if (handler != NULL) return(handler);
1601  break;
1602  case XML_CHAR_ENCODING_8859_5:
1603  handler = xmlFindCharEncodingHandler("ISO-8859-5");
1604  if (handler != NULL) return(handler);
1605  break;
1606  case XML_CHAR_ENCODING_8859_6:
1607  handler = xmlFindCharEncodingHandler("ISO-8859-6");
1608  if (handler != NULL) return(handler);
1609  break;
1610  case XML_CHAR_ENCODING_8859_7:
1611  handler = xmlFindCharEncodingHandler("ISO-8859-7");
1612  if (handler != NULL) return(handler);
1613  break;
1614  case XML_CHAR_ENCODING_8859_8:
1615  handler = xmlFindCharEncodingHandler("ISO-8859-8");
1616  if (handler != NULL) return(handler);
1617  break;
1618  case XML_CHAR_ENCODING_8859_9:
1619  handler = xmlFindCharEncodingHandler("ISO-8859-9");
1620  if (handler != NULL) return(handler);
1621  break;
1622 
1623 
1624  case XML_CHAR_ENCODING_2022_JP:
1625  handler = xmlFindCharEncodingHandler("ISO-2022-JP");
1626  if (handler != NULL) return(handler);
1627  break;
1628  case XML_CHAR_ENCODING_SHIFT_JIS:
1629  handler = xmlFindCharEncodingHandler("SHIFT-JIS");
1630  if (handler != NULL) return(handler);
1631  handler = xmlFindCharEncodingHandler("SHIFT_JIS");
1632  if (handler != NULL) return(handler);
1633  handler = xmlFindCharEncodingHandler("Shift_JIS");
1634  if (handler != NULL) return(handler);
1635  break;
1636  case XML_CHAR_ENCODING_EUC_JP:
1637  handler = xmlFindCharEncodingHandler("EUC-JP");
1638  if (handler != NULL) return(handler);
1639  break;
1640  default:
1641  break;
1642  }
1643 
1644 #ifdef DEBUG_ENCODING
1645  xmlGenericError(xmlGenericErrorContext,
1646  "No handler found for encoding %d\n", enc);
1647 #endif
1648  return(NULL);
1649 }
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlInitCharEncodingHandlers
void xmlInitCharEncodingHandlers(void)
Definition: encoding.c:1407
xmlUTF16BEHandler
static xmlCharEncodingHandlerPtr xmlUTF16BEHandler
Definition: encoding.c:52
xmlFindCharEncodingHandler
xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1660
xmlUTF16LEHandler
static xmlCharEncodingHandlerPtr xmlUTF16LEHandler
Definition: encoding.c:51
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
_xmlCharEncodingHandler
Definition: encoding.h:146
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

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

1244  {
1245  switch (enc) {
1246  case XML_CHAR_ENCODING_ERROR:
1247  return(NULL);
1248  case XML_CHAR_ENCODING_NONE:
1249  return(NULL);
1250  case XML_CHAR_ENCODING_UTF8:
1251  return("UTF-8");
1252  case XML_CHAR_ENCODING_UTF16LE:
1253  return("UTF-16");
1254  case XML_CHAR_ENCODING_UTF16BE:
1255  return("UTF-16");
1256  case XML_CHAR_ENCODING_EBCDIC:
1257  return("EBCDIC");
1258  case XML_CHAR_ENCODING_UCS4LE:
1259  return("ISO-10646-UCS-4");
1260  case XML_CHAR_ENCODING_UCS4BE:
1261  return("ISO-10646-UCS-4");
1262  case XML_CHAR_ENCODING_UCS4_2143:
1263  return("ISO-10646-UCS-4");
1264  case XML_CHAR_ENCODING_UCS4_3412:
1265  return("ISO-10646-UCS-4");
1266  case XML_CHAR_ENCODING_UCS2:
1267  return("ISO-10646-UCS-2");
1268  case XML_CHAR_ENCODING_8859_1:
1269  return("ISO-8859-1");
1270  case XML_CHAR_ENCODING_8859_2:
1271  return("ISO-8859-2");
1272  case XML_CHAR_ENCODING_8859_3:
1273  return("ISO-8859-3");
1274  case XML_CHAR_ENCODING_8859_4:
1275  return("ISO-8859-4");
1276  case XML_CHAR_ENCODING_8859_5:
1277  return("ISO-8859-5");
1278  case XML_CHAR_ENCODING_8859_6:
1279  return("ISO-8859-6");
1280  case XML_CHAR_ENCODING_8859_7:
1281  return("ISO-8859-7");
1282  case XML_CHAR_ENCODING_8859_8:
1283  return("ISO-8859-8");
1284  case XML_CHAR_ENCODING_8859_9:
1285  return("ISO-8859-9");
1286  case XML_CHAR_ENCODING_2022_JP:
1287  return("ISO-2022-JP");
1288  case XML_CHAR_ENCODING_SHIFT_JIS:
1289  return("Shift-JIS");
1290  case XML_CHAR_ENCODING_EUC_JP:
1291  return("EUC-JP");
1292  case XML_CHAR_ENCODING_ASCII:
1293  return(NULL);
1294  }
1295  return(NULL);
1296 }
NULL
#define NULL
Definition: types.h:112

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

1029  {
1030  int i;
1031  char upper[100];
1032 
1033  if (alias == NULL)
1034  return(NULL);
1035 
1036  if (xmlCharEncodingAliases == NULL)
1037  return(NULL);
1038 
1039  for (i = 0;i < 99;i++) {
1040  upper[i] = toupper(alias[i]);
1041  if (upper[i] == 0) break;
1042  }
1043  upper[i] = 0;
1044 
1045  /*
1046  * Walk down the list looking for a definition of the alias
1047  */
1048  for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
1049  if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
1050  return(xmlCharEncodingAliases[i].name);
1051  }
1052  }
1053  return(NULL);
1054 }
xmlCharEncodingAliases
static xmlCharEncodingAliasPtr xmlCharEncodingAliases
Definition: encoding.c:61
toupper
int toupper(int c)
Definition: utclib.c:881
xmlCharEncodingAliasesNb
static int xmlCharEncodingAliasesNb
Definition: encoding.c:62
alias
const WCHAR * alias
Definition: main.c:67
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

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

1407  {
1408  unsigned short int tst = 0x1234;
1409  unsigned char *ptr = (unsigned char *) &tst;
1410 
1411  if (handlers != NULL) return;
1412 
1413  handlers = (xmlCharEncodingHandlerPtr *)
1414  xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(xmlCharEncodingHandlerPtr));
1415 
1416  if (*ptr == 0x12) xmlLittleEndian = 0;
1417  else if (*ptr == 0x34) xmlLittleEndian = 1;
1418  else {
1419  xmlEncodingErr(XML_ERR_INTERNAL_ERROR,
1420  "Odd problem at endianness detection\n", NULL);
1421  }
1422 
1423  if (handlers == NULL) {
1424  xmlEncodingErrMemory("xmlInitCharEncodingHandlers : out of memory !\n");
1425  return;
1426  }
1427  xmlNewCharEncodingHandler("UTF-8", UTF8ToUTF8, UTF8ToUTF8);
1428 #ifdef LIBXML_OUTPUT_ENABLED
1429  xmlUTF16LEHandler =
1430  xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE);
1431  xmlUTF16BEHandler =
1432  xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE);
1433  xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, UTF8ToUTF16);
1434  xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, UTF8Toisolat1);
1435  xmlNewCharEncodingHandler("ASCII", asciiToUTF8, UTF8Toascii);
1436  xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, UTF8Toascii);
1437 #ifdef LIBXML_HTML_ENABLED
1438  xmlNewCharEncodingHandler("HTML", NULL, UTF8ToHtml);
1439 #endif
1440 #else
1441  xmlUTF16LEHandler =
1442  xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, NULL);
1443  xmlUTF16BEHandler =
1444  xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, NULL);
1445  xmlNewCharEncodingHandler("UTF-16", UTF16LEToUTF8, NULL);
1446  xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, NULL);
1447  xmlNewCharEncodingHandler("ASCII", asciiToUTF8, NULL);
1448  xmlNewCharEncodingHandler("US-ASCII", asciiToUTF8, NULL);
1449 #endif /* LIBXML_OUTPUT_ENABLED */
1450 #if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED)
1451 #ifdef LIBXML_ISO8859X_ENABLED
1452  xmlRegisterCharEncodingHandlersISO8859x ();
1453 #endif
1454 #endif
1455 
1456 }
xmlEncodingErrMemory
static void xmlEncodingErrMemory(const char *extra)
Definition: encoding.c:84
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlUTF16BEHandler
static xmlCharEncodingHandlerPtr xmlUTF16BEHandler
Definition: encoding.c:52
asciiToUTF8
static int asciiToUTF8(unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
Definition: encoding.c:176
UTF16BEToUTF8
static int UTF16BEToUTF8(unsigned char *out, int *outlen, const unsigned char *inb, int *inlenb)
Definition: encoding.c:742
xmlUTF16LEHandler
static xmlCharEncodingHandlerPtr xmlUTF16LEHandler
Definition: encoding.c:51
UTF16LEToUTF8
static int UTF16LEToUTF8(unsigned char *out, int *outlen, const unsigned char *inb, int *inlenb)
Definition: encoding.c:499
ptr
static PVOID ptr
Definition: dispmode.c:27
MAX_ENCODING_HANDLERS
#define MAX_ENCODING_HANDLERS
Definition: encoding.c:1306
xmlLittleEndian
static int xmlLittleEndian
Definition: encoding.c:75
_xmlCharEncodingHandler
Definition: encoding.h:146
xmlNewCharEncodingHandler
xmlCharEncodingHandlerPtr xmlNewCharEncodingHandler(const char *name, xmlCharEncodingInputFunc input, xmlCharEncodingOutputFunc output)
Definition: encoding.c:1328
NULL
#define NULL
Definition: types.h:112
xmlMalloc
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
UTF8ToUTF8
static int UTF8ToUTF8(unsigned char *out, int *outlen, const unsigned char *inb, int *inlenb)
Definition: encoding.c:355
isolat1ToUTF8
int isolat1ToUTF8(unsigned char *out, int *outlen, const unsigned char *in, int *inlen)
Definition: encoding.c:307

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

◆ xmlNewCharEncodingHandler()

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

Definition at line 1328 of file encoding.c.

1330  {
1331  xmlCharEncodingHandlerPtr handler;
1332  const char *alias;
1333  char upper[500];
1334  int i;
1335  char *up = NULL;
1336 
1337  /*
1338  * Do the alias resolution
1339  */
1340  alias = xmlGetEncodingAlias(name);
1341  if (alias != NULL)
1342  name = alias;
1343 
1344  /*
1345  * Keep only the uppercase version of the encoding.
1346  */
1347  if (name == NULL) {
1348  xmlEncodingErr(XML_I18N_NO_NAME,
1349  "xmlNewCharEncodingHandler : no name !\n", NULL);
1350  return(NULL);
1351  }
1352  for (i = 0;i < 499;i++) {
1353  upper[i] = toupper(name[i]);
1354  if (upper[i] == 0) break;
1355  }
1356  upper[i] = 0;
1357  up = xmlMemStrdup(upper);
1358  if (up == NULL) {
1359  xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n");
1360  return(NULL);
1361  }
1362 
1363  /*
1364  * allocate and fill-up an handler block.
1365  */
1366  handler = (xmlCharEncodingHandlerPtr)
1367  xmlMalloc(sizeof(xmlCharEncodingHandler));
1368  if (handler == NULL) {
1369  xmlFree(up);
1370  xmlEncodingErrMemory("xmlNewCharEncodingHandler : out of memory !\n");
1371  return(NULL);
1372  }
1373  memset(handler, 0, sizeof(xmlCharEncodingHandler));
1374  handler->input = input;
1375  handler->output = output;
1376  handler->name = up;
1377 
1378 #ifdef LIBXML_ICONV_ENABLED
1379  handler->iconv_in = NULL;
1380  handler->iconv_out = NULL;
1381 #endif
1382 #ifdef LIBXML_ICU_ENABLED
1383  handler->uconv_in = NULL;
1384  handler->uconv_out = NULL;
1385 #endif
1386 
1387  /*
1388  * registers and returns the handler.
1389  */
1390  xmlRegisterCharEncodingHandler(handler);
1391 #ifdef DEBUG_ENCODING
1392  xmlGenericError(xmlGenericErrorContext,
1393  "Registered encoding handler for %s\n", name);
1394 #endif
1395  return(handler);
1396 }
xmlEncodingErrMemory
static void xmlEncodingErrMemory(const char *extra)
Definition: encoding.c:84
up
#define up(mutex)
Definition: glue.h:30
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
toupper
int toupper(int c)
Definition: utclib.c:881
_xmlCharEncodingHandler
Definition: encoding.h:146
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlGetEncodingAlias
const char * xmlGetEncodingAlias(const char *alias)
Definition: encoding.c:1029
alias
const WCHAR * alias
Definition: main.c:67
xmlRegisterCharEncodingHandler
void xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler)
Definition: encoding.c:1491
xmlMemStrdup
XMLPUBVAR xmlStrdupFunc xmlMemStrdup
Definition: globals.h:251
input
GLenum GLenum GLenum input
Definition: glext.h:9031
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
xmlCharEncodingHandlerPtr
xmlCharEncodingHandler * xmlCharEncodingHandlerPtr
Definition: encoding.h:145
NULL
#define NULL
Definition: types.h:112
xmlMalloc
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
name
Definition: name.c:38
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
memset
#define memset(x, y, z)
Definition: compat.h:39
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

Referenced by xmlInitCharEncodingHandlers().

◆ xmlParseCharEncoding()

xmlCharEncoding xmlParseCharEncoding ( const char *  name)

Definition at line 1160 of file encoding.c.

1161 {
1162  const char *alias;
1163  char upper[500];
1164  int i;
1165 
1166  if (name == NULL)
1167  return(XML_CHAR_ENCODING_NONE);
1168 
1169  /*
1170  * Do the alias resolution
1171  */
1172  alias = xmlGetEncodingAlias(name);
1173  if (alias != NULL)
1174  name = alias;
1175 
1176  for (i = 0;i < 499;i++) {
1177  upper[i] = toupper(name[i]);
1178  if (upper[i] == 0) break;
1179  }
1180  upper[i] = 0;
1181 
1182  if (!strcmp(upper, "")) return(XML_CHAR_ENCODING_NONE);
1183  if (!strcmp(upper, "UTF-8")) return(XML_CHAR_ENCODING_UTF8);
1184  if (!strcmp(upper, "UTF8")) return(XML_CHAR_ENCODING_UTF8);
1185 
1186  /*
1187  * NOTE: if we were able to parse this, the endianness of UTF16 is
1188  * already found and in use
1189  */
1190  if (!strcmp(upper, "UTF-16")) return(XML_CHAR_ENCODING_UTF16LE);
1191  if (!strcmp(upper, "UTF16")) return(XML_CHAR_ENCODING_UTF16LE);
1192 
1193  if (!strcmp(upper, "ISO-10646-UCS-2")) return(XML_CHAR_ENCODING_UCS2);
1194  if (!strcmp(upper, "UCS-2")) return(XML_CHAR_ENCODING_UCS2);
1195  if (!strcmp(upper, "UCS2")) return(XML_CHAR_ENCODING_UCS2);
1196 
1197  /*
1198  * NOTE: if we were able to parse this, the endianness of UCS4 is
1199  * already found and in use
1200  */
1201  if (!strcmp(upper, "ISO-10646-UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
1202  if (!strcmp(upper, "UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);
1203  if (!strcmp(upper, "UCS4")) return(XML_CHAR_ENCODING_UCS4LE);
1204 
1205 
1206  if (!strcmp(upper, "ISO-8859-1")) return(XML_CHAR_ENCODING_8859_1);
1207  if (!strcmp(upper, "ISO-LATIN-1")) return(XML_CHAR_ENCODING_8859_1);
1208  if (!strcmp(upper, "ISO LATIN 1")) return(XML_CHAR_ENCODING_8859_1);
1209 
1210  if (!strcmp(upper, "ISO-8859-2")) return(XML_CHAR_ENCODING_8859_2);
1211  if (!strcmp(upper, "ISO-LATIN-2")) return(XML_CHAR_ENCODING_8859_2);
1212  if (!strcmp(upper, "ISO LATIN 2")) return(XML_CHAR_ENCODING_8859_2);
1213 
1214  if (!strcmp(upper, "ISO-8859-3")) return(XML_CHAR_ENCODING_8859_3);
1215  if (!strcmp(upper, "ISO-8859-4")) return(XML_CHAR_ENCODING_8859_4);
1216  if (!strcmp(upper, "ISO-8859-5")) return(XML_CHAR_ENCODING_8859_5);
1217  if (!strcmp(upper, "ISO-8859-6")) return(XML_CHAR_ENCODING_8859_6);
1218  if (!strcmp(upper, "ISO-8859-7")) return(XML_CHAR_ENCODING_8859_7);
1219  if (!strcmp(upper, "ISO-8859-8")) return(XML_CHAR_ENCODING_8859_8);
1220  if (!strcmp(upper, "ISO-8859-9")) return(XML_CHAR_ENCODING_8859_9);
1221 
1222  if (!strcmp(upper, "ISO-2022-JP")) return(XML_CHAR_ENCODING_2022_JP);
1223  if (!strcmp(upper, "SHIFT_JIS")) return(XML_CHAR_ENCODING_SHIFT_JIS);
1224  if (!strcmp(upper, "EUC-JP")) return(XML_CHAR_ENCODING_EUC_JP);
1225 
1226 #ifdef DEBUG_ENCODING
1227  xmlGenericError(xmlGenericErrorContext, "Unknown encoding %s\n", name);
1228 #endif
1229  return(XML_CHAR_ENCODING_ERROR);
1230 }
xmlGenericError
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:346
toupper
int toupper(int c)
Definition: utclib.c:881
xmlGetEncodingAlias
const char * xmlGetEncodingAlias(const char *alias)
Definition: encoding.c:1029
alias
const WCHAR * alias
Definition: main.c:67
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NULL
#define NULL
Definition: types.h:112
name
Definition: name.c:38
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
xmlGenericErrorContext
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:362

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

1491  {
1492  if (handlers == NULL) xmlInitCharEncodingHandlers();
1493  if ((handler == NULL) || (handlers == NULL)) {
1494  xmlEncodingErr(XML_I18N_NO_HANDLER,
1495  "xmlRegisterCharEncodingHandler: NULL handler !\n", NULL);
1496  goto free_handler;
1497  }
1498 
1499  if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {
1500  xmlEncodingErr(XML_I18N_EXCESS_HANDLER,
1501  "xmlRegisterCharEncodingHandler: Too many handler registered, see %s\n",
1502  "MAX_ENCODING_HANDLERS");
1503  goto free_handler;
1504  }
1505  handlers[nbCharEncodingHandler++] = handler;
1506  return;
1507 
1508 free_handler:
1509  if (handler != NULL) {
1510  if (handler->name != NULL) {
1511  xmlFree(handler->name);
1512  }
1513  xmlFree(handler);
1514  }
1515 }
handlers
static xmlCharEncodingHandlerPtr * handlers
Definition: encoding.c:1307
xmlInitCharEncodingHandlers
void xmlInitCharEncodingHandlers(void)
Definition: encoding.c:1407
MAX_ENCODING_HANDLERS
#define MAX_ENCODING_HANDLERS
Definition: encoding.c:1306
xmlFree
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
nbCharEncodingHandler
static int nbCharEncodingHandler
Definition: encoding.c:1308
NULL
#define NULL
Definition: types.h:112
handler
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

Referenced by xmlNewCharEncodingHandler().

Variable Documentation

◆ handlers

xmlCharEncodingHandlerPtr* handlers = NULL
static

Definition at line 1307 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 1308 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 1315 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().