hb-ot-shape-complex-indic.cc 42.9 KB
Newer Older
B
Behdad Esfahbod 已提交
1
/*
B
Minor  
Behdad Esfahbod 已提交
2
 * Copyright © 2011,2012  Google, Inc.
B
Behdad Esfahbod 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 *  This is part of HarfBuzz, a text shaping library.
 *
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the
 * above copyright notice and the following two paragraphs appear in
 * all copies of this software.
 *
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * Google Author(s): Behdad Esfahbod
 */

B
Behdad Esfahbod 已提交
27
#include "hb-ot-shape-complex-indic-private.hh"
B
Behdad Esfahbod 已提交
28
#include "hb-ot-layout-private.hh"
29

B
Behdad Esfahbod 已提交
30

31 32 33
/*
 * Global Indic shaper options.
 */
B
Behdad Esfahbod 已提交
34

35
struct indic_options_t
36
{
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
  int initialized : 1;
  int uniscribe_bug_compatible : 1;
};

union indic_options_union_t {
  int i;
  indic_options_t opts;
};
ASSERT_STATIC (sizeof (int) == sizeof (indic_options_union_t));

static indic_options_union_t
indic_options_init (void)
{
  indic_options_union_t u;
  u.i = 0;
  u.opts.initialized = 1;

  char *c = getenv ("HB_OT_INDIC_OPTIONS");
  u.opts.uniscribe_bug_compatible = c && strstr (c, "uniscribe-bug-compatible");

  return u;
}

B
Behdad Esfahbod 已提交
60
static inline indic_options_t
61 62 63 64 65 66 67
indic_options (void)
{
  static indic_options_union_t options;

  if (unlikely (!options.i)) {
    /* This is idempotent and threadsafe. */
    options = indic_options_init ();
68 69
  }

70 71 72
  return options.opts;
}

73

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
/*
 * Indic configurations.  Note that we do not want to keep every single script-specific
 * behavior in these tables necessarily.  This should mainly be used for per-script
 * properties that are cheaper keeping here, than in the code.  Ie. if, say, one and
 * only one script has an exception, that one script can be if'ed directly in the code,
 * instead of adding a new flag in these structs.
 */

enum base_position_t {
  BASE_POS_FIRST,
  BASE_POS_LAST
};
enum reph_position_t {
  REPH_POS_DEFAULT     = POS_BEFORE_POST,

  REPH_POS_AFTER_MAIN  = POS_AFTER_MAIN,
  REPH_POS_BEFORE_SUB  = POS_BEFORE_SUB,
  REPH_POS_AFTER_SUB   = POS_AFTER_SUB,
  REPH_POS_BEFORE_POST = POS_BEFORE_POST,
  REPH_POS_AFTER_POST  = POS_AFTER_POST
};
enum reph_mode_t {
  REPH_MODE_IMPLICIT,  /* Reph formed out of initial Ra,H sequence. */
  REPH_MODE_EXPLICIT,  /* Reph formed out of initial Ra,H,ZWJ sequence. */
  REPH_MODE_VIS_REPHA, /* Encoded Repha character, no reordering needed. */
  REPH_MODE_LOG_REPHA  /* Encoded Repha character, needs reordering. */
};
struct indic_config_t
{
  hb_script_t     script;
  bool            has_old_spec;
  hb_codepoint_t  virama;
  base_position_t base_pos;
  reph_position_t reph_pos;
  reph_mode_t     reph_mode;
};

static const indic_config_t indic_configs[] =
{
  /* Default.  Should be first. */
  {HB_SCRIPT_INVALID,	false,     0,BASE_POS_LAST, REPH_POS_DEFAULT,    REPH_MODE_IMPLICIT},
  {HB_SCRIPT_DEVANAGARI,true, 0x094D,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT},
  {HB_SCRIPT_BENGALI,	true, 0x09CD,BASE_POS_LAST, REPH_POS_AFTER_SUB,  REPH_MODE_IMPLICIT},
  {HB_SCRIPT_GURMUKHI,	true, 0x0A4D,BASE_POS_LAST, REPH_POS_BEFORE_SUB, REPH_MODE_IMPLICIT},
  {HB_SCRIPT_GUJARATI,	true, 0x0ACD,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT},
  {HB_SCRIPT_ORIYA,	true, 0x0B4D,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_IMPLICIT},
  {HB_SCRIPT_TAMIL,	true, 0x0BCD,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT},
  {HB_SCRIPT_TELUGU,	true, 0x0C4D,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT},
  {HB_SCRIPT_KANNADA,	true, 0x0CCD,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT},
  {HB_SCRIPT_MALAYALAM,	true, 0x0D4D,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_LOG_REPHA},
  {HB_SCRIPT_SINHALA,	false,0x0DCA,BASE_POS_FIRST,REPH_POS_AFTER_MAIN, REPH_MODE_EXPLICIT},
  {HB_SCRIPT_KHMER,	false,0x17D2,BASE_POS_FIRST,REPH_POS_DEFAULT,    REPH_MODE_VIS_REPHA},
B
Behdad Esfahbod 已提交
126 127
  /* Myanmar does not have the "old_indic" behavior, even though it has a "new" tag. */
  {HB_SCRIPT_MYANMAR,	false, 0x1039,BASE_POS_LAST, REPH_POS_DEFAULT,    REPH_MODE_EXPLICIT},
128 129 130 131 132 133 134
};



/*
 * Indic shaper.
 */
B
Behdad Esfahbod 已提交
135

136
struct feature_list_t {
137 138
  hb_tag_t tag;
  hb_bool_t is_global;
139 140 141
};

static const feature_list_t
142
indic_features[] =
B
Behdad Esfahbod 已提交
143
{
144 145 146 147
  /*
   * Basic features.
   * These features are applied in order, one at a time, after initial_reordering.
   */
148
  {HB_TAG('n','u','k','t'), true},
B
Behdad Esfahbod 已提交
149
  {HB_TAG('a','k','h','n'), true},
150
  {HB_TAG('r','p','h','f'), false},
B
Behdad Esfahbod 已提交
151
  {HB_TAG('r','k','r','f'), true},
152 153
  {HB_TAG('p','r','e','f'), false},
  {HB_TAG('h','a','l','f'), false},
154
  {HB_TAG('b','l','w','f'), false},
B
Behdad Esfahbod 已提交
155
  {HB_TAG('a','b','v','f'), false},
156
  {HB_TAG('p','s','t','f'), false},
B
Behdad Esfahbod 已提交
157
  {HB_TAG('c','f','a','r'), false},
B
Behdad Esfahbod 已提交
158
  {HB_TAG('c','j','c','t'), true},
159
  {HB_TAG('v','a','t','u'), true},
160 161 162 163 164 165 166 167 168 169 170 171 172 173
  /*
   * Other features.
   * These features are applied all at once, after final_reordering.
   */
  {HB_TAG('i','n','i','t'), false},
  {HB_TAG('p','r','e','s'), true},
  {HB_TAG('a','b','v','s'), true},
  {HB_TAG('b','l','w','s'), true},
  {HB_TAG('p','s','t','s'), true},
  {HB_TAG('h','a','l','n'), true},
  /* Positioning features, though we don't care about the types. */
  {HB_TAG('d','i','s','t'), true},
  {HB_TAG('a','b','v','m'), true},
  {HB_TAG('b','l','w','m'), true},
174 175
};

