Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/generic/conversion.c

    r88d5c1e r9d58539  
    3939#include <common.h>
    4040
    41 float64 float32_to_float64(float32 a)
     41float64 convertFloat32ToFloat64(float32 a)
    4242{
    4343        float64 result;
    … …  
    4848        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    4949       
    50         if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
     50        if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
    5151                result.parts.exp = FLOAT64_MAX_EXPONENT;
    52                 // TODO; check if its correct for SigNaNs
     52                /* TODO; check if its correct for SigNaNs*/
    5353                return result;
    5454        }
    … …  
    5757        if (a.parts.exp == 0) {
    5858                /* normalize denormalized numbers */
    59                
     59
    6060                if (result.parts.fraction == 0) { /* fix zero */
    6161                        result.parts.exp = 0;
    … …  
    7777}
    7878
    79 float128 float32_to_float128(float32 a)
     79float128 convertFloat32ToFloat128(float32 a)
    8080{
    8181        float128 result;
    8282        uint64_t frac_hi, frac_lo;
    8383        uint64_t tmp_hi, tmp_lo;
    84        
     84
    8585        result.parts.sign = a.parts.sign;
    8686        result.parts.frac_hi = 0;
    … …  
    9191        result.parts.frac_hi = frac_hi;
    9292        result.parts.frac_lo = frac_lo;
    93        
    94         if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
     93
     94        if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
    9595                result.parts.exp = FLOAT128_MAX_EXPONENT;
    96                 // TODO; check if its correct for SigNaNs
    97                 return result;
    98         }
    99        
     96                /* TODO; check if its correct for SigNaNs*/
     97                return result;
     98        }
     99
    100100        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
    101101        if (a.parts.exp == 0) {
    102102                /* normalize denormalized numbers */
    103                
     103
    104104                if (eq128(result.parts.frac_hi,
    105105                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
    … …  
    107107                        return result;
    108108                }
    109                
     109
    110110                frac_hi = result.parts.frac_hi;
    111111                frac_lo = result.parts.frac_lo;
    112                
     112
    113113                and128(frac_hi, frac_lo,
    114114                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    118118                        --result.parts.exp;
    119119                }
    120                
     120
    121121                ++result.parts.exp;
    122122                result.parts.frac_hi = frac_hi;
    123123                result.parts.frac_lo = frac_lo;
    124124        }
    125        
    126         return result;
    127 }
    128 
    129 float128 float64_to_float128(float64 a)
     125
     126        return result;
     127}
     128
     129float128 convertFloat64ToFloat128(float64 a)
    130130{
    131131        float128 result;
    132132        uint64_t frac_hi, frac_lo;
    133133        uint64_t tmp_hi, tmp_lo;
    134        
     134
    135135        result.parts.sign = a.parts.sign;
    136136        result.parts.frac_hi = 0;
    … …  
    141141        result.parts.frac_hi = frac_hi;
    142142        result.parts.frac_lo = frac_lo;
    143        
    144         if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
     143
     144        if ((isFloat64Infinity(a)) || (isFloat64NaN(a))) {
    145145                result.parts.exp = FLOAT128_MAX_EXPONENT;
    146                 // TODO; check if its correct for SigNaNs
    147                 return result;
    148         }
    149        
     146                /* TODO; check if its correct for SigNaNs*/
     147                return result;
     148        }
     149
    150150        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
    151151        if (a.parts.exp == 0) {
    152152                /* normalize denormalized numbers */
    153                
     153
    154154                if (eq128(result.parts.frac_hi,
    155155                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
    … …  
    157157                        return result;
    158158                }
    159                
     159
    160160                frac_hi = result.parts.frac_hi;
    161161                frac_lo = result.parts.frac_lo;
    162                
     162
    163163                and128(frac_hi, frac_lo,
    164164                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    … …  
    168168                        --result.parts.exp;
    169169                }
    170                
     170
    171171                ++result.parts.exp;
    172172                result.parts.frac_hi = frac_hi;
    173173                result.parts.frac_lo = frac_lo;
    174174        }
    175        
    176         return result;
    177 }
    178 
    179 float32 float64_to_float32(float64 a)
     175
     176        return result;
     177}
     178
     179float32 convertFloat64ToFloat32(float64 a)
    180180{
    181181        float32 result;
    … …  
    185185        result.parts.sign = a.parts.sign;
    186186       
    187         if (is_float64_nan(a)) {
     187        if (isFloat64NaN(a)) {
    188188                result.parts.exp = FLOAT32_MAX_EXPONENT;
    189189               
    190                 if (is_float64_signan(a)) {
     190                if (isFloat64SigNaN(a)) {
    191191                        /* set first bit of fraction nonzero */
    192192                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    193193                        return result;
    194194                }
    195                
     195
    196196                /* fraction nonzero but its first bit is zero */
    197197                result.parts.fraction = 0x1;
    198198                return result;
    199199        }
    200        
    201         if (is_float64_infinity(a)) {
     200
     201        if (isFloat64Infinity(a)) {
    202202                result.parts.fraction = 0;
    203203                result.parts.exp = FLOAT32_MAX_EXPONENT;
    204204                return result;
    205205        }
    206        
     206
    207207        exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
    208208       
    … …  
    239239                return result;
    240240        }
    241        
     241
    242242        result.parts.exp = exp;
    243243        result.parts.fraction =
    … …  
    246246}
    247247
    248 float32 float128_to_float32(float128 a)
     248float32 convertFloat128ToFloat32(float128 a)
    249249{
    250250        float32 result;
    251251        int32_t exp;
    252252        uint64_t frac_hi, frac_lo;
    253        
     253
    254254        result.parts.sign = a.parts.sign;
    255        
    256         if (is_float128_nan(a)) {
     255
     256        if (isFloat128NaN(a)) {
    257257                result.parts.exp = FLOAT32_MAX_EXPONENT;
    258                
    259                 if (is_float128_signan(a)) {
     258
     259                if (isFloat128SigNaN(a)) {
    260260                        /* set first bit of fraction nonzero */
    261261                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    262262                        return result;
    263263                }
    264                
     264
    265265                /* fraction nonzero but its first bit is zero */
    266266                result.parts.fraction = 0x1;
    267267                return result;
    268268        }
    269        
    270         if (is_float128_infinity(a)) {
     269
     270        if (isFloat128Infinity(a)) {
    271271                result.parts.fraction = 0;
    272272                result.parts.exp = FLOAT32_MAX_EXPONENT;
    273273                return result;
    274274        }
    275        
     275
    276276        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
    277        
     277
    278278        if (exp >= FLOAT32_MAX_EXPONENT) {
    279279                /* FIXME: overflow */
    … …  
    283283        } else if (exp <= 0) {
    284284                /* underflow or denormalized */
    285                
     285
    286286                result.parts.exp = 0;
    287                
     287
    288288                exp *= -1;
    289289                if (exp > FLOAT32_FRACTION_SIZE) {
    … …  
    292292                        return result;
    293293                }
    294                
     294
    295295                /* denormalized */
    296                
     296
    297297                frac_hi = a.parts.frac_hi;
    298298                frac_lo = a.parts.frac_lo;
    299                
     299
    300300                /* denormalize and set hidden bit */
    301301                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    302                
     302
    303303                rshift128(frac_hi, frac_lo,
    304304                    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
    305305                    &frac_hi, &frac_lo);
    306                
     306
    307307                while (exp > 0) {
    308308                        --exp;
    … …  
    310310                }
    311311                result.parts.fraction = frac_lo;
    312                
    313                 return result;
    314         }
    315        
     312
     313                return result;
     314        }
     315
    316316        result.parts.exp = exp;
    317317        frac_hi = a.parts.frac_hi;
    … …  
    324324}
    325325
    326 float64 float128_to_float64(float128 a)
     326float64 convertFloat128ToFloat64(float128 a)
    327327{
    328328        float64 result;
    329329        int32_t exp;
    330330        uint64_t frac_hi, frac_lo;
    331        
     331
    332332        result.parts.sign = a.parts.sign;
    333        
    334         if (is_float128_nan(a)) {
     333
     334        if (isFloat128NaN(a)) {
    335335                result.parts.exp = FLOAT64_MAX_EXPONENT;
    336                
    337                 if (is_float128_signan(a)) {
     336
     337                if (isFloat128SigNaN(a)) {
    338338                        /* set first bit of fraction nonzero */
    339339                        result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1;
    340340                        return result;
    341341                }
    342                
     342
    343343                /* fraction nonzero but its first bit is zero */
    344344                result.parts.fraction = 0x1;
    345345                return result;
    346346        }
    347        
    348         if (is_float128_infinity(a)) {
     347
     348        if (isFloat128Infinity(a)) {
    349349                result.parts.fraction = 0;
    350350                result.parts.exp = FLOAT64_MAX_EXPONENT;
    351351                return result;
    352352        }
    353        
     353
    354354        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
    355        
     355
    356356        if (exp >= FLOAT64_MAX_EXPONENT) {
    357357                /* FIXME: overflow */
    … …  
    361361        } else if (exp <= 0) {
    362362                /* underflow or denormalized */
    363                
     363
    364364                result.parts.exp = 0;
    365                
     365
    366366                exp *= -1;
    367367                if (exp > FLOAT64_FRACTION_SIZE) {
    … …  
    370370                        return result;
    371371                }
    372                
     372
    373373                /* denormalized */
    374                
     374
    375375                frac_hi = a.parts.frac_hi;
    376376                frac_lo = a.parts.frac_lo;
    377                
     377
    378378                /* denormalize and set hidden bit */
    379379                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    380                
     380
    381381                rshift128(frac_hi, frac_lo,
    382382                    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
    383383                    &frac_hi, &frac_lo);
    384                
     384
    385385                while (exp > 0) {
    386386                        --exp;
    … …  
    388388                }
    389389                result.parts.fraction = frac_lo;
    390                
    391                 return result;
    392         }
    393        
     390
     391                return result;
     392        }
     393
    394394        result.parts.exp = exp;
    395395        frac_hi = a.parts.frac_hi;
    … …  
    402402}
    403403
    404 /** Helper procedure for converting float32 to uint32.
     404
     405/**
     406 * Helping procedure for converting float32 to uint32.
    405407 *
    406408 * @param a Floating point number in normalized form
    … …  
    422424        /* shift fraction to left so hidden bit will be the most significant bit */
    423425        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
    424        
     426
    425427        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
    426428        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    432434}
    433435
    434 /*
    435  * FIXME: Im not sure what to return if overflow/underflow happens
    436  *  - now its the biggest or the smallest int
    437  */
     436/* 
     437 * FIXME: Im not sure what to return if overflow/underflow happens 
     438 *      - now its the biggest or the smallest int
     439 */ 
    438440uint32_t float32_to_uint32(float32 a)
    439441{
    440         if (is_float32_nan(a))
     442        if (isFloat32NaN(a))
    441443                return UINT32_MAX;
    442444       
    443         if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     445        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    444446                if (a.parts.sign)
    445447                        return UINT32_MIN;
    … …  
    451453}
    452454
    453 /*
    454  * FIXME: Im not sure what to return if overflow/underflow happens
    455  *  - now its the biggest or the smallest int
    456  */
     455/* 
     456 * FIXME: Im not sure what to return if overflow/underflow happens 
     457 *      - now its the biggest or the smallest int
     458 */ 
    457459int32_t float32_to_int32(float32 a)
    458460{
    459         if (is_float32_nan(a))
     461        if (isFloat32NaN(a))
    460462                return INT32_MAX;
    461463       
    462         if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     464        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    463465                if (a.parts.sign)
    464466                        return INT32_MIN;
    … …  
    470472}
    471473
    472 /** Helper procedure for converting float32 to uint64.
     474
     475/**
     476 * Helping procedure for converting float32 to uint64.
    473477 *
    474478 * @param a Floating point number in normalized form
    … …  
    479483{
    480484        uint64_t frac;
    481        
     485
    482486        if (a.parts.exp < FLOAT32_BIAS) {
    483                 // TODO: rounding
     487                /*TODO: rounding*/
    484488                return 0;
    485489        }
    486        
     490
    487491        frac = a.parts.fraction;
    488        
     492
    489493        frac |= FLOAT32_HIDDEN_BIT_MASK;
    490494        /* shift fraction to left so hidden bit will be the most significant bit */
    491495        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
    492        
     496
    493497        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    494498        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    496500                ++frac;
    497501        }
    498        
     502
    499503        return frac;
    500504}
    501505
    502 /*
     506/* 
    503507 * FIXME: Im not sure what to return if overflow/underflow happens
    504  *  - now its the biggest or the smallest int
     508 *      - now its the biggest or the smallest int
    505509 */
    506510uint64_t float32_to_uint64(float32 a)
    507511{
    508         if (is_float32_nan(a))
     512        if (isFloat32NaN(a))
    509513                return UINT64_MAX;
    510        
    511         if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     514
     515
     516        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    512517                if (a.parts.sign)
    513518                        return UINT64_MIN;
    514                
     519
    515520                return UINT64_MAX;
    516521        }
    517        
     522
    518523        return _float32_to_uint64_helper(a);
    519524}
    520525
    521 /*
     526/* 
    522527 * FIXME: Im not sure what to return if overflow/underflow happens
    523  *  - now its the biggest or the smallest int
     528 *      - now its the biggest or the smallest int
    524529 */
    525530int64_t float32_to_int64(float32 a)
    526531{
    527         if (is_float32_nan(a))
     532        if (isFloat32NaN(a))
    528533                return INT64_MAX;
    529        
    530         if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     534
     535        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    531536                if (a.parts.sign)
    532537                        return INT64_MIN;
    533                
     538
    534539                return INT64_MAX;
    535540        }
    536        
     541
    537542        return _float32_to_uint64_helper(a);
    538543}
    539544
    540 /** Helper procedure for converting float64 to uint64.
     545
     546/**
     547 * Helping procedure for converting float64 to uint64.
    541548 *
    542549 * @param a Floating point number in normalized form
    … …  
    547554{
    548555        uint64_t frac;
    549        
     556
    550557        if (a.parts.exp < FLOAT64_BIAS) {
    551                 // TODO: rounding
     558                /*TODO: rounding*/
    552559                return 0;
    553560        }
    554        
     561
    555562        frac = a.parts.fraction;
    556        
     563
    557564        frac |= FLOAT64_HIDDEN_BIT_MASK;
    558565        /* shift fraction to left so hidden bit will be the most significant bit */
    559566        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
    560        
     567
    561568        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    562569        if ((a.parts.sign == 1) && (frac != 0)) {
    … …  
    564571                ++frac;
    565572        }
    566        
     573
    567574        return frac;
    568575}
    … …  
    570577/*
    571578 * FIXME: Im not sure what to return if overflow/underflow happens
    572  *  - now its the biggest or the smallest int
     579 *      - now its the biggest or the smallest int
    573580 */
    574581uint32_t float64_to_uint32(float64 a)
    575582{
    576         if (is_float64_nan(a))
     583        if (isFloat64NaN(a))
    577584                return UINT32_MAX;
    578        
    579         if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     585
     586        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    580587                if (a.parts.sign)
    581588                        return UINT32_MIN;
    582                
     589
    583590                return UINT32_MAX;
    584591        }
    585        
     592
    586593        return (uint32_t) _float64_to_uint64_helper(a);
    587594}
    … …  
    589596/*
    590597 * FIXME: Im not sure what to return if overflow/underflow happens
    591  *  - now its the biggest or the smallest int
     598 *      - now its the biggest or the smallest int
    592599 */
    593600int32_t float64_to_int32(float64 a)
    594601{
    595         if (is_float64_nan(a))
     602        if (isFloat64NaN(a))
    596603                return INT32_MAX;
    597        
    598         if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     604
     605        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    599606                if (a.parts.sign)
    600607                        return INT32_MIN;
    601                
     608
    602609                return INT32_MAX;
    603610        }
    604        
     611
    605612        return (int32_t) _float64_to_uint64_helper(a);
    606613}
    607614
    608 /*
     615
     616/*
    609617 * FIXME: Im not sure what to return if overflow/underflow happens
    610  *  - now its the biggest or the smallest int
    611  */
     618 *      - now its the biggest or the smallest int
     619 */ 
    612620uint64_t float64_to_uint64(float64 a)
    613621{
    614         if (is_float64_nan(a))
     622        if (isFloat64NaN(a))
    615623                return UINT64_MAX;
    616624       
    617         if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     625        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    618626                if (a.parts.sign)
    619627                        return UINT64_MIN;
    … …  
    625633}
    626634
    627 /*
     635/* 
    628636 * FIXME: Im not sure what to return if overflow/underflow happens
    629  *  - now its the biggest or the smallest int
    630  */
     637 *      - now its the biggest or the smallest int
     638 */ 
    631639int64_t float64_to_int64(float64 a)
    632640{
    633         if (is_float64_nan(a))
     641        if (isFloat64NaN(a))
    634642                return INT64_MAX;
    635643       
    636         if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     644        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    637645                if (a.parts.sign)
    638646                        return INT64_MIN;
    … …  
    644652}
    645653
    646 /** Helper procedure for converting float128 to uint64.
     654
     655/**
     656 * Helping procedure for converting float128 to uint64.
    647657 *
    648658 * @param a Floating point number in normalized form
    … …  
    653663{
    654664        uint64_t frac_hi, frac_lo;
    655        
     665
    656666        if (a.parts.exp < FLOAT128_BIAS) {
    657                 // TODO: rounding
     667                /*TODO: rounding*/
    658668                return 0;
    659669        }
    660        
     670
    661671        frac_hi = a.parts.frac_hi;
    662672        frac_lo = a.parts.frac_lo;
    663        
     673
    664674        frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    665675        /* shift fraction to left so hidden bit will be the most significant bit */
    666676        lshift128(frac_hi, frac_lo,
    667677            (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
    668        
     678
    669679        rshift128(frac_hi, frac_lo,
    670680            (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
    … …  
    673683                add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
    674684        }
    675        
     685
    676686        return frac_lo;
    677687}
    … …  
    679689/*
    680690 * FIXME: Im not sure what to return if overflow/underflow happens
    681  *  - now its the biggest or the smallest int
     691 *      - now its the biggest or the smallest int
    682692 */
    683693uint32_t float128_to_uint32(float128 a)
    684694{
    685         if (is_float128_nan(a))
     695        if (isFloat128NaN(a))
    686696                return UINT32_MAX;
    687        
    688         if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     697
     698        if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    689699                if (a.parts.sign)
    690700                        return UINT32_MIN;
    691                
     701
    692702                return UINT32_MAX;
    693703        }
    694        
     704
    695705        return (uint32_t) _float128_to_uint64_helper(a);
    696706}
    … …  
    698708/*
    699709 * FIXME: Im not sure what to return if overflow/underflow happens
    700  *  - now its the biggest or the smallest int
     710 *      - now its the biggest or the smallest int
    701711 */
    702712int32_t float128_to_int32(float128 a)
    703713{
    704         if (is_float128_nan(a))
     714        if (isFloat128NaN(a))
    705715                return INT32_MAX;
    706        
    707         if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     716
     717        if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    708718                if (a.parts.sign)
    709719                        return INT32_MIN;
    710                
     720
    711721                return INT32_MAX;
    712722        }
    713        
     723
    714724        return (int32_t) _float128_to_uint64_helper(a);
    715725}
     726
    716727
    717728/*
    718729 * FIXME: Im not sure what to return if overflow/underflow happens
    719  *  - now its the biggest or the smallest int
     730 *      - now its the biggest or the smallest int
    720731 */
    721732uint64_t float128_to_uint64(float128 a)
    722733{
    723         if (is_float128_nan(a))
     734        if (isFloat128NaN(a))
    724735                return UINT64_MAX;
    725        
    726         if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     736
     737        if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    727738                if (a.parts.sign)
    728739                        return UINT64_MIN;
    729                
     740
    730741                return UINT64_MAX;
    731742        }
    732        
     743
    733744        return _float128_to_uint64_helper(a);
    734745}
    … …  
    736747/*
    737748 * FIXME: Im not sure what to return if overflow/underflow happens
    738  *  - now its the biggest or the smallest int
     749 *      - now its the biggest or the smallest int
    739750 */
    740751int64_t float128_to_int64(float128 a)
    741752{
    742         if (is_float128_nan(a))
     753        if (isFloat128NaN(a))
    743754                return INT64_MAX;
    744        
    745         if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     755
     756        if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    746757                if (a.parts.sign)
    747758                        return INT64_MIN;
    748                
     759
    749760                return INT64_MAX;
    750761        }
    751        
     762
    752763        return _float128_to_uint64_helper(a);
    753764}
     765
    754766
    755767float32 uint32_to_float32(uint32_t i)
    … …  
    761773        result.parts.sign = 0;
    762774        result.parts.fraction = 0;
    763        
    764         counter = count_zeroes32(i);
    765        
     775
     776        counter = countZeroes32(i);
     777
    766778        exp = FLOAT32_BIAS + 32 - counter - 1;
    767779       
    768780        if (counter == 32) {
    769                 result.bin = 0;
     781                result.binary = 0;
    770782                return result;
    771783        }
    … …  
    776788                i >>= 1;
    777789        }
    778        
    779         round_float32(&exp, &i);
    780        
     790
     791        roundFloat32(&exp, &i);
     792
    781793        result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
    782794        result.parts.exp = exp;
    783        
    784         return result;
    785 }
    786 
    787 float32 int32_to_float32(int32_t i)
     795
     796        return result;
     797}
     798
     799float32 int32_to_float32(int32_t i) 
    788800{
    789801        float32 result;
    790        
    791         if (i < 0)
     802
     803        if (i < 0) {
    792804                result = uint32_to_float32((uint32_t) (-i));
    793         else
     805        } else {
    794806                result = uint32_to_float32((uint32_t) i);
     807        }
    795808       
    796809        result.parts.sign = i < 0;
    797        
    798         return result;
    799 }
    800 
    801 float32 uint64_to_float32(uint64_t i)
     810
     811        return result;
     812}
     813
     814
     815float32 uint64_to_float32(uint64_t i)
    802816{
    803817        int counter;
    … …  
    808822        result.parts.sign = 0;
    809823        result.parts.fraction = 0;
    810        
    811         counter = count_zeroes64(i);
    812        
     824
     825        counter = countZeroes64(i);
     826
    813827        exp = FLOAT32_BIAS + 64 - counter - 1;
    814828       
    815829        if (counter == 64) {
    816                 result.bin = 0;
     830                result.binary = 0;
    817831                return result;
    818832        }
    … …  
    826840       
    827841        j = (uint32_t) i;
    828         round_float32(&exp, &j);
    829        
     842        roundFloat32(&exp, &j);
     843
    830844        result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
    831845        result.parts.exp = exp;
    … …  
    833847}
    834848
    835 float32 int64_to_float32(int64_t i)
     849float32 int64_to_float32(int64_t i) 
    836850{
    837851        float32 result;
    838        
    839         if (i < 0)
     852
     853        if (i < 0) {
    840854                result = uint64_to_float32((uint64_t) (-i));
    841         else
     855        } else {
    842856                result = uint64_to_float32((uint64_t) i);
     857        }
    843858       
    844859        result.parts.sign = i < 0;
    845        
    846         return result;
     860
     861        return result;
    847862}
    848863
    … …  
    856871        result.parts.sign = 0;
    857872        result.parts.fraction = 0;
    858        
    859         counter = count_zeroes32(i);
    860        
     873
     874        counter = countZeroes32(i);
     875
    861876        exp = FLOAT64_BIAS + 32 - counter - 1;
    862877       
    863878        if (counter == 32) {
    864                 result.bin = 0;
     879                result.binary = 0;
    865880                return result;
    866881        }
    867882       
    868883        frac = i;
    869         frac <<= counter + 32 - 1;
    870        
    871         round_float64(&exp, &frac);
    872        
     884        frac <<= counter + 32 - 1; 
     885
     886        roundFloat64(&exp, &frac);
     887
    873888        result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
    874889        result.parts.exp = exp;
    875        
    876         return result;
    877 }
    878 
    879 float64 int32_to_float64(int32_t i)
     890
     891        return result;
     892}
     893
     894float64 int32_to_float64(int32_t i) 
    880895{
    881896        float64 result;
    882        
    883         if (i < 0)
     897
     898        if (i < 0) {
    884899                result = uint32_to_float64((uint32_t) (-i));
    885         else
     900        } else {
    886901                result = uint32_to_float64((uint32_t) i);
     902        }
    887903       
    888904        result.parts.sign = i < 0;
    889        
    890         return result;
    891 }
    892 
    893 
    894 float64 uint64_to_float64(uint64_t i)
     905
     906        return result;
     907}
     908
     909
     910float64 uint64_to_float64(uint64_t i) 
    895911{
    896912        int counter;
    … …  
    900916        result.parts.sign = 0;
    901917        result.parts.fraction = 0;
    902        
    903         counter = count_zeroes64(i);
    904        
     918
     919        counter = countZeroes64(i);
     920
    905921        exp = FLOAT64_BIAS + 64 - counter - 1;
    906922       
    907923        if (counter == 64) {
    908                 result.bin = 0;
     924                result.binary = 0;
    909925                return result;
    910926        }
    … …  
    915931                i >>= 1;
    916932        }
    917        
    918         round_float64(&exp, &i);
    919        
     933
     934        roundFloat64(&exp, &i);
     935
    920936        result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
    921937        result.parts.exp = exp;
    … …  
    923939}
    924940
    925 float64 int64_to_float64(int64_t i)
     941float64 int64_to_float64(int64_t i) 
    926942{
    927943        float64 result;
    928        
    929         if (i < 0)
     944
     945        if (i < 0) {
    930946                result = uint64_to_float64((uint64_t) (-i));
    931         else
     947        } else {
    932948                result = uint64_to_float64((uint64_t) i);
     949        }
    933950       
    934951        result.parts.sign = i < 0;
    935        
    936         return result;
    937 }
     952
     953        return result;
     954}
     955
    938956
    939957float128 uint32_to_float128(uint32_t i)
    … …  
    943961        float128 result;
    944962        uint64_t frac_hi, frac_lo;
    945        
     963
    946964        result.parts.sign = 0;
    947965        result.parts.frac_hi = 0;
    948966        result.parts.frac_lo = 0;
    949        
    950         counter = count_zeroes32(i);
    951        
     967
     968        counter = countZeroes32(i);
     969
    952970        exp = FLOAT128_BIAS + 32 - counter - 1;
    953        
     971
    954972        if (counter == 32) {
    955                 result.bin.hi = 0;
    956                 result.bin.lo = 0;
    957                 return result;
    958         }
    959        
     973                result.binary.hi = 0;
     974                result.binary.lo = 0;
     975                return result;
     976        }
     977
    960978        frac_hi = 0;
    961979        frac_lo = i;
    962980        lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
    963        
    964         round_float128(&exp, &frac_hi, &frac_lo);
    965        
     981
     982        roundFloat128(&exp, &frac_hi, &frac_lo);
     983
    966984        rshift128(frac_hi, frac_lo,
    967985            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
    … …  
    969987        result.parts.frac_lo = frac_lo;
    970988        result.parts.exp = exp;
    971        
     989
    972990        return result;
    973991}
    … …  
    976994{
    977995        float128 result;
    978        
    979         if (i < 0)
     996
     997        if (i < 0) {
    980998                result = uint32_to_float128((uint32_t) (-i));
    981         else
     999        } else {
    9821000                result = uint32_to_float128((uint32_t) i);
    983        
     1001        }
     1002
    9841003        result.parts.sign = i < 0;
    985        
    986         return result;
     1004
     1005        return result;
    9871006}
    9881007
    … …  
    9941013        float128 result;
    9951014        uint64_t frac_hi, frac_lo;
    996        
     1015
    9971016        result.parts.sign = 0;
    9981017        result.parts.frac_hi = 0;
    9991018        result.parts.frac_lo = 0;
    1000        
    1001         counter = count_zeroes64(i);
    1002        
     1019
     1020        counter = countZeroes64(i);
     1021
    10031022        exp = FLOAT128_BIAS + 64 - counter - 1;
    1004        
     1023
    10051024        if (counter == 64) {
    1006                 result.bin.hi = 0;
    1007                 result.bin.lo = 0;
    1008                 return result;
    1009         }
    1010        
     1025                result.binary.hi = 0;
     1026                result.binary.lo = 0;
     1027                return result;
     1028        }
     1029
    10111030        frac_hi = 0;
    10121031        frac_lo = i;
    10131032        lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
    1014        
    1015         round_float128(&exp, &frac_hi, &frac_lo);
    1016        
     1033
     1034        roundFloat128(&exp, &frac_hi, &frac_lo);
     1035
    10171036        rshift128(frac_hi, frac_lo,
    10181037            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
    … …  
    10201039        result.parts.frac_lo = frac_lo;
    10211040        result.parts.exp = exp;
    1022        
     1041
    10231042        return result;
    10241043}
    … …  
    10271046{
    10281047        float128 result;
    1029        
    1030         if (i < 0)
     1048
     1049        if (i < 0) {
    10311050                result = uint64_to_float128((uint64_t) (-i));
    1032         else
     1051        } else {
    10331052                result = uint64_to_float128((uint64_t) i);
    1034        
     1053        }
     1054
    10351055        result.parts.sign = i < 0;
    1036        
    1037         return result;
     1056
     1057        return result;
    10381058}
    10391059
Note: See TracChangeset for help on using the changeset viewer.