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

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.