176 177 178
/*
 * Must be in the same order as the indic_features array.
 */
179 180
enum {
  _NUKT,
B
Behdad Esfahbod 已提交
181
  _AKHN,
182
  RPHF,
B
Minor  
Behdad Esfahbod 已提交
183
  _RKRF,
184 185
  PREF,
  HALF,
186
  BLWF,
B
Behdad Esfahbod 已提交
187
  ABVF,
188
  PSTF,
B
Behdad Esfahbod 已提交
189
  CFAR,
B
Behdad Esfahbod 已提交
190
  _CJCT,
191 192 193 194 195 196 197 198 199 200 201 202 203 204
  _VATU,

  INIT,
  _PRES,
  _ABVS,
  _BLWS,
  _PSTS,
  _HALN,
  _DIST,
  _ABVM,
  _BLWM,

  INDIC_NUM_FEATURES,
  INDIC_BASIC_FEATURES = INIT /* Don't forget to update this! */
B
Behdad Esfahbod 已提交
205 206
};

207 208 209 210
static void
setup_syllables (const hb_ot_shape_plan_t *plan,
		 hb_font_t *font,
		 hb_buffer_t *buffer);
B
Behdad Esfahbod 已提交
211
static void
212
initial_reordering (const hb_ot_shape_plan_t *plan,
213
		    hb_font_t *font,
B
Behdad Esfahbod 已提交
214
		    hb_buffer_t *buffer);
215
static void
216
final_reordering (const hb_ot_shape_plan_t *plan,
217
		  hb_font_t *font,
B
Behdad Esfahbod 已提交
218
		  hb_buffer_t *buffer);
B
Behdad Esfahbod 已提交
219

220
static void
221
collect_features_indic (hb_ot_shape_planner_t *plan)
B
Behdad Esfahbod 已提交
222
{
223 224
  hb_ot_map_builder_t *map = &plan->map;

225 226 227
  /* Do this before any lookups have been applied. */
  map->add_gsub_pause (setup_syllables);

228
  map->add_bool_feature (HB_TAG('l','o','c','l'));
B
Minor  
Behdad Esfahbod 已提交
229 230
  /* The Indic specs do not require ccmp, but we apply it here since if
   * there is a use of it, it's typically at the beginning. */
231 232 233
  map->add_bool_feature (HB_TAG('c','c','m','p'));


234 235 236 237
  unsigned int i = 0;
  map->add_gsub_pause (initial_reordering);
  for (; i < INDIC_BASIC_FEATURES; i++) {
    map->add_bool_feature (indic_features[i].tag, indic_features[i].is_global);
B
Behdad Esfahbod 已提交
238
    map->add_gsub_pause (NULL);
239
  }
B
Behdad Esfahbod 已提交
240
  map->add_gsub_pause (final_reordering);
241 242 243
  for (; i < INDIC_NUM_FEATURES; i++) {
    map->add_bool_feature (indic_features[i].tag, indic_features[i].is_global);
  }
B
Behdad Esfahbod 已提交
244 245
}

246
static void
247
override_features_indic (hb_ot_shape_planner_t *plan)
248
{
249 250
  /* Uniscribe does not apply 'kern'. */
  if (indic_options ().uniscribe_bug_compatible)
251
    plan->map.add_feature (HB_TAG('k','e','r','n'), 0, true);
B
Behdad Esfahbod 已提交
252 253

  plan->map.add_feature (HB_TAG('l','i','g','a'), 0, true);
254 255
}

256

257
struct would_substitute_feature_t
258
{
259
  inline void init (const hb_ot_map_t *map, hb_tag_t feature_tag)
260 261 262 263 264 265 266 267
  {
    map->get_stage_lookups (0/*GSUB*/,
			    map->get_feature_stage (0/*GSUB*/, feature_tag),
			    &lookups, &count);
  }

  inline bool would_substitute (hb_codepoint_t    *glyphs,
				unsigned int       glyphs_count,
268
				bool               zero_context,
269 270 271
				hb_face_t         *face) const
  {
    for (unsigned int i = 0; i < count; i++)
272
      if (hb_ot_layout_would_substitute_lookup_fast (face, lookups[i].index, glyphs, glyphs_count, zero_context))
273 274 275 276 277 278 279 280 281 282 283
	return true;
    return false;
  }

  private:
  const hb_ot_map_t::lookup_map_t *lookups;
  unsigned int count;
};

struct indic_shape_plan_t
{
284
  ASSERT_POD ();
285 286 287 288 289 290

  inline bool get_virama_glyph (hb_font_t *font, hb_codepoint_t *pglyph) const
  {
    hb_codepoint_t glyph = virama_glyph;
    if (unlikely (virama_glyph == (hb_codepoint_t) -1))
    {
291
      if (!config->virama || !font->get_glyph (config->virama, 0, &glyph))
292 293 294 295 296 297 298 299 300 301 302 303
	glyph = 0;
      /* Technically speaking, the spec says we should apply 'locl' to virama too.
       * Maybe one day... */

      /* Our get_glyph() function needs a font, so we can't get the virama glyph
       * during shape planning...  Instead, overwrite it here.  It's safe.  Don't worry! */
      (const_cast<indic_shape_plan_t *> (this))->virama_glyph = glyph;
    }

    *pglyph = glyph;
    return glyph != 0;
  }
304

305
  const indic_config_t *config;
306 307 308 309

  bool is_old_spec;
  hb_codepoint_t virama_glyph;

310
  would_substitute_feature_t rphf;
311 312 313 314 315
  would_substitute_feature_t pref;
  would_substitute_feature_t blwf;
  would_substitute_feature_t pstf;

  hb_mask_t mask_array[INDIC_NUM_FEATURES];
316 317 318 319 320
};

static void *
data_create_indic (const hb_ot_shape_plan_t *plan)
{
321 322
  indic_shape_plan_t *indic_plan = (indic_shape_plan_t *) calloc (1, sizeof (indic_shape_plan_t));
  if (unlikely (!indic_plan))
323 324
    return NULL;

325 326 327 328 329
  indic_plan->config = &indic_configs[0];
  for (unsigned int i = 1; i < ARRAY_LENGTH (indic_configs); i++)
    if (plan->props.script == indic_configs[i].script) {
      indic_plan->config = &indic_configs[i];
      break;
330
    }
331

B
Behdad Esfahbod 已提交
332
  indic_plan->is_old_spec = indic_plan->config->has_old_spec && ((plan->map.chosen_script[0] & 0x000000FF) != '2');
333
  indic_plan->virama_glyph = (hb_codepoint_t) -1;
334

335
  indic_plan->rphf.init (&plan->map, HB_TAG('r','p','h','f'));
336 337 338 339 340 341
  indic_plan->pref.init (&plan->map, HB_TAG('p','r','e','f'));
  indic_plan->blwf.init (&plan->map, HB_TAG('b','l','w','f'));
  indic_plan->pstf.init (&plan->map, HB_TAG('p','s','t','f'));

  for (unsigned int i = 0; i < ARRAY_LENGTH (indic_plan->mask_array); i++)
    indic_plan->mask_array[i] = indic_features[i].is_global ? 0 : plan->map.get_1_mask (indic_features[i].tag);
342

343
  return indic_plan;
344 345 346 347 348 349 350 351 352 353 354 355 356
}

static void
data_destroy_indic (void *data)
{
  free (data);
}

