Gibt es eine Möglichkeit zur Konvertierung von UTF8 nach iso-8859-1?

Meine software immer einige strings in UTF8 als ich brauche, um zu konvertieren, um ISO 8859-1. Ich weiß, dass UTF8-Domäne größer ist, als iso-8859. Aber die Daten im UTF8 Format wurde zuvor upconverted von ISO, also sollte ich nicht verpassen.

Ich würde gerne wissen, ob es einen einfachen /direkten Weg zur Konvertierung von UTF8 nach iso-8859-1.

Dank

Wenn Sie eine Bibliothek benutzen, die hat die Umstellung, es sollte auch etwas haben, um es zu konvertieren zurück. Vorausgesetzt, Sie ändern nicht alle Zeichen in der Zeichenfolge, die Sie sollten in Ordnung sein, nur geben es zurück.

InformationsquelleAutor fazineroso | 2012-06-22

Hier ist eine Funktion, die Sie nützlich finden könnten: utf8_to_latin9(). Es wandelt auf ISO-8859-15 (einschließlich EURO), die ISO-8859-1 nicht haben), aber funktioniert auch einwandfrei für die UTF-8->ISO-8859-1 Umwandlung Teil einer ISO-8859-1->UTF-8->ISO-8859-1 round-trip.

Die Funktion ignoriert ungültige code Punkte ähnlich wie //IGNORE Flagge für iconv, aber nicht wieder zusammensetzen zerlegt UTF-8-Sequenzen; das heißt, es lässt sich nicht einschalten U+006E U+0303 in U+00F1. Ich nicht die Mühe, die Neuanordnung, da iconv nicht entweder.

Die Funktion ist sehr vorsichtig über die string-Zugang. Es wird nie Scannen über den Puffer. Der Ausgabepuffer muss ein byte länger als die Länge, weil es immer hängt die end-of-string " NUL-byte. Die Funktion gibt die Anzahl der Zeichen (bytes) in der Ausgabe, nicht einschließlich der end-of-string " NUL-byte.

/* UTF-8 to ISO-8859-1/ISO-8859-15 mapper.
 * Return 0..255 for valid ISO-8859-15 code points, 256 otherwise.
*/
static inline unsigned int to_latin9(const unsigned int code)
{
    /* Code points 0 to U+00FF are the same in both. */
    if (code < 256U)
        return code;
    switch (code) {
    case 0x0152U: return 188U; /* U+0152 = 0xBC: OE ligature */
    case 0x0153U: return 189U; /* U+0153 = 0xBD: oe ligature */
    case 0x0160U: return 166U; /* U+0160 = 0xA6: S with caron */
    case 0x0161U: return 168U; /* U+0161 = 0xA8: s with caron */
    case 0x0178U: return 190U; /* U+0178 = 0xBE: Y with diaresis */
    case 0x017DU: return 180U; /* U+017D = 0xB4: Z with caron */
    case 0x017EU: return 184U; /* U+017E = 0xB8: z with caron */
    case 0x20ACU: return 164U; /* U+20AC = 0xA4: Euro */
    default:      return 256U;
    }
}

/* Convert an UTF-8 string to ISO-8859-15.
 * All invalid sequences are ignored.
 * Note: output == input is allowed,
 * but   input < output < input + length
 * is not.
 * Output has to have room for (length+1) chars, including the trailing NUL byte.
*/
size_t utf8_to_latin9(char *const output, const char *const input, const size_t length)
{
    unsigned char             *out = (unsigned char *)output;
    const unsigned char       *in  = (const unsigned char *)input;
    const unsigned char *const end = (const unsigned char *)input + length;
    unsigned int               c;

    while (in < end)
        if (*in < 128)
            *(out++) = *(in++); /* Valid codepoint */
        else
        if (*in < 192)
            in++;               /* 10000000 .. 10111111 are invalid */
        else
        if (*in < 224) {        /* 110xxxxx 10xxxxxx */
            if (in + 1 >= end)
                break;
            if ((in[1] & 192U) == 128U) {
                c = to_latin9( (((unsigned int)(in[0] & 0x1FU)) << 6U)
                             |  ((unsigned int)(in[1] & 0x3FU)) );
                if (c < 256)
                    *(out++) = c;
            }
            in += 2;

        } else
        if (*in < 240) {        /* 1110xxxx 10xxxxxx 10xxxxxx */
            if (in + 2 >= end)
                break;
            if ((in[1] & 192U) == 128U &&
                (in[2] & 192U) == 128U) {
                c = to_latin9( (((unsigned int)(in[0] & 0x0FU)) << 12U)
                             | (((unsigned int)(in[1] & 0x3FU)) << 6U)
                             |  ((unsigned int)(in[2] & 0x3FU)) );
                if (c < 256)
                    *(out++) = c;
            }
            in += 3;

        } else
        if (*in < 248) {        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
            if (in + 3 >= end)
                break;
            if ((in[1] & 192U) == 128U &&
                (in[2] & 192U) == 128U &&
                (in[3] & 192U) == 128U) {
                c = to_latin9( (((unsigned int)(in[0] & 0x07U)) << 18U)
                             | (((unsigned int)(in[1] & 0x3FU)) << 12U)
                             | (((unsigned int)(in[2] & 0x3FU)) << 6U)
                             |  ((unsigned int)(in[3] & 0x3FU)) );
                if (c < 256)
                    *(out++) = c;
            }
            in += 4;

        } else
        if (*in < 252) {        /* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
            if (in + 4 >= end)
                break;
            if ((in[1] & 192U) == 128U &&
                (in[2] & 192U) == 128U &&
                (in[3] & 192U) == 128U &&
                (in[4] & 192U) == 128U) {
                c = to_latin9( (((unsigned int)(in[0] & 0x03U)) << 24U)
                             | (((unsigned int)(in[1] & 0x3FU)) << 18U)
                             | (((unsigned int)(in[2] & 0x3FU)) << 12U)
                             | (((unsigned int)(in[3] & 0x3FU)) << 6U)
                             |  ((unsigned int)(in[4] & 0x3FU)) );
                if (c < 256)
                    *(out++) = c;
            }
            in += 5;

        } else
        if (*in < 254) {        /* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */
            if (in + 5 >= end)
                break;
            if ((in[1] & 192U) == 128U &&
                (in[2] & 192U) == 128U &&
                (in[3] & 192U) == 128U &&
                (in[4] & 192U) == 128U &&
                (in[5] & 192U) == 128U) {
                c = to_latin9( (((unsigned int)(in[0] & 0x01U)) << 30U)
                             | (((unsigned int)(in[1] & 0x3FU)) << 24U)
                             | (((unsigned int)(in[2] & 0x3FU)) << 18U)
                             | (((unsigned int)(in[3] & 0x3FU)) << 12U)
                             | (((unsigned int)(in[4] & 0x3FU)) << 6U)
                             |  ((unsigned int)(in[5] & 0x3FU)) );
                if (c < 256)
                    *(out++) = c;
            }
            in += 6;

        } else
            in++;               /* 11111110 and 11111111 are invalid */

    /* Terminate the output string. */
    *out = '\0';

    return (size_t)(out - (unsigned char *)output);
}

