Return to compare.c CVS log

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

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

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