Return to equiv.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt

Annotation of 43BSD/contrib/icon/rt/equiv.c, revision 1.1

1.1     ! root        1: #include "../h/rt.h"
        !             2: 
        !             3: /*
        !             4:  * equiv - test equivalence of two objects.
        !             5:  */
        !             6: 
        !             7: equiv(arg1, arg2)
        !             8: struct descrip *arg1, *arg2;
        !             9:    {
        !            10:    register int result, i;
        !            11:    register char *s1, *s2;
        !            12: 
        !            13:    result = 0;
        !            14: 
        !            15:       /*
        !            16:        * If the descriptors are identical, the objects are equivalent.
        !            17:        */
        !            18:    if (arg1->type == arg2->type && BLKLOC(*arg1) == BLKLOC(*arg2))
        !            19:       result = 1;
        !            20:    else if (QUAL(*arg1) && QUAL(*arg2)) {
        !            21: 
        !            22:       /*
        !            23:        * Both objects are strings, or one is &null and the other a string,
        !            24:        * If either is &null the other isn't or we wouldn't have
        !            25:        *  gotten this far.
        !            26:        *  If both are strings of equal length, compare their characters.
        !            27:        */
        !            28: 
        !            29:       if (NULLDESC(*arg1) || NULLDESC(*arg2))
        !            30:          result = 0;
        !            31:       else if ((i = STRLEN(*arg1)) == STRLEN(*arg2)) {
        !            32:          s1 = STRLOC(*arg1);
        !            33:          s2 = STRLOC(*arg2);
        !            34:          result = 1;
        !            35:          while (i--)
        !            36:            if (*s1++ != *s2++) {
        !            37:               result = 0;
        !            38:               break;
        !            39:               }
        !            40:          }
        !            41:       }
        !            42:    else if (arg1->type == arg2->type)
        !            43:       switch (TYPE(*arg1)) {
        !            44:          /*
        !            45:           * For integers and reals, just compare the values.
        !            46:           */
        !            47:          case T_INTEGER:
        !            48:             result = (INTVAL(*arg1) == INTVAL(*arg2));
        !            49:             break;
        !            50: #ifdef LONGS
        !            51:          case T_LONGINT:
        !            52:             result =
        !            53:                (BLKLOC(*arg1)->longint.intval == BLKLOC(*arg2)->longint.intval);
        !            54:             break;
        !            55: #endif LONGS
        !            56:          case T_REAL:
        !            57:             result =
        !            58:                (BLKLOC(*arg1)->realblk.realval == BLKLOC(*arg2)->realblk.realval);
        !            59:             break;
        !            60:          case T_CSET:
        !            61:             /*
        !            62:              * Compare the bit arrays of the csets.
        !            63:              */
        !            64:             result = 1;
        !            65:             for (i = 0; i < CSETSIZE; i++)
        !            66:                if (BLKLOC(*arg1)->cset.bits[i] != BLKLOC(*arg2)->cset.bits[i]) {
        !            67:                   result = 0;
        !            68:                   break;
        !            69:                   }
        !            70:          }
        !            71:    else
        !            72:       /*
        !            73:        * arg1 and arg2 are of different types, so they can't be
        !            74:        *  equivalent.
        !            75:        */
        !            76:       result = 0;
        !            77: 
        !            78:    return (result);
        !            79:    }

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