Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/comparison.c

    ra35b458 r1b20da0  
    190190        uint64_t tmp_hi;
    191191        uint64_t tmp_lo;
    192 
     192       
    193193        and128(ld.bin.hi, ld.bin.lo,
    194194            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    195 
     195       
    196196        return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    197197}
    … …  
    236236        uint64_t tmp_hi;
    237237        uint64_t tmp_lo;
    238 
     238       
    239239        /* both are zeros (with any sign) */
    240240        or128(a.bin.hi, a.bin.lo,
    … …  
    243243            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    244244        int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    245 
     245       
    246246        /* a equals to b */
    247247        int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    248 
     248       
    249249        return are_equal || both_zero;
    250250}
    … …  
    263263                return 0;
    264264        }
    265 
     265       
    266266        if ((a.parts.sign) && (b.parts.sign)) {
    267267                /* if both are negative, smaller is that with greater binary value */
    268268                return (a.bin > b.bin);
    269269        }
    270 
     270       
    271271        /*
    272272         * lets negate signs - now will be positive numbers always
    … …  
    292292                return 0;
    293293        }
    294 
     294       
    295295        if ((a.parts.sign) && (b.parts.sign)) {
    296296                /* if both are negative, smaller is that with greater binary value */
    297297                return (a.bin > b.bin);
    298298        }
    299 
     299       
    300300        /*
    301301         * lets negate signs - now will be positive numbers always
    … …  
    319319        uint64_t tmp_hi;
    320320        uint64_t tmp_lo;
    321 
     321       
    322322        or128(a.bin.hi, a.bin.lo,
    323323            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    … …  
    328328                return 0;
    329329        }
    330 
     330       
    331331        if ((a.parts.sign) && (b.parts.sign)) {
    332332                /* if both are negative, smaller is that with greater binary value */
    333333                return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
    334334        }
    335 
     335       
    336336        /*
    337337         * lets negate signs - now will be positive numbers always
    … …  
    357357                return 0;
    358358        }
    359 
     359       
    360360        if ((a.parts.sign) && (b.parts.sign)) {
    361361                /* if both are negative, greater is that with smaller binary value */
    362362                return (a.bin < b.bin);
    363363        }
    364 
     364       
    365365        /*
    366366         * lets negate signs - now will be positive numbers always
    … …  
    386386                return 0;
    387387        }
    388 
     388       
    389389        if ((a.parts.sign) && (b.parts.sign)) {
    390390                /* if both are negative, greater is that with smaller binary value */
    391391                return (a.bin < b.bin);
    392392        }
    393 
     393       
    394394        /*
    395395         * lets negate signs - now will be positive numbers always
    … …  
    413413        uint64_t tmp_hi;
    414414        uint64_t tmp_lo;
    415 
     415       
    416416        or128(a.bin.hi, a.bin.lo,
    417417            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    … …  
    422422                return 0;
    423423        }
    424 
     424       
    425425        if ((a.parts.sign) && (b.parts.sign)) {
    426426                /* if both are negative, greater is that with smaller binary value */
    427427                return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    428428        }
    429 
     429       
    430430        /*
    431431         * lets negate signs - now will be positive numbers always
    … …  
    444444        float32_u ua;
    445445        ua.val = a;
    446 
     446       
    447447        float32_u ub;
    448448        ub.val = b;
    449 
     449       
    450450        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    451451                // TODO: sigNaNs
    452452                return -1;
    453453        }
    454 
     454       
    455455        if (is_float32_gt(ua.data, ub.data))
    456456                return 1;
    457 
     457       
    458458        return 0;
    459459}
    … …  
    463463        float32_u ua;
    464464        ua.val = a;
    465 
     465       
    466466        float32_u ub;
    467467        ub.val = b;
    468 
     468       
    469469        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    470470                // TODO: sigNaNs
    471471                return -1;
    472472        }
    473 
     473       
    474474        if (is_float32_eq(ua.data, ub.data))
    475475                return 0;
    476 
     476       
    477477        if (is_float32_gt(ua.data, ub.data))
    478478                return 1;
    479 
     479       
    480480        return -1;
    481481}
    … …  
    485485        float32_u ua;
    486486        ua.val = a;
    487 
     487       
    488488        float32_u ub;
    489489        ub.val = b;
    490 
     490       
    491491        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    492492                // TODO: sigNaNs
    493493                return 1;
    494494        }
    495 
     495       
    496496        if (is_float32_lt(ua.data, ub.data))
    497497                return -1;
    498 
     498       
    499499        return 0;
    500500}
    … …  
    504504        float32_u ua;
    505505        ua.val = a;
    506 
     506       
    507507        float32_u ub;
    508508        ub.val = b;
    509 
     509       
    510510        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    511511                // TODO: sigNaNs
    512512                return 1;
    513513        }
    514 
     514       
    515515        if (is_float32_eq(ua.data, ub.data))
    516516                return 0;
    517 
     517       
    518518        if (is_float32_lt(ua.data, ub.data))
    519519                return -1;
    520 
     520       
    521521        return 1;
    522522}
    … …  
    526526        float32_u ua;
    527527        ua.val = a;
    528 
     528       
    529529        float32_u ub;
    530530        ub.val = b;
    531 
     531       
    532532        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    533533                // TODO: sigNaNs
    534534                return 1;
    535535        }
    536 
     536       
    537537        return is_float32_eq(ua.data, ub.data) - 1;
    538538}
    … …  
    548548        float32_u ua;
    549549        ua.val = a;
    550 
     550       
    551551        float32_u ub;
    552552        ub.val = b;
    553 
     553       
    554554        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    555555                /* No special constant for unordered - maybe signaled? */
    556556                return 1;
    557557        }
    558 
     558       
    559559        if (is_float32_eq(ua.data, ub.data))
    560560                return 0;
    561 
     561       
    562562        if (is_float32_lt(ua.data, ub.data))
    563563                return -1;
    564 
     564       
    565565        return 1;
    566566}
    … …  
    570570        float32_u ua;
    571571        ua.val = a;
    572 
     572       
    573573        float32_u ub;
    574574        ub.val = b;
    575 
     575       
    576576        return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data)));
    577577}
    … …  
    581581        float32_u ua;
    582582        ua.val = a;
    583 
     583       
    584584        float32_u ub;
    585585        ub.val = b;
    586 
     586       
    587587        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    588588                // TODO: sigNaNs
    589589                return -1;
    590590        }
    591 
     591       
    592592        if (is_float32_gt(ua.data, ub.data))
    593593                return 1;
    594 
     594       
    595595        return 0;
    596596}
    … …  
    600600        float32_u ua;
    601601        ua.val = a;
    602 
     602       
    603603        float32_u ub;
    604604        ub.val = b;
    605 
     605       
    606606        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    607607                // TODO: sigNaNs
    608608                return 1;
    609609        }
    610 
     610       
    611611        if (is_float32_lt(ua.data, ub.data))
    612612                return -1;
    613 
     613       
    614614        return 0;
    615615}
    … …  
    619619        float32_u ua;
    620620        ua.val = a;
    621 
     621       
    622622        float32_u ub;
    623623        ub.val = b;
    624 
     624       
    625625        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    626626                // TODO: sigNaNs
    627627                return -1;
    628628        }
    629 
     629       
    630630        if (is_float32_eq(ua.data, ub.data))
    631631                return 0;
    632 
     632       
    633633        if (is_float32_gt(ua.data, ub.data))
    634634                return 1;
    635 
     635       
    636636        return -1;
    637637}
    … …  
    641641        float32_u ua;
    642642        ua.val = a;
    643 
     643       
    644644        float32_u ub;
    645645        ub.val = b;
    646 
     646       
    647647        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    648648                // TODO: sigNaNs
    649649                return 1;
    650650        }
    651 
     651       
    652652        return is_float32_eq(ua.data, ub.data) - 1;
    653653}
    … …  
    661661        float64_u ua;
    662662        ua.val = a;
    663 
     663       
    664664        float64_u ub;
    665665        ub.val = b;
    666 
     666       
    667667        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    668668                // TODO: sigNaNs
    669669                return -1;
    670670        }
    671 
     671       
    672672        if (is_float64_gt(ua.data, ub.data))
    673673                return 1;
    674 
     674       
    675675        return 0;
    676676}
    … …  
    680680        float64_u ua;
    681681        ua.val = a;
    682 
     682       
    683683        float64_u ub;
    684684        ub.val = b;
    685 
     685       
    686686        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    687687                // TODO: sigNaNs
    688688                return -1;
    689689        }
    690 
     690       
    691691        if (is_float64_eq(ua.data, ub.data))
    692692                return 0;
    693 
     693       
    694694        if (is_float64_gt(ua.data, ub.data))
    695695                return 1;
    696 
     696       
    697697        return -1;
    698698}
    … …  
    702702        float64_u ua;
    703703        ua.val = a;
    704 
     704       
    705705        float64_u ub;
    706706        ub.val = b;
    707 
     707       
    708708        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    709709                // TODO: sigNaNs
    710710                return 1;
    711711        }
    712 
     712       
    713713        if (is_float64_lt(ua.data, ub.data))
    714714                return -1;
    715 
     715       
    716716        return 0;
    717717}
    … …  
    721721        float64_u ua;
    722722        ua.val = a;
    723 
     723       
    724724        float64_u ub;
    725725        ub.val = b;
    726 
     726       
    727727        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    728728                // TODO: sigNaNs
    729729                return 1;
    730730        }
    731 
     731       
    732732        if (is_float64_eq(ua.data, ub.data))
    733733                return 0;
    734 
     734       
    735735        if (is_float64_lt(ua.data, ub.data))
    736736                return -1;
    737 
     737       
    738738        return 1;
    739739}
    … …  
    743743        float64_u ua;
    744744        ua.val = a;
    745 
     745       
    746746        float64_u ub;
    747747        ub.val = b;
    748 
     748       
    749749        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    750750                // TODO: sigNaNs
    751751                return 1;
    752752        }
    753 
     753       
    754754        return is_float64_eq(ua.data, ub.data) - 1;
    755755}
    … …  
    765765        float64_u ua;
    766766        ua.val = a;
    767 
     767       
    768768        float64_u ub;
    769769        ub.val = b;
    770 
     770       
    771771        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    772772                /* No special constant for unordered - maybe signaled? */
    773773                return 1;
    774774        }
    775 
     775       
    776776        if (is_float64_eq(ua.data, ub.data))
    777777                return 0;
    778 
     778       
    779779        if (is_float64_lt(ua.data, ub.data))
    780780                return -1;
    781 
     781       
    782782        return 1;
    783783}
    … …  
    787787        float64_u ua;
    788788        ua.val = a;
    789 
     789       
    790790        float64_u ub;
    791791        ub.val = b;
    792 
     792       
    793793        return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data)));
    794794}
    … …  
    798798        float64_u ua;
    799799        ua.val = a;
    800 
     800       
    801801        float64_u ub;
    802802        ub.val = b;
    803 
     803       
    804804        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    805805                // TODO: sigNaNs
    806806                return 1;
    807807        }
    808 
     808       
    809809        if (is_float64_lt(ua.data, ub.data))
    810810                return -1;
    811 
     811       
    812812        return 0;
    813813}
    … …  
    817817        float64_u ua;
    818818        ua.val = a;
    819 
     819       
    820820        float64_u ub;
    821821        ub.val = b;
    822 
     822       
    823823        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    824824                // TODO: sigNaNs
    825825                return 1;
    826826        }
    827 
     827       
    828828        return is_float64_eq(ua.data, ub.data) - 1;
    829829}
    … …  
    833833        float64_u ua;
    834834        ua.val = a;
    835 
     835       
    836836        float64_u ub;
    837837        ub.val = b;
    838 
     838       
    839839        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    840840                // TODO: sigNaNs
    841841                return -1;
    842842        }
    843 
     843       
    844844        if (is_float64_gt(ua.data, ub.data))
    845845                return 1;
    846 
     846       
    847847        return 0;
    848848}
    … …  
    852852        float64_u ua;
    853853        ua.val = a;
    854 
     854       
    855855        float64_u ub;
    856856        ub.val = b;
    857 
     857       
    858858        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    859859                // TODO: sigNaNs
    860860                return -1;
    861861        }
    862 
     862       
    863863        if (is_float64_eq(ua.data, ub.data))
    864864                return 0;
    865 
     865       
    866866        if (is_float64_gt(ua.data, ub.data))
    867867                return 1;
    868 
     868       
    869869        return -1;
    870870}
    … …  
    874874        float64_u ua;
    875875        ua.val = a;
    876 
     876       
    877877        float64_u ub;
    878878        ub.val = b;
    879 
     879       
    880880        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    881881                // TODO: sigNaNs
    882882                return 1;
    883883        }
    884 
     884       
    885885        if (is_float64_eq(ua.data, ub.data))
    886886                return 0;
    887 
     887       
    888888        if (is_float64_lt(ua.data, ub.data))
    889889                return -1;
    890 
     890       
    891891        return 1;
    892892}
    … …  
    900900        float128_u ua;
    901901        ua.val = a;
    902 
    903         float128_u ub;
    904         ub.val = b;
    905 
     902       
     903        float128_u ub;
     904        ub.val = b;
     905       
    906906        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    907907                // TODO: sigNaNs
    908908                return -1;
    909909        }
    910 
     910       
    911911        if (is_float128_gt(ua.data, ub.data))
    912912                return 1;
    913 
     913       
    914914        return 0;
    915915}
    … …  
    919919        float128_u ua;
    920920        ua.val = a;
    921 
    922         float128_u ub;
    923         ub.val = b;
    924 
     921       
     922        float128_u ub;
     923        ub.val = b;
     924       
    925925        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    926926                // TODO: sigNaNs
    927927                return -1;
    928928        }
    929 
     929       
    930930        if (is_float128_eq(ua.data, ub.data))
    931931                return 0;
    932 
     932       
    933933        if (is_float128_gt(ua.data, ub.data))
    934934                return 1;
    935 
     935       
    936936        return -1;
    937937}
    … …  
    941941        float128_u ua;
    942942        ua.val = a;
    943 
    944         float128_u ub;
    945         ub.val = b;
    946 
     943       
     944        float128_u ub;
     945        ub.val = b;
     946       
    947947        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    948948                // TODO: sigNaNs
    949949                return 1;
    950950        }
    951 
     951       
    952952        if (is_float128_lt(ua.data, ub.data))
    953953                return -1;
    954 
     954       
    955955        return 0;
    956956}
    … …  
    960960        float128_u ua;
    961961        ua.val = a;
    962 
    963         float128_u ub;
    964         ub.val = b;
    965 
     962       
     963        float128_u ub;
     964        ub.val = b;
     965       
    966966        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    967967                // TODO: sigNaNs
    968968                return 1;
    969969        }
    970 
     970       
    971971        if (is_float128_eq(ua.data, ub.data))
    972972                return 0;
    973 
     973       
    974974        if (is_float128_lt(ua.data, ub.data))
    975975                return -1;
    976 
     976       
    977977        return 1;
    978978}
    … …  
    982982        float128_u ua;
    983983        ua.val = a;
    984 
    985         float128_u ub;
    986         ub.val = b;
    987 
     984       
     985        float128_u ub;
     986        ub.val = b;
     987       
    988988        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    989989                // TODO: sigNaNs
    990990                return 1;
    991991        }
    992 
     992       
    993993        return is_float128_eq(ua.data, ub.data) - 1;
    994994}
    … …  
    10041004        float128_u ua;
    10051005        ua.val = a;
    1006 
    1007         float128_u ub;
    1008         ub.val = b;
    1009 
     1006       
     1007        float128_u ub;
     1008        ub.val = b;
     1009       
    10101010        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    10111011                /* No special constant for unordered - maybe signaled? */
    10121012                return 1;
    10131013        }
    1014 
     1014       
    10151015        if (is_float128_eq(ua.data, ub.data))
    10161016                return 0;
    1017 
     1017       
    10181018        if (is_float128_lt(ua.data, ub.data))
    10191019                return -1;
    1020 
     1020       
    10211021        return 1;
    10221022}
    … …  
    10261026        float128_u ua;
    10271027        ua.val = a;
    1028 
    1029         float128_u ub;
    1030         ub.val = b;
    1031 
     1028       
     1029        float128_u ub;
     1030        ub.val = b;
     1031       
    10321032        return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)));
    10331033}
    … …  
    10371037        float128_u ua;
    10381038        ua.val = *a;
    1039 
     1039       
    10401040        float128_u ub;
    10411041        ub.val = *b;
    1042 
     1042       
    10431043        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10441044                return 3;
    1045 
     1045       
    10461046        if (is_float128_eq(ua.data, ub.data))
    10471047                return 0;
    1048 
     1048       
    10491049        if (is_float128_lt(ua.data, ub.data))
    10501050                return 1;
    1051 
     1051       
    10521052        return 2;
    10531053}
    … …  
    10631063        float128_u ua;
    10641064        ua.val = *a;
    1065 
     1065       
    10661066        float128_u ub;
    10671067        ub.val = *b;
    1068 
     1068       
    10691069        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10701070                return 0;
    1071 
     1071       
    10721072        return is_float128_gt(ua.data, ub.data);
    10731073}
    … …  
    10771077        float128_u ua;
    10781078        ua.val = *a;
    1079 
     1079       
    10801080        float128_u ub;
    10811081        ub.val = *b;
    1082 
     1082       
    10831083        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10841084                return 0;
    1085 
     1085       
    10861086        return is_float128_eq(ua.data, ub.data) ||
    10871087            is_float128_gt(ua.data, ub.data);
    … …  
    10921092        float128_u ua;
    10931093        ua.val = *a;
    1094 
     1094       
    10951095        float128_u ub;
    10961096        ub.val = *b;
    1097 
     1097       
    10981098        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10991099                return 0;
    1100 
     1100       
    11011101        return is_float128_lt(ua.data, ub.data);
    11021102}
    … …  
    11061106        float128_u ua;
    11071107        ua.val = *a;
    1108 
     1108       
    11091109        float128_u ub;
    11101110        ub.val = *b;
    1111 
     1111       
    11121112        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11131113                return 0;
    1114 
     1114       
    11151115        return is_float128_eq(ua.data, ub.data) ||
    11161116            is_float128_lt(ua.data, ub.data);
    … …  
    11211121        float128_u ua;
    11221122        ua.val = *a;
    1123 
     1123       
    11241124        float128_u ub;
    11251125        ub.val = *b;
    1126 
     1126       
    11271127        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11281128                return 0;
    1129 
     1129       
    11301130        return is_float128_eq(ua.data, ub.data);
    11311131}
    … …  
    11351135        float128_u ua;
    11361136        ua.val = *a;
    1137 
     1137       
    11381138        float128_u ub;
    11391139        ub.val = *b;
    1140 
     1140       
    11411141        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11421142                return 0;
    1143 
     1143       
    11441144        return !is_float128_eq(ua.data, ub.data);
    11451145}
Note: See TracChangeset for help on using the changeset viewer.