static indic_position_t
consonant_position_from_face (const indic_shape_plan_t *indic_plan,
			      hb_codepoint_t *glyphs, unsigned int glyphs_len,
			      hb_face_t      *face)
{
357 358 359 360
  bool zero_context = indic_plan->is_old_spec ? false : true;
  if (indic_plan->pref.would_substitute (glyphs, glyphs_len, zero_context, face)) return POS_BELOW_C;
  if (indic_plan->blwf.would_substitute (glyphs, glyphs_len, zero_context, face)) return POS_BELOW_C;
  if (indic_plan->pstf.would_substitute (glyphs, glyphs_len, zero_context, face)) return POS_POST_C;
361 362 363 364
  return POS_BASE_C;
}


365 366 367 368 369 370 371 372 373 374 375
enum syllable_type_t {
  consonant_syllable,
  vowel_syllable,
  standalone_cluster,
  broken_cluster,
  non_indic_cluster,
};

#include "hb-ot-shape-complex-indic-machine.hh"


376
static void
377 378 379
setup_masks_indic (const hb_ot_shape_plan_t *plan HB_UNUSED,
		   hb_buffer_t              *buffer,
		   hb_font_t                *font HB_UNUSED)
380 381 382 383 384 385 386 387 388 389 390 391
{
  HB_BUFFER_ALLOCATE_VAR (buffer, indic_category);
  HB_BUFFER_ALLOCATE_VAR (buffer, indic_position);

  /* We cannot setup masks here.  We save information about characters
   * and setup masks later on in a pause-callback. */

  unsigned int count = buffer->len;
  for (unsigned int i = 0; i < count; i++)
    set_indic_properties (buffer->info[i]);
}

392 393 394 395 396 397 398 399
static void
setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
		 hb_font_t *font HB_UNUSED,
		 hb_buffer_t *buffer)
{
  find_syllables (buffer);
}

400 401 402 403 404 405 406 407 408 409 410
static int
compare_indic_order (const hb_glyph_info_t *pa, const hb_glyph_info_t *pb)
{
  int a = pa->indic_position();
  int b = pb->indic_position();

  return a < b ? -1 : a == b ? 0 : +1;
}



411
static void
412
update_consonant_positions (const hb_ot_shape_plan_t *plan,
413 414
			    hb_font_t         *font,
			    hb_buffer_t       *buffer)
415
{
416
  const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
417

418
  unsigned int consonant_pos = indic_plan->is_old_spec ? 0 : 1;
419
  hb_codepoint_t glyphs[2];
420
  if (indic_plan->get_virama_glyph (font, &glyphs[1 - consonant_pos]))
421 422 423 424 425
  {
    hb_face_t *face = font->face;
    unsigned int count = buffer->len;
    for (unsigned int i = 0; i < count; i++)
      if (buffer->info[i].indic_position() == POS_BASE_C) {
426
	glyphs[consonant_pos] = buffer->info[i].codepoint;
427
	buffer->info[i].indic_position() = consonant_position_from_face (indic_plan, glyphs, 2, face);
428 429 430 431
      }
  }
}

432

B
Minor  
Behdad Esfahbod 已提交
433 434 435
/* Rules from:
 * https://www.microsoft.com/typography/otfntdev/devanot/shaping.aspx */

B
Behdad Esfahbod 已提交
436
static void
437 438 439
initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
				       hb_face_t *face,
				       hb_buffer_t *buffer,
440
				       unsigned int start, unsigned int end)
