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