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