Module utf16 [Version: v01]

[Documentation]

[Details]

[Wiki]

[Tests]

This documentation describes the Prokee module interface.

Static Methods:

decode_BE
int utf16::decode_BE(int *utf32out,const char16_t *utf16in)

decode_LE
int utf16::decode_LE(int *utf32out,const char16_t *utf16in)

encode_BE
int utf16::encode_BE(char16_t *utf16out,int utf32in)

encode_LE
int utf16::encode_LE(char16_t *utf16out,int utf32in)

convert_utf16_to_utf32
int utf16::convert_utf16_to_utf32(int **utf32string,int *utf32string_length,const char16_t *utf16string)

convert_utf16_to_utf32_BE
int utf16::convert_utf16_to_utf32_BE(int **utf32string,int *utf32string_length,const char16_t *utf16string)

convert_utf16_to_utf32_LE
int utf16::convert_utf16_to_utf32_LE(int **utf32string,int *utf32string_length,const char16_t *utf16string)

convert_utf32_to_utf16_BE
int utf16::convert_utf32_to_utf16_BE(char16_t **utf16string,int *utf16string_length,const int *utf32string)

convert_utf32_to_utf16_LE
int utf16::convert_utf32_to_utf16_LE(char16_t **utf16string,int *utf16string_length,const int *utf32string)

getBOM_BE
int utf16::getBOM_BE(char16_t *utf16out)

getBOM_LE
int utf16::getBOM_LE(char16_t *utf16out)

testBOM
int utf16::testBOM(const char16_t *utf16string)

Motivation

Das Modul bietet statische Methoden um Unicode Zeichen und Strings zwischen UTF-16 und UTF-32 zu konvertieren.

Annahmen

Der Datentyp int muss mindestens 4 Bytes groß sein um Unicode Codepoints (UTF-32 Zeichen) speichern zu können.

Static Methods

decode_BE

Berechnet die Zeichennummer (den Unicode Codepoint) eines utf16-codierten Zeichens in Big-Endian Byte Reihenfolge.

Signature:

int utf16::decode_BE(int *utf32out,const char16_t *utf16in)

Parameters:

Type	Name	Direction	Description
int *	utf32out	[OUT]	Speicherbereich in welchen die Zeichen-Nummer (der Unicode Codepoint) des Zeichens geschrieben wird.
const char16_t *	utf16in	[IN]	Ein Zeichen in UTF-16 Codierung. (2 oder 4 Bytes)

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das Zeichen in utf16-Codierung benötigt. Falls ein Fehler aufgetreten ist, wird 0 zurückgegeben.

Code: toggle

int utf16::decode_BE(int *utf32out,const char16_t *utf16in)
{
    if(!isSysLE())
    {
        return decode_intern(utf32out,utf16in);
    }
    char16_t utf16in_[2];
    unsigned char *c=(unsigned char *)utf16in;
    ((unsigned char *)utf16in_)[0]=c[1];
    ((unsigned char *)utf16in_)[1]=c[0];
    ((unsigned char *)utf16in_)[2]=c[3];
    ((unsigned char *)utf16in_)[3]=c[2];
    return decode_intern(utf32out,utf16in_);
}

Code: toggle

int utf16::decode_intern(int *utf32out,const char16_t *utf16in)
{
    //printf("W1=%#010x -- ",utf16in[0]);
    //printf("W2=%#010x -- ",utf16in[1]);
    if(*utf16in<0xD800 || *utf16in>0xDFFF)
    {
        *utf32out=*utf16in;
        return 1;
    }
    if(*utf16in>=0xD800 && *utf16in<=0xDBFF)
    {
        if(utf16in[1]>=0xDC00 && utf16in[1]<=0xDFFF)
        {
            *utf32out=(((int)(utf16in[0] & 0b0000001111111111) << 10) | (utf16in[1] & 0b0000001111111111)) + 0x10000;
            //printf("%c-%d\n",*utf32out,*utf32out);
            return 2;
        }
        else
        {
            fprintf(stderr,"[ERROR] utf16: while reading character. unexpected second 2-byte value %d found.\n",utf16in[1]);
            return 0;
        }
    }
    else
    {
        fprintf(stderr,"[ERROR] utf16: while reading character. unexpected 2-byte value %d found.\n",utf16in[0]);
        return 0;
    }
}

