summaryrefslogtreecommitdiffstats
path: root/layout/generic/MathMLTextRunFactory.cpp
blob: b96aa921b143f30e5817a384c6fdcbc9e3d8d9e7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MathMLTextRunFactory.h"

#include "mozilla/ArrayUtils.h"
#include "mozilla/BinarySearch.h"

#include "nsStyleConsts.h"
#include "nsTextFrameUtils.h"
#include "nsFontMetrics.h"
#include "nsDeviceContext.h"
#include "nsUnicodeScriptCodes.h"

using namespace mozilla;

/*
  Entries for the mathvariant lookup tables.  mKey represents the Unicode
  character to be transformed and is used for searching the tables.
  mReplacement represents the mapped mathvariant Unicode character.
*/
typedef struct
{
  uint32_t mKey;
  uint32_t mReplacement;
} MathVarMapping;

/*
 Lookup tables for use with mathvariant mappings to transform a unicode
 character point to another unicode character that indicates the proper output.
 mKey represents one of two concepts.
 1.  In the Latin table it represents a hole in the mathematical alphanumeric
     block, where the character that should occupy that position is located
     elsewhere.
 2.  It represents an Arabic letter.

  As a replacement, 0 is reserved to indicate no mapping was found.
*/
static const MathVarMapping gArabicInitialMapTable[] = {
  { 0x628, 0x1EE21 },
  { 0x62A, 0x1EE35 },
  { 0x62B, 0x1EE36 },
  { 0x62C, 0x1EE22 },
  { 0x62D, 0x1EE27 },
  { 0x62E, 0x1EE37 },
  { 0x633, 0x1EE2E },
  { 0x634, 0x1EE34 },
  { 0x635, 0x1EE31 },
  { 0x636, 0x1EE39 },
  { 0x639, 0x1EE2F },
  { 0x63A, 0x1EE3B },
  { 0x641, 0x1EE30 },
  { 0x642, 0x1EE32 },
  { 0x643, 0x1EE2A },
  { 0x644, 0x1EE2B },
  { 0x645, 0x1EE2C },
  { 0x646, 0x1EE2D },
  { 0x647, 0x1EE24 },
  { 0x64A, 0x1EE29 }
};

static const MathVarMapping gArabicTailedMapTable[] = {
  { 0x62C, 0x1EE42 },
  { 0x62D, 0x1EE47 },
  { 0x62E, 0x1EE57 },
  { 0x633, 0x1EE4E },
  { 0x634, 0x1EE54 },
  { 0x635, 0x1EE51 },
  { 0x636, 0x1EE59 },
  { 0x639, 0x1EE4F },
  { 0x63A, 0x1EE5B },
  { 0x642, 0x1EE52 },
  { 0x644, 0x1EE4B },
  { 0x646, 0x1EE4D },
  { 0x64A, 0x1EE49 },
  { 0x66F, 0x1EE5F },
  { 0x6BA, 0x1EE5D }
};

static const MathVarMapping gArabicStretchedMapTable[] = {
  { 0x628, 0x1EE61 },
  { 0x62A, 0x1EE75 },
  { 0x62B, 0x1EE76 },
  { 0x62C, 0x1EE62 },
  { 0x62D, 0x1EE67 },
  { 0x62E, 0x1EE77 },
  { 0x633, 0x1EE6E },
  { 0x634, 0x1EE74 },
  { 0x635, 0x1EE71 },
  { 0x636, 0x1EE79 },
  { 0x637, 0x1EE68 },
  { 0x638, 0x1EE7A },
  { 0x639, 0x1EE6F },
  { 0x63A, 0x1EE7B },
  { 0x641, 0x1EE70 },
  { 0x642, 0x1EE72 },
  { 0x643, 0x1EE6A },
  { 0x645, 0x1EE6C },
  { 0x646, 0x1EE6D },
  { 0x647, 0x1EE64 },
  { 0x64A, 0x1EE69 },
  { 0x66E, 0x1EE7C },
  { 0x6A1, 0x1EE7E }
};

