Grcov report - myanmar.rs

1

//! Implementation of font shaping for Myanmar scripts

2

3

use log::debug;

4

5

use crate::error::{ComplexScriptError, ParseError, ShapingError};

6

use crate::gsub::{self, Feature, FeatureMask, GlyphData, GlyphOrigin, RawGlyph, RawGlyphFlags};

7

use crate::layout::{FeatureTableSubstitution, GDEFTable, LayoutCache, LayoutTable, GSUB};

8

use crate::scripts::syllable::*;

9

use crate::tinyvec::tiny_vec;

10

use crate::{tag, DOTTED_CIRCLE};

11

12

// "A practical maximum cluster length is 31 characters."

13

// https://learn.microsoft.com/en-us/typography/script-development/use#cluster-length

14

const MAX_CLUSTER_LEN: usize = 31;

15

16

// A fairly arbitrary limit for match_repeat_upto since we don't have easy access to

17

//  the in-flight cluster length at the moment.

18

const MAX_REPEAT: usize = MAX_CLUSTER_LEN / 3;

19

20

#[derive(Copy, Clone, Debug, PartialEq)]

21

enum BasicFeature {

22

    Locl,

23

    Ccmp,

24

    Rphf,

25

    Pref,

26

    Blwf,

27

    Pstf,

28

29

30

impl BasicFeature {

31

    const ALL: &'static [BasicFeature] = &[

32

        BasicFeature::Locl,

33

        BasicFeature::Ccmp,

34

        BasicFeature::Rphf,

35

        BasicFeature::Pref,

36

        BasicFeature::Blwf,

37

        BasicFeature::Pstf,

38

];

39

40