decode_LE

Berechnet die Zeichennummer (den Unicode Codepoint) eines utf16-codierten Zeichens in Little-Endian Byte Reihenfolge.

Signature:

int utf16::decode_LE(int *utf32out,const char16_t *utf16in)

Parameters:

Type	Name	Direction	Description
int *	utf32out	[OUT]	Speicherbereich in welchen die Zeichen-Nummer (der Unicode Codepoint) des Zeichens geschrieben wird.
const char16_t *	utf16in	[IN]	Ein Zeichen in UTF-16 Codierung. (2 oder 4 Bytes)

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das Zeichen in utf16-Codierung benötigt. Falls ein Fehler aufgetreten ist, wird 0 zurückgegeben.

Code: toggle

int utf16::decode_LE(int *utf32out,const char16_t *utf16in)
{
    if(isSysLE())
    {
        return decode_intern(utf32out,utf16in);
    }
    char16_t utf16in_[2];
    unsigned char *c=(unsigned char *)utf16in;
    ((unsigned char *)utf16in_)[0]=c[1];
    ((unsigned char *)utf16in_)[1]=c[0];
    ((unsigned char *)utf16in_)[2]=c[3];
    ((unsigned char *)utf16in_)[3]=c[2];
    return decode_intern(utf32out,utf16in_);
}

Code: toggle

int utf16::decode_intern(int *utf32out,const char16_t *utf16in)
{
    //printf("W1=%#010x -- ",utf16in[0]);
    //printf("W2=%#010x -- ",utf16in[1]);
    if(*utf16in<0xD800 || *utf16in>0xDFFF)
    {
        *utf32out=*utf16in;
        return 1;
    }
    if(*utf16in>=0xD800 && *utf16in<=0xDBFF)
    {
        if(utf16in[1]>=0xDC00 && utf16in[1]<=0xDFFF)
        {
            *utf32out=(((int)(utf16in[0] & 0b0000001111111111) << 10) | (utf16in[1] & 0b0000001111111111)) + 0x10000;
            //printf("%c-%d\n",*utf32out,*utf32out);
            return 2;
        }
        else
        {
            fprintf(stderr,"[ERROR] utf16: while reading character. unexpected second 2-byte value %d found.\n",utf16in[1]);
            return 0;
        }
    }
    else
    {
        fprintf(stderr,"[ERROR] utf16: while reading character. unexpected 2-byte value %d found.\n",utf16in[0]);
        return 0;
    }
}

encode_BE

Berechnet die utf16-Codierung (in Big-Endian Byte Reihenfolge) zu einer Zeichennummer (zu einem Unicode Codepoint) eines Zeichens.

Signature:

int utf16::encode_BE(char16_t *utf16out,int utf32in)

Parameters:

Type	Name	Direction	Description
char16_t *	utf16out	[OUT]	Speicherbereich in welchen das Zeichen in UTF-16 Codierung geschrieben wird. Der Speicherbereich muss groß genug sein, um bis zu 4 Bytes aufzunehmen.
int	utf32in	[IN]	Die Zeichennummer (der Unicode Codepoint) eines Zeichens.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das Zeichen in utf16-Codierung benötigt. Falls ein Fehler aufgetreten ist, wird 0 zurückgegeben.

Code: toggle

int utf16::encode_BE(char16_t *utf16out,int utf32in)
{
    if(utf32in>=0x10FFFF)
    {
        fprintf(stderr,"[ERROR] utf16: while writing character. illegal character %d.\n",utf32in);
        return 0;
    }
    if(utf32in<0x10000)
    {
        if(!isSysLE())
        {
            *utf16out=utf32in;
        }
        ((unsigned char *)utf16out)[0]=((unsigned char *)&utf32in)[1];
        ((unsigned char *)utf16out)[1]=((unsigned char *)&utf32in)[0];
        return 1;
    }
    utf32in-=0x10000;
    utf16out[0]=0xD800 | (utf32in >> 10);
    utf16out[1]=0xDC00 | (utf32in & 0b0000001111111111);
    if(isSysLE())
    {
        unsigned char c;
        c=((unsigned char *)utf16out)[0];
        ((unsigned char *)utf16out)[0]=((unsigned char *)utf16out)[1];
        ((unsigned char *)utf16out)[1]=c;
        c=((unsigned char *)utf16out)[2];
        ((unsigned char *)utf16out)[2]=((unsigned char *)utf16out)[3];
        ((unsigned char *)utf16out)[3]=c;
    }
    return 2;
}

