/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include <config.h>

#include <e32base.h>

#include <unicode/uchar.h>

U_STABLE UChar32 U_EXPORT2

u_tolower(UChar32 c) {

    return User::LowerCase(c);

}

U_STABLE UChar32 U_EXPORT2

u_toupper(UChar32 c) {

    return User::UpperCase(c);

}

U_STABLE UCharDirection U_EXPORT2

u_charDirection(UChar32 c) {

    switch (TChar(c).GetBdCategory()) {

        default:

        case TChar::ELeftToRight:

            return U_LEFT_TO_RIGHT;

        case TChar::ELeftToRightEmbedding:

            return U_LEFT_TO_RIGHT_EMBEDDING;

        case TChar::ELeftToRightOverride:

            return U_LEFT_TO_RIGHT_OVERRIDE;

        case TChar::ERightToLeft:

            return U_RIGHT_TO_LEFT;

        case TChar::ERightToLeftArabic:

            return U_RIGHT_TO_LEFT_ARABIC;

        case TChar::ERightToLeftEmbedding:

            return U_RIGHT_TO_LEFT_EMBEDDING;

        case TChar::ERightToLeftOverride:

            return U_RIGHT_TO_LEFT_OVERRIDE;

        case TChar::EPopDirectionalFormat:

            return U_POP_DIRECTIONAL_FORMAT;

        case TChar::EEuropeanNumber:

            return U_EUROPEAN_NUMBER;

        case TChar::EEuropeanNumberSeparator:

            return U_EUROPEAN_NUMBER_SEPARATOR;

        case TChar::EEuropeanNumberTerminator:

            return U_EUROPEAN_NUMBER_TERMINATOR;

        case TChar::EArabicNumber:

            return U_ARABIC_NUMBER;

        case TChar::ECommonNumberSeparator:

            return U_COMMON_NUMBER_SEPARATOR;

        case TChar::ENonSpacingMark:

            return U_DIR_NON_SPACING_MARK;

        case TChar::EBoundaryNeutral:

            return U_BOUNDARY_NEUTRAL;

        case TChar::EParagraphSeparator:

            return U_BLOCK_SEPARATOR;

        case TChar::ESegmentSeparator:

            return U_SEGMENT_SEPARATOR;

        case TChar::EWhitespace:

            return U_WHITE_SPACE_NEUTRAL;

        case TChar::EOtherNeutral:

            return U_OTHER_NEUTRAL;

    }

}

U_STABLE UBool U_EXPORT2

u_ispunct(UChar32 c) {

    return TChar(c).IsPunctuation();

}

U_STABLE UChar32 U_EXPORT2

u_foldCase(UChar32 c, uint32_t options) {

    TChar t(c);

    t.Fold();

    return t;

}

U_STABLE UBool U_EXPORT2

u_islower(UChar32 c) {

    return TChar(c).IsLower();

}

U_STABLE int32_t U_EXPORT2

u_charDigitValue(UChar32 c) {

    return TChar(c).GetNumericValue();

}

U_STABLE int8_t U_EXPORT2

u_charType(UChar32 c) {

    switch (TChar(c).GetCategory()) {

        default:

        case TChar::ELlCategory:

            return U_LOWERCASE_LETTER; //Ll

        case TChar::ELuCategory:

            return U_UPPERCASE_LETTER; //Lu

        case TChar::ELoCategory:

            return U_OTHER_LETTER;     //Lo

        case TChar::ELtCategory:

            return U_TITLECASE_LETTER; //Lt

        case TChar::ENlCategory:

            return U_LETTER_NUMBER; //Nl

        case TChar::EMcCategory:

            return U_COMBINING_SPACING_MARK; //Mc

        case TChar::EMeCategory:

            return U_ENCLOSING_MARK;         //Me

        case TChar::EMnCategory:

            return U_NON_SPACING_MARK;       //Mn

        case TChar::ELmCategory:

            return U_MODIFIER_LETTER;       //Lm

        case TChar::ENdCategory:

            return U_DECIMAL_DIGIT_NUMBER;   //Nd

        case TChar::EPcCategory:

            return U_CONNECTOR_PUNCTUATION;

        case TChar::EPdCategory:

            return U_DASH_PUNCTUATION;

        case TChar::EPsCategory:

            return U_START_PUNCTUATION;

        case TChar::EPeCategory:

            return U_END_PUNCTUATION;

        case TChar::EPiCategory:

            return U_INITIAL_PUNCTUATION;

        case TChar::EPfCategory:

            return U_FINAL_PUNCTUATION;

        case TChar::EPoCategory:

            return U_OTHER_PUNCTUATION;

        case TChar::ESmCategory:

            return U_MATH_SYMBOL;

        case TChar::EScCategory:

            return U_CURRENCY_SYMBOL;

        case TChar::ESkCategory:

            return U_MODIFIER_SYMBOL;

        case TChar::ESoCategory:

            return U_OTHER_SYMBOL;

        case TChar::EZsCategory:

            return U_SPACE_SEPARATOR;

        case TChar::EZlCategory:

            return U_LINE_SEPARATOR;

        case TChar::EZpCategory:

            return U_PARAGRAPH_SEPARATOR;

        case TChar::ECcCategory:

            return U_CONTROL_CHAR;

        case TChar::ECfCategory:

            return U_FORMAT_CHAR;

        case TChar::ECsCategory:

            return U_SURROGATE;

        case TChar::ECoCategory:

            return U_PRIVATE_USE_CHAR;

        case TChar::ECnCategory:

            return U_GENERAL_OTHER_TYPES;

    };

}

