From b2aa573b1c1fdc9f019d55ce5350a5b1dad59383 Mon Sep 17 00:00:00 2001 From: Wayne Davison Date: Wed, 14 Apr 2004 23:33:40 +0000 Subject: [PATCH] Our exclude lists are now comprised of a base structure with a head and a tail pointer pointing to a linked list of items (rather than an array of pointers that has to be reallocated all the time). --- exclude.c | 132 ++++++++++++++++++++---------------------------------- 1 file changed, 48 insertions(+), 84 deletions(-) diff --git a/exclude.c b/exclude.c index 274ab904..3e6c4df9 100644 --- a/exclude.c +++ b/exclude.c @@ -28,14 +28,14 @@ extern int verbose; -struct exclude_struct **exclude_list; -struct exclude_struct **local_exclude_list; -struct exclude_struct **server_exclude_list; +struct exclude_list_struct exclude_list; +struct exclude_list_struct local_exclude_list; +struct exclude_list_struct server_exclude_list; char *exclude_path_prefix = NULL; /** Build an exclude structure given a exclude pattern */ -static struct exclude_struct *make_exclude(const char *pattern, int pat_len, - int include) +static void make_exclude(struct exclude_list_struct *listp, const char *pattern, + int pat_len, int include) { struct exclude_struct *ret; const char *cp; @@ -80,32 +80,33 @@ static struct exclude_struct *make_exclude(const char *pattern, int pat_len, for (cp = ret->pattern; (cp = strchr(cp, '/')) != NULL; cp++) ret->slash_cnt++; - return ret; + if (!listp->tail) + listp->head = listp->tail = ret; + else { + listp->tail->next = ret; + listp->tail = ret; + } } static void free_exclude(struct exclude_struct *ex) { free(ex->pattern); - memset(ex, 0, sizeof ex[0]); free(ex); } - -void free_exclude_list(struct exclude_struct ***listp) +void free_exclude_list(struct exclude_list_struct *listp) { - struct exclude_struct **list = *listp; + struct exclude_struct *ent, *next; if (verbose > 2) rprintf(FINFO, "[%s] clearing exclude list\n", who_am_i()); - if (!list) - return; - - while (*list) - free_exclude(*list++); + for (ent = listp->head; ent; ent = next) { + next = ent->next; + free_exclude(ent); + } - free(*listp); - *listp = NULL; + memset(listp, 0, sizeof listp[0]); } static int check_one_exclude(char *name, struct exclude_struct *ex, @@ -207,15 +208,15 @@ static void report_exclude_result(char const *name, /* - * Return true if file NAME is defined to be excluded by either - * LOCAL_EXCLUDE_LIST or the globals EXCLUDE_LIST. + * Return true if file NAME is defined to be excluded by the specified + * exclude list. */ -int check_exclude(struct exclude_struct **list, char *name, int name_is_dir, +int check_exclude(struct exclude_list_struct *listp, char *name, int name_is_dir, const char *type) { struct exclude_struct *ent; - while ((ent = *list++) != NULL) { + for (ent = listp->head; ent; ent = ent->next) { if (check_one_exclude(name, ent, name_is_dir)) { report_exclude_result(name, ent, name_is_dir, type); return !ent->include; @@ -273,67 +274,38 @@ static const char *get_exclude_tok(const char *p, int *len_ptr, int *incl_ptr, } -void add_exclude(struct exclude_struct ***listp, const char *pattern, int xflags) +void add_exclude(struct exclude_list_struct *listp, const char *pattern, + int xflags) { - struct exclude_struct **list = *listp; - int pat_len, list_len = 0; - int incl, add_cnt = 1; + int pat_len, incl; const char *cp; if (!pattern) return; - if (xflags & XFLG_WORD_SPLIT) { - int add = 0; - /* Count maximum extra tokens we might encounter. */ - for (cp = pattern; *cp; cp++) { - if (isspace(*(unsigned char *)cp)) { - add_cnt += add; - add = 0; - } else - add = 1; - } - } - - cp = get_exclude_tok(pattern, &pat_len, &incl, xflags); - if (!pat_len) - return; - - /* Check for the special "!" token that clears the list. Yes, we - * only honor it at the start of a XFLG_WORD_SPLIT string. */ - if (incl < 0) { - free_exclude_list(listp); - if (!--add_cnt) - return; + cp = pattern; + pat_len = 0; + while (1) { cp = get_exclude_tok(cp + pat_len, &pat_len, &incl, xflags); if (!pat_len) - return; - } - - if (list) - for ( ; list[list_len]; list_len++) {} - - list = *listp = realloc_array(list, struct exclude_struct *, - list_len + add_cnt + 1); - if (!list) - out_of_memory("add_exclude"); - - while (pat_len) { - list[list_len++] = make_exclude(cp, pat_len, incl); - - if (verbose > 2) { - rprintf(FINFO, "[%s] add_exclude(%s,%s)\n", - who_am_i(), cp, - incl ? "include" : "exclude"); + break; + /* If we got the special "!" token, clear the list. */ + if (incl < 0) + free_exclude_list(listp); + else { + make_exclude(listp, cp, pat_len, incl); + + if (verbose > 2) { + rprintf(FINFO, "[%s] add_exclude(%s,%s)\n", + who_am_i(), cp, + incl ? "include" : "exclude"); + } } - cp = get_exclude_tok(cp + pat_len, &pat_len, &incl, xflags); } - - list[list_len] = NULL; } -void add_exclude_file(struct exclude_struct ***listp, const char *fname, +void add_exclude_file(struct exclude_list_struct *listp, const char *fname, int xflags) { FILE *fp; @@ -374,12 +346,9 @@ void add_exclude_file(struct exclude_struct ***listp, const char *fname, *s++ = ch; } *s = '\0'; - if (*line && *line != ';' && *line != '#') { - /* Skip lines starting with semicolon or pound. - * It probably wouldn't cause any harm to not skip - * them but there's no need to save them. */ + /* Skip lines starting with semicolon or pound. */ + if (*line && *line != ';' && *line != '#') add_exclude(listp, line, xflags); - } if (ch == EOF) break; } @@ -389,7 +358,7 @@ void add_exclude_file(struct exclude_struct ***listp, const char *fname, void send_exclude_list(int f) { - int i; + struct exclude_struct *ent; extern int list_only, recurse; /* This is a complete hack - blame Rusty. @@ -399,24 +368,19 @@ void send_exclude_list(int f) if (list_only && !recurse) add_exclude(&exclude_list, "/*/*", 0); - if (!exclude_list) { - write_int(f, 0); - return; - } - - for (i = 0; exclude_list[i]; i++) { + for (ent = exclude_list.head; ent; ent = ent->next) { unsigned int l; char p[MAXPATHLEN+1]; - l = strlcpy(p, exclude_list[i]->pattern, sizeof p); + l = strlcpy(p, ent->pattern, sizeof p); if (l == 0 || l >= MAXPATHLEN) continue; - if (exclude_list[i]->directory) { + if (ent->directory) { p[l++] = '/'; p[l] = '\0'; } - if (exclude_list[i]->include) { + if (ent->include) { write_int(f, l + 2); write_buf(f, "+ ", 2); } else if ((*p == '-' || *p == '+') && p[1] == ' ') { -- 2.34.1