Grcov report - gsub.rs

1

//! Glyph substitution (`gsub`) implementation.

2

//!

3

//! > The Glyph Substitution (GSUB) table provides data for substition of glyphs for appropriate

4

//! > rendering of scripts, such as cursively-connecting forms in Arabic script, or for advanced

5

//! > typographic effects, such as ligatures.

6

//!

7

//! — <https://docs.microsoft.com/en-us/typography/opentype/spec/gsub>

8

9

use std::collections::btree_map::Entry;

10

use std::collections::BTreeMap;

11

use std::fmt::Debug;

12

13

use enumflags2::BitFlags;

14

use tinyvec::{tiny_vec, TinyVec};

15

16

use crate::context::{ContextLookupHelper, Glyph, GlyphTable, MatchType};

17

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

18

use crate::layout::{

19

    chain_context_lookup_info, context_lookup_info, AlternateSet, AlternateSubst,

20

    ChainContextLookup, ContextLookup, FeatureTableSubstitution, GDEFTable, LangSys, LayoutCache,

21

    LayoutTable, Ligature, LigatureSubst, LookupCacheItem, LookupList, MultipleSubst,

22

    ReverseChainSingleSubst, SequenceTable, SingleSubst, SubstLookup, GSUB,

23

};

24

use crate::scripts::{self, ScriptType};

25

use crate::tables::variable_fonts::Tuple;

26

use crate::unicode::VariationSelector;

27

use crate::{tag, GlyphId};

28

29

const SUBST_RECURSION_LIMIT: usize = 2;

30

// Matches Harfbuzz:

31

// https://github.com/harfbuzz/harfbuzz/blob/8062c372590980d36d5b4cc720d33dca2662c56e/src/hb-limits.hh#L32

32

pub(crate) const MAX_GLYPHS_FACTOR: usize = 256;

33

34

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

35

pub struct FeatureInfo {

36

    pub feature_tag: u32,

37

    pub alternate: Option<usize>,

38

39

40

type SubstContext<'a> = ContextLookupHelper<'a, GSUB>;

41

42

impl Ligature {

43

410616

