Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/softfloat/generic/conversion.c

    r9539be6 r00acd66  
    2727 */
    2828
    29 /** @addtogroup softfloat
     29/** @addtogroup softfloat       
    3030 * @{
    3131 */
     
    4545        result.parts.sign = a.parts.sign;
    4646        result.parts.fraction = a.parts.fraction;
    47         result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    48        
    49         if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
     47        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
     48       
     49        if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
    5050                result.parts.exp = 0x7FF;
    5151                /* TODO; check if its correct for SigNaNs*/
     
    5353        };
    5454       
    55         result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS);
     55        result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
    5656        if (a.parts.exp == 0) {
    5757                /* normalize denormalized numbers */
     
    181181uint32_t float32_to_uint32(float32 a)
    182182{
    183         if (isFloat32NaN(a))
    184                 return UINT32_MAX;
    185        
    186         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    187                 if (a.parts.sign)
    188                         return UINT32_MIN;
    189                
    190                 return UINT32_MAX;
    191         }
    192        
     183        if (isFloat32NaN(a)) {
     184                return MAX_UINT32;
     185        }
     186       
     187        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
     188                if (a.parts.sign) {
     189                        return MIN_UINT32;
     190                }
     191                return MAX_UINT32;
     192        }
     193       
     194        return _float32_to_uint32_helper(a);   
     195}
     196
     197/* Convert float to signed int32
     198 * FIXME: Im not sure what to return if overflow/underflow happens
     199 *      - now its the biggest or the smallest int
     200 */
     201int32_t float32_to_int32(float32 a)
     202{
     203        if (isFloat32NaN(a)) {
     204                return MAX_INT32;
     205        }
     206       
     207        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
     208                if (a.parts.sign) {
     209                        return MIN_INT32;
     210                }
     211                return MAX_INT32;
     212        }
    193213        return _float32_to_uint32_helper(a);
    194 }
    195 
    196 /* Convert float to signed int32
    197  * FIXME: Im not sure what to return if overflow/underflow happens
    198  *      - now its the biggest or the smallest int
    199  */
    200 int32_t float32_to_int32(float32 a)
    201 {
    202         if (isFloat32NaN(a))
    203                 return INT32_MAX;
    204        
    205         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    206                 if (a.parts.sign)
    207                         return INT32_MIN;
    208                
    209                 return INT32_MAX;
    210         }
    211        
    212         return _float32_to_uint32_helper(a);
    213 }
     214}       
    214215
    215216
     
    248249uint64_t float64_to_uint64(float64 a)
    249250{
    250         if (isFloat64NaN(a))
    251                 return UINT64_MAX;
    252        
    253        
    254         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    255                 if (a.parts.sign)
    256                         return UINT64_MIN;
    257                
    258                 return UINT64_MAX;
    259         }
    260        
     251        if (isFloat64NaN(a)) {
     252                return MAX_UINT64;
     253        }
     254       
     255        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
     256                if (a.parts.sign) {
     257                        return MIN_UINT64;
     258                }
     259                return MAX_UINT64;
     260        }
     261       
     262        return _float64_to_uint64_helper(a);   
     263}
     264
     265/* Convert float to signed int64
     266 * FIXME: Im not sure what to return if overflow/underflow happens
     267 *      - now its the biggest or the smallest int
     268 */
     269int64_t float64_to_int64(float64 a)
     270{
     271        if (isFloat64NaN(a)) {
     272                return MAX_INT64;
     273        }
     274       
     275        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
     276                if (a.parts.sign) {
     277                        return MIN_INT64;
     278                }
     279                return MAX_INT64;
     280        }
    261281        return _float64_to_uint64_helper(a);
    262 }
    263 
    264 /* Convert float to signed int64
    265  * FIXME: Im not sure what to return if overflow/underflow happens
    266  *      - now its the biggest or the smallest int
    267  */
    268 int64_t float64_to_int64(float64 a)
    269 {
    270         if (isFloat64NaN(a))
    271                 return INT64_MAX;
    272        
    273        
    274         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    275                 if (a.parts.sign)
    276                         return INT64_MIN;
    277                
    278                 return INT64_MAX;
    279         }
    280        
    281         return _float64_to_uint64_helper(a);
    282 }
     282}       
    283283
    284284
     
    320320uint64_t float32_to_uint64(float32 a)
    321321{
    322         if (isFloat32NaN(a))
    323                 return UINT64_MAX;
    324        
    325        
    326         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    327                 if (a.parts.sign)
    328                         return UINT64_MIN;
    329                
    330                 return UINT64_MAX;
    331         }
    332        
     322        if (isFloat32NaN(a)) {
     323                return MAX_UINT64;
     324        }
     325       
     326        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
     327                if (a.parts.sign) {
     328                        return MIN_UINT64;
     329                }
     330                return MAX_UINT64;
     331        }
     332       
     333        return _float32_to_uint64_helper(a);   
     334}
     335
     336/* Convert float to signed int64
     337 * FIXME: Im not sure what to return if overflow/underflow happens
     338 *      - now its the biggest or the smallest int
     339 */
     340int64_t float32_to_int64(float32 a)
     341{
     342        if (isFloat32NaN(a)) {
     343                return MAX_INT64;
     344        }
     345       
     346        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
     347                if (a.parts.sign) {
     348                        return (MIN_INT64);
     349                }
     350                return MAX_INT64;
     351        }
    333352        return _float32_to_uint64_helper(a);
    334 }
    335 
    336 /* Convert float to signed int64
    337  * FIXME: Im not sure what to return if overflow/underflow happens
    338  *      - now its the biggest or the smallest int
    339  */
    340 int64_t float32_to_int64(float32 a)
    341 {
    342         if (isFloat32NaN(a))
    343                 return INT64_MAX;
    344        
    345         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    346                 if (a.parts.sign)
    347                         return INT64_MIN;
    348                
    349                 return INT64_MAX;
    350         }
    351        
    352         return _float32_to_uint64_helper(a);
    353 }
     353}       
    354354
    355355
     
    360360uint32_t float64_to_uint32(float64 a)
    361361{
    362         if (isFloat64NaN(a))
    363                 return UINT32_MAX;
    364        
    365        
    366         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    367                 if (a.parts.sign)
    368                         return UINT32_MIN;
    369                
    370                 return UINT32_MAX;
    371         }
    372        
    373         return (uint32_t) _float64_to_uint64_helper(a);
     362        if (isFloat64NaN(a)) {
     363                return MAX_UINT32;
     364        }
     365       
     366        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
     367                if (a.parts.sign) {
     368                        return MIN_UINT32;
     369                }
     370                return MAX_UINT32;
     371        }
     372       
     373        return (uint32_t)_float64_to_uint64_helper(a); 
    374374}
    375375
     
    380380int32_t float64_to_int32(float64 a)
    381381{
    382         if (isFloat64NaN(a))
    383                 return INT32_MAX;
    384        
    385        
    386         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    387                 if (a.parts.sign)
    388                         return INT32_MIN;
    389                
    390                 return INT32_MAX;
    391         }
    392        
    393         return (int32_t) _float64_to_uint64_helper(a);
    394 }
     382        if (isFloat64NaN(a)) {
     383                return MAX_INT32;
     384        }
     385       
     386        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
     387                if (a.parts.sign) {
     388                        return MIN_INT32;
     389                }
     390                return MAX_INT32;
     391        }
     392        return (int32_t)_float64_to_uint64_helper(a);
     393}       
    395394
    396395/** Convert unsigned integer to float32
Note: See TracChangeset for help on using the changeset viewer.