encode_LE

Berechnet die utf16-Codierung (in Little-Endian Byte Reihenfolge) zu einer Zeichennummer (zu einem Unicode Codepoint) eines Zeichens.

Signature:

int utf16::encode_LE(char16_t *utf16out,int utf32in)

Parameters:

Type	Name	Direction	Description
char16_t *	utf16out	[OUT]	Speicherbereich in welchen das Zeichen in UTF-16 Codierung geschrieben wird. Der Speicherbereich muss groß genug sein, um bis zu 4 Bytes aufzunehmen.
int	utf32in	[IN]	Die Zeichennummer (der Unicode Codepoint) eines Zeichens.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das Zeichen in utf16-Codierung benötigt. Falls ein Fehler aufgetreten ist, wird 0 zurückgegeben.

Code: toggle

int utf16::encode_LE(char16_t *utf16out,int utf32in)
{
    if(utf32in>=0x10FFFF)
    {
        fprintf(stderr,"[ERROR] utf16: while writing character. illegal character %d.\n",utf32in);
        return 0;
    }
    if(utf32in<0x10000)
    {
        if(isSysLE())
        {
            *utf16out=utf32in;
        }
        ((unsigned char *)utf16out)[0]=((unsigned char *)&utf32in)[1];
        ((unsigned char *)utf16out)[1]=((unsigned char *)&utf32in)[0];
        return 1;
    }
    utf32in-=0x10000;
    utf16out[0]=0xD800 | (utf32in >> 10);
    utf16out[1]=0xDC00 | (utf32in & 0b0000001111111111);
    if(!isSysLE())
    {
        unsigned char c;
        c=((unsigned char *)utf16out)[0];
        ((unsigned char *)utf16out)[0]=((unsigned char *)utf16out)[1];
        ((unsigned char *)utf16out)[1]=c;
        c=((unsigned char *)utf16out)[2];
        ((unsigned char *)utf16out)[2]=((unsigned char *)utf16out)[3];
        ((unsigned char *)utf16out)[3]=c;
    }
    return 2;
}

convert_utf16_to_utf32

Konvertiert einen String von UTF-16 zu UTF-32. Die Byte-Reihenfolge des UTF-16 Strings wird anhand eines BOM Zeichens (Byte-Order-Mark) ermittelt, sofern vorhanden. Ist kein BOM Zeichen vorhanden, so wird Big-Endian angenommen. (Die UTF-32 Werte werden in der Byte-Reigenfolge des Systems ausgegeben.)

Signature:

int utf16::convert_utf16_to_utf32(int **utf32string,int *utf32string_length,const char16_t *utf16string)

Parameters:

Type	Name	Direction	Description
int **	utf32string	[OUT]	Speicherbereich in den die Ausgabe geschrieben wird. Falls `NULL` angegeben wurde, oder falls utf32string = 0 ist, wird der Speicherbereich neu alloziert. Die anfängliche Länge des Speicherbereichs wird durch utf32string_length festgelegt. Falls utf32string_length = 0 (oder utf32string_length = `NULL`) ist, so wird die anfängliche Länge (in sizeof(int)) auf die Anzahl Bytes in utf8string gesetzt. Ist der Speicherbereich für die Ausgabe zu klein, so wird die Länge so lange verdoppelt (und der Speicher neu alloziert) bis der Speicherbereich lang genug ist. Die Länge des resultierenden Speicherbereichs kann daher deutlich länger sein, als die Länge des Ausgabe-Strings. Bei wiederholtem Aufruf, sollte ein bereits allozierter Speicherbereich wiederverwendet werden, um die Anzahl der benötigten Speicher-Allozierungen gering zu halten. Wird der Speicherbereich neu alloziert (oder re-alloziert) und ist utf32string nicht `NULL`, so wird die neue Adresse des Speicherbereichs nach *utf32string zurück geschrieben.
int *	utf32string_length	[IN/OUT]	Länge des Speicherbereichs utf32string in den die Ausgabe geschrieben wird. Bei Angabe von `NULL` oder falls utf32string_length = 0 ist, so wird falls utf32string = `NULL` oder utf32string = 0 ist, ein neuer Speicherbereich alloziert bzw. falls utf32string != 0 ist, der bestehende Speicherbereich re-alloziert. Ist der Speicherbereich zu klein für die Ausgabe, so wird ebenso ein längerer Speicherbereich alloziert. Sofern utf32string_length nicht `NULL` ist, wird die neue Länge des Speicherbereichs nach utf32string_length geschrieben.
const char16_t *	utf16string	[IN]	Ein null-terminierter und UTF-16 codierter String.

