Return to compare.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / iutil

Annotation of 43BSD/ingres/source/iutil/compare.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <symbol.h>
        !             4: # include      <aux.h>
        !             5: # include      <sccs.h>
        !             6: 
        !             7: SCCSID(@(#)compare.c   8.1     12/31/84)
        !             8: 
        !             9: icompare(ax, bx, frmt, frml)
        !            10: char   *ax, *bx, frmt, frml;
        !            11: {
        !            12:        register ANYTYPE        *a, *b;
        !            13:        register int            length;
        !            14:        float                   f4var;
        !            15:        double                  f8var;
        !            16:        ANYTYPE                 atemp, btemp;
        !            17: 
        !            18:        length = frml & I1MASK;
        !            19:        if (frmt == CHAR)
        !            20:                return (scompare(ax, length, bx, length));
        !            21:        a = &atemp;
        !            22:        b = &btemp;
        !            23:        bmove(ax, (char *) a, length);
        !            24:        bmove(bx, (char *) b, length);
        !            25:        if (bequal((char *) a, (char *) b, length))
        !            26:                return (0);
        !            27:        switch (frmt)
        !            28:        {
        !            29:          case INT:
        !            30:                switch (length)
        !            31:                {
        !            32:                  case 1:
        !            33:                        return (a->i1type - b->i1type);
        !            34:                  case 2:
        !            35:                        return (a->i2type - b->i2type);
        !            36:                  case 4:
        !            37:                        return (a->i4type > b->i4type ? 1 : -1);
        !            38:                }
        !            39:                break;
        !            40: 
        !            41:          case FLOAT:
        !            42:                if (frml == 4)
        !            43:                {
        !            44:                        if ( a->f4type > b->f4type )
        !            45:                                return ( 1 );
        !            46:                        else
        !            47:                                return ( -1 );
        !            48:                }
        !            49:                else
        !            50:                {
        !            51:                        if ( a->f8type > b->f8type )
        !            52:                                return ( 1 );
        !            53:                        else
        !            54:                                return ( -1 );
        !            55:                }
        !            56:                break;
        !            57:        }
        !            58:        syserr("compare: t=%d,l=%d", frmt, frml);
        !            59:        /*NOTREACHED*/
        !            60: }
        !            61: /*
        !            62: **  KCOMPARE -- key compare
        !            63: **
        !            64: **     compares all domains indicated by SETKEY in the tuple to the
        !            65: **     corressponding domains in the key.
        !            66: **     the comparison is done according to the format of the domain
        !            67: **     as specified in the descriptor.
        !            68: **
        !            69: **     function values:
        !            70: **             <0 tuple < key
        !            71: **             =0 tuple = key
        !            72: **             >0 tuple > key
        !            73: */
        !            74: 
        !            75: kcompare (dx, tuple, key)
        !            76: DESC   *dx;                    /*relation descriptor   */
        !            77: char   tuple[MAXTUP];          /*tuple to be compared  */
        !            78: char   key[MAXTUP];            /*second tuple or key   */
        !            79: {
        !            80:        register int    i, tmp;
        !            81:        register DESC   *d;
        !            82: 
        !            83:        d = dx;
        !            84:        for (i = 1; i <= d->reldum.relatts; i++)
        !            85:        {
        !            86:                if (d->relgiven[i])
        !            87:                {
        !            88:                        if (tmp = icompare(&tuple[d->reloff[i]],
        !            89:                                &key[d->reloff[i]],
        !            90:                                d->relfrmt[i],
        !            91:                                d->relfrml[i]))
        !            92:                        {
        !            93:                                return (tmp);
        !            94:                        }
        !            95:                }
        !            96:        }
        !            97:        return (0);
        !            98: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.