B
Behdad Esfahbod 已提交
441
{
442
  const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
B
Minor  
Behdad Esfahbod 已提交
443
  hb_glyph_info_t *info = buffer->info;
B
Behdad Esfahbod 已提交
444

B
Behdad Esfahbod 已提交
445

B
Behdad Esfahbod 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459
  /* 1. Find base consonant:
   *
   * The shaping engine finds the base consonant of the syllable, using the
   * following algorithm: starting from the end of the syllable, move backwards
   * until a consonant is found that does not have a below-base or post-base
   * form (post-base forms have to follow below-base forms), or that is not a
   * pre-base reordering Ra, or arrive at the first consonant. The consonant
   * stopped at will be the base.
   *
   *   o If the syllable starts with Ra + Halant (in a script that has Reph)
   *     and has more than one consonant, Ra is excluded from candidates for
   *     base consonants.
   */

460
  unsigned int base = end;
B
Behdad Esfahbod 已提交
461
  bool has_reph = false;
B
Behdad Esfahbod 已提交
462

B
Behdad Esfahbod 已提交
463
  {
B
Behdad Esfahbod 已提交
464 465 466 467
    /* -> If the syllable starts with Ra + Halant (in a script that has Reph)
     *    and has more than one consonant, Ra is excluded from candidates for
     *    base consonants. */
    unsigned int limit = start;
468
    if (indic_plan->mask_array[RPHF] &&
B
Behdad Esfahbod 已提交
469
	start + 3 <= end &&
470 471 472
	(/* TODO Handle other Reph modes. */
	 (indic_plan->config->reph_mode == REPH_MODE_IMPLICIT && !is_joiner (info[start + 2])) ||
	 (indic_plan->config->reph_mode == REPH_MODE_EXPLICIT && info[start + 2].indic_category() == OT_ZWJ)
473
	))
B
Behdad Esfahbod 已提交
474
    {
475 476 477 478 479 480 481 482 483 484
      /* See if it matches the 'rphf' feature. */
      hb_codepoint_t glyphs[2] = {info[start].codepoint, info[start + 1].codepoint};
      if (indic_plan->rphf.would_substitute (glyphs, ARRAY_LENGTH (glyphs), true, face))
      {
	limit += 2;
	while (limit < end && is_joiner (info[limit]))
	  limit++;
	base = start;
	has_reph = true;
      }
B
Behdad Esfahbod 已提交
485
    };
B
Behdad Esfahbod 已提交
486

B
Behdad Esfahbod 已提交
487
    switch (indic_plan->config->base_pos)
488
    {
489 490 491 492
      default:
        assert (false);
	/* fallthrough */

493 494 495 496 497 498 499 500 501
      case BASE_POS_LAST:
      {
	/* -> starting from the end of the syllable, move backwards */
	unsigned int i = end;
	bool seen_below = false;
	do {
	  i--;
	  /* -> until a consonant is found */
	  if (is_consonant (info[i]))
502
	  {
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
	    /* -> that does not have a below-base or post-base form
	     * (post-base forms have to follow below-base forms), */
	    if (info[i].indic_position() != POS_BELOW_C &&
		(info[i].indic_position() != POS_POST_C || seen_below))
	    {
	      base = i;
	      break;
	    }
	    if (info[i].indic_position() == POS_BELOW_C)
	      seen_below = true;

	    /* -> or that is not a pre-base reordering Ra,
	     *
	     * IMPLEMENTATION NOTES:
	     *
	     * Our pre-base reordering Ra's are marked POS_BELOW, so will be skipped
	     * by the logic above already.
	     */

	    /* -> or arrive at the first consonant. The consonant stopped at will
	     * be the base. */
524 525
	    base = i;
	  }
526 527 528 529 530 531
	  else
	  {
	    /* A ZWJ after a Halant stops the base search, and requests an explicit
	     * half form.
	     * A ZWJ before a Halant, requests a subjoined form instead, and hence
	     * search continues.  This is particularly important for Bengali
B
Typo  
Behdad Esfahbod 已提交
532
	     * sequence Ra,H,Ya that should form Ya-Phalaa by subjoining Ya. */
533 534 535 536 537 538 539 540
	    if (start < i &&
		info[i].indic_category() == OT_ZWJ &&
		info[i - 1].indic_category() == OT_H)
	      break;
	  }
	} while (i > limit);
      }
      break;
541

542 543 544
      case BASE_POS_FIRST:
      {
	/* In scripts without half forms (eg. Khmer), the first consonant is always the base. */
545

546 547
	if (!has_reph)
	  base = limit;
548

549 550 551 552 553 554 555 556 557 558
	/* Find the last base consonant that is not blocked by ZWJ.  If there is
	 * a ZWJ right before a base consonant, that would request a subjoined form. */
	for (unsigned int i = limit; i < end; i++)
	  if (is_consonant (info[i]) && info[i].indic_position() == POS_BASE_C)
	  {
	    if (limit < i && info[i - 1].indic_category() == OT_ZWJ)
	      break;
	    else
	      base = i;
	  }
559

560 561 562 563 564 565
	/* Mark all subsequent consonants as below. */
	for (unsigned int i = base + 1; i < end; i++)
	  if (is_consonant (info[i]) && info[i].indic_position() == POS_BASE_C)
	    info[i].indic_position() = POS_BELOW_C;
      }
      break;
566
    }
B
Behdad Esfahbod 已提交
567

B
Behdad Esfahbod 已提交
568 569
    /* -> If the syllable starts with Ra + Halant (in a script that has Reph)
     *    and has more than one consonant, Ra is excluded from candidates for
570 571 572 573
     *    base consonants.
     *
     *  Only do this for unforced Reph. (ie. not for Ra,H,ZWJ. */
    if (has_reph && base == start && start + 2 == limit) {
B
Behdad Esfahbod 已提交
574 575 576
      /* Have no other consonant, so Reph is not formed and Ra becomes base. */
      has_reph = false;
    }
B
Behdad Esfahbod 已提交
577
  }
578

579 580
  if (base < end)
    info[base].indic_position() = POS_BASE_C;
581 582


B
Behdad Esfahbod 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
  /* 2. Decompose and reorder Matras:
   *
   * Each matra and any syllable modifier sign in the cluster are moved to the
   * appropriate position relative to the consonant(s) in the cluster. The
   * shaping engine decomposes two- or three-part matras into their constituent
   * parts before any repositioning. Matra characters are classified by which
   * consonant in a conjunct they have affinity for and are reordered to the
   * following positions:
   *
   *   o Before first half form in the syllable
   *   o After subjoined consonants
   *   o After post-form consonant
   *   o After main consonant (for above marks)
   *
   * IMPLEMENTATION NOTES:
   *
   * The normalize() routine has already decomposed matras for us, so we don't
   * need to worry about that.
   */


  /* 3.  Reorder marks to canonical order:
   *
   * Adjacent nukta and halant or nukta and vedic sign are always repositioned
   * if necessary, so that the nukta is first.
   *
   * IMPLEMENTATION NOTES:
   *
   * We don't need to do this: the normalize() routine already did this for us.
   */


B
Behdad Esfahbod 已提交
615 616
  /* Reorder characters */

B
Minor  
Behdad Esfahbod 已提交
617
  for (unsigned int i = start; i < base; i++)
B
Minor  
Behdad Esfahbod 已提交
618
    info[i].indic_position() = MIN (POS_PRE_C, (indic_position_t) info[i].indic_position());
619

620 621
  if (base < end)
    info[base].indic_position() = POS_BASE_C;
B
Behdad Esfahbod 已提交
622

623 624 625 626 627 628 629 630 631 632 633 634
  /* Mark final consonants.  A final consonant is one appearing after a matra,
   * like in Khmer. */
  for (unsigned int i = base + 1; i < end; i++)
    if (info[i].indic_category() == OT_M) {
      for (unsigned int j = i + 1; j < end; j++)
        if (is_consonant (info[j])) {
	  info[j].indic_position() = POS_FINAL_C;
	  break;
	}
      break;
    }

635
  /* Handle beginning Ra */
B
Behdad Esfahbod 已提交
636
  if (has_reph)
637
    info[start].indic_position() = POS_RA_TO_BECOME_REPH;
638

639 640
  /* For old-style Indic script tags, move the first post-base Halant after
   * last consonant. */
641
  if (indic_plan->is_old_spec) {
B
Minor  
Behdad Esfahbod 已提交
642
    for (unsigned int i = base + 1; i < end; i++)
643 644 645
      if (info[i].indic_category() == OT_H) {
        unsigned int j;
        for (j = end - 1; j > i; j--)
B
Behdad Esfahbod 已提交
646
	  if (is_consonant (info[j]))
647 648 649 650 651 652 653 654 655 656 657
	    break;
	if (j > i) {
	  /* Move Halant to after last consonant. */
	  hb_glyph_info_t t = info[i];
	  memmove (&info[i], &info[i + 1], (j - i) * sizeof (info[0]));
	  info[j] = t;
	}
        break;
      }
  }

658
  /* Attach misc marks to previous char to move with them. */
659
  {
660 661 662 663 664 665
    indic_position_t last_pos = POS_START;
    for (unsigned int i = start; i < end; i++)
    {
      if ((FLAG (info[i].indic_category()) & (JOINER_FLAGS | FLAG (OT_N) | FLAG (OT_RS) | HALANT_OR_COENG_FLAGS)))
      {
	info[i].indic_position() = last_pos;
666
	if (unlikely (info[i].indic_category() == OT_H &&
667 668 669 670 671
		      info[i].indic_position() == POS_PRE_M))
	{
	  /*
	   * Uniscribe doesn't move the Halant with Left Matra.
	   * TEST: U+092B,U+093F,U+094DE
672 673 674 675 676
	   * We follow.  This is important for the Sinhala
	   * U+0DDA split matra since it decomposes to U+0DD9,U+0DCA
	   * where U+0DD9 is a left matra and U+0DCA is the virama.
	   * We don't want to move the virama with the left matra.
	   * TEST: U+0D9A,U+0DDA
677
	   */
678
	  for (unsigned int j = i; j > start; j--)
679
	    if (info[j - 1].indic_position() != POS_PRE_M) {
680 681 682
	      info[i].indic_position() = info[j - 1].indic_position();
	      break;
	    }
683 684 685
	}
      } else if (info[i].indic_position() != POS_SMVD) {
        last_pos = (indic_position_t) info[i].indic_position();
686
      }
687
    }
688
  }
689 690 691 692
  /* Re-attach ZWJ, ZWNJ, and halant to next char, for after-base consonants. */
  {
    unsigned int last_halant = end;
    for (unsigned int i = base + 1; i < end; i++)
693
      if (is_halant_or_coeng (info[i]))
694 695 696
        last_halant = i;
      else if (is_consonant (info[i])) {
	for (unsigned int j = last_halant; j < i; j++)
697 698
	  if (info[j].indic_position() != POS_SMVD)
	    info[j].indic_position() = info[i].indic_position();
699 700
      }
  }
B
Behdad Esfahbod 已提交
701

702
  {
703 704 705 706
    /* Things are out-of-control for post base positions, they may shuffle
     * around like crazy, so merge clusters.  For pre-base stuff, we handle
     * cluster issues in final reordering. */
    buffer->merge_clusters (base, end);
707
    /* Sit tight, rock 'n roll! */
708
    hb_bubble_sort (info + start, end - start, compare_indic_order);
709 710
    /* Find base again */
    base = end;
B
Minor  
Behdad Esfahbod 已提交
711
    for (unsigned int i = start; i < end; i++)
712 713 714 715 716
      if (info[i].indic_position() == POS_BASE_C) {
        base = i;
	break;
      }
  }
B
Behdad Esfahbod 已提交
717

B
Behdad Esfahbod 已提交
718 719
  /* Setup masks now */

B
Behdad Esfahbod 已提交
720 721 722
  {
    hb_mask_t mask;

723
    /* Reph */
724
    for (unsigned int i = start; i < end && info[i].indic_position() == POS_RA_TO_BECOME_REPH; i++)
725
      info[i].mask |= indic_plan->mask_array[RPHF];
726

B
Behdad Esfahbod 已提交
727
    /* Pre-base */
728
    mask = indic_plan->mask_array[HALF];
B
Minor  
Behdad Esfahbod 已提交
729
    for (unsigned int i = start; i < base; i++)
B
Behdad Esfahbod 已提交
730 731
      info[i].mask  |= mask;
    /* Base */
B
Behdad Esfahbod 已提交
732
    mask = 0;
733 734
    if (base < end)
      info[base].mask |= mask;
B
Behdad Esfahbod 已提交
735
    /* Post-base */
736
    mask = indic_plan->mask_array[BLWF] | indic_plan->mask_array[ABVF] | indic_plan->mask_array[PSTF];
B
Minor  
Behdad Esfahbod 已提交
737
    for (unsigned int i = base + 1; i < end; i++)
B
Behdad Esfahbod 已提交
738 739
      info[i].mask  |= mask;
  }
B
Behdad Esfahbod 已提交
740

741
  if (indic_plan->mask_array[PREF] && base + 2 < end)
742
  {
743
    /* Find a Halant,Ra sequence and mark it for pre-base reordering processing. */
744 745 746
    for (unsigned int i = base + 1; i + 1 < end; i++) {
      hb_codepoint_t glyphs[2] = {info[i].codepoint, info[i + 1].codepoint};
      if (indic_plan->pref.would_substitute (glyphs, ARRAY_LENGTH (glyphs), true, face))
747
      {
748 749
	info[i++].mask |= indic_plan->mask_array[PREF];
	info[i++].mask |= indic_plan->mask_array[PREF];
B
Behdad Esfahbod 已提交
750 751 752 753 754 755 756 757

	/* Mark the subsequent stuff with 'cfar'.  Used in Khmer.
	 * Read the feature spec.
	 * This allows distinguishing the following cases with MS Khmer fonts:
	 * U+1784,U+17D2,U+179A,U+17D2,U+1782
	 * U+1784,U+17D2,U+1782,U+17D2,U+179A
	 */
	for (; i < end; i++)
758
	  info[i].mask |= indic_plan->mask_array[CFAR];
B
Behdad Esfahbod 已提交
759

760 761
	break;
      }
762
    }
763 764
  }

B
Behdad Esfahbod 已提交
765
  /* Apply ZWJ/ZWNJ effects */
B
Minor  
Behdad Esfahbod 已提交
766
  for (unsigned int i = start + 1; i < end; i++)
B
Behdad Esfahbod 已提交
767 768
    if (is_joiner (info[i])) {
      bool non_joiner = info[i].indic_category() == OT_ZWNJ;
769
      unsigned int j = i;
B
Behdad Esfahbod 已提交
770 771 772

      do {
	j--;
773

B
Behdad Esfahbod 已提交
774 775 776 777
	/* A ZWJ disables CJCT, however, it's mere presence is enough
	 * to disable ligation.  No explicit action needed. */

	/* A ZWNJ disables HALF. */
778
	if (non_joiner)
779
	  info[j].mask &= ~indic_plan->mask_array[HALF];
780

B
Behdad Esfahbod 已提交
781 782
      } while (j > start && !is_consonant (info[j]));
    }
B
Behdad Esfahbod 已提交
783 784 785 786
}