Return value:
Gibt die Anzahl Zeichen zurück, die nach utf32string geschrieben wurden.

Code: toggle

int utf16::convert_utf16_to_utf32(int **utf32string,int *utf32string_length,const char16_t *utf16string)
{
    switch(testBOM(utf16string))
    {
        case 2:
            return convert_utf16_to_utf32_BE(utf32string,utf32string_length,utf16string);
        case 1:
            return convert_utf16_to_utf32_LE(utf32string,utf32string_length,utf16string);
        default:
            return convert_utf16_to_utf32_BE(utf32string,utf32string_length,utf16string);
    }
}

convert_utf16_to_utf32_BE

Konvertiert einen String von UTF-16 zu UTF-32. Der UTF-16 String muss in Big-Endian Byte-Reihenfolge angegeben sein. (Die UTF-32 Werte werden in der Byte-Reigenfolge des Systems ausgegeben.)

Signature:

int utf16::convert_utf16_to_utf32_BE(int **utf32string,int *utf32string_length,const char16_t *utf16string)

Parameters:

Type	Name	Direction	Description
int **	utf32string	[OUT]	Speicherbereich in den die Ausgabe geschrieben wird. Falls `NULL` angegeben wurde, oder falls utf32string = 0 ist, wird der Speicherbereich neu alloziert. Die anfängliche Länge des Speicherbereichs wird durch utf32string_length festgelegt. Falls utf32string_length = 0 (oder utf32string_length = `NULL`) ist, so wird die anfängliche Länge (in sizeof(int)) auf die Anzahl Bytes in utf8string gesetzt. Ist der Speicherbereich für die Ausgabe zu klein, so wird die Länge so lange verdoppelt (und der Speicher neu alloziert) bis der Speicherbereich lang genug ist. Die Länge des resultierenden Speicherbereichs kann daher deutlich länger sein, als die Länge des Ausgabe-Strings. Bei wiederholtem Aufruf, sollte ein bereits allozierter Speicherbereich wiederverwendet werden, um die Anzahl der benötigten Speicher-Allozierungen gering zu halten. Wird der Speicherbereich neu alloziert (oder re-alloziert) und ist utf32string nicht `NULL`, so wird die neue Adresse des Speicherbereichs nach *utf32string zurück geschrieben.
int *	utf32string_length	[IN/OUT]	Länge des Speicherbereichs utf32string in den die Ausgabe geschrieben wird. Bei Angabe von `NULL` oder falls utf32string_length = 0 ist, so wird falls utf32string = `NULL` oder utf32string = 0 ist, ein neuer Speicherbereich alloziert bzw. falls utf32string != 0 ist, der bestehende Speicherbereich re-alloziert. Ist der Speicherbereich zu klein für die Ausgabe, so wird ebenso ein längerer Speicherbereich alloziert. Sofern utf32string_length nicht `NULL` ist, wird die neue Länge des Speicherbereichs nach utf32string_length geschrieben.
const char16_t *	utf16string	[IN]	Ein null-terminierter und UTF-16 codierter String.

Return value:
Gibt die Anzahl Zeichen zurück, die nach utf32string geschrieben wurden.

Code: toggle

