icuSources/i18n/name2uni.cpp

   1 /*
   2 **********************************************************************
   3 *   Copyright (C) 2001-2011, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 *   Date        Name        Description
   7 *   06/07/01    aliu        Creation.
   8 **********************************************************************
   9 */
  10
  11 #include "unicode/utypes.h"
  12
  13 #if !UCONFIG_NO_TRANSLITERATION
  14
  15 #include "unicode/unifilt.h"
  16 #include "unicode/uchar.h"
  17 #include "unicode/uniset.h"
  18 #include "unicode/utf16.h"
  19 #include "cmemory.h"
  20 #include "name2uni.h"
  21 #include "patternprops.h"
  22 #include "uprops.h"
  23 #include "uinvchar.h"
  24 #include "util.h"
  25
  26 U_NAMESPACE_BEGIN
  27
  28 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NameUnicodeTransliterator)
  29
  30 static const UChar OPEN[] = {92,78,126,123,126,0}; // "\N~{~"
  31 static const UChar OPEN_DELIM  = 92;  // '\\' first char of OPEN
  32 static const UChar CLOSE_DELIM = 125; // '}'
  33 static const UChar SPACE       = 32;  // ' '
  34
  35 U_CDECL_BEGIN
  36
  37 // USetAdder implementation
  38 // Does not use uset.h to reduce code dependencies
  39 static void U_CALLCONV
  40 _set_add(USet *set, UChar32 c) {
  41     uset_add(set, c);
  42 }
  43
  44 // These functions aren't used.
  45 /*static void U_CALLCONV
  46 _set_addRange(USet *set, UChar32 start, UChar32 end) {
  47     ((UnicodeSet *)set)->add(start, end);
  48 }
  49
  50 static void U_CALLCONV
  51 _set_addString(USet *set, const UChar *str, int32_t length) {
  52     ((UnicodeSet *)set)->add(UnicodeString((UBool)(length<0), str, length));
  53 }*/
  54
  55 U_CDECL_END
  56
  57 /**
  58  * Constructs a transliterator with the default delimiters '{' and
  59  * '}'.
  60  */
  61 NameUnicodeTransliterator::NameUnicodeTransliterator(UnicodeFilter* adoptedFilter) :
  62     Transliterator(UNICODE_STRING("Name-Any", 8), adoptedFilter) {
  63
  64     UnicodeSet *legalPtr = &legal;
  65     // Get the legal character set
  66     USetAdder sa = {
  67         (USet *)legalPtr, // USet* == UnicodeSet*
  68         _set_add,
  69         NULL, // Don't need _set_addRange
  70         NULL, // Don't need _set_addString
  71         NULL, // Don't need remove()
  72         NULL
  73     };
  74     uprv_getCharNameCharacters(&sa);
  75 }
  76
  77 /**
  78  * Destructor.
  79  */
  80 NameUnicodeTransliterator::~NameUnicodeTransliterator() {}
  81
  82 /**
  83  * Copy constructor.
  84  */
  85 NameUnicodeTransliterator::NameUnicodeTransliterator(const NameUnicodeTransliterator& o) :
  86     Transliterator(o), legal(o.legal) {}
  87
  88 /**
  89  * Assignment operator.
  90  */
  91 /*NameUnicodeTransliterator& NameUnicodeTransliterator::operator=(
  92                              const NameUnicodeTransliterator& o) {
  93     Transliterator::operator=(o);
  94     // not necessary: the legal sets should all be the same -- legal=o.legal;
  95     return *this;
  96 }*/
  97
  98 /**
  99  * Transliterator API.
 100  */
 101 Transliterator* NameUnicodeTransliterator::clone(void) const {
 102     return new NameUnicodeTransliterator(*this);
 103 }
 104
 105 /**
 106  * Implements {@link Transliterator#handleTransliterate}.
 107  */
 108 void NameUnicodeTransliterator::handleTransliterate(Replaceable& text, UTransPosition& offsets,
 109                                                     UBool isIncremental) const {
 110     // The failure mode, here and below, is to behave like Any-Null,
 111     // if either there is no name data (max len == 0) or there is no
 112     // memory (malloc() => NULL).
 113
 114     int32_t maxLen = uprv_getMaxCharNameLength();
 115     if (maxLen == 0) {
 116         offsets.start = offsets.limit;
 117         return;
 118     }
 119
 120     // Accomodate the longest possible name
 121     ++maxLen; // allow for temporary trailing space
 122     char* cbuf = (char*) uprv_malloc(maxLen);
 123     if (cbuf == NULL) {
 124         offsets.start = offsets.limit;
 125         return;
 126     }
 127
 128     UnicodeString openPat(TRUE, OPEN, -1);
 129     UnicodeString str, name;
 130
 131     int32_t cursor = offsets.start;
 132     int32_t limit = offsets.limit;
 133
 134     // Modes:
 135     // 0 - looking for open delimiter
 136     // 1 - after open delimiter
 137     int32_t mode = 0;
 138     int32_t openPos = -1; // open delim candidate pos
 139
 140     UChar32 c;
 141     while (cursor < limit) {
 142         c = text.char32At(cursor);
 143
 144         switch (mode) {
 145         case 0: // looking for open delimiter
 146             if (c == OPEN_DELIM) { // quick check first
 147                 openPos = cursor;
 148                 int32_t i =
 149                     ICU_Utility::parsePattern(openPat, text, cursor, limit);
 150                 if (i >= 0 && i < limit) {
 151                     mode = 1;
 152                     name.truncate(0);
 153                     cursor = i;
 154                     continue; // *** reprocess char32At(cursor)
 155                 }
 156             }
 157             break;
 158
 159         case 1: // after open delimiter
 160             // Look for legal chars.  If \s+ is found, convert it
 161             // to a single space.  If closeDelimiter is found, exit
 162             // the loop.  If any other character is found, exit the
 163             // loop.  If the limit is reached, exit the loop.
 164
 165             // Convert \s+ => SPACE.  This assumes there are no
 166             // runs of >1 space characters in names.
 167             if (PatternProps::isWhiteSpace(c)) {
 168                 // Ignore leading whitespace
 169                 if (name.length() > 0 &&
 170                     name.charAt(name.length()-1) != SPACE) {
 171                     name.append(SPACE);
 172                     // If we are too long then abort.  maxLen includes
 173                     // temporary trailing space, so use '>'.
 174                     if (name.length() > maxLen) {
 175                         mode = 0;
 176                     }
 177                 }
 178                 break;
 179             }
 180
 181             if (c == CLOSE_DELIM) {
 182                 int32_t len = name.length();
 183
 184                 // Delete trailing space, if any
 185                 if (len > 0 &&
 186                     name.charAt(len-1) == SPACE) {
 187                     --len;
 188                 }
 189
 190                 if (uprv_isInvariantUString(name.getBuffer(), len)) {
 191                     name.extract(0, len, cbuf, maxLen, US_INV);
 192
 193                     UErrorCode status = U_ZERO_ERROR;
 194                     c = u_charFromName(U_EXTENDED_CHAR_NAME, cbuf, &status);
 195                     if (U_SUCCESS(status)) {
 196                         // Lookup succeeded
 197
 198                         // assert(U16_LENGTH(CLOSE_DELIM) == 1);
 199                         cursor++; // advance over CLOSE_DELIM
 200
 201                         str.truncate(0);
 202                         str.append(c);
 203                         text.handleReplaceBetween(openPos, cursor, str);
 204
 205                         // Adjust indices for the change in the length of
 206                         // the string.  Do not assume that str.length() ==
 207                         // 1, in case of surrogates.
 208                         int32_t delta = cursor - openPos - str.length();
 209                         cursor -= delta;
 210                         limit -= delta;
 211                         // assert(cursor == openPos + str.length());
 212                     }
 213                 }
 214                 // If the lookup failed, we leave things as-is and
 215                 // still switch to mode 0 and continue.
 216                 mode = 0;
 217                 openPos = -1; // close off candidate
 218                 continue; // *** reprocess char32At(cursor)
 219             }
 220
 221             // Check if c is a legal char.  We assume here that
 222             // legal.contains(OPEN_DELIM) is FALSE, so when we abort a
 223             // name, we don't have to go back to openPos+1.
 224             if (legal.contains(c)) {
 225                 name.append(c);
 226                 // If we go past the longest possible name then abort.
 227                 // maxLen includes temporary trailing space, so use '>='.
 228                 if (name.length() >= maxLen) {
 229                     mode = 0;
 230                 }
 231             }
 232
 233             // Invalid character
 234             else {
 235                 --cursor; // Backup and reprocess this character
 236                 mode = 0;
 237             }
 238
 239             break;
 240         }
 241
 242         cursor += U16_LENGTH(c);
 243     }
 244
 245     offsets.contextLimit += limit - offsets.limit;
 246     offsets.limit = limit;
 247     // In incremental mode, only advance the cursor up to the last
 248     // open delimiter candidate.
 249     offsets.start = (isIncremental && openPos >= 0) ? openPos : cursor;
 250
 251     uprv_free(cbuf);
 252 }
 253
 254 U_NAMESPACE_END
 255
 256 #endif /* #if !UCONFIG_NO_TRANSLITERATION */