    pub fn matches<T>(

44

410616

        &self,

45

410616

        match_type: MatchType,

46

410616

        opt_gdef_table: Option<&GDEFTable>,

47

410616

        i: usize,

48

410616

        glyphs: &[RawGlyph<T>],

49

410616

    ) -> bool {

50

410616

        let mut last_index = 0;

51

410616

        match_type

52

410616

            .match_front(

53

410616

                opt_gdef_table,

54

410616

                &GlyphTable::ById(&self.component_glyphs),

55

410616

                glyphs,

56

410616

i,

57

410616

                &mut last_index,

58

410616

59

410616

            .is_some()

60

410616

61

62

1188

    pub fn apply<T: GlyphData>(

63

1188

        &self,

64

1188

        match_type: MatchType,

65

1188

        opt_gdef_table: Option<&GDEFTable>,

66

1188

        i: usize,

67

1188

        glyphs: &mut Vec<RawGlyph<T>>,

68

1188

    ) -> usize {

69

1188

        let mut index = i + 1;

70

1188

        let mut matched = 0;

71

1188

        let mut skip = 0;

72

2376

        while matched < self.component_glyphs.len() {

73

1188

            if index < glyphs.len() {

74

1188

                if match_type.match_glyph(opt_gdef_table, &glyphs[index]) {

75

1188

                    matched += 1;

76

1188

                    let mut matched_glyph = glyphs.remove(index);

77

1188

                    glyphs[i].unicodes.append(&mut matched_glyph.unicodes);

78

1188

                    glyphs[i].extra_data =

79

1188

                        GlyphData::merge(glyphs[i].extra_data.clone(), matched_glyph.extra_data);

80

1188

                    glyphs[i].flags.set(RawGlyphFlag::LIGATURE, true);

81

1188

                } else {

82

                    glyphs[index].liga_component_pos = matched as u16;

83

                    skip += 1;

84

                    index += 1;

85

86

            } else {

87

                panic!("ran out of glyphs");

88

89

90

30888

        while index < glyphs.len()

91

29700

            && MatchType::marks_only().match_glyph(opt_gdef_table, &glyphs[index])

92

29700

93

29700

            glyphs[index].liga_component_pos = matched as u16;

94

29700

            index += 1;

95

29700

96

1188

        glyphs[i].glyph_index = self.ligature_glyph;

97

1188

        glyphs[i].glyph_origin = GlyphOrigin::Direct;

98

1188

        skip

99

1188

100

101

102

#[derive(Clone, Debug)]

103

pub struct RawGlyph<T> {

104

    pub unicodes: TinyVec<[char; 1]>,

105

    pub glyph_index: GlyphId,

106

    pub liga_component_pos: u16,

107

    pub glyph_origin: GlyphOrigin,

108

    pub flags: RawGlyphFlags,

109

    pub variation: Option<VariationSelector>,

110

    pub extra_data: T,

111

112

113

#[enumflags2::bitflags]

114

#[repr(u8)]

115

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

116

#[allow(non_camel_case_types)]

117

pub enum RawGlyphFlag {

118

    SMALL_CAPS = 1 << 0,

119

    MULTI_SUBST_DUP = 1 << 1,

120

    IS_VERT_ALT = 1 << 2,

121

    LIGATURE = 1 << 3,

122

    FAKE_BOLD = 1 << 4,

123

    FAKE_ITALIC = 1 << 5,

124

125

126

pub type RawGlyphFlags = BitFlags<RawGlyphFlag>;

127

128

/// `merge` is called during ligature substitution (i.e. merging of glyphs),

129

/// and determines how the `RawGlyph.extra_data` field should be merged

130

pub trait GlyphData: Clone {

131

    fn merge(data1: Self, data2: Self) -> Self;

132

133

134

impl GlyphData for () {

135

1188

    fn merge(_data1: (), _data2: ()) {}

136

137

138

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

139

pub enum GlyphOrigin {

140

    Char(char),

141

    Direct,

142

143

144

impl<T> RawGlyph<T> {

145

    pub fn small_caps(&self) -> bool {

146

        self.flags.contains(RawGlyphFlag::SMALL_CAPS)

147

148

149

211894

    pub fn multi_subst_dup(&self) -> bool {

150

211894

        self.flags.contains(RawGlyphFlag::MULTI_SUBST_DUP)

151

211894

152

153

    pub fn is_vert_alt(&self) -> bool {

154

        self.flags.contains(RawGlyphFlag::IS_VERT_ALT)

155

156

157

    pub fn ligature(&self) -> bool {

158

        self.flags.contains(RawGlyphFlag::LIGATURE)

159

160

161

    pub fn fake_bold(&self) -> bool {

162

        self.flags.contains(RawGlyphFlag::FAKE_BOLD)

163

164

165

    pub fn fake_italic(&self) -> bool {

166

        self.flags.contains(RawGlyphFlag::FAKE_ITALIC)

167

168

169

170

impl<T> Glyph for RawGlyph<T> {

171

1072548

    fn get_glyph_index(&self) -> u16 {

172

1072548

        self.glyph_index

173

1072548

174

175

176

pub fn gsub_feature_would_apply<T: GlyphData>(

177

    gsub_cache: &LayoutCache<GSUB>,

178

    gsub_table: &LayoutTable<GSUB>,

179

    opt_gdef_table: Option<&GDEFTable>,

180

    langsys: &LangSys,

181

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

182

    feature_tag: u32,

183

    glyphs: &[RawGlyph<T>],

184

    i: usize,

185

) -> Result<bool, ParseError> {

186

    if let Some(feature_table) =

187

        gsub_table.find_langsys_feature(langsys, feature_tag, feature_variations)?

188

189

        if let Some(ref lookup_list) = gsub_table.opt_lookup_list {

190

            for lookup_index in &feature_table.lookup_indices {

191

                let lookup_index = usize::from(*lookup_index);

192

                let lookup_cache_item = lookup_list.lookup_cache_gsub(gsub_cache, lookup_index)?;

193

                if gsub_lookup_would_apply(opt_gdef_table, &lookup_cache_item, glyphs, i)? {

194

                    return Ok(true);

195

196

197

198

199

    Ok(false)

200

201

202

pub fn gsub_lookup_would_apply<T: GlyphData>(

203

    opt_gdef_table: Option<&GDEFTable>,

204

    lookup: &LookupCacheItem<SubstLookup>,

205

    glyphs: &[RawGlyph<T>],

206

    i: usize,

207

) -> Result<bool, ParseError> {

208

    let match_type = MatchType::from_lookup_flag(lookup.lookup_flag, lookup.mark_filtering_set);

209

    if i < glyphs.len() && match_type.match_glyph(opt_gdef_table, &glyphs[i]) {

210

        return match lookup.lookup_subtables {

211

            SubstLookup::SingleSubst(ref subtables) => {

212

                match singlesubst_would_apply(subtables, &glyphs[i])? {

213

                    Some(_output_glyph) => Ok(true),

214

                    None => Ok(false),

215

216

217

            SubstLookup::MultipleSubst(ref subtables) => {

218

                match multiplesubst_would_apply(subtables, i, glyphs)? {

219

                    Some(_sequence_table) => Ok(true),

220

                    None => Ok(false),

221

222

223

            SubstLookup::AlternateSubst(ref subtables) => {

224

                match alternatesubst_would_apply(subtables, &glyphs[i])? {

225

                    Some(_alternate_set) => Ok(true),

226

                    None => Ok(false),

227

228

229

            SubstLookup::LigatureSubst(ref subtables) => {

230

                match ligaturesubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)? {

231

                    Some(_ligature) => Ok(true),

232

                    None => Ok(false),

233

234

235

            SubstLookup::ContextSubst(ref subtables) => {

236

                match contextsubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)? {

237

                    Some(_subst) => Ok(true),

238

                    None => Ok(false),

239

240

241

            SubstLookup::ChainContextSubst(ref subtables) => {

242

                match chaincontextsubst_would_apply(

243

                    opt_gdef_table,

244

                    subtables,

245

                    match_type,

246

i,

247

                    glyphs,

248

                )? {

249

                    Some(_subst) => Ok(true),

250

                    None => Ok(false),

251

252

253

            SubstLookup::ReverseChainSingleSubst(ref subtables) => {

254

                match reversechainsinglesubst_would_apply(

255

                    opt_gdef_table,

256

                    subtables,

257

                    match_type,

258

i,

259

                    glyphs,

260

                )? {

261

                    Some(_subst) => Ok(true),

262

                    None => Ok(false),

263

264

265

};

266

267

    Ok(false)

268

269

270

/// Apply the specified lookup to the given glyphs.

271

///

272

/// ## Arguments

273

///

274

/// * `gsub_cache` - The GSUB layout cache, created via [new_layout_cache][crate::layout::new_layout_cache].

275

/// * `gsub_table` - The GSUB layout table.

276

/// * `opt_gdef_table` - The GDEF table, if available.

277

/// * `lookup_index` - The index of the lookup to apply.

278

/// * `feature_tag` - The feature tag associated with the lookup.

279

/// * `opt_alternate` - The index of an alternate glyph in the alternate set, if available.

280

/// * `glyphs` - The glyphs to apply the lookup to.

281

/// * `max_glyphs` - The limit to which `glyphs` can grow through substitutions.

282

///   The length of `glyphs` will remain less than this value. If the limit is reached,

283

///   further substitutions will not be applied.

284

/// * `start` - The starting index of the glyphs to apply the lookup to.

285

/// * `length` - The length of the input sequence substituted.

286

/// * `pred` - The predicate function to filter the glyphs to apply the lookup to.

287

175122

pub fn gsub_apply_lookup<T: GlyphData>(

288

175122

    gsub_cache: &LayoutCache<GSUB>,

289

175122

    gsub_table: &LayoutTable<GSUB>,

290

175122

    opt_gdef_table: Option<&GDEFTable>,

291

175122

    lookup_index: usize,

292

175122

    feature_tag: u32,

293

175122

    opt_alternate: Option<usize>,

294

175122

    glyphs: &mut Vec<RawGlyph<T>>,

295

175122

    max_glyphs: usize,

296

175122

    start: usize,

297

175122

    mut length: usize,

298

175122

    pred: impl Fn(&RawGlyph<T>) -> bool,

299

175122

) -> Result<usize, ParseError> {

300

175122

    if let Some(ref lookup_list) = gsub_table.opt_lookup_list {

301

175122

        let lookup = lookup_list.lookup_cache_gsub(gsub_cache, lookup_index)?;

302

175122

        let match_type = MatchType::from_lookup_flag(lookup.lookup_flag, lookup.mark_filtering_set);

303

175122

        match lookup.lookup_subtables {

304

            SubstLookup::SingleSubst(ref subtables) => {

305

                for glyph in glyphs[start..(start + length)].iter_mut() {

306

                    if match_type.match_glyph(opt_gdef_table, glyph) && pred(glyph) {

307

                        singlesubst(subtables, feature_tag, glyph)?;

308

309

310

311

            SubstLookup::MultipleSubst(ref subtables) => {

312

                let mut i = start;

313

                while i < start + length {

314

                    if match_type.match_glyph(opt_gdef_table, &glyphs[i]) && pred(&glyphs[i]) {

315

                        match multiplesubst(subtables, i, glyphs, max_glyphs)? {

316

                            Some(replace_count) => {

317

                                i += replace_count;

318

                                length += replace_count;

319

                                length -= 1;

320

321

                            None => i += 1,

322

323

                    } else {

324

                        i += 1;

325

326

327

328

            SubstLookup::AlternateSubst(ref subtables) => {

329

                for glyph in glyphs[start..(start + length)].iter_mut() {

330

                    if match_type.match_glyph(opt_gdef_table, glyph) && pred(glyph) {

331

                        let alternate = opt_alternate.unwrap_or(0);

332

                        alternatesubst(subtables, alternate, glyph)?;

333

334

335

336

75924

            SubstLookup::LigatureSubst(ref subtables) => {

337

75924

                let mut i = start;

338

741906

                while i < start + length {

339

665982

                    if match_type.match_glyph(opt_gdef_table, &glyphs[i]) && pred(&glyphs[i]) {

340

665982

                        match ligaturesubst(opt_gdef_table, subtables, match_type, i, glyphs)? {

341

1188

                            Some((removed_count, skip_count)) => {

342

1188

                                i += skip_count + 1;

343

1188

                                length -= removed_count;

344

1188

345

664794

                            None => i += 1,

346

347

                    } else {

348

                        i += 1;

349

350

351

352

            SubstLookup::ContextSubst(ref subtables) => {

353

                let mut i = start;

354

                while i < start + length {

355

                    if match_type.match_glyph(opt_gdef_table, &glyphs[i]) && pred(&glyphs[i]) {

356

                        match contextsubst(

357

                            SUBST_RECURSION_LIMIT,

358

                            gsub_cache,

359

                            lookup_list,

360

                            opt_gdef_table,

361

                            subtables,

362

                            feature_tag,

363

                            match_type,

364

i,

365

                            glyphs,

366

                            max_glyphs,

367

                        )? {

368

                            Some((input_length, changes)) => {

369

                                i += input_length;

370

                                length = checked_add(length, changes).unwrap();

371

372

                            None => i += 1,

373

374

                    } else {

375

                        i += 1;

376

377

378

379

99198

            SubstLookup::ChainContextSubst(ref subtables) => {

380

99198

                let mut i = start;

381

938034

                while i < start + length {

382

838836

                    if match_type.match_glyph(opt_gdef_table, &glyphs[i]) && pred(&glyphs[i]) {

383

838836

                        match chaincontextsubst(

384

                            SUBST_RECURSION_LIMIT,

385

838836

                            gsub_cache,

386

838836

                            lookup_list,

387

838836

                            opt_gdef_table,

388

838836

                            subtables,

389

838836

                            feature_tag,

390

838836

                            match_type,

391

838836

i,

392

838836

                            glyphs,

393

838836

                            max_glyphs,

394

                        )? {

395

                            Some((input_length, changes)) => {

396

                                i += input_length;

397

                                length = checked_add(length, changes).unwrap();

398

399

838836

                            None => i += 1,

400

401

                    } else {

402

                        i += 1;

403

404

405

406

            SubstLookup::ReverseChainSingleSubst(ref subtables) => {

407

                for i in (start..start + length).rev() {

408

                    if match_type.match_glyph(opt_gdef_table, &glyphs[i]) && pred(&glyphs[i]) {

409

                        reversechainsinglesubst(opt_gdef_table, subtables, match_type, i, glyphs)?;

410

411

412

413

414

415

175122

    Ok(length)

416

175122

417

418

fn singlesubst_would_apply<T: GlyphData>(

419

    subtables: &[SingleSubst],

420

    glyph: &RawGlyph<T>,

421

) -> Result<Option<u16>, ParseError> {

422

    let glyph_index = glyph.glyph_index;

423

    for single_subst in subtables {

424

        if let Some(glyph_index) = single_subst.apply_glyph(glyph_index)? {

425

            return Ok(Some(glyph_index));

426

427

428

    Ok(None)

429

430

431

fn singlesubst<T: GlyphData>(

432

    subtables: &[SingleSubst],

433

    subst_tag: u32,

434

    glyph: &mut RawGlyph<T>,

435

) -> Result<(), ParseError> {

436

    if let Some(output_glyph) = singlesubst_would_apply(subtables, glyph)? {

437

        glyph.glyph_index = output_glyph;

438

        glyph.glyph_origin = GlyphOrigin::Direct;

439

        if subst_tag == tag::VERT || subst_tag == tag::VRT2 {

440

            glyph.flags.set(RawGlyphFlag::IS_VERT_ALT, true);

441

442

443

    Ok(())

444

445

446

fn multiplesubst_would_apply<'a, T: GlyphData>(

447

    subtables: &'a [MultipleSubst],

448

    i: usize,

449

    glyphs: &[RawGlyph<T>],

450

) -> Result<Option<&'a SequenceTable>, ParseError> {

451

    let glyph_index = glyphs[i].glyph_index;

452

    for multiple_subst in subtables {

453

        if let Some(sequence_table) = multiple_subst.apply_glyph(glyph_index)? {

454

            return Ok(Some(sequence_table));

455

456

457

    Ok(None)

458

459

460

fn multiplesubst<T: GlyphData>(

461

    subtables: &[MultipleSubst],

462

    i: usize,

463

    glyphs: &mut Vec<RawGlyph<T>>,

464

    max_glyphs: usize,

465

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

466

    match multiplesubst_would_apply(subtables, i, glyphs)? {

467

        Some(sequence_table) => {

468

            if sequence_table.substitute_glyphs.len() + glyphs.len() >= max_glyphs {

469

                // The Unicode text rendering tests say that shaping should stop when the limit is

470

                // reached, but not fail:

471

//

472

                // "If your implementation is immune to this attack, it should neither crash nor

473

                // hang when rendering lol with this font. Instead, your implementation should stop

474

                // executing once its internal buffer has reached a size limit."

475

                return Ok(Some(0));

476

477

478

            if !sequence_table.substitute_glyphs.is_empty() {

479

                let first_glyph_index = sequence_table.substitute_glyphs[0];

480

                glyphs[i].glyph_index = first_glyph_index;

481

                glyphs[i].glyph_origin = GlyphOrigin::Direct;

482

                for j in 1..sequence_table.substitute_glyphs.len() {

483

                    let output_glyph_index = sequence_table.substitute_glyphs[j];

484

                    let mut flags = glyphs[i].flags;

485

                    flags.set(RawGlyphFlag::MULTI_SUBST_DUP, true);

486

                    flags.set(RawGlyphFlag::LIGATURE, false);

487

                    let glyph = RawGlyph {

488

                        unicodes: glyphs[i].unicodes.clone(),

489

                        glyph_index: output_glyph_index,

490

                        liga_component_pos: 0, //glyphs[i].liga_component_pos,

491

                        glyph_origin: GlyphOrigin::Direct,

492

                        flags,

493

                        extra_data: glyphs[i].extra_data.clone(),

494

                        variation: glyphs[i].variation,

495

};

496

                    glyphs.insert(i + j, glyph);

497

498

                Ok(Some(sequence_table.substitute_glyphs.len()))

499

            } else {

500

                // the spec forbids this, but implementations all allow it

501

                glyphs.remove(i);

502

                Ok(Some(0))

503

504

505

        None => Ok(None),

506

507

508

509

fn alternatesubst_would_apply<'a, T: GlyphData>(

510

    subtables: &'a [AlternateSubst],

511

    glyph: &RawGlyph<T>,

512

) -> Result<Option<&'a AlternateSet>, ParseError> {

513

    let glyph_index = glyph.glyph_index;

514

    for alternate_subst in subtables {

515

        if let Some(alternate_set) = alternate_subst.apply_glyph(glyph_index)? {

516

            return Ok(Some(alternate_set));

517

518

519

    Ok(None)

520

521

522

fn alternatesubst<T: GlyphData>(

523

    subtables: &[AlternateSubst],

524

    alternate: usize,

525

    glyph: &mut RawGlyph<T>,

526

) -> Result<(), ParseError> {

527

    if let Some(alternateset) = alternatesubst_would_apply(subtables, glyph)? {

528

        // TODO allow users to specify which alternate glyph they want

529

        if alternate < alternateset.alternate_glyphs.len() {

530

            glyph.glyph_index = alternateset.alternate_glyphs[alternate];

531

            glyph.glyph_origin = GlyphOrigin::Direct;

532

533

534

    Ok(())

535

536

537

665982

fn ligaturesubst_would_apply<'a, T: GlyphData>(

538

665982

    opt_gdef_table: Option<&GDEFTable>,

539

665982

    subtables: &'a [LigatureSubst],

540

665982

    match_type: MatchType,

541

665982

    i: usize,

542

665982

    glyphs: &[RawGlyph<T>],

543

665982

) -> Result<Option<&'a Ligature>, ParseError> {

544

665982

    let glyph_index = glyphs[i].glyph_index;

545

1330776

    for ligature_subst in subtables {

546

665982

        if let Some(ligatureset) = ligature_subst.apply_glyph(glyph_index)? {

547

420876

            for ligature in &ligatureset.ligatures {

548

410616

                if ligature.matches(match_type, opt_gdef_table, i, glyphs) {

549

1188

                    return Ok(Some(ligature));

550

409428

551

552

654534

553

554

664794

    Ok(None)

555

665982

556

557

665982

fn ligaturesubst<T: GlyphData>(

558

665982

    opt_gdef_table: Option<&GDEFTable>,

559

665982

    subtables: &[LigatureSubst],

560

665982

    match_type: MatchType,

561

665982

    i: usize,

562

665982

    glyphs: &mut Vec<RawGlyph<T>>,

563

665982

) -> Result<Option<(usize, usize)>, ParseError> {

564

665982

    match ligaturesubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)? {

565

1188

        Some(ligature) => Ok(Some((

566

1188

            ligature.component_glyphs.len(),

567

1188

            ligature.apply(match_type, opt_gdef_table, i, glyphs),

568

1188

        ))),

569

664794

        None => Ok(None),

570

571

665982

572

573

fn contextsubst_would_apply<'a, T: GlyphData>(

574

    opt_gdef_table: Option<&GDEFTable>,

575

    subtables: &'a [ContextLookup<GSUB>],

576

    match_type: MatchType,

577

    i: usize,

578

    glyphs: &[RawGlyph<T>],

579

) -> Result<Option<Box<SubstContext<'a>>>, ParseError> {

580

    let glyph_index = glyphs[i].glyph_index;

581

    for context_lookup in subtables {

582

        if let Some(context) = context_lookup_info(context_lookup, glyph_index, |context| {

583

            context.matches(opt_gdef_table, match_type, glyphs, i)

584

        })? {

585

            return Ok(Some(context));

586

587

588

    Ok(None)

589

590

591

fn contextsubst<T: GlyphData>(

592

    recursion_limit: usize,

593

    gsub_cache: &LayoutCache<GSUB>,

594

    lookup_list: &LookupList<GSUB>,

595

    opt_gdef_table: Option<&GDEFTable>,

596

    subtables: &[ContextLookup<GSUB>],

597

    feature_tag: u32,

598

    match_type: MatchType,

599

    i: usize,

600

    glyphs: &mut Vec<RawGlyph<T>>,

601

    max_glyphs: usize,

602

) -> Result<Option<(usize, isize)>, ParseError> {

603

    match contextsubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)? {

604

        Some(subst) => apply_subst_context(

605

            recursion_limit,

606

            gsub_cache,

607

            lookup_list,

608

            opt_gdef_table,

609

            feature_tag,

610

            match_type,

611

            &subst,

612

i,

613

            glyphs,

614

            max_glyphs,

615

),

616

        None => Ok(None),

617

618

619

620

838836

fn chaincontextsubst_would_apply<'a, T: GlyphData>(

621

838836

    opt_gdef_table: Option<&GDEFTable>,

622

838836

    subtables: &'a [ChainContextLookup<GSUB>],

623

838836

    match_type: MatchType,

624

838836

    i: usize,

625

838836

    glyphs: &[RawGlyph<T>],

626

838836

) -> Result<Option<Box<SubstContext<'a>>>, ParseError> {

627

838836

    let glyph_index = glyphs[i].glyph_index;

628

2393496

    for chain_context_lookup in subtables {

629

        if let Some(context) =

630

1554660

            chain_context_lookup_info(chain_context_lookup, glyph_index, |context| {

631

6858

                context.matches(opt_gdef_table, match_type, glyphs, i)

632

6858

})?

633

634

            return Ok(Some(context));

635

1554660

636

637

838836

    Ok(None)

638

838836

639

640

838836

fn chaincontextsubst<T: GlyphData>(

641

838836

    recursion_limit: usize,

642

838836

    gsub_cache: &LayoutCache<GSUB>,

643

838836

    lookup_list: &LookupList<GSUB>,

644

838836

    opt_gdef_table: Option<&GDEFTable>,

645

838836

    subtables: &[ChainContextLookup<GSUB>],

646

838836

    feature_tag: u32,

647

838836

    match_type: MatchType,

648

838836

    i: usize,

649

838836

    glyphs: &mut Vec<RawGlyph<T>>,

650

838836

    max_glyphs: usize,

651

838836

) -> Result<Option<(usize, isize)>, ParseError> {

652

838836

    match chaincontextsubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)? {

653

        Some(subst) => apply_subst_context(

654

            recursion_limit,

655

            gsub_cache,

656

            lookup_list,

657

            opt_gdef_table,

658

            feature_tag,

659

            match_type,

660

            &subst,

661

i,

662

            glyphs,

663

            max_glyphs,

664

),

665

838836

        None => Ok(None),

666

667

838836

668

669

fn reversechainsinglesubst_would_apply<T: GlyphData>(

670

    opt_gdef_table: Option<&GDEFTable>,

671

    subtables: &[ReverseChainSingleSubst],

672

    match_type: MatchType,

673

    i: usize,

674

    glyphs: &[RawGlyph<T>],

675

) -> Result<Option<u16>, ParseError> {

676

    let glyph_index = glyphs[i].glyph_index;

677

    for reversechainsinglesubst in subtables {

678

        if let new_glyph_index @ Some(_) =

679

            reversechainsinglesubst.apply_glyph(glyph_index, |context| {

680

                context

681

                    .matches(opt_gdef_table, match_type, glyphs, i)

682

                    .is_some()

683

})?

684

685

            return Ok(new_glyph_index);

686

687

688

    Ok(None)

689

690

691

fn reversechainsinglesubst<T: GlyphData>(

692

    opt_gdef_table: Option<&GDEFTable>,

693

    subtables: &[ReverseChainSingleSubst],

694

    match_type: MatchType,

695

    i: usize,

696

    glyphs: &mut [RawGlyph<T>],

697

) -> Result<(), ParseError> {

698

    if let Some(output_glyph_index) =

699

        reversechainsinglesubst_would_apply(opt_gdef_table, subtables, match_type, i, glyphs)?

700

701

        glyphs[i].glyph_index = output_glyph_index;

702

        glyphs[i].glyph_origin = GlyphOrigin::Direct;

703

704

    Ok(())

705

706

707

fn apply_subst_context<T: GlyphData>(

708

    recursion_limit: usize,

709

    gsub_cache: &LayoutCache<GSUB>,

710

    lookup_list: &LookupList<GSUB>,

711

    opt_gdef_table: Option<&GDEFTable>,

712

    feature_tag: u32,

713

    match_type: MatchType,

714

    subst: &SubstContext<'_>,

715

    i: usize,

716

    glyphs: &mut Vec<RawGlyph<T>>,

717

    max_glyphs: usize,

718

) -> Result<Option<(usize, isize)>, ParseError> {

719

    let mut changes = 0;

720

    let len = match match_type.find_nth(

721

        opt_gdef_table,

722

        glyphs,

723

i,

724

        subst.match_context.input_table.len(),

725

) {

726

        Some(last) => last - i + 1,

727

        None => return Ok(None), // FIXME actually an error/impossible?

728

};

729

    for (subst_index, subst_lookup_index) in subst.lookup_array {

730

        if let Some(changes0) = apply_subst(

731

            recursion_limit,

732

            gsub_cache,

733

            lookup_list,

734

            opt_gdef_table,

735

            match_type,

736

            usize::from(*subst_index),

737

            usize::from(*subst_lookup_index),

738

            feature_tag,

739

            glyphs,

740

            max_glyphs,

741

i,

742

        )? {

743

            changes += changes0

744

745

746

    match checked_add(len, changes) {

747

        Some(new_len) => Ok(Some((new_len, changes))),

748

        None => panic!("apply_subst_context: len < 0"),

749

750

751

752

fn checked_add(base: usize, changes: isize) -> Option<usize> {

753

    if changes < 0 {

754

        base.checked_sub(changes.wrapping_abs() as usize)

755

    } else {

756

        base.checked_add(changes as usize)

757

758

759

760

fn apply_subst<T: GlyphData>(

761

    recursion_limit: usize,

762

    gsub_cache: &LayoutCache<GSUB>,

763

    lookup_list: &LookupList<GSUB>,

764

    opt_gdef_table: Option<&GDEFTable>,

765

    parent_match_type: MatchType,

766

    subst_index: usize,

767

    lookup_index: usize,

768

    feature_tag: u32,

769

    glyphs: &mut Vec<RawGlyph<T>>,

770

    max_glyphs: usize,

771

    index: usize,

772

) -> Result<Option<isize>, ParseError> {

773

    let lookup = lookup_list.lookup_cache_gsub(gsub_cache, lookup_index)?;

774

    let match_type = MatchType::from_lookup_flag(lookup.lookup_flag, lookup.mark_filtering_set);

775

    let i = match parent_match_type.find_nth(opt_gdef_table, glyphs, index, subst_index) {

776

        Some(index1) => index1,

777

        None => return Ok(None), // FIXME error?

778

};

779

    match lookup.lookup_subtables {

780

        SubstLookup::SingleSubst(ref subtables) => {

781

            singlesubst(subtables, feature_tag, &mut glyphs[i])?;

782

            Ok(Some(0))

783

784

        SubstLookup::MultipleSubst(ref subtables) => {

785

            match multiplesubst(subtables, i, glyphs, max_glyphs)? {

786

                Some(replace_count) => Ok(Some((replace_count as isize) - 1)),

787

                None => Ok(None),

788

789

790

        SubstLookup::AlternateSubst(ref subtables) => {

791

            alternatesubst(subtables, 0, &mut glyphs[i])?;

792

            Ok(Some(0))

793

794

        SubstLookup::LigatureSubst(ref subtables) => {

795

            match ligaturesubst(opt_gdef_table, subtables, match_type, i, glyphs)? {

796

                Some((removed_count, _skip_count)) => Ok(Some(-(removed_count as isize))),

797

                None => Ok(None), // FIXME error?

798

799

800

        SubstLookup::ContextSubst(ref subtables) => {

801

            if recursion_limit > 0 {

802

                match contextsubst(

803

                    recursion_limit - 1,

804

                    gsub_cache,

805

                    lookup_list,

806

                    opt_gdef_table,

807

                    subtables,

808

                    feature_tag,

809

                    match_type,

810

i,

811

                    glyphs,

812

                    max_glyphs,

813

                )? {

814

                    Some((_length, change)) => Ok(Some(change)),

815

                    None => Ok(None),

816

817

            } else {

818

                Err(ParseError::LimitExceeded)

819

820

821

        SubstLookup::ChainContextSubst(ref subtables) => {

822

            if recursion_limit > 0 {

823

                match chaincontextsubst(

824

                    recursion_limit - 1,

825

                    gsub_cache,

826

                    lookup_list,

827

                    opt_gdef_table,

828

                    subtables,

829

                    feature_tag,

830

                    match_type,

831

i,

832

                    glyphs,

833

                    max_glyphs,

834

                )? {

835

                    Some((_length, change)) => Ok(Some(change)),

836

                    None => Ok(None),

837

838

            } else {

839

                Err(ParseError::LimitExceeded)

840

841

842

        SubstLookup::ReverseChainSingleSubst(ref subtables) => {

843

            reversechainsinglesubst(opt_gdef_table, subtables, match_type, i, glyphs)?;

844

            Ok(Some(0))

845

846

847

848

849

fn build_lookups_custom(

850

    gsub_table: &LayoutTable<GSUB>,

851

    langsys: &LangSys,

852

    feature_tags: &[FeatureInfo],

853

    feature_mask: FeatureMask,

854

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

855

) -> Result<BTreeMap<usize, u32>, ParseError> {

856

    let mut lookups = BTreeMap::new();

857

    for feature_info in feature_tags {

858

        // Skip features already applied via the feature mask to avoid

859

        // applying them twice (e.g. font-feature-settings: "ccmp" 1).

860

        if let Some(feature) = Feature::from_tag(feature_info.feature_tag) {

861

            if feature_mask.contains(feature) {

862

                continue;

863

864

865

        if let Some(feature_table) = gsub_table.find_langsys_feature(

866

            langsys,

867

            feature_info.feature_tag,

868

            feature_variations,

869

        )? {

870

            lookups.extend(

871

                feature_table

872

                    .lookup_indices

873

                    .iter()

874

                    .map(|&lookup_index| (usize::from(lookup_index), feature_info.feature_tag)),

875

);

876

877

878

    Ok(lookups)

879

880

881

5238

fn build_lookups_default(

882

5238

    gsub_table: &LayoutTable<GSUB>,

883

5238

    langsys: &LangSys,

884

5238

    feature_masks: FeatureMask,

885

5238

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

886

5238

) -> Result<Vec<(usize, u32)>, ParseError> {

887

5238

    let mut lookups = BTreeMap::new();

888

20628

    for feature in feature_masks {

889

15390

        let feature_tag = feature.tag();

890

15390

        if let Some(feature_table) =

891

15390

            gsub_table.find_langsys_feature(langsys, feature_tag, feature_variations)?

892

893

45198

            for lookup_index in &feature_table.lookup_indices {

894

45198

                lookups.insert(usize::from(*lookup_index), feature_tag);

895

45198

896

        } else if feature == Feature::VRT2_OR_VERT {

897

            let vert_tag = tag::VERT;

898

            if let Some(feature_table) =

899

                gsub_table.find_langsys_feature(langsys, vert_tag, feature_variations)?

900

901

                for lookup_index in &feature_table.lookup_indices {

902

                    lookups.insert(usize::from(*lookup_index), vert_tag);

903

904

905

906

907

908

    // note: iter() returns sorted by key

909

5238

    Ok(lookups.into_iter().collect())

910

5238

911

912

5238

fn make_supported_features_mask(

913

5238

    gsub_table: &LayoutTable<GSUB>,

914

5238

    langsys: &LangSys,

915

5238

) -> Result<FeatureMask, ParseError> {

916

5238

    let mut feature_mask = FeatureMask::empty();

917

105462

    for feature_index in langsys.feature_indices_iter() {

918

105462

        let feature_record = gsub_table.feature_by_index(*feature_index)?;

919

105462

        feature_mask |= FeatureMask::from_tag(feature_record.feature_tag);

920

921

5238

    Ok(feature_mask)

922

5238

923

924

49248

fn lang_tag_key(opt_lang_tag: Option<u32>) -> u32 {

925

    // `DFLT` is not a valid lang tag so we use it to indicate the default

926

49248

    opt_lang_tag.unwrap_or(tag::DFLT)

927

49248

928

929

24624

fn get_supported_features(

930

24624

    gsub_cache: &LayoutCache<GSUB>,

931

24624

    script_tag: u32,

932

24624

    opt_lang_tag: Option<u32>,

933

24624

) -> Result<FeatureMask, ParseError> {

934

24624

    let feature_mask = match gsub_cache

935

24624

        .supported_features

936

24624

        .lock()

937

24624

        .unwrap()

938

24624

        .entry((script_tag, lang_tag_key(opt_lang_tag)))

939

940

19116

        Entry::Occupied(entry) => BitFlags::from_bits_truncate(*entry.get()),

941

5508

        Entry::Vacant(entry) => {

942

5508

            let gsub_table = &gsub_cache.layout_table;

943

5508

            let feature_mask =

944

5508

                if let Some(script) = gsub_table.find_script_or_default(script_tag)? {

945

5238

                    if let Some(langsys) = script.find_langsys_or_default(opt_lang_tag)? {

946

5238

                        make_supported_features_mask(gsub_table, langsys)?

947

                    } else {

948

                        FeatureMask::empty()

949

950

                } else {

951

270

                    FeatureMask::empty()

952

};

953

5508

            entry.insert(feature_mask.bits());

954

5508

            feature_mask

955

956

};

957

24624

    Ok(feature_mask)

958

24624

959

960

fn find_alternate(features_list: &[FeatureInfo], feature_tag: u32) -> Option<usize> {

961

    for feature_info in features_list {

962

        if feature_info.feature_tag == feature_tag {

963

            return feature_info.alternate;

964

965

966

    None

967

968

969

24624

pub fn replace_missing_glyphs<T: GlyphData>(glyphs: &mut [RawGlyph<T>], num_glyphs: u16) {

970

171558

    for glyph in glyphs.iter_mut() {

971

171558

        if glyph.glyph_index >= num_glyphs {

972

            glyph.unicodes = tiny_vec![];

973

            glyph.glyph_index = 0;

974

            glyph.liga_component_pos = 0;

975

            glyph.glyph_origin = GlyphOrigin::Direct;

976

            glyph.flags = RawGlyphFlags::empty();

977

            glyph.variation = None;

978

171558

979

980

24624

981

982

24624

fn strip_joiners<T: GlyphData>(glyphs: &mut Vec<RawGlyph<T>>) {

983

171558

    glyphs.retain(|g| match g.glyph_origin {

984

        GlyphOrigin::Char('\u{200C}') => false,

985

        GlyphOrigin::Char('\u{200D}') => false,

986

171558

        _ => true,

987

171558

})

988

24624

989

990

#[enumflags2::bitflags]

991

#[repr(u64)]

992

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

993

#[allow(non_camel_case_types)]

994

pub enum Feature {

995

    ABVF,

996

    ABVS,

997

    AFRC,

998

    AKHN,

999

    BLWF,

1000

    BLWS,

1001

    C2SC,

1002

    CALT,

1003

    CASE,

1004

    CCMP,

1005

    CFAR,

1006

    CJCT,

1007

    CLIG,

1008

    CPSP,

1009

    CSWH,

1010

    DLIG,

1011

    FINA,

1012

    FIN2,

1013

    FIN3,

1014

    FRAC,

1015

    HALF,

1016

    HALN,

1017

    HIST,

1018

    HLIG,

1019

    INIT,

1020

    ISOL,

1021

    LIGA,

1022

    LNUM,

1023

    LOCL,

1024

    MEDI,

1025

    MED2,

1026

    MSET,

1027

    NUKT,

1028

    ONUM,

1029

    ORDN,

1030

    PNUM,

1031

    PREF,

1032

    PRES,

1033

    PSTF,

1034

    PSTS,

1035

    RCLT,

1036

    RKRF,

1037

    RLIG,

1038

    RPHF,

1039

    SMCP,

1040

    TNUM,

1041

    VATU,

1042

    VRT2_OR_VERT,

1043

    ZERO,

1044

    RVRN,

1045

1046

1047

pub type FeatureMask = BitFlags<Feature>;

1048

1049

impl Feature {

1050

    /// Convert a single feature into a `FeatureMask` containing just that feature.

1051

    pub fn mask(self) -> FeatureMask {

1052

        FeatureMask::from(self)

1053

1054

1055

    /// Return the OpenType GSUB feature tag corresponding to this feature.

1056

15390

    pub fn tag(self) -> u32 {

1057

15390

        match self {

1058

            Feature::ABVF => tag::ABVF,

1059

            Feature::ABVS => tag::ABVS,

1060

            Feature::AFRC => tag::AFRC,

1061

            Feature::AKHN => tag::AKHN,

1062

            Feature::BLWF => tag::BLWF,

1063

            Feature::BLWS => tag::BLWS,

1064

            Feature::C2SC => tag::C2SC,

1065

4914

            Feature::CALT => tag::CALT,

1066

            Feature::CASE => tag::CASE,

1067

5238

            Feature::CCMP => tag::CCMP,

1068

            Feature::CFAR => tag::CFAR,

1069

            Feature::CJCT => tag::CJCT,

1070

            Feature::CLIG => tag::CLIG,

1071

            Feature::CPSP => tag::CPSP,

1072

            Feature::CSWH => tag::CSWH,

1073

            Feature::DLIG => tag::DLIG,

1074

            Feature::FINA => tag::FINA,

1075

            Feature::FIN2 => tag::FIN2,

1076

            Feature::FIN3 => tag::FIN3,

1077

            Feature::FRAC => tag::FRAC,

1078

            Feature::HALF => tag::HALF,

1079

            Feature::HALN => tag::HALN,

1080

            Feature::HIST => tag::HIST,

1081

            Feature::HLIG => tag::HLIG,

1082

            Feature::INIT => tag::INIT,

1083

            Feature::ISOL => tag::ISOL,

1084

5238

            Feature::LIGA => tag::LIGA,

1085

            Feature::LNUM => tag::LNUM,

1086

            Feature::LOCL => tag::LOCL,

1087

            Feature::MEDI => tag::MEDI,

1088

            Feature::MED2 => tag::MED2,

1089

            Feature::MSET => tag::MSET,

1090

            Feature::NUKT => tag::NUKT,

1091

            Feature::ONUM => tag::ONUM,

1092

            Feature::ORDN => tag::ORDN,

1093

            Feature::PNUM => tag::PNUM,

1094

            Feature::PREF => tag::PREF,

1095

            Feature::PRES => tag::PRES,

1096

            Feature::PSTF => tag::PSTF,

1097

            Feature::PSTS => tag::PSTS,

1098

            Feature::RCLT => tag::RCLT,

1099

            Feature::RKRF => tag::RKRF,

1100

            Feature::RLIG => tag::RLIG,

1101

            Feature::RPHF => tag::RPHF,

1102

            Feature::RVRN => tag::RVRN,

1103

            Feature::SMCP => tag::SMCP,

1104

            Feature::TNUM => tag::TNUM,

1105

            Feature::VATU => tag::VATU,

1106

            Feature::VRT2_OR_VERT => tag::VRT2,

1107

            Feature::ZERO => tag::ZERO,

1108

1109

15390

1110

1111

105462

    pub fn from_tag(tag: u32) -> Option<Feature> {

1112

105462

        match tag {

1113

            tag::ABVF => Some(Feature::ABVF),

1114

            tag::ABVS => Some(Feature::ABVS),

1115

            tag::AFRC => Some(Feature::AFRC),

1116

            tag::AKHN => Some(Feature::AKHN),

1117

            tag::BLWF => Some(Feature::BLWF),

1118

            tag::BLWS => Some(Feature::BLWS),

1119

            tag::C2SC => Some(Feature::C2SC),

1120

4914

            tag::CALT => Some(Feature::CALT),

1121

5238

            tag::CASE => Some(Feature::CASE),

1122

5238

            tag::CCMP => Some(Feature::CCMP),

1123

            tag::CFAR => Some(Feature::CFAR),

1124

            tag::CJCT => Some(Feature::CJCT),

1125

            tag::CLIG => Some(Feature::CLIG),

1126

            tag::CPSP => Some(Feature::CPSP),

1127

            tag::CSWH => Some(Feature::CSWH),

1128

5238

            tag::DLIG => Some(Feature::DLIG),

1129

            tag::FINA => Some(Feature::FINA),

1130

            tag::FIN2 => Some(Feature::FIN2),

1131

            tag::FIN3 => Some(Feature::FIN3),

1132

4914

            tag::FRAC => Some(Feature::FRAC),

1133

            tag::HALF => Some(Feature::HALF),

1134

            tag::HALN => Some(Feature::HALN),

1135

            tag::HIST => Some(Feature::HIST),

1136

324

            tag::HLIG => Some(Feature::HLIG),

1137

            tag::INIT => Some(Feature::INIT),

1138

            tag::ISOL => Some(Feature::ISOL),

1139

5238

            tag::LIGA => Some(Feature::LIGA),

1140

4914

            tag::LNUM => Some(Feature::LNUM),

1141

            tag::LOCL => Some(Feature::LOCL),

1142

            tag::MEDI => Some(Feature::MEDI),

1143

            tag::MED2 => Some(Feature::MED2),

1144

            tag::MSET => Some(Feature::MSET),

1145

            tag::NUKT => Some(Feature::NUKT),

1146

4914

            tag::ONUM => Some(Feature::ONUM),

1147

4914

            tag::ORDN => Some(Feature::ORDN),

1148

4914

            tag::PNUM => Some(Feature::PNUM),

1149

            tag::PREF => Some(Feature::PREF),

1150

            tag::PRES => Some(Feature::PRES),

1151

            tag::PSTF => Some(Feature::PSTF),

1152

            tag::PSTS => Some(Feature::PSTS),

1153

            tag::RCLT => Some(Feature::RCLT),

1154

            tag::RKRF => Some(Feature::RKRF),

1155

            tag::RLIG => Some(Feature::RLIG),

1156

            tag::RPHF => Some(Feature::RPHF),

1157

            tag::RVRN => Some(Feature::RVRN),

1158

            tag::SMCP => Some(Feature::SMCP),

1159

4914

            tag::TNUM => Some(Feature::TNUM),

1160

            tag::VATU => Some(Feature::VATU),

1161

            tag::VERT => Some(Feature::VRT2_OR_VERT),

1162

            tag::VRT2 => Some(Feature::VRT2_OR_VERT),

1163

            tag::ZERO => Some(Feature::ZERO),

1164

49788

            _ => None,

1165

1166

105462

1167

1168

1169

/// Extension trait adding methods to `FeatureMask` (`BitFlags<Feature>`).

1170

pub trait FeatureMaskExt {

1171

    /// Convert a feature tag to a FeatureMask. Returns empty mask for unknown tags.

1172

    fn from_tag(tag: u32) -> FeatureMask;

1173

1174

    /// Return the default FeatureMask for basic Latin/default shaping.

1175

    fn default_mask() -> FeatureMask;

1176

1177

    /// Iterate over the individual features in a FeatureMask.

1178

    fn features(&self) -> impl Iterator<Item = FeatureInfo>;

1179

1180

1181

impl FeatureMaskExt for FeatureMask {

1182

105462

    fn from_tag(tag: u32) -> FeatureMask {

1183

105462

        Feature::from_tag(tag).map_or(FeatureMask::empty(), FeatureMask::from)

1184

105462

1185

1186

24168

    fn default_mask() -> FeatureMask {

1187

24168

        Feature::CCMP

1188

24168

            | Feature::RLIG

1189

24168

            | Feature::CLIG

1190

24168

            | Feature::LIGA

1191

24168

            | Feature::LOCL

1192

24168

            | Feature::CALT

1193

24168

1194

1195

23274

    fn features(&self) -> impl Iterator<Item = FeatureInfo> {

1196

23274

        self.iter().map(|feature| FeatureInfo {

1197

            feature_tag: feature.tag(),

1198

            alternate: None,

1199

})

1200

23274

1201

1202

1203

pub fn features_supported(

1204

    gsub_cache: &LayoutCache<GSUB>,

1205

    script_tag: u32,

1206

    opt_lang_tag: Option<u32>,

1207

    feature_mask: FeatureMask,

1208

) -> Result<bool, ShapingError> {

1209

    let supported_features = get_supported_features(gsub_cache, script_tag, opt_lang_tag)?;

1210

    Ok(supported_features.contains(feature_mask))

1211

1212

1213

24624

pub fn get_lookups_cache_index(

1214

24624

    gsub_cache: &LayoutCache<GSUB>,

1215

24624

    script_tag: u32,

1216

24624

    opt_lang_tag: Option<u32>,

1217

24624

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

1218

24624

    feature_mask: FeatureMask,

1219

24624

) -> Result<usize, ParseError> {

1220

24624

    let index = match gsub_cache.lookups_index.lock().unwrap().entry((

1221

24624

        script_tag,

1222

24624

        lang_tag_key(opt_lang_tag),

1223

24624

        feature_mask.bits(),

1224

24624

    )) {

1225

19116

        Entry::Occupied(entry) => *entry.get(),

1226

5508

        Entry::Vacant(entry) => {

1227

5508

            let gsub_table = &gsub_cache.layout_table;

1228

5508

            if let Some(script) = gsub_table.find_script_or_default(script_tag)? {

1229

5238

                if let Some(langsys) = script.find_langsys_or_default(opt_lang_tag)? {

1230

5238

                    let lookups = build_lookups_default(

1231

5238

                        gsub_table,

1232

5238

                        langsys,

1233

5238

                        feature_mask,

1234

5238

                        feature_variations,

1235

)?;

1236

5238

                    let mut cached_lookups = gsub_cache.cached_lookups.lock().unwrap();

1237

5238

                    let index = cached_lookups.len();

1238

5238

                    cached_lookups.push(lookups);

1239

5238

                    *entry.insert(index)

1240

                } else {

1241

                    *entry.insert(0)

1242

1243

            } else {

1244

270

                *entry.insert(0)

1245

1246

1247

};

1248

24624

    Ok(index)

1249

24624

1250

1251

/// Perform glyph substitution according to the supplied features, script and language.

1252

///

1253

/// `dotted_circle_index` is the glyph index of U+25CC DOTTED CIRCLE: ◌. This is inserted

1254

/// when shaping some complex scripts where the input text contains incomplete syllables.

1255

/// If you have an instance of `FontDataImpl` the glyph index can be retrieved via the

1256

/// `lookup_glyph_index` method.

1257

///

1258

/// ## Example

1259

///

1260

/// The following shows a complete example of loading a font, mapping text to glyphs, and

1261

/// applying glyph substitution.

1262

///

1263

/// ```

1264

/// use std::error::Error;

1265

/// use std::sync::Arc;

1266

///

1267

/// use allsorts::binary::read::ReadScope;

1268

/// use allsorts::error::ParseError;

1269

/// use allsorts::font::{MatchingPresentation};

1270

/// use allsorts::font_data::FontData;

1271

/// use allsorts::gsub::{FeatureMask, FeatureMaskExt, GlyphOrigin, RawGlyph, RawGlyphFlags};

1272

/// use allsorts::tinyvec::tiny_vec;

1273

/// use allsorts::unicode::VariationSelector;

1274

/// use allsorts::DOTTED_CIRCLE;

1275

/// use allsorts::{gsub, tag, Font};

1276

///

1277

/// fn shape(text: &str) -> Result<Vec<RawGlyph<()>>, Box<dyn Error>> {

1278

///     let script = tag::from_string("LATN")?;

1279

///     let lang = tag::from_string("DFLT")?;

1280

///     let buffer = std::fs::read("tests/fonts/opentype/Klei.otf")

1281

///         .expect("unable to read Klei.otf");

1282

///     let scope = ReadScope::new(&buffer);

1283

///     let font_file = scope.read::<FontData<'_>>()?;

1284

///     // Use a different index to access other fonts in a font collection (E.g. TTC)

1285

///     let provider = font_file.table_provider(0)?;

1286

///     let mut font = Font::new(provider)?;

1287

///

1288

///     let opt_gsub_cache = font.gsub_cache()?;

1289

///     let opt_gpos_cache = font.gpos_cache()?;

1290

///     let opt_gdef_table = font.gdef_table()?;

1291

///     let opt_gdef_table = opt_gdef_table.as_ref().map(Arc::as_ref);

1292

///

1293

///     // Map glyphs

1294

///     //

1295

///     // We look ahead in the char stream for variation selectors. If one is found it is used for

1296

///     // mapping the current glyph. When a variation selector is reached in the stream it is

1297

///     // skipped as it was handled as part of the preceding character.

1298

///     let mut chars_iter = text.chars().peekable();

1299

///     let mut glyphs = Vec::new();

1300

///     while let Some(ch) = chars_iter.next() {

1301

///         match VariationSelector::try_from(ch) {

1302

///             Ok(_) => {} // filter out variation selectors

1303

///             Err(()) => {

1304

///                 let vs = chars_iter

1305

///                     .peek()

1306

///                     .and_then(|&next| VariationSelector::try_from(next).ok());

1307

///                 let (glyph_index, used_variation) = font.lookup_glyph_index(

1308

///                     ch,

1309

///                     MatchingPresentation::NotRequired,

1310

///                     vs,

1311

///                 );

1312

///                 let glyph = RawGlyph {

1313

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

1314

///                     glyph_index: glyph_index,

1315

///                     liga_component_pos: 0,

1316

///                     glyph_origin: GlyphOrigin::Char(ch),

1317

///                     flags: RawGlyphFlags::empty(),

1318

///                     extra_data: (),

1319

///                     variation: Some(used_variation),

1320

///                 };

1321

///                 glyphs.push(glyph);

1322

///             }

1323

///         }

1324

///     }

1325

///

1326

///     let (dotted_circle_index, _) = font.lookup_glyph_index(

1327

///         DOTTED_CIRCLE,

1328

///         MatchingPresentation::NotRequired,

1329

///         None,

1330

///     );

1331

///

1332

///     // If the font was a variable font you would want to supply the variation tuple

1333

///     let tuple = None;

1334

///

1335

///     // Apply gsub if table is present

1336

///     let num_glyphs = font.num_glyphs();

1337

///     if let Some(gsub_cache) = opt_gsub_cache {

1338

///         gsub::apply(

1339

///             dotted_circle_index,

1340

///             &gsub_cache,

1341

///             opt_gdef_table,

1342

///             script,

1343

///             Some(lang),

1344

///             FeatureMask::default_mask(),

1345

///             &[],

1346

///             tuple,

1347

///             num_glyphs,

1348

///             &mut glyphs,

1349

///         )?;

1350

///     }

1351

///

1352

///     // This is where you would apply `gpos` if the table is present.

1353

///

1354

///     Ok(glyphs)

1355

/// }

1356

///

1357

/// match shape("This is the first example.") {

1358

///     Ok(glyphs) => {

1359

///         assert!(!glyphs.is_empty());

1360

///     }

1361

///     Err(err) => panic!("Unable to shape text: {}", err),

1362

/// }

1363

/// ```

1364

24624

pub fn apply(

1365

24624

    dotted_circle_index: u16,

1366

24624

    gsub_cache: &LayoutCache<GSUB>,

1367

24624

    opt_gdef_table: Option<&GDEFTable>,

1368

24624

    script_tag: u32,

1369

24624

    opt_lang_tag: Option<u32>,

1370

24624

    mut feature_mask: FeatureMask,

1371

24624

    custom_features: &[FeatureInfo],

1372

24624

    tuple: Option<Tuple<'_>>,

1373

24624

    num_glyphs: u16,

1374

24624

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

1375

24624

) -> Result<(), ShapingError> {

1376

24624

    let max_glyphs = glyphs.len().saturating_mul(MAX_GLYPHS_FACTOR);

1377

24624

    let gsub_table = &gsub_cache.layout_table;

1378

24624

    let feature_variations = gsub_table.feature_variations(tuple)?;

1379

24624

    let feature_variations = feature_variations.as_ref();

1380

1381

    // Apply rvrn early if font is variable:

1382

//

1383

    // "The 'rvrn' feature is mandatory: it should be active by default and not directly exposed to

1384

    // user control."

1385

//

1386

    // "It should be processed early in GSUB processing, before application of the localized forms

1387

    // feature or features related to shaping of complex scripts or discretionary typographic

1388

    // effects."

1389

//

1390

    // https://learn.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-rvrn

1391

24624

    if tuple.is_some() {

1392

        apply_rvrn(

1393

            gsub_cache,

1394

            opt_gdef_table,

1395

            script_tag,

1396

            opt_lang_tag,

1397

            feature_variations,

1398

            glyphs,

1399

            max_glyphs,

1400

)?;

1401

24624

1402

1403

    // Extract optional features requested by the user for script shapers.

1404

24624

    let extra_features = feature_mask & (Feature::DLIG | Feature::HLIG | Feature::HIST);

1405

1406

24624

    match ScriptType::from(script_tag) {

1407

        ScriptType::Arabic => scripts::arabic::gsub_apply_arabic(

1408

            gsub_cache,

1409

            gsub_table,

1410

            opt_gdef_table,

1411

            script_tag,

1412

            opt_lang_tag,

1413

            feature_variations,

1414

            extra_features,

1415

            glyphs,

1416

            max_glyphs,

1417

)?,

1418

        ScriptType::Indic => scripts::indic::gsub_apply_indic(

1419

            dotted_circle_index,

1420

            gsub_cache,

1421

            gsub_table,

1422

            opt_gdef_table,

1423

            script_tag,

1424

            opt_lang_tag,

1425

            feature_variations,

1426

            extra_features,

1427

            glyphs,

1428

)?,

1429

        ScriptType::Khmer => scripts::khmer::gsub_apply_khmer(

1430

            dotted_circle_index,

1431

            gsub_cache,

1432

            gsub_table,

1433

            opt_gdef_table,

1434

            script_tag,

1435

            opt_lang_tag,

1436

            feature_variations,

1437

            extra_features,

1438

            glyphs,

1439

)?,

1440

        ScriptType::Mongolian => scripts::mongolian::gsub_apply_mongolian(

1441

            gsub_cache,

1442

            gsub_table,

1443

            opt_gdef_table,

1444

            script_tag,

1445

            opt_lang_tag,

1446

            feature_variations,

1447

            extra_features,

1448

            glyphs,

1449

            max_glyphs,

1450

)?,

1451

        ScriptType::Myanmar => scripts::myanmar::gsub_apply_myanmar(

1452

            dotted_circle_index,

1453

            gsub_cache,

1454

            gsub_table,

1455

            opt_gdef_table,

1456

            opt_lang_tag,

1457

            feature_variations,

1458

            extra_features,

1459

            glyphs,

1460

)?,

1461

        ScriptType::Syriac => scripts::syriac::gsub_apply_syriac(

1462

            gsub_cache,

1463

            gsub_table,

1464

            opt_gdef_table,

1465

            script_tag,

1466

            opt_lang_tag,

1467

            feature_variations,

1468

            extra_features,

1469

            glyphs,

1470

            max_glyphs,

1471

)?,

1472

        ScriptType::Tibetan => scripts::tibetan::gsub_apply_tibetan(

1473

            gsub_cache,

1474

            gsub_table,

1475

            opt_gdef_table,

1476

            script_tag,

1477

            opt_lang_tag,

1478

            feature_variations,

1479

            extra_features,

1480

            glyphs,

1481

            max_glyphs,

1482

)?,

1483

        ScriptType::ThaiLao => scripts::thai_lao::gsub_apply_thai_lao(

1484

            gsub_cache,

1485

            gsub_table,

1486

            opt_gdef_table,

1487

            script_tag,

1488

            opt_lang_tag,

1489

            feature_variations,

1490

            extra_features,

1491

            glyphs,

1492

            max_glyphs,

1493

)?,

1494

        ScriptType::Default => {

1495

24624

            feature_mask |= Feature::CCMP | Feature::RLIG | Feature::LOCL;

1496

24624

            feature_mask &= get_supported_features(gsub_cache, script_tag, opt_lang_tag)?;

1497

24624

            if feature_mask.contains(Feature::FRAC) {

1498

                let index_frac = get_lookups_cache_index(

1499

                    gsub_cache,

1500

                    script_tag,

1501

                    opt_lang_tag,

1502

                    feature_variations,

1503

                    feature_mask,

1504

)?;

1505

                feature_mask.remove(Feature::FRAC);

1506

                let index = get_lookups_cache_index(

1507

                    gsub_cache,

1508

                    script_tag,

1509

                    opt_lang_tag,

1510

                    feature_variations,

1511

                    feature_mask,

1512

)?;

1513

                let cached_lookups = gsub_cache.cached_lookups.lock().unwrap();

1514

                let lookups = &cached_lookups[index];

1515

                let lookups_frac = &cached_lookups[index_frac];

1516

                gsub_apply_lookups_frac(

1517

                    gsub_cache,

1518

                    gsub_table,

1519

                    opt_gdef_table,

1520

                    lookups,

1521

                    lookups_frac,

1522

                    glyphs,

1523

                    max_glyphs,

1524

)?;

1525

            } else {

1526

24624

                let index = get_lookups_cache_index(

1527

24624

                    gsub_cache,

1528

24624

                    script_tag,

1529

24624

                    opt_lang_tag,

1530

24624

                    feature_variations,

1531

24624

                    feature_mask,

1532

)?;

1533

24624

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

1534

24624

                gsub_apply_lookups(

1535

24624

                    gsub_cache,

1536

24624

                    gsub_table,

1537

24624

                    opt_gdef_table,

1538

24624

                    lookups,

1539

24624

                    glyphs,

1540

24624

                    max_glyphs,

1541

)?;

1542

1543

1544

1545

1546

    // Apply custom features (font-variant-alternates) after script-specific

1547

    // shaping but before cleanup.

1548

24624

    gsub_apply_custom_features(

1549

24624

        gsub_cache,

1550

24624

        gsub_table,

1551

24624

        opt_gdef_table,

1552

24624

        script_tag,

1553

24624

        opt_lang_tag,

1554

24624

        feature_variations,

1555

24624

        feature_mask,

1556

24624

        custom_features,

1557

24624

        glyphs,

1558

24624

        max_glyphs,

1559

)?;

1560

1561

24624

    strip_joiners(glyphs);

1562

24624

    replace_missing_glyphs(glyphs, num_glyphs);

1563

24624

    Ok(())

1564

24624

1565

1566

24624

fn gsub_apply_custom_features(

1567

24624

    gsub_cache: &LayoutCache<GSUB>,

1568

24624

    gsub_table: &LayoutTable<GSUB>,

1569

24624

    opt_gdef_table: Option<&GDEFTable>,

1570

24624

    script_tag: u32,

1571

24624

    opt_lang_tag: Option<u32>,

1572

24624

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

1573

24624

    feature_mask: FeatureMask,

1574

24624

    custom_features: &[FeatureInfo],

1575

24624

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

1576

24624

    max_glyphs: usize,

1577

24624

) -> Result<(), ShapingError> {

1578

24624

    if custom_features.is_empty() {

1579

24624

        return Ok(());

1580

1581

    // Resolve the script table. For Indic scripts, the shaper uses the v2

1582

    // tag (dev2, bng2, etc.) so we must look up features there too.

1583

    let script_table = match ScriptType::from(script_tag) {

1584

        ScriptType::Indic => {

1585

            let indic2 = scripts::indic::indic2_tag(script_tag);

1586

            match gsub_table.find_script(indic2)? {

1587

                Some(table) => Some(table),

1588

                None => gsub_table.find_script_or_default(script_tag)?,

1589

1590

1591

        _ => gsub_table.find_script_or_default(script_tag)?,

1592

};

1593

    if let Some(script) = script_table {

1594

        if let Some(langsys) = script.find_langsys_or_default(opt_lang_tag)? {

1595

            let lookups = build_lookups_custom(

1596

                gsub_table,

1597

                langsys,

1598

                custom_features,

1599

                feature_mask,

1600

                feature_variations,

1601

)?;

1602

            for (lookup_index, feature_tag) in lookups {

1603

                let alternate = find_alternate(custom_features, feature_tag);

1604

                gsub_apply_lookup(

1605

                    gsub_cache,

1606

                    gsub_table,

1607

                    opt_gdef_table,

1608

                    lookup_index,

1609

                    feature_tag,

1610

                    alternate,

1611

                    glyphs,

1612

                    max_glyphs,

1613

0,

1614

                    glyphs.len(),

1615

                    |_| true,

1616

)?;

1617

1618

1619

1620

    Ok(())

1621

24624

1622

1623

24624

fn gsub_apply_lookups(

1624

24624

    gsub_cache: &LayoutCache<GSUB>,

1625

24624

    gsub_table: &LayoutTable<GSUB>,

1626

24624

    opt_gdef_table: Option<&GDEFTable>,

1627

24624

    lookups: &[(usize, u32)],

1628

24624

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

1629

24624

    max_glyphs: usize,

1630

24624

) -> Result<(), ShapingError> {

1631

24624

    gsub_apply_lookups_impl(

1632

24624

        gsub_cache,

1633

24624

        gsub_table,

1634

24624

        opt_gdef_table,

1635

24624

        lookups,

1636

24624

        glyphs,

1637

24624

        max_glyphs,

1638

0,

1639

24624

        glyphs.len(),

1640

)?;

1641

24624

    Ok(())

1642

24624

1643

1644

24624

fn gsub_apply_lookups_impl(

1645

24624

    gsub_cache: &LayoutCache<GSUB>,

1646

24624

    gsub_table: &LayoutTable<GSUB>,

1647

24624

    opt_gdef_table: Option<&GDEFTable>,

1648

24624

    lookups: &[(usize, u32)],

1649

24624

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

1650

24624

    max_glyphs: usize,

1651

24624

    start: usize,

1652

24624

    mut length: usize,

1653

24624

) -> Result<usize, ShapingError> {

1654

199746

    for (lookup_index, feature_tag) in lookups {

1655

175122

        length = gsub_apply_lookup(

1656

175122

            gsub_cache,

1657

175122

            gsub_table,

1658

175122

            opt_gdef_table,

1659

175122

            *lookup_index,

1660

175122

            *feature_tag,

1661

175122

            None,

1662

175122

            glyphs,

1663

175122

            max_glyphs,

1664

175122

            start,

1665

175122

            length,

1666

            |_| true,

1667

)?;

1668

1669

24624

    Ok(length)

1670

24624

1671

1672

fn gsub_apply_lookups_frac(

1673

    gsub_cache: &LayoutCache<GSUB>,

1674

    gsub_table: &LayoutTable<GSUB>,

1675

    opt_gdef_table: Option<&GDEFTable>,

1676

    lookups: &[(usize, u32)],

1677

    lookups_frac: &[(usize, u32)],

1678

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

1679

    max_glyphs: usize,

1680

) -> Result<(), ShapingError> {

1681

    let mut i = 0;

1682

    while i < glyphs.len() {

1683

        if let Some((start_pos, _slash_pos, end_pos)) = find_fraction(&glyphs[i..]) {

1684

            if start_pos > 0 {

1685

                i += gsub_apply_lookups_impl(

1686

                    gsub_cache,

1687

                    gsub_table,

1688

                    opt_gdef_table,

1689

                    lookups,

1690

                    glyphs,

1691

                    max_glyphs,

1692

i,

1693

                    start_pos,

1694

)?;

1695

1696

            i += gsub_apply_lookups_impl(

1697

                gsub_cache,

1698

                gsub_table,

1699

                opt_gdef_table,

1700

                lookups_frac,

1701

                glyphs,

1702

                max_glyphs,

1703

i,

1704

                end_pos - start_pos + 1,

1705

)?;

1706

        } else {

1707

            gsub_apply_lookups_impl(

1708

                gsub_cache,

1709

                gsub_table,

1710

                opt_gdef_table,

1711

                lookups,

1712

                glyphs,

1713

                max_glyphs,

1714

i,

1715

                glyphs.len() - i,

1716

)?;

1717

            break;

1718

1719

1720

    Ok(())

1721

1722

1723

fn find_fraction(glyphs: &[RawGlyph<()>]) -> Option<(usize, usize, usize)> {

1724

    let slash_pos = glyphs

1725

        .iter()

1726

        .position(|g| g.glyph_origin == GlyphOrigin::Char('/'))?;

1727

    let mut start_pos = slash_pos;

1728

    while start_pos > 0 {

1729

        match glyphs[start_pos - 1].glyph_origin {

1730

            GlyphOrigin::Char(c) if c.is_ascii_digit() => {

1731

                start_pos -= 1;

1732

1733

            _ => break,

1734

1735

1736

    let mut end_pos = slash_pos;

1737

    while end_pos + 1 < glyphs.len() {

1738

        match glyphs[end_pos + 1].glyph_origin {

1739

            GlyphOrigin::Char(c) if c.is_ascii_digit() => {

1740

                end_pos += 1;

1741

1742

            _ => break,

1743

1744

1745

    if start_pos < slash_pos && slash_pos < end_pos {

1746

        Some((start_pos, slash_pos, end_pos))

1747

    } else {

1748

        None

1749

1750

1751

1752

fn apply_rvrn(

1753

    gsub_cache: &LayoutCache<GSUB>,

1754

    opt_gdef_table: Option<&GDEFTable>,

1755

    script_tag: u32,

1756

    opt_lang_tag: Option<u32>,

1757

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

1758

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

1759

    max_glyphs: usize,

1760

) -> Result<(), ShapingError> {

1761

    let gsub_table = &gsub_cache.layout_table;

1762

    let index = get_lookups_cache_index(

1763

        gsub_cache,

1764

        script_tag,

1765

        opt_lang_tag,

1766

        feature_variations,

1767

        Feature::RVRN.mask(),

1768

)?;

1769

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

1770

    gsub_apply_lookups(

1771

        gsub_cache,

1772

        gsub_table,

1773

        opt_gdef_table,

1774

        lookups,

1775

        glyphs,

1776

        max_glyphs,

1777

)?;

1778

    Ok(())

1779

1780

1781

#[cfg(test)]

1782

mod tests {

1783

    use super::*;

1784

    use crate::{

1785

        binary::read::ReadScope, font::MatchingPresentation, font_data::FontData,

1786

        tests::read_fixture, Font,

1787

};

1788

1789

    #[test]

1790

    fn feature_mask_iter() {

1791

        let mask = FeatureMask::empty();

1792

        assert_eq!(mask.features().count(), 0);

1793

1794

        let mask = FeatureMask::default_mask();

1795

        let expected = &[

1796

            FeatureInfo {

1797

                feature_tag: tag::CALT,

1798

                alternate: None,

1799

},

1800

            FeatureInfo {

1801

                feature_tag: tag::CCMP,

1802

                alternate: None,

1803

},

1804

            FeatureInfo {

1805

                feature_tag: tag::CLIG,

1806

                alternate: None,

1807

},

1808

            FeatureInfo {

1809

                feature_tag: tag::LIGA,

1810

                alternate: None,

1811

},

1812

            FeatureInfo {

1813

                feature_tag: tag::LOCL,

1814

                alternate: None,

1815

},

1816

            FeatureInfo {

1817

                feature_tag: tag::RLIG,

1818

                alternate: None,

1819

},

1820

];

1821

        assert_eq!(&mask.features().collect::<Vec<_>>(), expected);

1822

1823

1824

    /// Verify that Feature::tag and Feature::from_tag stay in sync.

1825

///

1826

    /// Every Feature variant must round-trip through tag/from_tag.

1827

    #[test]

1828

    fn feature_from_tag_in_sync() {

1829

        // Check that every Feature variant round-trips through tag/from_tag.

1830

        for feature in FeatureMask::all() {

1831

            let tag = feature.tag();

1832

            let back = Feature::from_tag(tag);

1833

            assert!(

1834

                back == Some(feature),

1835

                "from_tag(tag({:?})) = {:?}, expected Some({:?})",

1836

                feature,

1837

                back,

1838

                feature,

1839

);

1840

1841

1842

1843

    #[test]

1844

    fn billion_laughs() -> Result<(), Box<dyn std::error::Error>> {

1845

        let data = read_fixture("tests/fonts/opentype/TestGSUBThree.ttf");

1846

        let scope = ReadScope::new(&data);

1847

        let font_file = scope.read::<FontData<'_>>()?;

1848

        let provider = font_file.table_provider(0)?;

1849

        let mut font = Font::new(provider)?;

1850

1851

        // Map text to glyphs and then apply font shaping

1852

        let script = tag::LATN;

1853

        let lang = tag!(b"ENG ");

1854

        let glyphs = font.map_glyphs("lol", script, MatchingPresentation::NotRequired);

1855

        let infos = font

1856

            .shape(

1857

                glyphs,

1858

                script,

1859

                Some(lang),

1860

                FeatureMask::default_mask(),

1861

                &[],

1862

                None,

1863

                true,

1864

1865

            .map_err(|(err, _info)| err)?;

1866

1867

        assert_eq!(infos.len(), 759);

1868

1869

        Ok(())

1870

1871