Lines Matching defs:bits
159 /* is not useful for longer numbers because overflow of 32 bits */
302 /* masked special-values bits */
303 #define SPECIALARG (rhs->bits & DECSPECIAL)
304 #define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
375 if (in<0) dn->bits=DECNEG; /* sign needed */
407 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; /* bad */
424 if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
429 if (dn->bits&DECNEG) return -i;
442 if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
443 || (dn->bits&DECNEG && !ISZERO(dn))); /* bad */
513 uByte bits=0; /* working flags [assume +ve] */
549 bits=DECNEG;
571 dn->bits=bits | DECINF;
577 dn->bits=bits | DECNAN; /* assume simple NaN */
580 dn->bits=bits | DECSNAN;
609 bits=dn->bits; /* for copy-back */
713 dn->bits=bits;
770 decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
848 if (a|b) { /* maybe 1 bits to examine */
869 res->bits=0; /* sign=0 */
974 a->bits&=~DECNEG; /* .. and clear the sign */
988 b->bits&=~DECNEG; /* .. and clear the sign */
1178 res->bits=DECNAN;
1240 /* always need to examine all bits in rhs */
1256 res->bits=0; /* sign=0 */
1367 res->bits=DECNEG|DECINF; /* -Infinity */
1462 if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
1508 if (a->bits&DECSPECIAL || ISZERO(a)) {
1699 if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
1735 if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1737 res->bits=DECNEG; /* negative */
1787 if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
1789 res->bits=DECNEG; /* negative */
1797 if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
1863 if (a|b) { /* maybe 1 bits to examine */
1883 res->bits=0; /* sign=0 */
1991 uByte bits=0; /* result sign if errors */
2027 Flag rhsneg=rhs->bits&DECNEG; /* save rhs sign */
2037 if (rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2048 if (!rhsneg) res->bits|=DECINF; /* +Infinity [else is +0] */
2065 && isoddint) bits=DECNEG; /* .. to an odd power */
2069 uByte rbits=rhs->bits; /* save */
2077 if (!(rbits & DECNEG)) bits|=DECINF; /* was not a **-n */
2079 res->bits=bits;
2095 uByte rbits=rhs->bits; /* save */
2102 bits|=DECINF;
2106 res->bits=bits;
2243 } /*i*/ /* 32 bits */
2259 dac->bits=(dac->bits & ~DECNEG) | bits; /* force correct sign */
2952 /* [Until further notice, no error is possible and status bits */
2957 t->bits=0; t->digits=3;
2958 a->bits=0; a->digits=3;
3293 if (a|b) { /* maybe 1 bits to examine */
3313 res->bits=0; /* sign=0 */
3393 dest->bits=src->bits;
3426 res->bits&=~DECNEG; /* turn off sign */
3447 res->bits^=DECNEG; /* invert the sign */
3469 sign=rhs->bits & DECNEG; /* save sign bit */
3471 res->bits&=~DECNEG; /* clear the sign */
3472 res->bits|=sign; /* set from rhs */
3623 dn->bits=0;
3669 if (dn->bits&DECSPECIAL) { /* Is a special value */
3675 if (dn->bits&DECSNAN) { /* signalling NaN */
3843 uByte bits; /* result bits */
3876 diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
3889 bits=lhs->bits & DECNEG; /* get sign from LHS */
3891 else bits=(rhs->bits^negate) & DECNEG;/* RHS must be Infinity */
3892 bits|=DECINF;
3894 res->bits=bits; /* set +/- infinity */
3903 bits=lhs->bits; /* .. */
3906 res->bits^=negate; /* flip if rhs was negated */
3916 if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
3917 else res->bits=DECNEG; /* preserve 0 sign */
3939 bits=rhs->bits; /* be clean */
4010 bits=lhs->bits; /* assume sign is that of LHS */
4022 bits=(uByte)(rhs->bits^negate); /* assumed sign is now that of RHS */
4044 if (!swapped) res->bits^=negate;
4081 res->bits=(uByte)(bits&DECNEG); /* it's now safe to overwrite.. */
4099 res->bits^=DECNEG; /* flip the sign */
4165 if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG; /* sign - */
4166 else res->bits&=~DECNEG; /* sign + */
4283 uByte bits; /* working sign */
4314 bits=(lhs->bits^rhs->bits)&DECNEG; /* assumed sign for divisions */
4331 res->bits=bits|DECINF; /* set +/- infinity */
4342 res->bits=bits; /* set +/- zero */
4366 res->bits=bits|DECINF; /* .. is +/- Infinity */
4381 res->bits=bits; /* sign as computed */
4387 res->bits=bits; /* sign as computed */
4400 /* in 31 bits) and becomes the usual unadjusted exponent as the */
4414 res->bits=bits; /* set +/- zero */
4694 bits=lhs->bits; /* remainder sign is always as lhs */
4706 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4801 bits^=DECNEG; /* flip the sign */
4807 /* Set exponent and bits */
4809 res->bits=(uByte)(bits&DECNEG); /* [cleaned] */
4874 uByte bits; /* result sign */
4934 bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
4942 if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
4943 ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
4947 res->bits=bits|DECINF; /* infinity */
5152 res->bits=bits; /* set sign */
5514 } /*i*/ /* 32 bits */
5539 /* top 14 bits encoding 0-9999) and a 2-digit encode of the */
5540 /* exponent (e=the bottom 2 bits encoding 0-3) */
5666 res->bits=DECINF|DECNEG; /* set - infinity */
5753 b->bits=DECNEG; /* ln(0.10)->ln(0.99) always -ve */
5789 a->bits^=DECNEG; /* make -a */
5791 a->bits^=DECNEG; /* restore sign of a */
5914 else if ((lhs->bits ^ rhs->bits) & DECINF)
5946 if (!set->extended) res->bits=0; /* subset specification; no -0 */
5981 if (ISZERO(res) && !set->extended) res->bits=0; /* subset; no -0 */
6092 merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
6121 if (lhs->bits & DECNAN) result=-1; /* pick rhs */
6150 if (result<0) res->bits=DECNEG;
6160 uByte slhs=(lhs->bits & DECNEG);
6161 uByte srhs=(rhs->bits & DECNEG);
6236 if ((lhs->bits | rhs->bits) & DECINF) { /* one or more infinities */
6644 if ((dn->bits & DECSPECIAL) /* fast exit if special .. */
6887 dest->bits=src->bits;
6921 /* updated as necessary. dn->bits (sign) is unchanged. */
7287 dn->bits=0; /* .. and sign */
7323 /* adjusted exponent could overflow 31 bits [because it may already */
7393 uByte sign=dn->bits&DECNEG; /* clean and save sign bit */
7423 dn->bits=sign; /* set sign */
7425 else dn->bits=sign|DECINF; /* Value is +/-Infinity */
7450 dn->bits=0; /* + sign */
7738 if (lhs->bits & DECSNAN)
7741 else if (rhs->bits & DECSNAN) {
7745 else if (lhs->bits & DECNAN);
7754 res->bits=lhs->bits; /* need sign etc. */
7762 res->bits&=~DECSNAN; /* convert any sNaN to NaN, while */
7763 res->bits|=DECNAN; /* .. preserving sign */
7790 dn->bits=DECNAN; /* and make a quiet NaN */
7866 if (dn->bits&DECSPECIAL) { /* Is a special value */
7869 if (dn->bits&DECSNAN) printf("sNaN"); /* signalling NaN */
7985 res->bits=DECNAN; /* qNaN */
8013 if (dn->bits & DECSPECIAL) {
8017 (LI)dn->exponent, dn->bits);
8103 && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