static void
787
initial_reordering_vowel_syllable (const hb_ot_shape_plan_t *plan,
788
				   hb_face_t *face,
B
Behdad Esfahbod 已提交
789
				   hb_buffer_t *buffer,
790
				   unsigned int start, unsigned int end)
B
Behdad Esfahbod 已提交
791
{
B
Behdad Esfahbod 已提交
792
  /* We made the vowels look like consonants.  So let's call the consonant logic! */
793
  initial_reordering_consonant_syllable (plan, face, buffer, start, end);
B
Behdad Esfahbod 已提交
794 795 796
}

static void
797
initial_reordering_standalone_cluster (const hb_ot_shape_plan_t *plan,
798
				       hb_face_t *face,
B
Behdad Esfahbod 已提交
799
				       hb_buffer_t *buffer,
800
				       unsigned int start, unsigned int end)
B
Behdad Esfahbod 已提交
801
{
802 803 804
  /* We treat NBSP/dotted-circle as if they are consonants, so we should just chain.
   * Only if not in compatibility mode that is... */

805
  if (indic_options ().uniscribe_bug_compatible)
806 807 808 809 810 811 812 813
  {
    /* For dotted-circle, this is what Uniscribe does:
     * If dotted-circle is the last glyph, it just does nothing.
     * Ie. It doesn't form Reph. */
    if (buffer->info[end - 1].indic_category() == OT_DOTTEDCIRCLE)
      return;
  }

814
  initial_reordering_consonant_syllable (plan, face, buffer, start, end);
B
Behdad Esfahbod 已提交
815 816
}

817 818
static void
initial_reordering_broken_cluster (const hb_ot_shape_plan_t *plan,
819
				   hb_face_t *face,
820 821 822 823
				   hb_buffer_t *buffer,
				   unsigned int start, unsigned int end)
{
  /* We already inserted dotted-circles, so just call the standalone_cluster. */
824
  initial_reordering_standalone_cluster (plan, face, buffer, start, end);
825 826
}

B
Behdad Esfahbod 已提交
827
static void
828
initial_reordering_non_indic_cluster (const hb_ot_shape_plan_t *plan HB_UNUSED,
829
				      hb_face_t *face HB_UNUSED,
830 831
				      hb_buffer_t *buffer HB_UNUSED,
				      unsigned int start HB_UNUSED, unsigned int end HB_UNUSED)
B
Behdad Esfahbod 已提交
832 833 834 835 836
{
  /* Nothing to do right now.  If we ever switch to using the output
   * buffer in the reordering process, we'd need to next_glyph() here. */
}

837 838 839

static void
initial_reordering_syllable (const hb_ot_shape_plan_t *plan,
840
			     hb_face_t *face,
841 842 843 844 845
			     hb_buffer_t *buffer,
			     unsigned int start, unsigned int end)
{
  syllable_type_t syllable_type = (syllable_type_t) (buffer->info[start].syllable() & 0x0F);
  switch (syllable_type) {
846 847 848 849 850
  case consonant_syllable:	initial_reordering_consonant_syllable (plan, face, buffer, start, end); return;
  case vowel_syllable:		initial_reordering_vowel_syllable     (plan, face, buffer, start, end); return;
  case standalone_cluster:	initial_reordering_standalone_cluster (plan, face, buffer, start, end); return;
  case broken_cluster:		initial_reordering_broken_cluster     (plan, face, buffer, start, end); return;
  case non_indic_cluster:	initial_reordering_non_indic_cluster  (plan, face, buffer, start, end); return;
851 852 853
  }
}

