Coverage Report

Created: 2023-09-24 15:58

/src/harfbuzz/src/hb-ot-shaper-arabic-fallback.hh
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright © 2012  Google, Inc.
3
 *
4
 *  This is part of HarfBuzz, a text shaping library.
5
 *
6
 * Permission is hereby granted, without written agreement and without
7
 * license or royalty fees, to use, copy, modify, and distribute this
8
 * software and its documentation for any purpose, provided that the
9
 * above copyright notice and the following two paragraphs appear in
10
 * all copies of this software.
11
 *
12
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15
 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16
 * DAMAGE.
17
 *
18
 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
21
 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23
 *
24
 * Google Author(s): Behdad Esfahbod
25
 */
26
27
#ifndef HB_OT_SHAPER_ARABIC_FALLBACK_HH
28
#define HB_OT_SHAPER_ARABIC_FALLBACK_HH
29
30
#include "hb.hh"
31
32
#include "hb-ot-shape.hh"
33
#include "hb-ot-layout-gsub-table.hh"
34
35
36
/* Features ordered the same as the entries in shaping_table rows,
37
 * followed by rlig.  Don't change.
38
 *
39
 * We currently support one subtable per lookup, and one lookup
40
 * per feature.  But we allow duplicate features, so we use that!
41
 */
42
static const hb_tag_t arabic_fallback_features[] =
43
{
44
  HB_TAG('i','n','i','t'),
45
  HB_TAG('m','e','d','i'),
46
  HB_TAG('f','i','n','a'),
47
  HB_TAG('i','s','o','l'),
48
  HB_TAG('r','l','i','g'),
49
  HB_TAG('r','l','i','g'),
50
  HB_TAG('r','l','i','g'),
51
};
52
53
static OT::SubstLookup *
54
arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUSED,
55
            hb_font_t *font,
56
            unsigned int feature_index)
