icuSources/common/ubidiwrt.c

   1 /*
   2 ******************************************************************************
   3 *
   4 *   Copyright (C) 2000-2011, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 ******************************************************************************
   8 *   file name:  ubidiwrt.c
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 1999aug06
  14 *   created by: Markus W. Scherer, updated by Matitiahu Allouche
  15 *
  16 * This file contains implementations for BiDi functions that use
  17 * the core algorithm and core API to write reordered text.
  18 */
  19
  20 /* set import/export definitions */
  21 #ifndef U_COMMON_IMPLEMENTATION
  22 #   define U_COMMON_IMPLEMENTATION
  23 #endif
  24
  25 #include "unicode/utypes.h"
  26 #include "unicode/ustring.h"
  27 #include "unicode/uchar.h"
  28 #include "unicode/ubidi.h"
  29 #include "unicode/utf16.h"
  30 #include "cmemory.h"
  31 #include "ustr_imp.h"
  32 #include "ubidiimp.h"
  33
  34 /*
  35  * The function implementations in this file are designed
  36  * for UTF-16 and UTF-32, not for UTF-8.
  37  *
  38  * Assumptions that are not true for UTF-8:
  39  * - Any code point always needs the same number of code units
  40  *   ("minimum-length-problem" of UTF-8)
  41  * - The BiDi control characters need only one code unit each
  42  *
  43  * Further assumptions for all UTFs:
  44  * - u_charMirror(c) needs the same number of code units as c
  45  */
  46 #if UTF_SIZE==8
  47 # error reimplement ubidi_writeReordered() for UTF-8, see comment above
  48 #endif
  49
  50 #define IS_COMBINING(type) ((1UL<<(type))&(1UL<<U_NON_SPACING_MARK|1UL<<U_COMBINING_SPACING_MARK|1UL<<U_ENCLOSING_MARK))
  51
  52 /*
  53  * When we have UBIDI_OUTPUT_REVERSE set on ubidi_writeReordered(), then we
  54  * semantically write RTL runs in reverse and later reverse them again.
  55  * Instead, we actually write them in forward order to begin with.
  56  * However, if the RTL run was to be mirrored, we need to mirror here now
  57  * since the implicit second reversal must not do it.
  58  * It looks strange to do mirroring in LTR output, but it is only because
  59  * we are writing RTL output in reverse.
  60  */
  61 static int32_t
  62 doWriteForward(const UChar *src, int32_t srcLength,
  63                UChar *dest, int32_t destSize,
  64                uint16_t options,
  65                UErrorCode *pErrorCode) {
  66     /* optimize for several combinations of options */
  67     switch(options&(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING)) {
  68     case 0: {
  69         /* simply copy the LTR run to the destination */
  70         int32_t length=srcLength;
  71         if(destSize<length) {
  72             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
  73             return srcLength;
  74         }
  75         do {
  76             *dest++=*src++;
  77         } while(--length>0);
  78         return srcLength;
  79     }
  80     case UBIDI_DO_MIRRORING: {
  81         /* do mirroring */
  82         int32_t i=0, j=0;
  83         UChar32 c;
  84
  85         if(destSize<srcLength) {
  86             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
  87             return srcLength;
  88         }
  89         do {
  90             U16_NEXT(src, i, srcLength, c);
  91             c=u_charMirror(c);
  92             U16_APPEND_UNSAFE(dest, j, c);
  93         } while(i<srcLength);
  94         return srcLength;
  95     }
  96     case UBIDI_REMOVE_BIDI_CONTROLS: {
  97         /* copy the LTR run and remove any BiDi control characters */
  98         int32_t remaining=destSize;
  99         UChar c;
 100         do {
 101             c=*src++;
 102             if(!IS_BIDI_CONTROL_CHAR(c)) {
 103                 if(--remaining<0) {
 104                     *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 105
 106                     /* preflight the length */
 107                     while(--srcLength>0) {
 108                         c=*src++;
 109                         if(!IS_BIDI_CONTROL_CHAR(c)) {
 110                             --remaining;
 111                         }
 112                     }
 113                     return destSize-remaining;
 114                 }
 115                 *dest++=c;
 116             }
 117         } while(--srcLength>0);
 118         return destSize-remaining;
 119     }
 120     default: {
 121         /* remove BiDi control characters and do mirroring */
 122         int32_t remaining=destSize;
 123         int32_t i, j=0;
 124         UChar32 c;
 125         do {
 126             i=0;
 127             U16_NEXT(src, i, srcLength, c);
 128             src+=i;
 129             srcLength-=i;
 130             if(!IS_BIDI_CONTROL_CHAR(c)) {
 131                 remaining-=i;
 132                 if(remaining<0) {
 133                     *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 134
 135                     /* preflight the length */
 136                     while(srcLength>0) {
 137                         c=*src++;
 138                         if(!IS_BIDI_CONTROL_CHAR(c)) {
 139                             --remaining;
 140                         }
 141                         --srcLength;
 142                     }
 143                     return destSize-remaining;
 144                 }
 145                 c=u_charMirror(c);
 146                 U16_APPEND_UNSAFE(dest, j, c);
 147             }
 148         } while(srcLength>0);
 149         return j;
 150     }
 151     } /* end of switch */
 152 }
 153
 154 static int32_t
 155 doWriteReverse(const UChar *src, int32_t srcLength,
 156                UChar *dest, int32_t destSize,
 157                uint16_t options,
 158                UErrorCode *pErrorCode) {
 159     /*
 160      * RTL run -
 161      *
 162      * RTL runs need to be copied to the destination in reverse order
 163      * of code points, not code units, to keep Unicode characters intact.
 164      *
 165      * The general strategy for this is to read the source text
 166      * in backward order, collect all code units for a code point
 167      * (and optionally following combining characters, see below),
 168      * and copy all these code units in ascending order
 169      * to the destination for this run.
 170      *
 171      * Several options request whether combining characters
 172      * should be kept after their base characters,
 173      * whether BiDi control characters should be removed, and
 174      * whether characters should be replaced by their mirror-image
 175      * equivalent Unicode characters.
 176      */
 177     int32_t i, j;
 178     UChar32 c;
 179
 180     /* optimize for several combinations of options */
 181     switch(options&(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING)) {
 182     case 0:
 183         /*
 184          * With none of the "complicated" options set, the destination
 185          * run will have the same length as the source run,
 186          * and there is no mirroring and no keeping combining characters
 187          * with their base characters.
 188          */
 189         if(destSize<srcLength) {
 190             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 191             return srcLength;
 192         }
 193         destSize=srcLength;
 194
 195         /* preserve character integrity */
 196         do {
 197             /* i is always after the last code unit known to need to be kept in this segment */
 198             i=srcLength;
 199
 200             /* collect code units for one base character */
 201             U16_BACK_1(src, 0, srcLength);
 202
 203             /* copy this base character */
 204             j=srcLength;
 205             do {
 206                 *dest++=src[j++];
 207             } while(j<i);
 208         } while(srcLength>0);
 209         break;
 210     case UBIDI_KEEP_BASE_COMBINING:
 211         /*
 212          * Here, too, the destination
 213          * run will have the same length as the source run,
 214          * and there is no mirroring.
 215          * We do need to keep combining characters with their base characters.
 216          */
 217         if(destSize<srcLength) {
 218             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 219             return srcLength;
 220         }
 221         destSize=srcLength;
 222
 223         /* preserve character integrity */
 224         do {
 225             /* i is always after the last code unit known to need to be kept in this segment */
 226             i=srcLength;
 227
 228             /* collect code units and modifier letters for one base character */
 229             do {
 230                 U16_PREV(src, 0, srcLength, c);
 231             } while(srcLength>0 && IS_COMBINING(u_charType(c)));
 232
 233             /* copy this "user character" */
 234             j=srcLength;
 235             do {
 236                 *dest++=src[j++];
 237             } while(j<i);
 238         } while(srcLength>0);
 239         break;
 240     default:
 241         /*
 242          * With several "complicated" options set, this is the most
 243          * general and the slowest copying of an RTL run.
 244          * We will do mirroring, remove BiDi controls, and
 245          * keep combining characters with their base characters
 246          * as requested.
 247          */
 248         if(!(options&UBIDI_REMOVE_BIDI_CONTROLS)) {
 249             i=srcLength;
 250         } else {
 251             /* we need to find out the destination length of the run,
 252                which will not include the BiDi control characters */
 253             int32_t length=srcLength;
 254             UChar ch;
 255
 256             i=0;
 257             do {
 258                 ch=*src++;
 259                 if(!IS_BIDI_CONTROL_CHAR(ch)) {
 260                     ++i;
 261                 }
 262             } while(--length>0);
 263             src-=srcLength;
 264         }
 265
 266         if(destSize<i) {
 267             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 268             return i;
 269         }
 270         destSize=i;
 271
 272         /* preserve character integrity */
 273         do {
 274             /* i is always after the last code unit known to need to be kept in this segment */
 275             i=srcLength;
 276
 277             /* collect code units for one base character */
 278             U16_PREV(src, 0, srcLength, c);
 279             if(options&UBIDI_KEEP_BASE_COMBINING) {
 280                 /* collect modifier letters for this base character */
 281                 while(srcLength>0 && IS_COMBINING(u_charType(c))) {
 282                     U16_PREV(src, 0, srcLength, c);
 283                 }
 284             }
 285
 286             if(options&UBIDI_REMOVE_BIDI_CONTROLS && IS_BIDI_CONTROL_CHAR(c)) {
 287                 /* do not copy this BiDi control character */
 288                 continue;
 289             }
 290
 291             /* copy this "user character" */
 292             j=srcLength;
 293             if(options&UBIDI_DO_MIRRORING) {
 294                 /* mirror only the base character */
 295                 int32_t k=0;
 296                 c=u_charMirror(c);
 297                 U16_APPEND_UNSAFE(dest, k, c);
 298                 dest+=k;
 299                 j+=k;
 300             }
 301             while(j<i) {
 302                 *dest++=src[j++];
 303             }
 304         } while(srcLength>0);
 305         break;
 306     } /* end of switch */
 307
 308     return destSize;
 309 }
 310
 311 U_CAPI int32_t U_EXPORT2
 312 ubidi_writeReverse(const UChar *src, int32_t srcLength,
 313                    UChar *dest, int32_t destSize,
 314                    uint16_t options,
 315                    UErrorCode *pErrorCode) {
 316     int32_t destLength;
 317
 318     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 319         return 0;
 320     }
 321
 322     /* more error checking */
 323     if( src==NULL || srcLength<-1 ||
 324         destSize<0 || (destSize>0 && dest==NULL))
 325     {
 326         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 327         return 0;
 328     }
 329
 330     /* do input and output overlap? */
 331     if( dest!=NULL &&
 332         ((src>=dest && src<dest+destSize) ||
 333          (dest>=src && dest<src+srcLength)))
 334     {
 335         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 336         return 0;
 337     }
 338
 339     if(srcLength==-1) {
 340         srcLength=u_strlen(src);
 341     }
 342     if(srcLength>0) {
 343         destLength=doWriteReverse(src, srcLength, dest, destSize, options, pErrorCode);
 344     } else {
 345         /* nothing to do */
 346         destLength=0;
 347     }
 348
 349     return u_terminateUChars(dest, destSize, destLength, pErrorCode);
 350 }
 351
 352 U_CAPI int32_t U_EXPORT2
 353 ubidi_writeReordered(UBiDi *pBiDi,
 354                      UChar *dest, int32_t destSize,
 355                      uint16_t options,
 356                      UErrorCode *pErrorCode) {
 357     const UChar *text;
 358     UChar *saveDest;
 359     int32_t length, destCapacity;
 360     int32_t run, runCount, logicalStart, runLength;
 361
 362     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 363         return 0;
 364     }
 365
 366     /* more error checking */
 367     if( pBiDi==NULL ||
 368         (text=pBiDi->text)==NULL || (length=pBiDi->length)<0 ||
 369         destSize<0 || (destSize>0 && dest==NULL))
 370     {
 371         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 372         return 0;
 373     }
 374
 375     /* do input and output overlap? */
 376     if( dest!=NULL &&
 377         ((text>=dest && text<dest+destSize) ||
 378          (dest>=text && dest<text+pBiDi->originalLength)))
 379     {
 380         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 381         return 0;
 382     }
 383
 384     if(length==0) {
 385         /* nothing to do */
 386         return u_terminateUChars(dest, destSize, 0, pErrorCode);
 387     }
 388
 389     runCount=ubidi_countRuns(pBiDi, pErrorCode);
 390     if(U_FAILURE(*pErrorCode)) {
 391         return 0;
 392     }
 393
 394     /* destSize shrinks, later destination length=destCapacity-destSize */
 395     saveDest=dest;
 396     destCapacity=destSize;
 397
 398     /*
 399      * Option "insert marks" implies UBIDI_INSERT_LRM_FOR_NUMERIC if the
 400      * reordering mode (checked below) is appropriate.
 401      */
 402     if(pBiDi->reorderingOptions & UBIDI_OPTION_INSERT_MARKS) {
 403         options|=UBIDI_INSERT_LRM_FOR_NUMERIC;
 404         options&=~UBIDI_REMOVE_BIDI_CONTROLS;
 405     }
 406     /*
 407      * Option "remove controls" implies UBIDI_REMOVE_BIDI_CONTROLS
 408      * and cancels UBIDI_INSERT_LRM_FOR_NUMERIC.
 409      */
 410     if(pBiDi->reorderingOptions & UBIDI_OPTION_REMOVE_CONTROLS) {
 411         options|=UBIDI_REMOVE_BIDI_CONTROLS;
 412         options&=~UBIDI_INSERT_LRM_FOR_NUMERIC;
 413     }
 414     /*
 415      * If we do not perform the "inverse BiDi" algorithm, then we
 416      * don't need to insert any LRMs, and don't need to test for it.
 417      */
 418     if((pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_NUMBERS_AS_L) &&
 419        (pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_LIKE_DIRECT)  &&
 420        (pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL) &&
 421        (pBiDi->reorderingMode != UBIDI_REORDER_RUNS_ONLY)) {
 422         options&=~UBIDI_INSERT_LRM_FOR_NUMERIC;
 423     }
 424     /*
 425      * Iterate through all visual runs and copy the run text segments to
 426      * the destination, according to the options.
 427      *
 428      * The tests for where to insert LRMs ignore the fact that there may be
 429      * BN codes or non-BMP code points at the beginning and end of a run;
 430      * they may insert LRMs unnecessarily but the tests are faster this way
 431      * (this would have to be improved for UTF-8).
 432      *
 433      * Note that the only errors that are set by doWriteXY() are buffer overflow
 434      * errors. Ignore them until the end, and continue for preflighting.
 435      */
 436     if(!(options&UBIDI_OUTPUT_REVERSE)) {
 437         /* forward output */
 438         if(!(options&UBIDI_INSERT_LRM_FOR_NUMERIC)) {
 439             /* do not insert BiDi controls */
 440             for(run=0; run<runCount; ++run) {
 441                 if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength)) {
 442                     runLength=doWriteForward(text+logicalStart, runLength,
 443                                              dest, destSize,
 444                                              (uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
 445                 } else {
 446                     runLength=doWriteReverse(text+logicalStart, runLength,
 447                                              dest, destSize,
 448                                              options, pErrorCode);
 449                 }
 450                 if(dest!=NULL) {
 451                   dest+=runLength;
 452                 }
 453                 destSize-=runLength;
 454             }
 455         } else {
 456             /* insert BiDi controls for "inverse BiDi" */
 457             const DirProp *dirProps=pBiDi->dirProps;
 458             const UChar *src;
 459             UChar uc;
 460             UBiDiDirection dir;
 461             int32_t markFlag;
 462
 463             for(run=0; run<runCount; ++run) {
 464                 dir=ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength);
 465                 src=text+logicalStart;
 466                 /* check if something relevant in insertPoints */
 467                 markFlag=pBiDi->runs[run].insertRemove;
 468                 if(markFlag<0) {        /* BiDi controls count */
 469                     markFlag=0;
 470                 }
 471
 472                 if(UBIDI_LTR==dir) {
 473                     if((pBiDi->isInverse) &&
 474                        (/*run>0 &&*/ dirProps[logicalStart]!=L)) {
 475                         markFlag |= LRM_BEFORE;
 476                     }
 477                     if (markFlag & LRM_BEFORE) {
 478                         uc=LRM_CHAR;
 479                     }
 480                     else if (markFlag & RLM_BEFORE) {
 481                         uc=RLM_CHAR;
 482                     }
 483                     else  uc=0;
 484                     if(uc) {
 485                         if(destSize>0) {
 486                             *dest++=uc;
 487                         }
 488                         --destSize;
 489                     }
 490
 491                     runLength=doWriteForward(src, runLength,
 492                                              dest, destSize,
 493                                              (uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
 494                     if(dest!=NULL) {
 495                       dest+=runLength;
 496                     }
 497                     destSize-=runLength;
 498
 499                     if((pBiDi->isInverse) &&
 500                        (/*run<runCount-1 &&*/ dirProps[logicalStart+runLength-1]!=L)) {
 501                         markFlag |= LRM_AFTER;
 502                     }
 503                     if (markFlag & LRM_AFTER) {
 504                         uc=LRM_CHAR;
 505                     }
 506                     else if (markFlag & RLM_AFTER) {
 507                         uc=RLM_CHAR;
 508                     }
 509                     else  uc=0;
 510                     if(uc) {
 511                         if(destSize>0) {
 512                             *dest++=uc;
 513                         }
 514                         --destSize;
 515                     }
 516                 } else {                /* RTL run */
 517                     if((pBiDi->isInverse) &&
 518                        (/*run>0 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart+runLength-1])))) {
 519                         markFlag |= RLM_BEFORE;
 520                     }
 521                     if (markFlag & LRM_BEFORE) {
 522                         uc=LRM_CHAR;
 523                     }
 524                     else if (markFlag & RLM_BEFORE) {
 525                         uc=RLM_CHAR;
 526                     }
 527                     else  uc=0;
 528                     if(uc) {
 529                         if(destSize>0) {
 530                             *dest++=uc;
 531                         }
 532                         --destSize;
 533                     }
 534
 535                     runLength=doWriteReverse(src, runLength,
 536                                              dest, destSize,
 537                                              options, pErrorCode);
 538                     if(dest!=NULL) {
 539                       dest+=runLength;
 540                     }
 541                     destSize-=runLength;
 542
 543                     if((pBiDi->isInverse) &&
 544                        (/*run<runCount-1 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart])))) {
 545                         markFlag |= RLM_AFTER;
 546                     }
 547                     if (markFlag & LRM_AFTER) {
 548                         uc=LRM_CHAR;
 549                     }
 550                     else if (markFlag & RLM_AFTER) {
 551                         uc=RLM_CHAR;
 552                     }
 553                     else  uc=0;
 554                     if(uc) {
 555                         if(destSize>0) {
 556                             *dest++=uc;
 557                         }
 558                         --destSize;
 559                     }
 560                 }
 561             }
 562         }
 563     } else {
 564         /* reverse output */
 565         if(!(options&UBIDI_INSERT_LRM_FOR_NUMERIC)) {
 566             /* do not insert BiDi controls */
 567             for(run=runCount; --run>=0;) {
 568                 if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength)) {
 569                     runLength=doWriteReverse(text+logicalStart, runLength,
 570                                              dest, destSize,
 571                                              (uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
 572                 } else {
 573                     runLength=doWriteForward(text+logicalStart, runLength,
 574                                              dest, destSize,
 575                                              options, pErrorCode);
 576                 }
 577                 if(dest!=NULL) {
 578                   dest+=runLength;
 579                 }
 580                 destSize-=runLength;
 581             }
 582         } else {
 583             /* insert BiDi controls for "inverse BiDi" */
 584             const DirProp *dirProps=pBiDi->dirProps;
 585             const UChar *src;
 586             UBiDiDirection dir;
 587
 588             for(run=runCount; --run>=0;) {
 589                 /* reverse output */
 590                 dir=ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength);
 591                 src=text+logicalStart;
 592
 593                 if(UBIDI_LTR==dir) {
 594                     if(/*run<runCount-1 &&*/ dirProps[logicalStart+runLength-1]!=L) {
 595                         if(destSize>0) {
 596                             *dest++=LRM_CHAR;
 597                         }
 598                         --destSize;
 599                     }
 600
 601                     runLength=doWriteReverse(src, runLength,
 602                                              dest, destSize,
 603                                              (uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
 604                     if(dest!=NULL) {
 605                       dest+=runLength;
 606                     }
 607                     destSize-=runLength;
 608
 609                     if(/*run>0 &&*/ dirProps[logicalStart]!=L) {
 610                         if(destSize>0) {
 611                             *dest++=LRM_CHAR;
 612                         }
 613                         --destSize;
 614                     }
 615                 } else {
 616                     if(/*run<runCount-1 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart]))) {
 617                         if(destSize>0) {
 618                             *dest++=RLM_CHAR;
 619                         }
 620                         --destSize;
 621                     }
 622
 623                     runLength=doWriteForward(src, runLength,
 624                                              dest, destSize,
 625                                              options, pErrorCode);
 626                     if(dest!=NULL) {
 627                       dest+=runLength;
 628                     }
 629                     destSize-=runLength;
 630
 631                     if(/*run>0 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart+runLength-1]))) {
 632                         if(destSize>0) {
 633                             *dest++=RLM_CHAR;
 634                         }
 635                         --destSize;
 636                     }
 637                 }
 638             }
 639         }
 640     }
 641
 642     return u_terminateUChars(saveDest, destCapacity, destCapacity-destSize, pErrorCode);
 643 }