Return to scompare.c CVS log

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

Annotation of 42BSD/ingres/source/gutil/scompare.c, revision 1.1

1.1     ! root        1: # include      <sccs.h>
        !             2: 
        !             3: SCCSID(@(#)scompare.c  7.1     2/5/81)
        !             4: 
        !             5: /*
        !             6: **  STRING COMPARE
        !             7: **
        !             8: **     The strings 'a_ptr' and 'b_ptr' are compared.  Blanks are
        !             9: **     ignored.  The first string may be no longer than 'a_len'
        !            10: **     bytes, and the second string may be no longer than 'b_len'
        !            11: **     bytes.  If either length is zero, it is taken to be very
        !            12: **     long.  A null byte also terminates the scan.
        !            13: **
        !            14: **     Compares are based on the ascii ordering.
        !            15: **
        !            16: **     Shorter strings are less than longer strings.
        !            17: **
        !            18: **     Return value is positive one for a > b, minus one for a < b,
        !            19: **     and zero for a == b.
        !            20: **
        !            21: **     Examples:
        !            22: **             "abc" > "ab"
        !            23: **             "  a bc  " == "ab  c"
        !            24: **             "abc" < "abd"
        !            25: */
        !            26: 
        !            27: scompare(a_ptr, a_len, b_ptr, b_len)
        !            28: char   *a_ptr;
        !            29: int    a_len;
        !            30: char   *b_ptr;
        !            31: int    b_len;
        !            32: {
        !            33:        char            *ap;
        !            34:        char            *bp;
        !            35:        register char   a;
        !            36:        char            b;
        !            37:        register int    al;
        !            38:        register int    bl;
        !            39: 
        !            40:        ap = a_ptr;
        !            41:        bp = b_ptr;
        !            42:        al = a_len;
        !            43:        if (al == 0)
        !            44:                al = 32767;
        !            45:        bl = b_len;
        !            46:        if (bl == 0)
        !            47:                bl = 32767;
        !            48: 
        !            49:        while (1)
        !            50:        {
        !            51: 
        !            52:                /* supress blanks in both strings */
        !            53:                while ((a = *ap) == ' ' && al > 0)
        !            54:                {
        !            55:                        al--;
        !            56:                        ap++;
        !            57:                }
        !            58:                if (al == 0)
        !            59:                        a = 0;
        !            60:                while (*bp == ' ' && bl > 0)
        !            61:                {
        !            62:                        bl--;
        !            63:                        bp++;
        !            64:                }
        !            65:                if (bl == 0)
        !            66:                        b = 0;
        !            67:                else
        !            68:                        b = *bp;
        !            69: 
        !            70:                /* do inequality tests */
        !            71:                if (a < b)
        !            72:                        return (-1);
        !            73:                if (a > b)
        !            74:                        return (1);
        !            75:                if (a == 0)
        !            76:                        return (0);
        !            77: 
        !            78:                /* go on to the next character */
        !            79:                ap++;
        !            80:                al--;
        !            81:                bp++;
        !            82:                bl--;
        !            83:        }
        !            84: }

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