Beachten Sie, dass Sie können fügen Sie benutzerdefinierte transliteration für bestimmte code-Punkte in der to_latin9() Funktion, aber Sie sind beschränkt auf die ein-Zeichen-Ersetzungen.

Wie es derzeit geschrieben ist, kann die Funktion in-place-Konvertierung sicher: input-und output-Zeiger können die gleichen sein. Der Ausgabe-string wird nie länger sein, als der input-string. Wenn Sie Ihre Eingabe string hat Platz für ein extra-byte (zum Beispiel, es hat NUL Beendigung des string), können Sie sicher verwenden Sie die oben beschriebene Funktion zum konvertieren von UTF-8 auf ISO-8859-1/15. Ich schrieb bewusst so, weil es zu speichern, sollten Sie einige Mühe in einer integrierten Umgebung, obwohl dieser Ansatz ist ein bisschen beschränkt wrt. die Anpassung und Erweiterung.

Edit:

Habe ich ein paar Funktionen für die Konvertierung in einem edit zu beantworten für beide Latin-1/9 zur/von UTF-8-Konvertierung (ISO-8859-1 oder -15 to/from UTF-8); der Hauptunterschied ist, dass diese Funktionen geben einen dynamisch zugewiesenen Kopie, und behalten Sie die ursprüngliche Zeichenfolge intakt.

InformationsquelleAutor Nominal Animal

iconv - ausführen-Zeichensatz-Konvertierung

size_t iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);

iconv_t iconv_open(const char *tocode, const char *fromcode);

tocode ist "ISO_8859-1" und fromcode ist "UTF-8".

Beispiel:

#include <iconv.h>
#include <stdio.h>

int main (void) {
    iconv_t cd = iconv_open("ISO_8859-1", "UTF-8");
    if (cd == (iconv_t) -1) {
        perror("iconv_open failed!");
        return 1;
    }

    char input[] = "Test äöü";
    char *in_buf = &input[0];
    size_t in_left = sizeof(input) - 1;

    char output[32];
    char *out_buf = &output[0];
    size_t out_left = sizeof(output) - 1;

    do {
        if (iconv(cd, &in_buf, &in_left, &out_buf, &out_left) == (size_t) -1) {
            perror("iconv failed!");
            return 1;
        }
    } while (in_left > 0 && out_left > 0);
    *out_buf = 0;

    iconv_close(cd);

    printf("%s -> %s\n", input, output);
    return 0;
}

Vielen Dank,das Hauptproblem, das ich habe, und ich vergaß, um anzugeben, ist, dass meine software läuft unter embedded Linux und "iconv" ist nicht verfügbar.
Sie können iconv kompilieren für Ihr linux. Hat Ihr linux-glibc verwenden? Wenn ja, haben Sie Ihre kompatible Implementierung genannt gconv: gnu.org/software/libc/manual/html_node/...
Vielen Dank für den Austausch. Sollten Sie zu nennen iconv_close() für die Befreiung der Mittel iconv_open(). Setzen Sie einfach iconv_close(cd); vor der printf("%s -> %s\n", input, output); Linie.
danke für deinen Kommentar! Ich fügte hinzu, die Linie.

InformationsquelleAutor kay

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.