httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@hyperreal.org
Subject cvs commit: apache-apr/apr/lib apr_tables.c Makefile.in apr_pools.c
Date Tue, 27 Jul 1999 18:28:01 GMT
rbb         99/07/27 11:28:00

  Modified:    apr/lib  Makefile.in apr_pools.c
  Added:       apr/lib  apr_tables.c
  Log:
  Split the array and table functions out from the memory pool functions.
  This should make it easier to allow for pools vs malloc/free options at
  configure time.  I'll be splitting out more code shortly. :)
  
  Revision  Changes    Path
  1.12      +19 -6     apache-apr/apr/lib/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apache-apr/apr/lib/Makefile.in,v
  retrieving revision 1.11
  retrieving revision 1.12
  diff -u -r1.11 -r1.12
  --- Makefile.in	1999/07/23 14:41:38	1.11
  +++ Makefile.in	1999/07/27 18:27:58	1.12
  @@ -24,7 +24,8 @@
   	apr_pools.o \
   	apr_signal.o \
   	apr_slack.o \
  -	apr_snprintf.o
  +	apr_snprintf.o \
  +	apr_tables.o
   
   .c.o:
   	$(CC) $(CFLAGS) -c $(INCLUDES) $<
  @@ -62,12 +63,24 @@
   apr_cpystrn.o: apr_cpystrn.c $(INCDIR)/apr_config.h
   apr_execve.o: apr_execve.c $(INCDIR)/apr_config.h
   apr_fnmatch.o: apr_fnmatch.c $(INCDIR)/apr_config.h \
  - $(INCDIR)/apr_fnmatch.h
  + $(INCDIR)/apr_fnmatch.h $(INCDIR)/apr_lib.h \
  + ../../include/apr_general.h ../../include/apr_errno.h \
  + $(INCDIR)/hsregex.h
   apr_md5.o: apr_md5.c $(INCDIR)/apr_config.h $(INCDIR)/apr_md5.h \
  - $(INCDIR)/apr_lib.h $(INCDIR)/hsregex.h
  + $(INCDIR)/apr_lib.h ../../include/apr_general.h \
  + ../../include/apr_errno.h $(INCDIR)/hsregex.h
   apr_pools.o: apr_pools.c $(INCDIR)/apr_config.h \
  - $(INCDIR)/apr_pools.h $(INCDIR)/apr_lib.h $(INCDIR)/hsregex.h
  -apr_signal.o: apr_signal.c $(INCDIR)/apr_config.h
  + ../../include/apr_general.h ../../include/apr_errno.h \
  + $(INCDIR)/apr_pools.h $(INCDIR)/apr_lib.h $(INCDIR)/hsregex.h \
  + ../misc/unix/misc.h ../../include/apr_file_io.h
  +apr_signal.o: apr_signal.c $(INCDIR)/apr_config.h \
  + $(INCDIR)/apr_lib.h ../../include/apr_general.h \
  + ../../include/apr_errno.h $(INCDIR)/hsregex.h
   apr_slack.o: apr_slack.c $(INCDIR)/apr_config.h
   apr_snprintf.o: apr_snprintf.c $(INCDIR)/apr_config.h \
  - $(INCDIR)/apr_lib.h $(INCDIR)/hsregex.h
  + $(INCDIR)/apr_lib.h ../../include/apr_general.h \
  + ../../include/apr_errno.h $(INCDIR)/hsregex.h
  +apr_tables.o: apr_tables.c $(INCDIR)/apr_config.h \
  + ../../include/apr_general.h ../../include/apr_errno.h \
  + $(INCDIR)/apr_pools.h $(INCDIR)/apr_lib.h $(INCDIR)/hsregex.h \
  + ../misc/unix/misc.h ../../include/apr_file_io.h
  
  
  
  1.9       +0 -690    apache-apr/apr/lib/apr_pools.c
  
  Index: apr_pools.c
  ===================================================================
  RCS file: /home/cvs/apache-apr/apr/lib/apr_pools.c,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- apr_pools.c	1999/07/02 19:09:16	1.8
  +++ apr_pools.c	1999/07/27 18:27:59	1.9
  @@ -1026,696 +1026,6 @@
   
   /*****************************************************************
    *
  - * The 'array' functions...
  - */
  -
  -static void make_array_core(ap_array_header_t *res, struct context_t *c,
  -			    int nelts, int elt_size)
  -{
  -    /*
  -     * Assure sanity if someone asks for
  -     * array of zero elts.
  -     */
  -    if (nelts < 1) {
  -	nelts = 1;
  -    }
  -
  -    res->elts = ap_pcalloc(c, nelts * elt_size);
  -
  -    res->cont = c;
  -    res->elt_size = elt_size;
  -    res->nelts = 0;		/* No active elements yet... */
  -    res->nalloc = nelts;	/* ...but this many allocated */
  -}
  -
  -API_EXPORT(ap_array_header_t *) ap_make_array(struct context_t *p,
  -						int nelts, int elt_size)
  -{
  -    ap_array_header_t *res;
  -
  -    res = (ap_array_header_t *) ap_palloc(p, sizeof(ap_array_header_t));
  -    make_array_core(res, p, nelts, elt_size);
  -    return res;
  -}
  -
  -API_EXPORT(void *) ap_push_array(ap_array_header_t *arr)
  -{
  -    if (arr->nelts == arr->nalloc) {
  -	int new_size = (arr->nalloc <= 0) ? 1 : arr->nalloc * 2;
  -	char *new_data;
  -
  -	new_data = ap_pcalloc(arr->cont, arr->elt_size * new_size);
  -
  -	memcpy(new_data, arr->elts, arr->nalloc * arr->elt_size);
  -	arr->elts = new_data;
  -	arr->nalloc = new_size;
  -    }
  -
  -    ++arr->nelts;
  -    return arr->elts + (arr->elt_size * (arr->nelts - 1));
  -}
  -
  -API_EXPORT(void) ap_array_cat(ap_array_header_t *dst,
  -			       const ap_array_header_t *src)
  -{
  -    int elt_size = dst->elt_size;
  -
  -    if (dst->nelts + src->nelts > dst->nalloc) {
  -	int new_size = (dst->nalloc <= 0) ? 1 : dst->nalloc * 2;
  -	char *new_data;
  -
  -	while (dst->nelts + src->nelts > new_size) {
  -	    new_size *= 2;
  -	}
  -
  -	new_data = ap_pcalloc(dst->cont, elt_size * new_size);
  -	memcpy(new_data, dst->elts, dst->nalloc * elt_size);
  -
  -	dst->elts = new_data;
  -	dst->nalloc = new_size;
  -    }
  -
  -    memcpy(dst->elts + dst->nelts * elt_size, src->elts,
  -	   elt_size * src->nelts);
  -    dst->nelts += src->nelts;
  -}
  -
  -API_EXPORT(ap_array_header_t *) ap_copy_array(struct context_t *p,
  -						const ap_array_header_t *arr)
  -{
  -    ap_array_header_t *res = ap_make_array(p, arr->nalloc, arr->elt_size);
  -
  -    memcpy(res->elts, arr->elts, arr->elt_size * arr->nelts);
  -    res->nelts = arr->nelts;
  -    return res;
  -}
  -
  -/* This cute function copies the array header *only*, but arranges
  - * for the data section to be copied on the first push or arraycat.
  - * It's useful when the elements of the array being copied are
  - * read only, but new stuff *might* get added on the end; we have the
  - * overhead of the full copy only where it is really needed.
  - */
  -
  -static APR_INLINE void copy_array_hdr_core(ap_array_header_t *res,
  -					   const ap_array_header_t *arr)
  -{
  -    res->elts = arr->elts;
  -    res->elt_size = arr->elt_size;
  -    res->nelts = arr->nelts;
  -    res->nalloc = arr->nelts;	/* Force overflow on push */
  -}
  -
  -API_EXPORT(ap_array_header_t *)
  -    ap_copy_array_hdr(struct context_t *p,
  -		       const ap_array_header_t *arr)
  -{
  -    ap_array_header_t *res;
  -
  -    res = (ap_array_header_t *) ap_palloc(p, sizeof(ap_array_header_t));
  -    res->cont = p;
  -    copy_array_hdr_core(res, arr);
  -    return res;
  -}
  -
  -/* The above is used here to avoid consing multiple new array bodies... */
  -
  -API_EXPORT(ap_array_header_t *)
  -    ap_append_arrays(struct context_t *p,
  -		      const ap_array_header_t *first,
  -		      const ap_array_header_t *second)
  -{
  -    ap_array_header_t *res = ap_copy_array_hdr(p, first);
  -
  -    ap_array_cat(res, second);
  -    return res;
  -}
  -
  -/* ap_array_pstrcat generates a new string from the pool containing
  - * the concatenated sequence of substrings referenced as elements within
  - * the array.  The string will be empty if all substrings are empty or null,
  - * or if there are no elements in the array.
  - * If sep is non-NUL, it will be inserted between elements as a separator.
  - */
  -API_EXPORT(char *) ap_array_pstrcat(struct context_t *p,
  -				     const ap_array_header_t *arr,
  -				     const char sep)
  -{
  -    char *cp, *res, **strpp;
  -    int i, len;
  -
  -    if (arr->nelts <= 0 || arr->elts == NULL) {    /* Empty table? */
  -        return (char *) ap_pcalloc(p, 1);
  -    }
  -
  -    /* Pass one --- find length of required string */
  -
  -    len = 0;
  -    for (i = 0, strpp = (char **) arr->elts; ; ++strpp) {
  -        if (strpp && *strpp != NULL) {
  -            len += strlen(*strpp);
  -        }
  -        if (++i >= arr->nelts) {
  -            break;
  -	}
  -        if (sep) {
  -            ++len;
  -	}
  -    }
  -
  -    /* Allocate the required string */
  -
  -    res = (char *) ap_palloc(p, len + 1);
  -    cp = res;
  -
  -    /* Pass two --- copy the argument strings into the result space */
  -
  -    for (i = 0, strpp = (char **) arr->elts; ; ++strpp) {
  -        if (strpp && *strpp != NULL) {
  -            len = strlen(*strpp);
  -            memcpy(cp, *strpp, len);
  -            cp += len;
  -        }
  -        if (++i >= arr->nelts) {
  -            break;
  -	}
  -        if (sep) {
  -            *cp++ = sep;
  -	}
  -    }
  -
  -    *cp = '\0';
  -
  -    /* Return the result string */
  -
  -    return res;
  -}
  -
  -
  -/*****************************************************************
  - *
  - * The "table" functions.
  - */
  -
  -/*
  - * XXX: if you tweak this you should look at is_empty_table() and table_elts()
  - * in alloc.h
  - */
  -#ifdef MAKE_TABLE_PROFILE
  -static ap_table_entry_t *table_push(ap_table_t *t)
  -{
  -    if (t->a.nelts == t->a.nalloc) {
  -	fprintf(stderr,
  -		"table_push: table created by %p hit limit of %u\n",
  -		t->creator, t->a.nalloc);
  -    }
  -    return (ap_table_entry_t *) ap_push_array(&t->a);
  -}
  -#else /* MAKE_TABLE_PROFILE */
  -#define table_push(t)	((ap_table_entry_t *) ap_push_array(&(t)->a))
  -#endif /* MAKE_TABLE_PROFILE */
  -
  -
  -API_EXPORT(ap_table_t *) ap_make_table(struct context_t *p, int nelts)
  -{
  -    ap_table_t *t = ap_palloc(p, sizeof(ap_table_t));
  -
  -    make_array_core(&t->a, p, nelts, sizeof(ap_table_entry_t));
  -#ifdef MAKE_TABLE_PROFILE
  -    t->creator = __builtin_return_address(0);
  -#endif
  -    return t;
  -}
  -
  -API_EXPORT(ap_table_t *) ap_copy_table(struct context_t *p, const ap_table_t *t)
  -{
  -    ap_table_t *new = ap_palloc(p, sizeof(ap_table_t));
  -
  -#ifdef POOL_DEBUG
  -    /* we don't copy keys and values, so it's necessary that t->a.pool
  -     * have a life span at least as long as p
  -     */
  -    if (!ap_pool_is_ancestor(t->a.pool, p)) {
  -	fprintf(stderr, "copy_table: t's pool is not an ancestor of p\n");
  -	abort();
  -    }
  -#endif
  -    make_array_core(&new->a, p, t->a.nalloc, sizeof(ap_table_entry_t));
  -    memcpy(new->a.elts, t->a.elts, t->a.nelts * sizeof(ap_table_entry_t));
  -    new->a.nelts = t->a.nelts;
  -    return new;
  -}
  -
  -API_EXPORT(void) ap_clear_table(ap_table_t *t)
  -{
  -    t->a.nelts = 0;
  -}
  -
  -API_EXPORT(const char *) ap_table_get(const ap_table_t *t, const char *key)
  -{
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int i;
  -
  -    if (key == NULL) {
  -	return NULL;
  -    }
  -
  -    for (i = 0; i < t->a.nelts; ++i) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -	    return elts[i].val;
  -	}
  -    }
  -
  -    return NULL;
  -}
  -
  -API_EXPORT(void) ap_table_set(ap_table_t *t, const char *key,
  -			       const char *val)
  -{
  -    register int i, j, k;
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int done = 0;
  -
  -    for (i = 0; i < t->a.nelts; ) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -	    if (!done) {
  -		elts[i].val = ap_pstrdup(t->a.cont, val);
  -		done = 1;
  -		++i;
  -	    }
  -	    else {		/* delete an extraneous element */
  -		for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  -		    elts[j].key = elts[k].key;
  -		    elts[j].val = elts[k].val;
  -		}
  -		--t->a.nelts;
  -	    }
  -	}
  -	else {
  -	    ++i;
  -	}
  -    }
  -
  -    if (!done) {
  -	elts = (ap_table_entry_t *) table_push(t);
  -	elts->key = ap_pstrdup(t->a.cont, key);
  -	elts->val = ap_pstrdup(t->a.cont, val);
  -    }
  -}
  -
  -API_EXPORT(void) ap_table_setn(ap_table_t *t, const char *key,
  -				const char *val)
  -{
  -    register int i, j, k;
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int done = 0;
  -
  -#ifdef POOL_DEBUG
  -    {
  -	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  -	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  -	    abort();
  -	}
  -	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  -	    fprintf(stderr, "table_set: val not in ancestor pool of t\n");
  -	    abort();
  -	}
  -    }
  -#endif
  -
  -    for (i = 0; i < t->a.nelts; ) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -	    if (!done) {
  -		elts[i].val = (char *)val;
  -		done = 1;
  -		++i;
  -	    }
  -	    else {		/* delete an extraneous element */
  -		for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  -		    elts[j].key = elts[k].key;
  -		    elts[j].val = elts[k].val;
  -		}
  -		--t->a.nelts;
  -	    }
  -	}
  -	else {
  -	    ++i;
  -	}
  -    }
  -
  -    if (!done) {
  -	elts = (ap_table_entry_t *) table_push(t);
  -	elts->key = (char *)key;
  -	elts->val = (char *)val;
  -    }
  -}
  -
  -API_EXPORT(void) ap_table_unset(ap_table_t *t, const char *key)
  -{
  -    register int i, j, k;
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -
  -    for (i = 0; i < t->a.nelts; ) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -
  -	    /* found an element to skip over
  -	     * there are any number of ways to remove an element from
  -	     * a contiguous block of memory.  I've chosen one that
  -	     * doesn't do a memcpy/bcopy/array_delete, *shrug*...
  -	     */
  -	    for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  -		elts[j].key = elts[k].key;
  -		elts[j].val = elts[k].val;
  -	    }
  -	    --t->a.nelts;
  -	}
  -	else {
  -	    ++i;
  -	}
  -    }
  -}
  -
  -API_EXPORT(void) ap_table_merge(ap_table_t *t, const char *key,
  -				 const char *val)
  -{
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int i;
  -
  -    for (i = 0; i < t->a.nelts; ++i) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -	    elts[i].val = ap_pstrcat(t->a.cont, elts[i].val, ", ", val, NULL);
  -	    return;
  -	}
  -    }
  -
  -    elts = (ap_table_entry_t *) table_push(t);
  -    elts->key = ap_pstrdup(t->a.cont, key);
  -    elts->val = ap_pstrdup(t->a.cont, val);
  -}
  -
  -API_EXPORT(void) ap_table_mergen(ap_table_t *t, const char *key,
  -				  const char *val)
  -{
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int i;
  -
  -#ifdef POOL_DEBUG
  -    {
  -	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  -	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  -	    abort();
  -	}
  -	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  -	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  -	    abort();
  -	}
  -    }
  -#endif
  -
  -    for (i = 0; i < t->a.nelts; ++i) {
  -	if (!strcasecmp(elts[i].key, key)) {
  -	    elts[i].val = ap_pstrcat(t->a.cont, elts[i].val, ", ", val, NULL);
  -	    return;
  -	}
  -    }
  -
  -    elts = (ap_table_entry_t *) table_push(t);
  -    elts->key = (char *)key;
  -    elts->val = (char *)val;
  -}
  -
  -API_EXPORT(void) ap_table_add(ap_table_t *t, const char *key,
  -			       const char *val)
  -{
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -
  -    elts = (ap_table_entry_t *) table_push(t);
  -    elts->key = ap_pstrdup(t->a.cont, key);
  -    elts->val = ap_pstrdup(t->a.cont, val);
  -}
  -
  -API_EXPORT(void) ap_table_addn(ap_table_t *t, const char *key,
  -				const char *val)
  -{
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -
  -#ifdef POOL_DEBUG
  -    {
  -	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  -	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  -	    abort();
  -	}
  -	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  -	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  -	    abort();
  -	}
  -    }
  -#endif
  -
  -    elts = (ap_table_entry_t *) table_push(t);
  -    elts->key = (char *)key;
  -    elts->val = (char *)val;
  -}
  -
  -API_EXPORT(ap_table_t *) ap_overlay_tables(struct context_t *p,
  -					     const ap_table_t *overlay,
  -					     const ap_table_t *base)
  -{
  -    ap_table_t *res;
  -
  -#ifdef POOL_DEBUG
  -    /* we don't copy keys and values, so it's necessary that
  -     * overlay->a.pool and base->a.pool have a life span at least
  -     * as long as p
  -     */
  -    if (!ap_pool_is_ancestor(overlay->a.pool, p->pool)) {
  -	fprintf(stderr,
  -		"overlay_tables: overlay's pool is not an ancestor of p\n");
  -	abort();
  -    }
  -    if (!ap_pool_is_ancestor(base->a.pool, p->pool)) {
  -	fprintf(stderr,
  -		"overlay_tables: base's pool is not an ancestor of p\n");
  -	abort();
  -    }
  -#endif
  -
  -    res = ap_palloc(p, sizeof(ap_table_t));
  -    /* behave like append_arrays */
  -    res->a.cont = p;
  -    copy_array_hdr_core(&res->a, &overlay->a);
  -    ap_array_cat(&res->a, &base->a);
  -
  -    return res;
  -}
  -
  -/* And now for something completely abstract ...
  -
  - * For each key value given as a vararg:
  - *   run the function pointed to as
  - *     int comp(void *r, char *key, char *value);
  - *   on each valid key-value pair in the table t that matches the vararg key,
  - *   or once for every valid key-value pair if the vararg list is empty,
  - *   until the function returns false (0) or we finish the table.
  - *
  - * Note that we restart the traversal for each vararg, which means that
  - * duplicate varargs will result in multiple executions of the function
  - * for each matching key.  Note also that if the vararg list is empty,
  - * only one traversal will be made and will cut short if comp returns 0.
  - *
  - * Note that the table_get and table_merge functions assume that each key in
  - * the table is unique (i.e., no multiple entries with the same key).  This
  - * function does not make that assumption, since it (unfortunately) isn't
  - * true for some of Apache's tables.
  - *
  - * Note that rec is simply passed-on to the comp function, so that the
  - * caller can pass additional info for the task.
  - */
  -API_EXPORT(void) ap_table_do(int (*comp) (void *, const char *, const char *),
  -			      void *rec, const ap_table_t *t, ...)
  -{
  -    va_list vp;
  -    char *argp;
  -    ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  -    int rv, i;
  -
  -    va_start(vp, t);
  -
  -    argp = va_arg(vp, char *);
  -
  -    do {
  -	for (rv = 1, i = 0; rv && (i < t->a.nelts); ++i) {
  -	    if (elts[i].key && (!argp || !strcasecmp(elts[i].key, argp))) {
  -		rv = (*comp) (rec, elts[i].key, elts[i].val);
  -	    }
  -	}
  -    } while (argp && ((argp = va_arg(vp, char *)) != NULL));
  -
  -    va_end(vp);
  -}
  -
  -/* Curse libc and the fact that it doesn't guarantee a stable sort.  We
  - * have to enforce stability ourselves by using the order field.  If it
  - * provided a stable sort then we wouldn't even need temporary storage to
  - * do the work below. -djg
  - *
  - * ("stable sort" means that equal keys retain their original relative
  - * ordering in the output.)
  - */
  -typedef struct {
  -    char *key;
  -    char *val;
  -    int order;
  -} overlap_key;
  -
  -static int sort_overlap(const void *va, const void *vb)
  -{
  -    const overlap_key *a = va;
  -    const overlap_key *b = vb;
  -    int r;
  -
  -    r = strcasecmp(a->key, b->key);
  -    if (r) {
  -	return r;
  -    }
  -    return a->order - b->order;
  -}
  -
  -/* prefer to use the stack for temp storage for overlaps smaller than this */
  -#ifndef ap_OVERLAP_TABLES_ON_STACK
  -#define ap_OVERLAP_TABLES_ON_STACK	(512)
  -#endif
  -
  -API_EXPORT(void) ap_overlap_tables(ap_table_t *a, const ap_table_t *b,
  -				    unsigned flags)
  -{
  -    overlap_key cat_keys_buf[ap_OVERLAP_TABLES_ON_STACK];
  -    overlap_key *cat_keys;
  -    int nkeys;
  -    ap_table_entry_t *e;
  -    ap_table_entry_t *last_e;
  -    overlap_key *left;
  -    overlap_key *right;
  -    overlap_key *last;
  -
  -    nkeys = a->a.nelts + b->a.nelts;
  -    if (nkeys < ap_OVERLAP_TABLES_ON_STACK) {
  -	cat_keys = cat_keys_buf;
  -    }
  -    else {
  -	/* XXX: could use scratch free space in a or b's pool instead...
  -	 * which could save an allocation in b's pool.
  -	 */
  -	cat_keys = ap_palloc(b->a.cont, sizeof(overlap_key) * nkeys);
  -    }
  -
  -    nkeys = 0;
  -
  -    /* Create a list of the entries from a concatenated with the entries
  -     * from b.
  -     */
  -    e = (ap_table_entry_t *)a->a.elts;
  -    last_e = e + a->a.nelts;
  -    while (e < last_e) {
  -	cat_keys[nkeys].key = e->key;
  -	cat_keys[nkeys].val = e->val;
  -	cat_keys[nkeys].order = nkeys;
  -	++nkeys;
  -	++e;
  -    }
  -
  -    e = (ap_table_entry_t *)b->a.elts;
  -    last_e = e + b->a.nelts;
  -    while (e < last_e) {
  -	cat_keys[nkeys].key = e->key;
  -	cat_keys[nkeys].val = e->val;
  -	cat_keys[nkeys].order = nkeys;
  -	++nkeys;
  -	++e;
  -    }
  -
  -    qsort(cat_keys, nkeys, sizeof(overlap_key), sort_overlap);
  -
  -    /* Now iterate over the sorted list and rebuild a.
  -     * Start by making sure it has enough space.
  -     */
  -    a->a.nelts = 0;
  -    if (a->a.nalloc < nkeys) {
  -	a->a.elts = ap_palloc(a->a.cont, a->a.elt_size * nkeys * 2);
  -	a->a.nalloc = nkeys * 2;
  -    }
  -
  -    /*
  -     * In both the merge and set cases we retain the invariant:
  -     *
  -     * left->key, (left+1)->key, (left+2)->key, ..., (right-1)->key
  -     * are all equal keys.  (i.e. strcasecmp returns 0)
  -     *
  -     * We essentially need to find the maximal
  -     * right for each key, then we can do a quick merge or set as
  -     * appropriate.
  -     */
  -
  -    if (flags & ap_OVERLAP_TABLES_MERGE) {
  -	left = cat_keys;
  -	last = left + nkeys;
  -	while (left < last) {
  -	    right = left + 1;
  -	    if (right == last
  -		|| strcasecmp(left->key, right->key)) {
  -		ap_table_addn(a, left->key, left->val);
  -		left = right;
  -	    }
  -	    else {
  -		char *strp;
  -		char *value;
  -		size_t len;
  -
  -		/* Have to merge some headers.  Let's re-use the order field,
  -		 * since it's handy... we'll store the length of val there.
  -		 */
  -		left->order = strlen(left->val);
  -		len = left->order;
  -		do {
  -		    right->order = strlen(right->val);
  -		    len += 2 + right->order;
  -		    ++right;
  -		} while (right < last
  -			 && !strcasecmp(left->key, right->key));
  -		/* right points one past the last header to merge */
  -		value = ap_palloc(a->a.cont, len + 1);
  -		strp = value;
  -		for (;;) {
  -		    memcpy(strp, left->val, left->order);
  -		    strp += left->order;
  -		    ++left;
  -		    if (left == right) {
  -			break;
  -		    }
  -		    *strp++ = ',';
  -		    *strp++ = ' ';
  -		}
  -		*strp = 0;
  -		ap_table_addn(a, (left-1)->key, value);
  -	    }
  -	}
  -    }
  -    else {
  -	left = cat_keys;
  -	last = left + nkeys;
  -	while (left < last) {
  -	    right = left + 1;
  -	    while (right < last && !strcasecmp(left->key, right->key)) {
  -		++right;
  -	    }
  -	    ap_table_addn(a, (right-1)->key, (right-1)->val);
  -	    left = right;
  -	}
  -    }
  -}
  -
  -/*****************************************************************
  - *
    * Managing generic cleanups.  
    */
   
  
  
  
  1.1                  apache-apr/apr/lib/apr_tables.c
  
  Index: apr_tables.c
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer. 
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. All advertising materials mentioning features or use of this
   *    software must display the following acknowledgment:
   *    "This product includes software developed by the Apache Group
   *    for use in the Apache HTTP server project (http://www.apache.org/)."
   *
   * 4. The names "Apache Server" and "Apache Group" must not be used to
   *    endorse or promote products derived from this software without
   *    prior written permission. For written permission, please contact
   *    apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Group.
   *
   * 6. Redistributions of any form whatsoever must retain the following
   *    acknowledgment:
   *    "This product includes software developed by the Apache Group
   *    for use in the Apache HTTP server project (http://www.apache.org/)."
   *
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Group and was originally based
   * on public domain software written at the National Center for
   * Supercomputing Applications, University of Illinois, Urbana-Champaign.
   * For more information on the Apache Group and the Apache HTTP server
   * project, please see <http://www.apache.org/>.
   *
   */
  
  /*
   * Resource allocation code... the code here is responsible for making
   * sure that nothing leaks.
   *
   * rst --- 4/95 --- 6/95
   */
  
  #ifndef WIN32
  #include "apr_config.h"
  #else
  #include "apr_win.h"
  #endif
  
  #include "apr_general.h"
  #include "apr_pools.h"
  #include "apr_lib.h"
  #include "misc.h"
  #include <stdlib.h>
  #include <malloc.h>
  
  /*****************************************************************
   * This file contains array and table functions only.
   */
  
  /*****************************************************************
   *
   * The 'array' functions...
   */
  
  static void make_array_core(ap_array_header_t *res, struct context_t *c,
  			    int nelts, int elt_size)
  {
      /*
       * Assure sanity if someone asks for
       * array of zero elts.
       */
      if (nelts < 1) {
  	nelts = 1;
      }
  
      res->elts = ap_pcalloc(c, nelts * elt_size);
  
      res->cont = c;
      res->elt_size = elt_size;
      res->nelts = 0;		/* No active elements yet... */
      res->nalloc = nelts;	/* ...but this many allocated */
  }
  
  API_EXPORT(ap_array_header_t *) ap_make_array(struct context_t *p,
  						int nelts, int elt_size)
  {
      ap_array_header_t *res;
  
      res = (ap_array_header_t *) ap_palloc(p, sizeof(ap_array_header_t));
      make_array_core(res, p, nelts, elt_size);
      return res;
  }
  
  API_EXPORT(void *) ap_push_array(ap_array_header_t *arr)
  {
      if (arr->nelts == arr->nalloc) {
  	int new_size = (arr->nalloc <= 0) ? 1 : arr->nalloc * 2;
  	char *new_data;
  
  	new_data = ap_pcalloc(arr->cont, arr->elt_size * new_size);
  
  	memcpy(new_data, arr->elts, arr->nalloc * arr->elt_size);
  	arr->elts = new_data;
  	arr->nalloc = new_size;
      }
  
      ++arr->nelts;
      return arr->elts + (arr->elt_size * (arr->nelts - 1));
  }
  
  API_EXPORT(void) ap_array_cat(ap_array_header_t *dst,
  			       const ap_array_header_t *src)
  {
      int elt_size = dst->elt_size;
  
      if (dst->nelts + src->nelts > dst->nalloc) {
  	int new_size = (dst->nalloc <= 0) ? 1 : dst->nalloc * 2;
  	char *new_data;
  
  	while (dst->nelts + src->nelts > new_size) {
  	    new_size *= 2;
  	}
  
  	new_data = ap_pcalloc(dst->cont, elt_size * new_size);
  	memcpy(new_data, dst->elts, dst->nalloc * elt_size);
  
  	dst->elts = new_data;
  	dst->nalloc = new_size;
      }
  
      memcpy(dst->elts + dst->nelts * elt_size, src->elts,
  	   elt_size * src->nelts);
      dst->nelts += src->nelts;
  }
  
  API_EXPORT(ap_array_header_t *) ap_copy_array(struct context_t *p,
  						const ap_array_header_t *arr)
  {
      ap_array_header_t *res = ap_make_array(p, arr->nalloc, arr->elt_size);
  
      memcpy(res->elts, arr->elts, arr->elt_size * arr->nelts);
      res->nelts = arr->nelts;
      return res;
  }
  
  /* This cute function copies the array header *only*, but arranges
   * for the data section to be copied on the first push or arraycat.
   * It's useful when the elements of the array being copied are
   * read only, but new stuff *might* get added on the end; we have the
   * overhead of the full copy only where it is really needed.
   */
  
  static APR_INLINE void copy_array_hdr_core(ap_array_header_t *res,
  					   const ap_array_header_t *arr)
  {
      res->elts = arr->elts;
      res->elt_size = arr->elt_size;
      res->nelts = arr->nelts;
      res->nalloc = arr->nelts;	/* Force overflow on push */
  }
  
  API_EXPORT(ap_array_header_t *)
      ap_copy_array_hdr(struct context_t *p,
  		       const ap_array_header_t *arr)
  {
      ap_array_header_t *res;
  
      res = (ap_array_header_t *) ap_palloc(p, sizeof(ap_array_header_t));
      res->cont = p;
      copy_array_hdr_core(res, arr);
      return res;
  }
  
  /* The above is used here to avoid consing multiple new array bodies... */
  
  API_EXPORT(ap_array_header_t *)
      ap_append_arrays(struct context_t *p,
  		      const ap_array_header_t *first,
  		      const ap_array_header_t *second)
  {
      ap_array_header_t *res = ap_copy_array_hdr(p, first);
  
      ap_array_cat(res, second);
      return res;
  }
  
  /* ap_array_pstrcat generates a new string from the pool containing
   * the concatenated sequence of substrings referenced as elements within
   * the array.  The string will be empty if all substrings are empty or null,
   * or if there are no elements in the array.
   * If sep is non-NUL, it will be inserted between elements as a separator.
   */
  API_EXPORT(char *) ap_array_pstrcat(struct context_t *p,
  				     const ap_array_header_t *arr,
  				     const char sep)
  {
      char *cp, *res, **strpp;
      int i, len;
  
      if (arr->nelts <= 0 || arr->elts == NULL) {    /* Empty table? */
          return (char *) ap_pcalloc(p, 1);
      }
  
      /* Pass one --- find length of required string */
  
      len = 0;
      for (i = 0, strpp = (char **) arr->elts; ; ++strpp) {
          if (strpp && *strpp != NULL) {
              len += strlen(*strpp);
          }
          if (++i >= arr->nelts) {
              break;
  	}
          if (sep) {
              ++len;
  	}
      }
  
      /* Allocate the required string */
  
      res = (char *) ap_palloc(p, len + 1);
      cp = res;
  
      /* Pass two --- copy the argument strings into the result space */
  
      for (i = 0, strpp = (char **) arr->elts; ; ++strpp) {
          if (strpp && *strpp != NULL) {
              len = strlen(*strpp);
              memcpy(cp, *strpp, len);
              cp += len;
          }
          if (++i >= arr->nelts) {
              break;
  	}
          if (sep) {
              *cp++ = sep;
  	}
      }
  
      *cp = '\0';
  
      /* Return the result string */
  
      return res;
  }
  
  
  /*****************************************************************
   *
   * The "table" functions.
   */
  
  /*
   * XXX: if you tweak this you should look at is_empty_table() and table_elts()
   * in alloc.h
   */
  #ifdef MAKE_TABLE_PROFILE
  static ap_table_entry_t *table_push(ap_table_t *t)
  {
      if (t->a.nelts == t->a.nalloc) {
  	fprintf(stderr,
  		"table_push: table created by %p hit limit of %u\n",
  		t->creator, t->a.nalloc);
      }
      return (ap_table_entry_t *) ap_push_array(&t->a);
  }
  #else /* MAKE_TABLE_PROFILE */
  #define table_push(t)	((ap_table_entry_t *) ap_push_array(&(t)->a))
  #endif /* MAKE_TABLE_PROFILE */
  
  
  API_EXPORT(ap_table_t *) ap_make_table(struct context_t *p, int nelts)
  {
      ap_table_t *t = ap_palloc(p, sizeof(ap_table_t));
  
      make_array_core(&t->a, p, nelts, sizeof(ap_table_entry_t));
  #ifdef MAKE_TABLE_PROFILE
      t->creator = __builtin_return_address(0);
  #endif
      return t;
  }
  
  API_EXPORT(ap_table_t *) ap_copy_table(struct context_t *p, const ap_table_t *t)
  {
      ap_table_t *new = ap_palloc(p, sizeof(ap_table_t));
  
  #ifdef POOL_DEBUG
      /* we don't copy keys and values, so it's necessary that t->a.pool
       * have a life span at least as long as p
       */
      if (!ap_pool_is_ancestor(t->a.pool, p)) {
  	fprintf(stderr, "copy_table: t's pool is not an ancestor of p\n");
  	abort();
      }
  #endif
      make_array_core(&new->a, p, t->a.nalloc, sizeof(ap_table_entry_t));
      memcpy(new->a.elts, t->a.elts, t->a.nelts * sizeof(ap_table_entry_t));
      new->a.nelts = t->a.nelts;
      return new;
  }
  
  API_EXPORT(void) ap_clear_table(ap_table_t *t)
  {
      t->a.nelts = 0;
  }
  
  API_EXPORT(const char *) ap_table_get(const ap_table_t *t, const char *key)
  {
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int i;
  
      if (key == NULL) {
  	return NULL;
      }
  
      for (i = 0; i < t->a.nelts; ++i) {
  	if (!strcasecmp(elts[i].key, key)) {
  	    return elts[i].val;
  	}
      }
  
      return NULL;
  }
  
  API_EXPORT(void) ap_table_set(ap_table_t *t, const char *key,
  			       const char *val)
  {
      register int i, j, k;
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int done = 0;
  
      for (i = 0; i < t->a.nelts; ) {
  	if (!strcasecmp(elts[i].key, key)) {
  	    if (!done) {
  		elts[i].val = ap_pstrdup(t->a.cont, val);
  		done = 1;
  		++i;
  	    }
  	    else {		/* delete an extraneous element */
  		for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  		    elts[j].key = elts[k].key;
  		    elts[j].val = elts[k].val;
  		}
  		--t->a.nelts;
  	    }
  	}
  	else {
  	    ++i;
  	}
      }
  
      if (!done) {
  	elts = (ap_table_entry_t *) table_push(t);
  	elts->key = ap_pstrdup(t->a.cont, key);
  	elts->val = ap_pstrdup(t->a.cont, val);
      }
  }
  
  API_EXPORT(void) ap_table_setn(ap_table_t *t, const char *key,
  				const char *val)
  {
      register int i, j, k;
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int done = 0;
  
  #ifdef POOL_DEBUG
      {
  	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  	    abort();
  	}
  	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  	    fprintf(stderr, "table_set: val not in ancestor pool of t\n");
  	    abort();
  	}
      }
  #endif
  
      for (i = 0; i < t->a.nelts; ) {
  	if (!strcasecmp(elts[i].key, key)) {
  	    if (!done) {
  		elts[i].val = (char *)val;
  		done = 1;
  		++i;
  	    }
  	    else {		/* delete an extraneous element */
  		for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  		    elts[j].key = elts[k].key;
  		    elts[j].val = elts[k].val;
  		}
  		--t->a.nelts;
  	    }
  	}
  	else {
  	    ++i;
  	}
      }
  
      if (!done) {
  	elts = (ap_table_entry_t *) table_push(t);
  	elts->key = (char *)key;
  	elts->val = (char *)val;
      }
  }
  
  API_EXPORT(void) ap_table_unset(ap_table_t *t, const char *key)
  {
      register int i, j, k;
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  
      for (i = 0; i < t->a.nelts; ) {
  	if (!strcasecmp(elts[i].key, key)) {
  
  	    /* found an element to skip over
  	     * there are any number of ways to remove an element from
  	     * a contiguous block of memory.  I've chosen one that
  	     * doesn't do a memcpy/bcopy/array_delete, *shrug*...
  	     */
  	    for (j = i, k = i + 1; k < t->a.nelts; ++j, ++k) {
  		elts[j].key = elts[k].key;
  		elts[j].val = elts[k].val;
  	    }
  	    --t->a.nelts;
  	}
  	else {
  	    ++i;
  	}
      }
  }
  
  API_EXPORT(void) ap_table_merge(ap_table_t *t, const char *key,
  				 const char *val)
  {
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int i;
  
      for (i = 0; i < t->a.nelts; ++i) {
  	if (!strcasecmp(elts[i].key, key)) {
  	    elts[i].val = ap_pstrcat(t->a.cont, elts[i].val, ", ", val, NULL);
  	    return;
  	}
      }
  
      elts = (ap_table_entry_t *) table_push(t);
      elts->key = ap_pstrdup(t->a.cont, key);
      elts->val = ap_pstrdup(t->a.cont, val);
  }
  
  API_EXPORT(void) ap_table_mergen(ap_table_t *t, const char *key,
  				  const char *val)
  {
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int i;
  
  #ifdef POOL_DEBUG
      {
  	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  	    abort();
  	}
  	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  	    abort();
  	}
      }
  #endif
  
      for (i = 0; i < t->a.nelts; ++i) {
  	if (!strcasecmp(elts[i].key, key)) {
  	    elts[i].val = ap_pstrcat(t->a.cont, elts[i].val, ", ", val, NULL);
  	    return;
  	}
      }
  
      elts = (ap_table_entry_t *) table_push(t);
      elts->key = (char *)key;
      elts->val = (char *)val;
  }
  
  API_EXPORT(void) ap_table_add(ap_table_t *t, const char *key,
  			       const char *val)
  {
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  
      elts = (ap_table_entry_t *) table_push(t);
      elts->key = ap_pstrdup(t->a.cont, key);
      elts->val = ap_pstrdup(t->a.cont, val);
  }
  
  API_EXPORT(void) ap_table_addn(ap_table_t *t, const char *key,
  				const char *val)
  {
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
  
  #ifdef POOL_DEBUG
      {
  	if (!ap_pool_is_ancestor(ap_find_pool(key), t->a.pool)) {
  	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  	    abort();
  	}
  	if (!ap_pool_is_ancestor(ap_find_pool(val), t->a.pool)) {
  	    fprintf(stderr, "table_set: key not in ancestor pool of t\n");
  	    abort();
  	}
      }
  #endif
  
      elts = (ap_table_entry_t *) table_push(t);
      elts->key = (char *)key;
      elts->val = (char *)val;
  }
  
  API_EXPORT(ap_table_t *) ap_overlay_tables(struct context_t *p,
  					     const ap_table_t *overlay,
  					     const ap_table_t *base)
  {
      ap_table_t *res;
  
  #ifdef POOL_DEBUG
      /* we don't copy keys and values, so it's necessary that
       * overlay->a.pool and base->a.pool have a life span at least
       * as long as p
       */
      if (!ap_pool_is_ancestor(overlay->a.pool, p->pool)) {
  	fprintf(stderr,
  		"overlay_tables: overlay's pool is not an ancestor of p\n");
  	abort();
      }
      if (!ap_pool_is_ancestor(base->a.pool, p->pool)) {
  	fprintf(stderr,
  		"overlay_tables: base's pool is not an ancestor of p\n");
  	abort();
      }
  #endif
  
      res = ap_palloc(p, sizeof(ap_table_t));
      /* behave like append_arrays */
      res->a.cont = p;
      copy_array_hdr_core(&res->a, &overlay->a);
      ap_array_cat(&res->a, &base->a);
  
      return res;
  }
  
  /* And now for something completely abstract ...
  
   * For each key value given as a vararg:
   *   run the function pointed to as
   *     int comp(void *r, char *key, char *value);
   *   on each valid key-value pair in the table t that matches the vararg key,
   *   or once for every valid key-value pair if the vararg list is empty,
   *   until the function returns false (0) or we finish the table.
   *
   * Note that we restart the traversal for each vararg, which means that
   * duplicate varargs will result in multiple executions of the function
   * for each matching key.  Note also that if the vararg list is empty,
   * only one traversal will be made and will cut short if comp returns 0.
   *
   * Note that the table_get and table_merge functions assume that each key in
   * the table is unique (i.e., no multiple entries with the same key).  This
   * function does not make that assumption, since it (unfortunately) isn't
   * true for some of Apache's tables.
   *
   * Note that rec is simply passed-on to the comp function, so that the
   * caller can pass additional info for the task.
   */
  API_EXPORT(void) ap_table_do(int (*comp) (void *, const char *, const char *),
  			      void *rec, const ap_table_t *t, ...)
  {
      va_list vp;
      char *argp;
      ap_table_entry_t *elts = (ap_table_entry_t *) t->a.elts;
      int rv, i;
  
      va_start(vp, t);
  
      argp = va_arg(vp, char *);
  
      do {
  	for (rv = 1, i = 0; rv && (i < t->a.nelts); ++i) {
  	    if (elts[i].key && (!argp || !strcasecmp(elts[i].key, argp))) {
  		rv = (*comp) (rec, elts[i].key, elts[i].val);
  	    }
  	}
      } while (argp && ((argp = va_arg(vp, char *)) != NULL));
  
      va_end(vp);
  }
  
  /* Curse libc and the fact that it doesn't guarantee a stable sort.  We
   * have to enforce stability ourselves by using the order field.  If it
   * provided a stable sort then we wouldn't even need temporary storage to
   * do the work below. -djg
   *
   * ("stable sort" means that equal keys retain their original relative
   * ordering in the output.)
   */
  typedef struct {
      char *key;
      char *val;
      int order;
  } overlap_key;
  
  static int sort_overlap(const void *va, const void *vb)
  {
      const overlap_key *a = va;
      const overlap_key *b = vb;
      int r;
  
      r = strcasecmp(a->key, b->key);
      if (r) {
  	return r;
      }
      return a->order - b->order;
  }
  
  /* prefer to use the stack for temp storage for overlaps smaller than this */
  #ifndef ap_OVERLAP_TABLES_ON_STACK
  #define ap_OVERLAP_TABLES_ON_STACK	(512)
  #endif
  
  API_EXPORT(void) ap_overlap_tables(ap_table_t *a, const ap_table_t *b,
  				    unsigned flags)
  {
      overlap_key cat_keys_buf[ap_OVERLAP_TABLES_ON_STACK];
      overlap_key *cat_keys;
      int nkeys;
      ap_table_entry_t *e;
      ap_table_entry_t *last_e;
      overlap_key *left;
      overlap_key *right;
      overlap_key *last;
  
      nkeys = a->a.nelts + b->a.nelts;
      if (nkeys < ap_OVERLAP_TABLES_ON_STACK) {
  	cat_keys = cat_keys_buf;
      }
      else {
  	/* XXX: could use scratch free space in a or b's pool instead...
  	 * which could save an allocation in b's pool.
  	 */
  	cat_keys = ap_palloc(b->a.cont, sizeof(overlap_key) * nkeys);
      }
  
      nkeys = 0;
  
      /* Create a list of the entries from a concatenated with the entries
       * from b.
       */
      e = (ap_table_entry_t *)a->a.elts;
      last_e = e + a->a.nelts;
      while (e < last_e) {
  	cat_keys[nkeys].key = e->key;
  	cat_keys[nkeys].val = e->val;
  	cat_keys[nkeys].order = nkeys;
  	++nkeys;
  	++e;
      }
  
      e = (ap_table_entry_t *)b->a.elts;
      last_e = e + b->a.nelts;
      while (e < last_e) {
  	cat_keys[nkeys].key = e->key;
  	cat_keys[nkeys].val = e->val;
  	cat_keys[nkeys].order = nkeys;
  	++nkeys;
  	++e;
      }
  
      qsort(cat_keys, nkeys, sizeof(overlap_key), sort_overlap);
  
      /* Now iterate over the sorted list and rebuild a.
       * Start by making sure it has enough space.
       */
      a->a.nelts = 0;
      if (a->a.nalloc < nkeys) {
  	a->a.elts = ap_palloc(a->a.cont, a->a.elt_size * nkeys * 2);
  	a->a.nalloc = nkeys * 2;
      }
  
      /*
       * In both the merge and set cases we retain the invariant:
       *
       * left->key, (left+1)->key, (left+2)->key, ..., (right-1)->key
       * are all equal keys.  (i.e. strcasecmp returns 0)
       *
       * We essentially need to find the maximal
       * right for each key, then we can do a quick merge or set as
       * appropriate.
       */
  
      if (flags & ap_OVERLAP_TABLES_MERGE) {
  	left = cat_keys;
  	last = left + nkeys;
  	while (left < last) {
  	    right = left + 1;
  	    if (right == last
  		|| strcasecmp(left->key, right->key)) {
  		ap_table_addn(a, left->key, left->val);
  		left = right;
  	    }
  	    else {
  		char *strp;
  		char *value;
  		size_t len;
  
  		/* Have to merge some headers.  Let's re-use the order field,
  		 * since it's handy... we'll store the length of val there.
  		 */
  		left->order = strlen(left->val);
  		len = left->order;
  		do {
  		    right->order = strlen(right->val);
  		    len += 2 + right->order;
  		    ++right;
  		} while (right < last
  			 && !strcasecmp(left->key, right->key));
  		/* right points one past the last header to merge */
  		value = ap_palloc(a->a.cont, len + 1);
  		strp = value;
  		for (;;) {
  		    memcpy(strp, left->val, left->order);
  		    strp += left->order;
  		    ++left;
  		    if (left == right) {
  			break;
  		    }
  		    *strp++ = ',';
  		    *strp++ = ' ';
  		}
  		*strp = 0;
  		ap_table_addn(a, (left-1)->key, value);
  	    }
  	}
      }
      else {
  	left = cat_keys;
  	last = left + nkeys;
  	while (left < last) {
  	    right = left + 1;
  	    while (right < last && !strcasecmp(left->key, right->key)) {
  		++right;
  	    }
  	    ap_table_addn(a, (right-1)->key, (right-1)->val);
  	    left = right;
  	}
      }
  }
  
  
  
  

Mime
View raw message