int utf16::convert_utf16_to_utf32_BE(int **utf32string,int *utf32string_length,const char16_t *utf16string)
{
    int *out;
    int outln;

    if(!utf32string || *utf32string==0)
    {
        if(!utf32string_length || *utf32string_length==0)
        {
            outln=length(utf16string)+1;
        }
        else
        {
            outln=*utf32string_length;
        }
        out=(int *)malloc(outln*sizeof(int));
    }
    else
    {
        if(!utf32string_length || *utf32string_length==0)
        {
            outln=length(utf16string)+1;
            out=(int *)realloc(*utf32string,outln*sizeof(int));
        }
        else
        {
            outln=*utf32string_length;
            out=*utf32string;
        }
    }
    int read_pos=0;
    int write_pos=0;
    int bcount=0;
    do
    {
        if(write_pos>=outln)
        {
            outln*=2;
            out=(int *)realloc(out,outln*sizeof(int));
        }
        bcount=decode_BE(&out[write_pos],&utf16string[read_pos]);
        read_pos+=bcount;
        write_pos++;
    }
    while(out[write_pos-1] && bcount);

    // -- VERSION A -- Speicherbereich nicht kürzen.
    if(bcount==0)
    {
        if(write_pos>=outln)
        {
            outln+=1;
            out=(int *)realloc(out,outln*sizeof(int));
        }
        out[write_pos]=0;
        write_pos++;
    }

    /* -- VERSION B -- Speicherbereich kürzen.
    if(bcount==0)
    {
        outln=write_pos+1;
        out=(int *)realloc(out,outln*sizeof(int));
        out[write_pos]=0;
        write_pos++;
    }
    else
    {
        outln=write_pos;
        out=(int *)realloc(out,outln*sizeof(int));
    }
    */

    if(utf32string)
    {
        *utf32string=out;
    }
    if(utf32string_length)
    {
        *utf32string_length=outln;
    }

    return write_pos-1;
}

convert_utf16_to_utf32_LE

Konvertiert einen String von UTF-16 zu UTF-32. Der UTF-16 String muss in Little-Endian Byte-Reihenfolge angegeben sein. (Die UTF-32 Werte werden in der Byte-Reigenfolge des Systems ausgegeben.)

Signature:

int utf16::convert_utf16_to_utf32_LE(int **utf32string,int *utf32string_length,const char16_t *utf16string)

Parameters:

Type	Name	Direction	Description
int **	utf32string	[OUT]	Speicherbereich in den die Ausgabe geschrieben wird. Falls `NULL` angegeben wurde, oder falls utf32string = 0 ist, wird der Speicherbereich neu alloziert. Die anfängliche Länge des Speicherbereichs wird durch utf32string_length festgelegt. Falls utf32string_length = 0 (oder utf32string_length = `NULL`) ist, so wird die anfängliche Länge (in sizeof(int)) auf die Anzahl Bytes in utf8string gesetzt. Ist der Speicherbereich für die Ausgabe zu klein, so wird die Länge so lange verdoppelt (und der Speicher neu alloziert) bis der Speicherbereich lang genug ist. Die Länge des resultierenden Speicherbereichs kann daher deutlich länger sein, als die Länge des Ausgabe-Strings. Bei wiederholtem Aufruf, sollte ein bereits allozierter Speicherbereich wiederverwendet werden, um die Anzahl der benötigten Speicher-Allozierungen gering zu halten. Wird der Speicherbereich neu alloziert (oder re-alloziert) und ist utf32string nicht `NULL`, so wird die neue Adresse des Speicherbereichs nach *utf32string zurück geschrieben.
int *	utf32string_length	[IN/OUT]	Länge des Speicherbereichs utf32string in den die Ausgabe geschrieben wird. Bei Angabe von `NULL` oder falls utf32string_length = 0 ist, so wird falls utf32string = `NULL` oder utf32string = 0 ist, ein neuer Speicherbereich alloziert bzw. falls utf32string != 0 ist, der bestehende Speicherbereich re-alloziert. Ist der Speicherbereich zu klein für die Ausgabe, so wird ebenso ein längerer Speicherbereich alloziert. Sofern utf32string_length nicht `NULL` ist, wird die neue Länge des Speicherbereichs nach utf32string_length geschrieben.
const char16_t *	utf16string	[IN]	Ein null-terminierter und UTF-16 codierter String.

Return value:
Gibt die Anzahl Zeichen zurück, die nach utf32string geschrieben wurden.

Code: toggle

