/** * UTF8ToUTF16BE: * @outb:  a pointer to an array of bytes to store the result * @outlen:  the length of @outb * @in:  a pointer to an array of UTF-8 chars * @inlen:  the length of @in * * Take a block of UTF-8 chars in and try to convert it to an UTF-16BE * block of chars out. * TODO: UTF8ToUTF16BE need a fallback mechanism ... * * Returns the number of byte written, or -1 by lack of space, or -2 *     if the transcoding failed.  */intUTF8ToUTF16BE(unsigned char* outb, int outlen,            const unsigned char* in, int *inlen){    unsigned short* out = (unsigned short*) outb;    unsigned short* outstart= out;    unsigned short* outend;    const unsigned char* inend= in+*inlen;    unsigned int c, d, trailing;#ifdef BIG_ENDIAN#else    unsigned char *tmp;    unsigned short tmp1, tmp2;#endif /* BIG_ENDIAN */        outlen /= 2; /* convert in short length */    outend = out + outlen;    while (in < inend) {      d= *in++;      if      (d < 0x80)  { c= d; trailing= 0; }      else if (d < 0xC0)          return(-2);    /* trailing byte in leading position */      else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }      else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }      else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }      else          return(-2);    /* no chance for this in UTF-16 */      if (inend - in < trailing) {          *inlen -= (inend - in);          break;      }       for ( ; trailing; trailing--) {          if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))  return(-1);          c <<= 6;          c |= d & 0x3F;      }      /* assertion: c is a single UTF-4 value */        if (c < 0x10000) {            if (out >= outend)  return(-1);#ifdef BIG_ENDIAN            *out++ = c;#else            tmp = (unsigned char *) out;            *tmp = c >> 8;            *(tmp + 1) = c;            out++;#endif /* BIG_ENDIAN */        }        else if (c < 0x110000) {            if (out+1 >= outend)  return(-1);            c -= 0x10000;#ifdef BIG_ENDIAN            *out++ = 0xD800 | (c >> 10);            *out++ = 0xDC00 | (c & 0x03FF);#else            tmp1 = 0xD800 | (c >> 10);            tmp = (unsigned char *) out;            *tmp = tmp1 >> 8;            *(tmp + 1) = tmp1;            out++;            tmp2 = 0xDC00 | (c & 0x03FF);            tmp = (unsigned char *) out;            *tmp = tmp2 >> 8;            *(tmp + 1) = tmp2;            out++;#endif        }        else  return(-1);    }    return(out-outstart);}/** * xmlDetectCharEncoding: * @in:  a pointer to the first bytes of the XML entity, must be at least *       4 bytes long. * @len:  pointer to the length of the buffer * * Guess the encoding of the entity using the first bytes of the entity content * accordingly of the non-normative appendix F of the XML-1.0 recommendation. *  * Returns one of the XML_CHAR_ENCODING_... values. */xmlCharEncodingxmlDetectCharEncoding(const unsigned char* in, int len){    if (len >= 4) {	if ((in[0] == 0x00) && (in[1] == 0x00) &&	    (in[2] == 0x00) && (in[3] == 0x3C))	    return(XML_CHAR_ENCODING_UCS4BE);	if ((in[0] == 0x3C) && (in[1] == 0x00) &&	    (in[2] == 0x00) && (in[3] == 0x00))	    return(XML_CHAR_ENCODING_UCS4LE);	if ((in[0] == 0x00) && (in[1] == 0x00) &&	    (in[2] == 0x3C) && (in[3] == 0x00))	    return(XML_CHAR_ENCODING_UCS4_2143);	if ((in[0] == 0x00) && (in[1] == 0x3C) &&	    (in[2] == 0x00) && (in[3] == 0x00))	    return(XML_CHAR_ENCODING_UCS4_3412);	if ((in[0] == 0x4C) && (in[1] == 0x6F) &&	    (in[2] == 0xA7) && (in[3] == 0x94))	    return(XML_CHAR_ENCODING_EBCDIC);	if ((in[0] == 0x3C) && (in[1] == 0x3F) &&	    (in[2] == 0x78) && (in[3] == 0x6D))	    return(XML_CHAR_ENCODING_UTF8);    }    if (len >= 2) {	if ((in[0] == 0xFE) && (in[1] == 0xFF))	    return(XML_CHAR_ENCODING_UTF16BE);	if ((in[0] == 0xFF) && (in[1] == 0xFE))	    return(XML_CHAR_ENCODING_UTF16LE);    }    return(XML_CHAR_ENCODING_NONE);}/** * xmlParseCharEncoding: * @name:  the encoding name as parsed, in UTF-8 format (ASCII actually) * * Conpare the string to the known 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. */xmlCharEncodingxmlParseCharEncoding(const char* name){    char upper[500];    int i;    for (i = 0;i < 499;i++) {        upper[i] = toupper(name[i]);	if (upper[i] == 0) break;    }    upper[i] = 0;    if (!strcmp(upper, "")) return(XML_CHAR_ENCODING_NONE);    if (!strcmp(upper, "UTF-8")) return(XML_CHAR_ENCODING_UTF8);    if (!strcmp(upper, "UTF8")) return(XML_CHAR_ENCODING_UTF8);    /*     * NOTE: if we were able to parse this, the endianness of UTF16 is     *       already found and in use     */    if (!strcmp(upper, "UTF-16")) return(XML_CHAR_ENCODING_UTF16LE);    if (!strcmp(upper, "UTF16")) return(XML_CHAR_ENCODING_UTF16LE);        if (!strcmp(upper, "ISO-10646-UCS-2")) return(XML_CHAR_ENCODING_UCS2);    if (!strcmp(upper, "UCS-2")) return(XML_CHAR_ENCODING_UCS2);    if (!strcmp(upper, "UCS2")) return(XML_CHAR_ENCODING_UCS2);    /*     * NOTE: if we were able to parse this, the endianness of UCS4 is     *       already found and in use     */    if (!strcmp(upper, "ISO-10646-UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);    if (!strcmp(upper, "UCS-4")) return(XML_CHAR_ENCODING_UCS4LE);    if (!strcmp(upper, "UCS4")) return(XML_CHAR_ENCODING_UCS4LE);        if (!strcmp(upper,  "ISO-8859-1")) return(XML_CHAR_ENCODING_8859_1);    if (!strcmp(upper,  "ISO-LATIN-1")) return(XML_CHAR_ENCODING_8859_1);    if (!strcmp(upper,  "ISO LATIN 1")) return(XML_CHAR_ENCODING_8859_1);    if (!strcmp(upper,  "ISO-8859-2")) return(XML_CHAR_ENCODING_8859_2);    if (!strcmp(upper,  "ISO-LATIN-2")) return(XML_CHAR_ENCODING_8859_2);    if (!strcmp(upper,  "ISO LATIN 2")) return(XML_CHAR_ENCODING_8859_2);    if (!strcmp(upper,  "ISO-8859-3")) return(XML_CHAR_ENCODING_8859_3);    if (!strcmp(upper,  "ISO-8859-4")) return(XML_CHAR_ENCODING_8859_4);    if (!strcmp(upper,  "ISO-8859-5")) return(XML_CHAR_ENCODING_8859_5);    if (!strcmp(upper,  "ISO-8859-6")) return(XML_CHAR_ENCODING_8859_6);    if (!strcmp(upper,  "ISO-8859-7")) return(XML_CHAR_ENCODING_8859_7);    if (!strcmp(upper,  "ISO-8859-8")) return(XML_CHAR_ENCODING_8859_8);    if (!strcmp(upper,  "ISO-8859-9")) return(XML_CHAR_ENCODING_8859_9);    if (!strcmp(upper, "ISO-2022-JP")) return(XML_CHAR_ENCODING_2022_JP);    if (!strcmp(upper, "Shift_JIS")) return(XML_CHAR_ENCODING_SHIFT_JIS);    if (!strcmp(upper, "EUC-JP")) return(XML_CHAR_ENCODING_EUC_JP);    return(XML_CHAR_ENCODING_ERROR);}/**************************************************************** *								* *		Char encoding handlers				* *								* ****************************************************************//* the size should be growable, but it's not a big deal ... */#define MAX_ENCODING_HANDLERS 50static xmlCharEncodingHandlerPtr *handlers = NULL;static int nbCharEncodingHandler = 0;/* * The default is UTF-8 for XML, that's also the default used for the * parser internals, so the default encoding handler is NULL */static xmlCharEncodingHandlerPtr xmlDefaultCharEncodingHandler = NULL;/** * xmlNewCharEncodingHandler: * @name:  the encoding name, in UTF-8 format (ASCII actually) * @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). */xmlCharEncodingHandlerPtrxmlNewCharEncodingHandler(const char *name,                           xmlCharEncodingInputFunc input,                          xmlCharEncodingOutputFunc output) {    xmlCharEncodingHandlerPtr handler;    char upper[500];    int i;    char *up = 0;    /*     * Keep only the uppercase version of the encoding.     */    if (name == NULL) {        fprintf(stderr, "xmlNewCharEncodingHandler : no name !\n");	return(NULL);    }    for (i = 0;i < 499;i++) {        upper[i] = toupper(name[i]);	if (upper[i] == 0) break;    }    upper[i] = 0;    up = xmlMemStrdup(upper);    if (up == NULL) {        fprintf(stderr, "xmlNewCharEncodingHandler : out of memory !\n");	return(NULL);    }    /*     * allocate and fill-up an handler block.     */    handler = (xmlCharEncodingHandlerPtr)              xmlMalloc(sizeof(xmlCharEncodingHandler));    if (handler == NULL) {        fprintf(stderr, "xmlNewCharEncodingHandler : out of memory !\n");	return(NULL);    }    handler->input = input;    handler->output = output;    handler->name = up;    /*     * registers and returns the handler.     */    xmlRegisterCharEncodingHandler(handler);    return(handler);}/** * 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. */voidxmlInitCharEncodingHandlers(void) {    if (handlers != NULL) return;    handlers = (xmlCharEncodingHandlerPtr *)        xmlMalloc(MAX_ENCODING_HANDLERS * sizeof(xmlCharEncodingHandlerPtr));    if (handlers == NULL) {        fprintf(stderr, "xmlInitCharEncodingHandlers : out of memory !\n");	return;    }    xmlNewCharEncodingHandler("UTF-8", NULL, NULL);    xmlUTF16LEHandler =           xmlNewCharEncodingHandler("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE);    xmlUTF16BEHandler =           xmlNewCharEncodingHandler("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE);    xmlNewCharEncodingHandler("ISO-8859-1", isolat1ToUTF8, UTF8Toisolat1);}/** * xmlCleanupCharEncodingHandlers: * * Cleanup the memory allocated for the char encoding support, it * unregisters all the encoding handlers. */voidxmlCleanupCharEncodingHandlers(void) {    if (handlers == NULL) return;    for (;nbCharEncodingHandler > 0;) {        nbCharEncodingHandler--;	if (handlers[nbCharEncodingHandler] != NULL) {	    xmlFree(handlers[nbCharEncodingHandler]->name);	    xmlFree(handlers[nbCharEncodingHandler]);	}    }    xmlFree(handlers);    handlers = NULL;    nbCharEncodingHandler = 0;    xmlDefaultCharEncodingHandler = NULL;}/** * xmlRegisterCharEncodingHandler: * @handler:  the xmlCharEncodingHandlerPtr handler block * * Register the char encoding handler, surprizing, isn't it ? */voidxmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler) {    if (handlers == NULL) xmlInitCharEncodingHandlers();    if (handler == NULL) {        fprintf(stderr, "xmlRegisterCharEncodingHandler: NULL handler !\n");	return;    }    if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS) {        fprintf(stderr, 	"xmlRegisterCharEncodingHandler: Too many handler registered\n");        fprintf(stderr, "\tincrease MAX_ENCODING_HANDLERS : %s\n", __FILE__);	return;    }    handlers[nbCharEncodingHandler++] = handler;}/** * xmlGetCharEncodingHandler: * @enc:  an xmlCharEncoding value. * * Search in the registrered set the handler able to read/write that encoding. * * Returns the handler or NULL if not found */xmlCharEncodingHandlerPtrxmlGetCharEncodingHandler(xmlCharEncoding enc) {    if (handlers == NULL) xmlInitCharEncodingHandlers();    switch (enc) {        case XML_CHAR_ENCODING_ERROR:	    return(NULL);        case XML_CHAR_ENCODING_NONE:	    return(NULL);        case XML_CHAR_ENCODING_UTF8:	    return(NULL);        case XML_CHAR_ENCODING_UTF16LE:	    return(xmlUTF16LEHandler);        case XML_CHAR_ENCODING_UTF16BE:	    return(xmlUTF16BEHandler);        case XML_CHAR_ENCODING_EBCDIC:	    return(NULL);        case XML_CHAR_ENCODING_UCS4LE:	    return(NULL);        case XML_CHAR_ENCODING_UCS4BE:	    return(NULL);        case XML_CHAR_ENCODING_UCS4_2143:	    return(NULL);        case XML_CHAR_ENCODING_UCS4_3412:	    return(NULL);        case XML_CHAR_ENCODING_UCS2:	    return(NULL);        case XML_CHAR_ENCODING_8859_1:	    return(NULL);        case XML_CHAR_ENCODING_8859_2:	    return(NULL);        case XML_CHAR_ENCODING_8859_3:	    return(NULL);        case XML_CHAR_ENCODING_8859_4:	    return(NULL);        case XML_CHAR_ENCODING_8859_5:	    return(NULL);        case XML_CHAR_ENCODING_8859_6:	    return(NULL);        case XML_CHAR_ENCODING_8859_7:	    return(NULL);        case XML_CHAR_ENCODING_8859_8:	    return(NULL);        case XML_CHAR_ENCODING_8859_9:	    return(NULL);        case XML_CHAR_ENCODING_2022_JP:        case XML_CHAR_ENCODING_SHIFT_JIS:        case XML_CHAR_ENCODING_EUC_JP:	    return(NULL);    }    return(NULL);}/** * xmlGetCharEncodingHandler: * @enc:  a string describing the char encoding. * * Search in the registrered set the handler able to read/write that encoding. * * Returns the handler or NULL if not found */xmlCharEncodingHandlerPtrxmlFindCharEncodingHandler(const char *name) {    char upper[500];    int i;    if (handlers == NULL) xmlInitCharEncodingHandlers();    if (name == NULL) return(xmlDefaultCharEncodingHandler);    if (name[0] == 0) return(xmlDefaultCharEncodingHandler);    for (i = 0;i < 499;i++) {        upper[i] = toupper(name[i]);	if (upper[i] == 0) break;    }    upper[i] = 0;    for (i = 0;i < nbCharEncodingHandler; i++)        if (!strcmp(name, handlers[i]->name))	    return(handlers[i]);    return(NULL);}