[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
bug#24603: [PATCHv6 6/6] Implement special sigma casing rule (bug#24603)
From: |
Michal Nazarewicz |
Subject: |
bug#24603: [PATCHv6 6/6] Implement special sigma casing rule (bug#24603) |
Date: |
Tue, 21 Mar 2017 02:27:09 +0100 |
In Greek, a sigma character has two lower case forms which depend on
their position in the word. Implement logic determining it.
* src/casefiddle.c (struct casing_context, case_character_impl): Don’t
assume inword is true when flag is CASE_UP and false when flag is
CASE_DOWN. For final sigma detection we need this information tracked
reliably;.
(CAPITAL_SIGMA, SMALL_SIGMA, SMALL_FINAL_SIGMA): New macros defining
Unicode code point of different forms of sigma letter.
(case_character): Implement support for final sigma casing.
(do_casify_multibyte_string, do_casify_multibyte_region): Update after
changes to case_character.
* test/src/casefiddle-tests.el (casefiddle-tests-casing): Add test
cases for final sigma.
---
etc/NEWS | 5 +++
src/casefiddle.c | 73 +++++++++++++++++++++++++++++++++-----------
test/src/casefiddle-tests.el | 15 +++++----
3 files changed, 69 insertions(+), 24 deletions(-)
diff --git a/etc/NEWS b/etc/NEWS
index af1981b1453..fb5cc6095bb 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -367,6 +367,11 @@ of incorrect DŽungla).
*** Characters which turn into multiple ones when cased are correctly handled.
For example, fi ligature is converted to FI when upper cased.
+*** Greek small sigma is correctly handled when at the end of the word.
+Strings such as ΌΣΟΣ are now correctly converted to Όσος when
+capitalized instead of incorrect Όσοσ (compare lowercase sigma at the
+end of the word).
+
* Changes in Specialized Modes and Packages in Emacs 26.1
diff --git a/src/casefiddle.c b/src/casefiddle.c
index df94c970539..8a47641c4bb 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -45,9 +45,7 @@ struct casing_context {
When run on a buffer, syntax_prefix_flag_p is taken into account when
determined inword flag. */
bool inbuffer;
- /* Conceptually, this denotes whether we are inside of a word except
- that if flag is CASE_UP it’s always false and if flag is CASE_DOWN
- this is always true. */
+ /* Whether we are inside of a word. */
bool inword;
};
@@ -58,7 +56,7 @@ prepare_casing_context (struct casing_context *ctx,
{
ctx->flag = flag;
ctx->inbuffer = inbuffer;
- ctx->inword = flag == CASE_DOWN;
+ ctx->inword = false;
ctx->titlecase_char_table = (int)flag < (int)CASE_CAPITALIZE ? Qnil :
uniprop_table (intern_c_string ("titlecase"));
ctx->specialcase_char_tables[CASE_UP] = flag == CASE_DOWN ? Qnil :
@@ -100,15 +98,16 @@ case_character_impl (struct casing_str_buf *buf,
/* Update inword state */
was_inword = ctx->inword;
- if ((int) ctx->flag >= (int) CASE_CAPITALIZE)
- ctx->inword = SYNTAX (ch) == Sword &&
- (!ctx->inbuffer || was_inword || !syntax_prefix_flag_p (ch));
+ ctx->inword = SYNTAX (ch) == Sword &&
+ (!ctx->inbuffer || was_inword || !syntax_prefix_flag_p (ch));
/* Normalise flag so its one of CASE_UP, CASE_DOWN or CASE_CAPITALIZE. */
- if (!was_inword)
- flag = ctx->flag == CASE_UP ? CASE_UP : CASE_CAPITALIZE;
+ if (ctx->flag == CASE_CAPITALIZE)
+ flag = (enum case_action)((int)ctx->flag - was_inword);
else if (ctx->flag != CASE_CAPITALIZE_UP)
- flag = CASE_DOWN;
+ flag = ctx->flag;
+ else if (!was_inword)
+ flag = CASE_CAPITALIZE;
else
{
cased = ch;
@@ -149,7 +148,18 @@ case_character_impl (struct casing_str_buf *buf,
buf->len_bytes = CHAR_STRING (cased, buf->data);
return cased != ch;
}
+
+/* In Greek, lower case sigma has two forms: one when used in the middle and
one
+ when used at the end of a word. Below is to help handle those cases when
+ casing.
+
+ The rule does not conflict with any other casing rules so while it is
+ a conditional one, it is independent on language. */
+#define CAPITAL_SIGMA 0x03A3
+#define SMALL_SIGMA 0x03C3
+#define SMALL_FINAL_SIGMA 0x03C2
+
/* Based on CTX, case character CH accordingly. Update CTX as necessary.
Return cased character.
@@ -163,12 +173,34 @@ case_single_character (struct casing_context *ctx, int ch)
}
/* Save in BUF result of casing character CH. Return whether casing changed
the
- character. This is like case_single_character but also handles one-to-many
- casing rules. */
-static inline bool
-case_character (struct casing_str_buf *buf, struct casing_context *ctx, int ch)
+ character.
+
+ If not-NULL, NEXT points to the next character in the cased string. If
NULL,
+ it is assumed current character is the last one being cased. This is used
to
+ apply some rules which depend on proceeding state.
+
+ This is like case_single_character but also handles one-to-many casing
+ rules. */
+static bool
+case_character (struct casing_str_buf *buf, struct casing_context *ctx,
+ int ch, const unsigned char *next)
{
- return case_character_impl (buf, ctx, ch);
+ bool changed, was_inword;
+
+ was_inword = ctx->inword;
+ changed = case_character_impl (buf, ctx, ch);
+
+ /* If we have just down-cased a capital sigma and the next character no
longer
+ has a word syntax (i.e. current character is end of word), use final
+ sigma. */
+ if (was_inword && ch == CAPITAL_SIGMA && changed &&
+ (!next || SYNTAX (STRING_CHAR (next)) != Sword))
+ {
+ buf->len_bytes = CHAR_STRING (SMALL_FINAL_SIGMA, buf->data);
+ buf->len_chars = 1;
+ }
+
+ return changed;
}
static Lisp_Object
@@ -230,7 +262,7 @@ do_casify_multibyte_string (struct casing_context *ctx,
Lisp_Object obj)
if (dst_end - o < sizeof(struct casing_str_buf))
string_overflow ();
ch = STRING_CHAR_ADVANCE (src);
- case_character ((void *)o, ctx, ch);
+ case_character ((void *)o, ctx, ch, size > 1 ? src : NULL);
n += ((struct casing_str_buf *)o)->len_chars;
o += ((struct casing_str_buf *)o)->len_bytes;
}
@@ -381,12 +413,17 @@ do_casify_multibyte_region (struct casing_context *ctx,
ptrdiff_t pos = *startp, pos_byte = CHAR_TO_BYTE (pos), size = *endp - pos;
ptrdiff_t opoint = PT, added = 0;
struct casing_str_buf buf;
- int ch, cased, len;
+ bool changed;
+ int ch, len;
for (; size; --size)
{
ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (pos_byte), len);
- if (!case_character (&buf, ctx, ch))
+ changed = case_character (
+ &buf, ctx, ch,
+ size > 1 ? BYTE_POS_ADDR (pos_byte + len) : NULL);
+
+ if (!changed)
{
pos_byte += len;
++pos;
diff --git a/test/src/casefiddle-tests.el b/test/src/casefiddle-tests.el
index dd260633f4c..234d233c71a 100644
--- a/test/src/casefiddle-tests.el
+++ b/test/src/casefiddle-tests.el
@@ -195,13 +195,16 @@ casefiddle-tests--test-casing
("define" "DEFINE" "define" "Define" "Define")
("fish" "FISH" "fish" "Fish" "Fish")
("Straße" "STRASSE" "straße" "Straße" "Straße")
- ;; FIXME(bug#24603): Everything below is broken at the moment.
- ;; Here’s what should happen:
- ;;("ΌΣΟΣ" "ΌΣΟΣ" "όσος" "Όσος" "Όσος")
- ;; And here’s what is actually happening:
- ("ΌΣΟΣ" "ΌΣΟΣ" "όσοσ" "Όσοσ" "ΌΣΟΣ")
- ("όσος" "ΌΣΟΣ" "όσος" "Όσος" "Όσος"))))))
+ ;; The word repeated twice to test behaviour at the end of a word
+ ;; inside of an input string as well as at the end of the string.
+ ("ΌΣΟΣ ΌΣΟΣ" "ΌΣΟΣ ΌΣΟΣ" "όσος όσος" "Όσος Όσος" "ΌΣΟΣ ΌΣΟΣ")
+ ;; What should be done with sole sigma? It is ‘final’ but on the
+ ;; other hand it does not form a word. We’re using regular sigma.
+ ("Σ Σ" "Σ Σ" "σ σ" "Σ Σ" "Σ Σ")
+ ("όσος" "ΌΣΟΣ" "όσος" "Όσος" "Όσος")
+ ;; If sigma is already lower case, we don’t want to change it.
+ ("όσοσ" "ΌΣΟΣ" "όσοσ" "Όσοσ" "Όσοσ"))))))
(ert-deftest casefiddle-tests-casing-byte8 ()
(should-not
--
2.12.0.367.g23dc2f6d3c-goog
- bug#24603: [PATCHv5 11/11] Implement Irish casing rules (bug#24603), (continued)
bug#24603: [PATCHv5 05/11] Support casing characters which map into multiple code points (bug#24603), Michal Nazarewicz, 2017/03/09
bug#24603: [PATCHv5 00/11] Casing improvements, Eli Zaretskii, 2017/03/11
bug#24603: [PATCHv6 0/6] Casing improvements, language-independent part, Michal Nazarewicz, 2017/03/20
- bug#24603: [PATCHv6 3/6] Add support for title-casing letters (bug#24603), Michal Nazarewicz, 2017/03/20
- bug#24603: [PATCHv6 1/6] Split casify_object into multiple functions, Michal Nazarewicz, 2017/03/20
- bug#24603: [PATCHv6 6/6] Implement special sigma casing rule (bug#24603),
Michal Nazarewicz <=
- bug#24603: [PATCHv6 4/6] Split up casify_region function (bug#24603), Michal Nazarewicz, 2017/03/20
- bug#24603: [PATCHv6 2/6] Introduce case_character function, Michal Nazarewicz, 2017/03/20
- bug#24603: [PATCHv6 5/6] Support casing characters which map into multiple code points (bug#24603), Michal Nazarewicz, 2017/03/20