int utf16::convert_utf16_to_utf32_LE(int **utf32string,int *utf32string_length,const char16_t *utf16string)
{
    int *out;
    int outln;

    if(!utf32string || *utf32string==0)
    {
        if(!utf32string_length || *utf32string_length==0)
        {
            outln=length(utf16string)+1;
        }
        else
        {
            outln=*utf32string_length;
        }
        out=(int *)malloc(outln*sizeof(int));
    }
    else
    {
        if(!utf32string_length || *utf32string_length==0)
        {
            outln=length(utf16string)+1;
            out=(int *)realloc(*utf32string,outln*sizeof(int));
        }
        else
        {
            outln=*utf32string_length;
            out=*utf32string;
        }
    }
    int read_pos=0;
    int write_pos=0;
    int bcount=0;
    do
    {
        if(write_pos>=outln)
        {
            outln*=2;
            out=(int *)realloc(out,outln*sizeof(int));
        }
        bcount=decode_LE(&out[write_pos],&utf16string[read_pos]);
        read_pos+=bcount;
        write_pos++;
    }
    while(out[write_pos-1] && bcount);

    // -- VERSION A -- Speicherbereich nicht kürzen.
    if(bcount==0)
    {
        if(write_pos>=outln)
        {
            outln+=1;
            out=(int *)realloc(out,outln*sizeof(int));
        }
        out[write_pos]=0;
        write_pos++;
    }

    /* -- VERSION B -- Speicherbereich kürzen.
    if(bcount==0)
    {
        outln=write_pos+1;
        out=(int *)realloc(out,outln*sizeof(int));
        out[write_pos]=0;
        write_pos++;
    }
    else
    {
        outln=write_pos;
        out=(int *)realloc(out,outln*sizeof(int));
    }
    */

    if(utf32string)
    {
        *utf32string=out;
    }
    if(utf32string_length)
    {
        *utf32string_length=outln;
    }

    return write_pos-1;
}

convert_utf32_to_utf16_BE

Konvertiert einen String von UTF-32 zu UTF-16 in Big-Endian Byte Reihenfolge. Der UTF-32 muss in der Byte-Reihenfolge des System vorliegen.

Signature:

int utf16::convert_utf32_to_utf16_BE(char16_t **utf16string,int *utf16string_length,const int *utf32string)

Parameters:

Type	Name	Direction	Description
char16_t **	utf16string	[OUT]	Speicherbereich in den die Ausgabe geschrieben wird. Falls `NULL` angegeben wurde, oder falls utf16string = 0 ist, wird der Speicherbereich neu alloziert. Die anfängliche Länge des Speicherbereichs wird durch utf8string_length festgelegt. Falls utf16string_length = 0 (oder utf16string_length = `NULL`) ist, so wird die anfängliche Länge (in Bytes) auf die vierfache Anzahl Zeichen in utf32string gesetzt. Ist der Speicherbereich für die Ausgabe zu klein, so wird die Länge so lange verdoppelt (und der Speicher neu alloziert) bis der Speicherbereich lang genug ist. Die Länge des resultierenden Speicherbereichs kann daher deutlich länger sein, als die Länge des Ausgabe-Strings. Bei wiederholtem Aufruf, sollte ein bereits allozierter Speicherbereich wiederverwendet werden, um die Anzahl der benötigten Speicher-Allozierungen gering zu halten. Wird der Speicherbereich neu alloziert (oder re-alloziert) und ist utf8string nicht `NULL`, so wird die neue Adresse des Speicherbereichs nach *utf16string zurück geschrieben.
int *	utf16string_length	[IN/OUT]	Länge des Speicherbereichs utf16string in den die Ausgabe geschrieben wird. Bei Angabe von `NULL` oder falls utf16string_length = 0 ist, so wird falls utf32string = `NULL` oder utf32string = 0 ist, ein neuer Speicherbereich alloziert bzw. falls utf32string != 0 ist, der bestehende Speicherbereich re-alloziert. Ist der Speicherbereich zu klein für die Ausgabe, so wird ebenso ein längerer Speicherbereich alloziert. Sofern utf8string_length nicht `NULL` ist, wird die neue Länge des Speicherbereichs nach utf8string_length geschrieben.
const int *	utf32string	[IN]	Ein null-terminierter und UTF-32 codierter String.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die nach utf16string geschrieben wurden.

Code: toggle

