Return to scompare.c CVS log

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

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

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

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