summaryrefslogtreecommitdiff
path: root/lib/unicase/u-ct-totitle.h
diff options
context:
space:
mode:
Diffstat (limited to 'lib/unicase/u-ct-totitle.h')
-rw-r--r--lib/unicase/u-ct-totitle.h740
1 files changed, 370 insertions, 370 deletions
diff --git a/lib/unicase/u-ct-totitle.h b/lib/unicase/u-ct-totitle.h
index f0d4fd77..8892a5df 100644
--- a/lib/unicase/u-ct-totitle.h
+++ b/lib/unicase/u-ct-totitle.h
@@ -1,5 +1,5 @@
/* Titlecase mapping for UTF-8/UTF-16/UTF-32 substrings (locale dependent).
- Copyright (C) 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009-2010 Free Software Foundation, Inc.
Written by Bruno Haible <bruno@clisp.org>, 2009.
This program is free software: you can redistribute it and/or modify it
@@ -55,10 +55,10 @@ FUNC (const UNIT *s, size_t n,
{
wordbreaks = (char *) malloc (n);
if (wordbreaks == NULL)
- {
- errno = ENOMEM;
- goto fail2;
- }
+ {
+ errno = ENOMEM;
+ goto fail2;
+ }
U_WORDBREAKS (s, n, wordbreaks);
}
else
@@ -70,12 +70,12 @@ FUNC (const UNIT *s, size_t n,
/* When considering the string as segmented by word boundaries: For each
such segment:
- - In the first part, we are searching for the first cased character.
- In this state, in_word_first_part = true, and no conversion takes
- place.
- - In the second part, we are converting every character: the first
- among these characters to title case, the other ones to lower case.
- In this state, in_word_first_part = false. */
+ - In the first part, we are searching for the first cased character.
+ In this state, in_word_first_part = true, and no conversion takes
+ place.
+ - In the second part, we are converting every character: the first
+ among these characters to title case, the other ones to lower case.
+ In this state, in_word_first_part = false. */
bool in_word_first_part = true;
/* Helper for evaluating the FINAL_SIGMA condition:
@@ -90,356 +90,356 @@ FUNC (const UNIT *s, size_t n,
while (s < s_end)
{
- /* Fetch the next character. */
- ucs4_t uc;
- int count = U_MBTOUC_UNSAFE (&uc, s, s_end - s);
-
- ucs4_t (*single_character_map) (ucs4_t);
- size_t offset_in_rule; /* offset in 'struct special_casing_rule' */
-
- ucs4_t mapped_uc[3];
- unsigned int mapped_count;
-
- if (*wp)
- /* Crossing a word boundary. */
- in_word_first_part = true;
-
- /* Determine single_character_map, offset_in_rule.
- There are three possibilities:
- - uc should not be converted.
- - uc should be titlecased.
- - uc should be lowercased. */
- if (in_word_first_part)
- {
- if (uc_is_cased (uc))
- {
- /* uc is to be titlecased. */
- single_character_map = uc_totitle;
- offset_in_rule = offsetof (struct special_casing_rule, title[0]);
- in_word_first_part = false;
- }
- else
- {
- /* uc is not converted. */
- single_character_map = NULL;
- offset_in_rule = 0;
- }
- }
- else
- {
- /* uc is to be lowercased. */
- single_character_map = uc_tolower;
- offset_in_rule = offsetof (struct special_casing_rule, lower[0]);
- }
-
- /* Actually map uc. */
- if (single_character_map == NULL)
- {
- mapped_uc[0] = uc;
- mapped_count = 1;
- goto found_mapping;
- }
-
- if (uc < 0x10000)
- {
- /* Look first in the special-casing table. */
- char code[3];
-
- code[0] = (uc >> 8) & 0xff;
- code[1] = uc & 0xff;
-
- for (code[2] = 0; ; code[2]++)
- {
- const struct special_casing_rule *rule =
- gl_unicase_special_lookup (code, 3);
-
- if (rule == NULL)
- break;
-
- /* Test if the condition applies. */
- /* Does the language apply? */
- if (rule->language[0] == '\0'
- || (iso639_language != NULL
- && iso639_language[0] == rule->language[0]
- && iso639_language[1] == rule->language[1]))
- {
- /* Does the context apply? */
- int context = rule->context;
- bool applies;
-
- if (context < 0)
- context = - context;
- switch (context)
- {
- case SCC_ALWAYS:
- applies = true;
- break;
-
- case SCC_FINAL_SIGMA:
- /* "Before" condition: preceded by a sequence
- consisting of a cased letter and a case-ignorable
- sequence.
- "After" condition: not followed by a sequence
- consisting of a case-ignorable sequence and then a
- cased letter. */
- /* Test the "before" condition. */
- applies = uc_is_cased (last_char_except_ignorable);
- /* Test the "after" condition. */
- if (applies)
- {
- const UNIT *s2 = s + count;
- for (;;)
- {
- if (s2 < s_end)
- {
- ucs4_t uc2;
- int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
- /* Our uc_is_case_ignorable function is
- known to return false for all cased
- characters. So we can call
- uc_is_case_ignorable first. */
- if (!uc_is_case_ignorable (uc2))
- {
- applies = ! uc_is_cased (uc2);
- break;
- }
- s2 += count2;
- }
- else
- {
- applies = ! uc_is_cased (suffix_context.first_char_except_ignorable);
- break;
- }
- }
- }
- break;
-
- case SCC_AFTER_SOFT_DOTTED:
- /* "Before" condition: There is a Soft_Dotted character
- before it, with no intervening character of
- combining class 0 or 230 (Above). */
- /* Test the "before" condition. */
- applies = uc_is_property_soft_dotted (last_char_normal_or_above);
- break;
-
- case SCC_MORE_ABOVE:
- /* "After" condition: followed by a character of
- combining class 230 (Above) with no intervening
- character of combining class 0 or 230 (Above). */
- /* Test the "after" condition. */
- {
- const UNIT *s2 = s + count;
- applies = false;
- for (;;)
- {
- if (s2 < s_end)
- {
- ucs4_t uc2;
- int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
- int ccc = uc_combining_class (uc2);
- if (ccc == UC_CCC_A)
- {
- applies = true;
- break;
- }
- if (ccc == UC_CCC_NR)
- break;
- s2 += count2;
- }
- else
- {
- applies = ((suffix_context.bits & SCC_MORE_ABOVE_MASK) != 0);
- break;
- }
- }
- }
- break;
-
- case SCC_BEFORE_DOT:
- /* "After" condition: followed by COMBINING DOT ABOVE
- (U+0307). Any sequence of characters with a
- combining class that is neither 0 nor 230 may
- intervene between the current character and the
- combining dot above. */
- /* Test the "after" condition. */
- {
- const UNIT *s2 = s + count;
- applies = false;
- for (;;)
- {
- if (s2 < s_end)
- {
- ucs4_t uc2;
- int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
- if (uc2 == 0x0307) /* COMBINING DOT ABOVE */
- {
- applies = true;
- break;
- }
- {
- int ccc = uc_combining_class (uc2);
- if (ccc == UC_CCC_A || ccc == UC_CCC_NR)
- break;
- }
- s2 += count2;
- }
- else
- {
- applies = ((suffix_context.bits & SCC_BEFORE_DOT_MASK) != 0);
- break;
- }
- }
- }
- break;
-
- case SCC_AFTER_I:
- /* "Before" condition: There is an uppercase I before
- it, and there is no intervening character of
- combining class 0 or 230 (Above). */
- /* Test the "before" condition. */
- applies = (last_char_normal_or_above == 'I');
- break;
-
- default:
- abort ();
- }
- if (rule->context < 0)
- applies = !applies;
-
- if (applies)
- {
- /* The rule applies.
- Look up the mapping (0 to 3 characters). */
- const unsigned short *mapped_in_rule =
- (const unsigned short *)((const char *)rule + offset_in_rule);
-
- if (mapped_in_rule[0] == 0)
- mapped_count = 0;
- else
- {
- mapped_uc[0] = mapped_in_rule[0];
- if (mapped_in_rule[1] == 0)
- mapped_count = 1;
- else
- {
- mapped_uc[1] = mapped_in_rule[1];
- if (mapped_in_rule[2] == 0)
- mapped_count = 2;
- else
- {
- mapped_uc[2] = mapped_in_rule[2];
- mapped_count = 3;
- }
- }
- }
- goto found_mapping;
- }
- }
-
- /* Optimization: Save a hash table lookup in the next round. */
- if (!rule->has_next)
- break;
- }
- }
-
- /* No special-cased mapping. So use the locale and context independent
- mapping. */
- mapped_uc[0] = single_character_map (uc);
- mapped_count = 1;
+ /* Fetch the next character. */
+ ucs4_t uc;
+ int count = U_MBTOUC_UNSAFE (&uc, s, s_end - s);
+
+ ucs4_t (*single_character_map) (ucs4_t);
+ size_t offset_in_rule; /* offset in 'struct special_casing_rule' */
+
+ ucs4_t mapped_uc[3];
+ unsigned int mapped_count;
+
+ if (*wp)
+ /* Crossing a word boundary. */
+ in_word_first_part = true;
+
+ /* Determine single_character_map, offset_in_rule.
+ There are three possibilities:
+ - uc should not be converted.
+ - uc should be titlecased.
+ - uc should be lowercased. */
+ if (in_word_first_part)
+ {
+ if (uc_is_cased (uc))
+ {
+ /* uc is to be titlecased. */
+ single_character_map = uc_totitle;
+ offset_in_rule = offsetof (struct special_casing_rule, title[0]);
+ in_word_first_part = false;
+ }
+ else
+ {
+ /* uc is not converted. */
+ single_character_map = NULL;
+ offset_in_rule = 0;
+ }
+ }
+ else
+ {
+ /* uc is to be lowercased. */
+ single_character_map = uc_tolower;
+ offset_in_rule = offsetof (struct special_casing_rule, lower[0]);
+ }
+
+ /* Actually map uc. */
+ if (single_character_map == NULL)
+ {
+ mapped_uc[0] = uc;
+ mapped_count = 1;
+ goto found_mapping;
+ }
+
+ if (uc < 0x10000)
+ {
+ /* Look first in the special-casing table. */
+ char code[3];
+
+ code[0] = (uc >> 8) & 0xff;
+ code[1] = uc & 0xff;
+
+ for (code[2] = 0; ; code[2]++)
+ {
+ const struct special_casing_rule *rule =
+ gl_unicase_special_lookup (code, 3);
+
+ if (rule == NULL)
+ break;
+
+ /* Test if the condition applies. */
+ /* Does the language apply? */
+ if (rule->language[0] == '\0'
+ || (iso639_language != NULL
+ && iso639_language[0] == rule->language[0]
+ && iso639_language[1] == rule->language[1]))
+ {
+ /* Does the context apply? */
+ int context = rule->context;
+ bool applies;
+
+ if (context < 0)
+ context = - context;
+ switch (context)
+ {
+ case SCC_ALWAYS:
+ applies = true;
+ break;
+
+ case SCC_FINAL_SIGMA:
+ /* "Before" condition: preceded by a sequence
+ consisting of a cased letter and a case-ignorable
+ sequence.
+ "After" condition: not followed by a sequence
+ consisting of a case-ignorable sequence and then a
+ cased letter. */
+ /* Test the "before" condition. */
+ applies = uc_is_cased (last_char_except_ignorable);
+ /* Test the "after" condition. */
+ if (applies)
+ {
+ const UNIT *s2 = s + count;
+ for (;;)
+ {
+ if (s2 < s_end)
+ {
+ ucs4_t uc2;
+ int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
+ /* Our uc_is_case_ignorable function is
+ known to return false for all cased
+ characters. So we can call
+ uc_is_case_ignorable first. */
+ if (!uc_is_case_ignorable (uc2))
+ {
+ applies = ! uc_is_cased (uc2);
+ break;
+ }
+ s2 += count2;
+ }
+ else
+ {
+ applies = ! uc_is_cased (suffix_context.first_char_except_ignorable);
+ break;
+ }
+ }
+ }
+ break;
+
+ case SCC_AFTER_SOFT_DOTTED:
+ /* "Before" condition: There is a Soft_Dotted character
+ before it, with no intervening character of
+ combining class 0 or 230 (Above). */
+ /* Test the "before" condition. */
+ applies = uc_is_property_soft_dotted (last_char_normal_or_above);
+ break;
+
+ case SCC_MORE_ABOVE:
+ /* "After" condition: followed by a character of
+ combining class 230 (Above) with no intervening
+ character of combining class 0 or 230 (Above). */
+ /* Test the "after" condition. */
+ {
+ const UNIT *s2 = s + count;
+ applies = false;
+ for (;;)
+ {
+ if (s2 < s_end)
+ {
+ ucs4_t uc2;
+ int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
+ int ccc = uc_combining_class (uc2);
+ if (ccc == UC_CCC_A)
+ {
+ applies = true;
+ break;
+ }
+ if (ccc == UC_CCC_NR)
+ break;
+ s2 += count2;
+ }
+ else
+ {
+ applies = ((suffix_context.bits & SCC_MORE_ABOVE_MASK) != 0);
+ break;
+ }
+ }
+ }
+ break;
+
+ case SCC_BEFORE_DOT:
+ /* "After" condition: followed by COMBINING DOT ABOVE
+ (U+0307). Any sequence of characters with a
+ combining class that is neither 0 nor 230 may
+ intervene between the current character and the
+ combining dot above. */
+ /* Test the "after" condition. */
+ {
+ const UNIT *s2 = s + count;
+ applies = false;
+ for (;;)
+ {
+ if (s2 < s_end)
+ {
+ ucs4_t uc2;
+ int count2 = U_MBTOUC_UNSAFE (&uc2, s2, s_end - s2);
+ if (uc2 == 0x0307) /* COMBINING DOT ABOVE */
+ {
+ applies = true;
+ break;
+ }
+ {
+ int ccc = uc_combining_class (uc2);
+ if (ccc == UC_CCC_A || ccc == UC_CCC_NR)
+ break;
+ }
+ s2 += count2;
+ }
+ else
+ {
+ applies = ((suffix_context.bits & SCC_BEFORE_DOT_MASK) != 0);
+ break;
+ }
+ }
+ }
+ break;
+
+ case SCC_AFTER_I:
+ /* "Before" condition: There is an uppercase I before
+ it, and there is no intervening character of
+ combining class 0 or 230 (Above). */
+ /* Test the "before" condition. */
+ applies = (last_char_normal_or_above == 'I');
+ break;
+
+ default:
+ abort ();
+ }
+ if (rule->context < 0)
+ applies = !applies;
+
+ if (applies)
+ {
+ /* The rule applies.
+ Look up the mapping (0 to 3 characters). */
+ const unsigned short *mapped_in_rule =
+ (const unsigned short *)((const char *)rule + offset_in_rule);
+
+ if (mapped_in_rule[0] == 0)
+ mapped_count = 0;
+ else
+ {
+ mapped_uc[0] = mapped_in_rule[0];
+ if (mapped_in_rule[1] == 0)
+ mapped_count = 1;
+ else
+ {
+ mapped_uc[1] = mapped_in_rule[1];
+ if (mapped_in_rule[2] == 0)
+ mapped_count = 2;
+ else
+ {
+ mapped_uc[2] = mapped_in_rule[2];
+ mapped_count = 3;
+ }
+ }
+ }
+ goto found_mapping;
+ }
+ }
+
+ /* Optimization: Save a hash table lookup in the next round. */
+ if (!rule->has_next)
+ break;
+ }
+ }
+
+ /* No special-cased mapping. So use the locale and context independent
+ mapping. */
+ mapped_uc[0] = single_character_map (uc);
+ mapped_count = 1;
found_mapping:
- /* Found the mapping: uc maps to mapped_uc[0..mapped_count-1]. */
- {
- unsigned int i;
-
- for (i = 0; i < mapped_count; i++)
- {
- ucs4_t muc = mapped_uc[i];
-
- /* Append muc to the result accumulator. */
- if (length < allocated)
- {
- int ret = U_UCTOMB (result + length, muc, allocated - length);
- if (ret == -1)
- {
- errno = EINVAL;
- goto fail1;
- }
- if (ret >= 0)
- {
- length += ret;
- goto done_appending;
- }
- }
- {
- size_t old_allocated = allocated;
- size_t new_allocated = 2 * old_allocated;
- if (new_allocated < 64)
- new_allocated = 64;
- if (new_allocated < old_allocated) /* integer overflow? */
- abort ();
- {
- UNIT *larger_result;
- if (result == NULL)
- {
- larger_result = (UNIT *) malloc (new_allocated * sizeof (UNIT));
- if (larger_result == NULL)
- {
- errno = ENOMEM;
- goto fail1;
- }
- }
- else if (result == resultbuf)
- {
- larger_result = (UNIT *) malloc (new_allocated * sizeof (UNIT));
- if (larger_result == NULL)
- {
- errno = ENOMEM;
- goto fail1;
- }
- U_CPY (larger_result, resultbuf, length);
- }
- else
- {
- larger_result =
- (UNIT *) realloc (result, new_allocated * sizeof (UNIT));
- if (larger_result == NULL)
- {
- errno = ENOMEM;
- goto fail1;
- }
- }
- result = larger_result;
- allocated = new_allocated;
- {
- int ret = U_UCTOMB (result + length, muc, allocated - length);
- if (ret == -1)
- {
- errno = EINVAL;
- goto fail1;
- }
- if (ret < 0)
- abort ();
- length += ret;
- goto done_appending;
- }
- }
- }
- done_appending: ;
- }
- }
-
- if (!uc_is_case_ignorable (uc))
- last_char_except_ignorable = uc;
-
- {
- int ccc = uc_combining_class (uc);
- if (ccc == UC_CCC_A || ccc == UC_CCC_NR)
- last_char_normal_or_above = uc;
- }
-
- s += count;
- wp += count;
+ /* Found the mapping: uc maps to mapped_uc[0..mapped_count-1]. */
+ {
+ unsigned int i;
+
+ for (i = 0; i < mapped_count; i++)
+ {
+ ucs4_t muc = mapped_uc[i];
+
+ /* Append muc to the result accumulator. */
+ if (length < allocated)
+ {
+ int ret = U_UCTOMB (result + length, muc, allocated - length);
+ if (ret == -1)
+ {
+ errno = EINVAL;
+ goto fail1;
+ }
+ if (ret >= 0)
+ {
+ length += ret;
+ goto done_appending;
+ }
+ }
+ {
+ size_t old_allocated = allocated;
+ size_t new_allocated = 2 * old_allocated;
+ if (new_allocated < 64)
+ new_allocated = 64;
+ if (new_allocated < old_allocated) /* integer overflow? */
+ abort ();
+ {
+ UNIT *larger_result;
+ if (result == NULL)
+ {
+ larger_result = (UNIT *) malloc (new_allocated * sizeof (UNIT));
+ if (larger_result == NULL)
+ {
+ errno = ENOMEM;
+ goto fail1;
+ }
+ }
+ else if (result == resultbuf)
+ {
+ larger_result = (UNIT *) malloc (new_allocated * sizeof (UNIT));
+ if (larger_result == NULL)
+ {
+ errno = ENOMEM;
+ goto fail1;
+ }
+ U_CPY (larger_result, resultbuf, length);
+ }
+ else
+ {
+ larger_result =
+ (UNIT *) realloc (result, new_allocated * sizeof (UNIT));
+ if (larger_result == NULL)
+ {
+ errno = ENOMEM;
+ goto fail1;
+ }
+ }
+ result = larger_result;
+ allocated = new_allocated;
+ {
+ int ret = U_UCTOMB (result + length, muc, allocated - length);
+ if (ret == -1)
+ {
+ errno = EINVAL;
+ goto fail1;
+ }
+ if (ret < 0)
+ abort ();
+ length += ret;
+ goto done_appending;
+ }
+ }
+ }
+ done_appending: ;
+ }
+ }
+
+ if (!uc_is_case_ignorable (uc))
+ last_char_except_ignorable = uc;
+
+ {
+ int ccc = uc_combining_class (uc);
+ if (ccc == UC_CCC_A || ccc == UC_CCC_NR)
+ last_char_normal_or_above = uc;
+ }
+
+ s += count;
+ wp += count;
}
}
@@ -452,7 +452,7 @@ FUNC (const UNIT *s, size_t n,
normalized_result = U_NORMALIZE (nf, result, length, resultbuf, lengthp);
if (normalized_result == NULL)
- goto fail2;
+ goto fail2;
free (result);
return normalized_result;
@@ -461,15 +461,15 @@ FUNC (const UNIT *s, size_t n,
if (length == 0)
{
if (result == NULL)
- {
- /* Return a non-NULL value. NULL means error. */
- result = (UNIT *) malloc (1);
- if (result == NULL)
- {
- errno = ENOMEM;
- goto fail2;
- }
- }
+ {
+ /* Return a non-NULL value. NULL means error. */
+ result = (UNIT *) malloc (1);
+ if (result == NULL)
+ {
+ errno = ENOMEM;
+ goto fail2;
+ }
+ }
}
else if (result != resultbuf && length < allocated)
{
@@ -478,7 +478,7 @@ FUNC (const UNIT *s, size_t n,
memory = (UNIT *) realloc (result, length * sizeof (UNIT));
if (memory != NULL)
- result = memory;
+ result = memory;
}
*lengthp = length;