57
83.6k
{
58
83.6k
  OT::HBGlyphID16 glyphs[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
59
83.6k
  OT::HBGlyphID16 substitutes[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
60
83.6k
  unsigned int num_glyphs = 0;
61
62
  /* Populate arrays */
63
15.0M
  for (hb_codepoint_t u = SHAPING_TABLE_FIRST; u < SHAPING_TABLE_LAST + 1; u++)
64
14.9M
  {
65
14.9M
    hb_codepoint_t s = shaping_table[u - SHAPING_TABLE_FIRST][feature_index];
66
14.9M
    hb_codepoint_t u_glyph, s_glyph;
67
68
14.9M
    if (!s ||
69
14.9M
  !hb_font_get_glyph (font, u, 0, &u_glyph) ||
70
14.9M
  !hb_font_get_glyph (font, s, 0, &s_glyph) ||
71
14.9M
  u_glyph == s_glyph ||
72
14.9M
  u_glyph > 0xFFFFu || s_glyph > 0xFFFFu)
73
14.4M
      continue;
74
75
507k
    glyphs[num_glyphs] = u_glyph;
76
507k
    substitutes[num_glyphs] = s_glyph;
77
78
507k
    num_glyphs++;
79
507k
  }
80
81
83.6k
  if (!num_glyphs)
82
70.7k
    return nullptr;
83
84
  /* Bubble-sort or something equally good!
85
   * May not be good-enough for presidential candidate interviews, but good-enough for us... */
86
12.8k
  hb_stable_sort (&glyphs[0], num_glyphs,
87
12.8k
      (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID16::cmp,
88
12.8k
      &substitutes[0]);
89
90
91
  /* Each glyph takes four bytes max, and there's some overhead. */
92
12.8k
  char buf[(SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1) * 4 + 128];
93
12.8k
  hb_serialize_context_t c (buf, sizeof (buf));
94
12.8k
  OT::SubstLookup *lookup = c.start_serialize<OT::SubstLookup> ();
95
12.8k
  bool ret = lookup->serialize_single (&c,
96
12.8k
               OT::LookupFlag::IgnoreMarks,
97
12.8k
               hb_sorted_array (glyphs, num_glyphs),
98
12.8k
               hb_array (substitutes, num_glyphs));
99
12.8k
  c.end_serialize ();
100
101
12.8k
  return ret && !c.in_error () ? c.copy<OT::SubstLookup> () : nullptr;
102
83.6k
}
103
104
template <typename T>
105
static OT::SubstLookup *
106
arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UNUSED,
107
              hb_font_t *font,
108
              const T &ligature_table,
109
              unsigned lookup_flags)
110
61.3k
{
111
61.3k
  OT::HBGlyphID16 first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
112
61.3k
  unsigned int first_glyphs_indirection[ARRAY_LENGTH_CONST (ligature_table)];
113
61.3k
  unsigned int ligature_per_first_glyph_count_list[ARRAY_LENGTH_CONST (first_glyphs)];
114
61.3k
  unsigned int num_first_glyphs = 0;
115
116
  /* We know that all our ligatures have the same number of components. */
117
61.3k
  OT::HBGlyphID16 ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
118
61.3k
  unsigned int component_count_list[ARRAY_LENGTH_CONST (ligature_list)];
119
61.3k
  OT::HBGlyphID16 component_list[ARRAY_LENGTH_CONST (ligature_list) *
120
61.3k
         ARRAY_LENGTH_CONST (ligature_table[0].ligatures[0].components)];
121
61.3k
  unsigned int num_ligatures = 0;
122
61.3k
  unsigned int num_components = 0;
123
124
  /* Populate arrays */
125
126
  /* Sort out the first-glyphs */
127
470k
  for (unsigned int first_glyph_idx = 0; first_glyph_idx < ARRAY_LENGTH (first_glyphs); first_glyph_idx++)
128
409k
  {
129
409k
    hb_codepoint_t first_u = ligature_table[first_glyph_idx].first;
130
409k
    hb_codepoint_t first_glyph;
131
409k
    if (!hb_font_get_glyph (font, first_u, 0, &first_glyph))
132
320k
      continue;
133
88.9k
    first_glyphs[num_first_glyphs] = first_glyph;
134
88.9k
    ligature_per_first_glyph_count_list[num_first_glyphs] = 0;
135
88.9k
    first_glyphs_indirection[num_first_glyphs] = first_glyph_idx;
136
88.9k
    num_first_glyphs++;
137
88.9k
  }
138
61.3k
  hb_stable_sort (&first_glyphs[0], num_first_glyphs,
139
61.3k
      (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID16::cmp,
140
61.3k
      &first_glyphs_indirection[0]);
141
142
  /* Now that the first-glyphs are sorted, walk again, populate ligatures. */
143
150k
  for (unsigned int i = 0; i < num_first_glyphs; i++)
144
88.9k
  {
145
88.9k
    unsigned int first_glyph_idx = first_glyphs_indirection[i];
146
147
1.24M
    for (unsigned int ligature_idx = 0; ligature_idx < ARRAY_LENGTH (ligature_table[0].ligatures); ligature_idx++)
148
1.15M
    {
149
1.15M
      hb_codepoint_t ligature_u = ligature_table[first_glyph_idx].ligatures[ligature_idx].ligature;
150
1.15M
      hb_codepoint_t ligature_glyph;
151
1.15M
      if (!hb_font_get_glyph (font, ligature_u, 0, &ligature_glyph))
152
631k
  continue;
153
154
522k
      const auto &components = ligature_table[first_glyph_idx].ligatures[ligature_idx].components;
155
522k
      unsigned component_count = ARRAY_LENGTH_CONST (components);
156
157
522k
      bool matched = true;
158
778k
      for (unsigned j = 0; j < component_count; j++)
159
533k
      {
160
533k
  hb_codepoint_t component_u   = ligature_table[first_glyph_idx].ligatures[ligature_idx].components[j];
161
533k
  hb_codepoint_t component_glyph;
162
533k
  if (!component_u ||
163
533k
      !hb_font_get_nominal_glyph (font, component_u, &component_glyph))
164
277k
  {
165
277k
    matched = false;
166
277k
    break;
167
277k
  }
168
169
255k
  component_list[num_components++] = component_glyph;
170
255k
      }
171
522k
      if (!matched)
172
277k
        continue;
173
174
244k
      component_count_list[num_ligatures] = 1 + component_count;
175
244k
      ligature_list[num_ligatures] = ligature_glyph;
176
177
244k
      ligature_per_first_glyph_count_list[i]++;
178
179
244k
      num_ligatures++;
180
244k
    }
181
88.9k
  }
182
183
61.3k
  if (!num_ligatures)
184
49.3k
    return nullptr;
185
186
187
  /* 16 bytes per ligature ought to be enough... */
188
12.0k
  char buf[ARRAY_LENGTH_CONST (ligature_list) * 16 + 128];
189
12.0k
  hb_serialize_context_t c (buf, sizeof (buf));
190
12.0k
  OT::SubstLookup *lookup = c.start_serialize<OT::SubstLookup> ();
191
12.0k
  bool ret = lookup->serialize_ligature (&c,
192
12.0k
           lookup_flags,
193
12.0k
           hb_sorted_array (first_glyphs, num_first_glyphs),
194
12.0k
           hb_array (ligature_per_first_glyph_count_list, num_first_glyphs),
195
12.0k
           hb_array (ligature_list, num_ligatures),
196
12.0k
           hb_array (component_count_list, num_ligatures),
197
12.0k
           hb_array (component_list, num_components));
198
12.0k
  c.end_serialize ();
199
200
12.0k
  return ret && !c.in_error () ? c.copy<OT::SubstLookup> () : nullptr;
201
61.3k
}
hb-ot-shaper-arabic.cc:OT::Layout::GSUB_impl::SubstLookup* arabic_fallback_synthesize_lookup_ligature<ligature_3_set_t [1]>(hb_ot_shape_plan_t const*, hb_font_t*, ligature_3_set_t const (&) [1], unsigned int)
Line
Count
Source
110
20.4k
{
111
20.4k
  OT::HBGlyphID16 first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
112
20.4k
  unsigned int first_glyphs_indirection[ARRAY_LENGTH_CONST (ligature_table)];
113
20.4k
  unsigned int ligature_per_first_glyph_count_list[ARRAY_LENGTH_CONST (first_glyphs)];
114
20.4k
  unsigned int num_first_glyphs = 0;
115
116
  /* We know that all our ligatures have the same number of components. */
117
20.4k
  OT::HBGlyphID16 ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
118
20.4k
  unsigned int component_count_list[ARRAY_LENGTH_CONST (ligature_list)];
119
20.4k
  OT::HBGlyphID16 component_list[ARRAY_LENGTH_CONST (ligature_list) *
120
20.4k
         ARRAY_LENGTH_CONST (ligature_table[0].ligatures[0].components)];
121
20.4k
  unsigned int num_ligatures = 0;
122
20.4k
  unsigned int num_components = 0;
123
124
  /* Populate arrays */
125
126
  /* Sort out the first-glyphs */
127
40.9k
  for (unsigned int first_glyph_idx = 0; first_glyph_idx < ARRAY_LENGTH (first_glyphs); first_glyph_idx++)
128
20.4k
  {
129
20.4k
    hb_codepoint_t first_u = ligature_table[first_glyph_idx].first;
130
20.4k
    hb_codepoint_t first_glyph;
131
20.4k
    if (!hb_font_get_glyph (font, first_u, 0, &first_glyph))
132
15.9k
      continue;
133
4.52k
    first_glyphs[num_first_glyphs] = first_glyph;
134
4.52k
    ligature_per_first_glyph_count_list[num_first_glyphs] = 0;
135
4.52k
    first_glyphs_indirection[num_first_glyphs] = first_glyph_idx;
136
4.52k
    num_first_glyphs++;
137
4.52k
  }
138
20.4k
  hb_stable_sort (&first_glyphs[0], num_first_glyphs,
139
20.4k
      (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID16::cmp,
140
20.4k
      &first_glyphs_indirection[0]);
141
142
  /* Now that the first-glyphs are sorted, walk again, populate ligatures. */
143
24.9k
  for (unsigned int i = 0; i < num_first_glyphs; i++)
144
4.52k
  {
145
4.52k
    unsigned int first_glyph_idx = first_glyphs_indirection[i];
146
147
18.0k
    for (unsigned int ligature_idx = 0; ligature_idx < ARRAY_LENGTH (ligature_table[0].ligatures); ligature_idx++)
148
13.5k
    {
149
13.5k
      hb_codepoint_t ligature_u = ligature_table[first_glyph_idx].ligatures[ligature_idx].ligature;
150
13.5k
      hb_codepoint_t ligature_glyph;
151
13.5k
      if (!hb_font_get_glyph (font, ligature_u, 0, &ligature_glyph))
152
2.23k
  continue;
153
154
11.3k
      const auto &components = ligature_table[first_glyph_idx].ligatures[ligature_idx].components;
155
11.3k
      unsigned component_count = ARRAY_LENGTH_CONST (components);
156
157
11.3k
      bool matched = true;
158
33.3k
      for (unsigned j = 0; j < component_count; j++)
159
22.4k
      {
160
22.4k
  hb_codepoint_t component_u   = ligature_table[first_glyph_idx].ligatures[ligature_idx].components[j];
161
22.4k
  hb_codepoint_t component_glyph;
162
22.4k
  if (!component_u ||
163
22.4k
      !hb_font_get_nominal_glyph (font, component_u, &component_glyph))
164
435
  {
165
435
    matched = false;
166
435
    break;
167
435
  }
168
169
22.0k
  component_list[num_components++] = component_glyph;
170
22.0k
      }
171
11.3k
      if (!matched)
172
435
        continue;
173
174
10.9k
      component_count_list[num_ligatures] = 1 + component_count;
175
10.9k
      ligature_list[num_ligatures] = ligature_glyph;
176
177
10.9k
      ligature_per_first_glyph_count_list[i]++;
178
179
10.9k
      num_ligatures++;
180
10.9k
    }
181
4.52k
  }
182
183
20.4k
  if (!num_ligatures)
184
16.5k
    return nullptr;
185
186
187
  /* 16 bytes per ligature ought to be enough... */
188
3.94k
  char buf[ARRAY_LENGTH_CONST (ligature_list) * 16 + 128];
189
3.94k
  hb_serialize_context_t c (buf, sizeof (buf));
190
3.94k
  OT::SubstLookup *lookup = c.start_serialize<OT::SubstLookup> ();
191
3.94k
  bool ret = lookup->serialize_ligature (&c,
192
3.94k
           lookup_flags,
193
3.94k
           hb_sorted_array (first_glyphs, num_first_glyphs),
194
3.94k
           hb_array (ligature_per_first_glyph_count_list, num_first_glyphs),
195
3.94k
           hb_array (ligature_list, num_ligatures),
196
3.94k
           hb_array (component_count_list, num_ligatures),
197
3.94k
           hb_array (component_list, num_components));
198
3.94k
  c.end_serialize ();
199
200
3.94k
  return ret && !c.in_error () ? c.copy<OT::SubstLookup> () : nullptr;
201
20.4k
}
hb-ot-shaper-arabic.cc:OT::Layout::GSUB_impl::SubstLookup* arabic_fallback_synthesize_lookup_ligature<ligature_set_t [18]>(hb_ot_shape_plan_t const*, hb_font_t*, ligature_set_t const (&) [18], unsigned int)
Line
Count
Source
110
20.4k
{
111
20.4k
  OT::HBGlyphID16 first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
112
20.4k
  unsigned int first_glyphs_indirection[ARRAY_LENGTH_CONST (ligature_table)];
113
20.4k
  unsigned int ligature_per_first_glyph_count_list[ARRAY_LENGTH_CONST (first_glyphs)];
114
20.4k
  unsigned int num_first_glyphs = 0;
115
116
  /* We know that all our ligatures have the same number of components. */
117
20.4k
  OT::HBGlyphID16 ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
118
20.4k
  unsigned int component_count_list[ARRAY_LENGTH_CONST (ligature_list)];
119
20.4k
  OT::HBGlyphID16 component_list[ARRAY_LENGTH_CONST (ligature_list) *
120
20.4k
         ARRAY_LENGTH_CONST (ligature_table[0].ligatures[0].components)];
121
20.4k
  unsigned int num_ligatures = 0;
122
20.4k
  unsigned int num_components = 0;
123
124
  /* Populate arrays */
125
126
  /* Sort out the first-glyphs */
127
388k
  for (unsigned int first_glyph_idx = 0; first_glyph_idx < ARRAY_LENGTH (first_glyphs); first_glyph_idx++)
128
368k
  {
129
368k
    hb_codepoint_t first_u = ligature_table[first_glyph_idx].first;
130
368k
    hb_codepoint_t first_glyph;
131
368k
    if (!hb_font_get_glyph (font, first_u, 0, &first_glyph))
132
288k
      continue;
133
79.8k
    first_glyphs[num_first_glyphs] = first_glyph;
134
79.8k
    ligature_per_first_glyph_count_list[num_first_glyphs] = 0;
135
79.8k
    first_glyphs_indirection[num_first_glyphs] = first_glyph_idx;
136
79.8k
    num_first_glyphs++;
137
79.8k
  }
138
20.4k
  hb_stable_sort (&first_glyphs[0], num_first_glyphs,
139
20.4k
      (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID16::cmp,
140
20.4k
      &first_glyphs_indirection[0]);
141
142
  /* Now that the first-glyphs are sorted, walk again, populate ligatures. */
143
100k
  for (unsigned int i = 0; i < num_first_glyphs; i++)
144
79.8k
  {
145
79.8k
    unsigned int first_glyph_idx = first_glyphs_indirection[i];
146
147
1.19M
    for (unsigned int ligature_idx = 0; ligature_idx < ARRAY_LENGTH (ligature_table[0].ligatures); ligature_idx++)
148
1.11M
    {
149
1.11M
      hb_codepoint_t ligature_u = ligature_table[first_glyph_idx].ligatures[ligature_idx].ligature;
150
1.11M
      hb_codepoint_t ligature_glyph;
151
1.11M
      if (!hb_font_get_glyph (font, ligature_u, 0, &ligature_glyph))
152
624k
  continue;
153
154
494k
      const auto &components = ligature_table[first_glyph_idx].ligatures[ligature_idx].components;
155
494k
      unsigned component_count = ARRAY_LENGTH_CONST (components);
156
157
494k
      bool matched = true;
158
711k
      for (unsigned j = 0; j < component_count; j++)
159
494k
      {
160
494k
  hb_codepoint_t component_u   = ligature_table[first_glyph_idx].ligatures[ligature_idx].components[j];
161
494k
  hb_codepoint_t component_glyph;
162
494k
  if (!component_u ||
163
494k
      !hb_font_get_nominal_glyph (font, component_u, &component_glyph))
164
277k
  {
165
277k
    matched = false;
166
277k
    break;
167
277k
  }
168
169
217k
  component_list[num_components++] = component_glyph;
170
217k
      }
171
494k
      if (!matched)
172
277k
        continue;
173
174
217k
      component_count_list[num_ligatures] = 1 + component_count;
175
217k
      ligature_list[num_ligatures] = ligature_glyph;
176
177
217k
      ligature_per_first_glyph_count_list[i]++;
178
179
217k
      num_ligatures++;
180
217k
    }
181
79.8k
  }
182
183
20.4k
  if (!num_ligatures)
184
15.9k
    return nullptr;
185
186
187
  /* 16 bytes per ligature ought to be enough... */
188
4.46k
  char buf[ARRAY_LENGTH_CONST (ligature_list) * 16 + 128];
189
4.46k
  hb_serialize_context_t c (buf, sizeof (buf));
190
4.46k
  OT::SubstLookup *lookup = c.start_serialize<OT::SubstLookup> ();
191
4.46k
  bool ret = lookup->serialize_ligature (&c,
192
4.46k
           lookup_flags,
193
4.46k
           hb_sorted_array (first_glyphs, num_first_glyphs),
194
4.46k
           hb_array (ligature_per_first_glyph_count_list, num_first_glyphs),
195
4.46k
           hb_array (ligature_list, num_ligatures),
196
4.46k
           hb_array (component_count_list, num_ligatures),
197
4.46k
           hb_array (component_list, num_components));
198
4.46k
  c.end_serialize ();
199
200
4.46k
  return ret && !c.in_error () ? c.copy<OT::SubstLookup> () : nullptr;
201
20.4k
}
hb-ot-shaper-arabic.cc:OT::Layout::GSUB_impl::SubstLookup* arabic_fallback_synthesize_lookup_ligature<ligature_mark_set_t [1]>(hb_ot_shape_plan_t const*, hb_font_t*, ligature_mark_set_t const (&) [1], unsigned int)
Line
Count
Source
110
20.4k
{
111
20.4k
  OT::HBGlyphID16 first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
112
20.4k
  unsigned int first_glyphs_indirection[ARRAY_LENGTH_CONST (ligature_table)];
113
20.4k
  unsigned int ligature_per_first_glyph_count_list[ARRAY_LENGTH_CONST (first_glyphs)];
114
20.4k
  unsigned int num_first_glyphs = 0;
115
116
  /* We know that all our ligatures have the same number of components. */
117
20.4k
  OT::HBGlyphID16 ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
118
20.4k
  unsigned int component_count_list[ARRAY_LENGTH_CONST (ligature_list)];
119
20.4k
  OT::HBGlyphID16 component_list[ARRAY_LENGTH_CONST (ligature_list) *
120
20.4k
         ARRAY_LENGTH_CONST (ligature_table[0].ligatures[0].components)];
121
20.4k
  unsigned int num_ligatures = 0;
122
20.4k
  unsigned int num_components = 0;
123
124
  /* Populate arrays */
125
126
  /* Sort out the first-glyphs */
127
40.9k
  for (unsigned int first_glyph_idx = 0; first_glyph_idx < ARRAY_LENGTH (first_glyphs); first_glyph_idx++)
128
20.4k
  {
129
20.4k
    hb_codepoint_t first_u = ligature_table[first_glyph_idx].first;
130
20.4k
    hb_codepoint_t first_glyph;
131
20.4k
    if (!hb_font_get_glyph (font, first_u, 0, &first_glyph))
132
15.9k
      continue;
133
4.49k
    first_glyphs[num_first_glyphs] = first_glyph;
134
4.49k
    ligature_per_first_glyph_count_list[num_first_glyphs] = 0;
135
4.49k
    first_glyphs_indirection[num_first_glyphs] = first_glyph_idx;
136
4.49k
    num_first_glyphs++;
137
4.49k
  }
138
20.4k
  hb_stable_sort (&first_glyphs[0], num_first_glyphs,
139
20.4k
      (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID16::cmp,
140
20.4k
      &first_glyphs_indirection[0]);
141
142
  /* Now that the first-glyphs are sorted, walk again, populate ligatures. */
143
24.9k
  for (unsigned int i = 0; i < num_first_glyphs; i++)
144
4.49k
  {
145
4.49k
    unsigned int first_glyph_idx = first_glyphs_indirection[i];
146
147
26.9k
    for (unsigned int ligature_idx = 0; ligature_idx < ARRAY_LENGTH (ligature_table[0].ligatures); ligature_idx++)
148
22.4k
    {
149
22.4k
      hb_codepoint_t ligature_u = ligature_table[first_glyph_idx].ligatures[ligature_idx].ligature;
150
22.4k
      hb_codepoint_t ligature_glyph;
151
22.4k
      if (!hb_font_get_glyph (font, ligature_u, 0, &ligature_glyph))
152
5.48k
  continue;
153
154
16.9k
      const auto &components = ligature_table[first_glyph_idx].ligatures[ligature_idx].components;
155
16.9k
      unsigned component_count = ARRAY_LENGTH_CONST (components);
156
157
16.9k
      bool matched = true;
158
33.8k
      for (unsigned j = 0; j < component_count; j++)
159
16.9k
      {
160
16.9k
  hb_codepoint_t component_u   = ligature_table[first_glyph_idx].ligatures[ligature_idx].components[j];
161
16.9k
  hb_codepoint_t component_glyph;
162
16.9k
  if (!component_u ||
163
16.9k
      !hb_font_get_nominal_glyph (font, component_u, &component_glyph))
164
144
  {
165
144
    matched = false;
166
144
    break;
167
144
  }
168
169
16.8k
  component_list[num_components++] = component_glyph;
170
16.8k
      }
171
16.9k
      if (!matched)
172
144
        continue;
173
174
16.8k
      component_count_list[num_ligatures] = 1 + component_count;
175
16.8k
      ligature_list[num_ligatures] = ligature_glyph;
176
177
16.8k
      ligature_per_first_glyph_count_list[i]++;
178
179
16.8k
      num_ligatures++;
180
16.8k
    }
181
4.49k
  }
182
183
20.4k
  if (!num_ligatures)
184
16.8k
    return nullptr;
185
186
187
  /* 16 bytes per ligature ought to be enough... */
188
3.58k
  char buf[ARRAY_LENGTH_CONST (ligature_list) * 16 + 128];
189
3.58k
  hb_serialize_context_t c (buf, sizeof (buf));
190
3.58k
  OT::SubstLookup *lookup = c.start_serialize<OT::SubstLookup> ();
191
3.58k
  bool ret = lookup->serialize_ligature (&c,
192
3.58k
           lookup_flags,
193
3.58k
           hb_sorted_array (first_glyphs, num_first_glyphs),
194
3.58k
           hb_array (ligature_per_first_glyph_count_list, num_first_glyphs),
195
3.58k
           hb_array (ligature_list, num_ligatures),
196
3.58k
           hb_array (component_count_list, num_ligatures),
197
3.58k
           hb_array (component_list, num_components));
198
3.58k
  c.end_serialize ();
199
200
3.58k
  return ret && !c.in_error () ? c.copy<OT::SubstLookup> () : nullptr;
201
20.4k
}
202
203
static OT::SubstLookup *
204
arabic_fallback_synthesize_lookup (const hb_ot_shape_plan_t *plan,
205
           hb_font_t *font,
206
           unsigned int feature_index)
207
145k
{
208
145k
  if (feature_index < 4)
209
83.6k
    return arabic_fallback_synthesize_lookup_single (plan, font, feature_index);
210
61.3k
  else
211
61.3k
  {
212
61.3k
    switch (feature_index) {
213
20.4k
      case 4: return arabic_fallback_synthesize_lookup_ligature (plan, font, ligature_3_table, OT::LookupFlag::IgnoreMarks);
214
20.4k
      case 5: return arabic_fallback_synthesize_lookup_ligature (plan, font, ligature_table, OT::LookupFlag::IgnoreMarks);
215
20.4k
      case 6: return arabic_fallback_synthesize_lookup_ligature (plan, font, ligature_mark_table, 0);
216
61.3k
    }
217
61.3k
  }
218
0
  assert (false);
219
0
  return nullptr;
220
145k
}
221
222
#define ARABIC_FALLBACK_MAX_LOOKUPS ARRAY_LENGTH_CONST (arabic_fallback_features)
223
224
struct arabic_fallback_plan_t
225
{
226
  unsigned int num_lookups;
227
  bool free_lookups;
228
229
  hb_mask_t mask_array[ARABIC_FALLBACK_MAX_LOOKUPS];
230
  OT::SubstLookup *lookup_array[ARABIC_FALLBACK_MAX_LOOKUPS];
231
  OT::hb_ot_layout_lookup_accelerator_t accel_array[ARABIC_FALLBACK_MAX_LOOKUPS];
232
};
233
234
#if defined(_WIN32) && !defined(HB_NO_WIN1256)
235
#define HB_WITH_WIN1256
236
#endif
237
238
#ifdef HB_WITH_WIN1256
239
#include "hb-ot-shaper-arabic-win1256.hh"
240
#endif
241
242
struct ManifestLookup
243
{
244
  public:
245
  OT::Tag tag;
246
  OT::Offset16To<OT::SubstLookup> lookupOffset;
247
  public:
248
  DEFINE_SIZE_STATIC (6);
249
};
250
typedef OT::Array16Of<ManifestLookup> Manifest;
251
252
static bool
253
arabic_fallback_plan_init_win1256 (arabic_fallback_plan_t *fallback_plan HB_UNUSED,
254
           const hb_ot_shape_plan_t *plan HB_UNUSED,
255
           hb_font_t *font HB_UNUSED)
256
16.0k
{
257
#ifdef HB_WITH_WIN1256
258
  /* Does this font look like it's Windows-1256-encoded? */
259
  hb_codepoint_t g;
260
  if (!(hb_font_get_glyph (font, 0x0627u, 0, &g) && g == 199 /* ALEF */ &&
261
  hb_font_get_glyph (font, 0x0644u, 0, &g) && g == 225 /* LAM */ &&
262
  hb_font_get_glyph (font, 0x0649u, 0, &g) && g == 236 /* ALEF MAKSURA */ &&
263
  hb_font_get_glyph (font, 0x064Au, 0, &g) && g == 237 /* YEH */ &&
264
  hb_font_get_glyph (font, 0x0652u, 0, &g) && g == 250 /* SUKUN */))
265
    return false;
266
267
  const Manifest &manifest = reinterpret_cast<const Manifest&> (arabic_win1256_gsub_lookups.manifest);
268
  static_assert (sizeof (arabic_win1256_gsub_lookups.manifestData) <=
269
     ARABIC_FALLBACK_MAX_LOOKUPS * sizeof (ManifestLookup), "");
270
271
  unsigned j = 0;
272
  unsigned int count = manifest.len;
273
  for (unsigned int i = 0; i < count; i++)
274
  {
275
    fallback_plan->mask_array[j] = plan->map.get_1_mask (manifest[i].tag);
276
    if (fallback_plan->mask_array[j])
277
    {
278
      fallback_plan->lookup_array[j] = const_cast<OT::SubstLookup*> (&(&manifest+manifest[i].lookupOffset));
279
      if (fallback_plan->lookup_array[j])
280
      {
281
  fallback_plan->accel_array[j].init (*fallback_plan->lookup_array[j]);
282
  j++;
283
      }
284
    }
285
  }
286
287
  fallback_plan->num_lookups = j;
288
  fallback_plan->free_lookups = false;
289
290
  return j > 0;
291
#else
292
16.0k
  return false;
293
16.0k
#endif
294
16.0k
}
295
296
static bool
297
arabic_fallback_plan_init_unicode (arabic_fallback_plan_t *fallback_plan,
298
           const hb_ot_shape_plan_t *plan,
299
           hb_font_t *font)
300
20.9k
{
301
20.9k
  static_assert ((ARRAY_LENGTH_CONST (arabic_fallback_features) <= ARABIC_FALLBACK_MAX_LOOKUPS), "");
302
20.9k
  unsigned int j = 0;
303
167k
  for (unsigned int i = 0; i < ARRAY_LENGTH(arabic_fallback_features) ; i++)
304
146k
  {
305
146k
    fallback_plan->mask_array[j] = plan->map.get_1_mask (arabic_fallback_features[i]);
306
146k
    if (fallback_plan->mask_array[j])
307
145k
    {
308
145k
      fallback_plan->lookup_array[j] = arabic_fallback_synthesize_lookup (plan, font, i);
309
145k
      if (fallback_plan->lookup_array[j])
310
19.6k
      {
311
19.6k
  fallback_plan->accel_array[j].init (*fallback_plan->lookup_array[j]);
312
19.6k
  j++;
313
19.6k
      }
314
145k
    }
315
146k
  }
316
317
20.9k
  fallback_plan->num_lookups = j;
318
20.9k
  fallback_plan->free_lookups = true;
319
320
20.9k
  return j > 0;
321
20.9k
}
322
323
static arabic_fallback_plan_t *
324
arabic_fallback_plan_create (const hb_ot_shape_plan_t *plan,
325
           hb_font_t *font)
326
21.0k
{
327
21.0k
  arabic_fallback_plan_t *fallback_plan = (arabic_fallback_plan_t *) hb_calloc (1, sizeof (arabic_fallback_plan_t));
328
21.0k
  if (unlikely (!fallback_plan))
329
138
    return const_cast<arabic_fallback_plan_t *> (&Null (arabic_fallback_plan_t));
330
331
20.9k
  fallback_plan->num_lookups = 0;
332
20.9k
  fallback_plan->free_lookups = false;
333
334
  /* Try synthesizing GSUB table using Unicode Arabic Presentation Forms,
335
   * in case the font has cmap entries for the presentation-forms characters. */
336
20.9k
  if (arabic_fallback_plan_init_unicode (fallback_plan, plan, font))
337
4.87k
    return fallback_plan;
338
339
  /* See if this looks like a Windows-1256-encoded font.  If it does, use a
340
   * hand-coded GSUB table. */
341
16.0k
  if (arabic_fallback_plan_init_win1256 (fallback_plan, plan, font))
342
0
    return fallback_plan;
343
344
16.0k
  assert (fallback_plan->num_lookups == 0);
345
16.0k
  hb_free (fallback_plan);
346
16.0k
  return const_cast<arabic_fallback_plan_t *> (&Null (arabic_fallback_plan_t));
347
16.0k
}
348
349
static void
350
arabic_fallback_plan_destroy (arabic_fallback_plan_t *fallback_plan)
351
27.6k
{
352
27.6k
  if (!fallback_plan || fallback_plan->num_lookups == 0)
353
22.7k
    return;
354
355
24.5k
  for (unsigned int i = 0; i < fallback_plan->num_lookups; i++)
356
19.6k
    if (fallback_plan->lookup_array[i])
357
19.6k
    {
358
19.6k
      fallback_plan->accel_array[i].fini ();
359
19.6k
      if (fallback_plan->free_lookups)
360
19.6k
  hb_free (fallback_plan->lookup_array[i]);
361
19.6k
    }
362
363
4.87k
  hb_free (fallback_plan);
364
4.87k
}
365
366
static void
367
arabic_fallback_plan_shape (arabic_fallback_plan_t *fallback_plan,
368
          hb_font_t *font,
369
          hb_buffer_t *buffer)
370
21.0k
{
371
21.0k
  OT::hb_ot_apply_context_t c (0, font, buffer);
372
40.7k
  for (unsigned int i = 0; i < fallback_plan->num_lookups; i++)
373
19.6k
    if (fallback_plan->lookup_array[i]) {
374
19.6k
      c.set_lookup_mask (fallback_plan->mask_array[i]);
375
19.6k
      hb_ot_layout_substitute_lookup (&c,
376
19.6k
              *fallback_plan->lookup_array[i],
377
19.6k
              fallback_plan->accel_array[i]);
378
19.6k
    }
379
21.0k
}
380
381
382
#endif /* HB_OT_SHAPER_ARABIC_FALLBACK_HH */