854
static inline void
855 856 857 858
insert_dotted_circles (const hb_ot_shape_plan_t *plan,
		       hb_font_t *font,
		       hb_buffer_t *buffer)
{
859 860 861 862 863 864 865 866 867 868 869 870
  /* Note: This loop is extra overhead, but should not be measurable. */
  bool has_broken_syllables = false;
  unsigned int count = buffer->len;
  for (unsigned int i = 0; i < count; i++)
    if ((buffer->info[i].syllable() & 0x0F) == broken_cluster) {
      has_broken_syllables = true;
      break;
    }
  if (likely (!has_broken_syllables))
    return;


871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
  hb_codepoint_t dottedcircle_glyph;
  if (!font->get_glyph (0x25CC, 0, &dottedcircle_glyph))
    return;

  hb_glyph_info_t dottedcircle;
  dottedcircle.codepoint = 0x25CC;
  set_indic_properties (dottedcircle);
  dottedcircle.codepoint = dottedcircle_glyph;

  buffer->clear_output ();

  buffer->idx = 0;
  unsigned int last_syllable = 0;
  while (buffer->idx < buffer->len)
  {
    unsigned int syllable = buffer->cur().syllable();
    syllable_type_t syllable_type = (syllable_type_t) (syllable & 0x0F);
    if (unlikely (last_syllable != syllable && syllable_type == broken_cluster))
    {
      hb_glyph_info_t info = dottedcircle;
      info.cluster = buffer->cur().cluster;
      info.mask = buffer->cur().mask;
      info.syllable() = buffer->cur().syllable();
      buffer->output_info (info);
      last_syllable = syllable;
    }
    buffer->next_glyph ();
  }

  buffer->swap_buffers ();
}

B
Behdad Esfahbod 已提交
903
static void
904
initial_reordering (const hb_ot_shape_plan_t *plan,
905
		    hb_font_t *font,
B
Behdad Esfahbod 已提交
906
		    hb_buffer_t *buffer)
B
Behdad Esfahbod 已提交
907
{
908
  update_consonant_positions (plan, font, buffer);
909
  insert_dotted_circles (plan, font, buffer);
910 911

  hb_glyph_info_t *info = buffer->info;
912 913
  unsigned int count = buffer->len;
  if (unlikely (!count)) return;
914 915 916 917
  unsigned int last = 0;
  unsigned int last_syllable = info[0].syllable();
  for (unsigned int i = 1; i < count; i++)
    if (last_syllable != info[i].syllable()) {
918
      initial_reordering_syllable (plan, font->face, buffer, last, i);
919 920 921
      last = i;
      last_syllable = info[last].syllable();
    }
922
  initial_reordering_syllable (plan, font->face, buffer, last, count);
B
Behdad Esfahbod 已提交
923 924
}

B
Behdad Esfahbod 已提交
925
static void
926 927
final_reordering_syllable (const hb_ot_shape_plan_t *plan,
			   hb_buffer_t *buffer,
928
			   unsigned int start, unsigned int end)
