root/trunk/thune/encoding.c

/*============================================================================
    Urlan Interpreter
    Copyright (C) 2005-2007  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include <urlan.h>
/*
#include <urlan_atoms.h>
*/


int ur_encodingCharSize[ UR_ENC_COUNT ] = { 1, 1, 2 };


/*
   Returns number of characters copied.
*/
int copyLatin1ToUtf8( uint8_t* dest, const uint8_t* src, int len )
{
    // TODO: Prevent overflow of dest.
    const uint8_t* start;
    const uint8_t* end;
    uint16_t c;

    start = dest;
    end = src + len;

    while( src != end )
    {
        c = *src++;
        if( c > 127 )
        {
            *dest++ = 0xC0 | (c >> 6);
            c = 0x80 | (c & 0x3f);
        }
        *dest++ = c;
    }
    return dest - start;
}


/*
   Returns number of characters copied.
*/
int copyUcs2ToUtf8( uint8_t* dest, const uint16_t* src, int len )
{
    // TODO: Prevent overflow of dest.
    const uint8_t* start;
    const uint16_t* end;
    uint16_t c;

    start = dest;
    end = src + len;

    while( src != end )
    {
        c = *src++;
        if( c > 127 )
        {
            if( c > 0x07ff )
            {
                *dest++ = 0xE0 | (c >> 12);
                *dest++ = 0x80 | ((c >> 6) & 0x3f);
                c = 0x80 | (c & 0x3f);
            }
            else
            {
                *dest++ = 0xC0 | (c >> 6);
                c = 0x80 | (c & 0x3f);
            }
        }
        *dest++ = c;
    }
    return dest - start;
}


#if 0
int copyUcs2ToAscii( char* dest, const uint16_t* src, int len )
{
    const uint16_t* end;
    uint16_t c;

    end = src + len;

    while( src != end )
    {
        c = *src++;
        if( c > 127 )
            c = 0;
        *dest++ = (char) c;
    }
    return len;
}
#endif


/*
   Returns number of characters copied.
*/
int copyAsciiToUtf16( uint16_t* dest, const uint8_t* src, int len )
{
    const uint8_t* end = src + len;
    while( src != end )
        *dest++ = *src++;
    return len;
}


// (str enc -- new-str)
UR_CALL( uc_encode )
{
    UIndex strN;
    UCell* res;
    uint8_t* cpA;
    uint8_t* cpB;
    UBinary* bin;
    int count;
    int enc;

    UR_S_DROP;
    res = UR_TOS;

    if( ur_isAWord(tos) && ur_stringSlice(ut, res, &cpA, &cpB) )
    {
        count = cpB - cpA;

        switch( ur_atom(tos) )
        {
            case UR_ATOM_LATIN1:
                switch( ur_encoding(res) )
                {
                    case UR_ENC_UCS2:
                        count >>= 1;
                        strN = ur_makeBinary( count * 2, &bin ); 
                        bin->used = copyUcs2ToUtf8( bin->ptr.b,
                                                    (uint16_t*) cpA, count );
                        enc = UR_ENC_LATIN1;
                        goto set_result;
                }
                break;

            case UR_ATOM_UTF8:
                /*
                enc = UR_ENC_UTF8;
                switch( ur_encoding(res) )
                {
                    case UR_ENC_LATIN1:
                        goto set_result;

                    case UR_ENC_UCS2:
                        goto set_result;
                }
                */
                break;

            case UR_ATOM_UCS2:
                switch( ur_encoding(res) )
                {
                    case UR_ENC_LATIN1:
                        strN = ur_makeBinary( count * 2, &bin ); 
                        bin->used = copyAsciiToUtf16( bin->ptr.u16,
                                                      cpA, count );
                        enc = UR_ENC_UCS2;
                        goto set_result;
                }
                break;
        }
    }
    return;

set_result:

    ur_initType(res, UT_STRING);
    ur_setEncoding(res, enc);
    ur_setSeries(res, strN, 0);
}


// (str -- enc)
UR_CALL( uc_encodingQ )
{
    UR_CALL_UNUSED_TH

    if( ur_is(tos, UT_STRING) )
    {
        UAtom atom = UR_ATOM_LATIN1;

        switch( ur_encoding(tos) )
        {
            //case UR_ENC_LATIN1: atom = UR_ATOM_LATIN1; break;
            case UR_ENC_UTF8:  atom = UR_ATOM_UTF8;  break;
            case UR_ENC_UCS2:  atom = UR_ATOM_UCS2;  break;
        }

        ur_initType(tos, UT_WORD);
        ur_setUnbound(tos, atom);
    }
    else
    {
        ur_initType(tos, UT_NONE);
    }
}


/* EOF */