[pango/bidi-stack-size: 9/11] Revert "Split pango_default_break into functions"
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [pango/bidi-stack-size: 9/11] Revert "Split pango_default_break into functions"
- Date: Fri, 30 Jul 2021 13:06:30 +0000 (UTC)
commit d16db0d6730ac4f93f6557bd01f3ba5fa75264a3
Author: Matthias Clasen <mclasen redhat com>
Date: Wed Jul 28 14:47:36 2021 -0400
Revert "Split pango_default_break into functions"
This reverts commit a7aeaf146761fd3136e56153216e102ed2dfb868.
pango/break.c | 814 ++++++++++++++++++++++++----------------------------------
1 file changed, 342 insertions(+), 472 deletions(-)
---
diff --git a/pango/break.c b/pango/break.c
index 00290a59..b9cf3cae 100644
--- a/pango/break.c
+++ b/pango/break.c
@@ -138,13 +138,225 @@ typedef enum
WordNumbers
} WordType;
- __attribute__((noinline))
-static void
-determine_whitespace (gunichar wc,
- GUnicodeType type,
- PangoLogAttr *attrs,
- int i)
+
+/**
+ * pango_default_break:
+ * @text: text to break. Must be valid UTF-8
+ * @length: length of text in bytes (may be -1 if @text is nul-terminated)
+ * @analysis: (nullable): a `PangoAnalysis` structure for the @text
+ * @attrs: logical attributes to fill in
+ * @attrs_len: size of the array passed as @attrs
+ *
+ * This is the default break algorithm.
+ *
+ * It applies Unicode rules without language-specific
+ * tailoring, therefore the @analyis argument is unused
+ * and can be %NULL.
+ *
+ * See [func@Pango.tailor_break] for language-specific breaks.
+ */
+void
+pango_default_break (const gchar *text,
+ gint length,
+ PangoAnalysis *analysis G_GNUC_UNUSED,
+ PangoLogAttr *attrs,
+ int attrs_len G_GNUC_UNUSED)
{
+ /* The rationale for all this is in section 5.15 of the Unicode 3.0 book,
+ * the line breaking stuff is also in TR14 on unicode.org
+ */
+
+ /* This is a default break implementation that should work for nearly all
+ * languages. Language engines can override it optionally.
+ */
+
+ /* FIXME one cheesy optimization here would be to memset attrs to 0
+ * before we start, and then never assign %FALSE to anything
+ */
+
+ const gchar *next;
+ gint i;
+
+ gunichar prev_wc;
+ gunichar next_wc;
+
+ JamoType prev_jamo;
+
+ GUnicodeBreakType next_break_type;
+ GUnicodeBreakType prev_break_type;
+ GUnicodeBreakType prev_prev_break_type;
+
+ /* See Grapheme_Cluster_Break Property Values table of UAX#29 */
+ typedef enum
+ {
+ GB_Other,
+ GB_ControlCRLF,
+ GB_Extend,
+ GB_ZWJ,
+ GB_Prepend,
+ GB_SpacingMark,
+ GB_InHangulSyllable, /* Handles all of L, V, T, LV, LVT rules */
+ /* Use state machine to handle emoji sequence */
+ /* Rule GB12 and GB13 */
+ GB_RI_Odd, /* Meets odd number of RI */
+ GB_RI_Even, /* Meets even number of RI */
+ } GraphemeBreakType;
+ GraphemeBreakType prev_GB_type = GB_Other;
+ gboolean met_Extended_Pictographic = FALSE;
+
+ /* See Word_Break Property Values table of UAX#29 */
+ typedef enum
+ {
+ WB_Other,
+ WB_NewlineCRLF,
+ WB_ExtendFormat,
+ WB_Katakana,
+ WB_Hebrew_Letter,
+ WB_ALetter,
+ WB_MidNumLet,
+ WB_MidLetter,
+ WB_MidNum,
+ WB_Numeric,
+ WB_ExtendNumLet,
+ WB_RI_Odd,
+ WB_RI_Even,
+ WB_WSegSpace,
+ } WordBreakType;
+ WordBreakType prev_prev_WB_type = WB_Other, prev_WB_type = WB_Other;
+ gint prev_WB_i = -1;
+
+ /* See Sentence_Break Property Values table of UAX#29 */
+ typedef enum
+ {
+ SB_Other,
+ SB_ExtendFormat,
+ SB_ParaSep,
+ SB_Sp,
+ SB_Lower,
+ SB_Upper,
+ SB_OLetter,
+ SB_Numeric,
+ SB_ATerm,
+ SB_SContinue,
+ SB_STerm,
+ SB_Close,
+ /* Rules SB8 and SB8a */
+ SB_ATerm_Close_Sp,
+ SB_STerm_Close_Sp,
+ } SentenceBreakType;
+ SentenceBreakType prev_prev_SB_type = SB_Other, prev_SB_type = SB_Other;
+ gint prev_SB_i = -1;
+
+ /* Rule LB25 with Example 7 of Customization */
+ typedef enum
+ {
+ LB_Other,
+ LB_Numeric,
+ LB_Numeric_Close,
+ LB_RI_Odd,
+ LB_RI_Even,
+ } LineBreakType;
+ LineBreakType prev_LB_type = LB_Other;
+
+ WordType current_word_type = WordNone;
+ gunichar last_word_letter = 0;
+ gunichar base_character = 0;
+
+ gint last_sentence_start = -1;
+ gint last_non_space = -1;
+
+ gboolean almost_done = FALSE;
+ gboolean done = FALSE;
+
+ g_return_if_fail (length == 0 || text != NULL);
+ g_return_if_fail (attrs != NULL);
+
+ next = text;
+
+ prev_break_type = G_UNICODE_BREAK_UNKNOWN;
+ prev_prev_break_type = G_UNICODE_BREAK_UNKNOWN;
+ prev_wc = 0;
+ prev_jamo = NO_JAMO;
+
+ if (length == 0 || *text == '\0')
+ {
+ next_wc = PARAGRAPH_SEPARATOR;
+ almost_done = TRUE;
+ }
+ else
+ next_wc = g_utf8_get_char (next);
+
+ next_break_type = g_unichar_break_type (next_wc);
+ next_break_type = BREAK_TYPE_SAFE (next_break_type);
+
+ for (i = 0; !done ; i++)
+ {
+ GUnicodeType type;
+ gunichar wc;
+ GUnicodeBreakType break_type;
+ GUnicodeBreakType row_break_type;
+ BreakOpportunity break_op;
+ JamoType jamo;
+ gboolean makes_hangul_syllable;
+
+ /* UAX#29 boundaries */
+ gboolean is_grapheme_boundary;
+ gboolean is_word_boundary;
+ gboolean is_sentence_boundary;
+
+ /* Emoji extended pictographics */
+ gboolean is_Extended_Pictographic;
+
+ gboolean can_break;
+
+ wc = next_wc;
+ break_type = next_break_type;
+
+ if (almost_done)
+ {
+ /*
+ * If we have already reached the end of @text g_utf8_next_char()
+ * may not increment next
+ */
+ next_wc = 0;
+ next_break_type = G_UNICODE_BREAK_UNKNOWN;
+ done = TRUE;
+ }
+ else
+ {
+ next = g_utf8_next_char (next);
+
+ if ((length >= 0 && next >= text + length) || *next == '\0')
+ {
+ /* This is how we fill in the last element (end position) of the
+ * attr array - assume there's a paragraph separators off the end
+ * of @text.
+ */
+ next_wc = PARAGRAPH_SEPARATOR;
+ almost_done = TRUE;
+ }
+ else
+ next_wc = g_utf8_get_char (next);
+
+ next_break_type = g_unichar_break_type (next_wc);
+ next_break_type = BREAK_TYPE_SAFE (next_break_type);
+ }
+
+ type = g_unichar_type (wc);
+ jamo = JAMO_TYPE (break_type);
+
+ /* Determine wheter this forms a Hangul syllable with prev. */
+ if (jamo == NO_JAMO)
+ makes_hangul_syllable = FALSE;
+ else
+ {
+ JamoType prev_end = HangulJamoProps[prev_jamo].end ;
+ JamoType this_start = HangulJamoProps[ jamo].start;
+
+ /* See comments before IS_JAMO */
+ makes_hangul_syllable = (prev_end == this_start) || (prev_end + 1 == this_start);
+ }
+
switch (type)
{
case G_UNICODE_SPACE_SEPARATOR:
@@ -167,39 +379,14 @@ determine_whitespace (gunichar wc,
attrs[i].is_expandable_space = FALSE;
break;
}
-}
- /* See Grapheme_Cluster_Break Property Values table of UAX#29 */
- typedef enum
- {
- GB_Other,
- GB_ControlCRLF,
- GB_Extend,
- GB_ZWJ,
- GB_Prepend,
- GB_SpacingMark,
- GB_InHangulSyllable, /* Handles all of L, V, T, LV, LVT rules */
- /* Use state machine to handle emoji sequence */
- /* Rule GB12 and GB13 */
- GB_RI_Odd, /* Meets odd number of RI */
- GB_RI_Even, /* Meets even number of RI */
- } GraphemeBreakType;
+ is_Extended_Pictographic =
+ _pango_Is_Emoji_Extended_Pictographic (wc);
+
/* ---- UAX#29 Grapheme Boundaries ---- */
- __attribute__((noinline))
-static void
-determine_grapheme_boundaries (gunichar wc,
- GUnicodeType type,
- gunichar prev_wc,
- gboolean makes_hangul_syllable,
- gboolean is_Extended_Pictographic,
- gboolean *met_Extended_Pictographic,
- GraphemeBreakType *prev_GB_type,
- PangoLogAttr *attrs,
- int i)
{
GraphemeBreakType GB_type;
- gboolean is_grapheme_boundary;
/* Find the GraphemeBreakType of wc */
GB_type = GB_Other;
@@ -285,9 +472,9 @@ determine_grapheme_boundaries (gunichar wc,
case G_UNICODE_OTHER_SYMBOL:
if (G_UNLIKELY(wc >=0x1F1E6 && wc <=0x1F1FF))
{
- if (*prev_GB_type == GB_RI_Odd)
+ if (prev_GB_type == GB_RI_Odd)
GB_type = GB_RI_Even;
- else if (*prev_GB_type == GB_RI_Even)
+ else if (prev_GB_type == GB_RI_Even)
GB_type = GB_RI_Odd;
else
GB_type = GB_RI_Odd;
@@ -302,20 +489,20 @@ determine_grapheme_boundaries (gunichar wc,
break;
}
- /* Rule GB11 */
- if (*met_Extended_Pictographic)
+ /* Rule GB11 */
+ if (met_Extended_Pictographic)
{
if (GB_type == GB_Extend)
- *met_Extended_Pictographic = TRUE;
+ met_Extended_Pictographic = TRUE;
else if (_pango_Is_Emoji_Extended_Pictographic (prev_wc) &&
GB_type == GB_ZWJ)
- *met_Extended_Pictographic = TRUE;
- else if (*prev_GB_type == GB_Extend && GB_type == GB_ZWJ)
- *met_Extended_Pictographic = TRUE;
- else if (*prev_GB_type == GB_ZWJ && is_Extended_Pictographic)
- *met_Extended_Pictographic = TRUE;
+ met_Extended_Pictographic = TRUE;
+ else if (prev_GB_type == GB_Extend && GB_type == GB_ZWJ)
+ met_Extended_Pictographic = TRUE;
+ else if (prev_GB_type == GB_ZWJ && is_Extended_Pictographic)
+ met_Extended_Pictographic = TRUE;
else
- *met_Extended_Pictographic = FALSE;
+ met_Extended_Pictographic = FALSE;
}
/* Grapheme Cluster Boundary Rules */
@@ -324,7 +511,7 @@ determine_grapheme_boundaries (gunichar wc,
/* We apply Rules GB1 and GB2 at the end of the function */
if (wc == '\n' && prev_wc == '\r')
is_grapheme_boundary = FALSE; /* Rule GB3 */
- else if (*prev_GB_type == GB_ControlCRLF || GB_type == GB_ControlCRLF)
+ else if (prev_GB_type == GB_ControlCRLF || GB_type == GB_ControlCRLF)
is_grapheme_boundary = TRUE; /* Rules GB4 and GB5 */
else if (GB_type == GB_InHangulSyllable)
is_grapheme_boundary = FALSE; /* Rules GB6, GB7, GB8 */
@@ -334,34 +521,23 @@ determine_grapheme_boundaries (gunichar wc,
is_grapheme_boundary = FALSE; /* Rule GB9 */
else if (GB_type == GB_SpacingMark)
is_grapheme_boundary = FALSE; /* Rule GB9a */
- else if (*prev_GB_type == GB_Prepend)
+ else if (prev_GB_type == GB_Prepend)
is_grapheme_boundary = FALSE; /* Rule GB9b */
else if (is_Extended_Pictographic)
{ /* Rule GB11 */
- if (*prev_GB_type == GB_ZWJ && *met_Extended_Pictographic)
+ if (prev_GB_type == GB_ZWJ && met_Extended_Pictographic)
is_grapheme_boundary = FALSE;
}
- else if (*prev_GB_type == GB_RI_Odd && GB_type == GB_RI_Even)
+ else if (prev_GB_type == GB_RI_Odd && GB_type == GB_RI_Even)
is_grapheme_boundary = FALSE; /* Rule GB12 and GB13 */
if (is_Extended_Pictographic)
- *met_Extended_Pictographic = TRUE;
+ met_Extended_Pictographic = TRUE;
attrs[i].is_cursor_position = is_grapheme_boundary;
-
- *prev_GB_type = GB_type;
- }
-
- __attribute__((noinline))
-static void
-determine_backspace (gunichar prev_wc,
- gunichar base_character,
- PangoLogAttr *attrs,
- int i)
-{
/* If this is a grapheme boundary, we have to decide if backspace
* deletes a character or the whole grapheme cluster */
- if (attrs[i].is_cursor_position)
+ if (is_grapheme_boundary)
{
attrs[i].backspace_deletes_character = BACKSPACE_DELETES_CHARACTER (base_character);
@@ -372,46 +548,14 @@ determine_backspace (gunichar prev_wc,
}
else
attrs[i].backspace_deletes_character = FALSE;
-}
- /* See Word_Break Property Values table of UAX#29 */
- typedef enum
- {
- WB_Other,
- WB_NewlineCRLF,
- WB_ExtendFormat,
- WB_Katakana,
- WB_Hebrew_Letter,
- WB_ALetter,
- WB_MidNumLet,
- WB_MidLetter,
- WB_MidNum,
- WB_Numeric,
- WB_ExtendNumLet,
- WB_RI_Odd,
- WB_RI_Even,
- WB_WSegSpace,
- } WordBreakType;
+ prev_GB_type = GB_type;
+ }
/* ---- UAX#29 Word Boundaries ---- */
- __attribute__((noinline))
-static void
-determine_word_boundaries (gunichar wc,
- GUnicodeType type,
- GUnicodeBreakType break_type,
- gunichar prev_wc,
- gboolean is_Extended_Pictographic,
- WordBreakType *prev_WB_type,
- int *prev_WB_i,
- WordBreakType *prev_prev_WB_type,
- PangoLogAttr *attrs,
- int i)
{
- gboolean is_word_boundary;
-
is_word_boundary = FALSE;
-
- if (attrs[i].is_cursor_position ||
+ if (is_grapheme_boundary ||
G_UNLIKELY(wc >=0x1F1E6 && wc <=0x1F1FF)) /* Rules WB3 and WB4 */
{
PangoScript script;
@@ -511,7 +655,7 @@ determine_word_boundaries (gunichar wc,
if (G_UNLIKELY(wc >= 0x1F1E6 && wc <= 0x1F1FF))
{
- if (*prev_WB_type == WB_RI_Odd)
+ if (prev_WB_type == WB_RI_Odd)
WB_type = WB_RI_Even;
else
WB_type = WB_RI_Odd;
@@ -556,8 +700,8 @@ determine_word_boundaries (gunichar wc,
/* We apply Rules WB1 and WB2 at the end of the function */
if (prev_wc == 0x3031 && wc == 0x41)
- g_debug ("Y %d %d", *prev_WB_type, WB_type);
- if (*prev_WB_type == WB_NewlineCRLF && *prev_WB_i + 1 == i)
+ g_debug ("Y %d %d", prev_WB_type, WB_type);
+ if (prev_WB_type == WB_NewlineCRLF && prev_WB_i + 1 == i)
{
/* The extra check for prev_WB_i is to correctly handle sequences like
* Newline ÷ Extend × Extend
@@ -569,116 +713,80 @@ determine_word_boundaries (gunichar wc,
is_word_boundary = TRUE; /* Rule WB3b */
else if (prev_wc == 0x200D && is_Extended_Pictographic)
is_word_boundary = FALSE; /* Rule WB3c */
- else if (*prev_WB_type == WB_WSegSpace &&
- WB_type == WB_WSegSpace && *prev_WB_i + 1 == i)
+ else if (prev_WB_type == WB_WSegSpace &&
+ WB_type == WB_WSegSpace && prev_WB_i + 1 == i)
is_word_boundary = FALSE; /* Rule WB3d */
else if (WB_type == WB_ExtendFormat)
is_word_boundary = FALSE; /* Rules WB4? */
- else if ((*prev_WB_type == WB_ALetter ||
- *prev_WB_type == WB_Hebrew_Letter ||
- *prev_WB_type == WB_Numeric) &&
+ else if ((prev_WB_type == WB_ALetter ||
+ prev_WB_type == WB_Hebrew_Letter ||
+ prev_WB_type == WB_Numeric) &&
(WB_type == WB_ALetter ||
WB_type == WB_Hebrew_Letter ||
WB_type == WB_Numeric))
is_word_boundary = FALSE; /* Rules WB5, WB8, WB9, WB10 */
- else if (*prev_WB_type == WB_Katakana && WB_type == WB_Katakana)
+ else if (prev_WB_type == WB_Katakana && WB_type == WB_Katakana)
is_word_boundary = FALSE; /* Rule WB13 */
- else if ((*prev_WB_type == WB_ALetter ||
- *prev_WB_type == WB_Hebrew_Letter ||
- *prev_WB_type == WB_Numeric ||
- *prev_WB_type == WB_Katakana ||
- *prev_WB_type == WB_ExtendNumLet) &&
+ else if ((prev_WB_type == WB_ALetter ||
+ prev_WB_type == WB_Hebrew_Letter ||
+ prev_WB_type == WB_Numeric ||
+ prev_WB_type == WB_Katakana ||
+ prev_WB_type == WB_ExtendNumLet) &&
WB_type == WB_ExtendNumLet)
is_word_boundary = FALSE; /* Rule WB13a */
- else if (*prev_WB_type == WB_ExtendNumLet &&
+ else if (prev_WB_type == WB_ExtendNumLet &&
(WB_type == WB_ALetter ||
WB_type == WB_Hebrew_Letter ||
WB_type == WB_Numeric ||
WB_type == WB_Katakana))
is_word_boundary = FALSE; /* Rule WB13b */
- else if (((*prev_prev_WB_type == WB_ALetter ||
- *prev_prev_WB_type == WB_Hebrew_Letter) &&
+ else if (((prev_prev_WB_type == WB_ALetter ||
+ prev_prev_WB_type == WB_Hebrew_Letter) &&
(WB_type == WB_ALetter ||
WB_type == WB_Hebrew_Letter)) &&
- (*prev_WB_type == WB_MidLetter ||
- *prev_WB_type == WB_MidNumLet ||
+ (prev_WB_type == WB_MidLetter ||
+ prev_WB_type == WB_MidNumLet ||
prev_wc == 0x0027))
{
- attrs[*prev_WB_i].is_word_boundary = FALSE; /* Rule WB6 */
+ attrs[prev_WB_i].is_word_boundary = FALSE; /* Rule WB6 */
is_word_boundary = FALSE; /* Rule WB7 */
}
- else if (*prev_WB_type == WB_Hebrew_Letter && wc == 0x0027)
+ else if (prev_WB_type == WB_Hebrew_Letter && wc == 0x0027)
is_word_boundary = FALSE; /* Rule WB7a */
- else if (*prev_prev_WB_type == WB_Hebrew_Letter && prev_wc == 0x0022 &&
+ else if (prev_prev_WB_type == WB_Hebrew_Letter && prev_wc == 0x0022 &&
WB_type == WB_Hebrew_Letter)
{
- attrs[*prev_WB_i].is_word_boundary = FALSE; /* Rule WB7b */
+ attrs[prev_WB_i].is_word_boundary = FALSE; /* Rule WB7b */
is_word_boundary = FALSE; /* Rule WB7c */
}
- else if ((*prev_prev_WB_type == WB_Numeric && WB_type == WB_Numeric) &&
- (*prev_WB_type == WB_MidNum ||
- *prev_WB_type == WB_MidNumLet ||
+ else if ((prev_prev_WB_type == WB_Numeric && WB_type == WB_Numeric) &&
+ (prev_WB_type == WB_MidNum ||
+ prev_WB_type == WB_MidNumLet ||
prev_wc == 0x0027))
{
is_word_boundary = FALSE; /* Rule WB11 */
- attrs[*prev_WB_i].is_word_boundary = FALSE; /* Rule WB12 */
+ attrs[prev_WB_i].is_word_boundary = FALSE; /* Rule WB12 */
}
- else if (*prev_WB_type == WB_RI_Odd && WB_type == WB_RI_Even)
+ else if (prev_WB_type == WB_RI_Odd && WB_type == WB_RI_Even)
is_word_boundary = FALSE; /* Rule WB15 and WB16 */
else
is_word_boundary = TRUE; /* Rule WB999 */
if (WB_type != WB_ExtendFormat)
{
- *prev_prev_WB_type = *prev_WB_type;
- *prev_WB_type = WB_type;
- *prev_WB_i = i;
+ prev_prev_WB_type = prev_WB_type;
+ prev_WB_type = WB_type;
+ prev_WB_i = i;
}
}
attrs[i].is_word_boundary = is_word_boundary;
}
-
- /* See Sentence_Break Property Values table of UAX#29 */
- typedef enum
- {
- SB_Other,
- SB_ExtendFormat,
- SB_ParaSep,
- SB_Sp,
- SB_Lower,
- SB_Upper,
- SB_OLetter,
- SB_Numeric,
- SB_ATerm,
- SB_SContinue,
- SB_STerm,
- SB_Close,
- /* Rules SB8 and SB8a */
- SB_ATerm_Close_Sp,
- SB_STerm_Close_Sp,
- } SentenceBreakType;
/* ---- UAX#29 Sentence Boundaries ---- */
-
- __attribute__((noinline))
-static void
-determine_sentence_boundaries (gunichar wc,
- GUnicodeType type,
- GUnicodeBreakType break_type,
- gunichar prev_wc,
- SentenceBreakType *prev_SB_type,
- int *prev_SB_i,
- SentenceBreakType *prev_prev_SB_type,
- int *last_sentence_start,
- PangoLogAttr *attrs,
- int i,
- gboolean done)
{
- gboolean is_sentence_boundary;
-
is_sentence_boundary = FALSE;
- if (attrs[i].is_word_boundary ||
+ if (is_word_boundary ||
wc == '\r' || wc == '\n') /* Rules SB3 and SB5 */
{
SentenceBreakType SB_type;
@@ -802,7 +910,7 @@ determine_sentence_boundaries (gunichar wc,
if (wc == '\n' && prev_wc == '\r')
is_sentence_boundary = FALSE; /* Rule SB3 */
- else if (*prev_SB_type == SB_ParaSep && *prev_SB_i + 1 == i)
+ else if (prev_SB_type == SB_ParaSep && prev_SB_i + 1 == i)
{
/* The extra check for prev_SB_i is to correctly handle sequences like
* ParaSep ÷ Extend × Extend
@@ -813,80 +921,80 @@ determine_sentence_boundaries (gunichar wc,
}
else if (SB_type == SB_ExtendFormat)
is_sentence_boundary = FALSE; /* Rule SB5? */
- else if (*prev_SB_type == SB_ATerm && SB_type == SB_Numeric)
+ else if (prev_SB_type == SB_ATerm && SB_type == SB_Numeric)
is_sentence_boundary = FALSE; /* Rule SB6 */
- else if ((*prev_prev_SB_type == SB_Upper ||
- *prev_prev_SB_type == SB_Lower) &&
- *prev_SB_type == SB_ATerm &&
+ else if ((prev_prev_SB_type == SB_Upper ||
+ prev_prev_SB_type == SB_Lower) &&
+ prev_SB_type == SB_ATerm &&
SB_type == SB_Upper)
is_sentence_boundary = FALSE; /* Rule SB7 */
- else if (*prev_SB_type == SB_ATerm && SB_type == SB_Close)
+ else if (prev_SB_type == SB_ATerm && SB_type == SB_Close)
SB_type = SB_ATerm;
- else if (*prev_SB_type == SB_STerm && SB_type == SB_Close)
+ else if (prev_SB_type == SB_STerm && SB_type == SB_Close)
SB_type = SB_STerm;
- else if (*prev_SB_type == SB_ATerm && SB_type == SB_Sp)
+ else if (prev_SB_type == SB_ATerm && SB_type == SB_Sp)
SB_type = SB_ATerm_Close_Sp;
- else if (*prev_SB_type == SB_STerm && SB_type == SB_Sp)
+ else if (prev_SB_type == SB_STerm && SB_type == SB_Sp)
SB_type = SB_STerm_Close_Sp;
/* Rule SB8 */
- else if ((*prev_SB_type == SB_ATerm ||
- *prev_SB_type == SB_ATerm_Close_Sp) &&
+ else if ((prev_SB_type == SB_ATerm ||
+ prev_SB_type == SB_ATerm_Close_Sp) &&
SB_type == SB_Lower)
is_sentence_boundary = FALSE;
- else if ((*prev_prev_SB_type == SB_ATerm ||
- *prev_prev_SB_type == SB_ATerm_Close_Sp) &&
- IS_OTHER_TERM(*prev_SB_type) &&
+ else if ((prev_prev_SB_type == SB_ATerm ||
+ prev_prev_SB_type == SB_ATerm_Close_Sp) &&
+ IS_OTHER_TERM(prev_SB_type) &&
SB_type == SB_Lower)
{
- attrs[*prev_SB_i].is_sentence_boundary = FALSE;
- attrs[*prev_SB_i].is_sentence_start = FALSE;
- attrs[*prev_SB_i].is_sentence_end = FALSE;
- *last_sentence_start = -1;
- for (int j = *prev_SB_i - 1; j >= 0; j--)
+ attrs[prev_SB_i].is_sentence_boundary = FALSE;
+ attrs[prev_SB_i].is_sentence_start = FALSE;
+ attrs[prev_SB_i].is_sentence_end = FALSE;
+ last_sentence_start = -1;
+ for (int j = prev_SB_i - 1; j >= 0; j--)
{
if (attrs[j].is_sentence_boundary)
{
- *last_sentence_start = j;
+ last_sentence_start = j;
break;
}
}
}
- else if ((*prev_SB_type == SB_ATerm ||
- *prev_SB_type == SB_ATerm_Close_Sp ||
- *prev_SB_type == SB_STerm ||
- *prev_SB_type == SB_STerm_Close_Sp) &&
+ else if ((prev_SB_type == SB_ATerm ||
+ prev_SB_type == SB_ATerm_Close_Sp ||
+ prev_SB_type == SB_STerm ||
+ prev_SB_type == SB_STerm_Close_Sp) &&
(SB_type == SB_SContinue ||
SB_type == SB_ATerm || SB_type == SB_STerm))
is_sentence_boundary = FALSE; /* Rule SB8a */
- else if ((*prev_SB_type == SB_ATerm ||
- *prev_SB_type == SB_STerm) &&
+ else if ((prev_SB_type == SB_ATerm ||
+ prev_SB_type == SB_STerm) &&
(SB_type == SB_Close || SB_type == SB_Sp ||
SB_type == SB_ParaSep))
is_sentence_boundary = FALSE; /* Rule SB9 */
- else if ((*prev_SB_type == SB_ATerm ||
- *prev_SB_type == SB_ATerm_Close_Sp ||
- *prev_SB_type == SB_STerm ||
- *prev_SB_type == SB_STerm_Close_Sp) &&
+ else if ((prev_SB_type == SB_ATerm ||
+ prev_SB_type == SB_ATerm_Close_Sp ||
+ prev_SB_type == SB_STerm ||
+ prev_SB_type == SB_STerm_Close_Sp) &&
(SB_type == SB_Sp || SB_type == SB_ParaSep))
is_sentence_boundary = FALSE; /* Rule SB10 */
- else if ((*prev_SB_type == SB_ATerm ||
- *prev_SB_type == SB_ATerm_Close_Sp ||
- *prev_SB_type == SB_STerm ||
- *prev_SB_type == SB_STerm_Close_Sp) &&
+ else if ((prev_SB_type == SB_ATerm ||
+ prev_SB_type == SB_ATerm_Close_Sp ||
+ prev_SB_type == SB_STerm ||
+ prev_SB_type == SB_STerm_Close_Sp) &&
SB_type != SB_ParaSep)
is_sentence_boundary = TRUE; /* Rule SB11 */
else
is_sentence_boundary = FALSE; /* Rule SB998 */
if (SB_type != SB_ExtendFormat &&
- !((*prev_prev_SB_type == SB_ATerm ||
- *prev_prev_SB_type == SB_ATerm_Close_Sp) &&
- IS_OTHER_TERM(*prev_SB_type) &&
+ !((prev_prev_SB_type == SB_ATerm ||
+ prev_prev_SB_type == SB_ATerm_Close_Sp) &&
+ IS_OTHER_TERM(prev_SB_type) &&
IS_OTHER_TERM(SB_type)))
{
- *prev_prev_SB_type = *prev_SB_type;
- *prev_SB_type = SB_type;
- *prev_SB_i = i;
+ prev_prev_SB_type = prev_SB_type;
+ prev_SB_type = SB_type;
+ prev_SB_i = i;
}
#undef IS_OTHER_TERM
@@ -899,38 +1007,7 @@ determine_sentence_boundaries (gunichar wc,
attrs[i].is_sentence_boundary = is_sentence_boundary;
}
-
/* ---- Line breaking ---- */
- typedef enum
- {
- LB_Other,
- LB_Numeric,
- LB_Numeric_Close,
- LB_RI_Odd,
- LB_RI_Even,
- } LineBreakType;
-
- __attribute__((noinline))
-static void
-determine_line_breaks (gunichar wc,
- GUnicodeType type,
- GUnicodeBreakType break_type,
- gunichar prev_wc,
- GUnicodeBreakType *pprev_break_type,
- GUnicodeBreakType *pprev_prev_break_type,
- GUnicodeBreakType next_break_type,
- LineBreakType *pprev_LB_type,
- JamoType jamo,
- JamoType *pprev_jamo,
- PangoLogAttr *attrs,
- int i)
-{
- gboolean can_break;
- BreakOpportunity break_op;
- GUnicodeBreakType row_break_type;
- GUnicodeBreakType prev_break_type = *pprev_break_type;
- GUnicodeBreakType prev_prev_break_type = *pprev_prev_break_type;
- LineBreakType prev_LB_type = *pprev_LB_type;
break_op = BREAK_ALREADY_HANDLED;
@@ -1296,12 +1373,12 @@ determine_line_breaks (gunichar wc,
break_type == G_UNICODE_BREAK_INFIX_SEPARATOR)
{
if (prev_LB_type != LB_Numeric)
- *pprev_LB_type = LB_type;
+ prev_LB_type = LB_type;
/* else don't change the prev_LB_type */
}
else
{
- *pprev_LB_type = LB_type;
+ prev_LB_type = LB_type;
}
}
/* else don't change the prev_LB_type for Rule LB9 */
@@ -1311,8 +1388,8 @@ determine_line_breaks (gunichar wc,
{
if (prev_break_type != G_UNICODE_BREAK_SPACE)
{
- *pprev_prev_break_type = prev_break_type;
- *pprev_break_type = break_type;
+ prev_prev_break_type = prev_break_type;
+ prev_break_type = break_type;
}
/* else don't change the prev_break_type */
}
@@ -1326,33 +1403,20 @@ determine_line_breaks (gunichar wc,
prev_break_type == G_UNICODE_BREAK_NEXT_LINE ||
prev_break_type == G_UNICODE_BREAK_SPACE ||
prev_break_type == G_UNICODE_BREAK_ZERO_WIDTH_SPACE)
- *pprev_break_type = G_UNICODE_BREAK_ALPHABETIC; /* Rule LB10 */
+ prev_break_type = G_UNICODE_BREAK_ALPHABETIC; /* Rule LB10 */
/* else don't change the prev_break_type for Rule LB9 */
- *pprev_jamo = jamo;
+ prev_jamo = jamo;
}
else
{
- *pprev_prev_break_type = prev_break_type;
- *pprev_break_type = break_type;
- *pprev_jamo = jamo;
+ prev_prev_break_type = prev_break_type;
+ prev_break_type = break_type;
+ prev_jamo = jamo;
}
-}
/* ---- Word breaks ---- */
- __attribute__((noinline))
-static void
-determine_word_breaks (gunichar wc,
- GUnicodeType type,
- WordType *pcurrent_word_type,
- gunichar *plast_word_letter,
- PangoLogAttr *attrs,
- int i)
-{
- WordType current_word_type = *pcurrent_word_type;
- gunichar last_word_letter = *plast_word_letter;
-
/* default to not a word start/end */
attrs[i].is_word_start = FALSE;
attrs[i].is_word_end = FALSE;
@@ -1393,19 +1457,19 @@ determine_word_breaks (gunichar wc,
attrs[i].is_word_end = TRUE;
}
}
- *plast_word_letter = wc;
+ last_word_letter = wc;
break;
case G_UNICODE_DECIMAL_NUMBER:
case G_UNICODE_LETTER_NUMBER:
case G_UNICODE_OTHER_NUMBER:
- *plast_word_letter = wc;
+ last_word_letter = wc;
break;
default:
/* Punctuation, control/format chars, etc. all end a word. */
attrs[i].is_word_end = TRUE;
- *pcurrent_word_type = WordNone;
+ current_word_type = WordNone;
break;
}
}
@@ -1419,16 +1483,16 @@ determine_word_breaks (gunichar wc,
case G_UNICODE_OTHER_LETTER:
case G_UNICODE_TITLECASE_LETTER:
case G_UNICODE_UPPERCASE_LETTER:
- *pcurrent_word_type = WordLetters;
- *plast_word_letter = wc;
+ current_word_type = WordLetters;
+ last_word_letter = wc;
attrs[i].is_word_start = TRUE;
break;
case G_UNICODE_DECIMAL_NUMBER:
case G_UNICODE_LETTER_NUMBER:
case G_UNICODE_OTHER_NUMBER:
- *pcurrent_word_type = WordNumbers;
- *plast_word_letter = wc;
+ current_word_type = WordNumbers;
+ last_word_letter = wc;
attrs[i].is_word_start = TRUE;
break;
@@ -1437,236 +1501,42 @@ determine_word_breaks (gunichar wc,
break;
}
}
-}
/* ---- Sentence breaks ---- */
-static void
-determine_sentence_breaks (gunichar wc,
- GUnicodeType type,
- int *last_sentence_start,
- int *last_non_space,
- PangoLogAttr *attrs,
- int i)
{
+
/* default to not a sentence start/end */
attrs[i].is_sentence_start = FALSE;
attrs[i].is_sentence_end = FALSE;
/* maybe start sentence */
- if (*last_sentence_start == -1 && !attrs[i].is_sentence_boundary)
- *last_sentence_start = i - 1;
+ if (last_sentence_start == -1 && !is_sentence_boundary)
+ last_sentence_start = i - 1;
/* remember last non space character position */
if (i > 0 && !attrs[i - 1].is_white)
- *last_non_space = i;
+ last_non_space = i;
/* meets sentence end, mark both sentence start and end */
-
- if (*last_sentence_start != -1 && attrs[i].is_sentence_boundary) {
- if (*last_non_space != -1) {
- attrs[*last_sentence_start].is_sentence_start = TRUE;
- attrs[*last_non_space].is_sentence_end = TRUE;
+ if (last_sentence_start != -1 && is_sentence_boundary) {
+ if (last_non_space != -1) {
+ attrs[last_sentence_start].is_sentence_start = TRUE;
+ attrs[last_non_space].is_sentence_end = TRUE;
}
- *last_sentence_start = -1;
- *last_non_space = -1;
+ last_sentence_start = -1;
+ last_non_space = -1;
}
/* meets space character, move sentence start */
- if (*last_sentence_start != -1 &&
- *last_sentence_start == i - 1 &&
+ if (last_sentence_start != -1 &&
+ last_sentence_start == i - 1 &&
attrs[i - 1].is_white) {
- (*last_sentence_start)++;
+ last_sentence_start++;
}
}
-/**
- * pango_default_break:
- * @text: text to break. Must be valid UTF-8
- * @length: length of text in bytes (may be -1 if @text is nul-terminated)
- * @analysis: (nullable): a `PangoAnalysis` structure for the @text
- * @attrs: logical attributes to fill in
- * @attrs_len: size of the array passed as @attrs
- *
- * This is the default break algorithm.
- *
- * It applies Unicode rules without language-specific
- * tailoring, therefore the @analyis argument is unused
- * and can be %NULL.
- *
- * See [func@Pango.tailor_break] for language-specific breaks.
- */
-void
-pango_default_break (const gchar *text,
- gint length,
- PangoAnalysis *analysis G_GNUC_UNUSED,
- PangoLogAttr *attrs,
- int attrs_len G_GNUC_UNUSED)
-{
- /* The rationale for all this is in section 5.15 of the Unicode 3.0 book,
- * the line breaking stuff is also in TR14 on unicode.org
- */
-
- /* This is a default break implementation that should work for nearly all
- * languages. Language engines can override it optionally.
- */
-
- /* FIXME one cheesy optimization here would be to memset attrs to 0
- * before we start, and then never assign %FALSE to anything
- */
-
- const gchar *next;
- gint i;
-
- gunichar prev_wc;
- gunichar next_wc;
-
- JamoType prev_jamo;
-
- GUnicodeBreakType next_break_type;
- GUnicodeBreakType prev_break_type;
- GUnicodeBreakType prev_prev_break_type;
-
- GraphemeBreakType prev_GB_type = GB_Other;
- gboolean met_Extended_Pictographic = FALSE;
-
- WordBreakType prev_prev_WB_type = WB_Other, prev_WB_type = WB_Other;
- gint prev_WB_i = -1;
-
- SentenceBreakType prev_prev_SB_type = SB_Other, prev_SB_type = SB_Other;
- gint prev_SB_i = -1;
-
- LineBreakType prev_LB_type = LB_Other;
-
- WordType current_word_type = WordNone;
- gunichar last_word_letter = 0;
- gunichar base_character = 0;
-
- gint last_sentence_start = -1;
- gint last_non_space = -1;
-
- gboolean almost_done = FALSE;
- gboolean done = FALSE;
-
- g_return_if_fail (length == 0 || text != NULL);
- g_return_if_fail (attrs != NULL);
-
- next = text;
-
- prev_break_type = G_UNICODE_BREAK_UNKNOWN;
- prev_prev_break_type = G_UNICODE_BREAK_UNKNOWN;
- prev_wc = 0;
- prev_jamo = NO_JAMO;
-
- if (length == 0 || *text == '\0')
- {
- next_wc = PARAGRAPH_SEPARATOR;
- almost_done = TRUE;
- }
- else
- next_wc = g_utf8_get_char (next);
-
- next_break_type = g_unichar_break_type (next_wc);
- next_break_type = BREAK_TYPE_SAFE (next_break_type);
-
- for (i = 0; !done ; i++)
- {
- GUnicodeType type;
- gunichar wc;
- GUnicodeBreakType break_type;
- JamoType jamo;
- gboolean makes_hangul_syllable;
-
- /* Emoji extended pictographics */
- gboolean is_Extended_Pictographic;
-
- wc = next_wc;
- break_type = next_break_type;
-
- if (almost_done)
- {
- /*
- * If we have already reached the end of @text g_utf8_next_char()
- * may not increment next
- */
- next_wc = 0;
- next_break_type = G_UNICODE_BREAK_UNKNOWN;
- done = TRUE;
- }
- else
- {
- next = g_utf8_next_char (next);
-
- if ((length >= 0 && next >= text + length) || *next == '\0')
- {
- /* This is how we fill in the last element (end position) of the
- * attr array - assume there's a paragraph separators off the end
- * of @text.
- */
- next_wc = PARAGRAPH_SEPARATOR;
- almost_done = TRUE;
- }
- else
- next_wc = g_utf8_get_char (next);
-
- next_break_type = g_unichar_break_type (next_wc);
- next_break_type = BREAK_TYPE_SAFE (next_break_type);
- }
-
- type = g_unichar_type (wc);
- jamo = JAMO_TYPE (break_type);
-
- /* Determine wheter this forms a Hangul syllable with prev. */
- if (jamo == NO_JAMO)
- makes_hangul_syllable = FALSE;
- else
- {
- JamoType prev_end = HangulJamoProps[prev_jamo].end ;
- JamoType this_start = HangulJamoProps[ jamo].start;
-
- /* See comments before IS_JAMO */
- makes_hangul_syllable = (prev_end == this_start) || (prev_end + 1 == this_start);
- }
-
- is_Extended_Pictographic =
- _pango_Is_Emoji_Extended_Pictographic (wc);
-
- determine_whitespace (wc, type, attrs, i);
-
- determine_grapheme_boundaries (wc, type, prev_wc,
- makes_hangul_syllable,
- is_Extended_Pictographic,
- &met_Extended_Pictographic,
- &prev_GB_type,
- attrs, i);
-
- determine_backspace (prev_wc, base_character, attrs, i);
-
- determine_word_boundaries (wc, type, break_type, prev_wc,
- is_Extended_Pictographic,
- &prev_WB_type, &prev_WB_i,
- &prev_prev_WB_type,
- attrs, i);
-
- determine_sentence_boundaries (wc, type, break_type, prev_wc,
- &prev_SB_type, &prev_SB_i,
- &prev_prev_SB_type,
- &last_sentence_start,
- attrs, i, done);
-
- determine_line_breaks (wc, type, break_type, prev_wc,
- &prev_break_type, &prev_prev_break_type,
- next_break_type,
- &prev_LB_type, jamo, &prev_jamo,
- attrs, i);
-
- determine_word_breaks (wc, type, ¤t_word_type, &last_word_letter,
- attrs, i);
-
- determine_sentence_breaks (wc, type, &last_sentence_start, &last_non_space,
- attrs, i);
-
prev_wc = wc;
/* wc might not be a valid Unicode base character, but really all we
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
