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, b_HL, b_CJ, b_RI};
  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                 break;
 101         }
 102     }
 103
 104     /* LB1 */
 105     /* TODO: Have outside algorithms for these scripts */
 106     for (i = 0; i < count; i++)
 107     {
 108         switch(break_class[i])
 109         {
 110             case b_AI:
 111             case b_SA:
 112             case b_SG:
 113             case b_XX:
 114                 break_class[i] = b_AL;
 115                 break;
 116             case b_CJ:
 117                 break_class[i] = b_NS;
 118                 break;
 119         }
 120     }
 121
 122     /* LB2 - LB3 */
 123     break_before[0] = b_x;
 124     for (i = 0; i < count; i++)
 125     {
 126         switch(break_class[i])
 127         {
 128             /* LB4 - LB6 */
 129             case b_CR:
 130                 if (i < count-1 && break_class[i+1] == b_LF)
 131                 {
 132                     else_break(&break_before[i],b_x);
 133                     else_break(&break_before[i+1],b_x);
 134                     break;
 135                 }
 136             case b_LF:
 137             case b_NL:
 138             case b_BK:
 139                 if (i < count-1) else_break(&break_before[i+1],b_r);
 140                 else_break(&break_before[i],b_x);
 141                 break;
 142             /* LB7 */
 143             case b_SP:
 144                 else_break(&break_before[i],b_x);
 145                 break;
 146             case b_ZW:
 147                 else_break(&break_before[i],b_x);
 148             /* LB8 */
 149                 while (i < count-1 && break_class[i+1] == b_SP)
 150                     i++;
 151                 else_break(&break_before[i],b_s);
 152                 break;
 153         }
 154     }
 155
 156     debug_output_breaks(break_before,count);
 157
 158     /* LB9 - LB10 */
 159     for (i = 0; i < count; i++)
 160     {
 161         if (break_class[i] == b_CM)
 162         {
 163             if (i > 0)
 164             {
 165                 switch (break_class[i-1])
 166                 {
 167                     case b_SP:
 168                     case b_BK:
 169                     case b_CR:
 170                     case b_LF:
 171                     case b_NL:
 172                     case b_ZW:
 173                         break_class[i] = b_AL;
 174                         break;
 175                     default:
 176                         break_class[i] = break_class[i-1];
 177                 }
 178             }
 179             else break_class[i] = b_AL;
 180         }
 181     }
 182
 183     for (i = 0; i < count; i++)
 184     {
 185         switch(break_class[i])
 186         {
 187             /* LB11 */
 188             case b_WJ:
 189                 else_break(&break_before[i],b_x);
 190                 if (i < count-1)
 191                     else_break(&break_before[i+1],b_x);
 192                 break;
 193             /* LB12 */
 194             case b_GL:
 195                 if (i < count-1)
 196                     else_break(&break_before[i+1],b_x);
 197             /* LB12a */
 198                 if (i > 0)
 199                 {
 200                     if (break_class[i-1] != b_SP &&
 201                         break_class[i-1] != b_BA &&
 202                         break_class[i-1] != b_HY)
 203                         else_break(&break_before[i],b_x);
 204                 }
 205                 break;
 206             /* LB13 */
 207             case b_CL:
 208             case b_CP:
 209             case b_EX:
 210             case b_IS:
 211             case b_SY:
 212                 else_break(&break_before[i],b_x);
 213                 break;
 214             /* LB14 */
 215             case b_OP:
 216                 while (i < count-1 && break_class[i+1] == b_SP)
 217                 {
 218                     else_break(&break_before[i+1],b_x);
 219                     i++;
 220                 }
 221                 else_break(&break_before[i+1],b_x);
 222                 break;
 223             /* LB15 */
 224             case b_QU:
 225                 j = i+1;
 226                 while (j < count-1 && break_class[j] == b_SP)
 227                     j++;
 228                 if (break_class[j] == b_OP)
 229                 {
 230                     for (; j > i; j--)
 231                         else_break(&break_before[j],b_x);
 232                 }
 233                 break;
 234             /* LB16 */
 235             case b_NS:
 236                 j = i-1;
 237                 while(j > 0 && break_class[j] == b_SP)
 238                     j--;
 239                 if (break_class[j] == b_CL || break_class[j] == b_CP)
 240                 {
 241                     for (j++; j <= i; j++)
 242                         else_break(&break_before[j],b_x);
 243                 }
 244                 break;
 245             /* LB17 */
 246             case b_B2:
 247                 j = i+1;
 248                 while (j < count && break_class[j] == b_SP)
 249                     j++;
 250                 if (break_class[j] == b_B2)
 251                 {
 252                     for (; j > i; j--)
 253                         else_break(&break_before[j],b_x);
 254                 }
 255                 break;
 256         }
 257     }
 258
 259     debug_output_breaks(break_before,count);
 260
 261     for (i = 0; i < count; i++)
 262     {
 263         switch(break_class[i])
 264         {
 265             /* LB18 */
 266             case b_SP:
 267                 if (i < count-1)
 268                     else_break(&break_before[i+1],b_s);
 269                 break;
 270             /* LB19 */
 271             case b_QU:
 272                 else_break(&break_before[i],b_x);
 273                 if (i < count-1)
 274                     else_break(&break_before[i+1],b_x);
 275                 break;
 276             /* LB20 */
 277             case b_CB:
 278                 else_break(&break_before[i],b_s);
 279                 if (i < count-1)
 280                     else_break(&break_before[i+1],b_s);
 281                 break;
 282             /* LB21 */
 283             case b_BA:
 284             case b_HY:
 285             case b_NS:
 286                 else_break(&break_before[i],b_x);
 287                 break;
 288             case b_BB:
 289                 if (i < count-1)
 290                     else_break(&break_before[i+1],b_x);
 291                 break;
 292             /* LB21a */
 293             case b_HL:
 294                 if (i < count-2)
 295                     switch (break_class[i+1])
 296                     {
 297                     case b_HY:
 298                     case b_BA:
 299                         else_break(&break_before[i+2], b_x);
 300                     }
 301                 break;
 302             /* LB22 */
 303             case b_IN:
 304                 if (i > 0)
 305                 {
 306                     switch (break_class[i-1])
 307                     {
 308                         case b_AL:
 309                         case b_HL:
 310                         case b_ID:
 311                         case b_IN:
 312                         case b_NU:
 313                             else_break(&break_before[i], b_x);
 314                     }
 315                 }
 316                 break;
 317         }
 318
 319         if (i < count-1)
 320         {
 321             /* LB23 */
 322             if ((break_class[i] == b_ID && break_class[i+1] == b_PO) ||
 323                 (break_class[i] == b_AL && break_class[i+1] == b_NU) ||
 324                 (break_class[i] == b_HL && break_class[i+1] == b_NU) ||
 325                 (break_class[i] == b_NU && break_class[i+1] == b_AL) ||
 326                 (break_class[i] == b_NU && break_class[i+1] == b_HL))
 327                     else_break(&break_before[i+1],b_x);
 328             /* LB24 */
 329             if ((break_class[i] == b_PR && break_class[i+1] == b_ID) ||
 330                 (break_class[i] == b_PR && break_class[i+1] == b_AL) ||
 331                 (break_class[i] == b_PR && break_class[i+1] == b_HL) ||
 332                 (break_class[i] == b_PO && break_class[i+1] == b_AL) ||
 333                 (break_class[i] == b_PO && break_class[i+1] == b_HL))
 334                     else_break(&break_before[i+1],b_x);
 335
 336             /* LB25 */
 337             if ((break_class[i] == b_CL && break_class[i+1] == b_PO) ||
 338                 (break_class[i] == b_CP && break_class[i+1] == b_PO) ||
 339                 (break_class[i] == b_CL && break_class[i+1] == b_PR) ||
 340                 (break_class[i] == b_CP && break_class[i+1] == b_PR) ||
 341                 (break_class[i] == b_NU && break_class[i+1] == b_PO) ||
 342                 (break_class[i] == b_NU && break_class[i+1] == b_PR) ||
 343                 (break_class[i] == b_PO && break_class[i+1] == b_OP) ||
 344                 (break_class[i] == b_PO && break_class[i+1] == b_NU) ||
 345                 (break_class[i] == b_PR && break_class[i+1] == b_OP) ||
 346                 (break_class[i] == b_PR && break_class[i+1] == b_NU) ||
 347                 (break_class[i] == b_HY && break_class[i+1] == b_NU) ||
 348                 (break_class[i] == b_IS && break_class[i+1] == b_NU) ||
 349                 (break_class[i] == b_NU && break_class[i+1] == b_NU) ||
 350                 (break_class[i] == b_SY && break_class[i+1] == b_NU))
 351                     else_break(&break_before[i+1],b_x);
 352
 353             /* LB26 */
 354             if (break_class[i] == b_JL)
 355             {
 356                 switch (break_class[i+1])
 357                 {
 358                     case b_JL:
 359                     case b_JV:
 360                     case b_H2:
 361                     case b_H3:
 362                         else_break(&break_before[i+1],b_x);
 363                 }
 364             }
 365             if ((break_class[i] == b_JV || break_class[i] == b_H2) &&
 366                 (break_class[i+1] == b_JV || break_class[i+1] == b_JT))
 367                     else_break(&break_before[i+1],b_x);
 368             if ((break_class[i] == b_JT || break_class[i] == b_H3) &&
 369                  break_class[i+1] == b_JT)
 370                     else_break(&break_before[i+1],b_x);
 371
 372             /* LB27 */
 373             switch (break_class[i])
 374             {
 375                 case b_JL:
 376                 case b_JV:
 377                 case b_JT:
 378                 case b_H2:
 379                 case b_H3:
 380                     if (break_class[i+1] == b_IN || break_class[i+1] == b_PO)
 381                         else_break(&break_before[i+1],b_x);
 382             }
 383             if (break_class[i] == b_PO)
 384             {
 385                 switch (break_class[i+1])
 386                 {
 387                     case b_JL:
 388                     case b_JV:
 389                     case b_JT:
 390                     case b_H2:
 391                     case b_H3:
 392                         else_break(&break_before[i+1],b_x);
 393                 }
 394             }
 395
 396             /* LB28 */
 397             if ((break_class[i] == b_AL && break_class[i+1] == b_AL) ||
 398                 (break_class[i] == b_AL && break_class[i+1] == b_HL) ||
 399                 (break_class[i] == b_HL && break_class[i+1] == b_AL) ||
 400                 (break_class[i] == b_HL && break_class[i+1] == b_HL))
 401                 else_break(&break_before[i+1],b_x);
 402
 403             /* LB29 */
 404             if ((break_class[i] == b_IS && break_class[i+1] == b_AL) ||
 405                 (break_class[i] == b_IS && break_class[i+1] == b_HL))
 406                 else_break(&break_before[i+1],b_x);
 407
 408             /* LB30 */
 409             if ((break_class[i] == b_AL || break_class[i] == b_HL || break_class[i] == b_NU) &&
 410                  break_class[i+1] == b_OP)
 411                 else_break(&break_before[i+1],b_x);
 412             if (break_class[i] == b_CP &&
 413                 (break_class[i+1] == b_AL || break_class[i] == b_HL || break_class[i] == b_NU))
 414                 else_break(&break_before[i+1],b_x);
 415
 416             /* LB30a */
 417             if (break_class[i] == b_RI && break_class[i+1] == b_RI)
 418                 else_break(&break_before[i+1],b_x);
 419         }
 420     }
 421     debug_output_breaks(break_before,count);
 422
 423     /* LB31 */
 424     for (i = 0; i < count-1; i++)
 425         else_break(&break_before[i+1],b_s);
 426
 427     debug_output_breaks(break_before,count);
 428     for (i = 0; i < count; i++)
 429     {
 430         if (break_before[i] != b_x)
 431         {
 432             la[i].fSoftBreak = TRUE;
 433             la[i].fWordStop = TRUE;
 434         }
 435     }
 436
 437     HeapFree(GetProcessHeap(), 0, break_before);
 438     HeapFree(GetProcessHeap(), 0, break_class);
 439 }