From: Junio C Hamano <junkio@cox.net>
Date: Sun, 13 Aug 2006 02:13:31 +0000 (-0700)
Subject: Merge branch 'mk/rename'
X-Git-Tag: v1.4.3-rc1~278
X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=bb266cb11842f76712ebff1d8b1bd086dc65337f;p=git.git

Merge branch 'mk/rename'
---

bb266cb11842f76712ebff1d8b1bd086dc65337f
diff --cc builtin-checkout-index.c
index 000000000,29ea6fdc6..8d0dbad49
mode 000000,100644..100644
--- a/builtin-checkout-index.c
+++ b/builtin-checkout-index.c
@@@ -1,0 -1,309 +1,309 @@@
+ /*
+  * Check-out files from the "current cache directory"
+  *
+  * Copyright (C) 2005 Linus Torvalds
+  *
+  * Careful: order of argument flags does matter. For example,
+  *
+  *	git-checkout-index -a -f file.c
+  *
+  * Will first check out all files listed in the cache (but not
+  * overwrite any old ones), and then force-checkout "file.c" a
+  * second time (ie that one _will_ overwrite any old contents
+  * with the same filename).
+  *
+  * Also, just doing "git-checkout-index" does nothing. You probably
+  * meant "git-checkout-index -a". And if you want to force it, you
+  * want "git-checkout-index -f -a".
+  *
+  * Intuitiveness is not the goal here. Repeatability is. The
+  * reason for the "no arguments means no work" thing is that
+  * from scripts you are supposed to be able to do things like
+  *
+  *	find . -name '*.h' -print0 | xargs -0 git-checkout-index -f --
+  *
+  * or:
+  *
+  *	find . -name '*.h' -print0 | git-checkout-index -f -z --stdin
+  *
+  * which will force all existing *.h files to be replaced with
+  * their cached copies. If an empty command line implied "all",
+  * then this would force-refresh everything in the cache, which
+  * was not the point.
+  *
+  * Oh, and the "--" is just a good idea when you know the rest
+  * will be filenames. Just so that you wouldn't have a filename
+  * of "-a" causing problems (not possible in the above example,
+  * but get used to it in scripting!).
+  */
+ #include "cache.h"
+ #include "strbuf.h"
+ #include "quote.h"
+ #include "cache-tree.h"
+ 
+ #define CHECKOUT_ALL 4
+ static int line_termination = '\n';
+ static int checkout_stage; /* default to checkout stage0 */
+ static int to_tempfile;
+ static char topath[4][MAXPATHLEN+1];
+ 
+ static struct checkout state;
+ 
+ static void write_tempfile_record(const char *name, int prefix_length)
+ {
+ 	int i;
+ 
+ 	if (CHECKOUT_ALL == checkout_stage) {
+ 		for (i = 1; i < 4; i++) {
+ 			if (i > 1)
+ 				putchar(' ');
+ 			if (topath[i][0])
+ 				fputs(topath[i], stdout);
+ 			else
+ 				putchar('.');
+ 		}
+ 	} else
+ 		fputs(topath[checkout_stage], stdout);
+ 
+ 	putchar('\t');
+ 	write_name_quoted("", 0, name + prefix_length,
+ 		line_termination, stdout);
+ 	putchar(line_termination);
+ 
+ 	for (i = 0; i < 4; i++) {
+ 		topath[i][0] = 0;
+ 	}
+ }
+ 
+ static int checkout_file(const char *name, int prefix_length)
+ {
+ 	int namelen = strlen(name);
+ 	int pos = cache_name_pos(name, namelen);
+ 	int has_same_name = 0;
+ 	int did_checkout = 0;
+ 	int errs = 0;
+ 
+ 	if (pos < 0)
+ 		pos = -pos - 1;
+ 
+ 	while (pos < active_nr) {
+ 		struct cache_entry *ce = active_cache[pos];
+ 		if (ce_namelen(ce) != namelen ||
+ 		    memcmp(ce->name, name, namelen))
+ 			break;
+ 		has_same_name = 1;
+ 		pos++;
+ 		if (ce_stage(ce) != checkout_stage
+ 		    && (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
+ 			continue;
+ 		did_checkout = 1;
+ 		if (checkout_entry(ce, &state,
+ 		    to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
+ 			errs++;
+ 	}
+ 
+ 	if (did_checkout) {
+ 		if (to_tempfile)
+ 			write_tempfile_record(name, prefix_length);
+ 		return errs > 0 ? -1 : 0;
+ 	}
+ 
+ 	if (!state.quiet) {
+ 		fprintf(stderr, "git-checkout-index: %s ", name);
+ 		if (!has_same_name)
+ 			fprintf(stderr, "is not in the cache");
+ 		else if (checkout_stage)
+ 			fprintf(stderr, "does not exist at stage %d",
+ 				checkout_stage);
+ 		else
+ 			fprintf(stderr, "is unmerged");
+ 		fputc('\n', stderr);
+ 	}
+ 	return -1;
+ }
+ 
+ static int checkout_all(const char *prefix, int prefix_length)
+ {
+ 	int i, errs = 0;
+ 	struct cache_entry* last_ce = NULL;
+ 
+ 	for (i = 0; i < active_nr ; i++) {
+ 		struct cache_entry *ce = active_cache[i];
+ 		if (ce_stage(ce) != checkout_stage
+ 		    && (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
+ 			continue;
+ 		if (prefix && *prefix &&
+ 		    (ce_namelen(ce) <= prefix_length ||
+ 		     memcmp(prefix, ce->name, prefix_length)))
+ 			continue;
+ 		if (last_ce && to_tempfile) {
+ 			if (ce_namelen(last_ce) != ce_namelen(ce)
+ 			    || memcmp(last_ce->name, ce->name, ce_namelen(ce)))
+ 				write_tempfile_record(last_ce->name, prefix_length);
+ 		}
+ 		if (checkout_entry(ce, &state,
+ 		    to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
+ 			errs++;
+ 		last_ce = ce;
+ 	}
+ 	if (last_ce && to_tempfile)
+ 		write_tempfile_record(last_ce->name, prefix_length);
+ 	if (errs)
+ 		/* we have already done our error reporting.
+ 		 * exit with the same code as die().
+ 		 */
+ 		exit(128);
+ 	return 0;
+ }
+ 
+ static const char checkout_cache_usage[] =
+ "git-checkout-index [-u] [-q] [-a] [-f] [-n] [--stage=[123]|all] [--prefix=<string>] [--temp] [--] <file>...";
+ 
+ static struct lock_file lock_file;
+ 
+ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
+ {
+ 	int i;
+ 	int newfd = -1;
+ 	int all = 0;
+ 	int read_from_stdin = 0;
+ 	int prefix_length;
+ 
+ 	git_config(git_default_config);
+ 	state.base_dir = "";
+ 	prefix_length = prefix ? strlen(prefix) : 0;
+ 
+ 	if (read_cache() < 0) {
+ 		die("invalid cache");
+ 	}
+ 
+ 	for (i = 1; i < argc; i++) {
+ 		const char *arg = argv[i];
+ 
+ 		if (!strcmp(arg, "--")) {
+ 			i++;
+ 			break;
+ 		}
+ 		if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
+ 			all = 1;
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "-f") || !strcmp(arg, "--force")) {
+ 			state.force = 1;
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) {
+ 			state.quiet = 1;
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "-n") || !strcmp(arg, "--no-create")) {
+ 			state.not_new = 1;
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "-u") || !strcmp(arg, "--index")) {
+ 			state.refresh_cache = 1;
+ 			if (newfd < 0)
+ 				newfd = hold_lock_file_for_update
 -					(&lock_file, get_index_file());
++					(&lock_file, get_index_file(), 1);
+ 			if (newfd < 0)
+ 				die("cannot open index.lock file.");
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "-z")) {
+ 			line_termination = 0;
+ 			continue;
+ 		}
+ 		if (!strcmp(arg, "--stdin")) {
+ 			if (i != argc - 1)
+ 				die("--stdin must be at the end");
+ 			read_from_stdin = 1;
+ 			i++; /* do not consider arg as a file name */
+ 			break;
+ 		}
+ 		if (!strcmp(arg, "--temp")) {
+ 			to_tempfile = 1;
+ 			continue;
+ 		}
+ 		if (!strncmp(arg, "--prefix=", 9)) {
+ 			state.base_dir = arg+9;
+ 			state.base_dir_len = strlen(state.base_dir);
+ 			continue;
+ 		}
+ 		if (!strncmp(arg, "--stage=", 8)) {
+ 			if (!strcmp(arg + 8, "all")) {
+ 				to_tempfile = 1;
+ 				checkout_stage = CHECKOUT_ALL;
+ 			} else {
+ 				int ch = arg[8];
+ 				if ('1' <= ch && ch <= '3')
+ 					checkout_stage = arg[8] - '0';
+ 				else
+ 					die("stage should be between 1 and 3 or all");
+ 			}
+ 			continue;
+ 		}
+ 		if (arg[0] == '-')
+ 			usage(checkout_cache_usage);
+ 		break;
+ 	}
+ 
+ 	if (state.base_dir_len || to_tempfile) {
+ 		/* when --prefix is specified we do not
+ 		 * want to update cache.
+ 		 */
+ 		if (state.refresh_cache) {
+ 			close(newfd); newfd = -1;
+ 			rollback_lock_file(&lock_file);
+ 		}
+ 		state.refresh_cache = 0;
+ 	}
+ 
+ 	/* Check out named files first */
+ 	for ( ; i < argc; i++) {
+ 		const char *arg = argv[i];
+ 		const char *p;
+ 
+ 		if (all)
+ 			die("git-checkout-index: don't mix '--all' and explicit filenames");
+ 		if (read_from_stdin)
+ 			die("git-checkout-index: don't mix '--stdin' and explicit filenames");
+ 		p = prefix_path(prefix, prefix_length, arg);
+ 		checkout_file(p, prefix_length);
+ 		if (p < arg || p > arg + strlen(arg))
+ 			free((char*)p);
+ 	}
+ 
+ 	if (read_from_stdin) {
+ 		struct strbuf buf;
+ 		if (all)
+ 			die("git-checkout-index: don't mix '--all' and '--stdin'");
+ 		strbuf_init(&buf);
+ 		while (1) {
+ 			char *path_name;
+ 			const char *p;
+ 
+ 			read_line(&buf, stdin, line_termination);
+ 			if (buf.eof)
+ 				break;
+ 			if (line_termination && buf.buf[0] == '"')
+ 				path_name = unquote_c_style(buf.buf, NULL);
+ 			else
+ 				path_name = buf.buf;
+ 			p = prefix_path(prefix, prefix_length, path_name);
+ 			checkout_file(p, prefix_length);
+ 			if (p < path_name || p > path_name + strlen(path_name))
+ 				free((char *)p);
+ 			if (path_name != buf.buf)
+ 				free(path_name);
+ 		}
+ 	}
+ 
+ 	if (all)
+ 		checkout_all(prefix, prefix_length);
+ 
+ 	if (0 <= newfd &&
+ 	    (write_cache(newfd, active_cache, active_nr) ||
+ 	     close(newfd) || commit_lock_file(&lock_file)))
+ 		die("Unable to write new index file");
+ 	return 0;
+ }
diff --cc builtin-verify-pack.c
index 000000000,d700761e1..7d39d9bcd
mode 000000,100644..100644
--- a/builtin-verify-pack.c
+++ b/builtin-verify-pack.c
@@@ -1,0 -1,79 +1,79 @@@
+ #include "builtin.h"
+ #include "cache.h"
+ #include "pack.h"
+ 
+ static int verify_one_pack(const char *path, int verbose)
+ {
+ 	char arg[PATH_MAX];
+ 	int len;
+ 	struct packed_git *pack;
+ 	int err;
+ 
+ 	len = strlcpy(arg, path, PATH_MAX);
+ 	if (len >= PATH_MAX)
+ 		return error("name too long: %s", path);
+ 
+ 	/*
+ 	 * In addition to "foo.idx" we accept "foo.pack" and "foo";
+ 	 * normalize these forms to "foo.idx" for add_packed_git().
+ 	 */
 -	if (has_extension(arg, len, ".pack")) {
++	if (has_extension(arg, ".pack")) {
+ 		strcpy(arg + len - 5, ".idx");
+ 		len--;
 -	} else if (!has_extension(arg, len, ".idx")) {
++	} else if (!has_extension(arg, ".idx")) {
+ 		if (len + 4 >= PATH_MAX)
+ 			return error("name too long: %s.idx", arg);
+ 		strcpy(arg + len, ".idx");
+ 		len += 4;
+ 	}
+ 
+ 	/*
+ 	 * add_packed_git() uses our buffer (containing "foo.idx") to
+ 	 * build the pack filename ("foo.pack").  Make sure it fits.
+ 	 */
+ 	if (len + 1 >= PATH_MAX) {
+ 		arg[len - 4] = '\0';
+ 		return error("name too long: %s.pack", arg);
+ 	}
+ 
+ 	pack = add_packed_git(arg, len, 1);
+ 	if (!pack)
+ 		return error("packfile %s not found.", arg);
+ 
+ 	err = verify_pack(pack, verbose);
+ 	free(pack);
+ 
+ 	return err;
+ }
+ 
+ static const char verify_pack_usage[] = "git-verify-pack [-v] <pack>...";
+ 
+ int cmd_verify_pack(int argc, const char **argv, const char *prefix)
+ {
+ 	int err = 0;
+ 	int verbose = 0;
+ 	int no_more_options = 0;
+ 	int nothing_done = 1;
+ 
+ 	while (1 < argc) {
+ 		if (!no_more_options && argv[1][0] == '-') {
+ 			if (!strcmp("-v", argv[1]))
+ 				verbose = 1;
+ 			else if (!strcmp("--", argv[1]))
+ 				no_more_options = 1;
+ 			else
+ 				usage(verify_pack_usage);
+ 		}
+ 		else {
+ 			if (verify_one_pack(argv[1], verbose))
+ 				err = 1;
+ 			nothing_done = 0;
+ 		}
+ 		argc--; argv++;
+ 	}
+ 
+ 	if (nothing_done)
+ 		usage(verify_pack_usage);
+ 
+ 	return err;
+ }
diff --cc help.c
index 000000000,7a7f7759e..6484cb9df
mode 000000,100644..100644
--- a/help.c
+++ b/help.c
@@@ -1,0 -1,234 +1,234 @@@
+ /*
+  * builtin-help.c
+  *
+  * Builtin help-related commands (help, usage, version)
+  */
+ #include <sys/ioctl.h>
+ #include "cache.h"
+ #include "builtin.h"
+ #include "exec_cmd.h"
+ #include "common-cmds.h"
+ 
+ 
+ /* most GUI terminals set COLUMNS (although some don't export it) */
+ static int term_columns(void)
+ {
+ 	char *col_string = getenv("COLUMNS");
+ 	int n_cols = 0;
+ 
+ 	if (col_string && (n_cols = atoi(col_string)) > 0)
+ 		return n_cols;
+ 
+ #ifdef TIOCGWINSZ
+ 	{
+ 		struct winsize ws;
+ 		if (!ioctl(1, TIOCGWINSZ, &ws)) {
+ 			if (ws.ws_col)
+ 				return ws.ws_col;
+ 		}
+ 	}
+ #endif
+ 
+ 	return 80;
+ }
+ 
+ static void oom(void)
+ {
+ 	fprintf(stderr, "git: out of memory\n");
+ 	exit(1);
+ }
+ 
+ static inline void mput_char(char c, unsigned int num)
+ {
+ 	while(num--)
+ 		putchar(c);
+ }
+ 
+ static struct cmdname {
+ 	size_t len;
+ 	char name[1];
+ } **cmdname;
+ static int cmdname_alloc, cmdname_cnt;
+ 
+ static void add_cmdname(const char *name, int len)
+ {
+ 	struct cmdname *ent;
+ 	if (cmdname_alloc <= cmdname_cnt) {
+ 		cmdname_alloc = cmdname_alloc + 200;
+ 		cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
+ 		if (!cmdname)
+ 			oom();
+ 	}
+ 	ent = malloc(sizeof(*ent) + len);
+ 	if (!ent)
+ 		oom();
+ 	ent->len = len;
+ 	memcpy(ent->name, name, len);
+ 	ent->name[len] = 0;
+ 	cmdname[cmdname_cnt++] = ent;
+ }
+ 
+ static int cmdname_compare(const void *a_, const void *b_)
+ {
+ 	struct cmdname *a = *(struct cmdname **)a_;
+ 	struct cmdname *b = *(struct cmdname **)b_;
+ 	return strcmp(a->name, b->name);
+ }
+ 
+ static void pretty_print_string_list(struct cmdname **cmdname, int longest)
+ {
+ 	int cols = 1, rows;
+ 	int space = longest + 1; /* min 1 SP between words */
+ 	int max_cols = term_columns() - 1; /* don't print *on* the edge */
+ 	int i, j;
+ 
+ 	if (space < max_cols)
+ 		cols = max_cols / space;
+ 	rows = (cmdname_cnt + cols - 1) / cols;
+ 
+ 	qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
+ 
+ 	for (i = 0; i < rows; i++) {
+ 		printf("  ");
+ 
+ 		for (j = 0; j < cols; j++) {
+ 			int n = j * rows + i;
+ 			int size = space;
+ 			if (n >= cmdname_cnt)
+ 				break;
+ 			if (j == cols-1 || n + rows >= cmdname_cnt)
+ 				size = 1;
+ 			printf("%-*s", size, cmdname[n]->name);
+ 		}
+ 		putchar('\n');
+ 	}
+ }
+ 
+ static void list_commands(const char *exec_path, const char *pattern)
+ {
+ 	unsigned int longest = 0;
+ 	char path[PATH_MAX];
+ 	int dirlen;
+ 	DIR *dir = opendir(exec_path);
+ 	struct dirent *de;
+ 
+ 	if (!dir) {
+ 		fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
+ 		exit(1);
+ 	}
+ 
+ 	dirlen = strlen(exec_path);
+ 	if (PATH_MAX - 20 < dirlen) {
+ 		fprintf(stderr, "git: insanely long exec-path '%s'\n",
+ 			exec_path);
+ 		exit(1);
+ 	}
+ 
+ 	memcpy(path, exec_path, dirlen);
+ 	path[dirlen++] = '/';
+ 
+ 	while ((de = readdir(dir)) != NULL) {
+ 		struct stat st;
+ 		int entlen;
+ 
+ 		if (strncmp(de->d_name, "git-", 4))
+ 			continue;
+ 		strcpy(path+dirlen, de->d_name);
+ 		if (stat(path, &st) || /* stat, not lstat */
+ 		    !S_ISREG(st.st_mode) ||
+ 		    !(st.st_mode & S_IXUSR))
+ 			continue;
+ 
+ 		entlen = strlen(de->d_name);
 -		if (has_extension(de->d_name, entlen, ".exe"))
++		if (has_extension(de->d_name, ".exe"))
+ 			entlen -= 4;
+ 
+ 		if (longest < entlen)
+ 			longest = entlen;
+ 
+ 		add_cmdname(de->d_name + 4, entlen-4);
+ 	}
+ 	closedir(dir);
+ 
+ 	printf("git commands available in '%s'\n", exec_path);
+ 	printf("----------------------------");
+ 	mput_char('-', strlen(exec_path));
+ 	putchar('\n');
+ 	pretty_print_string_list(cmdname, longest - 4);
+ 	putchar('\n');
+ }
+ 
+ static void list_common_cmds_help(void)
+ {
+ 	int i, longest = 0;
+ 
+ 	for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+ 		if (longest < strlen(common_cmds[i].name))
+ 			longest = strlen(common_cmds[i].name);
+ 	}
+ 
+ 	puts("The most commonly used git commands are:");
+ 	for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+ 		printf("    %s", common_cmds[i].name);
+ 		mput_char(' ', longest - strlen(common_cmds[i].name) + 4);
+ 		puts(common_cmds[i].help);
+ 	}
+ 	puts("(use 'git help -a' to get a list of all installed git commands)");
+ }
+ 
+ static void show_man_page(const char *git_cmd)
+ {
+ 	const char *page;
+ 
+ 	if (!strncmp(git_cmd, "git", 3))
+ 		page = git_cmd;
+ 	else {
+ 		int page_len = strlen(git_cmd) + 4;
+ 		char *p = malloc(page_len + 1);
+ 		strcpy(p, "git-");
+ 		strcpy(p + 4, git_cmd);
+ 		p[page_len] = 0;
+ 		page = p;
+ 	}
+ 
+ 	execlp("man", "man", page, NULL);
+ }
+ 
+ void help_unknown_cmd(const char *cmd)
+ {
+ 	printf("git: '%s' is not a git-command\n\n", cmd);
+ 	list_common_cmds_help();
+ 	exit(1);
+ }
+ 
+ int cmd_version(int argc, const char **argv, const char *prefix)
+ {
+ 	printf("git version %s\n", git_version_string);
+ 	return 0;
+ }
+ 
+ int cmd_help(int argc, const char **argv, const char *prefix)
+ {
+ 	const char *help_cmd = argc > 1 ? argv[1] : NULL;
+ 	const char *exec_path = git_exec_path();
+ 
+ 	if (!help_cmd) {
+ 		printf("usage: %s\n\n", git_usage_string);
+ 		list_common_cmds_help();
+ 		exit(1);
+ 	}
+ 
+ 	else if (!strcmp(help_cmd, "--all") || !strcmp(help_cmd, "-a")) {
+ 		printf("usage: %s\n\n", git_usage_string);
+ 		if(exec_path)
+ 			list_commands(exec_path, "git-*");
+ 		exit(1);
+ 	}
+ 
+ 	else
+ 		show_man_page(help_cmd);
+ 
+ 	return 0;
+ }
+ 
+