int utf16::convert_utf32_to_utf16_BE(char16_t **utf16string,int *utf16string_length,const int *utf32string)
{
    char16_t *out;
    int outln;

    if(!utf16string || *utf16string==0)
    {
        if(!utf16string_length || *utf16string_length==0)
        {
            outln=length(utf32string)+1;
        }
        else
        {
            outln=*utf16string_length;
        }
        out=(char16_t *)malloc(outln*sizeof(char16_t));
    }
    else
    {
        if(!utf16string_length || *utf16string_length==0)
        {
            outln=length(utf32string)+1;
            out=(char16_t *)realloc(*utf16string,outln*sizeof(char16_t));
        }
        else
        {
            outln=*utf16string_length;
            out=*utf16string;
        }
    }
    int read_pos=0;
    int write_pos=0;
    int bcount=-1;
    while(utf32string[read_pos] && bcount)
    {
        if(write_pos>=outln-4)
        {
            outln*=2+4;
            out=(char16_t *)realloc(out,outln*sizeof(char16_t));
        }
        bcount=encode_BE(&out[write_pos],utf32string[read_pos]);
        write_pos+=bcount;
        read_pos++;
    }

    // -- VERSION A -- Speicherbereich nicht kürzen.
    if(write_pos>=outln)
    {
        outln+=1;
        out=(char16_t *)realloc(out,outln*sizeof(char16_t));
    }
    out[write_pos]=0;

    /* -- VERSION B -- Speicherbereich kürzen.
    outln=write_pos+1;
    out=(char16_t *)realloc(out,outln*sizeof(char16_t));
    out[write_pos]=0;
    */

    if(utf16string)
    {
        *utf16string=out;
    }
    if(utf16string_length)
    {
        *utf16string_length=outln;
    }

    return write_pos;
}

convert_utf32_to_utf16_LE

Konvertiert einen String von UTF-32 zu UTF-16 in Little-Endian Byte Reihenfolge. Der UTF-32 muss in der Byte-Reihenfolge des System vorliegen.

Signature:

int utf16::convert_utf32_to_utf16_LE(char16_t **utf16string,int *utf16string_length,const int *utf32string)

Parameters:

Type	Name	Direction	Description
char16_t **	utf16string	[OUT]	Speicherbereich in den die Ausgabe geschrieben wird. Falls `NULL` angegeben wurde, oder falls utf16string = 0 ist, wird der Speicherbereich neu alloziert. Die anfängliche Länge des Speicherbereichs wird durch utf8string_length festgelegt. Falls utf16string_length = 0 (oder utf16string_length = `NULL`) ist, so wird die anfängliche Länge (in Bytes) auf die vierfache Anzahl Zeichen in utf32string gesetzt. Ist der Speicherbereich für die Ausgabe zu klein, so wird die Länge so lange verdoppelt (und der Speicher neu alloziert) bis der Speicherbereich lang genug ist. Die Länge des resultierenden Speicherbereichs kann daher deutlich länger sein, als die Länge des Ausgabe-Strings. Bei wiederholtem Aufruf, sollte ein bereits allozierter Speicherbereich wiederverwendet werden, um die Anzahl der benötigten Speicher-Allozierungen gering zu halten. Wird der Speicherbereich neu alloziert (oder re-alloziert) und ist utf8string nicht `NULL`, so wird die neue Adresse des Speicherbereichs nach *utf16string zurück geschrieben.
int *	utf16string_length	[IN/OUT]	Länge des Speicherbereichs utf16string in den die Ausgabe geschrieben wird. Bei Angabe von `NULL` oder falls utf16string_length = 0 ist, so wird falls utf32string = `NULL` oder utf32string = 0 ist, ein neuer Speicherbereich alloziert bzw. falls utf32string != 0 ist, der bestehende Speicherbereich re-alloziert. Ist der Speicherbereich zu klein für die Ausgabe, so wird ebenso ein längerer Speicherbereich alloziert. Sofern utf8string_length nicht `NULL` ist, wird die neue Länge des Speicherbereichs nach utf8string_length geschrieben.
const int *	utf32string	[IN]	Ein null-terminierter und UTF-32 codierter String.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die nach utf16string geschrieben wurden.

Code: toggle