static const MathVarMapping gArabicLoopedMapTable[] = {
  { 0x627, 0x1EE80 },
  { 0x628, 0x1EE81 },
  { 0x62A, 0x1EE95 },
  { 0x62B, 0x1EE96 },
  { 0x62C, 0x1EE82 },
  { 0x62D, 0x1EE87 },
  { 0x62E, 0x1EE97 },
  { 0x62F, 0x1EE83 },
  { 0x630, 0x1EE98 },
  { 0x631, 0x1EE93 },
  { 0x632, 0x1EE86 },
  { 0x633, 0x1EE8E },
  { 0x634, 0x1EE94 },
  { 0x635, 0x1EE91 },
  { 0x636, 0x1EE99 },
  { 0x637, 0x1EE88 },
  { 0x638, 0x1EE9A },
  { 0x639, 0x1EE8F },
  { 0x63A, 0x1EE9B },
  { 0x641, 0x1EE90 },
  { 0x642, 0x1EE92 },
  { 0x644, 0x1EE8B },
  { 0x645, 0x1EE8C },
  { 0x646, 0x1EE8D },
  { 0x647, 0x1EE84 },
  { 0x648, 0x1EE85 },
  { 0x64A, 0x1EE89 }
};

static const MathVarMapping gArabicDoubleMapTable[] = {
  { 0x628, 0x1EEA1 },
  { 0x62A, 0x1EEB5 },
  { 0x62B, 0x1EEB6 },
  { 0x62C, 0x1EEA2 },
  { 0x62D, 0x1EEA7 },
  { 0x62E, 0x1EEB7 },
  { 0x62F, 0x1EEA3 },
  { 0x630, 0x1EEB8 },
  { 0x631, 0x1EEB3 },
  { 0x632, 0x1EEA6 },
  { 0x633, 0x1EEAE },
  { 0x634, 0x1EEB4 },
  { 0x635, 0x1EEB1 },
  { 0x636, 0x1EEB9 },
  { 0x637, 0x1EEA8 },
  { 0x638, 0x1EEBA },
  { 0x639, 0x1EEAF },
  { 0x63A, 0x1EEBB },
  { 0x641, 0x1EEB0 },
  { 0x642, 0x1EEB2 },
  { 0x644, 0x1EEAB },
  { 0x645, 0x1EEAC },
  { 0x646, 0x1EEAD },
  { 0x648, 0x1EEA5 },
  { 0x64A, 0x1EEA9 }
};

static const MathVarMapping gLatinExceptionMapTable[] = {
  { 0x1D455, 0x210E },
  { 0x1D49D, 0x212C },
  { 0x1D4A0, 0x2130 },
  { 0x1D4A1, 0x2131 },
  { 0x1D4A3, 0x210B },
  { 0x1D4A4, 0x2110 },
  { 0x1D4A7, 0x2112 },
  { 0x1D4A8, 0x2133 },
  { 0x1D4AD, 0x211B },
  { 0x1D4BA, 0x212F },
  { 0x1D4BC, 0x210A },
  { 0x1D4C4, 0x2134 },
  { 0x1D506, 0x212D },
  { 0x1D50B, 0x210C },
  { 0x1D50C, 0x2111 },
  { 0x1D515, 0x211C },
  { 0x1D51D, 0x2128 },
  { 0x1D53A, 0x2102 },
  { 0x1D53F, 0x210D },
  { 0x1D545, 0x2115 },
  { 0x1D547, 0x2119 },
  { 0x1D548, 0x211A },
  { 0x1D549, 0x211D },
  { 0x1D551, 0x2124 }
};

namespace {

struct MathVarMappingWrapper
{
  const MathVarMapping* const mTable;
  explicit MathVarMappingWrapper(const MathVarMapping* aTable) : mTable(aTable) {}
  uint32_t operator[](size_t index) const {
    return mTable[index].mKey;
  }
};

} // namespace

// Finds a MathVarMapping struct with the specified key (aKey) within aTable.
// aTable must be an array, whose length is specified by aNumElements
static uint32_t
MathvarMappingSearch(uint32_t aKey, const MathVarMapping* aTable, uint32_t aNumElements)
{
  size_t index;
  if (BinarySearch(MathVarMappingWrapper(aTable), 0, aNumElements, aKey, &index)) {
    return aTable[index].mReplacement;
  }

  return 0;
}