B
Behdad Esfahbod 已提交
929
{
930
  const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
931 932
  hb_glyph_info_t *info = buffer->info;

933 934 935 936 937 938
  /* 4. Final reordering:
   *
   * After the localized forms and basic shaping forms GSUB features have been
   * applied (see below), the shaping engine performs some final glyph
   * reordering before applying all the remaining font features to the entire
   * cluster.
939 940 941
   */

  /* Find base again */
942 943 944 945 946 947 948
  unsigned int base;
  for (base = start; base < end; base++)
    if (info[base].indic_position() >= POS_BASE_C) {
      if (start < base && info[base].indic_position() > POS_BASE_C)
        base--;
      break;
    }
949

B
Minor  
Behdad Esfahbod 已提交
950

951
  /*   o Reorder matras:
952 953 954 955 956 957 958
   *
   *     If a pre-base matra character had been reordered before applying basic
   *     features, the glyph can be moved closer to the main consonant based on
   *     whether half-forms had been formed. Actual position for the matra is
   *     defined as “after last standalone halant glyph, after initial matra
   *     position and before the main consonant”. If ZWJ or ZWNJ follow this
   *     halant, position is moved after it.
959 960
   */

961
  if (start + 1 < end && start < base) /* Otherwise there can't be any pre-base matra characters. */
962
  {
963 964 965
    /* If we lost track of base, alas, position before last thingy. */
    unsigned int new_pos = base == end ? base - 2 : base - 1;

966 967 968
    /* Malayalam / Tamil do not have "half" forms or explicit virama forms.
     * The glyphs formed by 'half' are Chillus or ligated explicit viramas.
     * We want to position matra after them.
969
     */
970
    if (buffer->props.script != HB_SCRIPT_MALAYALAM && buffer->props.script != HB_SCRIPT_TAMIL)
971
    {
972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
      while (new_pos > start &&
	     !(is_one_of (info[new_pos], (FLAG (OT_M) | FLAG (OT_H) | FLAG (OT_Coeng)))))
	new_pos--;

      /* If we found no Halant we are done.
       * Otherwise only proceed if the Halant does
       * not belong to the Matra itself! */
      if (is_halant_or_coeng (info[new_pos]) &&
	  info[new_pos].indic_position() != POS_PRE_M)
      {
	/* -> If ZWJ or ZWNJ follow this halant, position is moved after it. */
	if (new_pos + 1 < end && is_joiner (info[new_pos + 1]))
	  new_pos++;
      }
      else
        new_pos = start; /* No move. */
    }
989

990
    if (start < new_pos && info[new_pos].indic_position () != POS_PRE_M)
991
    {
992
      /* Now go see if there's actually any matras... */
B
Behdad Esfahbod 已提交
993
      for (unsigned int i = new_pos; i > start; i--)
994
	if (info[i - 1].indic_position () == POS_PRE_M)
995
	{
B
Behdad Esfahbod 已提交
996 997 998 999
	  unsigned int old_pos = i - 1;
	  hb_glyph_info_t tmp = info[old_pos];
	  memmove (&info[old_pos], &info[old_pos + 1], (new_pos - old_pos) * sizeof (info[0]));
	  info[new_pos] = tmp;
B
Behdad Esfahbod 已提交
1000
	  new_pos--;
1001
	}
1002
      buffer->merge_clusters (new_pos, MIN (end, base + 1));
1003
    } else {
1004
      for (unsigned int i = start; i < base; i++)
1005
	if (info[i].indic_position () == POS_PRE_M) {
1006
	  buffer->merge_clusters (i, MIN (end, base + 1));
1007 1008
	  break;
	}
1009
    }
1010 1011 1012 1013
  }


  /*   o Reorder reph:
1014 1015 1016 1017 1018 1019
   *
   *     Reph’s original position is always at the beginning of the syllable,
   *     (i.e. it is not reordered at the character reordering stage). However,
   *     it will be reordered according to the basic-forms shaping results.
   *     Possible positions for reph, depending on the script, are; after main,
   *     before post-base consonant forms, and after post-base consonant forms.
1020 1021 1022 1023 1024 1025 1026 1027 1028
   */

  /* If there's anything after the Ra that has the REPH pos, it ought to be halant.
   * Which means that the font has failed to ligate the Reph.  In which case, we
   * shouldn't move. */
  if (start + 1 < end &&
      info[start].indic_position() == POS_RA_TO_BECOME_REPH &&
      info[start + 1].indic_position() != POS_RA_TO_BECOME_REPH)
  {
1029 1030 1031 1032
    unsigned int new_reph_pos;
    reph_position_t reph_pos = indic_plan->config->reph_pos;

    /* XXX Figure out old behavior too */
1033

1034 1035
    /*       1. If reph should be positioned after post-base consonant forms,
     *          proceed to step 5.
1036
     */
1037
    if (reph_pos == REPH_POS_AFTER_POST)
1038
    {
1039
      goto reph_step_5;
1040 1041 1042
    }

    /*       2. If the reph repositioning class is not after post-base: target
1043 1044 1045 1046 1047 1048 1049 1050 1051
     *          position is after the first explicit halant glyph between the
     *          first post-reph consonant and last main consonant. If ZWJ or ZWNJ
     *          are following this halant, position is moved after it. If such
     *          position is found, this is the target position. Otherwise,
     *          proceed to the next step.
     *
     *          Note: in old-implementation fonts, where classifications were
     *          fixed in shaping engine, there was no case where reph position
     *          will be found on this step.
1052 1053 1054
     */
    {
      new_reph_pos = start + 1;
1055
      while (new_reph_pos < base && !is_halant_or_coeng (info[new_reph_pos]))
1056 1057
	new_reph_pos++;

1058
      if (new_reph_pos < base && is_halant_or_coeng (info[new_reph_pos])) {
1059 1060 1061 1062 1063 1064 1065 1066
	/* ->If ZWJ or ZWNJ are following this halant, position is moved after it. */
	if (new_reph_pos + 1 < base && is_joiner (info[new_reph_pos + 1]))
	  new_reph_pos++;
	goto reph_move;
      }
    }

    /*       3. If reph should be repositioned after the main consonant: find the
1067 1068
     *          first consonant not ligated with main, or find the first
     *          consonant that is not a potential pre-base reordering Ra.
1069
     */
1070
    if (reph_pos == REPH_POS_AFTER_MAIN)
1071
    {
1072 1073
      new_reph_pos = base;
      /* XXX Skip potential pre-base reordering Ra. */
1074
      while (new_reph_pos + 1 < end && info[new_reph_pos + 1].indic_position() <= POS_AFTER_MAIN)
1075 1076 1077
	new_reph_pos++;
      if (new_reph_pos < end)
        goto reph_move;
1078 1079 1080
    }

    /*       4. If reph should be positioned before post-base consonant, find
1081 1082 1083
     *          first post-base classified consonant not ligated with main. If no
     *          consonant is found, the target position should be before the
     *          first matra, syllable modifier sign or vedic sign.
1084
     */
1085
    /* This is our take on what step 4 is trying to say (and failing, BADLY). */
1086
    if (reph_pos == REPH_POS_AFTER_SUB)
1087
    {
1088 1089
      new_reph_pos = base;
      while (new_reph_pos < end &&
1090
	     !( FLAG (info[new_reph_pos + 1].indic_position()) & (FLAG (POS_POST_C) | FLAG (POS_AFTER_POST) | FLAG (POS_SMVD))))
1091 1092 1093
	new_reph_pos++;
      if (new_reph_pos < end)
        goto reph_move;
1094 1095 1096
    }

    /*       5. If no consonant is found in steps 3 or 4, move reph to a position
1097 1098 1099 1100 1101 1102
     *          immediately before the first post-base matra, syllable modifier
     *          sign or vedic sign that has a reordering class after the intended
     *          reph position. For example, if the reordering position for reph
     *          is post-main, it will skip above-base matras that also have a
     *          post-main position.
     */
1103 1104
    reph_step_5:
    {
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
      /* Copied from step 2. */
      new_reph_pos = start + 1;
      while (new_reph_pos < base && !is_halant_or_coeng (info[new_reph_pos]))
	new_reph_pos++;

      if (new_reph_pos < base && is_halant_or_coeng (info[new_reph_pos])) {
	/* ->If ZWJ or ZWNJ are following this halant, position is moved after it. */
	if (new_reph_pos + 1 < base && is_joiner (info[new_reph_pos + 1]))
	  new_reph_pos++;
	goto reph_move;
      }
1116
    }
1117

1118 1119 1120 1121 1122 1123 1124
    /*       6. Otherwise, reorder reph to the end of the syllable.
     */
    {
      new_reph_pos = end - 1;
      while (new_reph_pos > start && info[new_reph_pos].indic_position() == POS_SMVD)
	new_reph_pos--;

1125 1126 1127 1128 1129 1130 1131
      /*
       * If the Reph is to be ending up after a Matra,Halant sequence,
       * position it before that Halant so it can interact with the Matra.
       * However, if it's a plain Consonant,Halant we shouldn't do that.
       * Uniscribe doesn't do this.
       * TEST: U+0930,U+094D,U+0915,U+094B,U+094D
       */
1132
      if (!indic_options ().uniscribe_bug_compatible &&
1133
	  unlikely (is_halant_or_coeng (info[new_reph_pos]))) {
1134 1135 1136 1137 1138 1139 1140
	for (unsigned int i = base + 1; i < new_reph_pos; i++)
	  if (info[i].indic_category() == OT_M) {
	    /* Ok, got it. */
	    new_reph_pos--;
	  }
      }
      goto reph_move;
1141 1142
    }

1143 1144
    reph_move:
    {
1145 1146 1147
      /* Yay, one big cluster! Merge before moving. */
      buffer->merge_clusters (start, end);

1148 1149 1150 1151 1152
      /* Move */
      hb_glyph_info_t reph = info[start];
      memmove (&info[start], &info[start + 1], (new_reph_pos - start) * sizeof (info[0]));
      info[new_reph_pos] = reph;
    }
1153 1154 1155 1156
  }


  /*   o Reorder pre-base reordering consonants:
1157 1158 1159 1160 1161
   *
   *     If a pre-base reordering consonant is found, reorder it according to
   *     the following rules:
   */

1162
  if (indic_plan->mask_array[PREF] && base + 1 < end) /* Otherwise there can't be any pre-base reordering Ra. */
1163
  {
1164
    for (unsigned int i = base + 1; i < end; i++)
1165
      if ((info[i].mask & indic_plan->mask_array[PREF]) != 0)
1166
      {
1167 1168 1169 1170
	/*       1. Only reorder a glyph produced by substitution during application
	 *          of the <pref> feature. (Note that a font may shape a Ra consonant with
	 *          the feature generally but block it in certain contexts.)
	 */
1171
	if (i + 1 == end || (info[i + 1].mask & indic_plan->mask_array[PREF]) == 0)
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	{
	  /*
	   *       2. Try to find a target position the same way as for pre-base matra.
	   *          If it is found, reorder pre-base consonant glyph.
	   *
	   *       3. If position is not found, reorder immediately before main
	   *          consonant.
	   */

	  unsigned int new_pos = base;
1182 1183 1184 1185 1186
	  /* Malayalam / Tamil do not have "half" forms or explicit virama forms.
	   * The glyphs formed by 'half' are Chillus or ligated explicit viramas.
	   * We want to position matra after them.
	   */
	  if (buffer->props.script != HB_SCRIPT_MALAYALAM && buffer->props.script != HB_SCRIPT_TAMIL)
1187
	  {
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	    while (new_pos > start &&
		   !(is_one_of (info[new_pos - 1], FLAG(OT_M) | HALANT_OR_COENG_FLAGS)))
	      new_pos--;

	    /* In Khmer coeng model, a V,Ra can go *after* matras.  If it goes after a
	     * split matra, it should be reordered to *before* the left part of such matra. */
	    if (new_pos > start && info[new_pos - 1].indic_category() == OT_M)
	    {
	      unsigned int old_pos = i;
	      for (unsigned int i = base + 1; i < old_pos; i++)
		if (info[i].indic_category() == OT_M)
		{
		  new_pos--;
		  break;
		}
	    }
1204 1205
	  }

1206
	  if (new_pos > start && is_halant_or_coeng (info[new_pos - 1]))
1207 1208 1209 1210 1211 1212
	    /* -> If ZWJ or ZWNJ follow this halant, position is moved after it. */
	    if (new_pos < end && is_joiner (info[new_pos]))
	      new_pos++;

	  {
	    unsigned int old_pos = i;
1213
	    buffer->merge_clusters (new_pos, old_pos + 1);
1214 1215 1216 1217 1218 1219 1220
	    hb_glyph_info_t tmp = info[old_pos];
	    memmove (&info[new_pos + 1], &info[new_pos], (old_pos - new_pos) * sizeof (info[0]));
	    info[new_pos] = tmp;
	  }
	}

        break;
1221
      }
1222
  }
1223 1224


1225
  /* Apply 'init' to the Left Matra if it's a word start. */
1226
  if (info[start].indic_position () == POS_PRE_M &&
1227
      (!start ||
B
Minor  
Behdad Esfahbod 已提交
1228
       !(FLAG (_hb_glyph_info_get_general_category (&info[start - 1])) &
1229
	 FLAG_RANGE (HB_UNICODE_GENERAL_CATEGORY_FORMAT, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK))))
1230
    info[start].mask |= indic_plan->mask_array[INIT];
1231

1232

B
Behdad Esfahbod 已提交
1233 1234 1235
  /*
   * Finish off the clusters and go home!
   */
B
Behdad Esfahbod 已提交
1236
  if (indic_options ().uniscribe_bug_compatible)
1237
  {
1238
    /* Uniscribe merges the entire cluster.
1239 1240 1241
     * This means, half forms are submerged into the main consonants cluster.
     * This is unnecessary, and makes cursor positioning harder, but that's what
     * Uniscribe does. */
1242
    buffer->merge_clusters (start, end);
1243
  }
1244
}
1245 1246


1247
static void
1248
final_reordering (const hb_ot_shape_plan_t *plan,
1249
		  hb_font_t *font,
B
Behdad Esfahbod 已提交
1250
		  hb_buffer_t *buffer)
1251 1252
{
  unsigned int count = buffer->len;
1253
  if (unlikely (!count)) return;
1254 1255 1256

  hb_glyph_info_t *info = buffer->info;
  unsigned int last = 0;
1257
  unsigned int last_syllable = info[0].syllable();
1258
  for (unsigned int i = 1; i < count; i++)
1259
    if (last_syllable != info[i].syllable()) {
1260
      final_reordering_syllable (plan, buffer, last, i);
1261
      last = i;
1262
      last_syllable = info[last].syllable();
1263
    }
1264
  final_reordering_syllable (plan, buffer, last, count);
1265

1266 1267 1268 1269
  /* Zero syllables now... */
  for (unsigned int i = 0; i < count; i++)
    info[i].syllable() = 0;

B
Behdad Esfahbod 已提交
1270 1271 1272 1273 1274
  HB_BUFFER_DEALLOCATE_VAR (buffer, indic_category);
  HB_BUFFER_DEALLOCATE_VAR (buffer, indic_position);
}


1275
static hb_ot_shape_normalization_mode_t
1276
normalization_preference_indic (const hb_segment_properties_t *props)
1277 1278 1279 1280
{
  return HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT;
}

1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
static hb_bool_t
decompose_indic (hb_unicode_funcs_t *unicode,
		 hb_codepoint_t  ab,
		 hb_codepoint_t *a,
		 hb_codepoint_t *b)
{
  switch (ab)
  {
    /* Don't decompose these. */
    case 0x0931  : return false;
    case 0x0B94  : return false;


    /*
     * Decompose split matras that don't have Unicode decompositions.
     */

    case 0x0F77  : *a = 0x0FB2; *b= 0x0F81; return true;
    case 0x0F79  : *a = 0x0FB3; *b= 0x0F81; return true;
    case 0x17BE  : *a = 0x17C1; *b= 0x17BE; return true;
    case 0x17BF  : *a = 0x17C1; *b= 0x17BF; return true;
    case 0x17C0  : *a = 0x17C1; *b= 0x17C0; return true;
    case 0x17C4  : *a = 0x17C1; *b= 0x17C4; return true;
    case 0x17C5  : *a = 0x17C1; *b= 0x17C5; return true;
    case 0x1925  : *a = 0x1920; *b= 0x1923; return true;
    case 0x1926  : *a = 0x1920; *b= 0x1924; return true;
    case 0x1B3C  : *a = 0x1B42; *b= 0x1B3C; return true;
    case 0x1112E  : *a = 0x11127; *b= 0x11131; return true;
    case 0x1112F  : *a = 0x11127; *b= 0x11132; return true;
#if 0
    /* This one has no decomposition in Unicode, but needs no decomposition either. */
    /* case 0x0AC9  : return false; */
    case 0x0B57  : *a = no decomp, -> RIGHT; return true;
    case 0x1C29  : *a = no decomp, -> LEFT; return true;
    case 0xA9C0  : *a = no decomp, -> RIGHT; return true;
    case 0x111BF  : *a = no decomp, -> ABOVE; return true;
#endif
  }

  if (indic_options ().uniscribe_bug_compatible)
  switch (ab)
  {
    /* These Sinhala ones have Unicode decompositions, but Uniscribe
     * decomposes them "Khmer-style". */
    case 0x0DDA  : *a = 0x0DD9; *b= 0x0DDA; return true;
    case 0x0DDC  : *a = 0x0DD9; *b= 0x0DDC; return true;
    case 0x0DDD  : *a = 0x0DD9; *b= 0x0DDD; return true;
    case 0x0DDE  : *a = 0x0DD9; *b= 0x0DDE; return true;
  }

  return unicode->decompose (ab, a, b);
}

static hb_bool_t
compose_indic (hb_unicode_funcs_t *unicode,
	       hb_codepoint_t  a,
	       hb_codepoint_t  b,
	       hb_codepoint_t *ab)
{
  /* Avoid recomposing split matras. */
  if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (unicode->general_category (a)))
    return false;

  /* Composition-exclusion exceptions that we want to recompose. */
  if (a == 0x09AF && b == 0x09BC) { *ab = 0x09DF; return true; }

  return unicode->compose (a, b, ab);
}


1351 1352 1353 1354 1355
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_indic =
{
  "indic",
  collect_features_indic,
  override_features_indic,
1356 1357
  data_create_indic,
  data_destroy_indic,
1358
  NULL, /* preprocess_text */
1359
  normalization_preference_indic,
1360 1361
  decompose_indic,
  compose_indic,
1362
  setup_masks_indic,
1363
  false, /* zero_width_attached_marks */
1364
  false, /* fallback_position */
1365
};