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 /* Don't violate cache integrity: character positions should
675 correspond to cache positions 1:1. */
676 if (idx
> 0 && bidi_it
->charpos
!= bidi_cache
[idx
- 1].charpos
+ 1)
678 bidi_copy_it (&bidi_cache
[idx
], bidi_it
);
680 bidi_cache
[idx
].resolved_level
= -1;
681 bidi_cache
[idx
].new_paragraph
= 0;
685 /* Copy only the members which could have changed, to avoid
686 costly copying of the entire struct. */
687 bidi_cache
[idx
].type
= bidi_it
->type
;
688 bidi_check_type (bidi_it
->type
);
689 bidi_cache
[idx
].type_after_w1
= bidi_it
->type_after_w1
;
690 bidi_check_type (bidi_it
->type_after_w1
);
692 bidi_cache
[idx
].resolved_level
= bidi_it
->resolved_level
;
694 bidi_cache
[idx
].resolved_level
= -1;
695 bidi_cache
[idx
].invalid_levels
= bidi_it
->invalid_levels
;
696 bidi_cache
[idx
].invalid_rl_levels
= bidi_it
->invalid_rl_levels
;
697 bidi_cache
[idx
].next_for_neutral
= bidi_it
->next_for_neutral
;
698 bidi_cache
[idx
].next_for_ws
= bidi_it
->next_for_ws
;
699 bidi_cache
[idx
].ignore_bn_limit
= bidi_it
->ignore_bn_limit
;
702 bidi_cache_last_idx
= idx
;
703 if (idx
>= bidi_cache_idx
)
704 bidi_cache_idx
= idx
+ 1;
707 static inline bidi_type_t
708 bidi_cache_find (int charpos
, int level
, struct bidi_it
*bidi_it
)
710 int i
= bidi_cache_search (charpos
, level
, bidi_it
->scan_dir
);
714 bidi_dir_t current_scan_dir
= bidi_it
->scan_dir
;
716 bidi_copy_it (bidi_it
, &bidi_cache
[i
]);
717 bidi_cache_last_idx
= i
;
718 /* Don't let scan direction from from the cached state override
719 the current scan direction. */
720 bidi_it
->scan_dir
= current_scan_dir
;
721 return bidi_it
->type
;
728 bidi_peek_at_next_level (struct bidi_it
*bidi_it
)
730 if (bidi_cache_idx
== 0 || bidi_cache_last_idx
== -1)
732 return bidi_cache
[bidi_cache_last_idx
+ bidi_it
->scan_dir
].resolved_level
;
735 /* Check if buffer position CHARPOS/BYTEPOS is the end of a paragraph.
736 Value is the non-negative length of the paragraph separator
737 following the buffer position, -1 if position is at the beginning
738 of a new paragraph, or -2 if position is neither at beginning nor
739 at end of a paragraph. */
741 bidi_at_paragraph_end (EMACS_INT charpos
, EMACS_INT bytepos
)
743 Lisp_Object sep_re
= Fbuffer_local_value (Qparagraph_separate
,
745 Lisp_Object start_re
= Fbuffer_local_value (Qparagraph_start
,
749 if (!STRINGP (sep_re
))
750 sep_re
= fallback_paragraph_separate_re
;
751 if (!STRINGP (start_re
))
752 start_re
= fallback_paragraph_start_re
;
754 val
= fast_looking_at (sep_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
);
757 if (fast_looking_at (start_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) >= 0)
766 /* Determine the start-of-run (sor) directional type given the two
767 embedding levels on either side of the run boundary. Also, update
768 the saved info about previously seen characters, since that info is
769 generally valid for a single level run. */
771 bidi_set_sor_type (struct bidi_it
*bidi_it
, int level_before
, int level_after
)
773 int higher_level
= level_before
> level_after
? level_before
: level_after
;
775 /* The prev_was_pdf gork is required for when we have several PDFs
776 in a row. In that case, we want to compute the sor type for the
777 next level run only once: when we see the first PDF. That's
778 because the sor type depends only on the higher of the two levels
779 that we find on the two sides of the level boundary (see UAX#9,
780 clause X10), and so we don't need to know the final embedding
781 level to which we descend after processing all the PDFs. */
782 if (!bidi_it
->prev_was_pdf
|| level_before
< level_after
)
783 /* FIXME: should the default sor direction be user selectable? */
784 bidi_it
->sor
= (higher_level
& 1) != 0 ? R2L
: L2R
;
785 if (level_before
> level_after
)
786 bidi_it
->prev_was_pdf
= 1;
788 bidi_it
->prev
.type
= UNKNOWN_BT
;
789 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
790 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
791 bidi_it
->prev_for_neutral
.type
= bidi_it
->sor
== R2L
? STRONG_R
: STRONG_L
;
792 bidi_it
->prev_for_neutral
.charpos
= bidi_it
->charpos
;
793 bidi_it
->prev_for_neutral
.bytepos
= bidi_it
->bytepos
;
794 bidi_it
->next_for_neutral
.type
= bidi_it
->next_for_neutral
.type_after_w1
=
795 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
796 bidi_it
->ignore_bn_limit
= 0; /* meaning it's unknown */
800 bidi_line_init (struct bidi_it
*bidi_it
)
802 bidi_it
->scan_dir
= 1; /* FIXME: do we need to have control on this? */
803 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
804 bidi_it
->level_stack
[0].override
= NEUTRAL_DIR
; /* X1 */
805 bidi_it
->invalid_levels
= 0;
806 bidi_it
->invalid_rl_levels
= -1;
807 bidi_it
->next_en_pos
= -1;
808 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
809 bidi_set_sor_type (bidi_it
,
810 bidi_it
->paragraph_dir
== R2L
? 1 : 0,
811 bidi_it
->level_stack
[0].level
); /* X10 */
816 /* Find the beginning of this paragraph by looking back in the buffer.
817 Value is the byte position of the paragraph's beginning. */
819 bidi_find_paragraph_start (EMACS_INT pos
, EMACS_INT pos_byte
)
821 Lisp_Object re
= Fbuffer_local_value (Qparagraph_start
, Fcurrent_buffer ());
822 EMACS_INT limit
= ZV
, limit_byte
= ZV_BYTE
;
825 re
= fallback_paragraph_start_re
;
826 while (pos_byte
> BEGV_BYTE
827 && fast_looking_at (re
, pos
, pos_byte
, limit
, limit_byte
, Qnil
) < 0)
829 pos
= find_next_newline_no_quit (pos
- 1, -1);
830 pos_byte
= CHAR_TO_BYTE (pos
);
835 /* Determine the direction, a.k.a. base embedding level, of the
836 paragraph we are about to iterate through. If DIR is either L2R or
837 R2L, just use that. Otherwise, determine the paragraph direction
838 from the first strong character of the paragraph.
840 Note that this gives the paragraph separator the same direction as
841 the preceding paragraph, even though Emacs generally views the
842 separartor as not belonging to any paragraph. */
844 bidi_paragraph_init (bidi_dir_t dir
, struct bidi_it
*bidi_it
)
846 EMACS_INT bytepos
= bidi_it
->bytepos
;
848 /* Special case for an empty buffer. */
849 if (bytepos
== BEGV_BYTE
&& bytepos
== ZV_BYTE
)
851 /* We should never be called at EOB or before BEGV. */
852 else if (bytepos
>= ZV_BYTE
|| bytepos
< BEGV_BYTE
)
857 bidi_it
->paragraph_dir
= L2R
;
858 bidi_it
->new_paragraph
= 0;
862 bidi_it
->paragraph_dir
= R2L
;
863 bidi_it
->new_paragraph
= 0;
865 else if (dir
== NEUTRAL_DIR
) /* P2 */
872 /* If we are inside a paragraph separator, we are just waiting
873 for the separator to be exhausted; use the previous paragraph
874 direction. But don't do that if we have been just reseated,
875 because we need to reinitialize below in that case. */
876 if (!bidi_it
->first_elt
877 && bidi_it
->charpos
< bidi_it
->separator_limit
)
880 /* If we are on a newline, get past it to where the next
881 paragraph might start. But don't do that at BEGV since then
882 we are potentially in a new paragraph that doesn't yet
884 pos
= bidi_it
->charpos
;
885 if (bytepos
> BEGV_BYTE
&& FETCH_CHAR (bytepos
) == '\n')
891 /* We are either at the beginning of a paragraph or in the
892 middle of it. Find where this paragraph starts. */
893 bytepos
= bidi_find_paragraph_start (pos
, bytepos
);
895 /* We should always be at the beginning of a new line at this
897 if (!(bytepos
== BEGV_BYTE
|| FETCH_CHAR (bytepos
- 1) == '\n'))
900 bidi_it
->separator_limit
= -1;
901 bidi_it
->new_paragraph
= 0;
902 ch
= FETCH_CHAR (bytepos
);
903 ch_len
= CHAR_BYTES (ch
);
904 pos
= BYTE_TO_CHAR (bytepos
);
905 type
= bidi_get_type (ch
, NEUTRAL_DIR
);
907 for (pos
++, bytepos
+= ch_len
;
908 /* NOTE: UAX#9 says to search only for L, AL, or R types of
909 characters, and ignore RLE, RLO, LRE, and LRO. However,
910 I'm not sure it makes sense to omit those 4; should try
911 with and without that to see the effect. */
912 (bidi_get_category (type
) != STRONG
)
913 || (bidi_ignore_explicit_marks_for_paragraph_level
914 && (type
== RLE
|| type
== RLO
915 || type
== LRE
|| type
== LRO
));
916 type
= bidi_get_type (ch
, NEUTRAL_DIR
))
918 if (type
== NEUTRAL_B
&& bidi_at_paragraph_end (pos
, bytepos
) >= -1)
920 if (bytepos
>= ZV_BYTE
)
922 /* Pretend there's a paragraph separator at end of buffer. */
926 FETCH_CHAR_ADVANCE (ch
, pos
, bytepos
);
928 if (type
== STRONG_R
|| type
== STRONG_AL
) /* P3 */
929 bidi_it
->paragraph_dir
= R2L
;
930 else if (type
== STRONG_L
)
931 bidi_it
->paragraph_dir
= L2R
;
936 /* Contrary to UAX#9 clause P3, we only default the paragraph
937 direction to L2R if we have no previous usable paragraph
939 if (bidi_it
->paragraph_dir
== NEUTRAL_DIR
)
940 bidi_it
->paragraph_dir
= L2R
; /* P3 and ``higher protocols'' */
941 if (bidi_it
->paragraph_dir
== R2L
)
942 bidi_it
->level_stack
[0].level
= 1;
944 bidi_it
->level_stack
[0].level
= 0;
946 bidi_line_init (bidi_it
);
949 /* Do whatever UAX#9 clause X8 says should be done at paragraph's
952 bidi_set_paragraph_end (struct bidi_it
*bidi_it
)
954 bidi_it
->invalid_levels
= 0;
955 bidi_it
->invalid_rl_levels
= -1;
956 bidi_it
->stack_idx
= 0;
957 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
960 /* Initialize the bidi iterator from buffer position CHARPOS. */
962 bidi_init_it (EMACS_INT charpos
, EMACS_INT bytepos
, struct bidi_it
*bidi_it
)
964 if (! bidi_initialized
)
966 bidi_it
->charpos
= charpos
;
967 bidi_it
->bytepos
= bytepos
;
968 bidi_it
->first_elt
= 1;
969 bidi_set_paragraph_end (bidi_it
);
970 bidi_it
->new_paragraph
= 1;
971 bidi_it
->separator_limit
= -1;
972 bidi_it
->type
= NEUTRAL_B
;
973 bidi_it
->type_after_w1
= UNKNOWN_BT
;
974 bidi_it
->orig_type
= UNKNOWN_BT
;
975 bidi_it
->prev_was_pdf
= 0;
976 bidi_it
->prev
.type
= bidi_it
->prev
.type_after_w1
= UNKNOWN_BT
;
977 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
978 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
979 bidi_it
->next_for_neutral
.charpos
= -1;
980 bidi_it
->next_for_neutral
.type
=
981 bidi_it
->next_for_neutral
.type_after_w1
=
982 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
983 bidi_it
->prev_for_neutral
.charpos
= -1;
984 bidi_it
->prev_for_neutral
.type
=
985 bidi_it
->prev_for_neutral
.type_after_w1
=
986 bidi_it
->prev_for_neutral
.orig_type
= UNKNOWN_BT
;
987 bidi_it
->sor
= L2R
; /* FIXME: should it be user-selectable? */
990 /* Push the current embedding level and override status; reset the
991 current level to LEVEL and the current override status to OVERRIDE. */
993 bidi_push_embedding_level (struct bidi_it
*bidi_it
,
994 int level
, bidi_dir_t override
)
996 bidi_it
->stack_idx
++;
997 if (bidi_it
->stack_idx
>= BIDI_MAXLEVEL
)
999 bidi_it
->level_stack
[bidi_it
->stack_idx
].level
= level
;
1000 bidi_it
->level_stack
[bidi_it
->stack_idx
].override
= override
;
1003 /* Pop the embedding level and directional override status from the
1004 stack, and return the new level. */
1006 bidi_pop_embedding_level (struct bidi_it
*bidi_it
)
1008 /* UAX#9 says to ignore invalid PDFs. */
1009 if (bidi_it
->stack_idx
> 0)
1010 bidi_it
->stack_idx
--;
1011 return bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1014 /* Record in SAVED_INFO the information about the current character. */
1016 bidi_remember_char (struct bidi_saved_info
*saved_info
,
1017 struct bidi_it
*bidi_it
)
1019 saved_info
->charpos
= bidi_it
->charpos
;
1020 saved_info
->bytepos
= bidi_it
->bytepos
;
1021 saved_info
->type
= bidi_it
->type
;
1022 bidi_check_type (bidi_it
->type
);
1023 saved_info
->type_after_w1
= bidi_it
->type_after_w1
;
1024 bidi_check_type (bidi_it
->type_after_w1
);
1025 saved_info
->orig_type
= bidi_it
->orig_type
;
1026 bidi_check_type (bidi_it
->orig_type
);
1029 /* Resolve the type of a neutral character according to the type of
1030 surrounding strong text and the current embedding level. */
1031 static inline bidi_type_t
1032 bidi_resolve_neutral_1 (bidi_type_t prev_type
, bidi_type_t next_type
, int lev
)
1034 /* N1: European and Arabic numbers are treated as though they were R. */
1035 if (next_type
== WEAK_EN
|| next_type
== WEAK_AN
)
1036 next_type
= STRONG_R
;
1037 if (prev_type
== WEAK_EN
|| prev_type
== WEAK_AN
)
1038 prev_type
= STRONG_R
;
1040 if (next_type
== prev_type
) /* N1 */
1042 else if ((lev
& 1) == 0) /* N2 */
1049 bidi_explicit_dir_char (int c
)
1051 /* FIXME: this should be replaced with a lookup table with suitable
1052 bits set, like standard C ctype macros do. */
1053 return (c
== LRE_CHAR
|| c
== LRO_CHAR
1054 || c
== RLE_CHAR
|| c
== RLO_CHAR
|| c
== PDF_CHAR
);
1057 /* A helper function for bidi_resolve_explicit. It advances to the
1058 next character in logical order and determines the new embedding
1059 level and directional override, but does not take into account
1060 empty embeddings. */
1062 bidi_resolve_explicit_1 (struct bidi_it
*bidi_it
)
1068 bidi_dir_t override
;
1070 if (bidi_it
->bytepos
< BEGV_BYTE
/* after reseat to BEGV? */
1071 || bidi_it
->first_elt
)
1073 bidi_it
->first_elt
= 0;
1074 if (bidi_it
->charpos
< BEGV
)
1075 bidi_it
->charpos
= BEGV
;
1076 bidi_it
->bytepos
= CHAR_TO_BYTE (bidi_it
->charpos
);
1078 else if (bidi_it
->bytepos
< ZV_BYTE
) /* don't move at ZV */
1081 if (bidi_it
->ch_len
== 0)
1083 bidi_it
->bytepos
+= bidi_it
->ch_len
;
1086 current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
; /* X1 */
1087 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1088 new_level
= current_level
;
1090 /* in case it is a unibyte character (not yet implemented) */
1091 /* _fetch_multibyte_char_len = 1; */
1092 if (bidi_it
->bytepos
>= ZV_BYTE
)
1095 bidi_it
->ch_len
= 1;
1099 curchar
= FETCH_CHAR (bidi_it
->bytepos
);
1100 bidi_it
->ch_len
= CHAR_BYTES (curchar
);
1102 bidi_it
->ch
= curchar
;
1104 /* Don't apply directional override here, as all the types we handle
1105 below will not be affected by the override anyway, and we need
1106 the original type unaltered. The override will be applied in
1107 bidi_resolve_weak. */
1108 type
= bidi_get_type (curchar
, NEUTRAL_DIR
);
1109 bidi_it
->orig_type
= type
;
1110 bidi_check_type (bidi_it
->orig_type
);
1113 bidi_it
->prev_was_pdf
= 0;
1115 bidi_it
->type_after_w1
= UNKNOWN_BT
;
1121 bidi_it
->type_after_w1
= type
;
1122 bidi_check_type (bidi_it
->type_after_w1
);
1123 type
= WEAK_BN
; /* X9/Retaining */
1124 if (bidi_it
->ignore_bn_limit
<= 0)
1126 if (current_level
<= BIDI_MAXLEVEL
- 4)
1128 /* Compute the least odd embedding level greater than
1129 the current level. */
1130 new_level
= ((current_level
+ 1) & ~1) + 1;
1131 if (bidi_it
->type_after_w1
== RLE
)
1132 override
= NEUTRAL_DIR
;
1135 if (current_level
== BIDI_MAXLEVEL
- 4)
1136 bidi_it
->invalid_rl_levels
= 0;
1137 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1141 bidi_it
->invalid_levels
++;
1142 /* See the commentary about invalid_rl_levels below. */
1143 if (bidi_it
->invalid_rl_levels
< 0)
1144 bidi_it
->invalid_rl_levels
= 0;
1145 bidi_it
->invalid_rl_levels
++;
1148 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1149 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1154 bidi_it
->type_after_w1
= type
;
1155 bidi_check_type (bidi_it
->type_after_w1
);
1156 type
= WEAK_BN
; /* X9/Retaining */
1157 if (bidi_it
->ignore_bn_limit
<= 0)
1159 if (current_level
<= BIDI_MAXLEVEL
- 5)
1161 /* Compute the least even embedding level greater than
1162 the current level. */
1163 new_level
= ((current_level
+ 2) & ~1);
1164 if (bidi_it
->type_after_w1
== LRE
)
1165 override
= NEUTRAL_DIR
;
1168 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1172 bidi_it
->invalid_levels
++;
1173 /* invalid_rl_levels counts invalid levels encountered
1174 while the embedding level was already too high for
1175 LRE/LRO, but not for RLE/RLO. That is because
1176 there may be exactly one PDF which we should not
1177 ignore even though invalid_levels is non-zero.
1178 invalid_rl_levels helps to know what PDF is
1180 if (bidi_it
->invalid_rl_levels
>= 0)
1181 bidi_it
->invalid_rl_levels
++;
1184 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1185 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1189 bidi_it
->type_after_w1
= type
;
1190 bidi_check_type (bidi_it
->type_after_w1
);
1191 type
= WEAK_BN
; /* X9/Retaining */
1192 if (bidi_it
->ignore_bn_limit
<= 0)
1194 if (!bidi_it
->invalid_rl_levels
)
1196 new_level
= bidi_pop_embedding_level (bidi_it
);
1197 bidi_it
->invalid_rl_levels
= -1;
1198 if (bidi_it
->invalid_levels
)
1199 bidi_it
->invalid_levels
--;
1200 /* else nothing: UAX#9 says to ignore invalid PDFs */
1202 if (!bidi_it
->invalid_levels
)
1203 new_level
= bidi_pop_embedding_level (bidi_it
);
1206 bidi_it
->invalid_levels
--;
1207 bidi_it
->invalid_rl_levels
--;
1210 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1211 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1219 bidi_it
->type
= type
;
1220 bidi_check_type (bidi_it
->type
);
1225 /* Given an iterator state in BIDI_IT, advance one character position
1226 in the buffer to the next character (in the logical order), resolve
1227 any explicit embeddings and directional overrides, and return the
1228 embedding level of the character after resolving explicit
1229 directives and ignoring empty embeddings. */
1231 bidi_resolve_explicit (struct bidi_it
*bidi_it
)
1233 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1234 int new_level
= bidi_resolve_explicit_1 (bidi_it
);
1236 if (prev_level
< new_level
1237 && bidi_it
->type
== WEAK_BN
1238 && bidi_it
->ignore_bn_limit
== 0 /* only if not already known */
1239 && bidi_it
->ch
!= BIDI_EOB
/* not already at EOB */
1240 && bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1241 + bidi_it
->ch_len
)))
1243 /* Avoid pushing and popping embedding levels if the level run
1244 is empty, as this breaks level runs where it shouldn't.
1245 UAX#9 removes all the explicit embedding and override codes,
1246 so empty embeddings disappear without a trace. We need to
1247 behave as if we did the same. */
1248 struct bidi_it saved_it
;
1249 int level
= prev_level
;
1251 bidi_copy_it (&saved_it
, bidi_it
);
1253 while (bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1254 + bidi_it
->ch_len
)))
1256 level
= bidi_resolve_explicit_1 (bidi_it
);
1259 if (level
== prev_level
) /* empty embedding */
1260 saved_it
.ignore_bn_limit
= bidi_it
->charpos
+ 1;
1261 else /* this embedding is non-empty */
1262 saved_it
.ignore_bn_limit
= -1;
1264 bidi_copy_it (bidi_it
, &saved_it
);
1265 if (bidi_it
->ignore_bn_limit
> 0)
1267 /* We pushed a level, but we shouldn't have. Undo that. */
1268 if (!bidi_it
->invalid_rl_levels
)
1270 new_level
= bidi_pop_embedding_level (bidi_it
);
1271 bidi_it
->invalid_rl_levels
= -1;
1272 if (bidi_it
->invalid_levels
)
1273 bidi_it
->invalid_levels
--;
1275 if (!bidi_it
->invalid_levels
)
1276 new_level
= bidi_pop_embedding_level (bidi_it
);
1279 bidi_it
->invalid_levels
--;
1280 bidi_it
->invalid_rl_levels
--;
1285 if (bidi_it
->type
== NEUTRAL_B
) /* X8 */
1287 bidi_set_paragraph_end (bidi_it
);
1288 /* This is needed by bidi_resolve_weak below, and in L1. */
1289 bidi_it
->type_after_w1
= bidi_it
->type
;
1290 bidi_check_type (bidi_it
->type_after_w1
);
1296 /* Advance in the buffer, resolve weak types and return the type of
1297 the next character after weak type resolution. */
1299 bidi_resolve_weak (struct bidi_it
*bidi_it
)
1302 bidi_dir_t override
;
1303 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1304 int new_level
= bidi_resolve_explicit (bidi_it
);
1306 bidi_type_t type_of_next
;
1307 struct bidi_it saved_it
;
1309 type
= bidi_it
->type
;
1310 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1312 if (type
== UNKNOWN_BT
1320 if (new_level
!= prev_level
1321 || bidi_it
->type
== NEUTRAL_B
)
1323 /* We've got a new embedding level run, compute the directional
1324 type of sor and initialize per-run variables (UAX#9, clause
1326 bidi_set_sor_type (bidi_it
, prev_level
, new_level
);
1328 else if (type
== NEUTRAL_S
|| type
== NEUTRAL_WS
1329 || type
== WEAK_BN
|| type
== STRONG_AL
)
1330 bidi_it
->type_after_w1
= type
; /* needed in L1 */
1331 bidi_check_type (bidi_it
->type_after_w1
);
1333 /* Level and directional override status are already recorded in
1334 bidi_it, and do not need any change; see X6. */
1335 if (override
== R2L
) /* X6 */
1337 else if (override
== L2R
)
1341 if (type
== WEAK_NSM
) /* W1 */
1343 /* Note that we don't need to consider the case where the
1344 prev character has its type overridden by an RLO or LRO:
1345 such characters are outside the current level run, and
1346 thus not relevant to this NSM. Thus, NSM gets the
1347 orig_type of the previous character. */
1348 if (bidi_it
->prev
.type
!= UNKNOWN_BT
)
1349 type
= bidi_it
->prev
.orig_type
;
1350 else if (bidi_it
->sor
== R2L
)
1352 else if (bidi_it
->sor
== L2R
)
1354 else /* shouldn't happen! */
1357 if (type
== WEAK_EN
/* W2 */
1358 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)
1360 else if (type
== STRONG_AL
) /* W3 */
1362 else if ((type
== WEAK_ES
/* W4 */
1363 && bidi_it
->prev
.type_after_w1
== WEAK_EN
1364 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1366 && ((bidi_it
->prev
.type_after_w1
== WEAK_EN
1367 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1368 || bidi_it
->prev
.type_after_w1
== WEAK_AN
)))
1371 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1372 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1373 type_of_next
= bidi_get_type (next_char
, override
);
1375 if (type_of_next
== WEAK_BN
1376 || bidi_explicit_dir_char (next_char
))
1378 bidi_copy_it (&saved_it
, bidi_it
);
1379 while (bidi_resolve_explicit (bidi_it
) == new_level
1380 && bidi_it
->type
== WEAK_BN
)
1382 type_of_next
= bidi_it
->type
;
1383 bidi_copy_it (bidi_it
, &saved_it
);
1386 /* If the next character is EN, but the last strong-type
1387 character is AL, that next EN will be changed to AN when
1388 we process it in W2 above. So in that case, this ES
1389 should not be changed into EN. */
1391 && type_of_next
== WEAK_EN
1392 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1394 else if (type
== WEAK_CS
)
1396 if (bidi_it
->prev
.type_after_w1
== WEAK_AN
1397 && (type_of_next
== WEAK_AN
1398 /* If the next character is EN, but the last
1399 strong-type character is AL, EN will be later
1400 changed to AN when we process it in W2 above.
1401 So in that case, this ES should not be
1403 || (type_of_next
== WEAK_EN
1404 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)))
1406 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
1407 && type_of_next
== WEAK_EN
1408 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1412 else if (type
== WEAK_ET
/* W5: ET with EN before or after it */
1413 || type
== WEAK_BN
) /* W5/Retaining */
1415 if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* ET/BN w/EN before it */
1416 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1418 else /* W5: ET/BN with EN after it. */
1420 EMACS_INT en_pos
= bidi_it
->charpos
+ 1;
1423 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1424 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1425 type_of_next
= bidi_get_type (next_char
, override
);
1427 if (type_of_next
== WEAK_ET
1428 || type_of_next
== WEAK_BN
1429 || bidi_explicit_dir_char (next_char
))
1431 bidi_copy_it (&saved_it
, bidi_it
);
1432 while (bidi_resolve_explicit (bidi_it
) == new_level
1433 && (bidi_it
->type
== WEAK_BN
1434 || bidi_it
->type
== WEAK_ET
))
1436 type_of_next
= bidi_it
->type
;
1437 en_pos
= bidi_it
->charpos
;
1438 bidi_copy_it (bidi_it
, &saved_it
);
1440 if (type_of_next
== WEAK_EN
)
1442 /* If the last strong character is AL, the EN we've
1443 found will become AN when we get to it (W2). */
1444 if (bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1447 /* Remember this EN position, to speed up processing
1449 bidi_it
->next_en_pos
= en_pos
;
1451 else if (type
== WEAK_BN
)
1452 type
= NEUTRAL_ON
; /* W6/Retaining */
1458 if (type
== WEAK_ES
|| type
== WEAK_ET
|| type
== WEAK_CS
/* W6 */
1460 && (bidi_it
->prev
.type_after_w1
== WEAK_CS
/* W6/Retaining */
1461 || bidi_it
->prev
.type_after_w1
== WEAK_ES
1462 || bidi_it
->prev
.type_after_w1
== WEAK_ET
)))
1465 /* Store the type we've got so far, before we clobber it with strong
1466 types in W7 and while resolving neutral types. But leave alone
1467 the original types that were recorded above, because we will need
1468 them for the L1 clause. */
1469 if (bidi_it
->type_after_w1
== UNKNOWN_BT
)
1470 bidi_it
->type_after_w1
= type
;
1471 bidi_check_type (bidi_it
->type_after_w1
);
1473 if (type
== WEAK_EN
) /* W7 */
1475 if ((bidi_it
->last_strong
.type_after_w1
== STRONG_L
)
1476 || (bidi_it
->last_strong
.type
== UNKNOWN_BT
&& bidi_it
->sor
== L2R
))
1480 bidi_it
->type
= type
;
1481 bidi_check_type (bidi_it
->type
);
1486 bidi_resolve_neutral (struct bidi_it
*bidi_it
)
1488 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1489 bidi_type_t type
= bidi_resolve_weak (bidi_it
);
1490 int current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1492 if (!(type
== STRONG_R
1497 || type
== NEUTRAL_B
1498 || type
== NEUTRAL_S
1499 || type
== NEUTRAL_WS
1500 || type
== NEUTRAL_ON
))
1503 if (bidi_get_category (type
) == NEUTRAL
1504 || (type
== WEAK_BN
&& prev_level
== current_level
))
1506 if (bidi_it
->next_for_neutral
.type
!= UNKNOWN_BT
)
1507 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1508 bidi_it
->next_for_neutral
.type
,
1512 /* Arrrgh!! The UAX#9 algorithm is too deeply entrenched in
1513 the assumption of batch-style processing; see clauses W4,
1514 W5, and especially N1, which require to look far forward
1515 (as well as back) in the buffer. May the fleas of a
1516 thousand camels infest the armpits of those who design
1517 supposedly general-purpose algorithms by looking at their
1518 own implementations, and fail to consider other possible
1520 struct bidi_it saved_it
;
1521 bidi_type_t next_type
;
1523 if (bidi_it
->scan_dir
== -1)
1526 bidi_copy_it (&saved_it
, bidi_it
);
1527 /* Scan the text forward until we find the first non-neutral
1528 character, and then use that to resolve the neutral we
1529 are dealing with now. We also cache the scanned iterator
1530 states, to salvage some of the effort later. */
1531 bidi_cache_iterator_state (bidi_it
, 0);
1533 /* Record the info about the previous character, so that
1534 it will be cached below with this state. */
1535 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1536 && bidi_it
->type
!= WEAK_BN
)
1537 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1538 type
= bidi_resolve_weak (bidi_it
);
1539 /* Paragraph separators have their levels fully resolved
1540 at this point, so cache them as resolved. */
1541 bidi_cache_iterator_state (bidi_it
, type
== NEUTRAL_B
);
1542 /* FIXME: implement L1 here, by testing for a newline and
1543 resetting the level for any sequence of whitespace
1544 characters adjacent to it. */
1545 } while (!(type
== NEUTRAL_B
1547 && bidi_get_category (type
) != NEUTRAL
)
1548 /* This is all per level run, so stop when we
1549 reach the end of this level run. */
1550 || bidi_it
->level_stack
[bidi_it
->stack_idx
].level
!=
1553 bidi_remember_char (&saved_it
.next_for_neutral
, bidi_it
);
1564 /* N1: ``European and Arabic numbers are treated as
1565 though they were R.'' */
1566 next_type
= STRONG_R
;
1567 saved_it
.next_for_neutral
.type
= STRONG_R
;
1570 if (!bidi_explicit_dir_char (bidi_it
->ch
))
1571 abort (); /* can't happen: BNs are skipped */
1574 /* Marched all the way to the end of this level run.
1575 We need to use the eor type, whose information is
1576 stored by bidi_set_sor_type in the prev_for_neutral
1578 if (saved_it
.type
!= WEAK_BN
1579 || bidi_get_category (bidi_it
->prev
.type_after_w1
) == NEUTRAL
)
1581 next_type
= bidi_it
->prev_for_neutral
.type
;
1582 saved_it
.next_for_neutral
.type
= next_type
;
1583 bidi_check_type (next_type
);
1587 /* This is a BN which does not adjoin neutrals.
1588 Leave its type alone. */
1589 bidi_copy_it (bidi_it
, &saved_it
);
1590 return bidi_it
->type
;
1596 type
= bidi_resolve_neutral_1 (saved_it
.prev_for_neutral
.type
,
1597 next_type
, current_level
);
1598 saved_it
.type
= type
;
1599 bidi_check_type (type
);
1600 bidi_copy_it (bidi_it
, &saved_it
);
1606 /* Given an iterator state in BIDI_IT, advance one character position
1607 in the buffer to the next character (in the logical order), resolve
1608 the bidi type of that next character, and return that type. */
1610 bidi_type_of_next_char (struct bidi_it
*bidi_it
)
1614 /* This should always be called during a forward scan. */
1615 if (bidi_it
->scan_dir
!= 1)
1618 /* Reset the limit until which to ignore BNs if we step out of the
1619 area where we found only empty levels. */
1620 if ((bidi_it
->ignore_bn_limit
> 0
1621 && bidi_it
->ignore_bn_limit
<= bidi_it
->charpos
)
1622 || (bidi_it
->ignore_bn_limit
== -1
1623 && !bidi_explicit_dir_char (bidi_it
->ch
)))
1624 bidi_it
->ignore_bn_limit
= 0;
1626 type
= bidi_resolve_neutral (bidi_it
);
1631 /* Given an iterator state BIDI_IT, advance one character position in
1632 the buffer to the next character (in the logical order), resolve
1633 the embedding and implicit levels of that next character, and
1634 return the resulting level. */
1636 bidi_level_of_next_char (struct bidi_it
*bidi_it
)
1639 int level
, prev_level
= -1;
1640 struct bidi_saved_info next_for_neutral
;
1642 if (bidi_it
->scan_dir
== 1)
1644 /* There's no sense in trying to advance if we hit end of text. */
1645 if (bidi_it
->ch
== BIDI_EOB
)
1646 return bidi_it
->resolved_level
;
1648 /* Record the info about the previous character. */
1649 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1650 && bidi_it
->type
!= WEAK_BN
)
1651 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1652 if (bidi_it
->type_after_w1
== STRONG_R
1653 || bidi_it
->type_after_w1
== STRONG_L
1654 || bidi_it
->type_after_w1
== STRONG_AL
)
1655 bidi_remember_char (&bidi_it
->last_strong
, bidi_it
);
1656 /* FIXME: it sounds like we don't need both prev and
1657 prev_for_neutral members, but I'm leaving them both for now. */
1658 if (bidi_it
->type
== STRONG_R
|| bidi_it
->type
== STRONG_L
1659 || bidi_it
->type
== WEAK_EN
|| bidi_it
->type
== WEAK_AN
)
1660 bidi_remember_char (&bidi_it
->prev_for_neutral
, bidi_it
);
1662 /* If we overstepped the characters used for resolving neutrals
1663 and whitespace, invalidate their info in the iterator. */
1664 if (bidi_it
->charpos
>= bidi_it
->next_for_neutral
.charpos
)
1665 bidi_it
->next_for_neutral
.type
= UNKNOWN_BT
;
1666 if (bidi_it
->next_en_pos
>= 0
1667 && bidi_it
->charpos
>= bidi_it
->next_en_pos
)
1668 bidi_it
->next_en_pos
= -1;
1669 if (bidi_it
->next_for_ws
.type
!= UNKNOWN_BT
1670 && bidi_it
->charpos
>= bidi_it
->next_for_ws
.charpos
)
1671 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
1673 /* This must be taken before we fill the iterator with the info
1674 about the next char. If we scan backwards, the iterator
1675 state must be already cached, so there's no need to know the
1676 embedding level of the previous character, since we will be
1677 returning to our caller shortly. */
1678 prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1680 next_for_neutral
= bidi_it
->next_for_neutral
;
1682 /* Perhaps it is already cached. */
1683 type
= bidi_cache_find (bidi_it
->charpos
+ bidi_it
->scan_dir
, -1, bidi_it
);
1684 if (type
!= UNKNOWN_BT
)
1686 /* Don't lose the information for resolving neutrals! The
1687 cached states could have been cached before their
1688 next_for_neutral member was computed. If we are on our way
1689 forward, we can simply take the info from the previous
1691 if (bidi_it
->scan_dir
== 1
1692 && bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1693 bidi_it
->next_for_neutral
= next_for_neutral
;
1695 /* If resolved_level is -1, it means this state was cached
1696 before it was completely resolved, so we cannot return
1698 if (bidi_it
->resolved_level
!= -1)
1699 return bidi_it
->resolved_level
;
1701 if (bidi_it
->scan_dir
== -1)
1702 /* If we are going backwards, the iterator state is already cached
1703 from previous scans, and should be fully resolved. */
1706 if (type
== UNKNOWN_BT
)
1707 type
= bidi_type_of_next_char (bidi_it
);
1709 if (type
== NEUTRAL_B
)
1710 return bidi_it
->resolved_level
;
1712 level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1713 if ((bidi_get_category (type
) == NEUTRAL
/* && type != NEUTRAL_B */)
1714 || (type
== WEAK_BN
&& prev_level
== level
))
1716 if (bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1719 /* If the cached state shows a neutral character, it was not
1720 resolved by bidi_resolve_neutral, so do it now. */
1721 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1722 bidi_it
->next_for_neutral
.type
,
1726 if (!(type
== STRONG_R
1730 || type
== WEAK_AN
))
1732 bidi_it
->type
= type
;
1733 bidi_check_type (bidi_it
->type
);
1735 /* For L1 below, we need to know, for each WS character, whether
1736 it belongs to a sequence of WS characters preceeding a newline
1737 or a TAB or a paragraph separator. */
1738 if (bidi_it
->orig_type
== NEUTRAL_WS
1739 && bidi_it
->next_for_ws
.type
== UNKNOWN_BT
)
1742 int clen
= bidi_it
->ch_len
;
1743 EMACS_INT bpos
= bidi_it
->bytepos
;
1744 EMACS_INT cpos
= bidi_it
->charpos
;
1748 /*_fetch_multibyte_char_len = 1;*/
1749 ch
= bpos
+ clen
>= ZV_BYTE
? BIDI_EOB
: FETCH_CHAR (bpos
+ clen
);
1752 clen
= (ch
== BIDI_EOB
? 1 : CHAR_BYTES (ch
));
1753 if (ch
== '\n' || ch
== BIDI_EOB
/* || ch == LINESEP_CHAR */)
1756 chtype
= bidi_get_type (ch
, NEUTRAL_DIR
);
1757 } while (chtype
== NEUTRAL_WS
|| chtype
== WEAK_BN
1758 || bidi_explicit_dir_char (ch
)); /* L1/Retaining */
1759 bidi_it
->next_for_ws
.type
= chtype
;
1760 bidi_check_type (bidi_it
->next_for_ws
.type
);
1761 bidi_it
->next_for_ws
.charpos
= cpos
;
1762 bidi_it
->next_for_ws
.bytepos
= bpos
;
1765 /* Resolve implicit levels, with a twist: PDFs get the embedding
1766 level of the enbedding they terminate. See below for the
1768 if (bidi_it
->orig_type
== PDF
1769 /* Don't do this if this formatting code didn't change the
1770 embedding level due to invalid or empty embeddings. */
1771 && prev_level
!= level
)
1773 /* Don't look in UAX#9 for the reason for this: it's our own
1774 private quirk. The reason is that we want the formatting
1775 codes to be delivered so that they bracket the text of their
1776 embedding. For example, given the text
1780 we want it to be displayed as
1788 which will result because we bump up the embedding level as
1789 soon as we see the RLO and pop it as soon as we see the PDF,
1790 so RLO itself has the same embedding level as "teST", and
1791 thus would be normally delivered last, just before the PDF.
1792 The switch below fiddles with the level of PDF so that this
1793 ugly side effect does not happen.
1795 (This is, of course, only important if the formatting codes
1796 are actually displayed, but Emacs does need to display them
1797 if the user wants to.) */
1800 else if (bidi_it
->orig_type
== NEUTRAL_B
/* L1 */
1801 || bidi_it
->orig_type
== NEUTRAL_S
1802 || bidi_it
->ch
== '\n' || bidi_it
->ch
== BIDI_EOB
1803 /* || bidi_it->ch == LINESEP_CHAR */
1804 || (bidi_it
->orig_type
== NEUTRAL_WS
1805 && (bidi_it
->next_for_ws
.type
== NEUTRAL_B
1806 || bidi_it
->next_for_ws
.type
== NEUTRAL_S
)))
1807 level
= bidi_it
->level_stack
[0].level
;
1808 else if ((level
& 1) == 0) /* I1 */
1810 if (type
== STRONG_R
)
1812 else if (type
== WEAK_EN
|| type
== WEAK_AN
)
1817 if (type
== STRONG_L
|| type
== WEAK_EN
|| type
== WEAK_AN
)
1821 bidi_it
->resolved_level
= level
;
1825 /* Move to the other edge of a level given by LEVEL. If END_FLAG is
1826 non-zero, we are at the end of a level, and we need to prepare to
1827 resume the scan of the lower level.
1829 If this level's other edge is cached, we simply jump to it, filling
1830 the iterator structure with the iterator state on the other edge.
1831 Otherwise, we walk the buffer until we come back to the same level
1834 Note: we are not talking here about a ``level run'' in the UAX#9
1835 sense of the term, but rather about a ``level'' which includes
1836 all the levels higher than it. In other words, given the levels
1839 11111112222222333333334443343222222111111112223322111
1842 and assuming we are at point A scanning left to right, this
1843 function moves to point C, whereas the UAX#9 ``level 2 run'' ends
1846 bidi_find_other_level_edge (struct bidi_it
*bidi_it
, int level
, int end_flag
)
1848 int dir
= end_flag
? -bidi_it
->scan_dir
: bidi_it
->scan_dir
;
1851 /* Try the cache first. */
1852 if ((idx
= bidi_cache_find_level_change (level
, dir
, end_flag
)) >= 0)
1853 bidi_cache_fetch_state (idx
, bidi_it
);
1859 abort (); /* if we are at end of level, its edges must be cached */
1861 bidi_cache_iterator_state (bidi_it
, 1);
1863 new_level
= bidi_level_of_next_char (bidi_it
);
1864 bidi_cache_iterator_state (bidi_it
, 1);
1865 } while (new_level
>= level
);
1870 bidi_get_next_char_visually (struct bidi_it
*bidi_it
)
1872 int old_level
, new_level
, next_level
;
1873 struct bidi_it sentinel
;
1875 if (bidi_it
->scan_dir
== 0)
1877 bidi_it
->scan_dir
= 1; /* default to logical order */
1880 /* If we just passed a newline, initialize for the next line. */
1881 if (!bidi_it
->first_elt
&& bidi_it
->orig_type
== NEUTRAL_B
)
1882 bidi_line_init (bidi_it
);
1884 /* Prepare the sentinel iterator state. */
1885 if (bidi_cache_idx
== 0)
1887 bidi_copy_it (&sentinel
, bidi_it
);
1888 if (bidi_it
->first_elt
)
1890 sentinel
.charpos
--; /* cached charpos needs to be monotonic */
1892 sentinel
.ch
= '\n'; /* doesn't matter, but why not? */
1893 sentinel
.ch_len
= 1;
1897 old_level
= bidi_it
->resolved_level
;
1898 new_level
= bidi_level_of_next_char (bidi_it
);
1900 /* Reordering of resolved levels (clause L2) is implemented by
1901 jumping to the other edge of the level and flipping direction of
1902 scanning the text whenever we find a level change. */
1903 if (new_level
!= old_level
)
1905 int ascending
= new_level
> old_level
;
1906 int level_to_search
= ascending
? old_level
+ 1 : old_level
;
1907 int incr
= ascending
? 1 : -1;
1908 int expected_next_level
= old_level
+ incr
;
1910 /* If we don't have anything cached yet, we need to cache the
1911 sentinel state, since we'll need it to record where to jump
1912 when the last non-base level is exhausted. */
1913 if (bidi_cache_idx
== 0)
1914 bidi_cache_iterator_state (&sentinel
, 1);
1915 /* Jump (or walk) to the other edge of this level. */
1916 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1917 /* Switch scan direction and peek at the next character in the
1919 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1921 /* The following loop handles the case where the resolved level
1922 jumps by more than one. This is typical for numbers inside a
1923 run of text with left-to-right embedding direction, but can
1924 also happen in other situations. In those cases the decision
1925 where to continue after a level change, and in what direction,
1926 is tricky. For example, given a text like below:
1931 (where the numbers below the text show the resolved levels),
1932 the result of reordering according to UAX#9 should be this:
1936 This is implemented by the loop below which flips direction
1937 and jumps to the other edge of the level each time it finds
1938 the new level not to be the expected one. The expected level
1939 is always one more or one less than the previous one. */
1940 next_level
= bidi_peek_at_next_level (bidi_it
);
1941 while (next_level
!= expected_next_level
)
1943 expected_next_level
+= incr
;
1944 level_to_search
+= incr
;
1945 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1946 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1947 next_level
= bidi_peek_at_next_level (bidi_it
);
1950 /* Finally, deliver the next character in the new direction. */
1951 next_level
= bidi_level_of_next_char (bidi_it
);
1954 /* Take note when we have just processed the newline that precedes
1955 the end of the paragraph. The next time we are about to be
1956 called, set_iterator_to_next will automatically reinit the
1957 paragraph direction, if needed. We do this at the newline before
1958 the paragraph separator, because the next character might not be
1959 the first character of the next paragraph, due to the bidi
1960 reordering, whereas we _must_ know the paragraph base direction
1961 _before_ we process the paragraph's text, since the base
1962 direction affects the reordering. */
1963 if (bidi_it
->scan_dir
== 1
1964 && bidi_it
->orig_type
== NEUTRAL_B
1965 && bidi_it
->bytepos
< ZV_BYTE
)
1968 bidi_at_paragraph_end (bidi_it
->charpos
+ 1,
1969 bidi_it
->bytepos
+ bidi_it
->ch_len
);
1972 bidi_it
->new_paragraph
= 1;
1973 /* Record the buffer position of the last character of the
1974 paragraph separator. */
1975 bidi_it
->separator_limit
= bidi_it
->charpos
+ 1 + sep_len
;
1979 if (bidi_it
->scan_dir
== 1 && bidi_cache_idx
)
1981 /* If we are at paragraph's base embedding level and beyond the
1982 last cached position, the cache's job is done and we can
1984 if (bidi_it
->resolved_level
== bidi_it
->level_stack
[0].level
1985 && bidi_it
->charpos
> bidi_cache
[bidi_cache_idx
- 1].charpos
)
1986 bidi_cache_reset ();
1987 /* But as long as we are caching during forward scan, we must
1988 cache each state, or else the cache integrity will be
1989 compromised: it assumes cached states correspond to buffer
1992 bidi_cache_iterator_state (bidi_it
, 1);
1996 /* This is meant to be called from within the debugger, whenever you
1997 wish to examine the cache contents. */
1999 bidi_dump_cached_states (void)
2004 if (bidi_cache_idx
== 0)
2006 fprintf (stderr
, "The cache is empty.\n");
2009 fprintf (stderr
, "Total of %d state%s in cache:\n",
2010 bidi_cache_idx
, bidi_cache_idx
== 1 ? "" : "s");
2012 for (i
= bidi_cache
[bidi_cache_idx
- 1].charpos
; i
> 0; i
/= 10)
2014 fputs ("ch ", stderr
);
2015 for (i
= 0; i
< bidi_cache_idx
; i
++)
2016 fprintf (stderr
, "%*c", ndigits
, bidi_cache
[i
].ch
);
2017 fputs ("\n", stderr
);
2018 fputs ("lvl ", stderr
);
2019 for (i
= 0; i
< bidi_cache_idx
; i
++)
2020 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].resolved_level
);
2021 fputs ("\n", stderr
);
2022 fputs ("pos ", stderr
);
2023 for (i
= 0; i
< bidi_cache_idx
; i
++)
2024 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].charpos
);
2025 fputs ("\n", stderr
);