projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk r58687.
[reactos.git] / dll / win32 / usp10 / breaking.c
1 /*
2 * Implementation of line breaking algorithm for the Uniscribe Script Processor
3 *
4 * Copyright 2011 CodeWeavers, Aric Stewart
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 */
21 #include <config.h>
22 #include <stdarg.h>
23 //#include <stdio.h>
24 //#include <stdlib.h>
25
26 #include <windef.h>
27 #include <winbase.h>
28 //#include "winuser.h"
29 #include <wingdi.h>
30 //#include "winnls.h"
31 #include <usp10.h>
32 //#include "winternl.h"
33
34 #include <wine/debug.h>
35 #include "usp10_internal.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
38
39 extern const unsigned short wine_linebreak_table[];
40
41 enum breaking_types { b_BK=1, b_CR, b_LF, b_CM, b_SG, b_GL, b_CB, b_SP, b_ZW, b_NL, b_WJ, b_JL, b_JV, b_JT, b_H2, b_H3, b_XX, b_OP, b_CL, b_CP, b_QU, b_NS, b_EX, b_SY, b_IS, b_PR, b_PO, b_NU, b_AL, b_ID, b_IN, b_HY, b_BB, b_BA, b_SA, b_AI, b_B2};
42
43 enum breaking_class {b_r=1, b_s, b_x};
44
45 static void debug_output_breaks(const short* breaks, int count)
46 {
47 if (TRACE_ON(uniscribe))
48 {
49 int i;
50 TRACE("[");
51 for (i = 0; i < count && i < 200; i++)
52 {
53 switch (breaks[i])
54 {
55 case b_x: TRACE("x"); break;
56 case b_r: TRACE("!"); break;
57 case b_s: TRACE("+"); break;
58 default: TRACE("*");
59 }
60 }
61 if (i == 200)
62 TRACE("...");
63 TRACE("]\n");
64 }
65 }
66
67 static inline void else_break(short* before, short class)
68 {
69 if (*before == 0) *before = class;
70 }
71
72 void BREAK_line(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
73 {
74 int i,j;
75 short *break_class;
76 short *break_before;
77
78 TRACE("In %s\n",debugstr_wn(chars,count));
79
80 break_class = HeapAlloc(GetProcessHeap(),0, count * sizeof(short));
81 break_before = HeapAlloc(GetProcessHeap(),0, count * sizeof(short));
82
83 for (i = 0; i < count; i++)
84 {
85 break_class[i] = get_table_entry( wine_linebreak_table, chars[i] );
86 break_before[i] = 0;
87
88 memset(&la[i],0,sizeof(SCRIPT_LOGATTR));
89
90 la[i].fCharStop = TRUE;
91 switch (break_class[i])
92 {
93 case b_BK:
94 case b_ZW:
95 case b_SP:
96 la[i].fWhiteSpace = TRUE;
97 break;
98 case b_CM:
99 la[i].fCharStop = FALSE;
100 }
101 }
102
103 /* LB1 */
104 /* TODO: Have outside algorithms for these scripts */
105 for (i = 0; i < count; i++)
106 {
107 switch(break_class[i])
108 {
109 case b_AI:
110 case b_SA:
111 case b_SG:
112 case b_XX:
113 break_class[i] = b_AL;
114 }
115 }
116
117 /* LB2 - LB3 */
118 break_before[0] = b_x;
119 for (i = 0; i < count; i++)
120 {
121 switch(break_class[i])
122 {
123 /* LB4 - LB6 */
124 case b_CR:
125 if (i < count-1 && break_class[i+1] == b_LF)
126 {
127 else_break(&break_before[i],b_x);
128 else_break(&break_before[i+1],b_x);
129 break;
130 }
131 case b_LF:
132 case b_NL:
133 case b_BK:
134 if (i < count-1) else_break(&break_before[i+1],b_r);
135 else_break(&break_before[i],b_x);
136 break;
137 /* LB7 */
138 case b_SP:
139 else_break(&break_before[i],b_x);
140 break;
141 case b_ZW:
142 else_break(&break_before[i],b_x);
143 /* LB8 */
144 while (i < count-1 && break_class[i+1] == b_SP)
145 i++;
146 else_break(&break_before[i],b_s);
147 break;
148 }
149 }
150
151 debug_output_breaks(break_before,count);
152
153 /* LB9 - LB10 */
154 for (i = 0; i < count; i++)
155 {
156 if (break_class[i] == b_CM)
157 {
158 if (i > 0)
159 {
160 switch (break_class[i-1])
161 {
162 case b_SP:
163 case b_BK:
164 case b_CR:
165 case b_LF:
166 case b_NL:
167 case b_ZW:
168 break_class[i] = b_AL;
169 break;
170 default:
171 break_class[i] = break_class[i-1];
172 }
173 }
174 else break_class[i] = b_AL;
175 }
176 }
177
178 for (i = 0; i < count; i++)
179 {
180 switch(break_class[i])
181 {
182 /* LB11 */
183 case b_WJ:
184 else_break(&break_before[i],b_x);
185 if (i < count-1)
186 else_break(&break_before[i+1],b_x);
187 break;
188 /* LB12 */
189 case b_GL:
190 if (i < count-1)
191 else_break(&break_before[i+1],b_x);
192 /* LB12a */
193 if (i > 0)
194 {
195 if (break_class[i-1] != b_SP &&
196 break_class[i-1] != b_BA &&
197 break_class[i-1] != b_HY)
198 else_break(&break_before[i],b_x);
199 }
200 break;
201 /* LB13 */
202 case b_CL:
203 case b_CP:
204 case b_EX:
205 case b_IS:
206 case b_SY:
207 else_break(&break_before[i],b_x);
208 break;
209 /* LB14 */
210 case b_OP:
211 while (i < count-1 && break_class[i+1] == b_SP)
212 {
213 else_break(&break_before[i+1],b_x);
214 i++;
215 }
216 else_break(&break_before[i+1],b_x);
217 break;
218 /* LB15 */
219 case b_QU:
220 j = i+1;
221 while (j < count-1 && break_class[j] == b_SP)
222 j++;
223 if (break_class[j] == b_OP)
224 {
225 for (; j > i; j--)
226 else_break(&break_before[j],b_x);
227 }
228 break;
229 /* LB16 */
230 case b_NS:
231 j = i-1;
232 while(j > 0 && break_class[j] == b_SP)
233 j--;
234 if (break_class[j] == b_CL || break_class[j] == b_CP)
235 {
236 for (j++; j <= i; j++)
237 else_break(&break_before[j],b_x);
238 }
239 break;
240 /* LB17 */
241 case b_B2:
242 j = i+1;
243 while (j < count && break_class[j] == b_SP)
244 j++;
245 if (break_class[j] == b_B2)
246 {
247 for (; j > i; j--)
248 else_break(&break_before[j],b_x);
249 }
250 break;
251 }
252 }
253
254 debug_output_breaks(break_before,count);
255
256 for (i = 0; i < count; i++)
257 {
258 switch(break_class[i])
259 {
260 /* LB18 */
261 case b_SP:
262 if (i < count-1)
263 else_break(&break_before[i+1],b_s);
264 break;
265 /* LB19 */
266 case b_QU:
267 else_break(&break_before[i],b_x);
268 if (i < count-1)
269 else_break(&break_before[i+1],b_x);
270 break;
271 /* LB20 */
272 case b_CB:
273 else_break(&break_before[i],b_s);
274 if (i < count-1)
275 else_break(&break_before[i+1],b_s);
276 /* LB21 */
277 case b_BA:
278 case b_HY:
279 case b_NS:
280 else_break(&break_before[i],b_x);
281 break;
282 case b_BB:
283 if (i < count-1)
284 else_break(&break_before[i+1],b_x);
285 break;
286 /* LB22 */
287 case b_IN:
288 if (i > 0)
289 {
290 switch (break_class[i-1])
291 {
292 case b_AL:
293 case b_ID:
294 case b_IN:
295 case b_NU:
296 else_break(&break_before[i], b_x);
297 }
298 }
299 break;
300 }
301
302 if (i < count-1)
303 {
304 /* LB23 */
305 if ((break_class[i] == b_ID && break_class[i+1] == b_PO) ||
306 (break_class[i] == b_AL && break_class[i+1] == b_NU) ||
307 (break_class[i] == b_NU && break_class[i+1] == b_AL))
308 else_break(&break_before[i+1],b_x);
309 /* LB24 */
310 if ((break_class[i] == b_PR && break_class[i+1] == b_ID) ||
311 (break_class[i] == b_PR && break_class[i+1] == b_AL) ||
312 (break_class[i] == b_PO && break_class[i+1] == b_AL))
313 else_break(&break_before[i+1],b_x);
314
315 /* LB25 */
316 if ((break_class[i] == b_CL && break_class[i+1] == b_PO) ||
317 (break_class[i] == b_CP && break_class[i+1] == b_PO) ||
318 (break_class[i] == b_CL && break_class[i+1] == b_PR) ||
319 (break_class[i] == b_CP && break_class[i+1] == b_PR) ||
320 (break_class[i] == b_NU && break_class[i+1] == b_PO) ||
321 (break_class[i] == b_NU && break_class[i+1] == b_PR) ||
322 (break_class[i] == b_PO && break_class[i+1] == b_OP) ||
323 (break_class[i] == b_PO && break_class[i+1] == b_NU) ||
324 (break_class[i] == b_PR && break_class[i+1] == b_OP) ||
325 (break_class[i] == b_PR && break_class[i+1] == b_NU) ||
326 (break_class[i] == b_HY && break_class[i+1] == b_NU) ||
327 (break_class[i] == b_IS && break_class[i+1] == b_NU) ||
328 (break_class[i] == b_NU && break_class[i+1] == b_NU) ||
329 (break_class[i] == b_SY && break_class[i+1] == b_NU))
330 else_break(&break_before[i+1],b_x);
331
332 /* LB26 */
333 if (break_class[i] == b_JL)
334 {
335 switch (break_class[i+1])
336 {
337 case b_JL:
338 case b_JV:
339 case b_H2:
340 case b_H3:
341 else_break(&break_before[i+1],b_x);
342 }
343 }
344 if ((break_class[i] == b_JV || break_class[i] == b_H2) &&
345 (break_class[i+1] == b_JV || break_class[i+1] == b_JT))
346 else_break(&break_before[i+1],b_x);
347 if ((break_class[i] == b_JT || break_class[i] == b_H3) &&
348 break_class[i+1] == b_JT)
349 else_break(&break_before[i+1],b_x);
350
351 /* LB27 */
352 switch (break_class[i])
353 {
354 case b_JL:
355 case b_JV:
356 case b_JT:
357 case b_H2:
358 case b_H3:
359 if (break_class[i+1] == b_IN || break_class[i+1] == b_PO)
360 else_break(&break_before[i+1],b_x);
361 }
362 if (break_class[i] == b_PO)
363 {
364 switch (break_class[i+1])
365 {
366 case b_JL:
367 case b_JV:
368 case b_JT:
369 case b_H2:
370 case b_H3:
371 else_break(&break_before[i+1],b_x);
372 }
373 }
374
375 /* LB28 */
376 if (break_class[i] == b_AL && break_class[i+1] == b_AL)
377 else_break(&break_before[i+1],b_x);
378
379 /* LB29 */
380 if (break_class[i] == b_IS && break_class[i+1] == b_AL)
381 else_break(&break_before[i+1],b_x);
382
383 /* LB30 */
384 if ((break_class[i] == b_AL || break_class[i] == b_NU) &&
385 break_class[i+1] == b_OP)
386 else_break(&break_before[i+1],b_x);
387 if (break_class[i] == b_CP &&
388 (break_class[i+1] == b_AL || break_class[i] == b_NU))
389 else_break(&break_before[i+1],b_x);
390 }
391 }
392 debug_output_breaks(break_before,count);
393
394 /* LB31 */
395 for (i = 0; i < count-1; i++)
396 else_break(&break_before[i+1],b_s);
397
398 debug_output_breaks(break_before,count);
399 for (i = 0; i < count; i++)
400 {
401 if (break_before[i] != b_x)
402 {
403 la[i].fSoftBreak = TRUE;
404 la[i].fWordStop = TRUE;
405 }
406 }
407
408 HeapFree(GetProcessHeap(), 0, break_before);
409 HeapFree(GetProcessHeap(), 0, break_class);
410 }
A free Windows-compatible Operating System