Return to rdn_merge.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/dsap/common/rdn_merge.c, revision 1.1.1.1

1.1       root        1: #include "quipu/util.h"
                      2: #include "quipu/name.h"
                      3: 
                      4: RDN rdn_merge (a,b)
                      5: RDN a,b;
                      6: {
                      7: register RDN aptr, bptr, result, trail;
                      8: 
                      9:        if ( a == NULLRDN )
                     10:                return (b);
                     11:        if ( b == NULLRDN )
                     12:                return (a);
                     13: 
                     14:        /* start sequence off, make sure 'a' is the first */
                     15:        switch (rdn_cmp_comp (a,b)) {
                     16:                case 0: /* equal */
                     17:                        result = a;
                     18:                        aptr = a->rdn_next;
                     19:                        rdn_comp_free (b);
                     20:                        bptr = b->rdn_next;
                     21:                        break;
                     22:                case -1:
                     23:                        result = b;
                     24:                        aptr = a;
                     25:                        bptr = b->rdn_next;
                     26:                        break;
                     27:                case 1:
                     28:                        result = a;
                     29:                        aptr = a->rdn_next;
                     30:                        bptr = b;
                     31:                        break;
                     32:                }
                     33: 
                     34:        trail = result;
                     35:        while (  (aptr != NULLRDN) && (bptr != NULLRDN) ) {
                     36: 
                     37:           switch (rdn_cmp_comp (aptr,bptr)) {
                     38:                case 0: /* equal */
                     39:                        trail->rdn_next = aptr;
                     40:                        trail = aptr;
                     41:                        rdn_comp_free (bptr);
                     42:                        aptr = aptr->rdn_next;
                     43:                        bptr = bptr->rdn_next;
                     44:                        break;
                     45:                case -1:
                     46:                        trail->rdn_next = bptr;
                     47:                        trail = bptr;
                     48:                        bptr = bptr->rdn_next;
                     49:                        break;
                     50:                case 1:
                     51:                        trail->rdn_next = aptr;
                     52:                        trail = aptr;
                     53:                        aptr = aptr->rdn_next;
                     54:                        break;
                     55:            }
                     56:        }
                     57:        if (aptr == NULLRDN)
                     58:                trail->rdn_next = bptr;
                     59:        else
                     60:                trail->rdn_next = aptr;
                     61: 
                     62:        return (result);
                     63: }
                     64: 

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