Return to as_merge.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common

Annotation of 43BSDReno/contrib/isode-beta/dsap/common/as_merge.c, revision 1.1

1.1     ! root        1: #include "quipu/util.h"
        !             2: #include "quipu/attrvalue.h"
        !             3: 
        !             4: Attr_Sequence as_merge (a,b)
        !             5: Attr_Sequence a,b;
        !             6: {
        !             7: register Attr_Sequence aptr, bptr, result, trail, tmp;
        !             8: 
        !             9:        if ( a == NULLATTR )
        !            10:                return (b);
        !            11:        if ( b == NULLATTR )
        !            12:                return (a);
        !            13: 
        !            14:        /* start sequence off, make sure 'a' is the first */
        !            15:        switch (AttrT_cmp (a->attr_type,b->attr_type)) {
        !            16:                case 0: /* equal */
        !            17:                        result = a;
        !            18:                        a->attr_value = avs_merge (a->attr_value, b->attr_value);
        !            19:                        aptr = a->attr_link;
        !            20:                        bptr = b->attr_link;
        !            21:                        free ((char *) b);
        !            22:                        break;
        !            23:                case -1:
        !            24:                        result = b;
        !            25:                        aptr = a;
        !            26:                        bptr = b->attr_link;
        !            27:                        break;
        !            28:                case 1:
        !            29:                        result = a;
        !            30:                        aptr = a->attr_link;
        !            31:                        bptr = b;
        !            32:                        break;
        !            33:                }
        !            34: 
        !            35:        trail = result;
        !            36:        while (  (aptr != NULLATTR) && (bptr != NULLATTR) ) {
        !            37: 
        !            38:           switch (AttrT_cmp (aptr->attr_type,bptr->attr_type)) {
        !            39:                case 0: /* equal */
        !            40:                        aptr->attr_value = avs_merge (aptr->attr_value, bptr->attr_value);
        !            41:                        tmp = bptr->attr_link;
        !            42:                        free ((char *) bptr);
        !            43:                        trail->attr_link = aptr;
        !            44:                        trail = aptr;
        !            45:                        aptr = aptr->attr_link;
        !            46:                        bptr = tmp;
        !            47:                        break;
        !            48:                case -1:
        !            49:                        trail->attr_link = bptr;
        !            50:                        trail = bptr;
        !            51:                        bptr = bptr->attr_link;
        !            52:                        break;
        !            53:                case 1:
        !            54:                        trail->attr_link = aptr;
        !            55:                        trail = aptr;
        !            56:                        aptr = aptr->attr_link;
        !            57:                        break;
        !            58:            }
        !            59:        }
        !            60:        if (aptr == NULLATTR)
        !            61:                trail->attr_link = bptr;
        !            62:        else
        !            63:                trail->attr_link = aptr;
        !            64: 
        !            65:        return (result);
        !            66: }
        !            67: 
        !            68: Attr_Sequence as_merge_aux (a,b)
        !            69: Attr_Sequence a,b;
        !            70: {
        !            71: register Attr_Sequence aptr, bptr, result, trail, tmp;
        !            72: 
        !            73:        if ( a == NULLATTR )
        !            74:                return (b);
        !            75:        if ( b == NULLATTR )
        !            76:                return (a);
        !            77: 
        !            78:        /* start sequence off, make sure 'a' is the first */
        !            79:        switch (AttrT_cmp (a->attr_type,b->attr_type)) {
        !            80:                case 0: /* equal */
        !            81:                        result = a;
        !            82:                        avs_free (a->attr_value);
        !            83:                        a->attr_value = b->attr_value;
        !            84:                        aptr = a->attr_link;
        !            85:                        bptr = b->attr_link;
        !            86:                        free ((char *) b);
        !            87:                        break;
        !            88:                case -1:
        !            89:                        result = b;
        !            90:                        aptr = a;
        !            91:                        bptr = b->attr_link;
        !            92:                        break;
        !            93:                case 1:
        !            94:                        result = a;
        !            95:                        aptr = a->attr_link;
        !            96:                        bptr = b;
        !            97:                        break;
        !            98:                }
        !            99: 
        !           100:        trail = result;
        !           101:        while (  (aptr != NULLATTR) && (bptr != NULLATTR) ) {
        !           102: 
        !           103:           switch (AttrT_cmp (aptr->attr_type,bptr->attr_type)) {
        !           104:                case 0: /* equal */
        !           105:                        avs_free (aptr->attr_value);
        !           106:                        aptr->attr_value = bptr->attr_value;
        !           107:                        tmp = bptr->attr_link;
        !           108:                        free ((char *) bptr);
        !           109:                        trail->attr_link = aptr;
        !           110:                        trail = aptr;
        !           111:                        aptr = aptr->attr_link;
        !           112:                        bptr = tmp;
        !           113:                        break;
        !           114:                case -1:
        !           115:                        trail->attr_link = bptr;
        !           116:                        trail = bptr;
        !           117:                        bptr = bptr->attr_link;
        !           118:                        break;
        !           119:                case 1:
        !           120:                        trail->attr_link = aptr;
        !           121:                        trail = aptr;
        !           122:                        aptr = aptr->attr_link;
        !           123:                        break;
        !           124:            }
        !           125:        }
        !           126:        if (aptr == NULLATTR)
        !           127:                trail->attr_link = bptr;
        !           128:        else
        !           129:                trail->attr_link = aptr;
        !           130: 
        !           131:        return (result);
        !           132: }
        !           133: 

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