U_STABLE UBool U_EXPORT2

u_isdigit(UChar32 c) {

    return TChar(c).IsDigit();

}

U_STABLE int32_t U_EXPORT2

u_getIntPropertyValue(UChar32 c, UProperty which) {

    // unimplemented

    return 0;

}

U_STABLE UChar32 U_EXPORT2

u_totitle(UChar32 c) {

    return User::TitleCase(c);

}

const char mirrored_chars[] = {

    '<','>',

    '(',')',

    '[',']',

    '{','}',

    0

};

U_STABLE UChar32 U_EXPORT2

u_charMirror(UChar32 c) {

    if (!TChar(c).IsMirrored())

        return c;

    int n=0;

    while(mirrored_chars[n] && mirrored_chars[n]!=c) n++;

    if (mirrored_chars[n]) {

        return mirrored_chars[n+(n%2?-1:1)];

    }

    return c;

}

U_STABLE UBool U_EXPORT2

u_isUUppercase(UChar32 c) {

    return TChar(c).IsUpper();

}

U_STABLE uint8_t U_EXPORT2

u_getCombiningClass(UChar32 c) {

    return TChar(c).GetCombiningClass();

}

#include <unicode/ustring.h>

U_STABLE int32_t U_EXPORT2

u_memcasecmp(const UChar *s1, const UChar *s2, int32_t length, uint32_t options) {

    return Mem::CompareF(s1,length,s2,length);

}

U_STABLE int32_t U_EXPORT2

u_strToLower(UChar *dest, int32_t destCapacity,

             const UChar *src, int32_t srcLength,

             const char *locale,

             UErrorCode *pErrorCode) {

    if (srcLength==-1) {

        srcLength = 0;

        const UChar* p = src;

        while(*p++) srcLength++;

    }

    if (!dest || !destCapacity)

        return srcLength;

    int l = destCapacity<srcLength?destCapacity:srcLength;

    for (int n=0; n<l;n++)

        dest[n] = User::LowerCase(src[n]);

    return srcLength;

}

U_STABLE int32_t U_EXPORT2

u_strToUpper(UChar *dest, int32_t destCapacity,

             const UChar *src, int32_t srcLength,

             const char *locale,

             UErrorCode *pErrorCode) {

    if (srcLength==-1) {

        srcLength = 0;

        const UChar* p = src;

        while(*p++) srcLength++;

    }

    if (!dest || !destCapacity)

        return srcLength;

    int l = destCapacity<srcLength?destCapacity:srcLength;

    for (int n=0; n<l;n++)

        dest[n] = User::UpperCase(src[n]);

    return srcLength;

}

U_STABLE int32_t U_EXPORT2

u_strFoldCase(UChar *dest, int32_t destCapacity,

              const UChar *src, int32_t srcLength,

              uint32_t options,

              UErrorCode *pErrorCode) {

    if (srcLength==-1) {

        srcLength = 0;

        const UChar* p = src;

        while(*p++) srcLength++;

    }

    if (!dest || !destCapacity)

        return srcLength;

    int l = destCapacity<srcLength?destCapacity:srcLength;

    for (int n=0; n<l;n++)

        dest[n] = User::Fold(src[n]);

    return srcLength;

}

#include <unicode/ubrk.h>

struct UBreakIteratorImpl {

    int textLength;

    int pos;

};

U_STABLE UBreakIterator* U_EXPORT2

ubrk_open(UBreakIteratorType type,

      const char *locale,

      const UChar *text,

      int32_t textLength,

      UErrorCode *status) {

    UBreakIteratorImpl* bi = new UBreakIteratorImpl;

    bi->textLength = textLength;

    bi->pos = 0;

    return (UBreakIterator*)bi;

}