#define GREEK_UPPER_THETA               0x03F4
#define HOLE_GREEK_UPPER_THETA          0x03A2
#define NABLA                           0x2207
#define PARTIAL_DIFFERENTIAL            0x2202
#define GREEK_UPPER_ALPHA               0x0391
#define GREEK_UPPER_OMEGA               0x03A9
#define GREEK_LOWER_ALPHA               0x03B1
#define GREEK_LOWER_OMEGA               0x03C9
#define GREEK_LUNATE_EPSILON_SYMBOL     0x03F5
#define GREEK_THETA_SYMBOL              0x03D1
#define GREEK_KAPPA_SYMBOL              0x03F0
#define GREEK_PHI_SYMBOL                0x03D5
#define GREEK_RHO_SYMBOL                0x03F1
#define GREEK_PI_SYMBOL                 0x03D6
#define GREEK_LETTER_DIGAMMA            0x03DC
#define GREEK_SMALL_LETTER_DIGAMMA      0x03DD
#define MATH_BOLD_CAPITAL_DIGAMMA       0x1D7CA
#define MATH_BOLD_SMALL_DIGAMMA         0x1D7CB

#define LATIN_SMALL_LETTER_DOTLESS_I    0x0131
#define LATIN_SMALL_LETTER_DOTLESS_J    0x0237

#define MATH_ITALIC_SMALL_DOTLESS_I     0x1D6A4
#define MATH_ITALIC_SMALL_DOTLESS_J     0x1D6A5

#define MATH_BOLD_UPPER_A               0x1D400
#define MATH_ITALIC_UPPER_A             0x1D434
#define MATH_BOLD_SMALL_A               0x1D41A
#define MATH_BOLD_UPPER_ALPHA           0x1D6A8
#define MATH_BOLD_SMALL_ALPHA           0x1D6C2
#define MATH_ITALIC_UPPER_ALPHA         0x1D6E2
#define MATH_BOLD_DIGIT_ZERO            0x1D7CE
#define MATH_DOUBLE_STRUCK_ZERO         0x1D7D8

#define MATH_BOLD_UPPER_THETA           0x1D6B9
#define MATH_BOLD_NABLA                 0x1D6C1
#define MATH_BOLD_PARTIAL_DIFFERENTIAL  0x1D6DB
#define MATH_BOLD_EPSILON_SYMBOL        0x1D6DC
#define MATH_BOLD_THETA_SYMBOL          0x1D6DD
#define MATH_BOLD_KAPPA_SYMBOL          0x1D6DE
#define MATH_BOLD_PHI_SYMBOL            0x1D6DF
#define MATH_BOLD_RHO_SYMBOL            0x1D6E0
#define MATH_BOLD_PI_SYMBOL             0x1D6E1