    fn feature(self) -> Feature {

41

        match self {

42

            BasicFeature::Locl => Feature::LOCL,

43

            BasicFeature::Ccmp => Feature::CCMP,

44

            BasicFeature::Rphf => Feature::RPHF,

45

            BasicFeature::Pref => Feature::PREF,

46

            BasicFeature::Blwf => Feature::BLWF,

47

            BasicFeature::Pstf => Feature::PSTF,

48

49

50

51

    // Returns `true` if feature applies to the entire glyph buffer.

52

    fn is_global(self) -> bool {

53

        match self {

54

            BasicFeature::Locl => true,

55

            BasicFeature::Ccmp => true,

56

            BasicFeature::Rphf => true,

57

            BasicFeature::Pref => true,

58

            BasicFeature::Blwf => true,

59

            BasicFeature::Pstf => true,

60

61

62

63

64

// NOTE(unused): ConsonantWithStacker variant is only constructed by Vedic extension characters,

65

// which aren't used yet.

66

#[allow(unused)]

67

#[derive(Copy, Clone, Debug, PartialEq)]

68

enum ShapingClass {

69

    Bindu,

70

    Visarga,

71

    PureKiller,

72

    Consonant,

73

    VowelIndependent,

74

    VowelDependent,

75

    ConsonantMedial,

76

    ConsonantPlaceholder,

77

    Number,

78

    Symbol,

79

    ToneMarker,

80

    InvisibleStacker,

81

    ConsonantWithStacker,

82

    Placeholder,

83

    Joiner,

84

    NonJoiner,

85

    DottedCircle,

86

87

88

#[derive(Copy, Clone, Debug)]

89

enum MarkPlacementSubclass {

90

    TopPosition,

91

    RightPosition,

92

    BottomPosition,

93

    LeftPosition,

94

    TopLeftAndBottomPosition,

95

96

97

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]

98

enum Pos {

99

    PrebaseMatra,

100

    PrebaseConsonant,

101

    SyllableBase,

102

    AfterMain,

103

    BeforeSubjoined,

104

    BelowbaseConsonant,

105

    AfterSubjoined,

106

107

108

/////////////////////////////////////////////////////////////////////////////

109

// Syllable state machine

110

/////////////////////////////////////////////////////////////////////////////

111

112

#[derive(Copy, Clone, Debug, PartialEq, Eq)]

113

enum Syllable {

114

    Valid,

115

    Broken,

116

117

118

fn shaping_class(ch: char) -> Option<ShapingClass> {

119

    let (shaping, _) = myanmar_character(ch);

120

    shaping

121

122

123

// C

124

//

125

// The definition of _consonant_ in the shaping docs excludes _ra_ but the only place it's

126

// used, 'C', adds _ra_ back in, so we skip that.

127

fn consonant(ch: char) -> bool {

128

    match shaping_class(ch) {

129

        Some(ShapingClass::Consonant | ShapingClass::ConsonantPlaceholder) => true,

130

        _ => false,

131

132

133

134

// _vowel_

135

fn vowel(ch: char) -> bool {

136

    matches!(shaping_class(ch), Some(ShapingClass::VowelIndependent))

137

138

139

// _d_

140

fn digit(ch: char) -> bool {

141

    shaping_class(ch) == Some(ShapingClass::Number)

142

143

144

// _gb_

145

fn generic_base(ch: char) -> bool {

146

    matches!(

147

ch,

148

        '\u{002D}'

149

            | '\u{00A0}'

150

            | '\u{00D7}'

151

            | '\u{2012}'

152

            | '\u{2013}'

153

            | '\u{2014}'

154

            | '\u{2015}'

155

            | '\u{2022}'

156

            | '\u{25CC}'

157

            | '\u{25FB}'

158

            | '\u{25FC}'

159

            | '\u{25FD}'

160

            | '\u{25FE}'

161

162

163

164

// Simple non-compounding cluster

165

//

166

// <P | S | R | WJ| WS | O | D0 >

167

//

168

// Punctuation (P), symbols (S), reserved characters from the Myanmar block (R), word joiner (WJ),

169

// white space (WS), and other SCRIPT_COMMON characters (O) contain one character per cluster.

170

fn standalone(ch: char) -> bool {

171

    let class = shaping_class(ch);

172

    matches!(ch,

173

        '\u{1000}'..='\u{109f}' | '\u{AA60}' ..= '\u{AA7F}' | '\u{A9E0}' ..= '\u{A9FF}'

174

    ) && (class.is_none() || class == Some(ShapingClass::Placeholder))

175

176

177

fn variation_selector(ch: char) -> bool {

178

    // At present, only "Variation Selector 1" (U+FE00) is used with Myanmar.

179

    ch == '\u{FE00}'

180

181

182

fn halant(ch: char) -> bool {

183

    shaping_class(ch) == Some(ShapingClass::InvisibleStacker)

184

185

186

fn zwj(ch: char) -> bool {

187

    matches!(shaping_class(ch), Some(ShapingClass::Joiner))

188

189

190

fn zwnj(ch: char) -> bool {

191

    matches!(shaping_class(ch), Some(ShapingClass::NonJoiner))

192

193

194

fn joiner(ch: char) -> bool {

195

    zwj(ch) || zwnj(ch)

196

197

198

fn ra(ch: char) -> bool {

199

    match ch {

200

        '\u{101B}' => true, // Ra

201

        '\u{1004}' => true, // Nga

202

        '\u{105A}' => true, // Mon Nga

203

        _ => false,

204

205

206

207

fn asat(ch: char) -> bool {

208

    ch == '\u{103A}' // Asat

209

210

211

fn consonant_with_stacker(ch: char) -> bool {

212

    matches!(shaping_class(ch), Some(ShapingClass::ConsonantWithStacker))

213

214

215

fn matra_pre(ch: char) -> bool {

216

    matches!(

217

        myanmar_character(ch),

218

219

            Some(ShapingClass::VowelDependent),

220

            Some(MarkPlacementSubclass::LeftPosition)

221

222

223

224

225

fn matra_post(ch: char) -> bool {

226

    matches!(

227

        myanmar_character(ch),

228

229

            Some(ShapingClass::VowelDependent),

230

            Some(MarkPlacementSubclass::RightPosition)

231

232

233

234

235

// "Anusvara" | "Sign Ai"

236

fn a(ch: char) -> bool {

237

    // Note: "Sign Ai" is classified as a, not as matraabove, in order to implement

238

    // orthographically correct behavior.

239

    ch == '\u{1036}' || ch == '\u{1032}'

240

241

242

fn dot_below(ch: char) -> bool {

243

    ch == '\u{1037}'

244

245

246

fn matra_above(ch: char) -> bool {

247

    !a(ch)

248

        && matches!(

249

            myanmar_character(ch),

250

251

                Some(ShapingClass::VowelDependent),

252

                Some(MarkPlacementSubclass::TopPosition)

253

254

255

256

257

fn matra_below(ch: char) -> bool {

258

    matches!(

259

        myanmar_character(ch),

260

261

            Some(ShapingClass::VowelDependent),

262

            Some(MarkPlacementSubclass::BottomPosition)

263

264

265

266

267

// "Medial Ha"

268

fn medial_ha(ch: char) -> bool {

269

    ch == '\u{103E}'

270

271

272

// "Mon Medial La"

273

fn medial_la(ch: char) -> bool {

274

    ch == '\u{1060}'

275

276

277

// Medial Ra

278

fn medial_ra(ch: char) -> bool {

279

    ch == '\u{103C}'

280

281

282

// "Medial Wa" | "Shan Medial Wa"

283

fn medial_wa(ch: char) -> bool {

284

    ch == '\u{103D}' || ch == '\u{1082}'

285

286

287

// "Medial Ya" | "Mon Medial Na" | "Mon Medial Ma"

288

fn medial_ya(ch: char) -> bool {

289

    ch == '\u{103B}' || ch == '\u{105E}' || ch == '\u{105F}'

290

291

292

// "Tone Sgaw Karen Hathi" | "Tone Sgaw Karen Ke Pho" | "Western Pwo Karen Tone 1"

293

// | "Western Pwo Karen Tone 2" | "Western Pwo Karen Tone 3" | "Western Pwo Karen Tone 4"

294

// | "Western Pwo Karen Tone 5" | "Pao Karen Tone"

295

fn pt(ch: char) -> bool {

296

    match ch {

297

        // U+1063 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၣ Tone Sgaw Karen Hathi

298

        // U+1064 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၤ Tone Sgaw Karen Ke Pho

299

        '\u{1063}' | '\u{1064}' => true,

300

        // U+1069 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၩ Sign Western Pwo Karen Tone 1

301

        // U+106A 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၪ Sign Western Pwo Karen Tone 2

302

        // U+106B 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၫ Sign Western Pwo Karen Tone 3

303

        // U+106C 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၬ Sign Western Pwo Karen Tone 4

304

        // U+106D 	Mark [Mc] 	TONE_MARKER 	RIGHT_POSITION 	ၭ Sign Western Pwo Karen Tone 5

305

        '\u{1069}'..='\u{106D}' => true,

306

        // U+AA7B	TONE_MARKER	RIGHT_POSITION	ꩻ Sign Pao Karen Tone

307

        '\u{AA7B}' => true,

308

        _ => false,

309

310

311

312

// _punc_ = "Little Section" | "Section"

313

fn punc(ch: char) -> bool {

314

    // ch == '\u{104A}' || ch == '\u{104B}'

315

    matches!(ch, '\u{104a}'..='\u{104f}')

316

317

318

// G = _gb_ | _d_ | _punc_

319

fn g(ch: char) -> bool {

320

    generic_base(ch) || digit(ch) || punc(ch)

321

322

323

// (C | _vowel_ | G)

324

fn initial_group(ch: char) -> bool {

325

    consonant(ch) || vowel(ch) || g(ch)

326

327

328

// _ra_ _asat_ _halant_

329

fn match_kinzi<T: SyllableChar>(cs: &[T]) -> Option<usize> {

330

    match_seq(match_one(ra), match_seq(match_one(asat), match_one(halant)))(cs)

331

332

333

fn match_z<T: SyllableChar>(cs: &[T]) -> Option<usize> {

334

    match_one(joiner)(cs)

335

336

337

// _matrapre_* _matraabove_* _matrabelow_* _a_* (_db_ _asat_?)?

338

fn match_vmain<T: SyllableChar>(cs: &[T]) -> Option<usize> {

339

    match_repeat_upto(

340

        MAX_REPEAT,

341

        match_one(matra_pre),

342

        match_repeat_upto(

343

4,

344

            match_one(matra_above),

345

            match_repeat_upto(

346

4,

347

                match_one(matra_below),

348

                match_repeat_upto(

349

4,

350

                    match_one(a),

351

                    match_optional(match_seq(

352

                        match_one(dot_below),

353

                        match_optional(match_one(asat)),

354

)),

355

),

356

),

357

),

358

    )(cs)

359

360

361

// _matrapost_ _mh_? _asat_* _matraabove_* _a_* (_db_ _asat_?)?

362

fn match_vpost<T: SyllableChar>(cs: &[T]) -> Option<usize> {

363

    match_seq(

364

        match_one(matra_post),

365

        match_repeat_upto(

366

4,

367

            match_optional(match_one(medial_ha)),

368

            match_repeat_upto(

369

4,

370

                match_one(asat),

371

                match_repeat_upto(

372

4,

373

                    match_one(matra_above),

374

                    match_repeat_upto(

375

4,

376

                        match_one(a),

377

                        match_optional(match_seq(

378

                            match_one(dot_below),

379

                            match_optional(match_one(asat)),

380

)),

381

),

382

),

383

),

384

),

385

    )(cs)

386

387

388

// _pt_ _a_* _db_? _asat_?

389

fn match_pwo<T: SyllableChar>(cs: &[T]) -> Option<usize> {

390

    match_seq(

391

        match_one(pt),

392

        match_repeat_upto(

393

            MAX_REPEAT,

394

            match_one(a),

395

            match_seq(

396

                match_optional(match_one(dot_below)),

397

                match_optional(match_one(asat)),

398

),

399

),

400

    )(cs)

401

402

403

fn visarga(ch: char) -> bool {

404

    shaping_class(ch) == Some(ShapingClass::Visarga)

405

406

407

fn sm(ch: char) -> bool {

408

    match ch {

409

        // Shan Tone 2, 3, 5, 6, Shan Council Tone 2, 3, Emphatic

410

        '\u{1087}'..='\u{108D}' => true,

411

        // Rumai Palaung Tone 5

412

        '\u{108F}' => true,

413

        // Khamti Tone 1, 3, Aiton A

414

        '\u{109A}'..='\u{109C}' => true,

415

        // Visarga

416

        _ if visarga(ch) => true,

417

        _ => false,

418

419

420

421

// Tcomplex= _asat_* Med Vmain Vpost* Pwo* _sm_* Z?

422

fn match_t_complex<T: SyllableChar>(cs: &[T]) -> Option<usize> {

423

    match_repeat_upto(

424

        MAX_REPEAT,

425

        match_one(asat),

426

        match_seq(

427

            match_medial_group,

428

            match_seq(

429

                match_vmain,

430

                match_repeat_upto(

431

                    MAX_REPEAT,

432

                    match_vpost,

433

                    match_repeat_upto(

434

                        MAX_REPEAT,

435

                        match_pwo,

436

                        match_repeat_upto(MAX_REPEAT, match_one(sm), match_optional(match_z)),

437

),

438

),

439

),

440

),

441

    )(cs)

442

443

444

// _halant_ | Tcomplex

445

fn match_syllable_tail<T: SyllableChar>(cs: &[T]) -> Option<usize> {

446

    match_either(match_one(halant), match_t_complex)(cs)

447

448

449

// (_halant_ (C | _vowel_) _vs_?)

450

fn match_halant_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

451

    match_seq(

452

        match_seq(

453

            match_one(halant),

454

            match_either(match_one(consonant), match_one(vowel)),

455

),

456

        match_optional(match_one(variation_selector)),

457

    )(cs)

458

459

460

// Med = _my_? _asat_? _mr_? ( (mw mh? ml? | mh ml? | ml) asat?)?

461

fn match_medial_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

462

    match_optional_seq(

463

        match_one(medial_ya),

464

        match_optional_seq(

465

            match_one(asat),

466

            match_optional_seq(match_one(medial_ra), match_optional(match_medial_group2)),

467

),

468

    )(cs)

469

470

471

// (mw mh? ml? | mh ml? | ml) asat?

472

fn match_medial_group2<T: SyllableChar>(cs: &[T]) -> Option<usize> {

473

    match_seq(

474

        match_either(

475

            match_medial_group2a,

476

            match_either(match_medial_group2b, match_one(medial_la)),

477

),

478

        match_optional(match_one(asat)),

479

    )(cs)

480

481

482

// mw mh? ml?

483

fn match_medial_group2a<T: SyllableChar>(cs: &[T]) -> Option<usize> {

484

    match_seq(

485

        match_one(medial_wa),

486

        match_optional_seq(match_one(medial_ha), match_optional(match_one(medial_la))),

487

    )(cs)

488

489

490

// mh ml?

491

fn match_medial_group2b<T: SyllableChar>(cs: &[T]) -> Option<usize> {

492

    match_seq(match_one(medial_ha), match_optional(match_one(medial_la)))(cs)

493

494

495

// (C | _vowel_ | G)

496

fn match_initial_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

497

    match_one(initial_group)(cs)

498

499

500

// (K | _cs_)? (C | _vowel_ | G) _vs_? (_halant_ (C | _vowel_) _vs_?)* Tail

501

fn match_consonant_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

502

    match_optional_seq(

503

        match_either(match_kinzi, match_one(consonant_with_stacker)),

504

        match_seq(

505

            match_initial_group,

506

            match_optional_seq(

507

                match_one(variation_selector),

508

                match_repeat_upto(MAX_REPEAT, match_halant_group, match_syllable_tail),

509

),

510

),

511

    )(cs)

512

513

514

fn match_standalone<T: SyllableChar>(cs: &[T]) -> Option<usize> {

515

    match_one(standalone)(cs)

516

517

518

fn match_syllable<T: SyllableChar>(cs: &[T]) -> Option<(usize, Syllable)> {

519

    match match_consonant_syllable(cs) {

520

        Some(len) => Some((len, Syllable::Valid)),

521

        None => match_standalone(cs).map(|len| (len, Syllable::Broken)),

522

523

524

525

/////////////////////////////////////////////////////////////////////////////

526

// Shaping

527

/////////////////////////////////////////////////////////////////////////////

528

529

#[derive(Clone, Debug)]

530

struct MyanmarData {

531

    pos: Option<Pos>,

532

    mask: FeatureMask,

533

534

535

impl GlyphData for MyanmarData {

536

    /// Merge semantics for MyanmarData. The values that get used in the merged

537

    /// glyph are the values belonging to the glyph with the higher merge

538

    /// precedence.

539

///

540

    /// Merge precedence:

541

///

542

    ///   1. SyllableBase

543

    ///   2. PrebaseConsonant

544

    ///   3. !None

545

    ///   4. None (shouldn't happen - all glyphs should be tagged by this point)

546

    fn merge(data1: MyanmarData, data2: MyanmarData) -> MyanmarData {

547

        match (data1.pos, data2.pos) {

548

            (Some(Pos::SyllableBase), _) => data1,

549

            (_, Some(Pos::SyllableBase)) => data2,

550

            (Some(Pos::PrebaseConsonant), _) => data1,

551

            (_, Some(Pos::PrebaseConsonant)) => data2,

552

            (_, None) => data1,

553

            (None, _) => data2,

554

            _ => data1, // Default

555

556

557

558

559

type RawGlyphMyanmar = RawGlyph<MyanmarData>;

560

561

impl RawGlyphMyanmar {

562

    fn is(&self, pred: impl FnOnce(char) -> bool) -> bool {

563

        match self.glyph_origin {

564

            GlyphOrigin::Char(c) => pred(c),

565

            GlyphOrigin::Direct => false,

566

567

568

569

    fn set_pos(&mut self, pos: Option<Pos>) {

570

        self.extra_data.pos = pos

571

572

573

    fn pos(&self) -> Option<Pos> {

574

        self.extra_data.pos

575

576

577

    fn has_mask(&self, mask: FeatureMask) -> bool {

578

        self.extra_data.mask.contains(mask)

579

580

581

582

struct MyanmarShapingData<'tables> {

583

    gsub_cache: &'tables LayoutCache<GSUB>,

584

    gsub_table: &'tables LayoutTable<GSUB>,

585

    gdef_table: Option<&'tables GDEFTable>,

586

    script_tag: u32,

587

    lang_tag: Option<u32>,

588

    feature_variations: Option<&'tables FeatureTableSubstitution<'tables>>,

589

590

591

impl MyanmarShapingData<'_> {

592

    fn get_lookups_cache_index(&self, mask: FeatureMask) -> Result<usize, ParseError> {

593

        gsub::get_lookups_cache_index(

594

            self.gsub_cache,

595

            self.script_tag,

596

            self.lang_tag,

597

            self.feature_variations,

598

            mask,

599

600

601

602

    fn apply_lookup(

603

        &self,

604

        lookup_index: usize,

605

        feature_tag: u32,

606

        glyphs: &mut Vec<RawGlyphMyanmar>,

607

        max_glyphs: usize,

608

        pred: impl Fn(&RawGlyphMyanmar) -> bool,

609

    ) -> Result<(), ParseError> {

610

        gsub::gsub_apply_lookup(

611

            self.gsub_cache,

612

            self.gsub_table,

613

            self.gdef_table,

614

            lookup_index,

615

            feature_tag,

616

            None,

617

            glyphs,

618

            max_glyphs,

619

0,

620

            glyphs.len(),

621

            pred,

622

)?;

623

        Ok(())

624

625

626

627

/// Does the following:

628

///   * Splits syllables

629

///   * Inserts dotted circles into broken syllables

630

///   * Initial reordering

631

///   * Applies basic features

632

///   * Final reordering

633

///   * Applies presentation features

634

pub fn gsub_apply_myanmar<'a>(

635

    dotted_circle_index: u16,

636

    gsub_cache: &'a LayoutCache<GSUB>,

637

    gsub_table: &'a LayoutTable<GSUB>,

638

    gdef_table: Option<&'a GDEFTable>,

639

    lang_tag: Option<u32>,

640

    feature_variations: Option<&'a FeatureTableSubstitution<'a>>,

641

    extra_features: FeatureMask,

642

    glyphs: &mut Vec<RawGlyph<()>>,

643

) -> Result<(), ShapingError> {

644

    if glyphs.is_empty() {

645

        return Err(ComplexScriptError::EmptyBuffer.into());

646

647

648

    // > The script tag for Myanmar script for use with the Myanmar shaping engine is mym2 and not

649

    // > mymr. The script tag mymr has limited support and should not be used.

650

    let script_tag = tag::MYM2;

651

    let mut syllables = to_myanmar_syllables(glyphs);

652

    let shaping_data = MyanmarShapingData {

653

        gsub_cache,

654

        gsub_table,

655

        gdef_table,

656

        script_tag,

657

        lang_tag,

658

        feature_variations,

659

};

660

661

    for i in 0..syllables.len() {

662

        let (syllable, syllable_type) = &mut syllables[i];

663

        if let Err(err) = shape_syllable(

664

            dotted_circle_index,

665

            &shaping_data,

666

            syllable,

667

            *syllable_type,

668

            extra_features,

669

) {

670

            debug!("gsub apply myanmar: {}", err);

671

672

673

674

    *glyphs = syllables

675

        .into_iter()

676

        .flat_map(|(s, _)| s.into_iter())

677

        .map(from_raw_glyph_myanmar)

678

        .collect();

679

680

    Ok(())

681

682

683

fn shape_syllable(

684

    dotted_circle_index: u16,

685

    shaping_data: &MyanmarShapingData<'_>,

686

    syllable: &mut Vec<RawGlyphMyanmar>,

687

    syllable_type: Syllable,

688

    extra_features: FeatureMask,

689

) -> Result<(), ShapingError> {

690

    let max_glyphs = syllable.len().saturating_mul(gsub::MAX_GLYPHS_FACTOR);

691

692

    // Add a dotted circle to broken syllables so they can be treated

693

    // like standalone syllables

694

    // https://github.com/n8willis/opentype-shaping-documents/issues/45

695

    if syllable_type == Syllable::Broken {

696

        insert_dotted_circle(dotted_circle_index, syllable)?;

697

698

699

    match syllable_type {

700

        Syllable::Valid | Syllable::Broken => {

701

            initial_reorder_consonant_syllable(shaping_data, syllable)?;

702

            apply_basic_features(shaping_data, syllable, max_glyphs)?;

703

            apply_presentation_features(shaping_data, syllable, max_glyphs, extra_features)?;

704

705

706

707

    Ok(())

708

709

710

fn insert_dotted_circle(

711

    dotted_circle_index: u16,

712

    glyphs: &mut Vec<RawGlyphMyanmar>,

713

) -> Result<(), ComplexScriptError> {

714

    if dotted_circle_index == 0 {

715

        return Err(ComplexScriptError::MissingDottedCircle);

716

717

718

    let dotted_circle = RawGlyphMyanmar {

719

        unicodes: tiny_vec![[char; 1] => DOTTED_CIRCLE],

720

        glyph_index: dotted_circle_index,

721

        liga_component_pos: 0,

722

        glyph_origin: GlyphOrigin::Char(DOTTED_CIRCLE),

723

        flags: RawGlyphFlags::empty(),

724

        variation: None,

725

        extra_data: MyanmarData {

726

            pos: None,

727

            mask: FeatureMask::empty(),

728

},

729

};

730

    glyphs.insert(0, dotted_circle);

731

732

    Ok(())

733

734

735

/// Splits the input glyph buffer and collects it into a vector of Myanmar syllables.

736

fn to_myanmar_syllables(mut glyphs: &[RawGlyph<()>]) -> Vec<(Vec<RawGlyphMyanmar>, Syllable)> {

737

    let mut syllables: Vec<(Vec<RawGlyphMyanmar>, Syllable)> = Vec::new();

738

739

    while !glyphs.is_empty() {

740

        let len = match match_syllable(glyphs) {

741

            Some((len, syllable_type)) => {

742

                assert_ne!(len, 0);

743

                let syllable = glyphs[..len].iter().map(to_raw_glyph_myanmar).collect();

744

                syllables.push((syllable, syllable_type));

745

len

746

747

            None => {

748

                let invalid_glyph = to_raw_glyph_myanmar(&glyphs[0]);

749

                match syllables.last_mut() {

750

                    // If the last syllable in `syllables` is invalid, just append

751

                    // this invalid glyph to that syllable

752

                    Some((invalid_syllable, Syllable::Broken)) => {

753

                        invalid_syllable.push(invalid_glyph)

754

755

                    // Collect invalid glyphs

756

                    _ => syllables.push((vec![invalid_glyph], Syllable::Broken)),

757

758

759

760

761

};

762

763

        glyphs = &glyphs[len..];

764

765

766

    syllables

767

768

769

/////////////////////////////////////////////////////////////////////////////

770

// Initial reordering

771

/////////////////////////////////////////////////////////////////////////////

772

773

// The initial reordering stage is used to relocate glyphs from the phonetic order in which they

774

// occur in a run of text to the orthographic order in which they are presented visually.

775

//

776

// Primarily, this means moving dependent-vowel (matra) glyphs, "Kinzi"-forming sequences, and

777

// pre-base-reordering medial consonants.

778

779

fn initial_reorder_consonant_syllable(

780

    shaping_data: &MyanmarShapingData<'_>,

781

    glyphs: &mut [RawGlyphMyanmar],

782

) -> Result<(), ShapingError> {

783

    let _base_index = tag_syllable(shaping_data, glyphs)?;

784

785

    // Check that no glyphs have been left untagged, then reorder glyphs

786

    // to canonical order

787

    if glyphs.iter().any(|g| g.pos().is_none()) {

788

        return Err(ComplexScriptError::MissingTags.into());

789

    } else {

790

        glyphs.sort_by_key(|g| g.pos());

791

792

793

    Ok(())

794

795

796

/// Assign `Pos` tags to consonants in a syllable. Return the index of the base consonant, or `None`

797

/// if base consonant does not exist.

798

fn tag_syllable(

799

    _shaping_data: &MyanmarShapingData<'_>,

800

    glyphs: &mut [RawGlyphMyanmar],

801

) -> Result<Option<usize>, ShapingError> {

802

    let mut base_index = None;

803

    let mut i = 0;

804

    let start;

805

806

    // Check for initial Kinzi

807

//

808

    // The first consonant of a syllable is always the base consonant, excluding a consonant that

809

    // is part of an initial "Kinzi"-forming sequence (if it is present).

810

//

811

    // "Kinzi" is always encoded as a syllable-initial sequence, but it is reordered. The final

812

    // position of "Kinzi" is immediately after the base consonant.

813

    if let Some(len) = match_kinzi(glyphs) {

814

        // Tag the Kinzi (reordering step 2.5)

815

        glyphs[..len]

816

            .iter_mut()

817

            .for_each(|glyph| glyph.set_pos(Some(Pos::AfterMain)));

818

819

        // skip

820

        i += len;

821

        start = i;

822

    } else {

823

        start = 0;

824

825

826

    // Find base consonant

827

    while i < glyphs.len() {

828

        let glyph = &glyphs[i];

829

830

        if glyph.is(initial_group) {

831

            // We have identified the base consonant

832

            let glyph = &mut glyphs[i];

833

            glyph.set_pos(Some(Pos::SyllableBase));

834

            base_index = Some(i);

835

            break;

836

837

838

        i += 1;

839

840

841

    let base = base_index.unwrap_or(start); // FIXME: What should the base default to?

842

843

    // Init everything that comes before the base to PrebaseConsonant

844

    glyphs[start..base]

845

        .iter_mut()

846

        .for_each(|glyph| glyph.set_pos(Some(Pos::PrebaseConsonant)));

847

848

    // Now process everything after the base

849

    let mut pos = Pos::AfterMain;

850

    for i in (base..glyphs.len()).skip(1) {

851

        // split_at allows glyphs before i to be mutated, as well as glyphs[i]

852

        let (before_i, rest) = glyphs.split_at_mut(i);

853

        let glyph = &mut rest[0];

854

855

        // Reordering step 2.4 - Pre-base-reordering consonants

856

        if glyph.is(medial_ra) {

857

            glyph.set_pos(Some(Pos::PrebaseConsonant))

858

859

        // Any ANUSVARA marks appearing after a below-base vowel sign must be tagged

860

        // with POS_BEFORE_SUBJOINED

861

        else if glyph.is(a)

862

            && prev_glyph_skip(before_i, a)

863

                .is_some_and(|prev| prev.pos() == Some(Pos::BelowbaseConsonant))

864

865

            glyph.set_pos(Some(Pos::BeforeSubjoined))

866

867

        // Variation selectors are tagged with the same tag as the preceding glyph

868

        else if glyph.is(variation_selector) {

869

            if let Some(prev) = i.checked_sub(1) {

870

                glyph.set_pos(before_i[prev].pos())

871

872

873

        // Matras

874

        else if pos == Pos::AfterMain && glyph.pos() == Some(Pos::BelowbaseConsonant) {

875

            pos = Pos::BelowbaseConsonant

876

        } else if pos == Pos::BelowbaseConsonant && !glyph.is(a) {

877

            pos = Pos::AfterSubjoined;

878

            // FIXME: Should this just check for None?

879

            if glyph.pos() != Some(Pos::BelowbaseConsonant) {

880

                glyph.set_pos(Some(pos))

881

882

        } else if glyph.pos().is_none() {

883

            glyph.set_pos(Some(pos))

884

885

886

887

    Ok(base_index)

888

889

890

// Return the previous glyph, skipping over those that match the predicate

891

fn prev_glyph_skip(

892

    glyphs: &[RawGlyphMyanmar],

893

    pred: impl Fn(char) -> bool,

894

) -> Option<&RawGlyphMyanmar> {

895

    glyphs.iter().rev().find(|g| !g.is(&pred))

896

897

898

/////////////////////////////////////////////////////////////////////////////

899

// Basic substitution features

900

/////////////////////////////////////////////////////////////////////////////

901

902

/// Applies Myanmar basic features in their required order

903

fn apply_basic_features(

904

    shaping_data: &MyanmarShapingData<'_>,

905

    glyphs: &mut Vec<RawGlyphMyanmar>,

906

    max_glyphs: usize,

907

) -> Result<(), ParseError> {

908

    for feature in BasicFeature::ALL {

909

        let index = shaping_data.get_lookups_cache_index(feature.feature().mask())?;

910

        let lookups = &shaping_data.gsub_cache.cached_lookups.lock().unwrap()[index];

911

912

        for &(lookup_index, feature_tag) in lookups {

913

            shaping_data.apply_lookup(lookup_index, feature_tag, glyphs, max_glyphs, |g| {

914

                feature.is_global() || g.has_mask(feature.feature().mask())

915

            })?;

916

917

918

919

    Ok(())

920

921

922

/////////////////////////////////////////////////////////////////////////////

923

// Remaining substitution features

924

/////////////////////////////////////////////////////////////////////////////

925

926

/// Apply remaining substitution features after final reordering.

927

///

928

/// The order in which the remaining features are applied should be in

929

/// the order in which they appear in the GSUB table.

930

fn apply_presentation_features(

931

    shaping_data: &MyanmarShapingData<'_>,

932

    glyphs: &mut Vec<RawGlyphMyanmar>,

933

    max_glyphs: usize,

934

    extra_features: FeatureMask,

935

) -> Result<(), ParseError> {

936

    let features = Feature::PRES

937

        | Feature::ABVS

938

        | Feature::BLWS

939

        | Feature::PSTS

940

        | Feature::LIGA

941

        | Feature::RLIG

942

        | extra_features;

943

944

    let index = shaping_data.get_lookups_cache_index(features)?;

945

    let lookups = &shaping_data.gsub_cache.cached_lookups.lock().unwrap()[index];

946

947

    for &(lookup_index, feature_tag) in lookups {

948

        shaping_data.apply_lookup(lookup_index, feature_tag, glyphs, max_glyphs, |_g| true)?;

949

950

951

    Ok(())

952

953

954

/////////////////////////////////////////////////////////////////////////////

955

// Helper functions

956

/////////////////////////////////////////////////////////////////////////////

957

958

fn to_raw_glyph_myanmar(glyph: &RawGlyph<()>) -> RawGlyphMyanmar {

959

    let pos = match myanmar_character(glyph.char()) {

960

        (Some(ShapingClass::VowelDependent), Some(placement)) => match placement {

961

            // If the syllable contains any below-base dependent-vowel (matra) signs, then

962

            // those below-base matra signs must be tagged with POS_BELOWBASE_CONSONANT.

963

            MarkPlacementSubclass::BottomPosition => Some(Pos::BelowbaseConsonant),

964

            // All left-side dependent-vowel (matra) signs must be tagged to be moved to the

965

            // beginning of the syllable, with POS_PREBASE_MATRA.

966

            MarkPlacementSubclass::LeftPosition => Some(Pos::PrebaseMatra),

967

            MarkPlacementSubclass::TopLeftAndBottomPosition

968

            | MarkPlacementSubclass::RightPosition

969

            | MarkPlacementSubclass::TopPosition => None,

970

},

971

        _ => None,

972

};

973

974

    RawGlyphMyanmar {

975

        unicodes: glyph.unicodes.clone(),

976

        glyph_index: glyph.glyph_index,

977

        liga_component_pos: glyph.liga_component_pos,

978

        glyph_origin: glyph.glyph_origin,

979

        flags: glyph.flags,

980

        variation: glyph.variation,

981

        extra_data: MyanmarData {

982

            pos,

983

            mask: FeatureMask::empty(),

984

},

985

986

987

988

fn from_raw_glyph_myanmar(glyph: RawGlyphMyanmar) -> RawGlyph<()> {

989

    RawGlyph {

990

        unicodes: glyph.unicodes,

991

        glyph_index: glyph.glyph_index,

992

        liga_component_pos: glyph.liga_component_pos,

993

        glyph_origin: glyph.glyph_origin,

994

        flags: glyph.flags,

995

        variation: glyph.variation,

996

        extra_data: (),

997

998

999

1000

/////////////////////////////////////////////////////////////////////////////

1001

// Myanmar character tables

1002

/////////////////////////////////////////////////////////////////////////////

1003

1004

fn myanmar_character(ch: char) -> (Option<ShapingClass>, Option<MarkPlacementSubclass>) {

1005

    use MarkPlacementSubclass::*;

1006

    use ShapingClass::*;

1007

1008

    match ch as u32 {

1009

        // Myanmar character table

1010

        0x1000 => (Some(Consonant), None),        // က Ka

1011

        0x1001 => (Some(Consonant), None),        // ခ Kha

1012

        0x1002 => (Some(Consonant), None),        // ဂ Ga

1013

        0x1003 => (Some(Consonant), None),        // ဃ Gha

1014

        0x1004 => (Some(Consonant), None),        // င Nga

1015

        0x1005 => (Some(Consonant), None),        // စ Ca

1016

        0x1006 => (Some(Consonant), None),        // ဆ Cha

1017

        0x1007 => (Some(Consonant), None),        // ဇ Ja

1018

        0x1008 => (Some(Consonant), None),        // ဈ Jha

1019

        0x1009 => (Some(Consonant), None),        // ဉ Nya

1020

        0x100A => (Some(Consonant), None),        // ည Nnya

1021

        0x100B => (Some(Consonant), None),        // ဋ Tta

1022

        0x100C => (Some(Consonant), None),        // ဌ Ttha

1023

        0x100D => (Some(Consonant), None),        // ဍ Dda

1024

        0x100E => (Some(Consonant), None),        // ဎ DDha

1025

        0x100F => (Some(Consonant), None),        // ဏ Nna

1026

        0x1010 => (Some(Consonant), None),        // တ Ta

1027

        0x1011 => (Some(Consonant), None),        // ထ Tha

1028

        0x1012 => (Some(Consonant), None),        // ဒ Da

1029

        0x1013 => (Some(Consonant), None),        // ဓ Dha

1030

        0x1014 => (Some(Consonant), None),        // န Na

1031

        0x1015 => (Some(Consonant), None),        // ပ Pa

1032

        0x1016 => (Some(Consonant), None),        // ဖ Pha

1033

        0x1017 => (Some(Consonant), None),        // ဗ Ba

1034

        0x1018 => (Some(Consonant), None),        // ဘ Bha

1035

        0x1019 => (Some(Consonant), None),        // မ Ma

1036

        0x101A => (Some(Consonant), None),        // ယ Ya

1037

        0x101B => (Some(Consonant), None),        // ရ Ra

1038

        0x101C => (Some(Consonant), None),        // လ La

1039

        0x101D => (Some(Consonant), None),        // ဝ Wa

1040

        0x101E => (Some(Consonant), None),        // သ Sa

1041

        0x101F => (Some(Consonant), None),        // ဟ Ha

1042

        0x1020 => (Some(Consonant), None),        // ဠ Lla

1043

        0x1021 => (Some(VowelIndependent), None), // အ A

1044

        0x1022 => (Some(VowelIndependent), None), // ဢ Shan A

1045

        0x1023 => (Some(VowelIndependent), None), // ဣ I

1046

        0x1024 => (Some(VowelIndependent), None), // ဤ Ii

1047

        0x1025 => (Some(VowelIndependent), None), // ဥ U

1048

        0x1026 => (Some(VowelIndependent), None), // ဦ Uu

1049

        0x1027 => (Some(VowelIndependent), None), // ဧ E

1050

        0x1028 => (Some(VowelIndependent), None), // ဨ Mon E

1051

        0x1029 => (Some(VowelIndependent), None), // ဩ O

1052

        0x102A => (Some(VowelIndependent), None), // ဪ Au

1053

        0x102B => (Some(VowelDependent), Some(RightPosition)), // ါ Sign Tall Aa

1054

        0x102C => (Some(VowelDependent), Some(RightPosition)), // ာ Sign Aa

1055

        0x102D => (Some(VowelDependent), Some(TopPosition)), // ိ Sign I

1056

        0x102E => (Some(VowelDependent), Some(TopPosition)), // ီ Sign Ii

1057

        0x102F => (Some(VowelDependent), Some(BottomPosition)), // ု Sign U

1058

        0x1030 => (Some(VowelDependent), Some(BottomPosition)), // ူ Sign Uu

1059

        0x1031 => (Some(VowelDependent), Some(LeftPosition)), // ေ Sign E

1060

        0x1032 => (Some(VowelDependent), Some(TopPosition)), // ဲ Sign Ai

1061

        0x1033 => (Some(VowelDependent), Some(TopPosition)), // ဳ Sign Mon Ii

1062

        0x1034 => (Some(VowelDependent), Some(TopPosition)), // ဴ Sign Mon O

1063

        0x1035 => (Some(VowelDependent), Some(TopPosition)), // ဵ Sign E Above

1064

        0x1036 => (Some(Bindu), Some(TopPosition)), // ံ Anusvara

1065

        0x1037 => (Some(ToneMarker), Some(BottomPosition)), // ့ Dot Below

1066

        0x1038 => (Some(Visarga), Some(RightPosition)), // း Visarga

1067

        0x1039 => (Some(InvisibleStacker), None), // ္ Virama

1068

        0x103A => (Some(PureKiller), Some(TopPosition)), // ် Asat

1069

        0x103B => (Some(ConsonantMedial), Some(RightPosition)), // ျ Sign Medial Ya

1070

        0x103C => (Some(ConsonantMedial), Some(TopLeftAndBottomPosition)), // ြ Sign Medial Ra

1071

        0x103D => (Some(ConsonantMedial), Some(BottomPosition)), // ွ Sign Medial Wa

1072

        0x103E => (Some(ConsonantMedial), Some(BottomPosition)), // ှ Sign Medial Ha

1073

        0x103F => (Some(Consonant), None),        // ဿ Great Sa

1074

        0x1040 => (Some(Number), None),           // ၀ Digit Zero

1075

        0x1041 => (Some(Number), None),           // ၁ Digit One

1076

        0x1042 => (Some(Number), None),           // ၂ Digit Two

1077

        0x1043 => (Some(Number), None),           // ၃ Digit Three

1078

        0x1044 => (Some(Number), None),           // ၄ Digit Four

1079

        0x1045 => (Some(Number), None),           // ၅ Digit Five

1080

        0x1046 => (Some(Number), None),           // ၆ Digit Six

1081

        0x1047 => (Some(Number), None),           // ၇ Digit Seven

1082

        0x1048 => (Some(Number), None),           // ၈ Digit Eight

1083

        0x1049 => (Some(Number), None),           // ၉ Digit Nine

1084

        0x104A => (None, None),                   // ၊ Little Section

1085

        0x104B => (None, None),                   // ။ Section

1086

        0x104C => (None, None),                   // ၌ Locative

1087

        0x104D => (None, None),                   // ၍ Completed

1088

        0x104E => (Some(ConsonantPlaceholder), None), // ၎ Aforementioned

1089

        0x104F => (None, None),                   // ၏ Genitive

1090

        0x1050 => (Some(Consonant), None),        // ၐ Sha

1091

        0x1051 => (Some(Consonant), None),        // ၑ Ssa

1092

        0x1052 => (Some(VowelIndependent), None), // ၒ Vocalic R

1093

        0x1053 => (Some(VowelIndependent), None), // ၓ Vocalic Rr

1094

        0x1054 => (Some(VowelIndependent), None), // ၔ Vocalic L

1095

        0x1055 => (Some(VowelIndependent), None), // ၕ Vocalic Ll

1096

        0x1056 => (Some(VowelDependent), Some(RightPosition)), // ၖ Sign Vocalic R

1097

        0x1057 => (Some(VowelDependent), Some(RightPosition)), // ၗ Sign Vocalic Rr

1098

        0x1058 => (Some(VowelDependent), Some(BottomPosition)), // ၘ Sign Vocalic L

1099

        0x1059 => (Some(VowelDependent), Some(BottomPosition)), // ၙ Sign Vocalic Ll

1100

        0x105A => (Some(Consonant), None),        // ၚ Mon Nga

1101

        0x105B => (Some(Consonant), None),        // ၛ Mon Jha

1102

        0x105C => (Some(Consonant), None),        // ၜ Mon Bba

1103

        0x105D => (Some(Consonant), None),        // ၝ Mon Bbe

1104

        0x105E => (Some(ConsonantMedial), Some(BottomPosition)), // ၞ Sign Mon Medial Na

1105

        0x105F => (Some(ConsonantMedial), Some(BottomPosition)), // ၟ Sign Mon Medial Ma

1106

        0x1060 => (Some(ConsonantMedial), Some(BottomPosition)), // ၠ Sign Mon Medial La

1107

        0x1061 => (Some(Consonant), None),        // ၡ Sgaw Karen Sha

1108

        0x1062 => (Some(VowelDependent), Some(RightPosition)), // ၢ Sign Sgaw Karen Eu

1109

        0x1063 => (Some(ToneMarker), Some(RightPosition)), // ၣ Tone Sgaw Karen Hathi

1110

        0x1064 => (Some(ToneMarker), Some(RightPosition)), // ၤ Tone Sgaw Karen Ke Pho

1111

        0x1065 => (Some(Consonant), None),        // ၥ Western Pwo Karen Tha

1112

        0x1066 => (Some(Consonant), None),        // ၦ Western Pwo Karen Pwa

1113

        0x1067 => (Some(VowelDependent), Some(RightPosition)), // ၧ Sign Western Pwo Karen Eu

1114

        0x1068 => (Some(VowelDependent), Some(RightPosition)), // ၨ Sign Western Pwo Karen Ue

1115

        0x1069 => (Some(ToneMarker), Some(RightPosition)), // ၩ Sign Western Pwo Karen Tone 1

1116

        0x106A => (Some(ToneMarker), Some(RightPosition)), // ၪ Sign Western Pwo Karen Tone 2

1117

        0x106B => (Some(ToneMarker), Some(RightPosition)), // ၫ Sign Western Pwo Karen Tone 3

1118

        0x106C => (Some(ToneMarker), Some(RightPosition)), // ၬ Sign Western Pwo Karen Tone 4

1119

        0x106D => (Some(ToneMarker), Some(RightPosition)), // ၭ Sign Western Pwo Karen Tone 5

1120

        0x106E => (Some(Consonant), None),        // ၮ Eastern Pwo Karen Nna

1121

        0x106F => (Some(Consonant), None),        // ၯ Eastern Pwo Karen Ywa

1122

        0x1070 => (Some(Consonant), None),        // ၰ Eastern Pwo Karen Ghwa

1123

        0x1071 => (Some(VowelDependent), Some(TopPosition)), // ၱ Sign Geba Karen I

1124

        0x1072 => (Some(VowelDependent), Some(TopPosition)), // ၲ Sign Kayah Oe

1125

        0x1073 => (Some(VowelDependent), Some(TopPosition)), // ၳ Sign Kayah U

1126

        0x1074 => (Some(VowelDependent), Some(TopPosition)), // ၴ Sign Kayah Ee

1127

        0x1075 => (Some(Consonant), None),        // ၵ Shan Ka

1128

        0x1076 => (Some(Consonant), None),        // ၶ Shan Kha

1129

        0x1077 => (Some(Consonant), None),        // ၷ Shan Ga

1130

        0x1078 => (Some(Consonant), None),        // ၸ Shan Ca

1131

        0x1079 => (Some(Consonant), None),        // ၹ Shan Za

1132

        0x107A => (Some(Consonant), None),        // ၺ Shan Nya

1133

        0x107B => (Some(Consonant), None),        // ၻ Shan Da

1134

        0x107C => (Some(Consonant), None),        // ၼ Shan Na

1135

        0x107D => (Some(Consonant), None),        // ၽ Shan Pha

1136

        0x107E => (Some(Consonant), None),        // ၾ Shan Fa

1137

        0x107F => (Some(Consonant), None),        // ၿ Shan Ba

1138

        0x1080 => (Some(Consonant), None),        // ႀ Shan Tha

1139

        0x1081 => (Some(Consonant), None),        // ႁ Shan Ha

1140

        0x1082 => (Some(ConsonantMedial), Some(BottomPosition)), // ႂ Sign Shan Medial Wa

1141

        0x1083 => (Some(VowelDependent), Some(RightPosition)), // ႃ Sign Shan Aa

1142

        0x1084 => (Some(VowelDependent), Some(LeftPosition)), // ႄ Sign Shan E

1143

        0x1085 => (Some(VowelDependent), Some(TopPosition)), // ႅ Sign Shan E Above

1144

        0x1086 => (Some(VowelDependent), Some(TopPosition)), // ႆ Sign Shan Final Y

1145

        0x1087 => (Some(ToneMarker), Some(RightPosition)), // ႇ Sign Shan Tone 2

1146

        0x1088 => (Some(ToneMarker), Some(RightPosition)), // ႈ Sign Shan Tone 3

1147

        0x1089 => (Some(ToneMarker), Some(RightPosition)), // ႉ Sign Shan Tone 5

1148

        0x108A => (Some(ToneMarker), Some(RightPosition)), // ႊ Sign Shan Tone 6

1149

        0x108B => (Some(ToneMarker), Some(RightPosition)), // ႋ Sign Shan Council Tone 2

1150

        0x108C => (Some(ToneMarker), Some(RightPosition)), // ႌ Sign Shan Council Tone 3

1151

        0x108D => (Some(ToneMarker), Some(BottomPosition)), // ႍ Sign Shan Council Emphatic Tone

1152

        0x108E => (Some(Consonant), None),        // ႎ Rumai Palaung Fa

1153

        0x108F => (Some(ToneMarker), Some(RightPosition)), // ႏ Sign Rumai Palaung Tone 5

1154

        0x1090 => (Some(Number), None),           // ႐ Shan Digit Zero

1155

        0x1091 => (Some(Number), None),           // ႑ Shan Digit One

1156

        0x1092 => (Some(Number), None),           // ႒ Shan Digit Two

1157

        0x1093 => (Some(Number), None),           // ႓ Shan Digit Three

1158

        0x1094 => (Some(Number), None),           // ႔ Shan Digit Four

1159

        0x1095 => (Some(Number), None),           // ႕ Shan Digit Five

1160

        0x1096 => (Some(Number), None),           // ႖ Shan Digit Six

1161

        0x1097 => (Some(Number), None),           // ႗ Shan Digit Seven

1162

        0x1098 => (Some(Number), None),           // ႘ Shan Digit Eight

1163

        0x1099 => (Some(Number), None),           // ႙ Shan Digit Nine

1164

        0x109A => (Some(ToneMarker), Some(RightPosition)), // ႚ Sign Khamti Tone 1

1165

        0x109B => (Some(ToneMarker), Some(RightPosition)), // ႛ Sign Khamti Tone 3

1166

        0x109C => (Some(VowelDependent), Some(RightPosition)), // ႜ Sign Aiton A

1167

        0x109D => (Some(VowelDependent), Some(TopPosition)), // ႝ Sign Aiton Ai

1168

        0x109E => (Some(Symbol), None),           // ႞ Shan One

1169

        0x109F => (Some(Symbol), None),           // ႟ Shan Exclamation

1170

1171

        // Myanmar Extended A character table

1172

        0xAA60 => (Some(Consonant), None), // ꩠ Khamti Ga

1173

        0xAA61 => (Some(Consonant), None), // ꩡ Khamti Ca

1174

        0xAA62 => (Some(Consonant), None), // ꩢ Khamti Cha

1175

        0xAA63 => (Some(Consonant), None), // ꩣ Khamti Ja

1176

        0xAA64 => (Some(Consonant), None), // ꩤ Khamti Jha

1177

        0xAA65 => (Some(Consonant), None), // ꩥ Khamti Nya

1178

        0xAA66 => (Some(Consonant), None), // ꩦ Khamti Tta

1179

        0xAA67 => (Some(Consonant), None), // ꩧ Khamti Ttha

1180

        0xAA68 => (Some(Consonant), None), // ꩨ Khamti Dda

1181

        0xAA69 => (Some(Consonant), None), // ꩩ Khamti Ddha

1182

        0xAA6A => (Some(Consonant), None), // ꩪ Khamti Dha

1183

        0xAA6B => (Some(Consonant), None), // ꩫ Khamti Na

1184

        0xAA6C => (Some(Consonant), None), // ꩬ Khamti Sa

1185

        0xAA6D => (Some(Consonant), None), // ꩭ Khamti Ha

1186

        0xAA6E => (Some(Consonant), None), // ꩮ Khamti Hha

1187

        0xAA6F => (Some(Consonant), None), // ꩯ Khamti Fa

1188

        0xAA70 => (None, None),            // ꩰ Khamti Reduplication

1189

        0xAA71 => (Some(Consonant), None), // ꩱ Khamti Xa

1190

        0xAA72 => (Some(Consonant), None), // ꩲ Khamti Za

1191

        0xAA73 => (Some(Consonant), None), // ꩳ Khamti Ra

1192

        0xAA74 => (Some(ConsonantPlaceholder), None), // ꩴ Khamti Oay

1193

        0xAA75 => (Some(ConsonantPlaceholder), None), // ꩵ Khamti Qn

1194

        0xAA76 => (Some(ConsonantPlaceholder), None), // ꩶ Khamti Hm

1195

        0xAA77 => (Some(Symbol), None),    // ꩷ Khamti Aiton Exclamation

1196

        0xAA78 => (Some(Symbol), None),    // ꩸ Khamti Aiton One

1197

        0xAA79 => (Some(Symbol), None),    // ꩹ Khamti Aiton Two

1198

        0xAA7A => (Some(Consonant), None), // ꩺ Khamti Aiton Ra

1199

        0xAA7B => (Some(ToneMarker), Some(RightPosition)), // ꩻ Sign Pao Karen Tone

1200

        0xAA7C => (Some(ToneMarker), Some(TopPosition)), // ꩼ Sign Tai Laing Tone 2

1201

        0xAA7D => (Some(ToneMarker), Some(RightPosition)), // ꩽ Sign Tai Laing Tone 5

1202

        0xAA7E => (Some(Consonant), None), // ꩾ Shwe Palaung Cha

1203

        0xAA7F => (Some(Consonant), None), // ꩿ Shwe Palaung Sha

1204

1205

        // Myanmar Extended B character table

1206

        0xA9E0 => (Some(Consonant), None), // ꧠ Shan Gha

1207

        0xA9E1 => (Some(Consonant), None), // ꧡ Shan Cha

1208

        0xA9E2 => (Some(Consonant), None), // ꧢ Shan Jha

1209

        0xA9E3 => (Some(Consonant), None), // ꧣ Shan Nna

1210

        0xA9E4 => (Some(Consonant), None), // ꧤ Shan Bha

1211

        0xA9E5 => (Some(VowelDependent), Some(TopPosition)), // ꧥ Sign Shan Saw

1212

        0xA9E6 => (None, None),            // ꧦ Shan Reduplication

1213

        0xA9E7 => (Some(Consonant), None), // ꧧ Tai Laing Nya

1214

        0xA9E8 => (Some(Consonant), None), // ꧨ Tai Laing Fa

1215

        0xA9E9 => (Some(Consonant), None), // ꧩ Tai Laing Ga

1216

        0xA9EA => (Some(Consonant), None), // ꧪ Tai Laing Gha

1217

        0xA9EB => (Some(Consonant), None), // ꧫ Tai Laing Ja

1218

        0xA9EC => (Some(Consonant), None), // ꧬ Tai Laing Jha

1219

        0xA9ED => (Some(Consonant), None), // ꧭ Tai Laing Dda

1220

        0xA9EE => (Some(Consonant), None), // ꧮ Tai Laing Ddha

1221

        0xA9EF => (Some(Consonant), None), // ꧯ Tai Laing Nna

1222

        0xA9F0 => (Some(Number), None),    // ꧰ Tai Laing Digit Zero

1223

        0xA9F1 => (Some(Number), None),    // ꧱ Tai Laing Digit One

1224

        0xA9F2 => (Some(Number), None),    // ꧲ Tai Laing Digit Two

1225

        0xA9F3 => (Some(Number), None),    // ꧳ Tai Laing Digit Three

1226

        0xA9F4 => (Some(Number), None),    // ꧴ Tai Laing Digit Four

1227

        0xA9F5 => (Some(Number), None),    // ꧵ Tai Laing Digit Five

1228

        0xA9F6 => (Some(Number), None),    // ꧶ Tai Laing Digit Six

1229

        0xA9F7 => (Some(Number), None),    // ꧷ Tai Laing Digit Seven

1230

        0xA9F8 => (Some(Number), None),    // ꧸ Tai Laing Digit Eight

1231

        0xA9F9 => (Some(Number), None),    // ꧹ Tai Laing Digit Nine

1232

        0xA9FA => (Some(Consonant), None), // ꧺ Tai Laing Lla

1233

        0xA9FB => (Some(Consonant), None), // ꧻ Tai Laing Da

1234

        0xA9FC => (Some(Consonant), None), // ꧼ Tai Laing Dha

1235

        0xA9FD => (Some(Consonant), None), // ꧽ Tai Laing Ba

1236

        0xA9FE => (Some(Consonant), None), // ꧾ Tai Laing Bha

1237

1238

        // Myanmar Extended C character table

1239

        0x116D0 => (Some(Number), None), // 𑛐 Pao Digit Zero

1240

        0x116D1 => (Some(Number), None), // 𑛑 Pao Digit One

1241

        0x116D2 => (Some(Number), None), // 𑛒 Pao Digit Two

1242

        0x116D3 => (Some(Number), None), // 𑛓 Pao Digit Three

1243

        0x116D4 => (Some(Number), None), // 𑛔 Pao Digit Four

1244

        0x116D5 => (Some(Number), None), // 𑛕 Pao Digit Five

1245

        0x116D6 => (Some(Number), None), // 𑛖 Pao Digit Six

1246

        0x116D7 => (Some(Number), None), // 𑛗 Pao Digit Seven

1247

        0x116D8 => (Some(Number), None), // 𑛘 Pao Digit Eight

1248

        0x116D9 => (Some(Number), None), // 𑛙 Pao Digit Nine

1249

        0x116DA => (Some(Number), None), // 𑛚 Pao Digit Zero

1250

        0x116DB => (Some(Number), None), // 𑛛 Eastern Pwo Karen Digit One

1251

        0x116DC => (Some(Number), None), // 𑛜 Eastern Pwo Karen Digit Two

1252

        0x116DD => (Some(Number), None), // 𑛝 Eastern Pwo Karen Digit Three

1253

        0x116DE => (Some(Number), None), // 𑛞 Eastern Pwo Karen Digit Four

1254

        0x116DF => (Some(Number), None), // 𑛟 Eastern Pwo Karen Digit Five

1255

        0x116E0 => (Some(Number), None), // 𑛐 Eastern Pwo Karen Digit Six

1256

        0x116E1 => (Some(Number), None), // 𑛑 Eastern Pwo Karen Digit Seven

1257

        0x116E2 => (Some(Number), None), // 𑛒 Eastern Pwo Karen Digit Eight

1258

        0x116E3 => (Some(Number), None), // 𑛓 Eastern Pwo Karen Digit Nine

1259

1260

        // Miscellaneous character table

1261

        0x00A0 => (Some(Placeholder), None),  //   No-break space

1262

        0x200C => (Some(NonJoiner), None),    // ‌ Zero-width non-joiner

1263

        0x200D => (Some(Joiner), None),       // ‍ Zero-width joiner

1264

        0x2010 => (Some(Placeholder), None),  // ‐ Hyphen

1265

        0x2011 => (Some(Placeholder), None),  // ‑ No-break hyphen

1266

        0x2012 => (Some(Placeholder), None),  // ‒ Figure dash

1267

        0x2013 => (Some(Placeholder), None),  // – En dash

1268

        0x2014 => (Some(Placeholder), None),  // — Em dash

1269

        0x25CC => (Some(DottedCircle), None), // ◌ Dotted circle

1270

1271

        _ => (None, None),

1272

1273

1274

1275

/////////////////////////////////////////////////////////////////////////////

1276

// Unit tests

1277

/////////////////////////////////////////////////////////////////////////////

1278

1279

#[cfg(test)]

1280

mod tests {

1281

    use crate::{

1282

        binary::read::ReadScope,

1283

        font::read_cmap_subtable,

1284

        layout::new_layout_cache,

1285

        tables::{

1286

            cmap::{Cmap, CmapSubtable},

1287

            OffsetTable, OpenTypeData, OpenTypeFont,

1288

},

1289

        tests::read_fixture_font,

1290

};

1291

1292

    use super::*;

1293

1294

    // https://github.com/wcampbell0x2a/assert_hex/blob/12fe1790e04aa1a5c5da01a1d26f9d1752b1beb4/src/lib.rs

1295

//

1296

    // Permission is hereby granted, free of charge, to any

1297

    // person obtaining a copy of this software and associated

1298

    // documentation files (the "Software"), to deal in the

1299

    // Software without restriction, including without

1300

    // limitation the rights to use, copy, modify, merge,

1301

    // publish, distribute, sublicense, and/or sell copies of

1302

    // the Software, and to permit persons to whom the Software

1303

    // is furnished to do so, subject to the following

1304

    // conditions:

1305

1306

    // The above copyright notice and this permission notice

1307

    // shall be included in all copies or substantial portions

1308

    // of the Software.

1309

1310

    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF

1311

    // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

1312

    // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

1313

    // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT

1314

    // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

1315

    // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

1316

    // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR

1317

    // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

1318

    // DEALINGS IN THE SOFTWARE.

1319

    macro_rules! assert_eq_hex {

1320

        ($left:expr, $right:expr $(,)?) => ({

1321

            match (&$left, &$right) {

1322

                (left_val, right_val) => {

1323

                    if !(*left_val == *right_val) {

1324

                        // The reborrows below are intentional. Without them, the stack slot for the

1325

                        // borrow is initialized even before the values are compared, leading to a

1326

                        // noticeable slow down.

1327

                        panic!(r#"assertion `left == right` failed

1328

      left: {:#x?}

1329

     right: {:#x?}"#, &*left_val, &*right_val)

1330

1331

1332

1333

});

1334

        ($left:expr, $right:expr, $($arg:tt)+) => ({

1335

            match (&($left), &($right)) {

1336

                (left_val, right_val) => {

1337

                    if !(*left_val == *right_val) {

1338

                        // The reborrows below are intentional. Without them, the stack slot for the

1339

                        // borrow is initialized even before the values are compared, leading to a

1340

                        // noticeable slow down.

1341

                        panic!(r#"assertion `left == right` failed: {}

1342

      left: {:#x?}

1343

     right: {:#x?}"#, format_args!($($arg)+), &*left_val, &*right_val)

1344

1345

1346

1347

});

1348

1349

1350

    fn map_glyph(cmap_subtable: &CmapSubtable<'_>, ch: char) -> Result<RawGlyph<()>, ParseError> {

1351

        let glyph_index = cmap_subtable.map_glyph(ch as u32)?.unwrap_or(0);

1352

        let glyph = RawGlyph {

1353

            unicodes: tiny_vec![[char; 1] => ch],

1354

            glyph_index,

1355

            liga_component_pos: 0,

1356

            glyph_origin: GlyphOrigin::Char(ch),

1357

            flags: RawGlyphFlags::empty(),

1358

            variation: None,

1359

            extra_data: (),

1360

};

1361

        Ok(glyph)

1362

1363

1364

    fn apply_gsub<'a>(

1365

        scope: &ReadScope<'a>,

1366

        ttf: OffsetTable<'a>,

1367

        lang_tag: Option<u32>,

1368

        syllable: &str,

1369

    ) -> Result<Vec<RawGlyph<()>>, ShapingError> {

1370

        let cmap = if let Some(cmap_scope) = ttf.read_table(&scope, tag::CMAP)? {

1371

            cmap_scope.read::<Cmap<'_>>()?

1372

        } else {

1373

            panic!("no cmap table");

1374

};

1375

        let (_, cmap_subtable) = if let Some(cmap_subtable) = read_cmap_subtable(&cmap)? {

1376

            cmap_subtable

1377

        } else {

1378

            panic!("no suitable cmap subtable");

1379

};

1380

        let mut glyphs = syllable

1381

            .chars()

1382

            .map(|ch| map_glyph(&cmap_subtable, ch))

1383

            .collect::<Result<Vec<_>, _>>()

1384

            .unwrap();

1385

        let Some(gsub_record) = ttf.find_table_record(tag::GSUB) else {

1386

            panic!("no GSUB table record");

1387

};

1388

        let gsub_table = gsub_record

1389

            .read_table(&scope)?

1390

            .read::<LayoutTable<GSUB>>()?;

1391

        let gdef_table = match ttf.find_table_record(tag::GDEF) {

1392

            Some(gdef_record) => Some(gdef_record.read_table(&scope)?.read::<GDEFTable>()?),

1393

            None => None,

1394

};

1395

        let gsub_cache = new_layout_cache(gsub_table);

1396

        let gsub_table = &gsub_cache.layout_table;

1397

        let dotted_circle_index = cmap_subtable.map_glyph(DOTTED_CIRCLE as u32)?.unwrap_or(0);

1398

1399

        let feature_variations = None;

1400

        gsub_apply_myanmar(

1401

            dotted_circle_index,

1402

            &gsub_cache,

1403

            &gsub_table,

1404

            gdef_table.as_ref(),

1405

            lang_tag,

1406

            feature_variations,

1407

            FeatureMask::empty(),

1408

            &mut glyphs,

1409

)?;

1410

        Ok(glyphs)

1411

1412

1413

    // Tests for syllable identification

1414

    mod syllables {

1415

        use super::*;

1416

1417

        impl SyllableChar for char {

1418

            fn char(&self) -> char {

1419

                *self

1420

1421

1422

1423

        fn syllable_clusters(input: &str) -> Vec<(Vec<char>, Option<Syllable>)> {

1424

            let input = input.chars().collect::<Vec<_>>();

1425

            let mut input = input.as_slice();

1426

            let mut syllables: Vec<(Vec<_>, Option<Syllable>)> = Vec::new();

1427

1428

            while !input.is_empty() {

1429

                let len = match match_syllable(input) {

1430

                    Some((len, syllable_type)) => {

1431

                        assert_ne!(len, 0);

1432

1433

                        let syllable = input[..len].iter().copied().collect();

1434

                        syllables.push((syllable, Some(syllable_type)));

1435

1436

len

1437

1438

                    None => {

1439

                        let invalid_glyph = input[0];

1440

                        match syllables.last_mut() {

1441

                            // If the last syllable in `syllables` is invalid, just append

1442

                            // this invalid glyph to that syllable

1443

                            Some((invalid_syllable, None)) => invalid_syllable.push(invalid_glyph),

1444

                            // Collect invalid glyphs

1445

                            _ => syllables.push((vec![invalid_glyph], None)),

1446

1447

1448

1449

1450

};

1451

1452

                input = &input[len..];

1453

1454

1455

            syllables

1456

1457

1458

        #[test]

1459

        fn one() {

1460

            let input = "အကြွေးပေး";

1461

            let expected = ["အ", "ကြွေး", "ပေး"];

1462

1463

            let syllables = syllable_clusters(input)

1464

                .into_iter()

1465

                .filter_map(|(chars, syllable_ty)| {

1466

                    syllable_ty.map(|_| chars.into_iter().collect::<String>())

1467

})

1468

                .collect::<Vec<_>>();

1469

            assert_eq!(syllables, expected);

1470

1471

1472

        #[test]

1473

        fn two() {

1474

            let input = "ကံမဆရာတော်ဘုရားကြီး";

1475

            let expected = ["ကံ", "မ", "ဆ", "ရာ", "တော်", "ဘု", "ရား", "ကြီး"];

1476

1477

            let syllables = syllable_clusters(input)

1478

                .into_iter()

1479

                .filter_map(|(chars, syllable_ty)| {

1480

                    syllable_ty.map(|_| chars.into_iter().collect::<String>())

1481

})

1482

                .collect::<Vec<_>>();

1483

            assert_eq!(syllables, expected);

1484

1485

1486

        #[test]

1487

        fn three() {

1488

            let input = "ပို၍စောစီးစွာပေးပါက";

1489

            let expected = ["ပို", "၍", "စော", "စီး", "စွာ", "ပေး", "ပါ", "က"];

1490

1491

            let syllables = syllable_clusters(input)

1492

                .into_iter()

1493

                .filter_map(|(chars, syllable_ty)| {

1494

                    syllable_ty.map(|_| chars.into_iter().collect::<String>())

1495

})

1496

                .collect::<Vec<_>>();

1497

            assert_eq!(syllables, expected);

1498

1499

1500

        #[test]

1501

        fn four() {

1502

            let input = "ကင်းေ၀းသော";

1503

            // Vowel sign E is lacking a base so gets left by itself

1504

            let expected = ["က", "င်း", "ေ", "၀း", "သော"];

1505

1506

            let syllables = syllable_clusters(input)

1507

                .into_iter()

1508

                .map(|(chars, _syllable_ty)| chars.into_iter().collect::<String>())

1509

                .collect::<Vec<_>>();

1510

            assert_eq!(syllables, expected);

1511

1512

1513

        #[test]

1514

        fn complex_cluster() {

1515

            // https://learn.microsoft.com/en-us/typography/script-development/myanmar#well-formed-clusters

1516

            let input = "င်္က္ကျြွှေို့်ာှီ့ၤဲံ့းႍ";

1517

/*

1518

            | U+1004 | Letter    | CONSONANT         | _null_                       | Nga                    |  _ra_         ⎫

1519

            | U+103A | Mark [Mn] | PURE_KILLER       | TOP_POSITION                 | Asat                   |  _asat_       ⎬ Kinzi (K)

1520

            | U+1039 | Mark [Mn] | INVISIBLE_STACKER | _null_                       | Virama                 |  _halant_     ⎭

1521

            | U+1000 | Letter    | CONSONANT         | _null_                       | Ka                     |  C

1522

            | U+1039 | Mark [Mn] | INVISIBLE_STACKER | _null_                       | Virama                 |  _halant_

1523

            | U+1000 | Letter    | CONSONANT         | _null_                       | Ka                     |  C

1524

            | U+103B | Mark [Mc] | CONSONANT_MEDIAL  | RIGHT_POSITION               | Sign Medial Ya         |  _my_         ⎫

1525

            | U+103C | Mark [Mc] | CONSONANT_MEDIAL  | TOP_LEFT_AND_BOTTOM_POSITION | Sign Medial Ra         |  _mr_         ⎬ Med

1526

            | U+103D | Mark [Mn] | CONSONANT_MEDIAL  | BOTTOM_POSITION              | Sign Medial Wa         |  _mw_         ⎟

1527

            | U+103E | Mark [Mn] | CONSONANT_MEDIAL  | BOTTOM_POSITION              | Sign Medial Ha         |  _mh_         ⎭

1528

            | U+1031 | Mark [Mc] | VOWEL_DEPENDENT   | LEFT_POSITION                | Sign E                 |  _matrapre_   ⎫

1529

            | U+102D | Mark [Mn] | VOWEL_DEPENDENT   | TOP_POSITION                 | Sign I                 |  _matraabove_ ⎟

1530

            | U+102F | Mark [Mn] | VOWEL_DEPENDENT   | BOTTOM_POSITION              | Sign U                 |  _matrabelow_ ⎬ Vmain

1531

            | U+1037 | Mark [Mn] | TONE_MARKER       | BOTTOM_POSITION              | Dot Below              |  _db_         ⎟

1532

            | U+103A | Mark [Mn] | PURE_KILLER       | TOP_POSITION                 | Asat                   |  _asat_       ⎭

1533

            | U+102C | Mark [Mc] | VOWEL_DEPENDENT   | RIGHT_POSITION               | Sign Aa                |  _matrapost_  ⎫

1534

            | U+103E | Mark [Mn] | CONSONANT_MEDIAL  | BOTTOM_POSITION              | Sign Medial Ha         |  _mh_         ⎬ Vpost

1535

            | U+102E | Mark [Mn] | VOWEL_DEPENDENT   | TOP_POSITION                 | Sign Ii                |  _matraabove_ ⎟

1536

            | U+1037 | Mark [Mn] | TONE_MARKER       | BOTTOM_POSITION              | Dot Below              |  _db_         ⎭

1537

            | U+1064 | Mark [Mc] | TONE_MARKER       | RIGHT_POSITION               | Tone Sgaw Karen Ke Pho |  _pt_         ⎫

1538

            | U+1032 | Mark [Mn] | VOWEL_DEPENDENT   | TOP_POSITION                 | Sign Ai                |  _a_          ⎟

1539

            | U+1036 | Mark [Mn] | BINDU             | TOP_POSITION                 | Anusvara               |  _a_          ⎬ Pwo

1540

            | U+1037 | Mark [Mn] | TONE_MARKER       | BOTTOM_POSITION              | Dot Below              |  _db_         ⎟

1541

            | U+1038 | Mark [Mc] | VISARGA           | RIGHT_POSITION               | Visarga                |  _v_          ⎭

1542

            | U+108D | Mark [Mn] | TONE_MARKER       | BOTTOM_POSITION              | Sign Shan Council Emphatic Tone|

1543

*/

1544

1545

            // It's expected that this whole collection is matched as a single cluster

1546

            let expected = [input];

1547

1548

            let syllables = syllable_clusters(input)

1549

                .into_iter()

1550

                .map(|(chars, _syllable_ty)| chars.into_iter().collect::<String>())

1551

                .collect::<Vec<_>>();

1552

            assert_eq!(syllables, expected);

1553

1554

1555

1556

    // Test for insertion of dotted circles

1557

    mod dotted_circle {

1558

        use super::*;

1559

1560

        #[test]

1561

        fn em_dash() {

1562

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1563

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1564

1565

            let ttf = match fontfile.data {

1566

                OpenTypeData::Single(ttf) => ttf,

1567

                OpenTypeData::Collection(_ttc) => unreachable!(),

1568

};

1569

1570

            // Harfbuzz inserts a dotted circle for the dot-below to attach to but Uniscribe and

1571

            // CoreText don't. According the description of valid clusters EM DASH is a generic

1572

            // base, so it should be legit for the dot-below to attach to it.

1573

            let x = apply_gsub(&fontfile.scope, ttf, None, "—့").unwrap();

1574

            assert_eq!(x.len(), 2);

1575

1576

1577

        #[test]

1578

        fn visagara() {

1579

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1580

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1581

1582

            let ttf = match fontfile.data {

1583

                OpenTypeData::Single(ttf) => ttf,

1584

                OpenTypeData::Collection(_ttc) => unreachable!(),

1585

};

1586

1587

            // Should insert a dotted circle for the Visagara to attach to

1588

            let x = apply_gsub(&fontfile.scope, ttf, None, "းႍ").unwrap();

1589

1590

            assert_eq!(x.len(), 3);

1591

            assert_eq!(x[0].char(), '◌');

1592

1593

1594

        #[test]

1595

        fn nbsp() {

1596

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1597

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1598

1599

            let ttf = match fontfile.data {

1600

                OpenTypeData::Single(ttf) => ttf,

1601

                OpenTypeData::Collection(_ttc) => unreachable!(),

1602

};

1603

1604

            // Harfbuzz inserts a dotted circle but the non-breaking space should inhibit that to

1605

            // allow the marks to be shown insolation

1606

            let x = apply_gsub(

1607

                &fontfile.scope,

1608

                ttf,

1609

                None,

1610

                "\u{00a0}\u{102d}\u{102f}\u{1037}",

1611

1612

            .unwrap();

1613

1614

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

1615

1616

            // expected: [98, 760, 386, 395, 410]

1617

            //   actual: [98, 386, 394, 410]

1618

1619

            assert_eq!(gids, [98, 386, 394, 410]);

1620

1621

1622

        #[test]

1623

        fn punc() {

1624

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1625

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1626

1627

            let ttf = match fontfile.data {

1628

                OpenTypeData::Single(ttf) => ttf,

1629

                OpenTypeData::Collection(_ttc) => unreachable!(),

1630

};

1631

1632

            let x = apply_gsub(&fontfile.scope, ttf, None, "\u{104f}").unwrap();

1633

1634

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

1635

1636

            // expected: [485]      // 485 is U+104F MYANMAR SYMBOL GENITIVE, is_mark = false, Punctuation

1637

            //   actual: [760, 485] // 760 is dotted circle

1638

1639

            // A prior version of the spec did not match U+104F in the _punc_ rule, which would

1640

            // result in the syllable being marked broken. We insert a dotted circle at the

1641

            // beginning of broken syllables. This test checks that dotted circle is not inserted

1642

            // for this case.

1643

            assert_eq!(gids, [485]);

1644

1645

1646

1647

    // Tests for initial reordering of Myanmar syllables

1648

    mod reorder {

1649

        use super::*;

1650

1651

        fn do_reorder<'a>(

1652

            scope: &ReadScope<'a>,

1653

            ttf: OffsetTable<'a>,

1654

            lang_tag: Option<u32>,

1655

            syllable: &[char],

1656

        ) -> Result<Vec<RawGlyphMyanmar>, ShapingError> {

1657

            let cmap = if let Some(cmap_scope) = ttf.read_table(&scope, tag::CMAP)? {

1658

                cmap_scope.read::<Cmap<'_>>()?

1659

            } else {

1660

                panic!("no cmap table");

1661

};

1662

            let (_, cmap_subtable) = if let Some(cmap_subtable) = read_cmap_subtable(&cmap)? {

1663

                cmap_subtable

1664

            } else {

1665

                panic!("no suitable cmap subtable");

1666

};

1667

            let glyphs = syllable

1668

                .iter()

1669

                .copied()

1670

                .map(|ch| map_glyph(&cmap_subtable, ch))

1671

                .collect::<Result<Vec<_>, _>>()

1672

                .unwrap();

1673

            let Some(gsub_record) = ttf.find_table_record(tag::GSUB) else {

1674

                panic!("no GSUB table record");

1675

};

1676

            let gsub_table = gsub_record

1677

                .read_table(&scope)?

1678

                .read::<LayoutTable<GSUB>>()?;

1679

            let gdef_table = match ttf.find_table_record(tag::GDEF) {

1680

                Some(gdef_record) => Some(gdef_record.read_table(&scope)?.read::<GDEFTable>()?),

1681

                None => None,

1682

};

1683

            let gsub_cache = new_layout_cache(gsub_table);

1684

            let gsub_table = &gsub_cache.layout_table;

1685

1686

            let feature_variations = None;

1687

1688

            let script_tag = tag::MYM2;

1689

            let syllables = to_myanmar_syllables(&glyphs);

1690

            let shaping_data = MyanmarShapingData {

1691

                gsub_cache: &gsub_cache,

1692

                gsub_table,

1693

                gdef_table: gdef_table.as_ref(),

1694

                script_tag,

1695

                lang_tag,

1696

                feature_variations,

1697

};

1698

1699

            assert_eq!(syllables.len(), 1);

1700

            let mut syllable = syllables.into_iter().next().unwrap().0;

1701

1702

            initial_reorder_consonant_syllable(&shaping_data, &mut syllable)?;

1703

            Ok(syllable)

1704

1705

1706

        #[test]

1707

        fn pathological() {

1708

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1709

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1710

1711

            let ttf = match fontfile.data {

1712

                OpenTypeData::Single(ttf) => ttf,

1713

                OpenTypeData::Collection(_ttc) => unreachable!(),

1714

};

1715

1716

            // https://learn.microsoft.com/en-us/typography/script-development/myanmar#pathological-reordering-example

1717

            let chars = [

1718

                '\u{1004}', // Letter      CONSONANT          null               င Nga

1719

                '\u{103A}', // Mark [Mn]   PURE_KILLER        TOP_POSITION       ် Asat

1720

                '\u{1039}', // Mark [Mn]   INVISIBLE_STACKER  null               ္ Virama

1721

                '\u{1000}', // Letter      CONSONANT          null              က Ka

1722

                '\u{1039}', // Mark [Mn]   INVISIBLE_STACKER  null               ္ Virama

1723

                '\u{1000}', // Letter      CONSONANT          null              က Ka

1724

                '\u{103B}', // Mark [Mc]   CONSONANT_MEDIAL   RIGHT_POSITION    ျ Sign Medial Ya

1725

                '\u{103C}', // Mark [Mc]   CONSONANT_MEDIAL   TOP_LEFT_AND_BOTTOM_POSITION  ြ Sign Medial Ra

1726

                '\u{103D}', // Mark [Mn]   CONSONANT_MEDIAL   BOTTOM_POSITION   ွ Sign Medial Wa

1727

                '\u{1031}', // Mark [Mc]   VOWEL_DEPENDENT    LEFT_POSITION    ေ Sign E

1728

                '\u{1031}', // Mark [Mc]   VOWEL_DEPENDENT    LEFT_POSITION    ေ Sign E

1729

                '\u{102D}', // Mark [Mn]   VOWEL_DEPENDENT    TOP_POSITION      ိ Sign I

1730

                '\u{102F}', // Mark [Mn]   VOWEL_DEPENDENT    BOTTOM_POSITION   ု Sign U

1731

                '\u{1036}', // Mark [Mn]   BINDU              TOP_POSITION      ံ Anusvara

1732

                '\u{102C}', // Mark [Mc]   VOWEL_DEPENDENT    RIGHT_POSITION   ာ Sign Aa

1733

                '\u{1036}', // Mark [Mn]   BINDU              TOP_POSITION      ံ Anusvara

1734

];

1735

1736

            let reordered =

1737

                do_reorder(&fontfile.scope, ttf, None, &chars).expect("failed to reorder syllable");

1738

1739

            // Convert to u32 to make differences easier to identify

1740

            let chars = reordered

1741

                .into_iter()

1742

                .map(|glyph| glyph.char() as u32)

1743

                .collect::<Vec<_>>();

1744

1745

            assert_eq_hex!(

1746

                &chars,

1747

&[

1748

                    0x1031, 0x1031, 0x103C, 0x1000, 0x1004, 0x103A, 0x1039, 0x1039, 0x1000, 0x103B,

1749

                    0x103D, 0x102D, 0x1036, 0x102F, 0x102C, 0x1036,

1750

1751

1752

1753

1754

        #[test]

1755

        fn sign_aa() {

1756

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1757

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1758

1759

            let ttf = match fontfile.data {

1760

                OpenTypeData::Single(ttf) => ttf,

1761

                OpenTypeData::Collection(_ttc) => unreachable!(),

1762

};

1763

1764

            let input = [

1765

                '\u{1075}', // MYANMAR LETTER SHAN KA

1766

                '\u{102c}', // MYANMAR VOWEL SIGN AA

1767

                '\u{1038}', // MYANMAR SIGN VISARGA

1768

];

1769

1770

            let reordered =

1771

                do_reorder(&fontfile.scope, ttf, None, &input).expect("failed to reorder syllable");

1772

1773

            // Convert to u32 to make differences easier to identify

1774

            let output = reordered

1775

                .into_iter()

1776

                .map(|glyph| glyph.char() as u32)

1777

                .collect::<Vec<_>>();

1778

1779

            // A previous iteration of the code was placing Sign AA at the end of the syllable,

1780

            // which wasn't desired.

1781

            assert_eq_hex!(

1782

                &output,

1783

                &input.iter().copied().map(|c| c as u32).collect::<Vec<_>>()

1784

);

1785

1786

1787

        #[test]

1788

        fn shan_final_y() {

1789

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1790

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1791

1792

            let ttf = match fontfile.data {

1793

                OpenTypeData::Single(ttf) => ttf,

1794

                OpenTypeData::Collection(_ttc) => unreachable!(),

1795

};

1796

1797

            // line 07146: ၸၢႆး

1798

            //   expected: [543, 566, 513, 411]

1799

            //     actual: [543, 513, 566, 411]

1800

//

1801

            let input = [

1802

                '\u{1078}', // MYANMAR LETTER SHAN CA

1803

                '\u{1062}', // MYANMAR VOWEL SIGN SGAW KAREN EU (Right)

1804

                '\u{1086}', // MYANMAR VOWEL SIGN SHAN FINAL Y (Top, Mark)

1805

                '\u{1038}', // MYANMAR SIGN VISARGA

1806

];

1807

1808

            let reordered =

1809

                do_reorder(&fontfile.scope, ttf, None, &input).expect("failed to reorder syllable");

1810

1811

            // Convert to u32 to make differences easier to identify

1812

            let output = reordered

1813

                .into_iter()

1814

                .map(|glyph| glyph.char() as u32)

1815

                .collect::<Vec<_>>();

1816

1817

            // A previous iteration of the code wasn't ordering Shan Final Y properly.

1818

            assert_eq_hex!(

1819

                &output,

1820

                &input.iter().copied().map(|c| c as u32).collect::<Vec<_>>()

1821

);

1822

1823

1824

        #[test]

1825

        fn shan_digit_zero() {

1826

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1827

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1828

1829

            let ttf = match fontfile.data {

1830

                OpenTypeData::Single(ttf) => ttf,

1831

                OpenTypeData::Collection(_ttc) => unreachable!(),

1832

};

1833

1834

            // line 07190: ႐ုံ

1835

            //  expected: [583, 408, 394]

1836

            //    actual: [583, 394, 408]

1837

1838

            let input = [

1839

                '\u{1090}', // MYANMAR SHAN DIGIT ZERO

1840

                '\u{102f}', // MYANMAR VOWEL SIGN U, Mark, Bottom

1841

                '\u{1036}', // MYANMAR SIGN ANUSVARA, Mark, Top

1842

];

1843

1844

            let reordered =

1845

                do_reorder(&fontfile.scope, ttf, None, &input).expect("failed to reorder syllable");

1846

1847

            // Convert to u32 to make differences easier to identify

1848

            let output = reordered

1849

                .into_iter()

1850

                .map(|glyph| glyph.char() as u32)

1851

                .collect::<Vec<_>>();

1852

            let expected = [

1853

                '\u{1090}' as u32, // MYANMAR SHAN DIGIT ZERO

1854

                '\u{1036}' as u32, // MYANMAR SIGN ANUSVARA, Mark, Top

1855

                '\u{102f}' as u32, // MYANMAR VOWEL SIGN U, Mark, Bottom

1856

];

1857

1858

            // A previous iteration of the code was not tagging U+1090 as a base consonant,

1859

            // which meant reording failed.

1860

            assert_eq_hex!(&output, &expected);

1861

1862

1863

        #[test]

1864

        fn digit5() {

1865

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1866

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1867

1868

            let ttf = match fontfile.data {

1869

                OpenTypeData::Single(ttf) => ttf,

1870

                OpenTypeData::Collection(_ttc) => unreachable!(),

1871

};

1872

1873

            // line 06969: ၅ြ

1874

            //   expected: [472, 423]

1875

            //     actual: [423, 472]

1876

1877

            let input = [

1878

                '\u{1045}', // ‎MYANMAR DIGIT FIVE

1879

                '\u{103c}', // MYANMAR CONSONANT SIGN MEDIAL RA

1880

];

1881

1882

            let reordered =

1883

                do_reorder(&fontfile.scope, ttf, None, &input).expect("failed to reorder syllable");

1884

1885

            // Convert to u32 to make differences easier to identify

1886

            let output = reordered

1887

                .into_iter()

1888

                .map(|glyph| glyph.char() as u32)

1889

                .collect::<Vec<_>>();

1890

            let expected = [

1891

                '\u{103c}' as u32, // MYANMAR CONSONANT SIGN MEDIAL RA

1892

                '\u{1045}' as u32, // ‎MYANMAR DIGIT FIVE

1893

];

1894

1895

            assert_eq_hex!(&output, &expected);

1896

1897

1898

        #[test]

1899

        fn dual_below_base_consonant() {

1900

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1901

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1902

1903

            let ttf = match fontfile.data {

1904

                OpenTypeData::Single(ttf) => ttf,

1905

                OpenTypeData::Collection(_ttc) => unreachable!(),

1906

};

1907

1908

            let syllable = [

1909

                '\u{1001}', // MYANMAR LETTER KHA                Base

1910

                '\u{103C}', // MYANMAR CONSONANT SIGN MEDIAL RA  Pre-base

1911

                '\u{102F}', // MYANMAR VOWEL SIGN U              Vowel bottom

1912

                '\u{102F}', // MYANMAR VOWEL SIGN U              Vowel bottom

1913

                '\u{1036}', // MYANMAR SIGN ANUSVARA             Top

1914

];

1915

1916

            let reordered = do_reorder(&fontfile.scope, ttf, None, &syllable)

1917

                .expect("failed to reorder syllable");

1918

1919

            // Convert to u32 to make differences easier to identify

1920

            let output = reordered

1921

                .into_iter()

1922

                .map(|glyph| glyph.char() as u32)

1923

                .collect::<Vec<_>>();

1924

            let expected = [

1925

                '\u{103c}' as u32, // MYANMAR CONSONANT SIGN MEDIAL RA

1926

                '\u{1001}' as u32, // MYANMAR LETTER KHA

1927

                '\u{1036}' as u32, // MYANMAR SIGN ANUSVARA

1928

                '\u{102f}' as u32, // MYANMAR VOWEL SIGN U

1929

                '\u{102f}' as u32, // MYANMAR VOWEL SIGN U

1930

];

1931

1932

            // This tests two below-base consonants in a row followed by anusvara are ordered

1933

            // correctly

1934

            assert_eq_hex!(&output, &expected);

1935

1936

1937

        #[test]

1938

        fn punctuation() {

1939

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1940

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1941

1942

            let ttf = match fontfile.data {

1943

                OpenTypeData::Single(ttf) => ttf,

1944

                OpenTypeData::Collection(_ttc) => unreachable!(),

1945

};

1946

1947

            // line 07033: ။ေေ

1948

            let syllable = [

1949

                '\u{104b}', // MYANMAR SIGN SECTION

1950

                '\u{1031}', // MYANMAR VOWEL SIGN E

1951

                '\u{1031}', // MYANMAR VOWEL SIGN E

1952

];

1953

1954

            let reordered = do_reorder(&fontfile.scope, ttf, None, &syllable)

1955

                .expect("failed to reorder syllable");

1956

1957

            let output = reordered

1958

                .into_iter()

1959

                .map(|glyph| glyph.char() as u32)

1960

                .collect::<Vec<_>>();

1961

            let expected = [

1962

                '\u{1031}' as u32, // MYANMAR VOWEL SIGN E

1963

                '\u{1031}' as u32, // MYANMAR VOWEL SIGN E

1964

                '\u{104b}' as u32, // MYANMAR SIGN SECTION

1965

];

1966

1967

            // This tests the handling of characters with the Punctuation Unicode general category.

1968

            // As far as the implementation goes it's checking the ordering of characters in the

1969

            // `G` regex from the shaping docs.

1970

            assert_eq_hex!(&output, &expected);

1971

1972

1973

1974

    // Tests for shaping up to and including GSUB for Myanmar syllables

1975

    mod gsub {

1976

        use super::*;

1977

1978

        #[test]

1979

        fn gsub1() {

1980

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

1981

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

1982

1983

            let ttf = match fontfile.data {

1984

                OpenTypeData::Single(ttf) => ttf,

1985

                OpenTypeData::Collection(_ttc) => unreachable!(),

1986

};

1987

1988

            let x = apply_gsub(&fontfile.scope, ttf, None, "\u{1045}\u{103c}").unwrap();

1989

1990

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

1991

1992

            // line 06969: ၅ြ

1993

            //   expected: [472, 423]

1994

            //     actual: [423, 472]

1995

1996

            assert_eq!(gids, [423, 472]);

1997

1998

1999

        #[test]

2000

        fn gsub2() {

2001

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

2002

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2003

2004

            let ttf = match fontfile.data {

2005

                OpenTypeData::Single(ttf) => ttf,

2006

                OpenTypeData::Collection(_ttc) => unreachable!(),

2007

};

2008

2009

            // line 06876: ဩ‌

2010

            let x = apply_gsub(&fontfile.scope, ttf, None, "\u{1029}\u{200c}").unwrap();

2011

2012

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2013

2014

            // An earlier version of the code was producing [381] for this test

2015

            assert_eq!(gids, [430, 354, 707]);

2016

2017

2018

        #[test]

2019

        fn mark_filtering_set() {

2020

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

2021

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2022

2023

            let ttf = match fontfile.data {

2024

                OpenTypeData::Single(ttf) => ttf,

2025

                OpenTypeData::Collection(_ttc) => unreachable!(),

2026

};

2027

2028

            let syllable = IntoIterator::into_iter([

2029

                '\u{101C}', // MYANMAR LETTER LA

2030

                '\u{103E}', // MYANMAR CONSONANT SIGN MEDIAL HA

2031

                '\u{102F}', // MYANMAR VOWEL SIGN U

2032

                '\u{1036}', // MYANMAR SIGN ANUSVARA

2033

                '\u{1037}', // MYANMAR SIGN DOT BELOW

2034

])

2035

            .collect::<String>();

2036

2037

            let x = apply_gsub(&fontfile.scope, ttf, None, &syllable).unwrap();

2038

2039

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2040

2041

            // line 06058: လှုံ့

2042

            //   expected: [346, 458, 408, 410]

2043

            //     actual: [346, 454, 395, 408, 410]

2044

2045

            // This test case relies on a mark filtering set to ligate u103E and u102F.

2046

            assert_eq!(gids, [346, 458, 408, 410]);

2047

2048

2049

        #[test]

2050

        #[ignore = "ordering occurs prior to shaping in HB"]

2051

        fn ordering_pre_shaping() {

2052

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

2053

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2054

2055

            let ttf = match fontfile.data {

2056

                OpenTypeData::Single(ttf) => ttf,

2057

                OpenTypeData::Collection(_ttc) => unreachable!(),

2058

};

2059

2060

            let syllable = IntoIterator::into_iter([

2061

                '\u{1004}', // MYANMAR LETTER NGA      gid: 231

2062

                '\u{103A}', // MYANMAR SIGN ASAT       gid: 414

2063

                '\u{1037}', // MYANMAR SIGN DOT BELOW  gid: 410

2064

])

2065

            .collect::<String>();

2066

2067

            let x = apply_gsub(&fontfile.scope, ttf, None, &syllable).unwrap();

2068

2069

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2070

2071

            // line 01252: င့်

2072

            //   expected: [231, 410, 414]

2073

            //     actual: [231, 414, 410]

2074

2075

            // The glyphs are already in this order by the time they reach the Myanmar shaping

2076

            // code in Harfbuzz. I haven't been able to work out where and why this is

2077

            // happening yet. One possibility is Unicode normalisation.

2078

            assert_eq!(gids, [231, 410, 414]);

2079

2080

2081

        #[test]

2082

        fn multiple_anusvara() {

2083

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

2084

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2085

2086

            let ttf = match fontfile.data {

2087

                OpenTypeData::Single(ttf) => ttf,

2088

                OpenTypeData::Collection(_ttc) => unreachable!(),

2089

};

2090

2091

            let syllable = IntoIterator::into_iter([

2092

                '\u{1006}', // MYANMAR LETTER CHA    gid: 247

2093

                '\u{102F}', // MYANMAR VOWEL SIGN U  gid: 394

2094

                '\u{1036}', // MYANMAR SIGN ANUSVARA gid: 408

2095

                '\u{1036}', // MYANMAR SIGN ANUSVARA gid: 408

2096

])

2097

            .collect::<String>();

2098

2099

            let x = apply_gsub(&fontfile.scope, ttf, None, &syllable).unwrap();

2100

2101

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2102

2103

            // line 01831: ဆုံံ

2104

            //   expected: [247, 408, 395, 408]

2105

            //     actual: [247, 395, 408, 408]

2106

2107

            // This tests that Anusvara is tagged with before subjoined even when not immediately

2108

            // following a below base consonant:

2109

//

2110

            // > any ANUSVARA marks that appear after the below-base dependent vowel signs in the

2111

            // > syllable must be tagged with POS_BEFORE_SUBJOINED.

2112

            assert_eq!(gids, [247, 408, 395, 408]);

2113

2114

2115

        #[test]

2116

        fn zwnj() {

2117

            let font = read_fixture_font("myanmar/Padauk-Regular.ttf");

2118

            let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2119

2120

            let ttf = match fontfile.data {

2121

                OpenTypeData::Single(ttf) => ttf,

2122

                OpenTypeData::Collection(_ttc) => unreachable!(),

2123

};

2124

2125

            let syllable = IntoIterator::into_iter([

2126

                '\u{1026}', // MYANMAR LETTER UU

2127

                '\u{1038}', // MYANMAR SIGN VISARGA

2128

                '\u{200C}', // ZERO WIDTH NON-JOINER

2129

])

2130

            .collect::<String>();

2131

2132

            let lang_tag = tag::from_string("BRM").unwrap(); // Burmese

2133

            let x = apply_gsub(&fontfile.scope, ttf, Some(lang_tag), &syllable).unwrap();

2134

2135

            let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2136

2137

            // This tests input that ends with ZWNJ. Note that in gsub::apply

2138

            // there is a call to strip_joiners, which our apply_gsub function

2139

            // doesn't call so the ZWNJ is still present (707).

2140

            assert_eq!(gids, [377, 390, 411, 707]);

2141

2142

2143

2144

    #[test]

2145

    #[cfg(feature = "prince")]

2146

    fn complex_cluster() {

2147

        let font = read_fixture_font("myanmar/MMRTEXT.ttf");

2148

        let fontfile = ReadScope::new(&font).read::<OpenTypeFont<'_>>().unwrap();

2149

2150

        let ttf = match fontfile.data {

2151

            OpenTypeData::Single(ttf) => ttf,

2152

            OpenTypeData::Collection(_ttc) => unreachable!(),

2153

};

2154

2155

        // This test is covering the "complex cluster" example in the OpenType spec:

2156

        // https://learn.microsoft.com/en-us/typography/script-development/myanmar#well-formed-clusters

2157

        let x = apply_gsub(&fontfile.scope, ttf, None, "င်္က္ကျြွှေို့်ာှီ့ၤဲံ့းႍ").unwrap();

2158

        let gids = x.iter().map(|glyph| glyph.glyph_index).collect::<Vec<_>>();

2159

2160

        // 239: Some(AfterMain)                239 POS_AFTER_MAIN

2161

        // 370: Some(AfterMain)                370 POS_AFTER_MAIN

2162

        // 369: Some(AfterMain)                369 POS_AFTER_MAIN

2163

        // 235: Some(SyllableBase)             235 POS_BASE_C

2164

        // 369: Some(AfterMain)                369 POS_AFTER_MAIN, fallback

2165

        // 235: Some(AfterMain)                235 POS_AFTER_MAIN, fallback

2166

        // 319: Some(AfterMain)                319 POS_AFTER_MAIN, fallback

2167

        // 320: Some(PrebaseConsonant)         320 POS_PRE_C

2168

        // 321: Some(AfterMain)                321 POS_AFTER_MAIN, fallback

2169

        // 322: Some(AfterMain)                322 POS_AFTER_MAIN, fallback

2170

        // 344: Some(PrebaseMatra)             344 POS_PRE_M

2171

        // 340: Some(AfterMain)                340 POS_AFTER_MAIN, fallback

2172

        // 342: Some(BelowbaseConsonant)       342 POS_BELOW_C

2173

        // 367: Some(AfterSubjoined)           367 POS_AFTER_SUB

2174

        // 370: Some(AfterSubjoined)           370 POS_AFTER_SUB, fallback

2175

        // 339: Some(AfterSubjoined)           339 POS_AFTER_SUB, fallback

2176

        // 322: Some(AfterSubjoined)           322 POS_AFTER_SUB, fallback

2177

        // 341: Some(AfterSubjoined)           341 POS_AFTER_SUB, fallback

2178

        // 367: Some(AfterSubjoined)           367 POS_AFTER_SUB, fallback

2179

        // 372: Some(AfterSubjoined)           372 POS_AFTER_SUB, fallback

2180

        // 345: Some(BeforeSubjoined)          345 POS_AFTER_SUB, fallback U+1032 Vowel top

2181

        // 366: Some(BeforeSubjoined)          366 POS_AFTER_SUB, fallback

2182

        // 367: Some(AfterSubjoined)           367 POS_AFTER_SUB, fallback

2183

        // 368: Some(AfterSubjoined)           368 POS_AFTER_SUB, fallback

2184

        // 384: Some(AfterSubjoined)           384 POS_AFTER_SUB, fallback

2185

2186

        assert_eq!(

2187

            gids,

2188

2189

                344, 476, 235, 734, 615, 715, 511, 762, 370, 339, 506, 341, 367, 372, 345, 366,

2190

                367, 368, 384

2191

2192

);

2193

2194