Return to anycmp.c CVS log

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

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

1.1     ! root        1: #include "../h/rt.h"
        !             2: 
        !             3: /*
        !             4:  * anycmp - compare any two objects.  The result of the comparison is
        !             5:  *  an integer such that:
        !             6:  *    d1 = d2 -> 0
        !             7:  *    d1 > d2 -> >0  (1 if same type)
        !             8:  *    d1 < d2 -> <0  (-1 if same type)
        !             9:  */
        !            10: 
        !            11: anycmp(d1,d2)
        !            12: struct descrip *d1, *d2;
        !            13:    {
        !            14:    register int o1, o2;
        !            15:    register long lresult;
        !            16:    register double fresult;
        !            17: 
        !            18:    /*
        !            19:     * Get a collating number for d1 and d2.
        !            20:     */
        !            21:    o1 = order(d1);
        !            22:    o2 = order(d2);
        !            23: 
        !            24:    /*
        !            25:     * If d1 and d2 aren't of the same type, return the difference of
        !            26:     *  their collating numbers.
        !            27:     */
        !            28:    if (o1 != o2)
        !            29:       return (o1 - o2);
        !            30: 
        !            31:    if (o1 == D_NULL)
        !            32:       /*
        !            33:        * o1 0, (D_NULL), return 0 because all null values are the same.
        !            34:        */
        !            35:       return (0);
        !            36:    if (o1 == 3)
        !            37:       /*
        !            38:        * d1 and d2 are strings, use lexcmp to compare them.
        !            39:        */
        !            40:       return (lexcmp(d1,d2));
        !            41: 
        !            42:    switch (TYPE(*d1)) {
        !            43:       /*
        !            44:        * For numbers, return -1, 0, 1, depending on whether d1 <, =, > d2.
        !            45:        */
        !            46:       case T_INTEGER:
        !            47:          lresult = INTVAL(*d1) - INTVAL(*d2);
        !            48:          if (lresult == 0)
        !            49:             return (0);
        !            50:          return ((lresult > 0) ? 1 : -1);
        !            51: #ifdef LONGS
        !            52:       case T_LONGINT:
        !            53:          lresult = BLKLOC(*d1)->longint.intval - BLKLOC(*d2)->longint.intval;
        !            54:          if (lresult == 0)
        !            55:             return (0);
        !            56:          return ((lresult > 0) ? 1 : -1);
        !            57: #endif LONGS
        !            58:       case T_REAL:
        !            59:          fresult = BLKLOC(*d1)->realblk.realval - BLKLOC(*d2)->realblk.realval;
        !            60:          if (fresult == 0)
        !            61:             return (0);
        !            62:          return ((fresult > 0) ? 1 : -1);
        !            63: 
        !            64:       case T_CSET:
        !            65:       case T_FILE:
        !            66:       case T_PROC:
        !            67:       case T_LIST:
        !            68:       case T_TABLE:
        !            69: #ifdef SETS
        !            70:       case T_SET:
        !            71: #endif SETS
        !            72:       case T_RECORD:
        !            73:       case T_ESTACK:
        !            74:          /*
        !            75:           * Csets, files, procedures, lists, tables, records, co-expressions
        !            76:           *  and sets have no specified collating sequence so any two of 
        !            77:           *  the same type are considered to be equal.
        !            78:           */
        !            79:          return (0);
        !            80: 
        !            81:       default:
        !            82:          syserr("anycmp: unknown datatype.");
        !            83:       }
        !            84:    }
        !            85: 
        !            86: /*
        !            87:  * order(x) - return collating number for object x.
        !            88:  */
        !            89: 
        !            90: order(d)
        !            91: struct descrip *d;
        !            92:    {
        !            93:    if (QUAL(*d))
        !            94:       if (STRLOC(*d) == 0)
        !            95:          return(0);               /* &null */
        !            96:       else
        !            97:          return (3);              /* some string */
        !            98:    switch (TYPE(*d)) {
        !            99:       case T_INTEGER:
        !           100: #ifdef LONGS
        !           101:       case T_LONGINT:
        !           102: #endif LONGS
        !           103:          return (1);
        !           104:       case T_REAL:
        !           105:          return (2);
        !           106:       case T_CSET:
        !           107:          return (4);
        !           108:       case T_ESTACK:
        !           109:          return (5);
        !           110:       case T_FILE:
        !           111:          return (6);
        !           112:       case T_PROC:
        !           113:          return (7);
        !           114:       case T_LIST:
        !           115:          return (8);
        !           116:       case T_TABLE:
        !           117:          return (9);
        !           118: #ifdef SETS
        !           119:       case T_SET:
        !           120:          return (10);
        !           121: #endif SETS
        !           122:       case T_RECORD:
        !           123:          return (11);
        !           124:       default:
        !           125:          syserr("order: unknown datatype.");
        !           126:       }
        !           127:    }

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