int utf16::convert_utf32_to_utf16_LE(char16_t **utf16string,int *utf16string_length,const int *utf32string)
{
    char16_t *out;
    int outln;

    if(!utf16string || *utf16string==0)
    {
        if(!utf16string_length || *utf16string_length==0)
        {
            outln=length(utf32string)+1;
        }
        else
        {
            outln=*utf16string_length;
        }
        out=(char16_t *)malloc(outln*sizeof(char16_t));
    }
    else
    {
        if(!utf16string_length || *utf16string_length==0)
        {
            outln=length(utf32string)+1;
            out=(char16_t *)realloc(*utf16string,outln*sizeof(char16_t));
        }
        else
        {
            outln=*utf16string_length;
            out=*utf16string;
        }
    }
    int read_pos=0;
    int write_pos=0;
    int bcount=-1;
    while(utf32string[read_pos] && bcount)
    {
        if(write_pos>=outln-4)
        {
            outln*=2+4;
            out=(char16_t *)realloc(out,outln*sizeof(char16_t));
        }
        bcount=encode_LE(&out[write_pos],utf32string[read_pos]);
        write_pos+=bcount;
        read_pos++;
    }

    // -- VERSION A -- Speicherbereich nicht kürzen.
    if(write_pos>=outln)
    {
        outln+=1;
        out=(char16_t *)realloc(out,outln*sizeof(char16_t));
    }
    out[write_pos]=0;

    /* -- VERSION B -- Speicherbereich kürzen.
    outln=write_pos+1;
    out=(char16_t *)realloc(out,outln*sizeof(char16_t));
    out[write_pos]=0;
    */

    if(utf16string)
    {
        *utf16string=out;
    }
    if(utf16string_length)
    {
        *utf16string_length=outln;
    }

    return write_pos;
}

getBOM_BE

Schreibt das BOM-Zeichen (Byte-Order-Mark) für die utf16-Codierung mit Big-Endian Byte Reihenfolge in den angegebenen Speicherbereich.

Signature:

int utf16::getBOM_BE(char16_t *utf16out)

Parameters:

Type	Name	Direction	Description
char16_t *	utf16out	[OUT]	Speicherbereich in welchen das BOM-Zeichen in UTF-16 Codierung geschrieben wird. Der Speicherbereich muss groß genug sein, um 2 Bytes aufzunehmen.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das BOM-Zeichen für die utf16-Codierung benötigt. (Das ist immer 1.)

Code: toggle

int utf16::getBOM_BE(char16_t *utf16out)
{
    unsigned char *c=(unsigned char *)utf16out;
    c[0]=0xFE;
    c[1]=0xFF;
    return 1;
}

getBOM_LE

Schreibt das BOM-Zeichen (Byte-Order-Mark) für die utf16-Codierung mit Little-Endian Byte Reihenfolge in den angegebenen Speicherbereich.

Signature:

int utf16::getBOM_LE(char16_t *utf16out)

Parameters:

Type	Name	Direction	Description
char16_t *	utf16out	[OUT]	Speicherbereich in welchen das BOM-Zeichen in UTF-16 Codierung geschrieben wird. Der Speicherbereich muss groß genug sein, um 2 Bytes aufzunehmen.

Return value:
Gibt die Anzahl 2-Byte Zeichen zurück, die das BOM-Zeichen für die utf16-Codierung benötigt. (Das ist immer 1.)

Code: toggle

int utf16::getBOM_LE(char16_t *utf16out)
{
    unsigned char *c=(unsigned char *)utf16out;
    c[0]=0xFF;
    c[1]=0xFE;
    return 1;
}

testBOM

Testet, ob der gegebene String ein BOM-Zeichen (Byte-Order-Mark) für die UTF-16 Codierung enthält.

Signature:

int utf16::testBOM(const char16_t *utf16string)

Parameters:

Type	Name	Direction	Description
const char16_t *	utf16string	[IN]	Ein null-terminierter und UTF-16 codierter String.

Return value:

UTF16_NO_BOM / 0	falls kein BOM vorhanden ist.
UTF16_LE_BOM / 1	falls ein BOM für UTF-16 mit Little-Endian Byte Reihenfolge vorhanden ist.
UTF16_BE_BOM / 2	falls ein BOM für UTF-16 mit Big-Endian Byte Reihenfolge vorhanden ist.

Code: toggle

int utf16::testBOM(const char16_t *utf16in)
{
    unsigned char *c=(unsigned char *)utf16in;
    if(c[0]==0xFE && c[1]==0xFF)
    {
        //big-endian
        return 2;
    }
    if(c[0]==0xFF && c[1]==0xFE)
    {
        //little-endian
        return 1;
    }
    return 0;
}