1 /* Low-level bidirectional buffer-scanning functions for GNU Emacs.
2 Copyright (C) 2000, 2001, 2004, 2005, 2009 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* Written by Eli Zaretskii <eliz@gnu.org>.
24 A sequential implementation of the Unicode Bidirectional algorithm,
25 as per UAX#9, a part of the Unicode Standard.
27 Unlike the reference and most other implementations, this one is
28 designed to be called once for every character in the buffer.
30 The main entry point is bidi_get_next_char_visually. Each time it
31 is called, it finds the next character in the visual order, and
32 returns its information in a special structure. The caller is then
33 expected to process this character for display or any other
34 purposes, and call bidi_get_next_char_visually for the next
35 character. See the comments in bidi_get_next_char_visually for
36 more details about its algorithm that finds the next visual-order
37 character by resolving their levels on the fly.
39 If you want to understand the code, you will have to read it
40 together with the relevant portions of UAX#9. The comments include
41 references to UAX#9 rules, for that very reason.
43 A note about references to UAX#9 rules: if the reference says
44 something like "X9/Retaining", it means that you need to refer to
45 rule X9 and to its modifications decribed in the "Implementation
46 Notes" section of UAX#9, under "Retaining Format Codes". */
62 #include "character.h"
63 #include "dispextern.h"
65 static int bidi_initialized
= 0;
67 static Lisp_Object bidi_type_table
;
69 /* FIXME: Remove these when bidi_explicit_dir_char uses a lookup table. */
70 #define LRM_CHAR 0x200E
71 #define RLM_CHAR 0x200F
72 #define LRE_CHAR 0x202A
73 #define RLE_CHAR 0x202B
74 #define PDF_CHAR 0x202C
75 #define LRO_CHAR 0x202D
76 #define RLO_CHAR 0x202E
79 #define BIDI_BOB -2 /* FIXME: Is this needed? */
81 /* Local data structures. (Look in dispextern.h for the rest.) */
83 /* What we need to know about the current paragraph. */
84 struct bidi_paragraph_info
{
85 int start_bytepos
; /* byte position where it begins */
86 int end_bytepos
; /* byte position where it ends */
87 int embedding_level
; /* its basic embedding level */
88 bidi_dir_t base_dir
; /* its base direction */
91 /* Data type for describing the bidirectional character categories. */
99 int bidi_ignore_explicit_marks_for_paragraph_level
= 1;
101 static Lisp_Object fallback_paragraph_start_re
, fallback_paragraph_separate_re
;
102 static Lisp_Object Qparagraph_start
, Qparagraph_separate
;
107 /* FIXME: This should come from the Unicode Database. */
112 { { 0x0000, 0x0008, WEAK_BN
},
113 { 0x0009, 0x0000, NEUTRAL_S
},
114 { 0x000A, 0x0000, NEUTRAL_B
},
115 { 0x000B, 0x0000, NEUTRAL_S
},
116 { 0x000C, 0x0000, NEUTRAL_WS
},
117 { 0x000D, 0x0000, NEUTRAL_B
},
118 { 0x000E, 0x001B, WEAK_BN
},
119 { 0x001C, 0x001E, NEUTRAL_B
},
120 { 0x001F, 0x0000, NEUTRAL_S
},
121 { 0x0020, 0x0000, NEUTRAL_WS
},
122 { 0x0021, 0x0022, NEUTRAL_ON
},
123 { 0x0023, 0x0025, WEAK_ET
},
124 { 0x0026, 0x002A, NEUTRAL_ON
},
125 { 0x002B, 0x0000, WEAK_ES
},
126 { 0x002C, 0x0000, WEAK_CS
},
127 { 0x002D, 0x0000, WEAK_ES
},
128 { 0x002E, 0x002F, WEAK_CS
},
129 { 0x0030, 0x0039, WEAK_EN
},
130 { 0x003A, 0x0000, WEAK_CS
},
131 { 0x003B, 0x0040, NEUTRAL_ON
},
132 { 0x005B, 0x0060, NEUTRAL_ON
},
133 { 0x007B, 0x007E, NEUTRAL_ON
},
134 { 0x007F, 0x0084, WEAK_BN
},
135 { 0x0085, 0x0000, NEUTRAL_B
},
136 { 0x0086, 0x009F, WEAK_BN
},
137 { 0x00A0, 0x0000, WEAK_CS
},
138 { 0x00A1, 0x0000, NEUTRAL_ON
},
139 { 0x00A2, 0x00A5, WEAK_ET
},
140 { 0x00A6, 0x00A9, NEUTRAL_ON
},
141 { 0x00AB, 0x00AC, NEUTRAL_ON
},
142 { 0x00AD, 0x0000, WEAK_BN
},
143 { 0x00AE, 0x00Af, NEUTRAL_ON
},
144 { 0x00B0, 0x00B1, WEAK_ET
},
145 { 0x00B2, 0x00B3, WEAK_EN
},
146 { 0x00B4, 0x0000, NEUTRAL_ON
},
147 { 0x00B6, 0x00B8, NEUTRAL_ON
},
148 { 0x00B9, 0x0000, WEAK_EN
},
149 { 0x00BB, 0x00BF, NEUTRAL_ON
},
150 { 0x00D7, 0x0000, NEUTRAL_ON
},
151 { 0x00F7, 0x0000, NEUTRAL_ON
},
152 { 0x02B9, 0x02BA, NEUTRAL_ON
},
153 { 0x02C2, 0x02CF, NEUTRAL_ON
},
154 { 0x02D2, 0x02DF, NEUTRAL_ON
},
155 { 0x02E5, 0x02ED, NEUTRAL_ON
},
156 { 0x0300, 0x036F, WEAK_NSM
},
157 { 0x0374, 0x0375, NEUTRAL_ON
},
158 { 0x037E, 0x0385, NEUTRAL_ON
},
159 { 0x0387, 0x0000, NEUTRAL_ON
},
160 { 0x03F6, 0x0000, NEUTRAL_ON
},
161 { 0x0483, 0x0489, WEAK_NSM
},
162 { 0x058A, 0x0000, NEUTRAL_ON
},
163 { 0x0591, 0x05BD, WEAK_NSM
},
164 { 0x05BE, 0x0000, STRONG_R
},
165 { 0x05BF, 0x0000, WEAK_NSM
},
166 { 0x05C0, 0x0000, STRONG_R
},
167 { 0x05C1, 0x05C2, WEAK_NSM
},
168 { 0x05C3, 0x0000, STRONG_R
},
169 { 0x05C4, 0x05C5, WEAK_NSM
},
170 { 0x05C6, 0x0000, STRONG_R
},
171 { 0x05C7, 0x0000, WEAK_NSM
},
172 { 0x05D0, 0x05F4, STRONG_R
},
173 { 0x060C, 0x0000, WEAK_CS
},
174 { 0x061B, 0x064A, STRONG_AL
},
175 { 0x064B, 0x0655, WEAK_NSM
},
176 { 0x0660, 0x0669, WEAK_AN
},
177 { 0x066A, 0x0000, WEAK_ET
},
178 { 0x066B, 0x066C, WEAK_AN
},
179 { 0x066D, 0x066F, STRONG_AL
},
180 { 0x0670, 0x0000, WEAK_NSM
},
181 { 0x0671, 0x06D5, STRONG_AL
},
182 { 0x06D6, 0x06DC, WEAK_NSM
},
183 { 0x06DD, 0x0000, STRONG_AL
},
184 { 0x06DE, 0x06E4, WEAK_NSM
},
185 { 0x06E5, 0x06E6, STRONG_AL
},
186 { 0x06E7, 0x06E8, WEAK_NSM
},
187 { 0x06E9, 0x0000, NEUTRAL_ON
},
188 { 0x06EA, 0x06ED, WEAK_NSM
},
189 { 0x06F0, 0x06F9, WEAK_EN
},
190 { 0x06FA, 0x070D, STRONG_AL
},
191 { 0x070F, 0x0000, WEAK_BN
},
192 { 0x0710, 0x0000, STRONG_AL
},
193 { 0x0711, 0x0000, WEAK_NSM
},
194 { 0x0712, 0x072C, STRONG_AL
},
195 { 0x0730, 0x074A, WEAK_NSM
},
196 { 0x0780, 0x07A5, STRONG_AL
},
197 { 0x07A6, 0x07B0, WEAK_NSM
},
198 { 0x07B1, 0x0000, STRONG_AL
},
199 { 0x0901, 0x0902, WEAK_NSM
},
200 { 0x093C, 0x0000, WEAK_NSM
},
201 { 0x0941, 0x0948, WEAK_NSM
},
202 { 0x094D, 0x0000, WEAK_NSM
},
203 { 0x0951, 0x0954, WEAK_NSM
},
204 { 0x0962, 0x0963, WEAK_NSM
},
205 { 0x0981, 0x0000, WEAK_NSM
},
206 { 0x09BC, 0x0000, WEAK_NSM
},
207 { 0x09C1, 0x09C4, WEAK_NSM
},
208 { 0x09CD, 0x0000, WEAK_NSM
},
209 { 0x09E2, 0x09E3, WEAK_NSM
},
210 { 0x09F2, 0x09F3, WEAK_ET
},
211 { 0x0A02, 0x0000, WEAK_NSM
},
212 { 0x0A3C, 0x0000, WEAK_NSM
},
213 { 0x0A41, 0x0A4D, WEAK_NSM
},
214 { 0x0A70, 0x0A71, WEAK_NSM
},
215 { 0x0A81, 0x0A82, WEAK_NSM
},
216 { 0x0ABC, 0x0000, WEAK_NSM
},
217 { 0x0AC1, 0x0AC8, WEAK_NSM
},
218 { 0x0ACD, 0x0000, WEAK_NSM
},
219 { 0x0B01, 0x0000, WEAK_NSM
},
220 { 0x0B3C, 0x0000, WEAK_NSM
},
221 { 0x0B3F, 0x0000, WEAK_NSM
},
222 { 0x0B41, 0x0B43, WEAK_NSM
},
223 { 0x0B4D, 0x0B56, WEAK_NSM
},
224 { 0x0B82, 0x0000, WEAK_NSM
},
225 { 0x0BC0, 0x0000, WEAK_NSM
},
226 { 0x0BCD, 0x0000, WEAK_NSM
},
227 { 0x0C3E, 0x0C40, WEAK_NSM
},
228 { 0x0C46, 0x0C56, WEAK_NSM
},
229 { 0x0CBF, 0x0000, WEAK_NSM
},
230 { 0x0CC6, 0x0000, WEAK_NSM
},
231 { 0x0CCC, 0x0CCD, WEAK_NSM
},
232 { 0x0D41, 0x0D43, WEAK_NSM
},
233 { 0x0D4D, 0x0000, WEAK_NSM
},
234 { 0x0DCA, 0x0000, WEAK_NSM
},
235 { 0x0DD2, 0x0DD6, WEAK_NSM
},
236 { 0x0E31, 0x0000, WEAK_NSM
},
237 { 0x0E34, 0x0E3A, WEAK_NSM
},
238 { 0x0E3F, 0x0000, WEAK_ET
},
239 { 0x0E47, 0x0E4E, WEAK_NSM
},
240 { 0x0EB1, 0x0000, WEAK_NSM
},
241 { 0x0EB4, 0x0EBC, WEAK_NSM
},
242 { 0x0EC8, 0x0ECD, WEAK_NSM
},
243 { 0x0F18, 0x0F19, WEAK_NSM
},
244 { 0x0F35, 0x0000, WEAK_NSM
},
245 { 0x0F37, 0x0000, WEAK_NSM
},
246 { 0x0F39, 0x0000, WEAK_NSM
},
247 { 0x0F3A, 0x0F3D, NEUTRAL_ON
},
248 { 0x0F71, 0x0F7E, WEAK_NSM
},
249 { 0x0F80, 0x0F84, WEAK_NSM
},
250 { 0x0F86, 0x0F87, WEAK_NSM
},
251 { 0x0F90, 0x0FBC, WEAK_NSM
},
252 { 0x0FC6, 0x0000, WEAK_NSM
},
253 { 0x102D, 0x1030, WEAK_NSM
},
254 { 0x1032, 0x1037, WEAK_NSM
},
255 { 0x1039, 0x0000, WEAK_NSM
},
256 { 0x1058, 0x1059, WEAK_NSM
},
257 { 0x1680, 0x0000, NEUTRAL_WS
},
258 { 0x169B, 0x169C, NEUTRAL_ON
},
259 { 0x1712, 0x1714, WEAK_NSM
},
260 { 0x1732, 0x1734, WEAK_NSM
},
261 { 0x1752, 0x1753, WEAK_NSM
},
262 { 0x1772, 0x1773, WEAK_NSM
},
263 { 0x17B7, 0x17BD, WEAK_NSM
},
264 { 0x17C6, 0x0000, WEAK_NSM
},
265 { 0x17C9, 0x17D3, WEAK_NSM
},
266 { 0x17DB, 0x0000, WEAK_ET
},
267 { 0x1800, 0x180A, NEUTRAL_ON
},
268 { 0x180B, 0x180D, WEAK_NSM
},
269 { 0x180E, 0x0000, WEAK_BN
},
270 { 0x18A9, 0x0000, WEAK_NSM
},
271 { 0x1FBD, 0x0000, NEUTRAL_ON
},
272 { 0x1FBF, 0x1FC1, NEUTRAL_ON
},
273 { 0x1FCD, 0x1FCF, NEUTRAL_ON
},
274 { 0x1FDD, 0x1FDF, NEUTRAL_ON
},
275 { 0x1FED, 0x1FEF, NEUTRAL_ON
},
276 { 0x1FFD, 0x1FFE, NEUTRAL_ON
},
277 { 0x2000, 0x200A, NEUTRAL_WS
},
278 { 0x200B, 0x200D, WEAK_BN
},
279 { 0x200F, 0x0000, STRONG_R
},
280 { 0x2010, 0x2027, NEUTRAL_ON
},
281 { 0x2028, 0x0000, NEUTRAL_WS
},
282 { 0x2029, 0x0000, NEUTRAL_B
},
283 { 0x202A, 0x0000, LRE
},
284 { 0x202B, 0x0000, RLE
},
285 { 0x202C, 0x0000, PDF
},
286 { 0x202D, 0x0000, LRO
},
287 { 0x202E, 0x0000, RLO
},
288 { 0x202F, 0x0000, NEUTRAL_WS
},
289 { 0x2030, 0x2034, WEAK_ET
},
290 { 0x2035, 0x2057, NEUTRAL_ON
},
291 { 0x205F, 0x0000, NEUTRAL_WS
},
292 { 0x2060, 0x206F, WEAK_BN
},
293 { 0x2070, 0x0000, WEAK_EN
},
294 { 0x2074, 0x2079, WEAK_EN
},
295 { 0x207A, 0x207B, WEAK_ET
},
296 { 0x207C, 0x207E, NEUTRAL_ON
},
297 { 0x2080, 0x2089, WEAK_EN
},
298 { 0x208A, 0x208B, WEAK_ET
},
299 { 0x208C, 0x208E, NEUTRAL_ON
},
300 { 0x20A0, 0x20B1, WEAK_ET
},
301 { 0x20D0, 0x20EA, WEAK_NSM
},
302 { 0x2100, 0x2101, NEUTRAL_ON
},
303 { 0x2103, 0x2106, NEUTRAL_ON
},
304 { 0x2108, 0x2109, NEUTRAL_ON
},
305 { 0x2114, 0x0000, NEUTRAL_ON
},
306 { 0x2116, 0x2118, NEUTRAL_ON
},
307 { 0x211E, 0x2123, NEUTRAL_ON
},
308 { 0x2125, 0x0000, NEUTRAL_ON
},
309 { 0x2127, 0x0000, NEUTRAL_ON
},
310 { 0x2129, 0x0000, NEUTRAL_ON
},
311 { 0x212E, 0x0000, WEAK_ET
},
312 { 0x2132, 0x0000, NEUTRAL_ON
},
313 { 0x213A, 0x0000, NEUTRAL_ON
},
314 { 0x2140, 0x2144, NEUTRAL_ON
},
315 { 0x214A, 0x215F, NEUTRAL_ON
},
316 { 0x2190, 0x2211, NEUTRAL_ON
},
317 { 0x2212, 0x2213, WEAK_ET
},
318 { 0x2214, 0x2335, NEUTRAL_ON
},
319 { 0x237B, 0x2394, NEUTRAL_ON
},
320 { 0x2396, 0x244A, NEUTRAL_ON
},
321 { 0x2460, 0x249B, WEAK_EN
},
322 { 0x24EA, 0x0000, WEAK_EN
},
323 { 0x24EB, 0x2FFB, NEUTRAL_ON
},
324 { 0x3000, 0x0000, NEUTRAL_WS
},
325 { 0x3001, 0x3004, NEUTRAL_ON
},
326 { 0x3008, 0x3020, NEUTRAL_ON
},
327 { 0x302A, 0x302F, WEAK_NSM
},
328 { 0x3030, 0x0000, NEUTRAL_ON
},
329 { 0x3036, 0x3037, NEUTRAL_ON
},
330 { 0x303D, 0x303F, NEUTRAL_ON
},
331 { 0x3099, 0x309A, WEAK_NSM
},
332 { 0x309B, 0x309C, NEUTRAL_ON
},
333 { 0x30A0, 0x0000, NEUTRAL_ON
},
334 { 0x30FB, 0x0000, NEUTRAL_ON
},
335 { 0x3251, 0x325F, NEUTRAL_ON
},
336 { 0x32B1, 0x32BF, NEUTRAL_ON
},
337 { 0xA490, 0xA4C6, NEUTRAL_ON
},
338 { 0xFB1D, 0x0000, STRONG_R
},
339 { 0xFB1E, 0x0000, WEAK_NSM
},
340 { 0xFB1F, 0xFB28, STRONG_R
},
341 { 0xFB29, 0x0000, WEAK_ET
},
342 { 0xFB2A, 0xFB4F, STRONG_R
},
343 { 0xFB50, 0xFD3D, STRONG_AL
},
344 { 0xFD3E, 0xFD3F, NEUTRAL_ON
},
345 { 0xFD50, 0xFDFC, STRONG_AL
},
346 { 0xFE00, 0xFE23, WEAK_NSM
},
347 { 0xFE30, 0xFE4F, NEUTRAL_ON
},
348 { 0xFE50, 0x0000, WEAK_CS
},
349 { 0xFE51, 0x0000, NEUTRAL_ON
},
350 { 0xFE52, 0x0000, WEAK_CS
},
351 { 0xFE54, 0x0000, NEUTRAL_ON
},
352 { 0xFE55, 0x0000, WEAK_CS
},
353 { 0xFE56, 0xFE5E, NEUTRAL_ON
},
354 { 0xFE5F, 0x0000, WEAK_ET
},
355 { 0xFE60, 0xFE61, NEUTRAL_ON
},
356 { 0xFE62, 0xFE63, WEAK_ET
},
357 { 0xFE64, 0xFE68, NEUTRAL_ON
},
358 { 0xFE69, 0xFE6A, WEAK_ET
},
359 { 0xFE6B, 0x0000, NEUTRAL_ON
},
360 { 0xFE70, 0xFEFC, STRONG_AL
},
361 { 0xFEFF, 0x0000, WEAK_BN
},
362 { 0xFF01, 0xFF02, NEUTRAL_ON
},
363 { 0xFF03, 0xFF05, WEAK_ET
},
364 { 0xFF06, 0xFF0A, NEUTRAL_ON
},
365 { 0xFF0B, 0x0000, WEAK_ET
},
366 { 0xFF0C, 0x0000, WEAK_CS
},
367 { 0xFF0D, 0x0000, WEAK_ET
},
368 { 0xFF0E, 0x0000, WEAK_CS
},
369 { 0xFF0F, 0x0000, WEAK_ES
},
370 { 0xFF10, 0xFF19, WEAK_EN
},
371 { 0xFF1A, 0x0000, WEAK_CS
},
372 { 0xFF1B, 0xFF20, NEUTRAL_ON
},
373 { 0xFF3B, 0xFF40, NEUTRAL_ON
},
374 { 0xFF5B, 0xFF65, NEUTRAL_ON
},
375 { 0xFFE0, 0xFFE1, WEAK_ET
},
376 { 0xFFE2, 0xFFE4, NEUTRAL_ON
},
377 { 0xFFE5, 0xFFE6, WEAK_ET
},
378 { 0xFFE8, 0xFFEE, NEUTRAL_ON
},
379 { 0xFFF9, 0xFFFB, WEAK_BN
},
380 { 0xFFFC, 0xFFFD, NEUTRAL_ON
},
381 { 0x1D167, 0x1D169, WEAK_NSM
},
382 { 0x1D173, 0x1D17A, WEAK_BN
},
383 { 0x1D17B, 0x1D182, WEAK_NSM
},
384 { 0x1D185, 0x1D18B, WEAK_NSM
},
385 { 0x1D1AA, 0x1D1AD, WEAK_NSM
},
386 { 0x1D7CE, 0x1D7FF, WEAK_EN
},
387 { 0xE0001, 0xE007F, WEAK_BN
} };
390 bidi_type_table
= Fmake_char_table (Qnil
, make_number (STRONG_L
));
391 staticpro (&bidi_type_table
);
393 for (i
= 0; i
< sizeof bidi_type
/ sizeof bidi_type
[0]; i
++)
394 char_table_set_range (bidi_type_table
, bidi_type
[i
].from
,
395 bidi_type
[i
].to
? bidi_type
[i
].to
: bidi_type
[i
].from
,
396 make_number (bidi_type
[i
].type
));
398 fallback_paragraph_start_re
=
399 XSYMBOL (Fintern_soft (build_string ("paragraph-start"), Qnil
))->value
;
400 if (!STRINGP (fallback_paragraph_start_re
))
401 fallback_paragraph_start_re
= build_string ("\f\\|[ \t]*$");
402 staticpro (&fallback_paragraph_start_re
);
403 Qparagraph_start
= intern ("paragraph-start");
404 staticpro (&Qparagraph_start
);
405 fallback_paragraph_separate_re
=
406 XSYMBOL (Fintern_soft (build_string ("paragraph-separate"), Qnil
))->value
;
407 if (!STRINGP (fallback_paragraph_separate_re
))
408 fallback_paragraph_separate_re
= build_string ("[ \t\f]*$");
409 staticpro (&fallback_paragraph_separate_re
);
410 Qparagraph_separate
= intern ("paragraph-separate");
411 staticpro (&Qparagraph_separate
);
412 bidi_initialized
= 1;
415 /* Return the bidi type of a character CH, subject to the current
416 directional OVERRIDE. */
418 bidi_get_type (int ch
, bidi_dir_t override
)
420 bidi_type_t default_type
;
424 if (ch
< 0 || ch
> MAX_CHAR
)
427 default_type
= (bidi_type_t
) XINT (CHAR_TABLE_REF (bidi_type_table
, ch
));
429 if (override
== NEUTRAL_DIR
)
432 switch (default_type
)
434 /* Although UAX#9 does not tell, it doesn't make sense to
435 override NEUTRAL_B and LRM/RLM characters. */
450 if (override
== L2R
) /* X6 */
452 else if (override
== R2L
)
455 abort (); /* can't happen: handled above */
461 bidi_check_type (bidi_type_t type
)
463 if (type
< UNKNOWN_BT
|| type
> NEUTRAL_ON
)
467 /* Given a bidi TYPE of a character, return its category. */
469 bidi_get_category (bidi_type_t type
)
483 case PDF
: /* ??? really?? */
502 /* Return the mirrored character of C, if any.
504 Note: The conditions in UAX#9 clause L4 must be tested by the
506 /* FIXME: exceedingly temporary! Should consult the Unicode database
507 of character properties. */
509 bidi_mirror_char (int c
)
511 static const char mirrored_pairs
[] = "()<>[]{}";
512 const char *p
= c
> 0 && c
< 128 ? strchr (mirrored_pairs
, c
) : NULL
;
516 size_t i
= p
- mirrored_pairs
;
518 return mirrored_pairs
[(i
^ 1)];
523 /* Copy the bidi iterator from FROM to TO. To save cycles, this only
524 copies the part of the level stack that is actually in use. */
526 bidi_copy_it (struct bidi_it
*to
, struct bidi_it
*from
)
530 /* Copy everything except the level stack and beyond. */
531 memcpy (to
, from
, ((size_t)&((struct bidi_it
*)0)->level_stack
[0]));
533 /* Copy the active part of the level stack. */
534 to
->level_stack
[0] = from
->level_stack
[0]; /* level zero is always in use */
535 for (i
= 1; i
<= from
->stack_idx
; i
++)
536 to
->level_stack
[i
] = from
->level_stack
[i
];
539 /* Caching the bidi iterator states. */
541 static struct bidi_it bidi_cache
[1000]; /* FIXME: make this dynamically allocated! */
542 static int bidi_cache_idx
;
543 static int bidi_cache_last_idx
;
546 bidi_cache_reset (void)
549 bidi_cache_last_idx
= -1;
553 bidi_cache_fetch_state (int idx
, struct bidi_it
*bidi_it
)
555 int current_scan_dir
= bidi_it
->scan_dir
;
557 if (idx
< 0 || idx
>= bidi_cache_idx
)
560 bidi_copy_it (bidi_it
, &bidi_cache
[idx
]);
561 bidi_it
->scan_dir
= current_scan_dir
;
562 bidi_cache_last_idx
= idx
;
565 /* Find a cached state with a given CHARPOS and resolved embedding
566 level less or equal to LEVEL. if LEVEL is -1, disregard the
567 resolved levels in cached states. DIR, if non-zero, means search
568 in that direction from the last cache hit. */
570 bidi_cache_search (int charpos
, int level
, int dir
)
576 if (charpos
< bidi_cache
[bidi_cache_last_idx
].charpos
)
578 else if (charpos
> bidi_cache
[bidi_cache_last_idx
].charpos
)
581 i_start
= bidi_cache_last_idx
;
585 i_start
= bidi_cache_idx
- 1;
590 /* Linear search for now; FIXME! */
591 for (i
= i_start
; i
>= 0; i
--)
592 if (bidi_cache
[i
].charpos
== charpos
593 && (level
== -1 || bidi_cache
[i
].resolved_level
<= level
))
598 for (i
= i_start
; i
< bidi_cache_idx
; i
++)
599 if (bidi_cache
[i
].charpos
== charpos
600 && (level
== -1 || bidi_cache
[i
].resolved_level
<= level
))
608 /* Find a cached state where the resolved level changes to a value
609 that is lower than LEVEL, and return its cache slot index. DIR is
610 the direction to search, starting with the last used cache slot.
611 BEFORE, if non-zero, means return the index of the slot that is
612 ``before'' the level change in the search direction. That is,
613 given the cached levels like this:
618 and assuming we are at the position cached at the slot marked with
619 C, searching backwards (DIR = -1) for LEVEL = 2 will return the
620 index of slot B or A, depending whether BEFORE is, respectively,
623 bidi_cache_find_level_change (int level
, int dir
, int before
)
627 int i
= dir
? bidi_cache_last_idx
: bidi_cache_idx
- 1;
628 int incr
= before
? 1 : 0;
639 if (bidi_cache
[i
- incr
].resolved_level
>= 0
640 && bidi_cache
[i
- incr
].resolved_level
< level
)
647 while (i
< bidi_cache_idx
- incr
)
649 if (bidi_cache
[i
+ incr
].resolved_level
>= 0
650 && bidi_cache
[i
+ incr
].resolved_level
< level
)
661 bidi_cache_iterator_state (struct bidi_it
*bidi_it
, int resolved
)
665 /* We should never cache on backward scans. */
666 if (bidi_it
->scan_dir
== -1)
668 idx
= bidi_cache_search (bidi_it
->charpos
, -1, 1);
672 idx
= bidi_cache_idx
;
673 /* Don't overrun the cache limit. */
674 if (idx
> sizeof (bidi_cache
) / sizeof (bidi_cache
[0]) - 1)
676 /* Don't violate cache integrity: character positions should
677 correspond to cache positions 1:1. */
678 if (idx
> 0 && bidi_it
->charpos
!= bidi_cache
[idx
- 1].charpos
+ 1)
680 bidi_copy_it (&bidi_cache
[idx
], bidi_it
);
682 bidi_cache
[idx
].resolved_level
= -1;
683 bidi_cache
[idx
].new_paragraph
= 0;
687 /* Copy only the members which could have changed, to avoid
688 costly copying of the entire struct. */
689 bidi_cache
[idx
].type
= bidi_it
->type
;
690 bidi_check_type (bidi_it
->type
);
691 bidi_cache
[idx
].type_after_w1
= bidi_it
->type_after_w1
;
692 bidi_check_type (bidi_it
->type_after_w1
);
694 bidi_cache
[idx
].resolved_level
= bidi_it
->resolved_level
;
696 bidi_cache
[idx
].resolved_level
= -1;
697 bidi_cache
[idx
].invalid_levels
= bidi_it
->invalid_levels
;
698 bidi_cache
[idx
].invalid_rl_levels
= bidi_it
->invalid_rl_levels
;
699 bidi_cache
[idx
].next_for_neutral
= bidi_it
->next_for_neutral
;
700 bidi_cache
[idx
].next_for_ws
= bidi_it
->next_for_ws
;
701 bidi_cache
[idx
].ignore_bn_limit
= bidi_it
->ignore_bn_limit
;
704 bidi_cache_last_idx
= idx
;
705 if (idx
>= bidi_cache_idx
)
706 bidi_cache_idx
= idx
+ 1;
709 static inline bidi_type_t
710 bidi_cache_find (int charpos
, int level
, struct bidi_it
*bidi_it
)
712 int i
= bidi_cache_search (charpos
, level
, bidi_it
->scan_dir
);
716 bidi_dir_t current_scan_dir
= bidi_it
->scan_dir
;
718 bidi_copy_it (bidi_it
, &bidi_cache
[i
]);
719 bidi_cache_last_idx
= i
;
720 /* Don't let scan direction from from the cached state override
721 the current scan direction. */
722 bidi_it
->scan_dir
= current_scan_dir
;
723 return bidi_it
->type
;
730 bidi_peek_at_next_level (struct bidi_it
*bidi_it
)
732 if (bidi_cache_idx
== 0 || bidi_cache_last_idx
== -1)
734 return bidi_cache
[bidi_cache_last_idx
+ bidi_it
->scan_dir
].resolved_level
;
737 /* Check if buffer position CHARPOS/BYTEPOS is the end of a paragraph.
738 Value is the non-negative length of the paragraph separator
739 following the buffer position, -1 if position is at the beginning
740 of a new paragraph, or -2 if position is neither at beginning nor
741 at end of a paragraph. */
743 bidi_at_paragraph_end (EMACS_INT charpos
, EMACS_INT bytepos
)
745 Lisp_Object sep_re
= Fbuffer_local_value (Qparagraph_separate
,
747 Lisp_Object start_re
= Fbuffer_local_value (Qparagraph_start
,
751 if (!STRINGP (sep_re
))
752 sep_re
= fallback_paragraph_separate_re
;
753 if (!STRINGP (start_re
))
754 start_re
= fallback_paragraph_start_re
;
756 val
= fast_looking_at (sep_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
);
759 if (fast_looking_at (start_re
, charpos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) >= 0)
768 /* Determine the start-of-run (sor) directional type given the two
769 embedding levels on either side of the run boundary. Also, update
770 the saved info about previously seen characters, since that info is
771 generally valid for a single level run. */
773 bidi_set_sor_type (struct bidi_it
*bidi_it
, int level_before
, int level_after
)
775 int higher_level
= level_before
> level_after
? level_before
: level_after
;
777 /* The prev_was_pdf gork is required for when we have several PDFs
778 in a row. In that case, we want to compute the sor type for the
779 next level run only once: when we see the first PDF. That's
780 because the sor type depends only on the higher of the two levels
781 that we find on the two sides of the level boundary (see UAX#9,
782 clause X10), and so we don't need to know the final embedding
783 level to which we descend after processing all the PDFs. */
784 if (!bidi_it
->prev_was_pdf
|| level_before
< level_after
)
785 /* FIXME: should the default sor direction be user selectable? */
786 bidi_it
->sor
= (higher_level
& 1) != 0 ? R2L
: L2R
;
787 if (level_before
> level_after
)
788 bidi_it
->prev_was_pdf
= 1;
790 bidi_it
->prev
.type
= UNKNOWN_BT
;
791 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
792 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
793 bidi_it
->prev_for_neutral
.type
= bidi_it
->sor
== R2L
? STRONG_R
: STRONG_L
;
794 bidi_it
->prev_for_neutral
.charpos
= bidi_it
->charpos
;
795 bidi_it
->prev_for_neutral
.bytepos
= bidi_it
->bytepos
;
796 bidi_it
->next_for_neutral
.type
= bidi_it
->next_for_neutral
.type_after_w1
=
797 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
798 bidi_it
->ignore_bn_limit
= 0; /* meaning it's unknown */
802 bidi_line_init (struct bidi_it
*bidi_it
)
804 bidi_it
->scan_dir
= 1; /* FIXME: do we need to have control on this? */
805 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
806 bidi_it
->level_stack
[0].override
= NEUTRAL_DIR
; /* X1 */
807 bidi_it
->invalid_levels
= 0;
808 bidi_it
->invalid_rl_levels
= -1;
809 bidi_it
->next_en_pos
= -1;
810 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
811 bidi_set_sor_type (bidi_it
,
812 bidi_it
->paragraph_dir
== R2L
? 1 : 0,
813 bidi_it
->level_stack
[0].level
); /* X10 */
818 /* Find the beginning of this paragraph by looking back in the buffer.
819 Value is the byte position of the paragraph's beginning. */
821 bidi_find_paragraph_start (EMACS_INT pos
, EMACS_INT pos_byte
)
823 Lisp_Object re
= Fbuffer_local_value (Qparagraph_start
, Fcurrent_buffer ());
824 EMACS_INT limit
= ZV
, limit_byte
= ZV_BYTE
;
827 re
= fallback_paragraph_start_re
;
828 while (pos_byte
> BEGV_BYTE
829 && fast_looking_at (re
, pos
, pos_byte
, limit
, limit_byte
, Qnil
) < 0)
831 pos
= find_next_newline_no_quit (pos
- 1, -1);
832 pos_byte
= CHAR_TO_BYTE (pos
);
837 /* Determine the direction, a.k.a. base embedding level, of the
838 paragraph we are about to iterate through. If DIR is either L2R or
839 R2L, just use that. Otherwise, determine the paragraph direction
840 from the first strong character of the paragraph.
842 Note that this gives the paragraph separator the same direction as
843 the preceding paragraph, even though Emacs generally views the
844 separartor as not belonging to any paragraph. */
846 bidi_paragraph_init (bidi_dir_t dir
, struct bidi_it
*bidi_it
)
848 EMACS_INT bytepos
= bidi_it
->bytepos
;
850 /* Special case for an empty buffer. */
851 if (bytepos
== BEGV_BYTE
&& bytepos
== ZV_BYTE
)
853 /* We should never be called at EOB or before BEGV. */
854 else if (bytepos
>= ZV_BYTE
|| bytepos
< BEGV_BYTE
)
859 bidi_it
->paragraph_dir
= L2R
;
860 bidi_it
->new_paragraph
= 0;
864 bidi_it
->paragraph_dir
= R2L
;
865 bidi_it
->new_paragraph
= 0;
867 else if (dir
== NEUTRAL_DIR
) /* P2 */
874 /* If we are inside a paragraph separator, we are just waiting
875 for the separator to be exhausted; use the previous paragraph
876 direction. But don't do that if we have been just reseated,
877 because we need to reinitialize below in that case. */
878 if (!bidi_it
->first_elt
879 && bidi_it
->charpos
< bidi_it
->separator_limit
)
882 /* If we are on a newline, get past it to where the next
883 paragraph might start. But don't do that at BEGV since then
884 we are potentially in a new paragraph that doesn't yet
886 pos
= bidi_it
->charpos
;
887 if (bytepos
> BEGV_BYTE
&& FETCH_CHAR (bytepos
) == '\n')
893 /* We are either at the beginning of a paragraph or in the
894 middle of it. Find where this paragraph starts. */
895 bytepos
= bidi_find_paragraph_start (pos
, bytepos
);
897 /* We should always be at the beginning of a new line at this
899 if (!(bytepos
== BEGV_BYTE
|| FETCH_CHAR (bytepos
- 1) == '\n'))
902 bidi_it
->separator_limit
= -1;
903 bidi_it
->new_paragraph
= 0;
904 ch
= FETCH_CHAR (bytepos
);
905 ch_len
= CHAR_BYTES (ch
);
906 pos
= BYTE_TO_CHAR (bytepos
);
907 type
= bidi_get_type (ch
, NEUTRAL_DIR
);
909 for (pos
++, bytepos
+= ch_len
;
910 /* NOTE: UAX#9 says to search only for L, AL, or R types of
911 characters, and ignore RLE, RLO, LRE, and LRO. However,
912 I'm not sure it makes sense to omit those 4; should try
913 with and without that to see the effect. */
914 (bidi_get_category (type
) != STRONG
)
915 || (bidi_ignore_explicit_marks_for_paragraph_level
916 && (type
== RLE
|| type
== RLO
917 || type
== LRE
|| type
== LRO
));
918 type
= bidi_get_type (ch
, NEUTRAL_DIR
))
920 if (type
== NEUTRAL_B
&& bidi_at_paragraph_end (pos
, bytepos
) >= -1)
922 if (bytepos
>= ZV_BYTE
)
924 /* Pretend there's a paragraph separator at end of buffer. */
928 FETCH_CHAR_ADVANCE (ch
, pos
, bytepos
);
930 if (type
== STRONG_R
|| type
== STRONG_AL
) /* P3 */
931 bidi_it
->paragraph_dir
= R2L
;
932 else if (type
== STRONG_L
)
933 bidi_it
->paragraph_dir
= L2R
;
938 /* Contrary to UAX#9 clause P3, we only default the paragraph
939 direction to L2R if we have no previous usable paragraph
941 if (bidi_it
->paragraph_dir
== NEUTRAL_DIR
)
942 bidi_it
->paragraph_dir
= L2R
; /* P3 and ``higher protocols'' */
943 if (bidi_it
->paragraph_dir
== R2L
)
944 bidi_it
->level_stack
[0].level
= 1;
946 bidi_it
->level_stack
[0].level
= 0;
948 bidi_line_init (bidi_it
);
951 /* Do whatever UAX#9 clause X8 says should be done at paragraph's
954 bidi_set_paragraph_end (struct bidi_it
*bidi_it
)
956 bidi_it
->invalid_levels
= 0;
957 bidi_it
->invalid_rl_levels
= -1;
958 bidi_it
->stack_idx
= 0;
959 bidi_it
->resolved_level
= bidi_it
->level_stack
[0].level
;
962 /* Initialize the bidi iterator from buffer position CHARPOS. */
964 bidi_init_it (EMACS_INT charpos
, EMACS_INT bytepos
, struct bidi_it
*bidi_it
)
966 if (! bidi_initialized
)
968 bidi_it
->charpos
= charpos
;
969 bidi_it
->bytepos
= bytepos
;
970 bidi_it
->first_elt
= 1;
971 bidi_set_paragraph_end (bidi_it
);
972 bidi_it
->new_paragraph
= 1;
973 bidi_it
->separator_limit
= -1;
974 bidi_it
->type
= NEUTRAL_B
;
975 bidi_it
->type_after_w1
= UNKNOWN_BT
;
976 bidi_it
->orig_type
= UNKNOWN_BT
;
977 bidi_it
->prev_was_pdf
= 0;
978 bidi_it
->prev
.type
= bidi_it
->prev
.type_after_w1
= UNKNOWN_BT
;
979 bidi_it
->last_strong
.type
= bidi_it
->last_strong
.type_after_w1
=
980 bidi_it
->last_strong
.orig_type
= UNKNOWN_BT
;
981 bidi_it
->next_for_neutral
.charpos
= -1;
982 bidi_it
->next_for_neutral
.type
=
983 bidi_it
->next_for_neutral
.type_after_w1
=
984 bidi_it
->next_for_neutral
.orig_type
= UNKNOWN_BT
;
985 bidi_it
->prev_for_neutral
.charpos
= -1;
986 bidi_it
->prev_for_neutral
.type
=
987 bidi_it
->prev_for_neutral
.type_after_w1
=
988 bidi_it
->prev_for_neutral
.orig_type
= UNKNOWN_BT
;
989 bidi_it
->sor
= L2R
; /* FIXME: should it be user-selectable? */
992 /* Push the current embedding level and override status; reset the
993 current level to LEVEL and the current override status to OVERRIDE. */
995 bidi_push_embedding_level (struct bidi_it
*bidi_it
,
996 int level
, bidi_dir_t override
)
998 bidi_it
->stack_idx
++;
999 if (bidi_it
->stack_idx
>= BIDI_MAXLEVEL
)
1001 bidi_it
->level_stack
[bidi_it
->stack_idx
].level
= level
;
1002 bidi_it
->level_stack
[bidi_it
->stack_idx
].override
= override
;
1005 /* Pop the embedding level and directional override status from the
1006 stack, and return the new level. */
1008 bidi_pop_embedding_level (struct bidi_it
*bidi_it
)
1010 /* UAX#9 says to ignore invalid PDFs. */
1011 if (bidi_it
->stack_idx
> 0)
1012 bidi_it
->stack_idx
--;
1013 return bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1016 /* Record in SAVED_INFO the information about the current character. */
1018 bidi_remember_char (struct bidi_saved_info
*saved_info
,
1019 struct bidi_it
*bidi_it
)
1021 saved_info
->charpos
= bidi_it
->charpos
;
1022 saved_info
->bytepos
= bidi_it
->bytepos
;
1023 saved_info
->type
= bidi_it
->type
;
1024 bidi_check_type (bidi_it
->type
);
1025 saved_info
->type_after_w1
= bidi_it
->type_after_w1
;
1026 bidi_check_type (bidi_it
->type_after_w1
);
1027 saved_info
->orig_type
= bidi_it
->orig_type
;
1028 bidi_check_type (bidi_it
->orig_type
);
1031 /* Resolve the type of a neutral character according to the type of
1032 surrounding strong text and the current embedding level. */
1033 static inline bidi_type_t
1034 bidi_resolve_neutral_1 (bidi_type_t prev_type
, bidi_type_t next_type
, int lev
)
1036 /* N1: European and Arabic numbers are treated as though they were R. */
1037 if (next_type
== WEAK_EN
|| next_type
== WEAK_AN
)
1038 next_type
= STRONG_R
;
1039 if (prev_type
== WEAK_EN
|| prev_type
== WEAK_AN
)
1040 prev_type
= STRONG_R
;
1042 if (next_type
== prev_type
) /* N1 */
1044 else if ((lev
& 1) == 0) /* N2 */
1051 bidi_explicit_dir_char (int c
)
1053 /* FIXME: this should be replaced with a lookup table with suitable
1054 bits set, like standard C ctype macros do. */
1055 return (c
== LRE_CHAR
|| c
== LRO_CHAR
1056 || c
== RLE_CHAR
|| c
== RLO_CHAR
|| c
== PDF_CHAR
);
1059 /* A helper function for bidi_resolve_explicit. It advances to the
1060 next character in logical order and determines the new embedding
1061 level and directional override, but does not take into account
1062 empty embeddings. */
1064 bidi_resolve_explicit_1 (struct bidi_it
*bidi_it
)
1070 bidi_dir_t override
;
1072 if (bidi_it
->bytepos
< BEGV_BYTE
/* after reseat to BEGV? */
1073 || bidi_it
->first_elt
)
1075 bidi_it
->first_elt
= 0;
1076 if (bidi_it
->charpos
< BEGV
)
1077 bidi_it
->charpos
= BEGV
;
1078 bidi_it
->bytepos
= CHAR_TO_BYTE (bidi_it
->charpos
);
1080 else if (bidi_it
->bytepos
< ZV_BYTE
) /* don't move at ZV */
1083 if (bidi_it
->ch_len
== 0)
1085 bidi_it
->bytepos
+= bidi_it
->ch_len
;
1088 current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
; /* X1 */
1089 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1090 new_level
= current_level
;
1092 /* in case it is a unibyte character (not yet implemented) */
1093 /* _fetch_multibyte_char_len = 1; */
1094 if (bidi_it
->bytepos
>= ZV_BYTE
)
1097 bidi_it
->ch_len
= 1;
1101 curchar
= FETCH_CHAR (bidi_it
->bytepos
);
1102 bidi_it
->ch_len
= CHAR_BYTES (curchar
);
1104 bidi_it
->ch
= curchar
;
1106 /* Don't apply directional override here, as all the types we handle
1107 below will not be affected by the override anyway, and we need
1108 the original type unaltered. The override will be applied in
1109 bidi_resolve_weak. */
1110 type
= bidi_get_type (curchar
, NEUTRAL_DIR
);
1111 bidi_it
->orig_type
= type
;
1112 bidi_check_type (bidi_it
->orig_type
);
1115 bidi_it
->prev_was_pdf
= 0;
1117 bidi_it
->type_after_w1
= UNKNOWN_BT
;
1123 bidi_it
->type_after_w1
= type
;
1124 bidi_check_type (bidi_it
->type_after_w1
);
1125 type
= WEAK_BN
; /* X9/Retaining */
1126 if (bidi_it
->ignore_bn_limit
<= 0)
1128 if (current_level
<= BIDI_MAXLEVEL
- 4)
1130 /* Compute the least odd embedding level greater than
1131 the current level. */
1132 new_level
= ((current_level
+ 1) & ~1) + 1;
1133 if (bidi_it
->type_after_w1
== RLE
)
1134 override
= NEUTRAL_DIR
;
1137 if (current_level
== BIDI_MAXLEVEL
- 4)
1138 bidi_it
->invalid_rl_levels
= 0;
1139 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1143 bidi_it
->invalid_levels
++;
1144 /* See the commentary about invalid_rl_levels below. */
1145 if (bidi_it
->invalid_rl_levels
< 0)
1146 bidi_it
->invalid_rl_levels
= 0;
1147 bidi_it
->invalid_rl_levels
++;
1150 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1151 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1156 bidi_it
->type_after_w1
= type
;
1157 bidi_check_type (bidi_it
->type_after_w1
);
1158 type
= WEAK_BN
; /* X9/Retaining */
1159 if (bidi_it
->ignore_bn_limit
<= 0)
1161 if (current_level
<= BIDI_MAXLEVEL
- 5)
1163 /* Compute the least even embedding level greater than
1164 the current level. */
1165 new_level
= ((current_level
+ 2) & ~1);
1166 if (bidi_it
->type_after_w1
== LRE
)
1167 override
= NEUTRAL_DIR
;
1170 bidi_push_embedding_level (bidi_it
, new_level
, override
);
1174 bidi_it
->invalid_levels
++;
1175 /* invalid_rl_levels counts invalid levels encountered
1176 while the embedding level was already too high for
1177 LRE/LRO, but not for RLE/RLO. That is because
1178 there may be exactly one PDF which we should not
1179 ignore even though invalid_levels is non-zero.
1180 invalid_rl_levels helps to know what PDF is
1182 if (bidi_it
->invalid_rl_levels
>= 0)
1183 bidi_it
->invalid_rl_levels
++;
1186 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1187 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1191 bidi_it
->type_after_w1
= type
;
1192 bidi_check_type (bidi_it
->type_after_w1
);
1193 type
= WEAK_BN
; /* X9/Retaining */
1194 if (bidi_it
->ignore_bn_limit
<= 0)
1196 if (!bidi_it
->invalid_rl_levels
)
1198 new_level
= bidi_pop_embedding_level (bidi_it
);
1199 bidi_it
->invalid_rl_levels
= -1;
1200 if (bidi_it
->invalid_levels
)
1201 bidi_it
->invalid_levels
--;
1202 /* else nothing: UAX#9 says to ignore invalid PDFs */
1204 if (!bidi_it
->invalid_levels
)
1205 new_level
= bidi_pop_embedding_level (bidi_it
);
1208 bidi_it
->invalid_levels
--;
1209 bidi_it
->invalid_rl_levels
--;
1212 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* W5/Retaining */
1213 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1221 bidi_it
->type
= type
;
1222 bidi_check_type (bidi_it
->type
);
1227 /* Given an iterator state in BIDI_IT, advance one character position
1228 in the buffer to the next character (in the logical order), resolve
1229 any explicit embeddings and directional overrides, and return the
1230 embedding level of the character after resolving explicit
1231 directives and ignoring empty embeddings. */
1233 bidi_resolve_explicit (struct bidi_it
*bidi_it
)
1235 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1236 int new_level
= bidi_resolve_explicit_1 (bidi_it
);
1238 if (prev_level
< new_level
1239 && bidi_it
->type
== WEAK_BN
1240 && bidi_it
->ignore_bn_limit
== 0 /* only if not already known */
1241 && bidi_it
->ch
!= BIDI_EOB
/* not already at EOB */
1242 && bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1243 + bidi_it
->ch_len
)))
1245 /* Avoid pushing and popping embedding levels if the level run
1246 is empty, as this breaks level runs where it shouldn't.
1247 UAX#9 removes all the explicit embedding and override codes,
1248 so empty embeddings disappear without a trace. We need to
1249 behave as if we did the same. */
1250 struct bidi_it saved_it
;
1251 int level
= prev_level
;
1253 bidi_copy_it (&saved_it
, bidi_it
);
1255 while (bidi_explicit_dir_char (FETCH_CHAR (bidi_it
->bytepos
1256 + bidi_it
->ch_len
)))
1258 level
= bidi_resolve_explicit_1 (bidi_it
);
1261 if (level
== prev_level
) /* empty embedding */
1262 saved_it
.ignore_bn_limit
= bidi_it
->charpos
+ 1;
1263 else /* this embedding is non-empty */
1264 saved_it
.ignore_bn_limit
= -1;
1266 bidi_copy_it (bidi_it
, &saved_it
);
1267 if (bidi_it
->ignore_bn_limit
> 0)
1269 /* We pushed a level, but we shouldn't have. Undo that. */
1270 if (!bidi_it
->invalid_rl_levels
)
1272 new_level
= bidi_pop_embedding_level (bidi_it
);
1273 bidi_it
->invalid_rl_levels
= -1;
1274 if (bidi_it
->invalid_levels
)
1275 bidi_it
->invalid_levels
--;
1277 if (!bidi_it
->invalid_levels
)
1278 new_level
= bidi_pop_embedding_level (bidi_it
);
1281 bidi_it
->invalid_levels
--;
1282 bidi_it
->invalid_rl_levels
--;
1287 if (bidi_it
->type
== NEUTRAL_B
) /* X8 */
1289 bidi_set_paragraph_end (bidi_it
);
1290 /* This is needed by bidi_resolve_weak below, and in L1. */
1291 bidi_it
->type_after_w1
= bidi_it
->type
;
1292 bidi_check_type (bidi_it
->type_after_w1
);
1298 /* Advance in the buffer, resolve weak types and return the type of
1299 the next character after weak type resolution. */
1301 bidi_resolve_weak (struct bidi_it
*bidi_it
)
1304 bidi_dir_t override
;
1305 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1306 int new_level
= bidi_resolve_explicit (bidi_it
);
1308 bidi_type_t type_of_next
;
1309 struct bidi_it saved_it
;
1311 type
= bidi_it
->type
;
1312 override
= bidi_it
->level_stack
[bidi_it
->stack_idx
].override
;
1314 if (type
== UNKNOWN_BT
1322 if (new_level
!= prev_level
1323 || bidi_it
->type
== NEUTRAL_B
)
1325 /* We've got a new embedding level run, compute the directional
1326 type of sor and initialize per-run variables (UAX#9, clause
1328 bidi_set_sor_type (bidi_it
, prev_level
, new_level
);
1330 else if (type
== NEUTRAL_S
|| type
== NEUTRAL_WS
1331 || type
== WEAK_BN
|| type
== STRONG_AL
)
1332 bidi_it
->type_after_w1
= type
; /* needed in L1 */
1333 bidi_check_type (bidi_it
->type_after_w1
);
1335 /* Level and directional override status are already recorded in
1336 bidi_it, and do not need any change; see X6. */
1337 if (override
== R2L
) /* X6 */
1339 else if (override
== L2R
)
1343 if (type
== WEAK_NSM
) /* W1 */
1345 /* Note that we don't need to consider the case where the
1346 prev character has its type overridden by an RLO or LRO:
1347 such characters are outside the current level run, and
1348 thus not relevant to this NSM. Thus, NSM gets the
1349 orig_type of the previous character. */
1350 if (bidi_it
->prev
.type
!= UNKNOWN_BT
)
1351 type
= bidi_it
->prev
.orig_type
;
1352 else if (bidi_it
->sor
== R2L
)
1354 else if (bidi_it
->sor
== L2R
)
1356 else /* shouldn't happen! */
1359 if (type
== WEAK_EN
/* W2 */
1360 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)
1362 else if (type
== STRONG_AL
) /* W3 */
1364 else if ((type
== WEAK_ES
/* W4 */
1365 && bidi_it
->prev
.type_after_w1
== WEAK_EN
1366 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1368 && ((bidi_it
->prev
.type_after_w1
== WEAK_EN
1369 && bidi_it
->prev
.orig_type
== WEAK_EN
)
1370 || bidi_it
->prev
.type_after_w1
== WEAK_AN
)))
1373 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1374 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1375 type_of_next
= bidi_get_type (next_char
, override
);
1377 if (type_of_next
== WEAK_BN
1378 || bidi_explicit_dir_char (next_char
))
1380 bidi_copy_it (&saved_it
, bidi_it
);
1381 while (bidi_resolve_explicit (bidi_it
) == new_level
1382 && bidi_it
->type
== WEAK_BN
)
1384 type_of_next
= bidi_it
->type
;
1385 bidi_copy_it (bidi_it
, &saved_it
);
1388 /* If the next character is EN, but the last strong-type
1389 character is AL, that next EN will be changed to AN when
1390 we process it in W2 above. So in that case, this ES
1391 should not be changed into EN. */
1393 && type_of_next
== WEAK_EN
1394 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1396 else if (type
== WEAK_CS
)
1398 if (bidi_it
->prev
.type_after_w1
== WEAK_AN
1399 && (type_of_next
== WEAK_AN
1400 /* If the next character is EN, but the last
1401 strong-type character is AL, EN will be later
1402 changed to AN when we process it in W2 above.
1403 So in that case, this ES should not be
1405 || (type_of_next
== WEAK_EN
1406 && bidi_it
->last_strong
.type_after_w1
== STRONG_AL
)))
1408 else if (bidi_it
->prev
.type_after_w1
== WEAK_EN
1409 && type_of_next
== WEAK_EN
1410 && bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1414 else if (type
== WEAK_ET
/* W5: ET with EN before or after it */
1415 || type
== WEAK_BN
) /* W5/Retaining */
1417 if (bidi_it
->prev
.type_after_w1
== WEAK_EN
/* ET/BN w/EN before it */
1418 || bidi_it
->next_en_pos
> bidi_it
->charpos
)
1420 else /* W5: ET/BN with EN after it. */
1422 EMACS_INT en_pos
= bidi_it
->charpos
+ 1;
1425 bidi_it
->bytepos
+ bidi_it
->ch_len
>= ZV_BYTE
1426 ? BIDI_EOB
: FETCH_CHAR (bidi_it
->bytepos
+ bidi_it
->ch_len
);
1427 type_of_next
= bidi_get_type (next_char
, override
);
1429 if (type_of_next
== WEAK_ET
1430 || type_of_next
== WEAK_BN
1431 || bidi_explicit_dir_char (next_char
))
1433 bidi_copy_it (&saved_it
, bidi_it
);
1434 while (bidi_resolve_explicit (bidi_it
) == new_level
1435 && (bidi_it
->type
== WEAK_BN
1436 || bidi_it
->type
== WEAK_ET
))
1438 type_of_next
= bidi_it
->type
;
1439 en_pos
= bidi_it
->charpos
;
1440 bidi_copy_it (bidi_it
, &saved_it
);
1442 if (type_of_next
== WEAK_EN
)
1444 /* If the last strong character is AL, the EN we've
1445 found will become AN when we get to it (W2). */
1446 if (bidi_it
->last_strong
.type_after_w1
!= STRONG_AL
)
1449 /* Remember this EN position, to speed up processing
1451 bidi_it
->next_en_pos
= en_pos
;
1453 else if (type
== WEAK_BN
)
1454 type
= NEUTRAL_ON
; /* W6/Retaining */
1460 if (type
== WEAK_ES
|| type
== WEAK_ET
|| type
== WEAK_CS
/* W6 */
1462 && (bidi_it
->prev
.type_after_w1
== WEAK_CS
/* W6/Retaining */
1463 || bidi_it
->prev
.type_after_w1
== WEAK_ES
1464 || bidi_it
->prev
.type_after_w1
== WEAK_ET
)))
1467 /* Store the type we've got so far, before we clobber it with strong
1468 types in W7 and while resolving neutral types. But leave alone
1469 the original types that were recorded above, because we will need
1470 them for the L1 clause. */
1471 if (bidi_it
->type_after_w1
== UNKNOWN_BT
)
1472 bidi_it
->type_after_w1
= type
;
1473 bidi_check_type (bidi_it
->type_after_w1
);
1475 if (type
== WEAK_EN
) /* W7 */
1477 if ((bidi_it
->last_strong
.type_after_w1
== STRONG_L
)
1478 || (bidi_it
->last_strong
.type
== UNKNOWN_BT
&& bidi_it
->sor
== L2R
))
1482 bidi_it
->type
= type
;
1483 bidi_check_type (bidi_it
->type
);
1488 bidi_resolve_neutral (struct bidi_it
*bidi_it
)
1490 int prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1491 bidi_type_t type
= bidi_resolve_weak (bidi_it
);
1492 int current_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1494 if (!(type
== STRONG_R
1499 || type
== NEUTRAL_B
1500 || type
== NEUTRAL_S
1501 || type
== NEUTRAL_WS
1502 || type
== NEUTRAL_ON
))
1505 if (bidi_get_category (type
) == NEUTRAL
1506 || (type
== WEAK_BN
&& prev_level
== current_level
))
1508 if (bidi_it
->next_for_neutral
.type
!= UNKNOWN_BT
)
1509 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1510 bidi_it
->next_for_neutral
.type
,
1514 /* Arrrgh!! The UAX#9 algorithm is too deeply entrenched in
1515 the assumption of batch-style processing; see clauses W4,
1516 W5, and especially N1, which require to look far forward
1517 (as well as back) in the buffer. May the fleas of a
1518 thousand camels infest the armpits of those who design
1519 supposedly general-purpose algorithms by looking at their
1520 own implementations, and fail to consider other possible
1522 struct bidi_it saved_it
;
1523 bidi_type_t next_type
;
1525 if (bidi_it
->scan_dir
== -1)
1528 bidi_copy_it (&saved_it
, bidi_it
);
1529 /* Scan the text forward until we find the first non-neutral
1530 character, and then use that to resolve the neutral we
1531 are dealing with now. We also cache the scanned iterator
1532 states, to salvage some of the effort later. */
1533 bidi_cache_iterator_state (bidi_it
, 0);
1535 /* Record the info about the previous character, so that
1536 it will be cached below with this state. */
1537 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1538 && bidi_it
->type
!= WEAK_BN
)
1539 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1540 type
= bidi_resolve_weak (bidi_it
);
1541 /* Paragraph separators have their levels fully resolved
1542 at this point, so cache them as resolved. */
1543 bidi_cache_iterator_state (bidi_it
, type
== NEUTRAL_B
);
1544 /* FIXME: implement L1 here, by testing for a newline and
1545 resetting the level for any sequence of whitespace
1546 characters adjacent to it. */
1547 } while (!(type
== NEUTRAL_B
1549 && bidi_get_category (type
) != NEUTRAL
)
1550 /* This is all per level run, so stop when we
1551 reach the end of this level run. */
1552 || bidi_it
->level_stack
[bidi_it
->stack_idx
].level
!=
1555 bidi_remember_char (&saved_it
.next_for_neutral
, bidi_it
);
1566 /* N1: ``European and Arabic numbers are treated as
1567 though they were R.'' */
1568 next_type
= STRONG_R
;
1569 saved_it
.next_for_neutral
.type
= STRONG_R
;
1572 if (!bidi_explicit_dir_char (bidi_it
->ch
))
1573 abort (); /* can't happen: BNs are skipped */
1576 /* Marched all the way to the end of this level run.
1577 We need to use the eor type, whose information is
1578 stored by bidi_set_sor_type in the prev_for_neutral
1580 if (saved_it
.type
!= WEAK_BN
1581 || bidi_get_category (bidi_it
->prev
.type_after_w1
) == NEUTRAL
)
1583 next_type
= bidi_it
->prev_for_neutral
.type
;
1584 saved_it
.next_for_neutral
.type
= next_type
;
1585 bidi_check_type (next_type
);
1589 /* This is a BN which does not adjoin neutrals.
1590 Leave its type alone. */
1591 bidi_copy_it (bidi_it
, &saved_it
);
1592 return bidi_it
->type
;
1598 type
= bidi_resolve_neutral_1 (saved_it
.prev_for_neutral
.type
,
1599 next_type
, current_level
);
1600 saved_it
.type
= type
;
1601 bidi_check_type (type
);
1602 bidi_copy_it (bidi_it
, &saved_it
);
1608 /* Given an iterator state in BIDI_IT, advance one character position
1609 in the buffer to the next character (in the logical order), resolve
1610 the bidi type of that next character, and return that type. */
1612 bidi_type_of_next_char (struct bidi_it
*bidi_it
)
1616 /* This should always be called during a forward scan. */
1617 if (bidi_it
->scan_dir
!= 1)
1620 /* Reset the limit until which to ignore BNs if we step out of the
1621 area where we found only empty levels. */
1622 if ((bidi_it
->ignore_bn_limit
> 0
1623 && bidi_it
->ignore_bn_limit
<= bidi_it
->charpos
)
1624 || (bidi_it
->ignore_bn_limit
== -1
1625 && !bidi_explicit_dir_char (bidi_it
->ch
)))
1626 bidi_it
->ignore_bn_limit
= 0;
1628 type
= bidi_resolve_neutral (bidi_it
);
1633 /* Given an iterator state BIDI_IT, advance one character position in
1634 the buffer to the next character (in the logical order), resolve
1635 the embedding and implicit levels of that next character, and
1636 return the resulting level. */
1638 bidi_level_of_next_char (struct bidi_it
*bidi_it
)
1641 int level
, prev_level
= -1;
1642 struct bidi_saved_info next_for_neutral
;
1644 if (bidi_it
->scan_dir
== 1)
1646 /* There's no sense in trying to advance if we hit end of text. */
1647 if (bidi_it
->ch
== BIDI_EOB
)
1648 return bidi_it
->resolved_level
;
1650 /* Record the info about the previous character. */
1651 if (bidi_it
->type_after_w1
!= WEAK_BN
/* W1/Retaining */
1652 && bidi_it
->type
!= WEAK_BN
)
1653 bidi_remember_char (&bidi_it
->prev
, bidi_it
);
1654 if (bidi_it
->type_after_w1
== STRONG_R
1655 || bidi_it
->type_after_w1
== STRONG_L
1656 || bidi_it
->type_after_w1
== STRONG_AL
)
1657 bidi_remember_char (&bidi_it
->last_strong
, bidi_it
);
1658 /* FIXME: it sounds like we don't need both prev and
1659 prev_for_neutral members, but I'm leaving them both for now. */
1660 if (bidi_it
->type
== STRONG_R
|| bidi_it
->type
== STRONG_L
1661 || bidi_it
->type
== WEAK_EN
|| bidi_it
->type
== WEAK_AN
)
1662 bidi_remember_char (&bidi_it
->prev_for_neutral
, bidi_it
);
1664 /* If we overstepped the characters used for resolving neutrals
1665 and whitespace, invalidate their info in the iterator. */
1666 if (bidi_it
->charpos
>= bidi_it
->next_for_neutral
.charpos
)
1667 bidi_it
->next_for_neutral
.type
= UNKNOWN_BT
;
1668 if (bidi_it
->next_en_pos
>= 0
1669 && bidi_it
->charpos
>= bidi_it
->next_en_pos
)
1670 bidi_it
->next_en_pos
= -1;
1671 if (bidi_it
->next_for_ws
.type
!= UNKNOWN_BT
1672 && bidi_it
->charpos
>= bidi_it
->next_for_ws
.charpos
)
1673 bidi_it
->next_for_ws
.type
= UNKNOWN_BT
;
1675 /* This must be taken before we fill the iterator with the info
1676 about the next char. If we scan backwards, the iterator
1677 state must be already cached, so there's no need to know the
1678 embedding level of the previous character, since we will be
1679 returning to our caller shortly. */
1680 prev_level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1682 next_for_neutral
= bidi_it
->next_for_neutral
;
1684 /* Perhaps it is already cached. */
1685 type
= bidi_cache_find (bidi_it
->charpos
+ bidi_it
->scan_dir
, -1, bidi_it
);
1686 if (type
!= UNKNOWN_BT
)
1688 /* Don't lose the information for resolving neutrals! The
1689 cached states could have been cached before their
1690 next_for_neutral member was computed. If we are on our way
1691 forward, we can simply take the info from the previous
1693 if (bidi_it
->scan_dir
== 1
1694 && bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1695 bidi_it
->next_for_neutral
= next_for_neutral
;
1697 /* If resolved_level is -1, it means this state was cached
1698 before it was completely resolved, so we cannot return
1700 if (bidi_it
->resolved_level
!= -1)
1701 return bidi_it
->resolved_level
;
1703 if (bidi_it
->scan_dir
== -1)
1704 /* If we are going backwards, the iterator state is already cached
1705 from previous scans, and should be fully resolved. */
1708 if (type
== UNKNOWN_BT
)
1709 type
= bidi_type_of_next_char (bidi_it
);
1711 if (type
== NEUTRAL_B
)
1712 return bidi_it
->resolved_level
;
1714 level
= bidi_it
->level_stack
[bidi_it
->stack_idx
].level
;
1715 if ((bidi_get_category (type
) == NEUTRAL
/* && type != NEUTRAL_B */)
1716 || (type
== WEAK_BN
&& prev_level
== level
))
1718 if (bidi_it
->next_for_neutral
.type
== UNKNOWN_BT
)
1721 /* If the cached state shows a neutral character, it was not
1722 resolved by bidi_resolve_neutral, so do it now. */
1723 type
= bidi_resolve_neutral_1 (bidi_it
->prev_for_neutral
.type
,
1724 bidi_it
->next_for_neutral
.type
,
1728 if (!(type
== STRONG_R
1732 || type
== WEAK_AN
))
1734 bidi_it
->type
= type
;
1735 bidi_check_type (bidi_it
->type
);
1737 /* For L1 below, we need to know, for each WS character, whether
1738 it belongs to a sequence of WS characters preceeding a newline
1739 or a TAB or a paragraph separator. */
1740 if (bidi_it
->orig_type
== NEUTRAL_WS
1741 && bidi_it
->next_for_ws
.type
== UNKNOWN_BT
)
1744 int clen
= bidi_it
->ch_len
;
1745 EMACS_INT bpos
= bidi_it
->bytepos
;
1746 EMACS_INT cpos
= bidi_it
->charpos
;
1750 /*_fetch_multibyte_char_len = 1;*/
1751 ch
= bpos
+ clen
>= ZV_BYTE
? BIDI_EOB
: FETCH_CHAR (bpos
+ clen
);
1754 clen
= (ch
== BIDI_EOB
? 1 : CHAR_BYTES (ch
));
1755 if (ch
== '\n' || ch
== BIDI_EOB
/* || ch == LINESEP_CHAR */)
1758 chtype
= bidi_get_type (ch
, NEUTRAL_DIR
);
1759 } while (chtype
== NEUTRAL_WS
|| chtype
== WEAK_BN
1760 || bidi_explicit_dir_char (ch
)); /* L1/Retaining */
1761 bidi_it
->next_for_ws
.type
= chtype
;
1762 bidi_check_type (bidi_it
->next_for_ws
.type
);
1763 bidi_it
->next_for_ws
.charpos
= cpos
;
1764 bidi_it
->next_for_ws
.bytepos
= bpos
;
1767 /* Resolve implicit levels, with a twist: PDFs get the embedding
1768 level of the enbedding they terminate. See below for the
1770 if (bidi_it
->orig_type
== PDF
1771 /* Don't do this if this formatting code didn't change the
1772 embedding level due to invalid or empty embeddings. */
1773 && prev_level
!= level
)
1775 /* Don't look in UAX#9 for the reason for this: it's our own
1776 private quirk. The reason is that we want the formatting
1777 codes to be delivered so that they bracket the text of their
1778 embedding. For example, given the text
1782 we want it to be displayed as
1790 which will result because we bump up the embedding level as
1791 soon as we see the RLO and pop it as soon as we see the PDF,
1792 so RLO itself has the same embedding level as "teST", and
1793 thus would be normally delivered last, just before the PDF.
1794 The switch below fiddles with the level of PDF so that this
1795 ugly side effect does not happen.
1797 (This is, of course, only important if the formatting codes
1798 are actually displayed, but Emacs does need to display them
1799 if the user wants to.) */
1802 else if (bidi_it
->orig_type
== NEUTRAL_B
/* L1 */
1803 || bidi_it
->orig_type
== NEUTRAL_S
1804 || bidi_it
->ch
== '\n' || bidi_it
->ch
== BIDI_EOB
1805 /* || bidi_it->ch == LINESEP_CHAR */
1806 || (bidi_it
->orig_type
== NEUTRAL_WS
1807 && (bidi_it
->next_for_ws
.type
== NEUTRAL_B
1808 || bidi_it
->next_for_ws
.type
== NEUTRAL_S
)))
1809 level
= bidi_it
->level_stack
[0].level
;
1810 else if ((level
& 1) == 0) /* I1 */
1812 if (type
== STRONG_R
)
1814 else if (type
== WEAK_EN
|| type
== WEAK_AN
)
1819 if (type
== STRONG_L
|| type
== WEAK_EN
|| type
== WEAK_AN
)
1823 bidi_it
->resolved_level
= level
;
1827 /* Move to the other edge of a level given by LEVEL. If END_FLAG is
1828 non-zero, we are at the end of a level, and we need to prepare to
1829 resume the scan of the lower level.
1831 If this level's other edge is cached, we simply jump to it, filling
1832 the iterator structure with the iterator state on the other edge.
1833 Otherwise, we walk the buffer until we come back to the same level
1836 Note: we are not talking here about a ``level run'' in the UAX#9
1837 sense of the term, but rather about a ``level'' which includes
1838 all the levels higher than it. In other words, given the levels
1841 11111112222222333333334443343222222111111112223322111
1844 and assuming we are at point A scanning left to right, this
1845 function moves to point C, whereas the UAX#9 ``level 2 run'' ends
1848 bidi_find_other_level_edge (struct bidi_it
*bidi_it
, int level
, int end_flag
)
1850 int dir
= end_flag
? -bidi_it
->scan_dir
: bidi_it
->scan_dir
;
1853 /* Try the cache first. */
1854 if ((idx
= bidi_cache_find_level_change (level
, dir
, end_flag
)) >= 0)
1855 bidi_cache_fetch_state (idx
, bidi_it
);
1861 abort (); /* if we are at end of level, its edges must be cached */
1863 bidi_cache_iterator_state (bidi_it
, 1);
1865 new_level
= bidi_level_of_next_char (bidi_it
);
1866 bidi_cache_iterator_state (bidi_it
, 1);
1867 } while (new_level
>= level
);
1872 bidi_get_next_char_visually (struct bidi_it
*bidi_it
)
1874 int old_level
, new_level
, next_level
;
1875 struct bidi_it sentinel
;
1877 if (bidi_it
->scan_dir
== 0)
1879 bidi_it
->scan_dir
= 1; /* default to logical order */
1882 /* If we just passed a newline, initialize for the next line. */
1883 if (!bidi_it
->first_elt
&& bidi_it
->orig_type
== NEUTRAL_B
)
1884 bidi_line_init (bidi_it
);
1886 /* Prepare the sentinel iterator state. */
1887 if (bidi_cache_idx
== 0)
1889 bidi_copy_it (&sentinel
, bidi_it
);
1890 if (bidi_it
->first_elt
)
1892 sentinel
.charpos
--; /* cached charpos needs to be monotonic */
1894 sentinel
.ch
= '\n'; /* doesn't matter, but why not? */
1895 sentinel
.ch_len
= 1;
1899 old_level
= bidi_it
->resolved_level
;
1900 new_level
= bidi_level_of_next_char (bidi_it
);
1902 /* Reordering of resolved levels (clause L2) is implemented by
1903 jumping to the other edge of the level and flipping direction of
1904 scanning the text whenever we find a level change. */
1905 if (new_level
!= old_level
)
1907 int ascending
= new_level
> old_level
;
1908 int level_to_search
= ascending
? old_level
+ 1 : old_level
;
1909 int incr
= ascending
? 1 : -1;
1910 int expected_next_level
= old_level
+ incr
;
1912 /* If we don't have anything cached yet, we need to cache the
1913 sentinel state, since we'll need it to record where to jump
1914 when the last non-base level is exhausted. */
1915 if (bidi_cache_idx
== 0)
1916 bidi_cache_iterator_state (&sentinel
, 1);
1917 /* Jump (or walk) to the other edge of this level. */
1918 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1919 /* Switch scan direction and peek at the next character in the
1921 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1923 /* The following loop handles the case where the resolved level
1924 jumps by more than one. This is typical for numbers inside a
1925 run of text with left-to-right embedding direction, but can
1926 also happen in other situations. In those cases the decision
1927 where to continue after a level change, and in what direction,
1928 is tricky. For example, given a text like below:
1933 (where the numbers below the text show the resolved levels),
1934 the result of reordering according to UAX#9 should be this:
1938 This is implemented by the loop below which flips direction
1939 and jumps to the other edge of the level each time it finds
1940 the new level not to be the expected one. The expected level
1941 is always one more or one less than the previous one. */
1942 next_level
= bidi_peek_at_next_level (bidi_it
);
1943 while (next_level
!= expected_next_level
)
1945 expected_next_level
+= incr
;
1946 level_to_search
+= incr
;
1947 bidi_find_other_level_edge (bidi_it
, level_to_search
, !ascending
);
1948 bidi_it
->scan_dir
= -bidi_it
->scan_dir
;
1949 next_level
= bidi_peek_at_next_level (bidi_it
);
1952 /* Finally, deliver the next character in the new direction. */
1953 next_level
= bidi_level_of_next_char (bidi_it
);
1956 /* Take note when we have just processed the newline that precedes
1957 the end of the paragraph. The next time we are about to be
1958 called, set_iterator_to_next will automatically reinit the
1959 paragraph direction, if needed. We do this at the newline before
1960 the paragraph separator, because the next character might not be
1961 the first character of the next paragraph, due to the bidi
1962 reordering, whereas we _must_ know the paragraph base direction
1963 _before_ we process the paragraph's text, since the base
1964 direction affects the reordering. */
1965 if (bidi_it
->scan_dir
== 1
1966 && bidi_it
->orig_type
== NEUTRAL_B
1967 && bidi_it
->bytepos
< ZV_BYTE
)
1970 bidi_at_paragraph_end (bidi_it
->charpos
+ 1,
1971 bidi_it
->bytepos
+ bidi_it
->ch_len
);
1974 bidi_it
->new_paragraph
= 1;
1975 /* Record the buffer position of the last character of the
1976 paragraph separator. */
1977 bidi_it
->separator_limit
= bidi_it
->charpos
+ 1 + sep_len
;
1981 if (bidi_it
->scan_dir
== 1 && bidi_cache_idx
)
1983 /* If we are at paragraph's base embedding level and beyond the
1984 last cached position, the cache's job is done and we can
1986 if (bidi_it
->resolved_level
== bidi_it
->level_stack
[0].level
1987 && bidi_it
->charpos
> bidi_cache
[bidi_cache_idx
- 1].charpos
)
1988 bidi_cache_reset ();
1989 /* But as long as we are caching during forward scan, we must
1990 cache each state, or else the cache integrity will be
1991 compromised: it assumes cached states correspond to buffer
1994 bidi_cache_iterator_state (bidi_it
, 1);
1998 /* This is meant to be called from within the debugger, whenever you
1999 wish to examine the cache contents. */
2001 bidi_dump_cached_states (void)
2006 if (bidi_cache_idx
== 0)
2008 fprintf (stderr
, "The cache is empty.\n");
2011 fprintf (stderr
, "Total of %d state%s in cache:\n",
2012 bidi_cache_idx
, bidi_cache_idx
== 1 ? "" : "s");
2014 for (i
= bidi_cache
[bidi_cache_idx
- 1].charpos
; i
> 0; i
/= 10)
2016 fputs ("ch ", stderr
);
2017 for (i
= 0; i
< bidi_cache_idx
; i
++)
2018 fprintf (stderr
, "%*c", ndigits
, bidi_cache
[i
].ch
);
2019 fputs ("\n", stderr
);
2020 fputs ("lvl ", stderr
);
2021 for (i
= 0; i
< bidi_cache_idx
; i
++)
2022 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].resolved_level
);
2023 fputs ("\n", stderr
);
2024 fputs ("pos ", stderr
);
2025 for (i
= 0; i
< bidi_cache_idx
; i
++)
2026 fprintf (stderr
, "%*d", ndigits
, bidi_cache
[i
].charpos
);
2027 fputs ("\n", stderr
);