urlmon: Added AsyncInstallDistributionUnit implementation.
[wine] / dlls / 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 }