The Tor Browser / file comparison

comparison: intl/icu/source/i18n/tridpars.cpp

intl/icu/source/i18n/tridpars.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:47404bdebdec
1 /*
2 **********************************************************************
3 * Copyright (c) 2002-2012, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 **********************************************************************
6 * Date Name Description
7 * 01/14/2002 aliu Creation.
8 **********************************************************************
9 */
10
11 #include "unicode/utypes.h"
12
13 #if !UCONFIG_NO_TRANSLITERATION
14
15 #include "tridpars.h"
16 #include "hash.h"
17 #include "mutex.h"
18 #include "ucln_in.h"
19 #include "unicode/parsepos.h"
20 #include "unicode/translit.h"
21 #include "unicode/uchar.h"
22 #include "unicode/uniset.h"
23 #include "unicode/unistr.h"
24 #include "unicode/utrans.h"
25 #include "util.h"
26 #include "uvector.h"
27
28 U_NAMESPACE_BEGIN
29
30 static const UChar ID_DELIM = 0x003B; // ;
31 static const UChar TARGET_SEP = 0x002D; // -
32 static const UChar VARIANT_SEP = 0x002F; // /
33 static const UChar OPEN_REV = 0x0028; // (
34 static const UChar CLOSE_REV = 0x0029; // )
35
36 //static const UChar EMPTY[] = {0}; // ""
37 static const UChar ANY[] = {65,110,121,0}; // "Any"
38 static const UChar ANY_NULL[] = {65,110,121,45,78,117,108,108,0}; // "Any-Null"
39
40 static const int32_t FORWARD = UTRANS_FORWARD;
41 static const int32_t REVERSE = UTRANS_REVERSE;
42
43 static Hashtable* SPECIAL_INVERSES = NULL;
44
45 /**
46 * The mutex controlling access to SPECIAL_INVERSES
47 */
48 static UMutex LOCK = U_MUTEX_INITIALIZER;
49
50 TransliteratorIDParser::Specs::Specs(const UnicodeString& s, const UnicodeString& t,
51 const UnicodeString& v, UBool sawS,
52 const UnicodeString& f) {
53 source = s;
54 target = t;
55 variant = v;
56 sawSource = sawS;
57 filter = f;
58 }
59
60 TransliteratorIDParser::SingleID::SingleID(const UnicodeString& c, const UnicodeString& b,
61 const UnicodeString& f) {
62 canonID = c;
63 basicID = b;
64 filter = f;
65 }
66
67 TransliteratorIDParser::SingleID::SingleID(const UnicodeString& c, const UnicodeString& b) {
68 canonID = c;
69 basicID = b;
70 }
71
72 Transliterator* TransliteratorIDParser::SingleID::createInstance() {
73 Transliterator* t;
74 if (basicID.length() == 0) {
75 t = createBasicInstance(UnicodeString(TRUE, ANY_NULL, 8), &canonID);
76 } else {
77 t = createBasicInstance(basicID, &canonID);
78 }
79 if (t != NULL) {
80 if (filter.length() != 0) {
81 UErrorCode ec = U_ZERO_ERROR;
82 UnicodeSet *set = new UnicodeSet(filter, ec);
83 if (U_FAILURE(ec)) {
84 delete set;
85 } else {
86 t->adoptFilter(set);
87 }
88 }
89 }
90 return t;
91 }
92
93
94 /**
95 * Parse a single ID, that is, an ID of the general form
96 * "[f1] s1-t1/v1 ([f2] s2-t3/v2)", with the parenthesized element
97 * optional, the filters optional, and the variants optional.
98 * @param id the id to be parsed
99 * @param pos INPUT-OUTPUT parameter. On input, the position of
100 * the first character to parse. On output, the position after
101 * the last character parsed.
102 * @param dir the direction. If the direction is REVERSE then the
103 * SingleID is constructed for the reverse direction.
104 * @return a SingleID object or NULL
105 */
106 TransliteratorIDParser::SingleID*
107 TransliteratorIDParser::parseSingleID(const UnicodeString& id, int32_t& pos,
108 int32_t dir, UErrorCode& status) {
109
110 int32_t start = pos;
111
112 // The ID will be of the form A, A(), A(B), or (B), where
113 // A and B are filter IDs.
114 Specs* specsA = NULL;
115 Specs* specsB = NULL;
116 UBool sawParen = FALSE;
117
118 // On the first pass, look for (B) or (). If this fails, then
119 // on the second pass, look for A, A(B), or A().
120 for (int32_t pass=1; pass<=2; ++pass) {
121 if (pass == 2) {
122 specsA = parseFilterID(id, pos, TRUE);
123 if (specsA == NULL) {
124 pos = start;
125 return NULL;
126 }
127 }
128 if (ICU_Utility::parseChar(id, pos, OPEN_REV)) {
129 sawParen = TRUE;
130 if (!ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
131 specsB = parseFilterID(id, pos, TRUE);
132 // Must close with a ')'
133 if (specsB == NULL || !ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
134 delete specsA;
135 pos = start;
136 return NULL;
137 }
138 }
139 break;
140 }
141 }
142
143 // Assemble return results
144 SingleID* single;
145 if (sawParen) {
146 if (dir == FORWARD) {
147 SingleID* b = specsToID(specsB, FORWARD);
148 single = specsToID(specsA, FORWARD);
149 // Null pointers check
150 if (b == NULL || single == NULL) {
151 delete b;
152 delete single;
153 status = U_MEMORY_ALLOCATION_ERROR;
154 return NULL;
155 }
156 single->canonID.append(OPEN_REV)
157 .append(b->canonID).append(CLOSE_REV);
158 if (specsA != NULL) {
159 single->filter = specsA->filter;
160 }
161 delete b;
162 } else {
163 SingleID* a = specsToID(specsA, FORWARD);
164 single = specsToID(specsB, FORWARD);
165 // Check for null pointer.
166 if (a == NULL || single == NULL) {
167 delete a;
168 delete single;
169 status = U_MEMORY_ALLOCATION_ERROR;
170 return NULL;
171 }
172 single->canonID.append(OPEN_REV)
173 .append(a->canonID).append(CLOSE_REV);
174 if (specsB != NULL) {
175 single->filter = specsB->filter;
176 }
177 delete a;
178 }
179 } else {
180 // assert(specsA != NULL);
181 if (dir == FORWARD) {
182 single = specsToID(specsA, FORWARD);
183 } else {
184 single = specsToSpecialInverse(*specsA, status);
185 if (single == NULL) {
186 single = specsToID(specsA, REVERSE);
187 }
188 }
189 // Check for NULL pointer
190 if (single == NULL) {
191 status = U_MEMORY_ALLOCATION_ERROR;
192 return NULL;
193 }
194 single->filter = specsA->filter;
195 }
196
197 delete specsA;
198 delete specsB;
199
200 return single;
201 }
202
203 /**
204 * Parse a filter ID, that is, an ID of the general form
205 * "[f1] s1-t1/v1", with the filters optional, and the variants optional.
206 * @param id the id to be parsed
207 * @param pos INPUT-OUTPUT parameter. On input, the position of
208 * the first character to parse. On output, the position after
209 * the last character parsed.
210 * @return a SingleID object or null if the parse fails
211 */
212 TransliteratorIDParser::SingleID*
213 TransliteratorIDParser::parseFilterID(const UnicodeString& id, int32_t& pos) {
214
215 int32_t start = pos;
216
217 Specs* specs = parseFilterID(id, pos, TRUE);
218 if (specs == NULL) {
219 pos = start;
220 return NULL;
221 }
222
223 // Assemble return results
224 SingleID* single = specsToID(specs, FORWARD);
225 if (single != NULL) {
226 single->filter = specs->filter;
227 }
228 delete specs;
229 return single;
230 }
231
232 /**
233 * Parse a global filter of the form "[f]" or "([f])", depending
234 * on 'withParens'.
235 * @param id the pattern the parse
236 * @param pos INPUT-OUTPUT parameter. On input, the position of
237 * the first character to parse. On output, the position after
238 * the last character parsed.
239 * @param dir the direction.
240 * @param withParens INPUT-OUTPUT parameter. On entry, if
241 * withParens is 0, then parens are disallowed. If it is 1,
242 * then parens are requires. If it is -1, then parens are
243 * optional, and the return result will be set to 0 or 1.
244 * @param canonID OUTPUT parameter. The pattern for the filter
245 * added to the canonID, either at the end, if dir is FORWARD, or
246 * at the start, if dir is REVERSE. The pattern will be enclosed
247 * in parentheses if appropriate, and will be suffixed with an
248 * ID_DELIM character. May be NULL.
249 * @return a UnicodeSet object or NULL. A non-NULL results
250 * indicates a successful parse, regardless of whether the filter
251 * applies to the given direction. The caller should discard it
252 * if withParens != (dir == REVERSE).
253 */
254 UnicodeSet* TransliteratorIDParser::parseGlobalFilter(const UnicodeString& id, int32_t& pos,
255 int32_t dir,
256 int32_t& withParens,
257 UnicodeString* canonID) {
258 UnicodeSet* filter = NULL;
259 int32_t start = pos;
260
261 if (withParens == -1) {
262 withParens = ICU_Utility::parseChar(id, pos, OPEN_REV) ? 1 : 0;
263 } else if (withParens == 1) {
264 if (!ICU_Utility::parseChar(id, pos, OPEN_REV)) {
265 pos = start;
266 return NULL;
267 }
268 }
269
270 ICU_Utility::skipWhitespace(id, pos, TRUE);
271
272 if (UnicodeSet::resemblesPattern(id, pos)) {
273 ParsePosition ppos(pos);
274 UErrorCode ec = U_ZERO_ERROR;
275 filter = new UnicodeSet(id, ppos, USET_IGNORE_SPACE, NULL, ec);
276 /* test for NULL */
277 if (filter == 0) {
278 pos = start;
279 return 0;
280 }
281 if (U_FAILURE(ec)) {
282 delete filter;
283 pos = start;
284 return NULL;
285 }
286
287 UnicodeString pattern;
288 id.extractBetween(pos, ppos.getIndex(), pattern);
289 pos = ppos.getIndex();
290
291 if (withParens == 1 && !ICU_Utility::parseChar(id, pos, CLOSE_REV)) {
292 pos = start;
293 return NULL;
294 }
295
296 // In the forward direction, append the pattern to the
297 // canonID. In the reverse, insert it at zero, and invert
298 // the presence of parens ("A" <-> "(A)").
299 if (canonID != NULL) {
300 if (dir == FORWARD) {
301 if (withParens == 1) {
302 pattern.insert(0, OPEN_REV);
303 pattern.append(CLOSE_REV);
304 }
305 canonID->append(pattern).append(ID_DELIM);
306 } else {
307 if (withParens == 0) {
308 pattern.insert(0, OPEN_REV);
309 pattern.append(CLOSE_REV);
310 }
311 canonID->insert(0, pattern);
312 canonID->insert(pattern.length(), ID_DELIM);
313 }
314 }
315 }
316
317 return filter;
318 }
319
320 U_CDECL_BEGIN
321 static void U_CALLCONV _deleteSingleID(void* obj) {
322 delete (TransliteratorIDParser::SingleID*) obj;
323 }
324
325 static void U_CALLCONV _deleteTransliteratorTrIDPars(void* obj) {
326 delete (Transliterator*) obj;
327 }
328 U_CDECL_END
329
330 /**
331 * Parse a compound ID, consisting of an optional forward global
332 * filter, a separator, one or more single IDs delimited by
333 * separators, an an optional reverse global filter. The
334 * separator is a semicolon. The global filters are UnicodeSet
335 * patterns. The reverse global filter must be enclosed in
336 * parentheses.
337 * @param id the pattern the parse
338 * @param dir the direction.
339 * @param canonID OUTPUT parameter that receives the canonical ID,
340 * consisting of canonical IDs for all elements, as returned by
341 * parseSingleID(), separated by semicolons. Previous contents
342 * are discarded.
343 * @param list OUTPUT parameter that receives a list of SingleID
344 * objects representing the parsed IDs. Previous contents are
345 * discarded.
346 * @param globalFilter OUTPUT parameter that receives a pointer to
347 * a newly created global filter for this ID in this direction, or
348 * NULL if there is none.
349 * @return TRUE if the parse succeeds, that is, if the entire
350 * id is consumed without syntax error.
351 */
352 UBool TransliteratorIDParser::parseCompoundID(const UnicodeString& id, int32_t dir,
353 UnicodeString& canonID,
354 UVector& list,
355 UnicodeSet*& globalFilter) {
356 UErrorCode ec = U_ZERO_ERROR;
357 int32_t i;
358 int32_t pos = 0;
359 int32_t withParens = 1;
360 list.removeAllElements();
361 UnicodeSet* filter;
362 globalFilter = NULL;
363 canonID.truncate(0);
364
365 // Parse leading global filter, if any
366 withParens = 0; // parens disallowed
367 filter = parseGlobalFilter(id, pos, dir, withParens, &canonID);
368 if (filter != NULL) {
369 if (!ICU_Utility::parseChar(id, pos, ID_DELIM)) {
370 // Not a global filter; backup and resume
371 canonID.truncate(0);
372 pos = 0;
373 }
374 if (dir == FORWARD) {
375 globalFilter = filter;
376 } else {
377 delete filter;
378 }
379 filter = NULL;
380 }
381
382 UBool sawDelimiter = TRUE;
383 for (;;) {
384 SingleID* single = parseSingleID(id, pos, dir, ec);
385 if (single == NULL) {
386 break;
387 }
388 if (dir == FORWARD) {
389 list.addElement(single, ec);
390 } else {
391 list.insertElementAt(single, 0, ec);
392 }
393 if (U_FAILURE(ec)) {
394 goto FAIL;
395 }
396 if (!ICU_Utility::parseChar(id, pos, ID_DELIM)) {
397 sawDelimiter = FALSE;
398 break;
399 }
400 }
401
402 if (list.size() == 0) {
403 goto FAIL;
404 }
405
406 // Construct canonical ID
407 for (i=0; i<list.size(); ++i) {
408 SingleID* single = (SingleID*) list.elementAt(i);
409 canonID.append(single->canonID);
410 if (i != (list.size()-1)) {
411 canonID.append(ID_DELIM);
412 }
413 }
414
415 // Parse trailing global filter, if any, and only if we saw
416 // a trailing delimiter after the IDs.
417 if (sawDelimiter) {
418 withParens = 1; // parens required
419 filter = parseGlobalFilter(id, pos, dir, withParens, &canonID);
420 if (filter != NULL) {
421 // Don't require trailing ';', but parse it if present
422 ICU_Utility::parseChar(id, pos, ID_DELIM);
423
424 if (dir == REVERSE) {
425 globalFilter = filter;
426 } else {
427 delete filter;
428 }
429 filter = NULL;
430 }
431 }
432
433 // Trailing unparsed text is a syntax error
434 ICU_Utility::skipWhitespace(id, pos, TRUE);
435 if (pos != id.length()) {
436 goto FAIL;
437 }
438
439 return TRUE;
440
441 FAIL:
442 UObjectDeleter *save = list.setDeleter(_deleteSingleID);
443 list.removeAllElements();
444 list.setDeleter(save);
445 delete globalFilter;
446 globalFilter = NULL;
447 return FALSE;
448 }
449
450 /**
451 * Convert the elements of the 'list' vector, which are SingleID
452 * objects, into actual Transliterator objects. In the course of
453 * this, some (or all) entries may be removed. If all entries
454 * are removed, the NULL transliterator will be added.
455 *
456 * Delete entries with empty basicIDs; these are generated by
457 * elements like "(A)" in the forward direction, or "A()" in
458 * the reverse. THIS MAY RESULT IN AN EMPTY VECTOR. Convert
459 * SingleID entries to actual transliterators.
460 *
461 * @param list vector of SingleID objects. On exit, vector
462 * of one or more Transliterators.
463 * @return new value of insertIndex. The index will shift if
464 * there are empty items, like "(Lower)", with indices less than
465 * insertIndex.
466 */
467 void TransliteratorIDParser::instantiateList(UVector& list,
468 UErrorCode& ec) {
469 UVector tlist(ec);
470 if (U_FAILURE(ec)) {
471 goto RETURN;
472 }
473 tlist.setDeleter(_deleteTransliteratorTrIDPars);
474
475 Transliterator* t;
476 int32_t i;
477 for (i=0; i<=list.size(); ++i) { // [sic]: i<=list.size()
478 // We run the loop too long by one, so we can
479 // do an insert after the last element
480 if (i==list.size()) {
481 break;
482 }
483
484 SingleID* single = (SingleID*) list.elementAt(i);
485 if (single->basicID.length() != 0) {
486 t = single->createInstance();
487 if (t == NULL) {
488 ec = U_INVALID_ID;
489 goto RETURN;
490 }
491 tlist.addElement(t, ec);
492 if (U_FAILURE(ec)) {
493 delete t;
494 goto RETURN;
495 }
496 }
497 }
498
499 // An empty list is equivalent to a NULL transliterator.
500 if (tlist.size() == 0) {
501 t = createBasicInstance(UnicodeString(TRUE, ANY_NULL, 8), NULL);
502 if (t == NULL) {
503 // Should never happen
504 ec = U_INTERNAL_TRANSLITERATOR_ERROR;
505 }
506 tlist.addElement(t, ec);
507 if (U_FAILURE(ec)) {
508 delete t;
509 }
510 }
511
512 RETURN:
513
514 UObjectDeleter *save = list.setDeleter(_deleteSingleID);
515 list.removeAllElements();
516
517 if (U_SUCCESS(ec)) {
518 list.setDeleter(_deleteTransliteratorTrIDPars);
519
520 while (tlist.size() > 0) {
521 t = (Transliterator*) tlist.orphanElementAt(0);
522 list.addElement(t, ec);
523 if (U_FAILURE(ec)) {
524 delete t;
525 list.removeAllElements();
526 break;
527 }
528 }
529 }
530
531 list.setDeleter(save);
532 }
533
534 /**
535 * Parse an ID into pieces. Take IDs of the form T, T/V, S-T,
536 * S-T/V, or S/V-T. If the source is missing, return a source of
537 * ANY.
538 * @param id the id string, in any of several forms
539 * @return an array of 4 strings: source, target, variant, and
540 * isSourcePresent. If the source is not present, ANY will be
541 * given as the source, and isSourcePresent will be NULL. Otherwise
542 * isSourcePresent will be non-NULL. The target may be empty if the
543 * id is not well-formed. The variant may be empty.
544 */
545 void TransliteratorIDParser::IDtoSTV(const UnicodeString& id,
546 UnicodeString& source,
547 UnicodeString& target,
548 UnicodeString& variant,
549 UBool& isSourcePresent) {
550 source.setTo(ANY, 3);
551 target.truncate(0);
552 variant.truncate(0);
553
554 int32_t sep = id.indexOf(TARGET_SEP);
555 int32_t var = id.indexOf(VARIANT_SEP);
556 if (var < 0) {
557 var = id.length();
558 }
559 isSourcePresent = FALSE;
560
561 if (sep < 0) {
562 // Form: T/V or T (or /V)
563 id.extractBetween(0, var, target);
564 id.extractBetween(var, id.length(), variant);
565 } else if (sep < var) {
566 // Form: S-T/V or S-T (or -T/V or -T)
567 if (sep > 0) {
568 id.extractBetween(0, sep, source);
569 isSourcePresent = TRUE;
570 }
571 id.extractBetween(++sep, var, target);
572 id.extractBetween(var, id.length(), variant);
573 } else {
574 // Form: (S/V-T or /V-T)
575 if (var > 0) {
576 id.extractBetween(0, var, source);
577 isSourcePresent = TRUE;
578 }
579 id.extractBetween(var, sep++, variant);
580 id.extractBetween(sep, id.length(), target);
581 }
582
583 if (variant.length() > 0) {
584 variant.remove(0, 1);
585 }
586 }
587
588 /**
589 * Given source, target, and variant strings, concatenate them into a
590 * full ID. If the source is empty, then "Any" will be used for the
591 * source, so the ID will always be of the form s-t/v or s-t.
592 */
593 void TransliteratorIDParser::STVtoID(const UnicodeString& source,
594 const UnicodeString& target,
595 const UnicodeString& variant,
596 UnicodeString& id) {
597 id = source;
598 if (id.length() == 0) {
599 id.setTo(ANY, 3);
600 }
601 id.append(TARGET_SEP).append(target);
602 if (variant.length() != 0) {
603 id.append(VARIANT_SEP).append(variant);
604 }
605 // NUL-terminate the ID string for getTerminatedBuffer.
606 // This prevents valgrind and Purify warnings.
607 id.append((UChar)0);
608 id.truncate(id.length()-1);
609 }
610
611 /**
612 * Register two targets as being inverses of one another. For
613 * example, calling registerSpecialInverse("NFC", "NFD", TRUE) causes
614 * Transliterator to form the following inverse relationships:
615 *
616 * <pre>NFC => NFD
617 * Any-NFC => Any-NFD
618 * NFD => NFC
619 * Any-NFD => Any-NFC</pre>
620 *
621 * (Without the special inverse registration, the inverse of NFC
622 * would be NFC-Any.) Note that NFD is shorthand for Any-NFD, but
623 * that the presence or absence of "Any-" is preserved.
624 *
625 * <p>The relationship is symmetrical; registering (a, b) is
626 * equivalent to registering (b, a).
627 *
628 * <p>The relevant IDs must still be registered separately as
629 * factories or classes.
630 *
631 * <p>Only the targets are specified. Special inverses always
632 * have the form Any-Target1 <=> Any-Target2. The target should
633 * have canonical casing (the casing desired to be produced when
634 * an inverse is formed) and should contain no whitespace or other
635 * extraneous characters.
636 *
637 * @param target the target against which to register the inverse
638 * @param inverseTarget the inverse of target, that is
639 * Any-target.getInverse() => Any-inverseTarget
640 * @param bidirectional if TRUE, register the reverse relation
641 * as well, that is, Any-inverseTarget.getInverse() => Any-target
642 */
643 void TransliteratorIDParser::registerSpecialInverse(const UnicodeString& target,
644 const UnicodeString& inverseTarget,
645 UBool bidirectional,
646 UErrorCode &status) {
647 init(status);
648 if (U_FAILURE(status)) {
649 return;
650 }
651
652 // If target == inverseTarget then force bidirectional => FALSE
653 if (bidirectional && 0==target.caseCompare(inverseTarget, U_FOLD_CASE_DEFAULT)) {
654 bidirectional = FALSE;
655 }
656
657 Mutex lock(&LOCK);
658
659 UnicodeString *tempus = new UnicodeString(inverseTarget); // Used for null pointer check before usage.
660 if (tempus == NULL) {
661 status = U_MEMORY_ALLOCATION_ERROR;
662 return;
663 }
664 SPECIAL_INVERSES->put(target, tempus, status);
665 if (bidirectional) {
666 tempus = new UnicodeString(target);
667 if (tempus == NULL) {
668 status = U_MEMORY_ALLOCATION_ERROR;
669 return;
670 }
671 SPECIAL_INVERSES->put(inverseTarget, tempus, status);
672 }
673 }
674
675 //----------------------------------------------------------------
676 // Private implementation
677 //----------------------------------------------------------------
678
679 /**
680 * Parse an ID into component pieces. Take IDs of the form T,
681 * T/V, S-T, S-T/V, or S/V-T. If the source is missing, return a
682 * source of ANY.
683 * @param id the id string, in any of several forms
684 * @param pos INPUT-OUTPUT parameter. On input, pos is the
685 * offset of the first character to parse in id. On output,
686 * pos is the offset after the last parsed character. If the
687 * parse failed, pos will be unchanged.
688 * @param allowFilter2 if TRUE, a UnicodeSet pattern is allowed
689 * at any location between specs or delimiters, and is returned
690 * as the fifth string in the array.
691 * @return a Specs object, or NULL if the parse failed. If
692 * neither source nor target was seen in the parsed id, then the
693 * parse fails. If allowFilter is TRUE, then the parsed filter
694 * pattern is returned in the Specs object, otherwise the returned
695 * filter reference is NULL. If the parse fails for any reason
696 * NULL is returned.
697 */
698 TransliteratorIDParser::Specs*
699 TransliteratorIDParser::parseFilterID(const UnicodeString& id, int32_t& pos,
700 UBool allowFilter) {
701 UnicodeString first;
702 UnicodeString source;
703 UnicodeString target;
704 UnicodeString variant;
705 UnicodeString filter;
706 UChar delimiter = 0;
707 int32_t specCount = 0;
708 int32_t start = pos;
709
710 // This loop parses one of the following things with each
711 // pass: a filter, a delimiter character (either '-' or '/'),
712 // or a spec (source, target, or variant).
713 for (;;) {
714 ICU_Utility::skipWhitespace(id, pos, TRUE);
715 if (pos == id.length()) {
716 break;
717 }
718
719 // Parse filters
720 if (allowFilter && filter.length() == 0 &&
721 UnicodeSet::resemblesPattern(id, pos)) {
722
723 ParsePosition ppos(pos);
724 UErrorCode ec = U_ZERO_ERROR;
725 UnicodeSet set(id, ppos, USET_IGNORE_SPACE, NULL, ec);
726 if (U_FAILURE(ec)) {
727 pos = start;
728 return NULL;
729 }
730 id.extractBetween(pos, ppos.getIndex(), filter);
731 pos = ppos.getIndex();
732 continue;
733 }
734
735 if (delimiter == 0) {
736 UChar c = id.charAt(pos);
737 if ((c == TARGET_SEP && target.length() == 0) ||
738 (c == VARIANT_SEP && variant.length() == 0)) {
739 delimiter = c;
740 ++pos;
741 continue;
742 }
743 }
744
745 // We are about to try to parse a spec with no delimiter
746 // when we can no longer do so (we can only do so at the
747 // start); break.
748 if (delimiter == 0 && specCount > 0) {
749 break;
750 }
751
752 UnicodeString spec = ICU_Utility::parseUnicodeIdentifier(id, pos);
753 if (spec.length() == 0) {
754 // Note that if there was a trailing delimiter, we
755 // consume it. So Foo-, Foo/, Foo-Bar/, and Foo/Bar-
756 // are legal.
757 break;
758 }
759
760 switch (delimiter) {
761 case 0:
762 first = spec;
763 break;
764 case TARGET_SEP:
765 target = spec;
766 break;
767 case VARIANT_SEP:
768 variant = spec;
769 break;
770 }
771 ++specCount;
772 delimiter = 0;
773 }
774
775 // A spec with no prior character is either source or target,
776 // depending on whether an explicit "-target" was seen.
777 if (first.length() != 0) {
778 if (target.length() == 0) {
779 target = first;
780 } else {
781 source = first;
782 }
783 }
784
785 // Must have either source or target
786 if (source.length() == 0 && target.length() == 0) {
787 pos = start;
788 return NULL;
789 }
790
791 // Empty source or target defaults to ANY
792 UBool sawSource = TRUE;
793 if (source.length() == 0) {
794 source.setTo(ANY, 3);
795 sawSource = FALSE;
796 }
797 if (target.length() == 0) {
798 target.setTo(ANY, 3);
799 }
800
801 return new Specs(source, target, variant, sawSource, filter);
802 }
803
804 /**
805 * Givens a Spec object, convert it to a SingleID object. The
806 * Spec object is a more unprocessed parse result. The SingleID
807 * object contains information about canonical and basic IDs.
808 * @return a SingleID; never returns NULL. Returned object always
809 * has 'filter' field of NULL.
810 */
811 TransliteratorIDParser::SingleID*
812 TransliteratorIDParser::specsToID(const Specs* specs, int32_t dir) {
813 UnicodeString canonID;
814 UnicodeString basicID;
815 UnicodeString basicPrefix;
816 if (specs != NULL) {
817 UnicodeString buf;
818 if (dir == FORWARD) {
819 if (specs->sawSource) {
820 buf.append(specs->source).append(TARGET_SEP);
821 } else {
822 basicPrefix = specs->source;
823 basicPrefix.append(TARGET_SEP);
824 }
825 buf.append(specs->target);
826 } else {
827 buf.append(specs->target).append(TARGET_SEP).append(specs->source);
828 }
829 if (specs->variant.length() != 0) {
830 buf.append(VARIANT_SEP).append(specs->variant);
831 }
832 basicID = basicPrefix;
833 basicID.append(buf);
834 if (specs->filter.length() != 0) {
835 buf.insert(0, specs->filter);
836 }
837 canonID = buf;
838 }
839 return new SingleID(canonID, basicID);
840 }
841
842 /**
843 * Given a Specs object, return a SingleID representing the
844 * special inverse of that ID. If there is no special inverse
845 * then return NULL.
846 * @return a SingleID or NULL. Returned object always has
847 * 'filter' field of NULL.
848 */
849 TransliteratorIDParser::SingleID*
850 TransliteratorIDParser::specsToSpecialInverse(const Specs& specs, UErrorCode &status) {
851 if (0!=specs.source.caseCompare(ANY, 3, U_FOLD_CASE_DEFAULT)) {
852 return NULL;
853 }
854 init(status);
855
856 UnicodeString* inverseTarget;
857
858 umtx_lock(&LOCK);
859 inverseTarget = (UnicodeString*) SPECIAL_INVERSES->get(specs.target);
860 umtx_unlock(&LOCK);
861
862 if (inverseTarget != NULL) {
863 // If the original ID contained "Any-" then make the
864 // special inverse "Any-Foo"; otherwise make it "Foo".
865 // So "Any-NFC" => "Any-NFD" but "NFC" => "NFD".
866 UnicodeString buf;
867 if (specs.filter.length() != 0) {
868 buf.append(specs.filter);
869 }
870 if (specs.sawSource) {
871 buf.append(ANY, 3).append(TARGET_SEP);
872 }
873 buf.append(*inverseTarget);
874
875 UnicodeString basicID(TRUE, ANY, 3);
876 basicID.append(TARGET_SEP).append(*inverseTarget);
877
878 if (specs.variant.length() != 0) {
879 buf.append(VARIANT_SEP).append(specs.variant);
880 basicID.append(VARIANT_SEP).append(specs.variant);
881 }
882 return new SingleID(buf, basicID);
883 }
884 return NULL;
885 }
886
887 /**
888 * Glue method to get around access problems in C++. This would
889 * ideally be inline but we want to avoid a circular header
890 * dependency.
891 */
892 Transliterator* TransliteratorIDParser::createBasicInstance(const UnicodeString& id, const UnicodeString* canonID) {
893 return Transliterator::createBasicInstance(id, canonID);
894 }
895
896 /**
897 * Initialize static memory.
898 */
899 void TransliteratorIDParser::init(UErrorCode &status) {
900 if (SPECIAL_INVERSES != NULL) {
901 return;
902 }
903
904 Hashtable* special_inverses = new Hashtable(TRUE, status);
905 // Null pointer check
906 if (special_inverses == NULL) {
907 status = U_MEMORY_ALLOCATION_ERROR;
908 return;
909 }
910 special_inverses->setValueDeleter(uprv_deleteUObject);
911
912 umtx_lock(&LOCK);
913 if (SPECIAL_INVERSES == NULL) {
914 SPECIAL_INVERSES = special_inverses;
915 special_inverses = NULL;
916 }
917 umtx_unlock(&LOCK);
918 delete special_inverses; /*null instance*/
919
920 ucln_i18n_registerCleanup(UCLN_I18N_TRANSLITERATOR, utrans_transliterator_cleanup);
921 }
922
923 /**
924 * Free static memory.
925 */
926 void TransliteratorIDParser::cleanup() {
927 if (SPECIAL_INVERSES) {
928 delete SPECIAL_INVERSES;
929 SPECIAL_INVERSES = NULL;
930 }
931 }
932
933 U_NAMESPACE_END
934
935 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
936
937 //eof

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial