1 /* Low-level bidirectional buffer-scanning functions for GNU Emacs.
2 Copyright (C) 2000, 2001, 2004, 2005, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* Written by Eli Zaretskii <eliz@gnu.org>.
22 A sequential implementation of the Unicode Bidirectional algorithm,
23 as per UAX#9, a part of the Unicode Standard.
25 Unlike the reference and most other implementations, this one is
26 designed to be called once for every character in the buffer.
28 The main entry point is bidi_get_next_char_visually. Each time it
29 is called, it finds the next character in the visual order, and
30 returns its information in a special structure. The caller is then
31 expected to process this character for display or any other
32 purposes, and call bidi_get_next_char_visually for the next
33 character. See the comments in bidi_get_next_char_visually for
34 more details about its algorithm that finds the next visual-order
35 character by resolving their levels on the fly.
37 If you want to understand the code, you will have to read it
38 together with the relevant portions of UAX#9. The comments include
39 references to UAX#9 rules, for that very reason.
41 A note about references to UAX#9 rules: if the reference says
42 something like "X9/Retaining", it means that you need to refer to
43 rule X9 and to its modifications decribed in the "Implementation
44 Notes" section of UAX#9, under "Retaining Format Codes". */
60 #include "character.h"
61 #include "dispextern.h"
63 static int bidi_initialized
= 0;
65 static Lisp_Object bidi_type_table
;
67 /* FIXME: Remove these when bidi_explicit_dir_char uses a lookup table. */
68 #define LRM_CHAR 0x200E
69 #define RLM_CHAR 0x200F
70 #define LRE_CHAR 0x202A
71 #define RLE_CHAR 0x202B
72 #define PDF_CHAR 0x202C
73 #define LRO_CHAR 0x202D
74 #define RLO_CHAR 0x202E
77 #define BIDI_BOB -2 /* FIXME: Is this needed? */
79 /* Local data structures. (Look in dispextern.h for the rest.) */
81 /* What we need to know about the current paragraph. */
82 struct bidi_paragraph_info
{
83 int start_bytepos
; /* byte position where it begins */
84 int end_bytepos
; /* byte position where it ends */
85 int embedding_level
; /* its basic embedding level */
86 bidi_dir_t base_dir
; /* its base direction */
89 /* Data type for describing the bidirectional character categories. */
97 int bidi_ignore_explicit_marks_for_paragraph_level
= 1;
99 static Lisp_Object fallback_paragraph_start_re
, fallback_paragraph_separate_re
;
100 static Lisp_Object Qparagraph_start
, Qparagraph_separate
;
105 /* FIXME: This should come from the Unicode Database. */
110 { { 0x0000, 0x0008, WEAK_BN
},
111 { 0x0009, 0x0000, NEUTRAL_S
},
112 { 0x000A, 0x0000, NEUTRAL_B
},
113 { 0x000B, 0x0000, NEUTRAL_S
},
114 { 0x000C, 0x0000, NEUTRAL_WS
},
115 { 0x000D, 0x0000, NEUTRAL_B
},
116 { 0x000E, 0x001B, WEAK_BN
},
117 { 0x001C, 0x001E, NEUTRAL_B
},
118 { 0x001F, 0x0000, NEUTRAL_S
},
119 { 0x0020, 0x0000, NEUTRAL_WS
},
120 { 0x0021, 0x0022, NEUTRAL_ON
},
121 { 0x0023, 0x0025, WEAK_ET
},
122 { 0x0026, 0x002A, NEUTRAL_ON
},
123 { 0x002B, 0x0000, WEAK_ES
},
124 { 0x002C, 0x0000, WEAK_CS
},
125 { 0x002D, 0x0000, WEAK_ES
},
126 { 0x002E, 0x002F, WEAK_CS
},
127 { 0x0030, 0x0039, WEAK_EN
},
128 { 0x003A, 0x0000, WEAK_CS
},
129 { 0x003B, 0x0040, NEUTRAL_ON
},
130 { 0x005B, 0x0060, NEUTRAL_ON
},
131 { 0x007B, 0x007E, NEUTRAL_ON
},
132 { 0x007F, 0x0084, WEAK_BN
},
133 { 0x0085, 0x0000, NEUTRAL_B
},
134 { 0x0086, 0x009F, WEAK_BN
},
135 { 0x00A0, 0x0000, WEAK_CS
},
136 { 0x00A1, 0x0000, NEUTRAL_ON
},
137 { 0x00A2, 0x00A5, WEAK_ET
},
138 { 0x00A6, 0x00A9, NEUTRAL_ON
},
139 { 0x00AB, 0x00AC, NEUTRAL_ON
},
140 { 0x00AD, 0x0000, WEAK_BN
},
141 { 0x00AE, 0x00Af, NEUTRAL_ON
},
142 { 0x00B0, 0x00B1, WEAK_ET
},
143 { 0x00B2, 0x00B3, WEAK_EN
},
144 { 0x00B4, 0x0000, NEUTRAL_ON
},
145 { 0x00B6, 0x00B8, NEUTRAL_ON
},
146 { 0x00B9, 0x0000, WEAK_EN
},
147 { 0x00BB, 0x00BF, NEUTRAL_ON
},
148 { 0x00D7, 0x0000, NEUTRAL_ON
},
149 { 0x00F7, 0x0000, NEUTRAL_ON
},
150 { 0x02B9, 0x02BA, NEUTRAL_ON
},
151 { 0x02C2, 0x02CF, NEUTRAL_ON
},
152 { 0x02D2, 0x02DF, NEUTRAL_ON
},
153 { 0x02E5, 0x02ED, NEUTRAL_ON
},
154 { 0x0300, 0x036F, WEAK_NSM
},
155 { 0x0374, 0x0375, NEUTRAL_ON
},
156 { 0x037E, 0x0385, NEUTRAL_ON
},
157 { 0x0387, 0x0000, NEUTRAL_ON
},
158 { 0x03F6, 0x0000, NEUTRAL_ON
},
159 { 0x0483, 0x0489, WEAK_NSM
},
160 { 0x058A, 0x0000, NEUTRAL_ON
},
161 { 0x0591, 0x05BD, WEAK_NSM
},
162 { 0x05BE, 0x0000, STRONG_R
},
163 { 0x05BF, 0x0000, WEAK_NSM
},
164 { 0x05C0, 0x0000, STRONG_R
},
165 { 0x05C1, 0x05C2, WEAK_NSM
},
166 { 0x05C3, 0x0000, STRONG_R
},
167 { 0x05C4, 0x05C5, WEAK_NSM
},
168 { 0x05C6, 0x0000, STRONG_R
},
169 { 0x05C7, 0x0000, WEAK_NSM
},
170 { 0x05D0, 0x05F4, STRONG_R
},
171 { 0x060C, 0x0000, WEAK_CS
},
172 { 0x061B, 0x064A, STRONG_AL
},
173 { 0x064B, 0x0655, WEAK_NSM
},
174 { 0x0660, 0x0669, WEAK_AN
},
175 { 0x066A, 0x0000, WEAK_ET
},
176 { 0x066B, 0x066C, WEAK_AN
},
177 { 0x066D, 0x066F, STRONG_AL
},
178 { 0x0670, 0x0000, WEAK_NSM
},
179 { 0x0671, 0x06D5, STRONG_AL
},
180 { 0x06D6, 0x06DC, WEAK_NSM
},
181 { 0x06DD, 0x0000, STRONG_AL
},
182 { 0x06DE, 0x06E4, WEAK_NSM
},
183 { 0x06E5, 0x06E6, STRONG_AL
},
184 { 0x06E7, 0x06E8, WEAK_NSM
},
185 { 0x06E9, 0x0000, NEUTRAL_ON
},
186 { 0x06EA, 0x06ED, WEAK_NSM
},
187 { 0x06F0, 0x06F9, WEAK_EN
},
188 { 0x06FA, 0x070D, STRONG_AL
},
189 { 0x070F, 0x0000, WEAK_BN
},
190 { 0x0710, 0x0000, STRONG_AL
},
191 { 0x0711, 0x0000, WEAK_NSM
},
192 { 0x0712, 0x072C, STRONG_AL
},
193 { 0x0730, 0x074A, WEAK_NSM
},
194 { 0x0780, 0x07A5, STRONG_AL
},
195 { 0x07A6, 0x07B0, WEAK_NSM
},
196 { 0x07B1, 0x0000, STRONG_AL
},
197 { 0x0901, 0x0902, WEAK_NSM
},
198 { 0x093C, 0x0000, WEAK_NSM
},
199 { 0x0941, 0x0948, WEAK_NSM
},
200 { 0x094D, 0x0000, WEAK_NSM
},
201 { 0x0951, 0x0954, WEAK_NSM
},
202 { 0x0962, 0x0963, WEAK_NSM
},
203 { 0x0981, 0x0000, WEAK_NSM
},
204 { 0x09BC, 0x0000, WEAK_NSM
},
205 { 0x09C1, 0x09C4, WEAK_NSM
},
206 { 0x09CD, 0x0000, WEAK_NSM
},
207 { 0x09E2, 0x09E3, WEAK_NSM
},
208 { 0x09F2, 0x09F3, WEAK_ET
},
209 { 0x0A02, 0x0000, WEAK_NSM
},
210 { 0x0A3C, 0x0000, WEAK_NSM
},
211 { 0x0A41, 0x0A4D, WEAK_NSM
},
212 { 0x0A70, 0x0A71, WEAK_NSM
},
213 { 0x0A81, 0x0A82, WEAK_NSM
},
214 { 0x0ABC, 0x0000, WEAK_NSM
},
215 { 0x0AC1, 0x0AC8, WEAK_NSM
},
216 { 0x0ACD, 0x0000, WEAK_NSM
},
217 { 0x0B01, 0x0000, WEAK_NSM
},
218 { 0x0B3C, 0x0000, WEAK_NSM
},
219 { 0x0B3F, 0x0000, WEAK_NSM
},
220 { 0x0B41, 0x0B43, WEAK_NSM
},
221 { 0x0B4D, 0x0B56, WEAK_NSM
},
222 { 0x0B82, 0x0000, WEAK_NSM
},
223 { 0x0BC0, 0x0000, WEAK_NSM
},
224 { 0x0BCD, 0x0000, WEAK_NSM
},
225 { 0x0C3E, 0x0C40, WEAK_NSM
},
226 { 0x0C46, 0x0C56, WEAK_NSM
},
227 { 0x0CBF, 0x0000, WEAK_NSM
},
228 { 0x0CC6, 0x0000, WEAK_NSM
},
229 { 0x0CCC, 0x0CCD, WEAK_NSM
},
230 { 0x0D41, 0x0D43, WEAK_NSM
},
231 { 0x0D4D, 0x0000, WEAK_NSM
},
232 { 0x0DCA, 0x0000, WEAK_NSM
},
233 { 0x0DD2, 0x0DD6, WEAK_NSM
},
234 { 0x0E31, 0x0000, WEAK_NSM
},
235 { 0x0E34, 0x0E3A, WEAK_NSM
},
236 { 0x0E3F, 0x0000, WEAK_ET
},
237 { 0x0E47, 0x0E4E, WEAK_NSM
},
238 { 0x0EB1, 0x0000, WEAK_NSM
},
239 { 0x0EB4, 0x0EBC, WEAK_NSM
},
240 { 0x0EC8, 0x0ECD, WEAK_NSM
},
241 { 0x0F18, 0x0F19, WEAK_NSM
},
242 { 0x0F35, 0x0000, WEAK_NSM
},
243 { 0x0F37, 0x0000, WEAK_NSM
},
244 { 0x0F39, 0x0000, WEAK_NSM
},
245 { 0x0F3A, 0x0F3D, NEUTRAL_ON
},
246 { 0x0F71, 0x0F7E, WEAK_NSM
},
247 { 0x0F80, 0x0F84, WEAK_NSM
},
248 { 0x0F86, 0x0F87, WEAK_NSM
},
249 { 0x0F90, 0x0FBC, WEAK_NSM
},
250 { 0x0FC6, 0x0000, WEAK_NSM
},
251 { 0x102D, 0x1030, WEAK_NSM
},
252 { 0x1032, 0x1037, WEAK_NSM
},
253 { 0x1039, 0x0000, WEAK_NSM
},
254 { 0x1058, 0x1059, WEAK_NSM
},
255 { 0x1680, 0x0000, NEUTRAL_WS
},
256 { 0x169B, 0x169C, NEUTRAL_ON
},
257 { 0x1712, 0x1714, WEAK_NSM
},
258 { 0x1732, 0x1734, WEAK_NSM
},
259 { 0x1752, 0x1753, WEAK_NSM
},
260 { 0x1772, 0x1773, WEAK_NSM
},
261 { 0x17B7, 0x17BD, WEAK_NSM
},
262 { 0x17C6, 0x0000, WEAK_NSM
},
263 { 0x17C9, 0x17D3, WEAK_NSM
},
264 { 0x17DB, 0x0000, WEAK_ET
},
265 { 0x1800, 0x180A, NEUTRAL_ON
},
266 { 0x180B, 0x180D, WEAK_NSM
},
267 { 0x180E, 0x0000, WEAK_BN
},
268 { 0x18A9, 0x0000, WEAK_NSM
},
269 { 0x1FBD, 0x0000, NEUTRAL_ON
},
270 { 0x1FBF, 0x1FC1, NEUTRAL_ON
},
271 { 0x1FCD, 0x1FCF, NEUTRAL_ON
},
272 { 0x1FDD, 0x1FDF, NEUTRAL_ON
},
273 { 0x1FED, 0x1FEF, NEUTRAL_ON
},
274 { 0x1FFD, 0x1FFE, NEUTRAL_ON
},
275 { 0x2000, 0x200A, NEUTRAL_WS
},
276 { 0x200B, 0x200D, WEAK_BN
},
277 { 0x200F, 0x0000, STRONG_R
},
278 { 0x2010, 0x2027, NEUTRAL_ON
},
279 { 0x2028, 0x0000, NEUTRAL_WS
},
280 { 0x2029, 0x0000, NEUTRAL_B
},
281 { 0x202A, 0x0000, LRE
},
282 { 0x202B, 0x0000, RLE
},
283 { 0x202C, 0x0000, PDF
},
284 { 0x202D, 0x0000, LRO
},
285 { 0x202E, 0x0000, RLO
},
286 { 0x202F, 0x0000, NEUTRAL_WS
},
287 { 0x2030, 0x2034, WEAK_ET
},
288 { 0x2035, 0x2057, NEUTRAL_ON
},
289 { 0x205F, 0x0000, NEUTRAL_WS
},
290 { 0x2060, 0x206F, WEAK_BN
},
291 { 0x2070, 0x0000, WEAK_EN
},
292 { 0x2074, 0x2079, WEAK_EN
},
293 { 0x207A, 0x207B, WEAK_ET
},
294 { 0x207C, 0x207E, NEUTRAL_ON
},
295 { 0x2080, 0x2089, WEAK_EN
},
296 { 0x208A, 0x208B, WEAK_ET
},
297 { 0x208C, 0x208E, NEUTRAL_ON
},
298 { 0x20A0, 0x20B1, WEAK_ET
},
299 { 0x20D0, 0x20EA, WEAK_NSM
},
300 { 0x2100, 0x2101, NEUTRAL_ON
},
301 { 0x2103, 0x2106, NEUTRAL_ON
},
302 { 0x2108, 0x2109, NEUTRAL_ON
},
303 { 0x2114, 0x0000, NEUTRAL_ON
},
304 { 0x2116, 0x2118, NEUTRAL_ON
},
305 { 0x211E, 0x2123, NEUTRAL_ON
},
306 { 0x2125, 0x0000, NEUTRAL_ON
},
307 { 0x2127, 0x0000, NEUTRAL_ON
},
308 { 0x2129, 0x0000, NEUTRAL_ON
},
309 { 0x212E, 0x0000, WEAK_ET
},
310 { 0x2132, 0x0000, NEUTRAL_ON
},
311 { 0x213A, 0x0000, NEUTRAL_ON
},
312 { 0x2140, 0x2144, NEUTRAL_ON
},
313 { 0x214A, 0x215F, NEUTRAL_ON
},
314 { 0x2190, 0x2211, NEUTRAL_ON
},
315 { 0x2212, 0x2213, WEAK_ET
},
316 { 0x2214, 0x2335, NEUTRAL_ON
},
317 { 0x237B, 0x2394, NEUTRAL_ON
},
318 { 0x2396, 0x244A, NEUTRAL_ON
},
319 { 0x2460, 0x249B, WEAK_EN
},
320 { 0x24EA, 0x0000, WEAK_EN
},
321 { 0x24EB, 0x2FFB, NEUTRAL_ON
},
322 { 0x3000, 0x0000, NEUTRAL_WS
},
323 { 0x3001, 0x3004, NEUTRAL_ON
},
324 { 0x3008, 0x3020, NEUTRAL_ON
},
325 { 0x302A, 0x302F, WEAK_NSM
},
326 { 0x3030, 0x0000, NEUTRAL_ON
},
327 { 0x3036, 0x3037, NEUTRAL_ON
},
328 { 0x303D, 0x303F, NEUTRAL_ON
},
329 { 0x3099, 0x309A, WEAK_NSM
},
330 { 0x309B, 0x309C, NEUTRAL_ON
},
331 { 0x30A0, 0x0000, NEUTRAL_ON
},
332 { 0x30FB, 0x0000, NEUTRAL_ON
},
333 { 0x3251, 0x325F, NEUTRAL_ON
},
334 { 0x32B1, 0x32BF, NEUTRAL_ON
},
335 { 0xA490, 0xA4C6, NEUTRAL_ON
},
336 { 0xFB1D, 0x0000, STRONG_R
},
337 { 0xFB1E, 0x0000, WEAK_NSM
},
338 { 0xFB1F, 0xFB28, STRONG_R
},
339 { 0xFB29, 0x0000, WEAK_ET
},
340 { 0xFB2A, 0xFB4F, STRONG_R
},
341 { 0xFB50, 0xFD3D, STRONG_AL
},
342 { 0xFD3E, 0xFD3F, NEUTRAL_ON
},
343 { 0xFD50, 0xFDFC, STRONG_AL
},
344 { 0xFE00, 0xFE23, WEAK_NSM
},
345 { 0xFE30, 0xFE4F, NEUTRAL_ON
},
346 { 0xFE50, 0x0000, WEAK_CS
},
347 { 0xFE51, 0x0000, NEUTRAL_ON
},
348 { 0xFE52, 0x0000, WEAK_CS
},
349 { 0xFE54, 0x0000, NEUTRAL_ON
},
350 { 0xFE55, 0x0000, WEAK_CS
},
351 { 0xFE56, 0xFE5E, NEUTRAL_ON
},
352 { 0xFE5F, 0x0000, WEAK_ET
},
353 { 0xFE60, 0xFE61, NEUTRAL_ON
},
354 { 0xFE62, 0xFE63, WEAK_ET
},
355 { 0xFE64, 0xFE68, NEUTRAL_ON
},
356 { 0xFE69, 0xFE6A, WEAK_ET
},
357 { 0xFE6B, 0x0000, NEUTRAL_ON
},
358 { 0xFE70, 0xFEFC, STRONG_AL
},
359 { 0xFEFF, 0x0000, WEAK_BN
},
360 { 0xFF01, 0xFF02, NEUTRAL_ON
},
361 { 0xFF03, 0xFF05, WEAK_ET
},
362 { 0xFF06, 0xFF0A, NEUTRAL_ON
},
363 { 0xFF0B, 0x0000, WEAK_ET
},
364 { 0xFF0C, 0x0000, WEAK_CS
},
365 { 0xFF0D, 0x0000, WEAK_ET
},
366 { 0xFF0E, 0x0000, WEAK_CS
},
367 { 0xFF0F, 0x0000, WEAK_ES
},
368 { 0xFF10, 0xFF19, WEAK_EN
},
369 { 0xFF1A, 0x0000, WEAK_CS
},
370 { 0xFF1B, 0xFF20, NEUTRAL_ON
},
371 { 0xFF3B, 0xFF40, NEUTRAL_ON
},
372 { 0xFF5B, 0xFF65, NEUTRAL_ON
},
373 { 0xFFE0, 0xFFE1, WEAK_ET
},
374 { 0xFFE2, 0xFFE4, NEUTRAL_ON
},
375 { 0xFFE5, 0xFFE6, WEAK_ET
},
376 { 0xFFE8, 0xFFEE, NEUTRAL_ON
},
377 { 0xFFF9, 0xFFFB, WEAK_BN
},
378 { 0xFFFC, 0xFFFD, NEUTRAL_ON
},
379 { 0x1D167, 0x1D169, WEAK_NSM
},
380 { 0x1D173, 0x1D17A, WEAK_BN
},
381 { 0x1D17B, 0x1D182, WEAK_NSM
},
382 { 0x1D185, 0x1D18B, WEAK_NSM
},
383 { 0x1D1AA, 0x1D1AD, WEAK_NSM
},
384 { 0x1D7CE, 0x1D7FF, WEAK_EN
},
385 { 0xE0001, 0xE007F, WEAK_BN
} };
388 bidi_type_table
= Fmake_char_table (Qnil
, make_number (STRONG_L
));
389 staticpro (&bidi_type_table
);
391 for (i
= 0; i
< sizeof bidi_type
/ sizeof bidi_type
[0]; i
++)
392 char_table_set_range (bidi_type_table
, bidi_type
[i
].from
,
393 bidi_type
[i
].to
? bidi_type
[i
].to
: bidi_type
[i
].from
,
394 make_number (bidi_type
[i
].type
));
396 fallback_paragraph_start_re
=
397 XSYMBOL (Fintern_soft (build_string ("paragraph-start"), Qnil
))->value
;
398 if (!STRINGP (fallback_paragraph_start_re
))
399 fallback_paragraph_start_re
= build_string ("\f\\|[ \t]*$");
400 staticpro (&fallback_paragraph_start_re
);
401 Qparagraph_start
= intern ("paragraph-start");
402 staticpro (&Qparagraph_start
);
403 fallback_paragraph_separate_re
=
404 XSYMBOL (Fintern_soft (build_string ("paragraph-separate"), Qnil
))->value
;
405 if (!STRINGP (fallback_paragraph_separate_re
))
406 fallback_paragraph_separate_re
= build_string ("[ \t\f]*$");
407 staticpro (&fallback_paragraph_separate_re
);
408 Qparagraph_separate
= intern ("paragraph-separate");
409 staticpro (&Qparagraph_separate
);
410 bidi_initialized
= 1;
413 /* Return the bidi type of a character CH, subject to the current
414 directional OVERRIDE. */
416 bidi_get_type (int ch
, bidi_dir_t override
)
418 bidi_type_t default_type
;
422 if (ch
< 0 || ch
> MAX_CHAR
)
425 default_type
= (bidi_type_t
) XINT (CHAR_TABLE_REF (bidi_type_table
, ch
));
427 if (override
== NEUTRAL_DIR
)
430 switch (default_type
)
432 /* Although UAX#9 does not tell, it doesn't make sense to
433 override NEUTRAL_B and LRM/RLM characters. */
448 if (override
== L2R
) /* X6 */
450 else if (override
== R2L
)
453 abort (); /* can't happen: handled above */
459 bidi_check_type (bidi_type_t type
)
461 if (type
< UNKNOWN_BT
|| type
> NEUTRAL_ON
)
465 /* Given a bidi TYPE of a character, return its category. */
467 bidi_get_category (bidi_type_t type
)
481 case PDF
: /* ??? really?? */
500 /* Return the mirrored character of C, if any.
502 Note: The conditions in UAX#9 clause L4 must be tested by the
504 /* FIXME: exceedingly temporary! Should consult the Unicode database
505 of character properties. */
507 bidi_mirror_char (int c
)
509 static const char mirrored_pairs
[] = "()<>[]{}";
510 const char *p
= c
> 0 && c
< 128 ? strchr (mirrored_pairs
, c
) : NULL
;
514 size_t i
= p
- mirrored_pairs
;
516 return mirrored_pairs
[(i
^ 1)];
521 /* Copy the bidi iterator from FROM to TO. To save cycles, this only
522 copies the part of the level stack that is actually in use. */
524 bidi_copy_it (struct bidi_it
*to
, struct bidi_it
*from
)
528 /* Copy everything except the level stack and beyond. */
529 memcpy (to
, from
, ((size_t)&((struct bidi_it
*)0)->level_stack
[0]));
531 /* Copy the active part of the level stack. */
532 to
->level_stack
[0] = from
->level_stack
[0]; /* level zero is always in use */
533 for (i
= 1; i
<= from
->stack_idx
; i
++)
534 to
->level_stack
[i
] = from
->level_stack
[i
];
537 /* Caching the bidi iterator states. */
539 static struct bidi_it bidi_cache
[1000]; /* FIXME: make this dynamically allocated! */
540 static int bidi_cache_idx
;
541 static int bidi_cache_last_idx
;
544 bidi_cache_reset (void)
547 bidi_cache_last_idx
= -1;
551 bidi_cache_fetch_state (int idx
, struct bidi_it
*bidi_it
)
553 int current_scan_dir
= bidi_it
->scan_dir
;
555 if (idx
< 0 || idx
>= bidi_cache_idx
)
558 bidi_copy_it (bidi_it
, &bidi_cache
[idx
]);
559 bidi_it
->scan_dir
= current_scan_dir
;
560 bidi_cache_last_idx
= idx
;
563 /* Find a cached state with a given CHARPOS and resolved embedding
564 level less or equal to LEVEL. if LEVEL is -1, disregard the
565 resolved levels in cached states. DIR, if non-zero, means search
566 in that direction from the last cache hit. */
568 bidi_cache_search (int charpos
, int level
, int dir
)
574 if (charpos
< bidi_cache
[bidi_cache_last_idx
].charpos
)
576 else if (charpos
> bidi_cache
[bidi_cache_last_idx
].charpos
)
579 i_start
= bidi_cache_last_idx
;
583 i_start
= bidi_cache_idx
- 1;
588 /* Linear search for now; FIXME! */
589 for (i
= i_start
; i
>= 0; i
--)
590 if (bidi_cache
[i
].charpos
== charpos
591 && (level
== -1 || bidi_cache
[i
].resolved_level
<= level
))
596 for (i
= i_start
; i
< bidi_cache_idx
; i
++)
597 if (bidi_cache
[i
].charpos
== charpos
598 && (level
== -1 || bidi_cache
[i
].resolved_level
<= level
))
606 /* Find a cached state where the resolved level changes to a value
607 that is lower than LEVEL, and return its cache slot index. DIR is
608 the direction to search, starting with the last used cache slot.
609 BEFORE, if non-zero, means return the index of the slot that is
610 ``before'' the level change in the search direction. That is,
611 given the cached levels like this:
616 and assuming we are at the position cached at the slot marked with
617 C, searching backwards (DIR = -1) for LEVEL = 2 will return the
618 index of slot B or A, depending whether BEFORE is, respectively,
621 bidi_cache_find_level_change (int level
, int dir
, int before
)
625 int i
= dir
? bidi_cache_last_idx
: bidi_cache_idx
- 1;
626 int incr
= before
? 1 : 0;
637 if (bidi_cache
[i
- incr
].resolved_level
>= 0
638 && bidi_cache
[i
- incr
].resolved_level
< level
)
645 while (i
< bidi_cache_idx
- incr
)
647 if (bidi_cache
[i
+ incr
].resolved_level
>= 0
648 && bidi_cache
[i
+ incr
].resolved_level
< level
)
659 bidi_cache_iterator_state (struct bidi_it
*bidi_it
, int resolved
)
663 /* We should never cache on backward scans. */
664 if (bidi_it
->scan_dir
== -1)
666 idx
= bidi_cache_search (bidi_it
->charpos
, -1, 1);
670 idx
= bidi_cache_idx
;
671 /* Don't overrun the cache limit. */
672 if (idx
> sizeof (bidi_cache
) / sizeof (bidi_cache
[0]) - 1)
674 /* Character positions should correspond to cache positions 1:1.
675 If we are outside the range of cached positions, the cache is
676 useless and must be reset. */
678 (bidi_it
->charpos
> bidi_cache
[idx
- 1].charpos
+ 1
679 || bidi_it
->charpos
< bidi_cache
[0].charpos
))
684 bidi_copy_it (&bidi_cache
[idx
], bidi_it
);
686 bidi_cache
[idx
].resolved_level
= -1;
687 bidi_cache
[idx
].new_paragraph
= 0;
691 /* Copy only the members which could have changed, to avoid
692 costly copying of the entire struct. */
693 bidi_cache
[idx
].type
= bidi_it
->type
;
694 bidi_check_type (bidi_it
->type
);
695 bidi_cache
[idx
].type_after_w1
= bidi_it
->type_after_w1
;
696 bidi_check_type (bidi_it
->type_after_w1
);
698 bidi_cache
[idx
].resolved_level
= bidi_it
->resolved_level
;
700 bidi_cache
[idx
].resolved_level
= -1;
701 bidi_cache
[idx
].invalid_levels
= bidi_it
->invalid_levels
;
702 bidi_cache
[idx
].invalid_rl_levels
= bidi_it
->invalid_rl_levels
;
703 bidi_cache
[idx
].next_for_neutral
= bidi_it
->next_for_neutral
;
704 bidi_cache
[idx
].next_for_ws
= bidi_it
->next_for_ws
;
705 bidi_cache
[idx
].ignore_bn_limit
= bidi_it
->ignore_bn_limit
;
708 bidi_cache_last_idx
= idx
;
709 if (idx
>= bidi_cache_idx
)
710 bidi_cache_idx
= idx
+ 1;
713 static inline bidi_type_t
714 bidi_cache_find (int charpos
, int level
, struct bidi_it
*bidi_it
)
716 int i
= bidi_cache_search (charpos
, level
, bidi_it
->scan_dir
);
720 bidi_dir_t current_scan_dir
= bidi_it
->scan_dir
;
722 bidi_copy_it (bidi_it
, &bidi_cache
[i
]);
723 bidi_cache_last_idx
= i
;
724 /* Don't let scan direction from from the cached state override
725 the current scan direction. */
726 bidi_it
->scan_dir
= current_scan_dir
;
727 return bidi_it
->type
;
734 bidi_peek_at_next_level (struct bidi_it
*bidi_it
)
736 if (bidi_cache_idx
== 0 || bidi_cache_last_idx
== -1)
738 return bidi_cache
[bidi_cache_last_idx
+ bidi_it
->scan_dir
].resolved_level
;
741 /* Check if buffer position CHARPOS/BYTEPOS is the end of a paragraph.
742 Value is the non-negative length of the paragraph separator
743 following the buffer position, -1 if position is at the beginning
744 of a new paragraph, or -2 if position is neither at beginning nor
745 at end of a paragraph. */
747 bidi_at_paragraph_end (EMACS_INT charpos
, EMACS_INT bytepos
)
749 Lisp_Object sep_re
= Fbuffer_local_value (Qparagraph_separate
,
751 Lisp_Object start_re
= Fbuffer_local_value (Qparagraph_start
,
755 if (!STRINGP (sep_re
))
756 sep_re
= fallback_paragraph_separate_re
;
757 if (!STRINGP (start_re
))
758 start_re
= fallback_paragraph_start_re
;
760 val
= fast_looking_at (sep_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
);
763 if (fast_looking_at (start_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) >= 0)
772 /* Determine the start-of-run (sor) directional type given the two
773 embedding levels on either side of the run boundary. Also, update
774 the saved info about previously seen characters, since that info is
775 generally valid for a single level run. */
777 bidi_set_sor_type (struct bidi_it
*bidi_it
, int level_before
, int level_after
)
779 int higher_level
= level_before
> level_after
? level_before
: level_after
;
781 /* The prev_was_pdf gork is required for when we have several PDFs
782 in a row. In that case, we want to compute the sor type for the
783 next level run only once: when we see the first PDF. That's
784 because the sor type depends only on the higher of the two levels
785 that we find on the two sides of the level boundary (see UAX#9,
786 clause X10), and so we don't need to know the final embedding
787 level to which we descend after processing all the PDFs. */
788 if (!bidi_it
->prev_was_pdf
|| level_before
< level_after
)
789 /* FIXME: should the default sor direction be user selectable? */
790 bidi_it
->sor
= (higher_level
& 1) != 0 ? R2L
: L2R
;
791 if (level_before
> level_after
)
792 bidi_it
->prev_was_pdf
= 1;
794 bidi_it
->prev
.type
= UNKNOWN_BT
;
795 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
796 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
797 bidi_it
->prev_for_neutral
.type
= bidi_it
->sor
== R2L
? STRONG_R
: STRONG_L
;
798 bidi_it
->prev_for_neutral
.charpos
= bidi_it
->charpos
;
799 bidi_it
->prev_for_neutral
.bytepos
= bidi_it
->bytepos
;
800 bidi_it
->next_for_neutral
.type
= bidi_it
->next_for_neutral
.type_after_w1
=
801 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
802 bidi_it
->ignore_bn_limit
= 0; /* meaning it's unknown */
806 bidi_line_init (struct bidi_it
*bidi_it
)
808 bidi_it
->scan_dir
= 1; /* FIXME: do we need to have control on this? */
809 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
810 bidi_it
->level_stack
[0].override
= NEUTRAL_DIR
; /* X1 */
811 bidi_it
->invalid_levels
= 0;
812 bidi_it
->invalid_rl_levels
= -1;
813 bidi_it
->next_en_pos
= -1;
814 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
815 bidi_set_sor_type (bidi_it
,
816 bidi_it
->paragraph_dir
== R2L
? 1 : 0,
817 bidi_it
->level_stack
[0].level
); /* X10 */
822 /* Find the beginning of this paragraph by looking back in the buffer.
823 Value is the byte position of the paragraph's beginning. */
825 bidi_find_paragraph_start (EMACS_INT pos
, EMACS_INT pos_byte
)
827 Lisp_Object re
= Fbuffer_local_value (Qparagraph_start
, Fcurrent_buffer ());
828 EMACS_INT limit
= ZV
, limit_byte
= ZV_BYTE
;
831 re
= fallback_paragraph_start_re
;
832 while (pos_byte
> BEGV_BYTE
833 && fast_looking_at (re
, pos
, pos_byte
, limit
, limit_byte
, Qnil
) < 0)
835 pos
= find_next_newline_no_quit (pos
- 1, -1);
836 pos_byte
= CHAR_TO_BYTE (pos
);
841 /* Determine the direction, a.k.a. base embedding level, of the
842 paragraph we are about to iterate through. If DIR is either L2R or
843 R2L, just use that. Otherwise, determine the paragraph direction
844 from the first strong character of the paragraph.
846 Note that this gives the paragraph separator the same direction as
847 the preceding paragraph, even though Emacs generally views the
848 separartor as not belonging to any paragraph. */
850 bidi_paragraph_init (bidi_dir_t dir
, struct bidi_it
*bidi_it
)
852 EMACS_INT bytepos
= bidi_it
->bytepos
;
854 /* Special case for an empty buffer. */
855 if (bytepos
== BEGV_BYTE
&& bytepos
== ZV_BYTE
)
857 /* We should never be called at EOB or before BEGV. */
858 else if (bytepos
>= ZV_BYTE
|| bytepos
< BEGV_BYTE
)
863 bidi_it
->paragraph_dir
= L2R
;
864 bidi_it
->new_paragraph
= 0;
868 bidi_it
->paragraph_dir
= R2L
;
869 bidi_it
->new_paragraph
= 0;
871 else if (dir
== NEUTRAL_DIR
) /* P2 */
878 /* If we are inside a paragraph separator, we are just waiting
879 for the separator to be exhausted; use the previous paragraph
880 direction. But don't do that if we have been just reseated,
881 because we need to reinitialize below in that case. */
882 if (!bidi_it
->first_elt
883 && bidi_it
->charpos
< bidi_it
->separator_limit
)
886 /* If we are on a newline, get past it to where the next
887 paragraph might start. But don't do that at BEGV since then
888 we are potentially in a new paragraph that doesn't yet
890 pos
= bidi_it
->charpos
;
891 if (bytepos
> BEGV_BYTE
&& FETCH_CHAR (bytepos
) == '\n')
897 /* We are either at the beginning of a paragraph or in the
898 middle of it. Find where this paragraph starts. */
899 bytepos
= bidi_find_paragraph_start (pos
, bytepos
);
901 /* We should always be at the beginning of a new line at this
903 if (!(bytepos
== BEGV_BYTE
|| FETCH_CHAR (bytepos
- 1) == '\n'))
906 bidi_it
->separator_limit
= -1;
907 bidi_it
->new_paragraph
= 0;
908 ch
= FETCH_CHAR (bytepos
);
909 ch_len
= CHAR_BYTES (ch
);
910 pos
= BYTE_TO_CHAR (bytepos
);
911 type
= bidi_get_type (ch
, NEUTRAL_DIR
);
913 for (pos
++, bytepos
+= ch_len
;
914 /* NOTE: UAX#9 says to search only for L, AL, or R types of
915 characters, and ignore RLE, RLO, LRE, and LRO. However,
916 I'm not sure it makes sense to omit those 4; should try
917 with and without that to see the effect. */
918 (bidi_get_category (type
) != STRONG
)
919 || (bidi_ignore_explicit_marks_for_paragraph_level
920 && (type
== RLE
|| type
== RLO
921 || type
== LRE
|| type
== LRO
));
922 type
= bidi_get_type (ch
, NEUTRAL_DIR
))
924 if (type
== NEUTRAL_B
&& bidi_at_paragraph_end (pos
, bytepos
) >= -1)
926 if (bytepos
>= ZV_BYTE
)
928 /* Pretend there's a paragraph separator at end of buffer. */
932 FETCH_CHAR_ADVANCE (ch
, pos
, bytepos
);
934 if (type
== STRONG_R
|| type
== STRONG_AL
) /* P3 */
935 bidi_it
->paragraph_dir
= R2L
;
936 else if (type
== STRONG_L
)
937 bidi_it
->paragraph_dir
= L2R
;
942 /* Contrary to UAX#9 clause P3, we only default the paragraph
943 direction to L2R if we have no previous usable paragraph
945 if (bidi_it
->paragraph_dir
== NEUTRAL_DIR
)
946 bidi_it
->paragraph_dir
= L2R
; /* P3 and ``higher protocols'' */
947 if (bidi_it
->paragraph_dir
== R2L
)
948 bidi_it
->level_stack
[0].level
= 1;
950 bidi_it
->level_stack
[0].level
= 0;
952 bidi_line_init (bidi_it
);
955 /* Do whatever UAX#9 clause X8 says should be done at paragraph's
958 bidi_set_paragraph_end (struct bidi_it
*bidi_it
)
960 bidi_it
->invalid_levels
= 0;
961 bidi_it
->invalid_rl_levels
= -1;
962 bidi_it
->stack_idx
= 0;
963 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
966 /* Initialize the bidi iterator from buffer position CHARPOS. */
968 bidi_init_it (EMACS_INT charpos
, EMACS_INT bytepos
, struct bidi_it
*bidi_it
)
970 if (! bidi_initialized
)
972 bidi_it
->charpos
= charpos
;
973 bidi_it
->bytepos
= bytepos
;
974 bidi_it
->first_elt
= 1;
975 bidi_set_paragraph_end (bidi_it
);
976 bidi_it
->new_paragraph
= 1;
977 bidi_it
->separator_limit
= -1;
978 bidi_it
->type
= NEUTRAL_B
;
979 bidi_it
->type_after_w1
= NEUTRAL_B
;
980 bidi_it
->orig_type
= NEUTRAL_B
;
981 bidi_it
->prev_was_pdf
= 0;
982 bidi_it
->prev
.type
= bidi_it
->prev
.type_after_w1
=
983 bidi_it
->prev
.orig_type
= UNKNOWN_BT
;
984 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
985 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
986 bidi_it
->next_for_neutral
.charpos
= -1;
987 bidi_it
->next_for_neutral
.type
=
988 bidi_it
->next_for_neutral
.type_after_w1
=
989 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
990 bidi_it
->prev_for_neutral
.charpos
= -1;
991 bidi_it
->prev_for_neutral
.type
=
992 bidi_it
->prev_for_neutral
.type_after_w1
=
993 bidi_it
->prev_for_neutral
.orig_type
= UNKNOWN_BT
;
994 bidi_it
->sor
= L2R
; /* FIXME: should it be user-selectable? */
997 /* Push the current embedding level and override status; reset the
998 current level to LEVEL and the current override status to OVERRIDE. */
1000 bidi_push_embedding_level (struct bidi_it
*bidi_it
,
1001 int level
, bidi_dir_t override
)
1003 bidi_it
->stack_idx
++;
1004 if (bidi_it
->stack_idx
>= BIDI_MAXLEVEL
)
1006 bidi_it
->level_stack
[bidi_it
->stack_idx
].level
= level
;
1007 bidi_it
->level_stack
[bidi_it
->stack_idx
].override
= override
;
1010 /* Pop the embedding level and directional override status from the
1011 stack, and return the new level. */
1013 bidi_pop_embedding_level (struct bidi_it
*bidi_it
)
1015 /* UAX#9 says to ignore invalid PDFs. */
1016 if (bidi_it
->stack_idx
> 0)
1017 bidi_it
->stack_idx
--;
1018 return bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1021 /* Record in SAVED_INFO the information about the current character. */
1023 bidi_remember_char (struct bidi_saved_info
*saved_info
,
1024 struct bidi_it
*bidi_it
)
1026 saved_info
->charpos
= bidi_it
->charpos
;
1027 saved_info
->bytepos
= bidi_it
->bytepos
;
1028 saved_info
->type
= bidi_it
->type
;
1029 bidi_check_type (bidi_it
->type
);
1030 saved_info
->type_after_w1
= bidi_it
->type_after_w1
;
1031 bidi_check_type (bidi_it
->type_after_w1
);
1032 saved_info
->orig_type
= bidi_it
->orig_type
;
1033 bidi_check_type (bidi_it
->orig_type
);
1036 /* Resolve the type of a neutral character according to the type of
1037 surrounding strong text and the current embedding level. */
1038 static inline bidi_type_t
1039 bidi_resolve_neutral_1 (bidi_type_t prev_type
, bidi_type_t next_type
, int lev
)
1041 /* N1: European and Arabic numbers are treated as though they were R. */
1042 if (next_type
== WEAK_EN
|| next_type
== WEAK_AN
)
1043 next_type
= STRONG_R
;
1044 if (prev_type
== WEAK_EN
|| prev_type
== WEAK_AN
)
1045 prev_type
= STRONG_R
;
1047 if (next_type
== prev_type
) /* N1 */
1049 else if ((lev
& 1) == 0) /* N2 */
1056 bidi_explicit_dir_char (int c
)
1058 /* FIXME: this should be replaced with a lookup table with suitable
1059 bits set, like standard C ctype macros do. */
1060 return (c
== LRE_CHAR
|| c
== LRO_CHAR
1061 || c
== RLE_CHAR
|| c
== RLO_CHAR
|| c
== PDF_CHAR
);
1064 /* A helper function for bidi_resolve_explicit. It advances to the
1065 next character in logical order and determines the new embedding
1066 level and directional override, but does not take into account
1067 empty embeddings. */
1069 bidi_resolve_explicit_1 (struct bidi_it
*bidi_it
)
1075 bidi_dir_t override
;
1077 if (bidi_it
->bytepos
< BEGV_BYTE
/* after reseat to BEGV? */
1078 || bidi_it
->first_elt
)
1080 bidi_it
->first_elt
= 0;
1081 if (bidi_it
->charpos
< BEGV
)
1082 bidi_it
->charpos
= BEGV
;
1083 bidi_it
->bytepos
= CHAR_TO_BYTE (bidi_it
->charpos
);
1085 else if (bidi_it
->bytepos
< ZV_BYTE
) /* don't move at ZV */
1088 if (bidi_it
->ch_len
== 0)
1090 bidi_it
->bytepos
+= bidi_it
->ch_len
;
1093 current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
; /* X1 */
1094 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1095 new_level
= current_level
;
1097 /* in case it is a unibyte character (not yet implemented) */
1098 /* _fetch_multibyte_char_len = 1; */
1099 if (bidi_it
->bytepos
>= ZV_BYTE
)
1102 bidi_it
->ch_len
= 1;
1106 curchar
= FETCH_CHAR (bidi_it
->bytepos
);
1107 bidi_it
->ch_len
= CHAR_BYTES (curchar
);
1109 bidi_it
->ch
= curchar
;
1111 /* Don't apply directional override here, as all the types we handle
1112 below will not be affected by the override anyway, and we need
1113 the original type unaltered. The override will be applied in
1114 bidi_resolve_weak. */
1115 type
= bidi_get_type (curchar
, NEUTRAL_DIR
);
1116 bidi_it
->orig_type
= type
;
1117 bidi_check_type (bidi_it
->orig_type
);
1120 bidi_it
->prev_was_pdf
= 0;
1122 bidi_it
->type_after_w1
= UNKNOWN_BT
;
1128 bidi_it
->type_after_w1
= type
;
1129 bidi_check_type (bidi_it
->type_after_w1
);
1130 type
= WEAK_BN
; /* X9/Retaining */
1131 if (bidi_it
->ignore_bn_limit
<= 0)
1133 if (current_level
<= BIDI_MAXLEVEL
- 4)
1135 /* Compute the least odd embedding level greater than
1136 the current level. */
1137 new_level
= ((current_level
+ 1) & ~1) + 1;
1138 if (bidi_it
->type_after_w1
== RLE
)
1139 override
= NEUTRAL_DIR
;
1142 if (current_level
== BIDI_MAXLEVEL
- 4)
1143 bidi_it
->invalid_rl_levels
= 0;
1144 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1148 bidi_it
->invalid_levels
++;
1149 /* See the commentary about invalid_rl_levels below. */
1150 if (bidi_it
->invalid_rl_levels
< 0)
1151 bidi_it
->invalid_rl_levels
= 0;
1152 bidi_it
->invalid_rl_levels
++;
1155 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1156 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1161 bidi_it
->type_after_w1
= type
;
1162 bidi_check_type (bidi_it
->type_after_w1
);
1163 type
= WEAK_BN
; /* X9/Retaining */
1164 if (bidi_it
->ignore_bn_limit
<= 0)
1166 if (current_level
<= BIDI_MAXLEVEL
- 5)
1168 /* Compute the least even embedding level greater than
1169 the current level. */
1170 new_level
= ((current_level
+ 2) & ~1);
1171 if (bidi_it
->type_after_w1
== LRE
)
1172 override
= NEUTRAL_DIR
;
1175 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1179 bidi_it
->invalid_levels
++;
1180 /* invalid_rl_levels counts invalid levels encountered
1181 while the embedding level was already too high for
1182 LRE/LRO, but not for RLE/RLO. That is because
1183 there may be exactly one PDF which we should not
1184 ignore even though invalid_levels is non-zero.
1185 invalid_rl_levels helps to know what PDF is
1187 if (bidi_it
->invalid_rl_levels
>= 0)
1188 bidi_it
->invalid_rl_levels
++;
1191 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1192 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1196 bidi_it
->type_after_w1
= type
;
1197 bidi_check_type (bidi_it
->type_after_w1
);
1198 type
= WEAK_BN
; /* X9/Retaining */
1199 if (bidi_it
->ignore_bn_limit
<= 0)
1201 if (!bidi_it
->invalid_rl_levels
)
1203 new_level
= bidi_pop_embedding_level (bidi_it
);
1204 bidi_it
->invalid_rl_levels
= -1;
1205 if (bidi_it
->invalid_levels
)
1206 bidi_it
->invalid_levels
--;
1207 /* else nothing: UAX#9 says to ignore invalid PDFs */
1209 if (!bidi_it
->invalid_levels
)
1210 new_level
= bidi_pop_embedding_level (bidi_it
);
1213 bidi_it
->invalid_levels
--;
1214 bidi_it
->invalid_rl_levels
--;
1217 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1218 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1226 bidi_it
->type
= type
;
1227 bidi_check_type (bidi_it
->type
);
1232 /* Given an iterator state in BIDI_IT, advance one character position
1233 in the buffer to the next character (in the logical order), resolve
1234 any explicit embeddings and directional overrides, and return the
1235 embedding level of the character after resolving explicit
1236 directives and ignoring empty embeddings. */
1238 bidi_resolve_explicit (struct bidi_it
*bidi_it
)
1240 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1241 int new_level
= bidi_resolve_explicit_1 (bidi_it
);
1243 if (prev_level
< new_level
1244 && bidi_it
->type
== WEAK_BN
1245 && bidi_it
->ignore_bn_limit
== 0 /* only if not already known */
1246 && bidi_it
->bytepos
< ZV_BYTE
/* not already at EOB */
1247 && bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1248 + bidi_it
->ch_len
)))
1250 /* Avoid pushing and popping embedding levels if the level run
1251 is empty, as this breaks level runs where it shouldn't.
1252 UAX#9 removes all the explicit embedding and override codes,
1253 so empty embeddings disappear without a trace. We need to
1254 behave as if we did the same. */
1255 struct bidi_it saved_it
;
1256 int level
= prev_level
;
1258 bidi_copy_it (&saved_it
, bidi_it
);
1260 while (bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1261 + bidi_it
->ch_len
)))
1263 level
= bidi_resolve_explicit_1 (bidi_it
);
1266 if (level
== prev_level
) /* empty embedding */
1267 saved_it
.ignore_bn_limit
= bidi_it
->charpos
+ 1;
1268 else /* this embedding is non-empty */
1269 saved_it
.ignore_bn_limit
= -1;
1271 bidi_copy_it (bidi_it
, &saved_it
);
1272 if (bidi_it
->ignore_bn_limit
> 0)
1274 /* We pushed a level, but we shouldn't have. Undo that. */
1275 if (!bidi_it
->invalid_rl_levels
)
1277 new_level
= bidi_pop_embedding_level (bidi_it
);
1278 bidi_it
->invalid_rl_levels
= -1;
1279 if (bidi_it
->invalid_levels
)
1280 bidi_it
->invalid_levels
--;
1282 if (!bidi_it
->invalid_levels
)
1283 new_level
= bidi_pop_embedding_level (bidi_it
);
1286 bidi_it
->invalid_levels
--;
1287 bidi_it
->invalid_rl_levels
--;
1292 if (bidi_it
->type
== NEUTRAL_B
) /* X8 */
1294 bidi_set_paragraph_end (bidi_it
);
1295 /* This is needed by bidi_resolve_weak below, and in L1. */
1296 bidi_it
->type_after_w1
= bidi_it
->type
;
1297 bidi_check_type (bidi_it
->type_after_w1
);
1303 /* Advance in the buffer, resolve weak types and return the type of
1304 the next character after weak type resolution. */
1306 bidi_resolve_weak (struct bidi_it
*bidi_it
)
1309 bidi_dir_t override
;
1310 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1311 int new_level
= bidi_resolve_explicit (bidi_it
);
1313 bidi_type_t type_of_next
;
1314 struct bidi_it saved_it
;
1316 type
= bidi_it
->type
;
1317 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1319 if (type
== UNKNOWN_BT
1327 if (new_level
!= prev_level
1328 || bidi_it
->type
== NEUTRAL_B
)
1330 /* We've got a new embedding level run, compute the directional
1331 type of sor and initialize per-run variables (UAX#9, clause
1333 bidi_set_sor_type (bidi_it
, prev_level
, new_level
);
1335 else if (type
== NEUTRAL_S
|| type
== NEUTRAL_WS
1336 || type
== WEAK_BN
|| type
== STRONG_AL
)
1337 bidi_it
->type_after_w1
= type
; /* needed in L1 */
1338 bidi_check_type (bidi_it
->type_after_w1
);
1340 /* Level and directional override status are already recorded in
1341 bidi_it, and do not need any change; see X6. */
1342 if (override
== R2L
) /* X6 */
1344 else if (override
== L2R
)
1348 if (type
== WEAK_NSM
) /* W1 */
1350 /* Note that we don't need to consider the case where the
1351 prev character has its type overridden by an RLO or LRO,
1352 because then either the type of this NSM would have been
1353 also overridden, or the previous character is outside the
1354 current level run, and thus not relevant to this NSM.
1355 This is why NSM gets the type_after_w1 of the previous
1357 if (bidi_it
->prev
.type_after_w1
!= UNKNOWN_BT
1358 /* if type_after_w1 is NEUTRAL_B, this NSM is at sor */
1359 && bidi_it
->prev
.type_after_w1
!= NEUTRAL_B
)
1360 type
= bidi_it
->prev
.type_after_w1
;
1361 else if (bidi_it
->sor
== R2L
)
1363 else if (bidi_it
->sor
== L2R
)
1365 else /* shouldn't happen! */
1368 if (type
== WEAK_EN
/* W2 */
1369 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)
1371 else if (type
== STRONG_AL
) /* W3 */
1373 else if ((type
== WEAK_ES
/* W4 */
1374 && bidi_it
->prev
.type_after_w1
== WEAK_EN
1375 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1377 && ((bidi_it
->prev
.type_after_w1
== WEAK_EN
1378 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1379 || bidi_it
->prev
.type_after_w1
== WEAK_AN
)))
1382 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1383 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1384 type_of_next
= bidi_get_type (next_char
, override
);
1386 if (type_of_next
== WEAK_BN
1387 || bidi_explicit_dir_char (next_char
))
1389 bidi_copy_it (&saved_it
, bidi_it
);
1390 while (bidi_resolve_explicit (bidi_it
) == new_level
1391 && bidi_it
->type
== WEAK_BN
)
1393 type_of_next
= bidi_it
->type
;
1394 bidi_copy_it (bidi_it
, &saved_it
);
1397 /* If the next character is EN, but the last strong-type
1398 character is AL, that next EN will be changed to AN when
1399 we process it in W2 above. So in that case, this ES
1400 should not be changed into EN. */
1402 && type_of_next
== WEAK_EN
1403 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1405 else if (type
== WEAK_CS
)
1407 if (bidi_it
->prev
.type_after_w1
== WEAK_AN
1408 && (type_of_next
== WEAK_AN
1409 /* If the next character is EN, but the last
1410 strong-type character is AL, EN will be later
1411 changed to AN when we process it in W2 above.
1412 So in that case, this ES should not be
1414 || (type_of_next
== WEAK_EN
1415 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)))
1417 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
1418 && type_of_next
== WEAK_EN
1419 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1423 else if (type
== WEAK_ET
/* W5: ET with EN before or after it */
1424 || type
== WEAK_BN
) /* W5/Retaining */
1426 if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* ET/BN w/EN before it */
1427 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1429 else /* W5: ET/BN with EN after it. */
1431 EMACS_INT en_pos
= bidi_it
->charpos
+ 1;
1434 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1435 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1436 type_of_next
= bidi_get_type (next_char
, override
);
1438 if (type_of_next
== WEAK_ET
1439 || type_of_next
== WEAK_BN
1440 || bidi_explicit_dir_char (next_char
))
1442 bidi_copy_it (&saved_it
, bidi_it
);
1443 while (bidi_resolve_explicit (bidi_it
) == new_level
1444 && (bidi_it
->type
== WEAK_BN
1445 || bidi_it
->type
== WEAK_ET
))
1447 type_of_next
= bidi_it
->type
;
1448 en_pos
= bidi_it
->charpos
;
1449 bidi_copy_it (bidi_it
, &saved_it
);
1451 if (type_of_next
== WEAK_EN
)
1453 /* If the last strong character is AL, the EN we've
1454 found will become AN when we get to it (W2). */
1455 if (bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1458 /* Remember this EN position, to speed up processing
1460 bidi_it
->next_en_pos
= en_pos
;
1462 else if (type
== WEAK_BN
)
1463 type
= NEUTRAL_ON
; /* W6/Retaining */
1469 if (type
== WEAK_ES
|| type
== WEAK_ET
|| type
== WEAK_CS
/* W6 */
1471 && (bidi_it
->prev
.type_after_w1
== WEAK_CS
/* W6/Retaining */
1472 || bidi_it
->prev
.type_after_w1
== WEAK_ES
1473 || bidi_it
->prev
.type_after_w1
== WEAK_ET
)))
1476 /* Store the type we've got so far, before we clobber it with strong
1477 types in W7 and while resolving neutral types. But leave alone
1478 the original types that were recorded above, because we will need
1479 them for the L1 clause. */
1480 if (bidi_it
->type_after_w1
== UNKNOWN_BT
)
1481 bidi_it
->type_after_w1
= type
;
1482 bidi_check_type (bidi_it
->type_after_w1
);
1484 if (type
== WEAK_EN
) /* W7 */
1486 if ((bidi_it
->last_strong
.type_after_w1
== STRONG_L
)
1487 || (bidi_it
->last_strong
.type
== UNKNOWN_BT
&& bidi_it
->sor
== L2R
))
1491 bidi_it
->type
= type
;
1492 bidi_check_type (bidi_it
->type
);
1497 bidi_resolve_neutral (struct bidi_it
*bidi_it
)
1499 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1500 bidi_type_t type
= bidi_resolve_weak (bidi_it
);
1501 int current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1503 if (!(type
== STRONG_R
1508 || type
== NEUTRAL_B
1509 || type
== NEUTRAL_S
1510 || type
== NEUTRAL_WS
1511 || type
== NEUTRAL_ON
))
1514 if (bidi_get_category (type
) == NEUTRAL
1515 || (type
== WEAK_BN
&& prev_level
== current_level
))
1517 if (bidi_it
->next_for_neutral
.type
!= UNKNOWN_BT
)
1518 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1519 bidi_it
->next_for_neutral
.type
,
1523 /* Arrrgh!! The UAX#9 algorithm is too deeply entrenched in
1524 the assumption of batch-style processing; see clauses W4,
1525 W5, and especially N1, which require to look far forward
1526 (as well as back) in the buffer. May the fleas of a
1527 thousand camels infest the armpits of those who design
1528 supposedly general-purpose algorithms by looking at their
1529 own implementations, and fail to consider other possible
1531 struct bidi_it saved_it
;
1532 bidi_type_t next_type
;
1534 if (bidi_it
->scan_dir
== -1)
1537 bidi_copy_it (&saved_it
, bidi_it
);
1538 /* Scan the text forward until we find the first non-neutral
1539 character, and then use that to resolve the neutral we
1540 are dealing with now. We also cache the scanned iterator
1541 states, to salvage some of the effort later. */
1542 bidi_cache_iterator_state (bidi_it
, 0);
1544 /* Record the info about the previous character, so that
1545 it will be cached below with this state. */
1546 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1547 && bidi_it
->type
!= WEAK_BN
)
1548 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1549 type
= bidi_resolve_weak (bidi_it
);
1550 /* Paragraph separators have their levels fully resolved
1551 at this point, so cache them as resolved. */
1552 bidi_cache_iterator_state (bidi_it
, type
== NEUTRAL_B
);
1553 /* FIXME: implement L1 here, by testing for a newline and
1554 resetting the level for any sequence of whitespace
1555 characters adjacent to it. */
1556 } while (!(type
== NEUTRAL_B
1558 && bidi_get_category (type
) != NEUTRAL
)
1559 /* This is all per level run, so stop when we
1560 reach the end of this level run. */
1561 || bidi_it
->level_stack
[bidi_it
->stack_idx
].level
!=
1564 bidi_remember_char (&saved_it
.next_for_neutral
, bidi_it
);
1575 /* N1: ``European and Arabic numbers are treated as
1576 though they were R.'' */
1577 next_type
= STRONG_R
;
1578 saved_it
.next_for_neutral
.type
= STRONG_R
;
1581 if (!bidi_explicit_dir_char (bidi_it
->ch
))
1582 abort (); /* can't happen: BNs are skipped */
1585 /* Marched all the way to the end of this level run.
1586 We need to use the eor type, whose information is
1587 stored by bidi_set_sor_type in the prev_for_neutral
1589 if (saved_it
.type
!= WEAK_BN
1590 || bidi_get_category (bidi_it
->prev
.type_after_w1
) == NEUTRAL
)
1592 next_type
= bidi_it
->prev_for_neutral
.type
;
1593 saved_it
.next_for_neutral
.type
= next_type
;
1594 bidi_check_type (next_type
);
1598 /* This is a BN which does not adjoin neutrals.
1599 Leave its type alone. */
1600 bidi_copy_it (bidi_it
, &saved_it
);
1601 return bidi_it
->type
;
1607 type
= bidi_resolve_neutral_1 (saved_it
.prev_for_neutral
.type
,
1608 next_type
, current_level
);
1609 saved_it
.type
= type
;
1610 bidi_check_type (type
);
1611 bidi_copy_it (bidi_it
, &saved_it
);
1617 /* Given an iterator state in BIDI_IT, advance one character position
1618 in the buffer to the next character (in the logical order), resolve
1619 the bidi type of that next character, and return that type. */
1621 bidi_type_of_next_char (struct bidi_it
*bidi_it
)
1625 /* This should always be called during a forward scan. */
1626 if (bidi_it
->scan_dir
!= 1)
1629 /* Reset the limit until which to ignore BNs if we step out of the
1630 area where we found only empty levels. */
1631 if ((bidi_it
->ignore_bn_limit
> 0
1632 && bidi_it
->ignore_bn_limit
<= bidi_it
->charpos
)
1633 || (bidi_it
->ignore_bn_limit
== -1
1634 && !bidi_explicit_dir_char (bidi_it
->ch
)))
1635 bidi_it
->ignore_bn_limit
= 0;
1637 type
= bidi_resolve_neutral (bidi_it
);
1642 /* Given an iterator state BIDI_IT, advance one character position in
1643 the buffer to the next character (in the logical order), resolve
1644 the embedding and implicit levels of that next character, and
1645 return the resulting level. */
1647 bidi_level_of_next_char (struct bidi_it
*bidi_it
)
1650 int level
, prev_level
= -1;
1651 struct bidi_saved_info next_for_neutral
;
1653 if (bidi_it
->scan_dir
== 1)
1655 /* There's no sense in trying to advance if we hit end of text. */
1656 if (bidi_it
->bytepos
>= ZV_BYTE
)
1657 return bidi_it
->resolved_level
;
1659 /* Record the info about the previous character. */
1660 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1661 && bidi_it
->type
!= WEAK_BN
)
1662 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1663 if (bidi_it
->type_after_w1
== STRONG_R
1664 || bidi_it
->type_after_w1
== STRONG_L
1665 || bidi_it
->type_after_w1
== STRONG_AL
)
1666 bidi_remember_char (&bidi_it
->last_strong
, bidi_it
);
1667 /* FIXME: it sounds like we don't need both prev and
1668 prev_for_neutral members, but I'm leaving them both for now. */
1669 if (bidi_it
->type
== STRONG_R
|| bidi_it
->type
== STRONG_L
1670 || bidi_it
->type
== WEAK_EN
|| bidi_it
->type
== WEAK_AN
)
1671 bidi_remember_char (&bidi_it
->prev_for_neutral
, bidi_it
);
1673 /* If we overstepped the characters used for resolving neutrals
1674 and whitespace, invalidate their info in the iterator. */
1675 if (bidi_it
->charpos
>= bidi_it
->next_for_neutral
.charpos
)
1676 bidi_it
->next_for_neutral
.type
= UNKNOWN_BT
;
1677 if (bidi_it
->next_en_pos
>= 0
1678 && bidi_it
->charpos
>= bidi_it
->next_en_pos
)
1679 bidi_it
->next_en_pos
= -1;
1680 if (bidi_it
->next_for_ws
.type
!= UNKNOWN_BT
1681 && bidi_it
->charpos
>= bidi_it
->next_for_ws
.charpos
)
1682 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
1684 /* This must be taken before we fill the iterator with the info
1685 about the next char. If we scan backwards, the iterator
1686 state must be already cached, so there's no need to know the
1687 embedding level of the previous character, since we will be
1688 returning to our caller shortly. */
1689 prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1691 next_for_neutral
= bidi_it
->next_for_neutral
;
1693 /* Perhaps it is already cached. */
1694 type
= bidi_cache_find (bidi_it
->charpos
+ bidi_it
->scan_dir
, -1, bidi_it
);
1695 if (type
!= UNKNOWN_BT
)
1697 /* Don't lose the information for resolving neutrals! The
1698 cached states could have been cached before their
1699 next_for_neutral member was computed. If we are on our way
1700 forward, we can simply take the info from the previous
1702 if (bidi_it
->scan_dir
== 1
1703 && bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1704 bidi_it
->next_for_neutral
= next_for_neutral
;
1706 /* If resolved_level is -1, it means this state was cached
1707 before it was completely resolved, so we cannot return
1709 if (bidi_it
->resolved_level
!= -1)
1710 return bidi_it
->resolved_level
;
1712 if (bidi_it
->scan_dir
== -1)
1713 /* If we are going backwards, the iterator state is already cached
1714 from previous scans, and should be fully resolved. */
1717 if (type
== UNKNOWN_BT
)
1718 type
= bidi_type_of_next_char (bidi_it
);
1720 if (type
== NEUTRAL_B
)
1721 return bidi_it
->resolved_level
;
1723 level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1724 if ((bidi_get_category (type
) == NEUTRAL
/* && type != NEUTRAL_B */)
1725 || (type
== WEAK_BN
&& prev_level
== level
))
1727 if (bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1730 /* If the cached state shows a neutral character, it was not
1731 resolved by bidi_resolve_neutral, so do it now. */
1732 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1733 bidi_it
->next_for_neutral
.type
,
1737 if (!(type
== STRONG_R
1741 || type
== WEAK_AN
))
1743 bidi_it
->type
= type
;
1744 bidi_check_type (bidi_it
->type
);
1746 /* For L1 below, we need to know, for each WS character, whether
1747 it belongs to a sequence of WS characters preceeding a newline
1748 or a TAB or a paragraph separator. */
1749 if (bidi_it
->orig_type
== NEUTRAL_WS
1750 && bidi_it
->next_for_ws
.type
== UNKNOWN_BT
)
1753 int clen
= bidi_it
->ch_len
;
1754 EMACS_INT bpos
= bidi_it
->bytepos
;
1755 EMACS_INT cpos
= bidi_it
->charpos
;
1759 /*_fetch_multibyte_char_len = 1;*/
1760 ch
= bpos
+ clen
>= ZV_BYTE
? BIDI_EOB
: FETCH_CHAR (bpos
+ clen
);
1763 clen
= (ch
== BIDI_EOB
? 1 : CHAR_BYTES (ch
));
1764 if (ch
== '\n' || ch
== BIDI_EOB
/* || ch == LINESEP_CHAR */)
1767 chtype
= bidi_get_type (ch
, NEUTRAL_DIR
);
1768 } while (chtype
== NEUTRAL_WS
|| chtype
== WEAK_BN
1769 || bidi_explicit_dir_char (ch
)); /* L1/Retaining */
1770 bidi_it
->next_for_ws
.type
= chtype
;
1771 bidi_check_type (bidi_it
->next_for_ws
.type
);
1772 bidi_it
->next_for_ws
.charpos
= cpos
;
1773 bidi_it
->next_for_ws
.bytepos
= bpos
;
1776 /* Resolve implicit levels, with a twist: PDFs get the embedding
1777 level of the enbedding they terminate. See below for the
1779 if (bidi_it
->orig_type
== PDF
1780 /* Don't do this if this formatting code didn't change the
1781 embedding level due to invalid or empty embeddings. */
1782 && prev_level
!= level
)
1784 /* Don't look in UAX#9 for the reason for this: it's our own
1785 private quirk. The reason is that we want the formatting
1786 codes to be delivered so that they bracket the text of their
1787 embedding. For example, given the text
1791 we want it to be displayed as
1799 which will result because we bump up the embedding level as
1800 soon as we see the RLO and pop it as soon as we see the PDF,
1801 so RLO itself has the same embedding level as "teST", and
1802 thus would be normally delivered last, just before the PDF.
1803 The switch below fiddles with the level of PDF so that this
1804 ugly side effect does not happen.
1806 (This is, of course, only important if the formatting codes
1807 are actually displayed, but Emacs does need to display them
1808 if the user wants to.) */
1811 else if (bidi_it
->orig_type
== NEUTRAL_B
/* L1 */
1812 || bidi_it
->orig_type
== NEUTRAL_S
1813 || bidi_it
->ch
== '\n' || bidi_it
->ch
== BIDI_EOB
1814 /* || bidi_it->ch == LINESEP_CHAR */
1815 || (bidi_it
->orig_type
== NEUTRAL_WS
1816 && (bidi_it
->next_for_ws
.type
== NEUTRAL_B
1817 || bidi_it
->next_for_ws
.type
== NEUTRAL_S
)))
1818 level
= bidi_it
->level_stack
[0].level
;
1819 else if ((level
& 1) == 0) /* I1 */
1821 if (type
== STRONG_R
)
1823 else if (type
== WEAK_EN
|| type
== WEAK_AN
)
1828 if (type
== STRONG_L
|| type
== WEAK_EN
|| type
== WEAK_AN
)
1832 bidi_it
->resolved_level
= level
;
1836 /* Move to the other edge of a level given by LEVEL. If END_FLAG is
1837 non-zero, we are at the end of a level, and we need to prepare to
1838 resume the scan of the lower level.
1840 If this level's other edge is cached, we simply jump to it, filling
1841 the iterator structure with the iterator state on the other edge.
1842 Otherwise, we walk the buffer until we come back to the same level
1845 Note: we are not talking here about a ``level run'' in the UAX#9
1846 sense of the term, but rather about a ``level'' which includes
1847 all the levels higher than it. In other words, given the levels
1850 11111112222222333333334443343222222111111112223322111
1853 and assuming we are at point A scanning left to right, this
1854 function moves to point C, whereas the UAX#9 ``level 2 run'' ends
1857 bidi_find_other_level_edge (struct bidi_it
*bidi_it
, int level
, int end_flag
)
1859 int dir
= end_flag
? -bidi_it
->scan_dir
: bidi_it
->scan_dir
;
1862 /* Try the cache first. */
1863 if ((idx
= bidi_cache_find_level_change (level
, dir
, end_flag
)) >= 0)
1864 bidi_cache_fetch_state (idx
, bidi_it
);
1870 abort (); /* if we are at end of level, its edges must be cached */
1872 bidi_cache_iterator_state (bidi_it
, 1);
1874 new_level
= bidi_level_of_next_char (bidi_it
);
1875 bidi_cache_iterator_state (bidi_it
, 1);
1876 } while (new_level
>= level
);
1881 bidi_get_next_char_visually (struct bidi_it
*bidi_it
)
1883 int old_level
, new_level
, next_level
;
1884 struct bidi_it sentinel
;
1886 if (bidi_it
->scan_dir
== 0)
1888 bidi_it
->scan_dir
= 1; /* default to logical order */
1891 /* If we just passed a newline, initialize for the next line. */
1892 if (!bidi_it
->first_elt
&& bidi_it
->orig_type
== NEUTRAL_B
)
1893 bidi_line_init (bidi_it
);
1895 /* Prepare the sentinel iterator state. */
1896 if (bidi_cache_idx
== 0)
1898 bidi_copy_it (&sentinel
, bidi_it
);
1899 if (bidi_it
->first_elt
)
1901 sentinel
.charpos
--; /* cached charpos needs to be monotonic */
1903 sentinel
.ch
= '\n'; /* doesn't matter, but why not? */
1904 sentinel
.ch_len
= 1;
1908 old_level
= bidi_it
->resolved_level
;
1909 new_level
= bidi_level_of_next_char (bidi_it
);
1911 /* Reordering of resolved levels (clause L2) is implemented by
1912 jumping to the other edge of the level and flipping direction of
1913 scanning the text whenever we find a level change. */
1914 if (new_level
!= old_level
)
1916 int ascending
= new_level
> old_level
;
1917 int level_to_search
= ascending
? old_level
+ 1 : old_level
;
1918 int incr
= ascending
? 1 : -1;
1919 int expected_next_level
= old_level
+ incr
;
1921 /* If we don't have anything cached yet, we need to cache the
1922 sentinel state, since we'll need it to record where to jump
1923 when the last non-base level is exhausted. */
1924 if (bidi_cache_idx
== 0)
1925 bidi_cache_iterator_state (&sentinel
, 1);
1926 /* Jump (or walk) to the other edge of this level. */
1927 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1928 /* Switch scan direction and peek at the next character in the
1930 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1932 /* The following loop handles the case where the resolved level
1933 jumps by more than one. This is typical for numbers inside a
1934 run of text with left-to-right embedding direction, but can
1935 also happen in other situations. In those cases the decision
1936 where to continue after a level change, and in what direction,
1937 is tricky. For example, given a text like below:
1942 (where the numbers below the text show the resolved levels),
1943 the result of reordering according to UAX#9 should be this:
1947 This is implemented by the loop below which flips direction
1948 and jumps to the other edge of the level each time it finds
1949 the new level not to be the expected one. The expected level
1950 is always one more or one less than the previous one. */
1951 next_level
= bidi_peek_at_next_level (bidi_it
);
1952 while (next_level
!= expected_next_level
)
1954 expected_next_level
+= incr
;
1955 level_to_search
+= incr
;
1956 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1957 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1958 next_level
= bidi_peek_at_next_level (bidi_it
);
1961 /* Finally, deliver the next character in the new direction. */
1962 next_level
= bidi_level_of_next_char (bidi_it
);
1965 /* Take note when we have just processed the newline that precedes
1966 the end of the paragraph. The next time we are about to be
1967 called, set_iterator_to_next will automatically reinit the
1968 paragraph direction, if needed. We do this at the newline before
1969 the paragraph separator, because the next character might not be
1970 the first character of the next paragraph, due to the bidi
1971 reordering, whereas we _must_ know the paragraph base direction
1972 _before_ we process the paragraph's text, since the base
1973 direction affects the reordering. */
1974 if (bidi_it
->scan_dir
== 1
1975 && bidi_it
->orig_type
== NEUTRAL_B
1976 && bidi_it
->bytepos
< ZV_BYTE
)
1979 bidi_at_paragraph_end (bidi_it
->charpos
+ 1,
1980 bidi_it
->bytepos
+ bidi_it
->ch_len
);
1983 bidi_it
->new_paragraph
= 1;
1984 /* Record the buffer position of the last character of the
1985 paragraph separator. */
1986 bidi_it
->separator_limit
= bidi_it
->charpos
+ 1 + sep_len
;
1990 if (bidi_it
->scan_dir
== 1 && bidi_cache_idx
)
1992 /* If we are at paragraph's base embedding level and beyond the
1993 last cached position, the cache's job is done and we can
1995 if (bidi_it
->resolved_level
== bidi_it
->level_stack
[0].level
1996 && bidi_it
->charpos
> bidi_cache
[bidi_cache_idx
- 1].charpos
)
1997 bidi_cache_reset ();
1998 /* But as long as we are caching during forward scan, we must
1999 cache each state, or else the cache integrity will be
2000 compromised: it assumes cached states correspond to buffer
2003 bidi_cache_iterator_state (bidi_it
, 1);
2007 /* This is meant to be called from within the debugger, whenever you
2008 wish to examine the cache contents. */
2010 bidi_dump_cached_states (void)
2015 if (bidi_cache_idx
== 0)
2017 fprintf (stderr
, "The cache is empty.\n");
2020 fprintf (stderr
, "Total of %d state%s in cache:\n",
2021 bidi_cache_idx
, bidi_cache_idx
== 1 ? "" : "s");
2023 for (i
= bidi_cache
[bidi_cache_idx
- 1].charpos
; i
> 0; i
/= 10)
2025 fputs ("ch ", stderr
);
2026 for (i
= 0; i
< bidi_cache_idx
; i
++)
2027 fprintf (stderr
, "%*c", ndigits
, bidi_cache
[i
].ch
);
2028 fputs ("\n", stderr
);
2029 fputs ("lvl ", stderr
);
2030 for (i
= 0; i
< bidi_cache_idx
; i
++)
2031 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].resolved_level
);
2032 fputs ("\n", stderr
);
2033 fputs ("pos ", stderr
);
2034 for (i
= 0; i
< bidi_cache_idx
; i
++)
2035 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].charpos
);
2036 fputs ("\n", stderr
);