Changeset a35b458 in mainline for uspace/lib/softfloat/conversion.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/conversion.c

    r3061bc1 ra35b458  
    4242        float64 result;
    4343        uint64_t frac;
    44        
     44
    4545        result.parts.sign = a.parts.sign;
    4646        result.parts.fraction = a.parts.fraction;
    4747        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    48        
     48
    4949        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    5050                result.parts.exp = FLOAT64_MAX_EXPONENT;
    … …  
    5252                return result;
    5353        }
    54        
     54
    5555        result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS);
    5656        if (a.parts.exp == 0) {
    5757                /* normalize denormalized numbers */
    58                
     58
    5959                if (result.parts.fraction == 0) { /* fix zero */
    6060                        result.parts.exp = 0;
    6161                        return result;
    6262                }
    63                        
     63
    6464                frac = result.parts.fraction;
    65                
     65
    6666                while (!(frac & FLOAT64_HIDDEN_BIT_MASK)) {
    6767                        frac <<= 1;
    6868                        --result.parts.exp;
    6969                }
    70                
     70
    7171                ++result.parts.exp;
    7272                result.parts.fraction = frac;
    7373        }
    74        
     74
    7575        return result;
    7676}
    … …  
    8181        uint64_t frac_hi, frac_lo;
    8282        uint64_t tmp_hi, tmp_lo;
    83        
     83
    8484        result.parts.sign = a.parts.sign;
    8585        result.parts.frac_hi = 0;
    … …  
    9090        result.parts.frac_hi = frac_hi;
    9191        result.parts.frac_lo = frac_lo;
    92        
     92
    9393        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    9494                result.parts.exp = FLOAT128_MAX_EXPONENT;
    … …  
    9696                return result;
    9797        }
    98        
     98
    9999        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
    100100        if (a.parts.exp == 0) {
    101101                /* normalize denormalized numbers */
    102                
     102
    103103                if (eq128(result.parts.frac_hi,
    104104                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
    … …  
    106106                        return result;
    107107                }
    108                
     108
    109109                frac_hi = result.parts.frac_hi;
    110110                frac_lo = result.parts.frac_lo;
    111                
     111
    112112                and128(frac_hi, frac_lo,
    113113                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    117117                        --result.parts.exp;
    118118                }
    119                
     119
    120120                ++result.parts.exp;
    121121                result.parts.frac_hi = frac_hi;
    122122                result.parts.frac_lo = frac_lo;
    123123        }
    124        
     124
    125125        return result;
    126126}
    … …  
    131131        uint64_t frac_hi, frac_lo;
    132132        uint64_t tmp_hi, tmp_lo;
    133        
     133
    134134        result.parts.sign = a.parts.sign;
    135135        result.parts.frac_hi = 0;
    … …  
    140140        result.parts.frac_hi = frac_hi;
    141141        result.parts.frac_lo = frac_lo;
    142        
     142
    143143        if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
    144144                result.parts.exp = FLOAT128_MAX_EXPONENT;
    … …  
    146146                return result;
    147147        }
    148        
     148
    149149        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
    150150        if (a.parts.exp == 0) {
    151151                /* normalize denormalized numbers */
    152                
     152
    153153                if (eq128(result.parts.frac_hi,
    154154                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
    … …  
    156156                        return result;
    157157                }
    158                
     158
    159159                frac_hi = result.parts.frac_hi;
    160160                frac_lo = result.parts.frac_lo;
    161                
     161
    162162                and128(frac_hi, frac_lo,
    163163                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    167167                        --result.parts.exp;
    168168                }
    169                
     169
    170170                ++result.parts.exp;
    171171                result.parts.frac_hi = frac_hi;
    172172                result.parts.frac_lo = frac_lo;
    173173        }
    174        
     174
    175175        return result;
    176176}
    … …  
    181181        int32_t exp;
    182182        uint64_t frac;
    183        
     183
    184184        result.parts.sign = a.parts.sign;
    185        
     185
    186186        if (is_float64_nan(a)) {
    187187                result.parts.exp = FLOAT32_MAX_EXPONENT;
    188                
     188
    189189                if (is_float64_signan(a)) {
    190190                        /* set first bit of fraction nonzero */
    … …  
    192192                        return result;
    193193                }
    194                
     194
    195195                /* fraction nonzero but its first bit is zero */
    196196                result.parts.fraction = 0x1;
    197197                return result;
    198198        }
    199        
     199
    200200        if (is_float64_infinity(a)) {
    201201                result.parts.fraction = 0;
    … …  
    203203                return result;
    204204        }
    205        
     205
    206206        exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
    207        
     207
    208208        if (exp >= FLOAT32_MAX_EXPONENT) {
    209209                /* FIXME: overflow */
    … …  
    213213        } else if (exp <= 0) {
    214214                /* underflow or denormalized */
    215                
     215
    216216                result.parts.exp = 0;
    217                
     217
    218218                exp *= -1;
    219219                if (exp > FLOAT32_FRACTION_SIZE) {
    … …  
    222222                        return result;
    223223                }
    224                
     224
    225225                /* denormalized */
    226                
     226
    227227                frac = a.parts.fraction;
    228228                frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */
    229                
     229
    230230                frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
    231                
     231
    232232                while (exp > 0) {
    233233                        --exp;
    … …  
    235235                }
    236236                result.parts.fraction = frac;
    237                
    238                 return result;
    239         }
    240        
     237
     238                return result;
     239        }
     240
    241241        result.parts.exp = exp;
    242242        result.parts.fraction =
    … …  
    250250        int32_t exp;
    251251        uint64_t frac_hi, frac_lo;
    252        
     252
    253253        result.parts.sign = a.parts.sign;
    254        
     254
    255255        if (is_float128_nan(a)) {
    256256                result.parts.exp = FLOAT32_MAX_EXPONENT;
    257                
     257
    258258                if (is_float128_signan(a)) {
    259259                        /* set first bit of fraction nonzero */
    … …  
    261261                        return result;
    262262                }
    263                
     263
    264264                /* fraction nonzero but its first bit is zero */
    265265                result.parts.fraction = 0x1;
    266266                return result;
    267267        }
    268        
     268
    269269        if (is_float128_infinity(a)) {
    270270                result.parts.fraction = 0;
    … …  
    272272                return result;
    273273        }
    274        
     274
    275275        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
    276        
     276
    277277        if (exp >= FLOAT32_MAX_EXPONENT) {
    278278                /* FIXME: overflow */
    … …  
    282282        } else if (exp <= 0) {
    283283                /* underflow or denormalized */
    284                
     284
    285285                result.parts.exp = 0;
    286                
     286
    287287                exp *= -1;
    288288                if (exp > FLOAT32_FRACTION_SIZE) {
    … …  
    291291                        return result;
    292292                }
    293                
     293
    294294                /* denormalized */
    295                
     295
    296296                frac_hi = a.parts.frac_hi;
    297297                frac_lo = a.parts.frac_lo;
    298                
     298
    299299                /* denormalize and set hidden bit */
    300300                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    301                
     301
    302302                rshift128(frac_hi, frac_lo,
    303303                    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
    304304                    &frac_hi, &frac_lo);
    305                
     305
    306306                while (exp > 0) {
    307307                        --exp;
    … …  
    309309                }
    310310                result.parts.fraction = frac_lo;
    311                
    312                 return result;
    313         }
    314        
     311
     312                return result;
     313        }
     314
    315315        result.parts.exp = exp;
    316316        frac_hi = a.parts.frac_hi;
    … …  
    328328        int32_t exp;
    329329        uint64_t frac_hi, frac_lo;
    330        
     330
    331331        result.parts.sign = a.parts.sign;
    332        
     332
    333333        if (is_float128_nan(a)) {
    334334                result.parts.exp = FLOAT64_MAX_EXPONENT;
    335                
     335
    336336                if (is_float128_signan(a)) {
    337337                        /* set first bit of fraction nonzero */
    … …  
    339339                        return result;
    340340                }
    341                
     341
    342342                /* fraction nonzero but its first bit is zero */
    343343                result.parts.fraction = 0x1;
    344344                return result;
    345345        }
    346        
     346
    347347        if (is_float128_infinity(a)) {
    348348                result.parts.fraction = 0;
    … …  
    350350                return result;
    351351        }
    352        
     352
    353353        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
    354        
     354
    355355        if (exp >= FLOAT64_MAX_EXPONENT) {
    356356                /* FIXME: overflow */
    … …  
    360360        } else if (exp <= 0) {
    361361                /* underflow or denormalized */
    362                
     362
    363363                result.parts.exp = 0;
    364                
     364
    365365                exp *= -1;
    366366                if (exp > FLOAT64_FRACTION_SIZE) {
    … …  
    369369                        return result;
    370370                }
    371                
     371
    372372                /* denormalized */
    373                
     373
    374374                frac_hi = a.parts.frac_hi;
    375375                frac_lo = a.parts.frac_lo;
    376                
     376
    377377                /* denormalize and set hidden bit */
    378378                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    379                
     379
    380380                rshift128(frac_hi, frac_lo,
    381381                    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
    382382                    &frac_hi, &frac_lo);
    383                
     383
    384384                while (exp > 0) {
    385385                        --exp;
    … …  
    387387                }
    388388                result.parts.fraction = frac_lo;
    389                
    390                 return result;
    391         }
    392        
     389
     390                return result;
     391        }
     392
    393393        result.parts.exp = exp;
    394394        frac_hi = a.parts.frac_hi;
    … …  
    410410{
    411411        uint32_t frac;
    412        
     412
    413413        if (a.parts.exp < FLOAT32_BIAS) {
    414414                /* TODO: rounding */
    415415                return 0;
    416416        }
    417        
     417
    418418        frac = a.parts.fraction;
    419        
     419
    420420        frac |= FLOAT32_HIDDEN_BIT_MASK;
    421421        /* shift fraction to left so hidden bit will be the most significant bit */
    422422        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
    423        
     423
    424424        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
    425425        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    427427                ++frac;
    428428        }
    429        
     429
    430430        return frac;
    431431}
    … …  
    439439        if (is_float32_nan(a))
    440440                return UINT32_MAX;
    441        
     441
    442442        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    443443                if (a.parts.sign)
    444444                        return UINT32_MIN;
    445                
     445
    446446                return UINT32_MAX;
    447447        }
    448        
     448
    449449        return _float32_to_uint32_helper(a);
    450450}
    … …  
    458458        if (is_float32_nan(a))
    459459                return INT32_MAX;
    460        
     460
    461461        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    462462                if (a.parts.sign)
    463463                        return INT32_MIN;
    464                
     464
    465465                return INT32_MAX;
    466466        }
    467        
     467
    468468        return _float32_to_uint32_helper(a);
    469469}
    … …  
    478478{
    479479        uint64_t frac;
    480        
     480
    481481        if (a.parts.exp < FLOAT32_BIAS) {
    482482                // TODO: rounding
    483483                return 0;
    484484        }
    485        
     485
    486486        frac = a.parts.fraction;
    487        
     487
    488488        frac |= FLOAT32_HIDDEN_BIT_MASK;
    489489        /* shift fraction to left so hidden bit will be the most significant bit */
    490490        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
    491        
     491
    492492        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    493493        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    495495                ++frac;
    496496        }
    497        
     497
    498498        return frac;
    499499}
    … …  
    507507        if (is_float32_nan(a))
    508508                return UINT64_MAX;
    509        
     509
    510510        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    511511                if (a.parts.sign)
    512512                        return UINT64_MIN;
    513                
     513
    514514                return UINT64_MAX;
    515515        }
    516        
     516
    517517        return _float32_to_uint64_helper(a);
    518518}
    … …  
    526526        if (is_float32_nan(a))
    527527                return INT64_MAX;
    528        
     528
    529529        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    530530                if (a.parts.sign)
    531531                        return INT64_MIN;
    532                
     532
    533533                return INT64_MAX;
    534534        }
    535        
     535
    536536        return _float32_to_uint64_helper(a);
    537537}
    … …  
    546546{
    547547        uint64_t frac;
    548        
     548
    549549        if (a.parts.exp < FLOAT64_BIAS) {
    550550                // TODO: rounding
    551551                return 0;
    552552        }
    553        
     553
    554554        frac = a.parts.fraction;
    555        
     555
    556556        frac |= FLOAT64_HIDDEN_BIT_MASK;
    557557        /* shift fraction to left so hidden bit will be the most significant bit */
    558558        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
    559        
     559
    560560        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    561561        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    563563                ++frac;
    564564        }
    565        
     565
    566566        return frac;
    567567}
    … …  
    575575        if (is_float64_nan(a))
    576576                return UINT32_MAX;
    577        
     577
    578578        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    579579                if (a.parts.sign)
    580580                        return UINT32_MIN;
    581                
     581
    582582                return UINT32_MAX;
    583583        }
    584        
     584
    585585        return (uint32_t) _float64_to_uint64_helper(a);
    586586}
    … …  
    594594        if (is_float64_nan(a))
    595595                return INT32_MAX;
    596        
     596
    597597        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    598598                if (a.parts.sign)
    599599                        return INT32_MIN;
    600                
     600
    601601                return INT32_MAX;
    602602        }
    603        
     603
    604604        return (int32_t) _float64_to_uint64_helper(a);
    605605}
    … …  
    613613        if (is_float64_nan(a))
    614614                return UINT64_MAX;
    615        
     615
    616616        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    617617                if (a.parts.sign)
    618618                        return UINT64_MIN;
    619                
     619
    620620                return UINT64_MAX;
    621621        }
    622        
     622
    623623        return _float64_to_uint64_helper(a);
    624624}
    … …  
    632632        if (is_float64_nan(a))
    633633                return INT64_MAX;
    634        
     634
    635635        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    636636                if (a.parts.sign)
    637637                        return INT64_MIN;
    638                
     638
    639639                return INT64_MAX;
    640640        }
    641        
     641
    642642        return _float64_to_uint64_helper(a);
    643643}
    … …  
    652652{
    653653        uint64_t frac_hi, frac_lo;
    654        
     654
    655655        if (a.parts.exp < FLOAT128_BIAS) {
    656656                // TODO: rounding
    657657                return 0;
    658658        }
    659        
     659
    660660        frac_hi = a.parts.frac_hi;
    661661        frac_lo = a.parts.frac_lo;
    662        
     662
    663663        frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    664664        /* shift fraction to left so hidden bit will be the most significant bit */
    665665        lshift128(frac_hi, frac_lo,
    666666            (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
    667        
     667
    668668        rshift128(frac_hi, frac_lo,
    669669            (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
    … …  
    672672                add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
    673673        }
    674        
     674
    675675        return frac_lo;
    676676}
    … …  
    684684        if (is_float128_nan(a))
    685685                return UINT32_MAX;
    686        
     686
    687687        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    688688                if (a.parts.sign)
    689689                        return UINT32_MIN;
    690                
     690
    691691                return UINT32_MAX;
    692692        }
    693        
     693
    694694        return (uint32_t) _float128_to_uint64_helper(a);
    695695}
    … …  
    703703        if (is_float128_nan(a))
    704704                return INT32_MAX;
    705        
     705
    706706        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    707707                if (a.parts.sign)
    708708                        return INT32_MIN;
    709                
     709
    710710                return INT32_MAX;
    711711        }
    712        
     712
    713713        return (int32_t) _float128_to_uint64_helper(a);
    714714}
    … …  
    722722        if (is_float128_nan(a))
    723723                return UINT64_MAX;
    724        
     724
    725725        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    726726                if (a.parts.sign)
    727727                        return UINT64_MIN;
    728                
     728
    729729                return UINT64_MAX;
    730730        }
    731        
     731
    732732        return _float128_to_uint64_helper(a);
    733733}
    … …  
    741741        if (is_float128_nan(a))
    742742                return INT64_MAX;
    743        
     743
    744744        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    745745                if (a.parts.sign)
    746746                        return INT64_MIN;
    747                
     747
    748748                return INT64_MAX;
    749749        }
    750        
     750
    751751        return _float128_to_uint64_helper(a);
    752752}
    … …  
    757757        int32_t exp;
    758758        float32 result;
    759        
     759
    760760        result.parts.sign = 0;
    761761        result.parts.fraction = 0;
    762        
     762
    763763        counter = count_zeroes32(i);
    764        
     764
    765765        exp = FLOAT32_BIAS + 32 - counter - 1;
    766        
     766
    767767        if (counter == 32) {
    768768                result.bin = 0;
    769769                return result;
    770770        }
    771        
     771
    772772        if (counter > 0) {
    773773                i <<= counter - 1;
    … …  
    775775                i >>= 1;
    776776        }
    777        
     777
    778778        round_float32(&exp, &i);
    779        
     779
    780780        result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
    781781        result.parts.exp = exp;
    782        
     782
    783783        return result;
    784784}
    … …  
    787787{
    788788        float32 result;
    789        
     789
    790790        if (i < 0)
    791791                result = uint32_to_float32((uint32_t) (-i));
    792792        else
    793793                result = uint32_to_float32((uint32_t) i);
    794        
     794
    795795        result.parts.sign = i < 0;
    796        
     796
    797797        return result;
    798798}
    … …  
    804804        uint32_t j;
    805805        float32 result;
    806        
     806
    807807        result.parts.sign = 0;
    808808        result.parts.fraction = 0;
    809        
     809
    810810        counter = count_zeroes64(i);
    811        
     811
    812812        exp = FLOAT32_BIAS + 64 - counter - 1;
    813        
     813
    814814        if (counter == 64) {
    815815                result.bin = 0;
    816816                return result;
    817817        }
    818        
     818
    819819        /* Shift all to the first 31 bits (31st will be hidden 1) */
    820820        if (counter > 33) {
    … …  
    823823                i >>= 1 + 32 - counter;
    824824        }
    825        
     825
    826826        j = (uint32_t) i;
    827827        round_float32(&exp, &j);
    828        
     828
    829829        result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
    830830        result.parts.exp = exp;
    … …  
    835835{
    836836        float32 result;
    837        
     837
    838838        if (i < 0)
    839839                result = uint64_to_float32((uint64_t) (-i));
    840840        else
    841841                result = uint64_to_float32((uint64_t) i);
    842        
     842
    843843        result.parts.sign = i < 0;
    844        
     844
    845845        return result;
    846846}
    … …  
    852852        float64 result;
    853853        uint64_t frac;
    854        
     854
    855855        result.parts.sign = 0;
    856856        result.parts.fraction = 0;
    857        
     857
    858858        counter = count_zeroes32(i);
    859        
     859
    860860        exp = FLOAT64_BIAS + 32 - counter - 1;
    861        
     861
    862862        if (counter == 32) {
    863863                result.bin = 0;
    864864                return result;
    865865        }
    866        
     866
    867867        frac = i;
    868868        frac <<= counter + 32 - 1;
    869        
     869
    870870        round_float64(&exp, &frac);
    871        
     871
    872872        result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
    873873        result.parts.exp = exp;
    874        
     874
    875875        return result;
    876876}
    … …  
    879879{
    880880        float64 result;
    881        
     881
    882882        if (i < 0)
    883883                result = uint32_to_float64((uint32_t) (-i));
    884884        else
    885885                result = uint32_to_float64((uint32_t) i);
    886        
     886
    887887        result.parts.sign = i < 0;
    888        
     888
    889889        return result;
    890890}
    … …  
    895895        int32_t exp;
    896896        float64 result;
    897        
     897
    898898        result.parts.sign = 0;
    899899        result.parts.fraction = 0;
    900        
     900
    901901        counter = count_zeroes64(i);
    902        
     902
    903903        exp = FLOAT64_BIAS + 64 - counter - 1;
    904        
     904
    905905        if (counter == 64) {
    906906                result.bin = 0;
    907907                return result;
    908908        }
    909        
     909
    910910        if (counter > 0) {
    911911                i <<= counter - 1;
    … …  
    913913                i >>= 1;
    914914        }
    915        
     915
    916916        round_float64(&exp, &i);
    917        
     917
    918918        result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
    919919        result.parts.exp = exp;
    … …  
    924924{
    925925        float64 result;
    926        
     926
    927927        if (i < 0)
    928928                result = uint64_to_float64((uint64_t) (-i));
    929929        else
    930930                result = uint64_to_float64((uint64_t) i);
    931        
     931
    932932        result.parts.sign = i < 0;
    933        
     933
    934934        return result;
    935935}
    … …  
    941941        float128 result;
    942942        uint64_t frac_hi, frac_lo;
    943        
     943
    944944        result.parts.sign = 0;
    945945        result.parts.frac_hi = 0;
    946946        result.parts.frac_lo = 0;
    947        
     947
    948948        counter = count_zeroes32(i);
    949        
     949
    950950        exp = FLOAT128_BIAS + 32 - counter - 1;
    951        
     951
    952952        if (counter == 32) {
    953953                result.bin.hi = 0;
    … …  
    955955                return result;
    956956        }
    957        
     957
    958958        frac_hi = 0;
    959959        frac_lo = i;
    960960        lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
    961        
     961
    962962        round_float128(&exp, &frac_hi, &frac_lo);
    963        
     963
    964964        rshift128(frac_hi, frac_lo,
    965965            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
    … …  
    967967        result.parts.frac_lo = frac_lo;
    968968        result.parts.exp = exp;
    969        
     969
    970970        return result;
    971971}
    … …  
    974974{
    975975        float128 result;
    976        
     976
    977977        if (i < 0)
    978978                result = uint32_to_float128((uint32_t) (-i));
    979979        else
    980980                result = uint32_to_float128((uint32_t) i);
    981        
     981
    982982        result.parts.sign = i < 0;
    983        
     983
    984984        return result;
    985985}
    … …  
    992992        float128 result;
    993993        uint64_t frac_hi, frac_lo;
    994        
     994
    995995        result.parts.sign = 0;
    996996        result.parts.frac_hi = 0;
    997997        result.parts.frac_lo = 0;
    998        
     998
    999999        counter = count_zeroes64(i);
    1000        
     1000
    10011001        exp = FLOAT128_BIAS + 64 - counter - 1;
    1002        
     1002
    10031003        if (counter == 64) {
    10041004                result.bin.hi = 0;
    … …  
    10061006                return result;
    10071007        }
    1008        
     1008
    10091009        frac_hi = 0;
    10101010        frac_lo = i;
    10111011        lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
    1012        
     1012
    10131013        round_float128(&exp, &frac_hi, &frac_lo);
    1014        
     1014
    10151015        rshift128(frac_hi, frac_lo,
    10161016            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
    … …  
    10181018        result.parts.frac_lo = frac_lo;
    10191019        result.parts.exp = exp;
    1020        
     1020
    10211021        return result;
    10221022}
    … …  
    10251025{
    10261026        float128 result;
    1027        
     1027
    10281028        if (i < 0)
    10291029                result = uint64_to_float128((uint64_t) (-i));
    10301030        else
    10311031                result = uint64_to_float128((uint64_t) i);
    1032        
     1032
    10331033        result.parts.sign = i < 0;
    1034        
     1034
    10351035        return result;
    10361036}
    … …  
    10421042        float32_u res;
    10431043        res.data = int32_to_float32(i);
    1044        
     1044
    10451045        return res.val;
    10461046}
    … …  
    10501050        float32_u res;
    10511051        res.data = int64_to_float32(i);
    1052        
     1052
    10531053        return res.val;
    10541054}
    … …  
    10581058        float32_u res;
    10591059        res.data = uint32_to_float32(i);
    1060        
     1060
    10611061        return res.val;
    10621062}
    … …  
    10661066        float32_u res;
    10671067        res.data = uint64_to_float32(i);
    1068        
     1068
    10691069        return res.val;
    10701070}
    … …  
    10741074        float32_u ua;
    10751075        ua.val = a;
    1076        
     1076
    10771077        return float32_to_int32(ua.data);
    10781078}
    … …  
    10821082        float32_u ua;
    10831083        ua.val = a;
    1084        
     1084
    10851085        return float32_to_int64(ua.data);
    10861086}
    … …  
    10901090        float32_u ua;
    10911091        ua.val = a;
    1092        
     1092
    10931093        return float32_to_uint32(ua.data);
    10941094}
    … …  
    10981098        float32_u ua;
    10991099        ua.val = a;
    1100        
     1100
    11011101        return float32_to_uint64(ua.data);
    11021102}
    … …  
    11061106        float32_u ua;
    11071107        ua.val = a;
    1108        
     1108
    11091109        return float32_to_int32(ua.data);
    11101110}
    … …  
    11141114        float32_u ua;
    11151115        ua.val = a;
    1116        
     1116
    11171117        return float32_to_uint32(ua.data);
    11181118}
    … …  
    11221122        float32_u res;
    11231123        res.data = int32_to_float32(i);
    1124        
     1124
    11251125        return res.val;
    11261126}
    … …  
    11301130        float32_u res;
    11311131        res.data = int64_to_float32(i);
    1132        
     1132
    11331133        return res.val;
    11341134}
    … …  
    11381138        float32_u res;
    11391139        res.data = uint32_to_float32(i);
    1140        
     1140
    11411141        return res.val;
    11421142}
    … …  
    11461146        float32_u res;
    11471147        res.data = uint64_to_float32(i);
    1148        
     1148
    11491149        return res.val;
    11501150}
    … …  
    11581158        float64_u res;
    11591159        res.data = int32_to_float64(i);
    1160        
     1160
    11611161        return res.val;
    11621162}
    … …  
    11661166        float64_u res;
    11671167        res.data = int64_to_float64(i);
    1168        
     1168
    11691169        return res.val;
    11701170}
    … …  
    11741174        float64_u res;
    11751175        res.data = uint32_to_float64(i);
    1176        
     1176
    11771177        return res.val;
    11781178}
    … …  
    11821182        float64_u res;
    11831183        res.data = uint64_to_float64(i);
    1184        
     1184
    11851185        return res.val;
    11861186}
    … …  
    11901190        float64_u ua;
    11911191        ua.val = a;
    1192        
     1192
    11931193        return float64_to_uint32(ua.data);
    11941194}
    … …  
    11981198        float64_u ua;
    11991199        ua.val = a;
    1200        
     1200
    12011201        return float64_to_uint64(ua.data);
    12021202}
    … …  
    12061206        float64_u ua;
    12071207        ua.val = a;
    1208        
     1208
    12091209        return float64_to_int32(ua.data);
    12101210}
    … …  
    12141214        float64_u ua;
    12151215        ua.val = a;
    1216        
     1216
    12171217        return float64_to_int64(ua.data);
    12181218}
    … …  
    12221222        float64_u res;
    12231223        res.data = int32_to_float64(i);
    1224        
     1224
    12251225        return res.val;
    12261226}
    … …  
    12301230        float64_u res;
    12311231        res.data = uint32_to_float64(i);
    1232        
     1232
    12331233        return res.val;
    12341234}
    … …  
    12381238        float64_u res;
    12391239        res.data = int64_to_float64(i);
    1240        
     1240
    12411241        return res.val;
    12421242}
    … …  
    12461246        float64_u ua;
    12471247        ua.val = a;
    1248        
     1248
    12491249        return float64_to_int32(ua.data);
    12501250}
    … …  
    12541254        float64_u ua;
    12551255        ua.val = a;
    1256        
     1256
    12571257        return float64_to_int64(ua.data);
    12581258}
    … …  
    12621262        float64_u ua;
    12631263        ua.val = a;
    1264        
     1264
    12651265        return float64_to_uint32(ua.data);
    12661266}
    … …  
    12741274        float128_u res;
    12751275        res.data = int32_to_float128(i);
    1276        
     1276
    12771277        return res.val;
    12781278}
    … …  
    12821282        float128_u res;
    12831283        res.data = int64_to_float128(i);
    1284        
     1284
    12851285        return res.val;
    12861286}
    … …  
    12901290        float128_u res;
    12911291        res.data = uint32_to_float128(i);
    1292        
     1292
    12931293        return res.val;
    12941294}
    … …  
    12981298        float128_u res;
    12991299        res.data = uint64_to_float128(i);
    1300        
     1300
    13011301        return res.val;
    13021302}
    … …  
    13061306        float128_u ua;
    13071307        ua.val = a;
    1308        
     1308
    13091309        return float128_to_int32(ua.data);
    13101310}
    … …  
    13141314        float128_u ua;
    13151315        ua.val = a;
    1316        
     1316
    13171317        return float128_to_uint64(ua.data);
    13181318}
    … …  
    13221322        float128_u ua;
    13231323        ua.val = a;
    1324        
     1324
    13251325        return float128_to_uint32(ua.data);
    13261326}
    … …  
    13301330        float128_u ua;
    13311331        ua.val = a;
    1332        
     1332
    13331333        return float128_to_uint64(ua.data);
    13341334}
    … …  
    13821382        float64_u ua;
    13831383        ua.val = a;
    1384        
     1384
    13851385        float32_u res;
    13861386        res.data = float64_to_float32(ua.data);
    1387        
     1387
    13881388        return res.val;
    13891389}
    … …  
    13931393        float32_u ua;
    13941394        ua.val = a;
    1395        
     1395
    13961396        float64_u res;
    13971397        res.data = float32_to_float64(ua.data);
    1398        
     1398
    13991399        return res.val;
    14001400}
    … …  
    14041404        float32_u ua;
    14051405        ua.val = a;
    1406        
     1406
    14071407        float64_u res;
    14081408        res.data = float32_to_float64(ua.data);
    1409        
     1409
    14101410        return res.val;
    14111411}
    … …  
    14151415        float64_u ua;
    14161416        ua.val = a;
    1417        
     1417
    14181418        float32_u res;
    14191419        res.data = float64_to_float32(ua.data);
    1420        
     1420
    14211421        return res.val;
    14221422}
    … …  
    14301430        float128_u ua;
    14311431        ua.val = a;
    1432        
     1432
    14331433        float32_u res;
    14341434        res.data = float128_to_float32(ua.data);
    1435        
     1435
    14361436        return res.val;
    14371437}
    … …  
    14411441        float32_u ua;
    14421442        ua.val = a;
    1443        
     1443
    14441444        float128_u res;
    14451445        res.data = float32_to_float128(ua.data);
    1446        
     1446
    14471447        return res.val;
    14481448}
    … …  
    14661466        float128_u ua;
    14671467        ua.val = a;
    1468        
     1468
    14691469        float64_u res;
    14701470        res.data = float128_to_float64(ua.data);
    1471        
     1471
    14721472        return res.val;
    14731473}
    … …  
    14771477        float64_u ua;
    14781478        ua.val = a;
    1479        
     1479
    14801480        float128_u res;
    14811481        res.data = float64_to_float128(ua.data);
    1482        
     1482
    14831483        return res.val;
    14841484}
Note: See TracChangeset for help on using the changeset viewer.