i18npool/source/textconversion/textconversion_zh.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <assert.h>
  22 #include <textconversion.hxx>
  23 #include <com/sun/star/i18n/TextConversionType.hpp>
  24 #include <com/sun/star/i18n/TextConversionOption.hpp>
  25 #include <com/sun/star/lang/NoSupportException.hpp>
  26 #include <com/sun/star/linguistic2/ConversionDirection.hpp>
  27 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
  28 #include <com/sun/star/linguistic2/ConversionDictionaryList.hpp>
  29 #include <comphelper/string.hxx>
  30 #include <memory>
  31
  32 using namespace com::sun::star::lang;
  33 using namespace com::sun::star::i18n;
  34 using namespace com::sun::star::linguistic2;
  35 using namespace com::sun::star::uno;
  36
  37
  38 namespace i18npool {
  39
  40 TextConversion_zh::TextConversion_zh( const Reference < XComponentContext >& xContext )
  41     : TextConversionService("com.sun.star.i18n.TextConversion_zh")
  42 {
  43     xCDL = ConversionDictionaryList::create(xContext);
  44 }
  45
  46 sal_Unicode getOneCharConversion(sal_Unicode ch, const sal_Unicode* Data, const sal_uInt16* Index)
  47 {
  48     if (Data && Index) {
  49         sal_Unicode address = Index[ch>>8];
  50         if (address != 0xFFFF)
  51             address = Data[address + (ch & 0xFF)];
  52         return (address != 0xFFFF) ? address : ch;
  53     } else {
  54         return ch;
  55     }
  56 }
  57
  58 #ifdef DISABLE_DYNLOADING
  59
  60 extern "C" {
  61
  62 const sal_Unicode* getSTC_CharData_T2S();
  63 const sal_uInt16* getSTC_CharIndex_T2S();
  64 const sal_Unicode* getSTC_CharData_S2V();
  65 const sal_uInt16* getSTC_CharIndex_S2V();
  66 const sal_Unicode* getSTC_CharData_S2T();
  67 const sal_uInt16* getSTC_CharIndex_S2T();
  68
  69 const sal_Unicode *getSTC_WordData(sal_Int32&);
  70
  71 const sal_uInt16 *getSTC_WordIndex_T2S(sal_Int32&);
  72 const sal_uInt16 *getSTC_WordEntry_T2S();
  73 const sal_uInt16 *getSTC_WordIndex_S2T(sal_Int32&);
  74 const sal_uInt16 *getSTC_WordEntry_S2T();
  75
  76 }
  77
  78 #endif
  79
  80 OUString
  81 TextConversion_zh::getCharConversion(const OUString& aText, sal_Int32 nStartPos, sal_Int32 nLength, bool toSChinese, sal_Int32 nConversionOptions)
  82 {
  83     const sal_Unicode *Data;
  84     const sal_uInt16 *Index;
  85
  86 #ifndef DISABLE_DYNLOADING
  87     if (toSChinese) {
  88         Data = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_T2S"))();
  89         Index = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_T2S"))();
  90     } else if (nConversionOptions & TextConversionOption::USE_CHARACTER_VARIANTS) {
  91         Data = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_S2V"))();
  92         Index = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_S2V"))();
  93     } else {
  94         Data = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_S2T"))();
  95         Index = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_S2T"))();
  96     }
  97 #else
  98     if (toSChinese) {
  99         Data = getSTC_CharData_T2S();
 100         Index = getSTC_CharIndex_T2S();
 101     } else if (nConversionOptions & TextConversionOption::USE_CHARACTER_VARIANTS) {
 102         Data = getSTC_CharData_S2V();
 103         Index = getSTC_CharIndex_S2V();
 104     } else {
 105         Data = getSTC_CharData_S2T();
 106         Index = getSTC_CharIndex_S2T();
 107     }
 108 #endif
 109
 110     rtl_uString * newStr = rtl_uString_alloc(nLength);
 111     for (sal_Int32 i = 0; i < nLength; i++)
 112         newStr->buffer[i] =
 113             getOneCharConversion(aText[nStartPos+i], Data, Index);
 114     return OUString(newStr, SAL_NO_ACQUIRE); //take ownership
 115 }
 116
 117 OUString
 118 TextConversion_zh::getWordConversion(const OUString& aText, sal_Int32 nStartPos, sal_Int32 nLength, bool toSChinese, sal_Int32 nConversionOptions, Sequence<sal_Int32>& offset)
 119 {
 120     sal_Int32 dictLen = 0;
 121     sal_Int32 maxLen = 0;
 122     const sal_uInt16 *index;
 123     const sal_uInt16 *entry;
 124     const sal_Unicode *charData;
 125     const sal_uInt16 *charIndex;
 126     bool one2one=true;
 127
 128 #ifndef DISABLE_DYNLOADING
 129     const sal_Unicode *wordData = reinterpret_cast<const sal_Unicode* (*)(sal_Int32&)>(getFunctionBySymbol("getSTC_WordData"))(dictLen);
 130     if (toSChinese) {
 131         index = reinterpret_cast<const sal_uInt16* (*)(sal_Int32&)>(getFunctionBySymbol("getSTC_WordIndex_T2S"))(maxLen);
 132         entry = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_WordEntry_T2S"))();
 133         charData = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_T2S"))();
 134         charIndex = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_T2S"))();
 135     } else {
 136         index = reinterpret_cast<const sal_uInt16* (*)(sal_Int32&)>(getFunctionBySymbol("getSTC_WordIndex_S2T"))(maxLen);
 137         entry = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_WordEntry_S2T"))();
 138         if (nConversionOptions & TextConversionOption::USE_CHARACTER_VARIANTS) {
 139             charData = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_S2V"))();
 140             charIndex = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_S2V"))();
 141         } else {
 142             charData = reinterpret_cast<const sal_Unicode* (*)()>(getFunctionBySymbol("getSTC_CharData_S2T"))();
 143             charIndex = reinterpret_cast<const sal_uInt16* (*)()>(getFunctionBySymbol("getSTC_CharIndex_S2T"))();
 144         }
 145     }
 146 #else
 147     const sal_Unicode *wordData = getSTC_WordData(dictLen);
 148     if (toSChinese) {
 149         index = getSTC_WordIndex_T2S(maxLen);
 150         entry = getSTC_WordEntry_T2S();
 151         charData = getSTC_CharData_T2S();
 152         charIndex = getSTC_CharIndex_T2S();
 153     } else {
 154         index = getSTC_WordIndex_S2T(maxLen);
 155         entry = getSTC_WordEntry_S2T();
 156         if (nConversionOptions & TextConversionOption::USE_CHARACTER_VARIANTS) {
 157             charData = getSTC_CharData_S2V();
 158             charIndex = getSTC_CharIndex_S2V();
 159         } else {
 160             charData = getSTC_CharData_S2T();
 161             charIndex = getSTC_CharIndex_S2T();
 162         }
 163     }
 164 #endif
 165
 166     if ((!wordData || !index || !entry) && !xCDL.is()) // no word mapping defined, do char2char conversion.
 167         return getCharConversion(aText, nStartPos, nLength, toSChinese, nConversionOptions);
 168
 169     std::unique_ptr<sal_Unicode[]> newStr(new sal_Unicode[nLength * 2 + 1]);
 170     sal_Int32 currPos = 0, count = 0;
 171     while (currPos < nLength) {
 172         sal_Int32 len = nLength - currPos;
 173         bool found = false;
 174         if (len > maxLen)
 175             len = maxLen;
 176         for (; len > 0 && ! found; len--) {
 177             OUString word = aText.copy(nStartPos + currPos, len);
 178             sal_Int32 current = 0;
 179             // user dictionary
 180             if (xCDL.is()) {
 181                 Sequence < OUString > conversions;
 182                 try {
 183                     conversions = xCDL->queryConversions(word, 0, len,
 184                             aLocale, ConversionDictionaryType::SCHINESE_TCHINESE,
 185                             /*toSChinese ?*/ ConversionDirection_FROM_LEFT /*: ConversionDirection_FROM_RIGHT*/,
 186                             nConversionOptions);
 187                 }
 188                 catch ( NoSupportException & ) {
 189                     // clear reference (when there is no user dictionary) in order
 190                     // to not always have to catch this exception again
 191                     // in further calls. (save time)
 192                     xCDL = nullptr;
 193                 }
 194                 catch (...) {
 195                     // catch all other exceptions to allow
 196                     // querying the system dictionary in the next line
 197                 }
 198                 if (conversions.getLength() > 0) {
 199                     if (offset.getLength() > 0) {
 200                         if (word.getLength() != conversions[0].getLength())
 201                             one2one=false;
 202                         while (current < conversions[0].getLength()) {
 203                             offset[count] = nStartPos + currPos + (current *
 204                                     word.getLength() / conversions[0].getLength());
 205                             newStr[count++] = conversions[0][current++];
 206                         }
 207                         // offset[count-1] = nStartPos + currPos + word.getLength() - 1;
 208                     } else {
 209                         while (current < conversions[0].getLength())
 210                             newStr[count++] = conversions[0][current++];
 211                     }
 212                     currPos += word.getLength();
 213                     found = true;
 214                 }
 215             }
 216
 217             if (!found && index[len+1] - index[len] > 0) {
 218                 sal_Int32 bottom = static_cast<sal_Int32>(index[len]);
 219                 sal_Int32 top = static_cast<sal_Int32>(index[len+1]) - 1;
 220
 221                 while (bottom <= top && !found) {
 222                     current = (top + bottom) / 2;
 223                     const sal_Int32 result = word.compareTo(wordData + entry[current]);
 224                     if (result < 0)
 225                         top = current - 1;
 226                     else if (result > 0)
 227                         bottom = current + 1;
 228                     else {
 229                         if (toSChinese)   // Traditionary/Simplified conversion,
 230                             for (current = entry[current]-1; current > 0 && wordData[current-1]; current--) ;
 231                         else  // Simplified/Traditionary conversion, forwards search for next word
 232                             current = entry[current] + word.getLength() + 1;
 233                         sal_Int32 start=current;
 234                         if (offset.getLength() > 0) {
 235                             if (word.getLength() != OUString(&wordData[current]).getLength())
 236                                 one2one=false;
 237                             sal_Int32 convertedLength=OUString(&wordData[current]).getLength();
 238                             while (wordData[current]) {
 239                                 offset[count]=nStartPos + currPos + ((current-start) *
 240                                     word.getLength() / convertedLength);
 241                                 newStr[count++] = wordData[current++];
 242                             }
 243                             // offset[count-1]=nStartPos + currPos + word.getLength() - 1;
 244                         } else {
 245                             while (wordData[current])
 246                                 newStr[count++] = wordData[current++];
 247                         }
 248                         currPos += word.getLength();
 249                         found = true;
 250                     }
 251                 }
 252             }
 253         }
 254         if (!found) {
 255             if (offset.getLength() > 0)
 256                 offset[count]=nStartPos+currPos;
 257             newStr[count++] =
 258                 getOneCharConversion(aText[nStartPos+currPos], charData, charIndex);
 259             currPos++;
 260         }
 261     }
 262     if (offset.getLength() > 0)
 263         offset.realloc(one2one ? 0 : count);
 264     OUString aRet(newStr.get(), count);
 265     return aRet;
 266 }
 267
 268 TextConversionResult SAL_CALL
 269 TextConversion_zh::getConversions( const OUString& aText, sal_Int32 nStartPos, sal_Int32 nLength,
 270     const Locale& rLocale, sal_Int16 nConversionType, sal_Int32 nConversionOptions)
 271 {
 272     TextConversionResult result;
 273
 274     result.Candidates.realloc(1);
 275     result.Candidates[0] = getConversion( aText, nStartPos, nLength, rLocale, nConversionType, nConversionOptions);
 276     result.Boundary.startPos = nStartPos;
 277     result.Boundary.endPos = nStartPos + nLength;
 278
 279     return result;
 280 }
 281
 282 OUString SAL_CALL
 283 TextConversion_zh::getConversion( const OUString& aText, sal_Int32 nStartPos, sal_Int32 nLength,
 284     const Locale& rLocale, sal_Int16 nConversionType, sal_Int32 nConversionOptions)
 285 {
 286     if (rLocale.Language != "zh" || ( nConversionType != TextConversionType::TO_SCHINESE && nConversionType != TextConversionType::TO_TCHINESE) )
 287         throw NoSupportException(); // Conversion type is not supported in this service.
 288
 289     aLocale=rLocale;
 290     bool toSChinese = nConversionType == TextConversionType::TO_SCHINESE;
 291
 292     if (nConversionOptions & TextConversionOption::CHARACTER_BY_CHARACTER)
 293         // char to char dictionary
 294         return getCharConversion(aText, nStartPos, nLength, toSChinese, nConversionOptions);
 295     else {
 296         Sequence <sal_Int32> offset;
 297         // word to word dictionary
 298         return  getWordConversion(aText, nStartPos, nLength, toSChinese, nConversionOptions, offset);
 299     }
 300 }
 301
 302 OUString SAL_CALL
 303 TextConversion_zh::getConversionWithOffset( const OUString& aText, sal_Int32 nStartPos, sal_Int32 nLength,
 304     const Locale& rLocale, sal_Int16 nConversionType, sal_Int32 nConversionOptions, Sequence<sal_Int32>& offset)
 305 {
 306     if (rLocale.Language != "zh" || ( nConversionType != TextConversionType::TO_SCHINESE && nConversionType != TextConversionType::TO_TCHINESE) )
 307         throw NoSupportException(); // Conversion type is not supported in this service.
 308
 309     aLocale=rLocale;
 310     bool toSChinese = nConversionType == TextConversionType::TO_SCHINESE;
 311
 312     if (nConversionOptions & TextConversionOption::CHARACTER_BY_CHARACTER) {
 313         offset.realloc(0);
 314         // char to char dictionary
 315         return getCharConversion(aText, nStartPos, nLength, toSChinese, nConversionOptions);
 316     } else {
 317         if (offset.getLength() < 2*nLength)
 318             offset.realloc(2*nLength);
 319         // word to word dictionary
 320         return  getWordConversion(aText, nStartPos, nLength, toSChinese, nConversionOptions, offset);
 321     }
 322 }
 323
 324 sal_Bool SAL_CALL
 325 TextConversion_zh::interactiveConversion( const Locale& /*rLocale*/, sal_Int16 /*nTextConversionType*/, sal_Int32 /*nTextConversionOptions*/ )
 326 {
 327     return false;
 328 }
 329
 330 }
 331
 332 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */