From: Junio C Hamano Date: Tue, 4 Apr 2006 07:23:36 +0000 (-0700) Subject: Merge branch 'pe/cleanup' into next X-Git-Tag: v1.3.0-rc4~45 X-Git-Url: https://asedeno.scripts.mit.edu/gitweb/?a=commitdiff_plain;h=00cbdec981e186264dc2529edce31da4bcbd41f3;hp=90321c106ca6e36c0e884ca677c9a52dea47bdde;p=git.git Merge branch 'pe/cleanup' into next * pe/cleanup: Replace xmalloc+memset(0) with xcalloc. Use blob_, commit_, tag_, and tree_type throughout. --- diff --git a/git-clone.sh b/git-clone.sh index 823c74b91..c013e481d 100755 --- a/git-clone.sh +++ b/git-clone.sh @@ -52,7 +52,8 @@ Perhaps git-update-server-info needs to be run there?" git-http-fetch -v -a -w "$tname" "$name" "$1/" || exit 1 done <"$clone_tmp/refs" rm -fr "$clone_tmp" - http_fetch "$1/HEAD" "$GIT_DIR/REMOTE_HEAD" + http_fetch "$1/HEAD" "$GIT_DIR/REMOTE_HEAD" || + rm -f "$GIT_DIR/REMOTE_HEAD" } # Read git-fetch-pack -k output and store the remote branches. @@ -324,7 +325,7 @@ test -d "$GIT_DIR/refs/reference-tmp" && rm -fr "$GIT_DIR/refs/reference-tmp" if test -f "$GIT_DIR/CLONE_HEAD" then - # Figure out where the remote HEAD points at. + # Read git-fetch-pack -k output and store the remote branches. perl -e "$copy_refs" "$GIT_DIR" "$use_separate_remote" "$origin" fi @@ -332,22 +333,25 @@ cd "$D" || exit if test -z "$bare" && test -f "$GIT_DIR/REMOTE_HEAD" then - head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"` # Figure out which remote branch HEAD points at. case "$use_separate_remote" in '') remote_top=refs/heads ;; *) remote_top="refs/remotes/$origin" ;; esac - # What to use to track the remote primary branch - if test -n "$use_separate_remote" - then - origin_tracking="remotes/$origin/master" - else - origin_tracking="heads/$origin" - fi + head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"` + case "$head_sha1" in + 'ref: refs/'*) + # Uh-oh, the remote told us (http transport done against + # new style repository with a symref HEAD). + # Ideally we should skip the guesswork but for now + # opt for minimum change. + head_sha1=`expr "$head_sha1" : 'ref: refs/heads/\(.*\)'` + head_sha1=`cat "$GIT_DIR/$remote_top/$head_sha1"` + ;; + esac - # The name under $remote_top the remote HEAD seems to point at + # The name under $remote_top the remote HEAD seems to point at. head_points_at=$( ( echo "master" @@ -368,23 +372,28 @@ then ) ) - # Write out remotes/$origin file. + # Write out remotes/$origin file, and update our "$head_points_at". case "$head_points_at" in ?*) mkdir -p "$GIT_DIR/remotes" && - echo >"$GIT_DIR/remotes/$origin" \ - "URL: $repo -Pull: refs/heads/$head_points_at:refs/$origin_tracking" && + git-symbolic-ref HEAD "refs/heads/$head_points_at" && case "$use_separate_remote" in - t) git-update-ref HEAD "$head_sha1" ;; - *) git-update-ref "refs/heads/$origin" $(git-rev-parse HEAD) ;; + t) origin_track="$remote_top/$head_points_at" + git-update-ref HEAD "$head_sha1" ;; + *) origin_track="$remote_top/$origin" + git-update-ref "refs/heads/$origin" "$head_sha1" ;; esac && + echo >"$GIT_DIR/remotes/$origin" \ + "URL: $repo +Pull: refs/heads/$head_points_at:$origin_track" && (cd "$GIT_DIR/$remote_top" && find . -type f -print) | while read dotslref do name=`expr "$dotslref" : './\(.*\)'` && - test "$head_points_at" = "$name" || - test "$origin" = "$name" || + test "$use_separate_remote" = '' && { + test "$head_points_at" = "$name" || + test "$origin" = "$name" + } || echo "Pull: refs/heads/${name}:$remote_top/${name}" done >>"$GIT_DIR/remotes/$origin" && case "$use_separate_remote" in diff --git a/pack-objects.c b/pack-objects.c index 4145f2530..934639215 100644 --- a/pack-objects.c +++ b/pack-objects.c @@ -62,7 +62,7 @@ static int nr_objects = 0, nr_alloc = 0, nr_result = 0; static const char *base_name; static unsigned char pack_file_sha1[20]; static int progress = 1; -static volatile int progress_update = 0; +static volatile sig_atomic_t progress_update = 0; /* * The object names in objects array are hashed with this hashtable, @@ -883,7 +883,6 @@ static int try_delta(struct unpacked *cur, struct unpacked *old, unsigned max_de static void progress_interval(int signum) { - signal(SIGALRM, progress_interval); progress_update = 1; } @@ -1029,6 +1028,23 @@ static int reuse_cached_pack(unsigned char *sha1, int pack_to_stdout) return 1; } +static void setup_progress_signal(void) +{ + struct sigaction sa; + struct itimerval v; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = progress_interval; + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_RESTART; + sigaction(SIGALRM, &sa, NULL); + + v.it_interval.tv_sec = 1; + v.it_interval.tv_usec = 0; + v.it_value = v.it_interval; + setitimer(ITIMER_REAL, &v, NULL); +} + int main(int argc, char **argv) { SHA_CTX ctx; @@ -1094,18 +1110,24 @@ int main(int argc, char **argv) prepare_packed_git(); if (progress) { - struct itimerval v; - v.it_interval.tv_sec = 1; - v.it_interval.tv_usec = 0; - v.it_value = v.it_interval; - signal(SIGALRM, progress_interval); - setitimer(ITIMER_REAL, &v, NULL); fprintf(stderr, "Generating pack...\n"); + setup_progress_signal(); } - while (fgets(line, sizeof(line), stdin) != NULL) { + for (;;) { unsigned char sha1[20]; + if (!fgets(line, sizeof(line), stdin)) { + if (feof(stdin)) + break; + if (!ferror(stdin)) + die("fgets returned NULL, not EOF, not error!"); + if (errno != EINTR) + die("fgets: %s", strerror(errno)); + clearerr(stdin); + continue; + } + if (line[0] == '-') { if (get_sha1_hex(line+1, sha1)) die("expected edge sha1, got garbage:\n %s", diff --git a/read-tree.c b/read-tree.c index 58e56364e..26f4f7e32 100644 --- a/read-tree.c +++ b/read-tree.c @@ -270,10 +270,26 @@ static void unlink_entry(char *name) static void progress_interval(int signum) { - signal(SIGALRM, progress_interval); progress_update = 1; } +static void setup_progress_signal(void) +{ + struct sigaction sa; + struct itimerval v; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = progress_interval; + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_RESTART; + sigaction(SIGALRM, &sa, NULL); + + v.it_interval.tv_sec = 1; + v.it_interval.tv_usec = 0; + v.it_value = v.it_interval; + setitimer(ITIMER_REAL, &v, NULL); +} + static void check_updates(struct cache_entry **src, int nr) { static struct checkout state = { @@ -286,8 +302,6 @@ static void check_updates(struct cache_entry **src, int nr) unsigned last_percent = 200, cnt = 0, total = 0; if (update && verbose_update) { - struct itimerval v; - for (total = cnt = 0; cnt < nr; cnt++) { struct cache_entry *ce = src[cnt]; if (!ce->ce_mode || ce->ce_flags & mask) @@ -299,12 +313,8 @@ static void check_updates(struct cache_entry **src, int nr) total = 0; if (total) { - v.it_interval.tv_sec = 1; - v.it_interval.tv_usec = 0; - v.it_value = v.it_interval; - signal(SIGALRM, progress_interval); - setitimer(ITIMER_REAL, &v, NULL); fprintf(stderr, "Checking files out...\n"); + setup_progress_signal(); progress_update = 1; } cnt = 0; @@ -338,8 +348,8 @@ static void check_updates(struct cache_entry **src, int nr) } } if (total) { - fputc('\n', stderr); signal(SIGALRM, SIG_IGN); + fputc('\n', stderr); } } diff --git a/xdiff/xdiffi.c b/xdiff/xdiffi.c index 8ea04837e..e81bca633 100644 --- a/xdiff/xdiffi.c +++ b/xdiff/xdiffi.c @@ -349,12 +349,7 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, kvdf += xe->xdf2.nreff + 1; kvdb += xe->xdf2.nreff + 1; - /* - * Classical integer square root approximation using shifts. - */ - xenv.mxcost = 1; - for (; ndiags; ndiags >>= 2) - xenv.mxcost <<= 1; + xenv.mxcost = xdl_bogosqrt(ndiags); if (xenv.mxcost < XDL_MAX_COST_MIN) xenv.mxcost = XDL_MAX_COST_MIN; xenv.snake_cnt = XDL_SNAKE_CNT; diff --git a/xdiff/xprepare.c b/xdiff/xprepare.c index 27a08791a..add5a75c7 100644 --- a/xdiff/xprepare.c +++ b/xdiff/xprepare.c @@ -25,6 +25,7 @@ #define XDL_KPDIS_RUN 4 +#define XDL_MAX_EQLIMIT 1024 @@ -305,26 +306,48 @@ void xdl_free_env(xdfenv_t *xe) { static int xdl_clean_mmatch(char const *dis, long i, long s, long e) { - long r, rdis, rpdis; - - for (r = 1, rdis = 0, rpdis = 1; (i - r) >= s; r++) { + long r, rdis0, rpdis0, rdis1, rpdis1; + + /* + * Scans the lines before 'i' to find a run of lines that either + * have no match (dis[j] == 0) or have multiple matches (dis[j] > 1). + * Note that we always call this function with dis[i] > 1, so the + * current line (i) is already a multimatch line. + */ + for (r = 1, rdis0 = 0, rpdis0 = 1; (i - r) >= s; r++) { if (!dis[i - r]) - rdis++; + rdis0++; else if (dis[i - r] == 2) - rpdis++; + rpdis0++; else break; } - for (r = 1; (i + r) <= e; r++) { + /* + * If the run before the line 'i' found only multimatch lines, we + * return 0 and hence we don't make the current line (i) discarded. + * We want to discard multimatch lines only when they appear in the + * middle of runs with nomatch lines (dis[j] == 0). + */ + if (rdis0 == 0) + return 0; + for (r = 1, rdis1 = 0, rpdis1 = 1; (i + r) <= e; r++) { if (!dis[i + r]) - rdis++; + rdis1++; else if (dis[i + r] == 2) - rpdis++; + rpdis1++; else break; } - - return rpdis * XDL_KPDIS_RUN < (rpdis + rdis); + /* + * If the run after the line 'i' found only multimatch lines, we + * return 0 and hence we don't make the current line (i) discarded. + */ + if (rdis1 == 0) + return 0; + rdis1 += rdis0; + rpdis1 += rpdis0; + + return rpdis1 * XDL_KPDIS_RUN < (rpdis1 + rdis1); } @@ -334,34 +357,40 @@ static int xdl_clean_mmatch(char const *dis, long i, long s, long e) { * might be potentially discarded if they happear in a run of discardable. */ static int xdl_cleanup_records(xdfile_t *xdf1, xdfile_t *xdf2) { - long i, rhi, nreff; + long i, nm, rhi, nreff, mlim; unsigned long hav; xrecord_t **recs; xrecord_t *rec; char *dis, *dis1, *dis2; - if (!(dis = (char *) xdl_malloc((xdf1->nrec + xdf2->nrec + 2) * sizeof(char)))) { + if (!(dis = (char *) xdl_malloc(xdf1->nrec + xdf2->nrec + 2))) { return -1; } - memset(dis, 0, (xdf1->nrec + xdf2->nrec + 2) * sizeof(char)); + memset(dis, 0, xdf1->nrec + xdf2->nrec + 2); dis1 = dis; dis2 = dis1 + xdf1->nrec + 1; + if ((mlim = xdl_bogosqrt(xdf1->nrec)) > XDL_MAX_EQLIMIT) + mlim = XDL_MAX_EQLIMIT; for (i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; i <= xdf1->dend; i++, recs++) { hav = (*recs)->ha; rhi = (long) XDL_HASHLONG(hav, xdf2->hbits); - for (rec = xdf2->rhash[rhi]; rec; rec = rec->next) - if (rec->ha == hav && ++dis1[i] == 2) + for (nm = 0, rec = xdf2->rhash[rhi]; rec; rec = rec->next) + if (rec->ha == hav && ++nm == mlim) break; + dis1[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; } + if ((mlim = xdl_bogosqrt(xdf2->nrec)) > XDL_MAX_EQLIMIT) + mlim = XDL_MAX_EQLIMIT; for (i = xdf2->dstart, recs = &xdf2->recs[xdf2->dstart]; i <= xdf2->dend; i++, recs++) { hav = (*recs)->ha; rhi = (long) XDL_HASHLONG(hav, xdf1->hbits); - for (rec = xdf1->rhash[rhi]; rec; rec = rec->next) - if (rec->ha == hav && ++dis2[i] == 2) + for (nm = 0, rec = xdf1->rhash[rhi]; rec; rec = rec->next) + if (rec->ha == hav && ++nm == mlim) break; + dis2[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; } for (nreff = 0, i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; diff --git a/xdiff/xutils.c b/xdiff/xutils.c index afaada1ed..21ab8e7e2 100644 --- a/xdiff/xutils.c +++ b/xdiff/xutils.c @@ -29,6 +29,19 @@ +long xdl_bogosqrt(long n) { + long i; + + /* + * Classical integer square root approximation using shifts. + */ + for (i = 1; n > 0; n >>= 2) + i <<= 1; + + return i; +} + + int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize, xdemitcb_t *ecb) { mmbuffer_t mb[3]; @@ -244,7 +257,7 @@ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2, memcpy(buf, "@@ -", 4); nb += 4; - nb += xdl_num_out(buf + nb, c1 ? s1: 0); + nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1); if (c1 != 1) { memcpy(buf + nb, ",", 1); @@ -256,7 +269,7 @@ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2, memcpy(buf + nb, " +", 2); nb += 2; - nb += xdl_num_out(buf + nb, c2 ? s2: 0); + nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1); if (c2 != 1) { memcpy(buf + nb, ",", 1); diff --git a/xdiff/xutils.h b/xdiff/xutils.h index 55b0d39f4..ea38ee903 100644 --- a/xdiff/xutils.h +++ b/xdiff/xutils.h @@ -24,6 +24,7 @@ #define XUTILS_H +long xdl_bogosqrt(long n); int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize, xdemitcb_t *ecb); int xdl_cha_init(chastore_t *cha, long isize, long icount);