Changeset a35b458 in mainline for uspace/lib/softfloat/comparison.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/comparison.c

    r3061bc1 ra35b458  
    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.