U_STABLE void U_EXPORT2

ubrk_setText(UBreakIterator* bi,

             const UChar*    text,

             int32_t         textLength,

             UErrorCode*     status) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    i->textLength = textLength;

    i->pos = 0;

}

U_STABLE void U_EXPORT2

ubrk_close(UBreakIterator *bi) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    delete i;

}

U_STABLE int32_t U_EXPORT2

ubrk_first(UBreakIterator *bi) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    i->pos = 0;

    return 0;

}

U_STABLE int32_t U_EXPORT2

ubrk_preceding(UBreakIterator *bi,

           int32_t offset) {

    return offset?offset-1:UBRK_DONE;

}

U_STABLE int32_t U_EXPORT2

ubrk_following(UBreakIterator *bi,

           int32_t offset) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    return offset+1>=i->textLength?UBRK_DONE:offset+1;

}

U_STABLE int32_t U_EXPORT2

ubrk_next(UBreakIterator *bi) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    i->pos++;    

    return i->pos>=i->textLength?UBRK_DONE:i->pos;

}

U_STABLE int32_t U_EXPORT2

ubrk_current(const UBreakIterator *bi) {

    UBreakIteratorImpl* i = (UBreakIteratorImpl*)bi;

    return i->pos;

}

#include <unicode/ucnv.h>

U_STABLE void U_EXPORT2

ucnv_toUnicode(UConverter *converter,

               UChar **target,

               const UChar *targetLimit,

               const char **source,

               const char *sourceLimit,

               int32_t *offsets,

               UBool flush,

               UErrorCode *err) {

    return;

}

U_STABLE const char * U_EXPORT2

ucnv_getStandardName(const char *name, const char *standard, UErrorCode *pErrorCode) {

    return 0;

}

U_STABLE void U_EXPORT2

ucnv_setFromUCallBack (UConverter * converter,

                       UConverterFromUCallback newAction,

                       const void *newContext,

                       UConverterFromUCallback *oldAction,

                       const void **oldContext,

                       UErrorCode * err) {

    return;

}

U_STABLE void U_EXPORT2

ucnv_setSubstChars(UConverter *converter,

                   const char *subChars,

                   int8_t len,

                   UErrorCode *err) {

    return;

}

U_STABLE void U_EXPORT2

ucnv_fromUnicode (UConverter * converter,

                  char **target,

                  const char *targetLimit,

                  const UChar ** source,

                  const UChar * sourceLimit,

                  int32_t* offsets,

                  UBool flush,

                  UErrorCode * err) {

    return;

}

U_STABLE UConverter* U_EXPORT2

ucnv_open(const char *converterName, UErrorCode *err) {

    return 0;

}

U_STABLE void  U_EXPORT2

ucnv_close(UConverter * converter) {

    return;

}

#include <unicode/ucnv_err.h>

U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_ESCAPE (

                  const void *context,

                  UConverterFromUnicodeArgs *fromUArgs,

                  const UChar* codeUnits,

                  int32_t length,

                  UChar32 codePoint,

                  UConverterCallbackReason reason,

                  UErrorCode * err) {

    return;

}

U_STABLE void U_EXPORT2 UCNV_FROM_U_CALLBACK_SUBSTITUTE (

                  const void *context,

                  UConverterFromUnicodeArgs *fromUArgs,

                  const UChar* codeUnits,

                  int32_t length,

                  UChar32 codePoint,

                  UConverterCallbackReason reason,

                  UErrorCode * err) {

    return;

}

#include <unicode/uidna.h>

U_STABLE int32_t U_EXPORT2

uidna_IDNToASCII(  const UChar* src, int32_t srcLength,

                   UChar* dest, int32_t destCapacity,

                   int32_t options,

                   UParseError* parseError,

                   UErrorCode* status) {

    return 0;

}

#include <unicode/unorm.h>

U_STABLE UNormalizationCheckResult U_EXPORT2

unorm_quickCheck(const UChar *source, int32_t sourcelength,

                 UNormalizationMode mode,

                 UErrorCode *status) {

    return UNORM_YES;

}

U_STABLE int32_t U_EXPORT2

unorm_normalize(const UChar *source, int32_t sourceLength,

                UNormalizationMode mode, int32_t options,

                UChar *result, int32_t resultLength,

                UErrorCode *status) {

    return 0;

}

U_STABLE UChar* U_EXPORT2

u_memset(UChar *dest, UChar c, int32_t count)

{

    while( count-- ) {

        (*dest++) = c;

    }

    return dest;

}