/*
  Performs the character mapping needed to implement MathML's mathvariant
  attribute.  It takes a unicode character and maps it to its appropriate
  mathvariant counterpart specified by aMathVar.  The mapped character is
  typically located within Unicode's mathematical blocks (0x1D***, 0x1EE**) but
  there are exceptions which this function accounts for.
  Characters without a valid mapping or valid aMathvar value are returned
  unaltered.  Characters already in the mathematical blocks (or are one of the
  exceptions) are never transformed.
  Acceptable values for aMathVar are specified in layout/style/nsStyleConsts.h.
  The transformable characters can be found at:
  http://lists.w3.org/Archives/Public/www-math/2013Sep/0012.html and
  https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols
*/
static uint32_t
MathVariant(uint32_t aCh, uint8_t aMathVar)
{
  uint32_t baseChar;
  enum CharacterType {
    kIsLatin,
    kIsGreekish,
    kIsNumber,
    kIsArabic,
  };
  CharacterType varType;

  int8_t multiplier;

  if (aMathVar <= NS_MATHML_MATHVARIANT_NORMAL) {
    // nothing to do here
    return aCh;
  }
  if (aMathVar > NS_MATHML_MATHVARIANT_STRETCHED) {
    NS_ASSERTION(false, "Illegal mathvariant value");
    return aCh;
  }

  // Exceptional characters with at most one possible transformation
  if (aCh == HOLE_GREEK_UPPER_THETA) {
    // Nothing at this code point is transformed
    return aCh;
  }
  if (aCh == GREEK_LETTER_DIGAMMA) {
    if (aMathVar == NS_MATHML_MATHVARIANT_BOLD) {
      return MATH_BOLD_CAPITAL_DIGAMMA;
    }
    return aCh;
  }
  if (aCh == GREEK_SMALL_LETTER_DIGAMMA) {
    if (aMathVar == NS_MATHML_MATHVARIANT_BOLD) {
      return MATH_BOLD_SMALL_DIGAMMA;
    }
    return aCh;
  }
  if (aCh == LATIN_SMALL_LETTER_DOTLESS_I) {
    if (aMathVar == NS_MATHML_MATHVARIANT_ITALIC) {
      return MATH_ITALIC_SMALL_DOTLESS_I;
    }
    return aCh;
  }
  if (aCh == LATIN_SMALL_LETTER_DOTLESS_J) {
    if (aMathVar == NS_MATHML_MATHVARIANT_ITALIC) {
      return MATH_ITALIC_SMALL_DOTLESS_J;
    }
    return aCh;
  }

  // The Unicode mathematical blocks are divided into four segments: Latin,
  // Greek, numbers and Arabic.  In the case of the first three
  // baseChar represents the relative order in which the characters are
  // encoded in the Unicode mathematical block, normalised to the first
  // character of that sequence.
  //
  if ('A' <= aCh && aCh <= 'Z') {
    baseChar = aCh - 'A';
    varType = kIsLatin;
  } else if ('a' <= aCh && aCh <= 'z') {
    // Lowercase characters are placed immediately after the uppercase
    // characters in the Unicode mathematical block.  The constant subtraction
    // represents the number of characters between the start of the sequence
    // (capital A) and the first lowercase letter.
    baseChar = MATH_BOLD_SMALL_A-MATH_BOLD_UPPER_A + aCh - 'a';
    varType = kIsLatin;
  } else if ('0' <= aCh && aCh <= '9') {
    baseChar = aCh - '0';
    varType = kIsNumber;
  } else if (GREEK_UPPER_ALPHA <= aCh && aCh <= GREEK_UPPER_OMEGA) {
    baseChar = aCh-GREEK_UPPER_ALPHA;
    varType = kIsGreekish;
  } else if (GREEK_LOWER_ALPHA <= aCh && aCh <= GREEK_LOWER_OMEGA) {
    // Lowercase Greek comes after uppercase Greek.
    // Note in this instance the presence of an additional character (Nabla)
    // between the end of the uppercase Greek characters and the lowercase
    // ones.
    baseChar =  MATH_BOLD_SMALL_ALPHA - MATH_BOLD_UPPER_ALPHA
                + aCh-GREEK_LOWER_ALPHA;
    varType = kIsGreekish;
  } else if (0x0600 <= aCh && aCh <= 0x06FF) {
    // Arabic characters are defined within this range
    varType = kIsArabic;
  } else {
    switch (aCh) {
      case GREEK_UPPER_THETA:
        baseChar = MATH_BOLD_UPPER_THETA-MATH_BOLD_UPPER_ALPHA;
        break;
      case NABLA:
        baseChar = MATH_BOLD_NABLA-MATH_BOLD_UPPER_ALPHA;
        break;
      case PARTIAL_DIFFERENTIAL:
        baseChar = MATH_BOLD_PARTIAL_DIFFERENTIAL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_LUNATE_EPSILON_SYMBOL:
        baseChar = MATH_BOLD_EPSILON_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_THETA_SYMBOL:
        baseChar = MATH_BOLD_THETA_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_KAPPA_SYMBOL:
        baseChar = MATH_BOLD_KAPPA_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_PHI_SYMBOL:
        baseChar = MATH_BOLD_PHI_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_RHO_SYMBOL:
        baseChar = MATH_BOLD_RHO_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      case GREEK_PI_SYMBOL:
        baseChar = MATH_BOLD_PI_SYMBOL - MATH_BOLD_UPPER_ALPHA;
        break;
      default:
        return aCh;
    }

    varType = kIsGreekish;
  }

  if (varType == kIsNumber) {
    switch (aMathVar) {
      // Each possible number mathvariant is encoded in a single, contiguous
      // block.  For example the beginning of the double struck number range
      // follows immediately after the end of the bold number range.
      // multiplier represents the order of the sequences relative to the first
      // one.
      case NS_MATHML_MATHVARIANT_BOLD:
        multiplier = 0;
        break;
      case NS_MATHML_MATHVARIANT_DOUBLE_STRUCK:
        multiplier = 1;
        break;
      case NS_MATHML_MATHVARIANT_SANS_SERIF:
        multiplier = 2;
        break;
      case NS_MATHML_MATHVARIANT_BOLD_SANS_SERIF:
        multiplier = 3;
        break;
      case NS_MATHML_MATHVARIANT_MONOSPACE:
        multiplier = 4;
        break;
      default:
        // This mathvariant isn't defined for numbers or is otherwise normal
        return aCh;
    }
    // As the ranges are contiguous, to find the desired mathvariant range it
    // is sufficient to multiply the position within the sequence order
    // (multiplier) with the period of the sequence (which is constant for all
    // number sequences) and to add the character point of the first character
    // within the number mathvariant range.
    // To this the baseChar calculated earlier is added to obtain the final
    // code point.
    return baseChar+multiplier*(MATH_DOUBLE_STRUCK_ZERO-MATH_BOLD_DIGIT_ZERO)
             +MATH_BOLD_DIGIT_ZERO;
  } else if (varType == kIsGreekish) {
    switch (aMathVar) {
      case NS_MATHML_MATHVARIANT_BOLD:
        multiplier = 0;
        break;
      case NS_MATHML_MATHVARIANT_ITALIC:
        multiplier = 1;
        break;
      case NS_MATHML_MATHVARIANT_BOLD_ITALIC:
        multiplier = 2;
        break;
      case NS_MATHML_MATHVARIANT_BOLD_SANS_SERIF:
        multiplier = 3;
        break;
      case NS_MATHML_MATHVARIANT_SANS_SERIF_BOLD_ITALIC:
        multiplier = 4;
        break;
      default:
        // This mathvariant isn't defined for Greek or is otherwise normal
        return aCh;
    }
    // See the kIsNumber case for an explanation of the following calculation
    return baseChar + MATH_BOLD_UPPER_ALPHA +
             multiplier*(MATH_ITALIC_UPPER_ALPHA - MATH_BOLD_UPPER_ALPHA);
  }

  uint32_t tempChar;
  uint32_t newChar;
  if (varType == kIsArabic) {
    const MathVarMapping* mapTable;
    uint32_t tableLength;
    switch (aMathVar) {
      /* The Arabic mathematical block is not continuous, nor does it have a
       * monotonic mapping to the unencoded characters, requiring the use of a
       * lookup table.
       */
      case NS_MATHML_MATHVARIANT_INITIAL:
        mapTable = gArabicInitialMapTable;
        tableLength = ArrayLength(gArabicInitialMapTable);
        break;
      case NS_MATHML_MATHVARIANT_TAILED:
        mapTable = gArabicTailedMapTable;
        tableLength = ArrayLength(gArabicTailedMapTable);
        break;
      case NS_MATHML_MATHVARIANT_STRETCHED:
        mapTable = gArabicStretchedMapTable;
        tableLength = ArrayLength(gArabicStretchedMapTable);
        break;
      case NS_MATHML_MATHVARIANT_LOOPED:
        mapTable = gArabicLoopedMapTable;
        tableLength = ArrayLength(gArabicLoopedMapTable);
        break;
      case NS_MATHML_MATHVARIANT_DOUBLE_STRUCK:
        mapTable = gArabicDoubleMapTable;
        tableLength = ArrayLength(gArabicDoubleMapTable);
        break;
      default:
        // No valid transformations exist
        return aCh;
    }
    newChar = MathvarMappingSearch(aCh, mapTable, tableLength);
  } else {
    // Must be Latin
    if (aMathVar > NS_MATHML_MATHVARIANT_MONOSPACE) {
      // Latin doesn't support the Arabic mathvariants
      return aCh;
    }
    multiplier = aMathVar - 2;
    // This is possible because the values for NS_MATHML_MATHVARIANT_* are
    // chosen to coincide with the order in which the encoded mathvariant
    // characters are located within their unicode block (less an offset to
    // avoid _NONE and _NORMAL variants)
    // See the kIsNumber case for an explanation of the following calculation
    tempChar =  baseChar + MATH_BOLD_UPPER_A +
                multiplier*(MATH_ITALIC_UPPER_A - MATH_BOLD_UPPER_A);
    // There are roughly twenty characters that are located outside of the
    // mathematical block, so the spaces where they ought to be are used
    // as keys for a lookup table containing the correct character mappings.
    newChar = MathvarMappingSearch(tempChar, gLatinExceptionMapTable,
                                   ArrayLength(gLatinExceptionMapTable));
  }

  if (newChar) {
    return newChar;
  } else if (varType == kIsLatin) {
    return tempChar;
  } else {
    // An Arabic character without a corresponding mapping
    return aCh;
  }

}

