stringmgr.cpp

Go to the documentation of this file.

/******************************************************************************
 *
 *  stringmgr.cpp - implementation of class StringMgr
 *
 * $Id: stringmgr.cpp 3844 2021-02-14 18:26:54Z scribe $
 *
 * Copyright 2004-2013 CrossWire Bible Society (http://www.crosswire.org)
 *  CrossWire Bible Society
 *  P. O. Box 2528
 *  Tempe, AZ  85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program 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
 * General Public License for more details.
 *
 */

#include <ctype.h>
#include <stringmgr.h>
#include <swlog.h>
#include <localemgr.h>
#include <utilstr.h>

#ifdef _ICU_

#include <unicode/utypes.h>
#include <unicode/ucnv.h>
#include <unicode/ustring.h>
#include <unicode/uchar.h>

#include <unicode/unistr.h>
#include <unicode/translit.h>

#include <unicode/locid.h>

#else

#include <swtoupperdata.h>

#endif


SWORD_NAMESPACE_START


StringMgr *StringMgr::systemStringMgr = 0;

class __staticsystemStringMgr {
public:
    __staticsystemStringMgr() { }
    ~__staticsystemStringMgr() { if (StringMgr::systemStringMgr) delete StringMgr::systemStringMgr; StringMgr::systemStringMgr = 0; }
} _staticsystemStringMgr;


namespace {

    int isValidUTF8(unsigned char *txt) {
        unsigned int  countUTF8 = 0;
    #if 0
        unsigned char parts     = 0;


        unsigned char *p = txt;
        while (*p) {
            // Is the high order bit set?
            if (*p & 0x80) {
                // then count the number of high order bits that are set
                // this determines the number of following bytes need to have high order bits set
                unsigned char i = *p;
                for (parts = 0; i & 0x80; parts++) {
                    i <<= 1;
                }


                // The pattern 10nnnnnn is not a unicode character
                if (parts == 1) {
                    return 0;
                }
                else {
                    while (--parts && ++*p) {
                        // The pattern of each following character must be: 10nnnnnn
                        if (0xc0 & *p != 0x80) {
                            return  0;
                        }
                    }

                    // Oops, we've run out of bytes too soon: Cannot be UTF-8
                    if (parts) {
                        return 0;
                    }
                }
                countUTF8++;
            }
        }

        // At this point it is either UTF-8 or ascii
    #endif
        return countUTF8 ? 1 : -1;
    }

    char *lowerLatin1(char *buf, unsigned int maxlen = 0) {
        if (!buf)
            return 0;
            
        char *ret = buf;
        bool checkMax = maxlen;

        while (*buf && (!checkMax || maxlen--)) {
            *buf = SW_tolower(*buf);
            buf++;
        }

        return ret;
    }
}


#ifdef _ICU_

//here comes our ICUStringMgr reimplementation
class ICUStringMgr : public StringMgr {
public:
    virtual char *upperUTF8(char *, unsigned int maxlen = 0) const;
    virtual char *lowerUTF8(char *, unsigned int maxlen = 0) const;
    virtual bool isUpper(SW_u32 character) const;
    virtual bool isLower(SW_u32 character) const;
    virtual bool isDigit(SW_u32 character) const;
    virtual bool isAlpha(SW_u32 character) const;
    
protected:
    virtual bool supportsUnicode() const { return true; };
};

#endif


StringMgr::StringMgr() {
}

StringMgr::StringMgr(const StringMgr &m) {
}

StringMgr::~StringMgr() {
}

void StringMgr::setSystemStringMgr(StringMgr *newStringMgr) {
    if (systemStringMgr) 
        delete systemStringMgr;
    
    systemStringMgr = newStringMgr;

    // TODO: this is magic. apparently we have to reset the system localemgr upon changing stringmgr.
    // setting system stringmgr should be set before localemgr and not possible to change.
    // rework this design.
    LocaleMgr::getSystemLocaleMgr()->setSystemLocaleMgr(new LocaleMgr());
}

StringMgr* StringMgr::getSystemStringMgr() {
    if (!systemStringMgr) {
#ifdef _ICU_
        systemStringMgr = new ICUStringMgr();
//      SWLOGI("created default ICUStringMgr");
#else
        systemStringMgr = new StringMgr();
//          SWLOGI("created default StringMgr");
#endif
    }
    
    return systemStringMgr;
}


char *StringMgr::upperUTF8(char *t, unsigned int maxlen) const {

#ifndef _ICU_

    SWBuf orig = t;
    const unsigned char* from = (unsigned char*)orig.c_str();
    SWBuf text = "";
    std::map<SW_u32, SW_u32>::const_iterator it = toUpperData.end();
    while (*from) {     
        SW_u32 ch = getUniCharFromUTF8(&from, true);
        // should we skip conversion if we run into an invalid UTF8 character?
        // maybe the string isn't intended to be UTF8
        // Right now, if ch is bad, then convert to replacement char
        if (!ch) ch = 0xFFFD;

        it = toUpperData.find(ch);
        getUTF8FromUniChar(it == toUpperData.end() ? ch : it->second, &text);
    }
    long len = maxlen ? (text.size() < maxlen ? text.size() : (maxlen - 1)) : 0;
    if (len) memcpy(t, text.c_str(), len);
    t[len] = 0;
#endif
    return t;
/* OLD
    // try to decide if it's worth trying to toupper.  Do we have more
    // characters which are probably lower latin than not?
    // we still don't use isValidUTF8 optimally. what if we have 1 unicode
    // character in the string?  should we not try to upper any of the string?
    // dunno.  Best solution is to upper all other characters. Don't have
    // time to write that before release.

    long performOp = 0;
    if (!isValidUTF8((unsigned char *)t)) {
        performOp = 1;
    }
    else {
        for (const char *ch = t; *ch; ch++) {
            performOp += (*ch > 0) ? 1 : -1;
        }
    }

    if (performOp > 0) {
        return upperLatin1(t);
    }
*/

    return t;
}


