1 // Copyright 2015 The Servo Project Developers. See the
2 // COPYRIGHT file at the top-level directory of this distribution.
3 //
4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7 // option. This file may not be copied, modified, or distributed
8 // except according to those terms.
9
10 //! 3.3.4 - 3.3.6. Resolve implicit levels and types.
11
12 use core::cmp::max;
13 use alloc::vec::Vec;
14
15 use super::char_data::BidiClass::{self, *};
16 use super::prepare::{IsolatingRunSequence, LevelRun, not_removed_by_x9, removed_by_x9};
17 use super::level::Level;
18
19 /// 3.3.4 Resolving Weak Types
20 ///
21 /// <http://www.unicode.org/reports/tr9/#Resolving_Weak_Types>
22 #[cfg_attr(feature = "flame_it", flamer::flame)]
resolve_weak(sequence: &IsolatingRunSequence, processing_classes: &mut [BidiClass])23 pub fn resolve_weak(sequence: &IsolatingRunSequence, processing_classes: &mut [BidiClass]) {
24 // FIXME (#8): This function applies steps W1-W6 in a single pass. This can produce
25 // incorrect results in cases where a "later" rule changes the value of `prev_class` seen
26 // by an "earlier" rule. We should either split this into separate passes, or preserve
27 // extra state so each rule can see the correct previous class.
28
29 // FIXME: Also, this could be the cause of increased failure for using longer-UTF-8 chars in
30 // conformance tests, like BidiTest:69635 (AL ET EN)
31
32 let mut prev_class = sequence.sos;
33 let mut last_strong_is_al = false;
34 let mut et_run_indices = Vec::new(); // for W5
35
36 // Like sequence.runs.iter().flat_map(Clone::clone), but make indices itself clonable.
37 fn id(x: LevelRun) -> LevelRun {
38 x
39 }
40 let mut indices = sequence.runs.iter().cloned().flat_map(
41 id as fn(LevelRun) -> LevelRun,
42 );
43
44 while let Some(i) = indices.next() {
45 match processing_classes[i] {
46 // <http://www.unicode.org/reports/tr9/#W1>
47 NSM => {
48 processing_classes[i] = match prev_class {
49 RLI | LRI | FSI | PDI => ON,
50 _ => prev_class,
51 };
52 }
53 EN => {
54 if last_strong_is_al {
55 // W2. If previous strong char was AL, change EN to AN.
56 processing_classes[i] = AN;
57 } else {
58 // W5. If a run of ETs is adjacent to an EN, change the ETs to EN.
59 for j in &et_run_indices {
60 processing_classes[*j] = EN;
61 }
62 et_run_indices.clear();
63 }
64 }
65 // <http://www.unicode.org/reports/tr9/#W3>
66 AL => processing_classes[i] = R,
67
68 // <http://www.unicode.org/reports/tr9/#W4>
69 ES | CS => {
70 let next_class = indices
71 .clone()
72 .map(|j| processing_classes[j])
73 .find(not_removed_by_x9)
74 .unwrap_or(sequence.eos);
75 processing_classes[i] = match (prev_class, processing_classes[i], next_class) {
76 (EN, ES, EN) | (EN, CS, EN) => EN,
77 (AN, CS, AN) => AN,
78 (_, _, _) => ON,
79 }
80 }
81 // <http://www.unicode.org/reports/tr9/#W5>
82 ET => {
83 match prev_class {
84 EN => processing_classes[i] = EN,
85 _ => et_run_indices.push(i), // In case this is followed by an EN.
86 }
87 }
88 class => {
89 if removed_by_x9(class) {
90 continue;
91 }
92 }
93 }
94
95 prev_class = processing_classes[i];
96 match prev_class {
97 L | R => {
98 last_strong_is_al = false;
99 }
100 AL => {
101 last_strong_is_al = true;
102 }
103 _ => {}
104 }
105 if prev_class != ET {
106 // W6. If we didn't find an adjacent EN, turn any ETs into ON instead.
107 for j in &et_run_indices {
108 processing_classes[*j] = ON;
109 }
110 et_run_indices.clear();
111 }
112 }
113
114 // W7. If the previous strong char was L, change EN to L.
115 let mut last_strong_is_l = sequence.sos == L;
116 for run in &sequence.runs {
117 for i in run.clone() {
118 match processing_classes[i] {
119 EN if last_strong_is_l => {
120 processing_classes[i] = L;
121 }
122 L => {
123 last_strong_is_l = true;
124 }
125 R | AL => {
126 last_strong_is_l = false;
127 }
128 _ => {}
129 }
130 }
131 }
132 }
133
134 /// 3.3.5 Resolving Neutral Types
135 ///
136 /// <http://www.unicode.org/reports/tr9/#Resolving_Neutral_Types>
137 #[cfg_attr(feature = "flame_it", flamer::flame)]
resolve_neutral( sequence: &IsolatingRunSequence, levels: &[Level], processing_classes: &mut [BidiClass], )138 pub fn resolve_neutral(
139 sequence: &IsolatingRunSequence,
140 levels: &[Level],
141 processing_classes: &mut [BidiClass],
142 ) {
143 let e: BidiClass = levels[sequence.runs[0].start].bidi_class();
144 let mut indices = sequence.runs.iter().flat_map(Clone::clone);
145 let mut prev_class = sequence.sos;
146
147 while let Some(mut i) = indices.next() {
148 // N0. Process bracket pairs.
149 // TODO
150
151 // Process sequences of NI characters.
152 let mut ni_run = Vec::new();
153 if is_NI(processing_classes[i]) {
154 // Consume a run of consecutive NI characters.
155 ni_run.push(i);
156 let mut next_class;
157 loop {
158 match indices.next() {
159 Some(j) => {
160 i = j;
161 if removed_by_x9(processing_classes[i]) {
162 continue;
163 }
164 next_class = processing_classes[j];
165 if is_NI(next_class) {
166 ni_run.push(i);
167 } else {
168 break;
169 }
170 }
171 None => {
172 next_class = sequence.eos;
173 break;
174 }
175 };
176 }
177
178 // N1-N2.
179 //
180 // <http://www.unicode.org/reports/tr9/#N1>
181 // <http://www.unicode.org/reports/tr9/#N2>
182 let new_class = match (prev_class, next_class) {
183 (L, L) => L,
184 (R, R) | (R, AN) | (R, EN) | (AN, R) | (AN, AN) | (AN, EN) | (EN, R) |
185 (EN, AN) | (EN, EN) => R,
186 (_, _) => e,
187 };
188 for j in &ni_run {
189 processing_classes[*j] = new_class;
190 }
191 ni_run.clear();
192 }
193 prev_class = processing_classes[i];
194 }
195 }
196
197 /// 3.3.6 Resolving Implicit Levels
198 ///
199 /// Returns the maximum embedding level in the paragraph.
200 ///
201 /// <http://www.unicode.org/reports/tr9/#Resolving_Implicit_Levels>
202 #[cfg_attr(feature = "flame_it", flamer::flame)]
resolve_levels(original_classes: &[BidiClass], levels: &mut [Level]) -> Level203 pub fn resolve_levels(original_classes: &[BidiClass], levels: &mut [Level]) -> Level {
204 let mut max_level = Level::ltr();
205
206 assert_eq!(original_classes.len(), levels.len());
207 for i in 0..levels.len() {
208 match (levels[i].is_rtl(), original_classes[i]) {
209 (false, AN) | (false, EN) => levels[i].raise(2).expect("Level number error"),
210 (false, R) | (true, L) | (true, EN) | (true, AN) => {
211 levels[i].raise(1).expect("Level number error")
212 }
213 (_, _) => {}
214 }
215 max_level = max(max_level, levels[i]);
216 }
217
218 max_level
219 }
220
221 /// Neutral or Isolate formatting character (B, S, WS, ON, FSI, LRI, RLI, PDI)
222 ///
223 /// <http://www.unicode.org/reports/tr9/#NI>
224 #[allow(non_snake_case)]
is_NI(class: BidiClass) -> bool225 fn is_NI(class: BidiClass) -> bool {
226 match class {
227 B | S | WS | ON | FSI | LRI | RLI | PDI => true,
228 _ => false,
229 }
230 }
231