Return to sfcmp.c CVS log

Up to [local] / sys / arch / hppa / spmath

Annotation of sys/arch/hppa/spmath/sfcmp.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: sfcmp.c,v 1.6 2002/09/20 19:26:59 mickey Exp $        */
                      2: /*
                      3:   (c) Copyright 1986 HEWLETT-PACKARD COMPANY
                      4:   To anyone who acknowledges that this file is provided "AS IS"
                      5:   without any express or implied warranty:
                      6:       permission to use, copy, modify, and distribute this file
                      7:   for any purpose is hereby granted without fee, provided that
                      8:   the above copyright notice and this notice appears in all
                      9:   copies, and that the name of Hewlett-Packard Company not be
                     10:   used in advertising or publicity pertaining to distribution
                     11:   of the software without specific, written prior permission.
                     12:   Hewlett-Packard Company makes no representations about the
                     13:   suitability of this software for any purpose.
                     14: */
                     15: /* @(#)sfcmp.c: Revision: 1.7.88.2 Date: 93/12/08 13:28:43 */
                     16:
                     17: #include "float.h"
                     18: #include "sgl_float.h"
                     19:
                     20: /*
                     21:  * sgl_cmp: compare two values
                     22:  */
                     23: int
                     24: sgl_fcmp(leftptr, rightptr, cond, status)
                     25:     sgl_floating_point *leftptr, *rightptr;
                     26:     unsigned int cond; /* The predicate to be tested */
                     27:     unsigned int *status;
                     28: {
                     29:     register unsigned int left, right;
                     30:     register int xorresult;
                     31:
                     32:     /* Create local copies of the numbers */
                     33:     left = *leftptr;
                     34:     right = *rightptr;
                     35:     /*
                     36:      * Test for NaN
                     37:      */
                     38:     if(    (Sgl_exponent(left) == SGL_INFINITY_EXPONENT)
                     39:        || (Sgl_exponent(right) == SGL_INFINITY_EXPONENT) )
                     40:        {
                     41:        /* Check if a NaN is involved.  Signal an invalid exception when
                     42:         * comparing a signaling NaN or when comparing quiet NaNs and the
                     43:         * low bit of the condition is set */
                     44:        if( (  (Sgl_exponent(left) == SGL_INFINITY_EXPONENT)
                     45:            && Sgl_isnotzero_mantissa(left)
                     46:            && (Exception(cond) || Sgl_isone_signaling(left)))
                     47:           ||
                     48:            (  (Sgl_exponent(right) == SGL_INFINITY_EXPONENT)
                     49:            && Sgl_isnotzero_mantissa(right)
                     50:            && (Exception(cond) || Sgl_isone_signaling(right)) ) )
                     51:            {
                     52:            if( Is_invalidtrap_enabled() ) {
                     53:                Set_status_cbit(Unordered(cond));
                     54:                return(INVALIDEXCEPTION);
                     55:            }
                     56:            else Set_invalidflag();
                     57:            Set_status_cbit(Unordered(cond));
                     58:            return(NOEXCEPTION);
                     59:            }
                     60:        /* All the exceptional conditions are handled, now special case
                     61:           NaN compares */
                     62:        else if( ((Sgl_exponent(left) == SGL_INFINITY_EXPONENT)
                     63:            && Sgl_isnotzero_mantissa(left))
                     64:           ||
                     65:            ((Sgl_exponent(right) == SGL_INFINITY_EXPONENT)
                     66:            && Sgl_isnotzero_mantissa(right)) )
                     67:            {
                     68:            /* NaNs always compare unordered. */
                     69:            Set_status_cbit(Unordered(cond));
                     70:            return(NOEXCEPTION);
                     71:            }
                     72:        /* infinities will drop down to the normal compare mechanisms */
                     73:        }
                     74:     /* First compare for unequal signs => less or greater or
                     75:      * special equal case */
                     76:     Sgl_xortointp1(left,right,xorresult);
                     77:     if( xorresult < 0 )
                     78:        {
                     79:        /* left negative => less, left positive => greater.
                     80:         * equal is possible if both operands are zeros. */
                     81:        if( Sgl_iszero_exponentmantissa(left)
                     82:          && Sgl_iszero_exponentmantissa(right) )
                     83:            {
                     84:            Set_status_cbit(Equal(cond));
                     85:            }
                     86:        else if( Sgl_isone_sign(left) )
                     87:            {
                     88:            Set_status_cbit(Lessthan(cond));
                     89:            }
                     90:        else
                     91:            {
                     92:            Set_status_cbit(Greaterthan(cond));
                     93:            }
                     94:        }
                     95:     /* Signs are the same.  Treat negative numbers separately
                     96:      * from the positives because of the reversed sense.  */
                     97:     else if( Sgl_all(left) == Sgl_all(right) )
                     98:        {
                     99:        Set_status_cbit(Equal(cond));
                    100:        }
                    101:     else if( Sgl_iszero_sign(left) )
                    102:        {
                    103:        /* Positive compare */
                    104:        if( Sgl_all(left) < Sgl_all(right) )
                    105:            {
                    106:            Set_status_cbit(Lessthan(cond));
                    107:            }
                    108:        else
                    109:            {
                    110:            Set_status_cbit(Greaterthan(cond));
                    111:            }
                    112:        }
                    113:     else
                    114:        {
                    115:        /* Negative compare.  Signed or unsigned compares
                    116:         * both work the same.  That distinction is only
                    117:         * important when the sign bits differ. */
                    118:        if( Sgl_all(left) > Sgl_all(right) )
                    119:            {
                    120:            Set_status_cbit(Lessthan(cond));
                    121:            }
                    122:        else
                    123:            {
                    124:            Set_status_cbit(Greaterthan(cond));
                    125:            }
                    126:        }
                    127:        return(NOEXCEPTION);
                    128: }