Lines Matching full:diff
248 * mode decoder's incomplete (diff<<2)|count (ignored when toULength==0)
263 * @param diff difference value -0x10ffff..0x10ffff
271 packDiff(int32_t diff) {
274 if(diff>=BOCU1_REACH_NEG_1) {
277 if(diff<=BOCU1_REACH_POS_1) {
279 return 0x01000000|(BOCU1_MIDDLE+diff);
282 if(diff<=BOCU1_REACH_POS_2) {
284 diff-=BOCU1_REACH_POS_1+1;
287 m=diff%BOCU1_TRAIL_COUNT;
288 diff/=BOCU1_TRAIL_COUNT;
291 result|=(BOCU1_START_POS_2+diff)<<8;
292 } else if(diff<=BOCU1_REACH_POS_3) {
294 diff-=BOCU1_REACH_POS_2+1;
297 m=diff%BOCU1_TRAIL_COUNT;
298 diff/=BOCU1_TRAIL_COUNT;
301 m=diff%BOCU1_TRAIL_COUNT;
302 diff/=BOCU1_TRAIL_COUNT;
305 result|=(BOCU1_START_POS_3+diff)<<16;
308 diff-=BOCU1_REACH_POS_3+1;
310 m=diff%BOCU1_TRAIL_COUNT;
311 diff/=BOCU1_TRAIL_COUNT;
314 m=diff%BOCU1_TRAIL_COUNT;
315 diff/=BOCU1_TRAIL_COUNT;
319 * We know that / and % would deliver quotient 0 and rest=diff.
322 result|=BOCU1_TRAIL_TO_BYTE(diff)<<16;
328 if(diff>=BOCU1_REACH_NEG_2) {
330 diff-=BOCU1_REACH_NEG_1;
333 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
336 result|=(BOCU1_START_NEG_2+diff)<<8;
337 } else if(diff>=BOCU1_REACH_NEG_3) {
339 diff-=BOCU1_REACH_NEG_2;
342 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
345 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
348 result|=(BOCU1_START_NEG_3+diff)<<16;
351 diff-=BOCU1_REACH_NEG_3;
353 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
356 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
361 * quotient -1 and rest=diff+BOCU1_TRAIL_COUNT.
364 m=diff+BOCU1_TRAIL_COUNT;
373 /* Faster versions of packDiff() for single-byte-encoded diff values. */
375 /** Is a diff value encodable in a single byte? */
376 #define DIFF_IS_SINGLE(diff) (BOCU1_REACH_NEG_1<=(diff) && (diff)<=BOCU1_REACH_POS_1)
378 /** Encode a diff value in a single byte. */
379 #define PACK_SINGLE_DIFF(diff) (BOCU1_MIDDLE+(diff))
381 /** Is a diff value encodable in two bytes? */
382 #define DIFF_IS_DOUBLE(diff) (BOCU1_REACH_NEG_2<=(diff) && (diff)<=BOCU1_REACH_POS_2)
393 int32_t prev, c, diff;
426 diff=(int32_t)(sourceLimit-source);
427 if(targetCapacity>diff) {
428 targetCapacity=diff;
440 diff=c-prev;
441 if(DIFF_IS_SINGLE(diff)) {
443 *target++=(uint8_t)PACK_SINGLE_DIFF(diff);
505 diff=c-prev;
507 if(DIFF_IS_SINGLE(diff)) {
508 *target++=(uint8_t)PACK_SINGLE_DIFF(diff);
515 } else if(DIFF_IS_DOUBLE(diff) && 2<=targetCapacity) {
519 if(diff>=0) {
520 diff-=BOCU1_REACH_POS_1+1;
521 m=diff%BOCU1_TRAIL_COUNT;
522 diff/=BOCU1_TRAIL_COUNT;
523 diff+=BOCU1_START_POS_2;
525 diff-=BOCU1_REACH_NEG_1;
526 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
527 diff+=BOCU1_START_NEG_2;
529 *target++=(uint8_t)diff;
538 diff=packDiff(diff);
539 length=BOCU1_LENGTH_FROM_PACKED(diff);
541 /* write the output character bytes from diff and length */
547 *target++=(uint8_t)(diff>>24);
550 *target++=(uint8_t)(diff>>16);
553 *target++=(uint8_t)(diff>>8);
556 *target++=(uint8_t)diff;
579 *charErrorBuffer++=(uint8_t)(diff>>16);
581 *charErrorBuffer++=(uint8_t)(diff>>8);
583 *charErrorBuffer=(uint8_t)diff;
591 diff>>=8*length; /* length was reduced by targetCapacity */
595 *target++=(uint8_t)(diff>>16);
598 *target++=(uint8_t)(diff>>8);
601 *target++=(uint8_t)diff;
646 int32_t prev, c, diff;
670 diff=(int32_t)(sourceLimit-source);
671 if(targetCapacity>diff) {
672 targetCapacity=diff;
681 diff=c-prev;
682 if(DIFF_IS_SINGLE(diff)) {
684 *target++=(uint8_t)PACK_SINGLE_DIFF(diff);
739 diff=c-prev;
741 if(DIFF_IS_SINGLE(diff)) {
742 *target++=(uint8_t)PACK_SINGLE_DIFF(diff);
747 } else if(DIFF_IS_DOUBLE(diff) && 2<=targetCapacity) {
751 if(diff>=0) {
752 diff-=BOCU1_REACH_POS_1+1;
753 m=diff%BOCU1_TRAIL_COUNT;
754 diff/=BOCU1_TRAIL_COUNT;
755 diff+=BOCU1_START_POS_2;
757 diff-=BOCU1_REACH_NEG_1;
758 NEGDIVMOD(diff, BOCU1_TRAIL_COUNT, m);
759 diff+=BOCU1_START_NEG_2;
761 *target++=(uint8_t)diff;
767 diff=packDiff(diff);
768 length=BOCU1_LENGTH_FROM_PACKED(diff);
770 /* write the output character bytes from diff and length */
776 *target++=(uint8_t)(diff>>24);
778 *target++=(uint8_t)(diff>>16);
780 *target++=(uint8_t)(diff>>8);
782 *target++=(uint8_t)diff;
803 *charErrorBuffer++=(uint8_t)(diff>>16);
805 *charErrorBuffer++=(uint8_t)(diff>>8);
807 *charErrorBuffer=(uint8_t)diff;
815 diff>>=8*length; /* length was reduced by targetCapacity */
819 *target++=(uint8_t)(diff>>16);
821 *target++=(uint8_t)(diff>>8);
823 *target++=(uint8_t)diff;
858 * @return (diff<<2)|count
862 int32_t diff, count;
868 diff=((int32_t)b-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1;
872 diff=((int32_t)b-BOCU1_START_POS_3)*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_2+1;
876 diff=BOCU1_REACH_POS_3+1;
883 diff=((int32_t)b-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1;
887 diff=((int32_t)b-BOCU1_START_NEG_3)*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_2;
891 diff=-BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_3;
897 return (diff<<2)|count;
905 * @return new delta for diff including b - <0 indicates an error
942 int32_t prev, count, diff, c;
962 diff=cnv->mode; /* mode may be set to UCNV_SI by ucnv_bld.c but then toULength==0 */
963 count=diff&3;
964 diff>>=2;
981 diff=(int32_t)(sourceLimit-source);
983 if(count>diff) {
984 count=diff;
1045 diff=((int32_t)c-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1;
1047 diff=((int32_t)c-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1;
1053 if(c<0 || (uint32_t)(c=prev+diff+c)>0x10ffff) {
1074 diff=decodeBocu1LeadByte(c);
1075 count=diff&3;
1076 diff>>=2;
1092 diff+=c;
1096 c=prev+diff;
1138 cnv->mode=(diff<<2)|count;
1164 int32_t prev, count, diff, c;
1183 diff=cnv->mode; /* mode may be set to UCNV_SI by ucnv_bld.c but then toULength==0 */
1184 count=diff&3;
1185 diff>>=2;
1198 diff=(int32_t)(sourceLimit-source);
1200 if(count>diff) {
1201 count=diff;
1254 diff=((int32_t)c-BOCU1_START_POS_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_POS_1+1;
1256 diff=((int32_t)c-BOCU1_START_NEG_2)*BOCU1_TRAIL_COUNT+BOCU1_REACH_NEG_1;
1261 if(c<0 || (uint32_t)(c=prev+diff+c)>0x10ffff) {
1281 diff=decodeBocu1LeadByte(c);
1282 count=diff&3;
1283 diff>>=2;
1298 diff+=c;
1302 c=prev+diff;
1339 cnv->mode=(diff<<2)|count;