char *StringMgr::lowerUTF8(char *t, unsigned int maxlen) const {
    // try to decide if it's worth trying to tolower.  Do we have more
    // characters which are probably lower latin than not?
    // we still don't use isValidUTF8 optimally. what if we have 1 unicode
    // character in the string?  should we not try to lower any of the string?
    // dunno.  Best solution is to lower all other characters. Don't have
    // time to write that before release.
    long performOp = 0;
    if (!isValidUTF8((unsigned char *)t)) {
        performOp = 1;
    }
    else {
        for (const char *ch = t; *ch; ch++) {
            performOp += (*ch > 0) ? 1 : -1;
        }
    }

    if (performOp > 0) {
        return lowerLatin1(t);
    }

    return t;
}

bool StringMgr::isUpper(SW_u32 character) const {
    return isupper(character);
}
bool StringMgr::isLower(SW_u32 character) const {
    return islower(character);
}
bool StringMgr::isDigit(SW_u32 character) const {
    return isdigit(character);
}
bool StringMgr::isAlpha(SW_u32 character) const {
    return isalpha(character);
}



char *StringMgr::upperLatin1(char *buf, unsigned int maxlen) const {
    if (!buf)
        return 0;
        
    char *ret = buf;
    bool checkMax = maxlen;

    while (*buf && (!checkMax || maxlen--)) {
        *buf = SW_toupper(*buf);
        buf++;
    }

    return ret;
}

bool StringMgr::supportsUnicode() const {
    return true; //default impl has no UTF8 support
}


#ifdef _ICU_

char *ICUStringMgr::upperUTF8(char *buf, unsigned int maxlen) const {
    char *ret = buf;
    int max = (int)((maxlen) ? maxlen : strlen(buf));
        
    UErrorCode err = U_ZERO_ERROR;
        
    if (!buf || !max) {
        return ret;
    }
        
    UChar *lowerStr = new UChar[max+10];
    UChar *upperStr = new UChar[max+10];
        
    u_strFromUTF8(lowerStr, max+9, 0, buf, -1, &err);
    if (err != U_ZERO_ERROR) {
//      SWLog::getSystemLog()->logError("from: %s", u_errorName(err));
        delete [] lowerStr;
        delete [] upperStr;
        return ret;
    }

    u_strToUpper(upperStr, max+9, lowerStr, -1, 0, &err);
    if (err != U_ZERO_ERROR) {
//      SWLog::getSystemLog()->logError("upperCase: %s", u_errorName(err));
        delete [] lowerStr;
        delete [] upperStr;
        return ret;
    }

    ret = u_strToUTF8(ret, max, 0, upperStr, -1, &err);
        
    delete [] lowerStr;
    delete [] upperStr;
    return ret;
}

char *ICUStringMgr::lowerUTF8(char *buf, unsigned int maxlen) const {
    char *ret = buf;
    int max = (int)((maxlen) ? maxlen : strlen(buf));
        
    UErrorCode err = U_ZERO_ERROR;
        
    if (!buf || !max) {
        return ret;
    }
        
    UChar *sourceStr = new UChar[max+10];
    UChar *resultStr = new UChar[max+10];
        
    u_strFromUTF8(sourceStr, max+9, 0, buf, -1, &err);
    if (err != U_ZERO_ERROR) {
//      SWLog::getSystemLog()->logError("from: %s", u_errorName(err));
        delete [] sourceStr;
        delete [] resultStr;
        return ret;
    }

    u_strToLower(resultStr, max+9, sourceStr, -1, 0, &err);
    if (err != U_ZERO_ERROR) {
//      SWLog::getSystemLog()->logError("upperCase: %s", u_errorName(err));
        delete [] sourceStr;
        delete [] resultStr;
        return ret;
    }

    ret = u_strToUTF8(ret, max, 0, resultStr, -1, &err);
        
    delete [] sourceStr;
    delete [] resultStr;
    return ret;
}

bool ICUStringMgr::isUpper(SW_u32 character) const {
    return u_isupper(character);
}
bool ICUStringMgr::isLower(SW_u32 character) const {
    return u_islower(character);
}
bool ICUStringMgr::isDigit(SW_u32 character) const {
    return u_isdigit(character);
}
bool ICUStringMgr::isAlpha(SW_u32 character) const {
    return u_isalpha(character);
}
    
#endif

SWORD_NAMESPACE_END