#define TT_SSTY TRUETYPE_TAG('s', 's', 't', 'y')
#define TT_DTLS TRUETYPE_TAG('d', 't', 'l', 's')

void
MathMLTextRunFactory::RebuildTextRun(nsTransformedTextRun* aTextRun,
                                     mozilla::gfx::DrawTarget* aRefDrawTarget,
                                     gfxMissingFontRecorder* aMFR)
{
  gfxFontGroup* fontGroup = aTextRun->GetFontGroup();

  nsAutoString convertedString;
  AutoTArray<bool,50> charsToMergeArray;
  AutoTArray<bool,50> deletedCharsArray;
  AutoTArray<RefPtr<nsTransformedCharStyle>,50> styleArray;
  AutoTArray<uint8_t,50> canBreakBeforeArray;
  bool mergeNeeded = false;

  bool singleCharMI =
    aTextRun->GetFlags() & nsTextFrameUtils::TEXT_IS_SINGLE_CHAR_MI;

  uint32_t length = aTextRun->GetLength();
  const char16_t* str = aTextRun->mString.BeginReading();
  const nsTArray<RefPtr<nsTransformedCharStyle>>& styles = aTextRun->mStyles;
  nsFont font;
  if (length) {
    font = styles[0]->mFont;

    if (mSSTYScriptLevel || (mFlags & MATH_FONT_FEATURE_DTLS)) {
      bool foundSSTY = false;
      bool foundDTLS = false;
      // We respect ssty settings explicitly set by the user
      for (uint32_t i = 0; i < font.fontFeatureSettings.Length(); i++) {
        if (font.fontFeatureSettings[i].mTag == TT_SSTY) {
          foundSSTY = true;
        } else if (font.fontFeatureSettings[i].mTag == TT_DTLS) {
          foundDTLS = true;
        }
      }
      if (mSSTYScriptLevel && !foundSSTY) {
        uint8_t sstyLevel = 0;
        float scriptScaling = pow(styles[0]->mScriptSizeMultiplier,
                                  mSSTYScriptLevel);
        static_assert(NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER < 1,
                      "Shouldn't it make things smaller?");
        /*
          An SSTY level of 2 is set if the scaling factor is less than or equal
          to halfway between that for a scriptlevel of 1 (0.71) and that of a
          scriptlevel of 2 (0.71^2), assuming the default script size multiplier.
          An SSTY level of 1 is set if the script scaling factor is less than
          or equal that for a scriptlevel of 1 assuming the default script size
          multiplier.

          User specified values of script size multiplier will change the scaling
          factor which mSSTYScriptLevel values correspond to.

          In the event that the script size multiplier actually makes things
          larger, no change is made.

          To opt out of this change, add the following to the stylesheet:
          "font-feature-settings: 'ssty' 0"
        */
        if (scriptScaling <= (NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER +
                              (NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER *
                               NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER))/2) {
          // Currently only the first two ssty settings are used, so two is large
          // as we go
          sstyLevel = 2;
        } else if (scriptScaling <= NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER) {
          sstyLevel = 1;
        }
        if (sstyLevel) {
          gfxFontFeature settingSSTY;
          settingSSTY.mTag = TT_SSTY;
          settingSSTY.mValue = sstyLevel;
          font.fontFeatureSettings.AppendElement(settingSSTY);
        }
      }
      /*
        Apply the dtls font feature setting (dotless).
        This gets applied to the base frame and all descendants of the base
        frame of certain <mover> and <munderover> frames.

        See nsMathMLmunderoverFrame.cpp for a full description.

        To opt out of this change, add the following to the stylesheet:
        "font-feature-settings: 'dtls' 0"
      */
      if ((mFlags & MATH_FONT_FEATURE_DTLS) && !foundDTLS) {
        gfxFontFeature settingDTLS;
        settingDTLS.mTag = TT_DTLS;
        settingDTLS.mValue = 1;
        font.fontFeatureSettings.AppendElement(settingDTLS);
      }
    }
  }

  uint8_t mathVar = NS_MATHML_MATHVARIANT_NONE;
  bool doMathvariantStyling = true;

  for (uint32_t i = 0; i < length; ++i) {
    int extraChars = 0;
    mathVar = styles[i]->mMathVariant;

    if (singleCharMI && mathVar == NS_MATHML_MATHVARIANT_NONE) {
      // If the user has explicitly set a non-default value for fontstyle or
      // fontweight, the italic mathvariant behaviour of <mi> is disabled
      // This overrides the initial values specified in fontStyle, to avoid
      // inconsistencies in which attributes allow CSS changes and which do not.
      if (mFlags & MATH_FONT_WEIGHT_BOLD) {
        font.weight = NS_FONT_WEIGHT_BOLD;
        if (mFlags & MATH_FONT_STYLING_NORMAL) {
          font.style = NS_FONT_STYLE_NORMAL;
        } else {
          font.style = NS_FONT_STYLE_ITALIC;
        }
      } else if (mFlags & MATH_FONT_STYLING_NORMAL) {
        font.style = NS_FONT_STYLE_NORMAL;
        font.weight = NS_FONT_WEIGHT_NORMAL;
      } else {
        mathVar = NS_MATHML_MATHVARIANT_ITALIC;
      }
    }

    uint32_t ch = str[i];
    if (NS_IS_HIGH_SURROGATE(ch) && i < length - 1 &&
        NS_IS_LOW_SURROGATE(str[i + 1])) {
      ch = SURROGATE_TO_UCS4(ch, str[i + 1]);
    }
    uint32_t ch2 = MathVariant(ch, mathVar);

    if (mathVar == NS_MATHML_MATHVARIANT_BOLD ||
        mathVar == NS_MATHML_MATHVARIANT_BOLD_ITALIC ||
        mathVar == NS_MATHML_MATHVARIANT_ITALIC) {
      if (ch == ch2  && ch != 0x20 && ch != 0xA0) {
        // Don't apply the CSS style if a character cannot be
        // transformed. There is an exception for whitespace as it is both
        // common and innocuous.
        doMathvariantStyling = false;
      }
      if (ch2 != ch) {
        // Bug 930504. Some platforms do not have fonts for Mathematical
        // Alphanumeric Symbols. Hence we check whether the transformed
        // character is actually available.
        uint8_t matchType;
        RefPtr<gfxFont> mathFont = fontGroup->
          FindFontForChar(ch2, 0, 0, unicode::Script::COMMON, nullptr, &matchType);
        if (mathFont) {
          // Don't apply the CSS style if there is a math font for at least one
          // of the transformed character in this text run.
          doMathvariantStyling = false;
        } else {
          // We fallback to the original character.
          ch2 = ch;
          if (aMFR) {
            aMFR->RecordScript(unicode::Script::MATHEMATICAL_NOTATION);
          }
        }
      }
    }

    deletedCharsArray.AppendElement(false);
    charsToMergeArray.AppendElement(false);
    styleArray.AppendElement(styles[i]);
    canBreakBeforeArray.AppendElement(aTextRun->CanBreakLineBefore(i));

    if (IS_IN_BMP(ch2)) {
      convertedString.Append(ch2);
    } else {
      convertedString.Append(H_SURROGATE(ch2));
      convertedString.Append(L_SURROGATE(ch2));
      ++extraChars;
      if (!IS_IN_BMP(ch)) {
        deletedCharsArray.AppendElement(true); // not exactly deleted, but
                                          // the trailing surrogate is skipped
        ++i;
      }
    }

    while (extraChars-- > 0) {
      mergeNeeded = true;
      charsToMergeArray.AppendElement(true);
      styleArray.AppendElement(styles[i]);
      canBreakBeforeArray.AppendElement(false);
    }
  }

  uint32_t flags;
  gfxTextRunFactory::Parameters innerParams =
      GetParametersForInner(aTextRun, &flags, aRefDrawTarget);

  RefPtr<nsTransformedTextRun> transformedChild;
  RefPtr<gfxTextRun> cachedChild;
  gfxTextRun* child;

  if (mathVar == NS_MATHML_MATHVARIANT_BOLD && doMathvariantStyling) {
    font.style = NS_FONT_STYLE_NORMAL;
    font.weight = NS_FONT_WEIGHT_BOLD;
  } else if (mathVar == NS_MATHML_MATHVARIANT_ITALIC && doMathvariantStyling) {
    font.style = NS_FONT_STYLE_ITALIC;
    font.weight = NS_FONT_WEIGHT_NORMAL;
  } else if (mathVar == NS_MATHML_MATHVARIANT_BOLD_ITALIC &&
             doMathvariantStyling) {
    font.style = NS_FONT_STYLE_ITALIC;
    font.weight = NS_FONT_WEIGHT_BOLD;
  } else if (mathVar != NS_MATHML_MATHVARIANT_NONE) {
    // Mathvariant overrides fontstyle and fontweight
    // Need to check to see if mathvariant is actually applied as this function
    // is used for other purposes.
    font.style = NS_FONT_STYLE_NORMAL;
    font.weight = NS_FONT_WEIGHT_NORMAL;
  }
  gfxFontGroup* newFontGroup = nullptr;

  // Get the correct gfxFontGroup that corresponds to the earlier font changes.
  if (length) {
    font.size = NSToCoordRound(font.size * mFontInflation);
    nsPresContext* pc = styles[0]->mPresContext;
    nsFontMetrics::Params params;
    params.language = styles[0]->mLanguage;
    params.explicitLanguage = styles[0]->mExplicitLanguage;
    params.userFontSet = pc->GetUserFontSet();
    params.textPerf = pc->GetTextPerfMetrics();
    RefPtr<nsFontMetrics> metrics =
      pc->DeviceContext()->GetMetricsFor(font, params);
    newFontGroup = metrics->GetThebesFontGroup();
  }

  if (!newFontGroup) {
    // If we can't get a new font group, fall back to the old one.  Rendering
    // will be incorrect, but not significantly so.
    newFontGroup = fontGroup;
  }

  if (mInnerTransformingTextRunFactory) {
    transformedChild = mInnerTransformingTextRunFactory->MakeTextRun(
        convertedString.BeginReading(), convertedString.Length(),
        &innerParams, newFontGroup, flags, Move(styleArray), false);
    child = transformedChild.get();
  } else {
    cachedChild = newFontGroup->MakeTextRun(
        convertedString.BeginReading(), convertedString.Length(),
        &innerParams, flags, aMFR);
    child = cachedChild.get();
  }
  if (!child)
    return;

  typedef gfxTextRun::Range Range;

  // Copy potential linebreaks into child so they're preserved
  // (and also child will be shaped appropriately)
  NS_ASSERTION(convertedString.Length() == canBreakBeforeArray.Length(),
               "Dropped characters or break-before values somewhere!");
  Range range(0, uint32_t(canBreakBeforeArray.Length()));
  child->SetPotentialLineBreaks(range, canBreakBeforeArray.Elements());
  if (transformedChild) {
    transformedChild->FinishSettingProperties(aRefDrawTarget, aMFR);
  }

  if (mergeNeeded) {
    // Now merge multiple characters into one multi-glyph character as required
    NS_ASSERTION(charsToMergeArray.Length() == child->GetLength(),
                 "source length mismatch");
    NS_ASSERTION(deletedCharsArray.Length() == aTextRun->GetLength(),
                 "destination length mismatch");
    MergeCharactersInTextRun(aTextRun, child, charsToMergeArray.Elements(),
                             deletedCharsArray.Elements());
  } else {
    // No merging to do, so just copy; this produces a more optimized textrun.
    // We can't steal the data because the child may be cached and stealing
    // the data would break the cache.
    aTextRun->ResetGlyphRuns();
    aTextRun->CopyGlyphDataFrom(child, Range(child), 0);
  }
}