2005-07-15 00:55:09 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Eric Biederman, 2005
|
|
|
|
*/
|
Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
#include "builtin.h"
|
2023-06-27 16:19:01 +00:00
|
|
|
#include "attr.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2023-04-11 07:41:57 +00:00
|
|
|
#include "editor.h"
|
2023-02-24 00:09:29 +00:00
|
|
|
#include "ident.h"
|
2023-04-11 07:41:59 +00:00
|
|
|
#include "pager.h"
|
2021-11-03 20:17:02 +00:00
|
|
|
#include "refs.h"
|
2023-07-04 23:08:18 +00:00
|
|
|
#include "path.h"
|
|
|
|
#include "strbuf.h"
|
2005-07-15 00:55:09 +00:00
|
|
|
|
2010-02-14 11:55:53 +00:00
|
|
|
static const char var_usage[] = "git var (-l | <variable>)";
|
2005-07-15 00:55:09 +00:00
|
|
|
|
2023-06-27 16:18:59 +00:00
|
|
|
static char *committer(int ident_flag)
|
2009-11-12 00:01:27 +00:00
|
|
|
{
|
2023-06-27 16:18:59 +00:00
|
|
|
return xstrdup_or_null(git_committer_info(ident_flag));
|
2009-11-12 00:01:27 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 16:18:59 +00:00
|
|
|
static char *author(int ident_flag)
|
2022-12-17 23:09:59 +00:00
|
|
|
{
|
2023-06-27 16:18:59 +00:00
|
|
|
return xstrdup_or_null(git_author_info(ident_flag));
|
2022-12-17 23:09:59 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 16:18:59 +00:00
|
|
|
static char *editor(int ident_flag UNUSED)
|
|
|
|
{
|
|
|
|
return xstrdup_or_null(git_editor());
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *sequence_editor(int ident_flag UNUSED)
|
|
|
|
{
|
|
|
|
return xstrdup_or_null(git_sequence_editor());
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *pager(int ident_flag UNUSED)
|
2009-10-31 01:41:27 +00:00
|
|
|
{
|
2010-02-14 11:59:59 +00:00
|
|
|
const char *pgm = git_pager(1);
|
2009-10-31 01:41:27 +00:00
|
|
|
|
|
|
|
if (!pgm)
|
|
|
|
pgm = "cat";
|
2023-06-27 16:18:59 +00:00
|
|
|
return xstrdup(pgm);
|
2009-10-31 01:41:27 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 16:18:59 +00:00
|
|
|
static char *default_branch(int ident_flag UNUSED)
|
2021-11-03 20:17:02 +00:00
|
|
|
{
|
2023-06-27 16:18:59 +00:00
|
|
|
return xstrdup_or_null(git_default_branch_name(1));
|
2021-11-03 20:17:02 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 16:18:59 +00:00
|
|
|
static char *shell_path(int ident_flag UNUSED)
|
var: add support for listing the shell
On most Unix systems, finding a suitable shell is easy: one simply uses
"sh" with an appropriate PATH value. However, in many Windows
environments, the shell is shipped alongside Git, and it may or may not
be in PATH, even if Git is.
In such an environment, it can be very helpful to query Git for the
shell it's using, since other tools may want to use the same shell as
well. To help them out, let's add a variable, GIT_SHELL_PATH, that
points to the location of the shell.
On Unix, we know our shell must be executable to be functional, so
assume that the distributor has correctly configured their environment,
and use that as a basic test. On Git for Windows, we know that our
shell will be one of a few fixed values, all of which end in "sh" (such
as "bash"). This seems like it might be a nice test on Unix as well,
since it is customary for all shells to end in "sh", but there probably
exist such systems that don't have such a configuration, so be careful
here not to break them.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-27 16:18:57 +00:00
|
|
|
{
|
2023-06-27 16:18:59 +00:00
|
|
|
return xstrdup(SHELL_PATH);
|
2009-10-31 01:41:27 +00:00
|
|
|
}
|
|
|
|
|
2023-06-27 16:19:01 +00:00
|
|
|
static char *git_attr_val_system(int ident_flag UNUSED)
|
2021-11-03 20:17:02 +00:00
|
|
|
{
|
2023-06-27 16:19:01 +00:00
|
|
|
if (git_attr_system_is_enabled()) {
|
|
|
|
char *file = xstrdup(git_attr_system_file());
|
|
|
|
normalize_path_copy(file, file);
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *git_attr_val_global(int ident_flag UNUSED)
|
|
|
|
{
|
|
|
|
char *file = xstrdup(git_attr_global_file());
|
|
|
|
if (file) {
|
|
|
|
normalize_path_copy(file, file);
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
var: add config file locations
Much like with attributes files, sometimes programs would like to know
the location of configuration files at the global or system levels.
However, it isn't always clear where these may live, especially for the
system file, which may have been hard-coded at compile time or computed
dynamically based on the runtime prefix.
Since other parties cannot intuitively know how Git was compiled and
where it looks for these files, help them by providing variables that
can be queried. Because we have multiple paths for global config
values, print them in order from highest to lowest priority, and be sure
to split on newlines so that "git var -l" produces two entries for the
global value.
However, be careful not to split all values on newlines, since our
editor values could well contain such characters, and we don't want to
split them in such a case.
Note in the documentation that some values may contain multiple paths
and that callers should be prepared for that fact. This helps people
write code that will continue to work in the event we allow multiple
items elsewhere in the future.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-27 16:19:02 +00:00
|
|
|
static char *git_config_val_system(int ident_flag UNUSED)
|
|
|
|
{
|
|
|
|
if (git_config_system()) {
|
|
|
|
char *file = git_system_config();
|
|
|
|
normalize_path_copy(file, file);
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *git_config_val_global(int ident_flag UNUSED)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
char *user, *xdg;
|
|
|
|
size_t unused;
|
|
|
|
|
|
|
|
git_global_config(&user, &xdg);
|
|
|
|
if (xdg && *xdg) {
|
|
|
|
normalize_path_copy(xdg, xdg);
|
|
|
|
strbuf_addf(&buf, "%s\n", xdg);
|
|
|
|
}
|
|
|
|
if (user && *user) {
|
|
|
|
normalize_path_copy(user, user);
|
|
|
|
strbuf_addf(&buf, "%s\n", user);
|
|
|
|
}
|
|
|
|
free(xdg);
|
|
|
|
free(user);
|
|
|
|
strbuf_trim_trailing_newline(&buf);
|
|
|
|
if (buf.len == 0) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return strbuf_detach(&buf, &unused);
|
2021-11-03 20:17:02 +00:00
|
|
|
}
|
|
|
|
|
2005-07-15 00:55:09 +00:00
|
|
|
struct git_var {
|
|
|
|
const char *name;
|
2023-06-27 16:18:59 +00:00
|
|
|
char *(*read)(int);
|
var: add config file locations
Much like with attributes files, sometimes programs would like to know
the location of configuration files at the global or system levels.
However, it isn't always clear where these may live, especially for the
system file, which may have been hard-coded at compile time or computed
dynamically based on the runtime prefix.
Since other parties cannot intuitively know how Git was compiled and
where it looks for these files, help them by providing variables that
can be queried. Because we have multiple paths for global config
values, print them in order from highest to lowest priority, and be sure
to split on newlines so that "git var -l" produces two entries for the
global value.
However, be careful not to split all values on newlines, since our
editor values could well contain such characters, and we don't want to
split them in such a case.
Note in the documentation that some values may contain multiple paths
and that callers should be prepared for that fact. This helps people
write code that will continue to work in the event we allow multiple
items elsewhere in the future.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-27 16:19:02 +00:00
|
|
|
int multivalued;
|
2005-07-15 00:55:09 +00:00
|
|
|
};
|
|
|
|
static struct git_var git_vars[] = {
|
2023-06-27 16:18:58 +00:00
|
|
|
{
|
|
|
|
.name = "GIT_COMMITTER_IDENT",
|
2023-06-27 16:18:59 +00:00
|
|
|
.read = committer,
|
2023-06-27 16:18:58 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_AUTHOR_IDENT",
|
2023-06-27 16:18:59 +00:00
|
|
|
.read = author,
|
2023-06-27 16:18:58 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_EDITOR",
|
|
|
|
.read = editor,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_SEQUENCE_EDITOR",
|
|
|
|
.read = sequence_editor,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_PAGER",
|
|
|
|
.read = pager,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_DEFAULT_BRANCH",
|
|
|
|
.read = default_branch,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_SHELL_PATH",
|
|
|
|
.read = shell_path,
|
|
|
|
},
|
2023-06-27 16:19:01 +00:00
|
|
|
{
|
|
|
|
.name = "GIT_ATTR_SYSTEM",
|
|
|
|
.read = git_attr_val_system,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_ATTR_GLOBAL",
|
|
|
|
.read = git_attr_val_global,
|
|
|
|
},
|
var: add config file locations
Much like with attributes files, sometimes programs would like to know
the location of configuration files at the global or system levels.
However, it isn't always clear where these may live, especially for the
system file, which may have been hard-coded at compile time or computed
dynamically based on the runtime prefix.
Since other parties cannot intuitively know how Git was compiled and
where it looks for these files, help them by providing variables that
can be queried. Because we have multiple paths for global config
values, print them in order from highest to lowest priority, and be sure
to split on newlines so that "git var -l" produces two entries for the
global value.
However, be careful not to split all values on newlines, since our
editor values could well contain such characters, and we don't want to
split them in such a case.
Note in the documentation that some values may contain multiple paths
and that callers should be prepared for that fact. This helps people
write code that will continue to work in the event we allow multiple
items elsewhere in the future.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-27 16:19:02 +00:00
|
|
|
{
|
|
|
|
.name = "GIT_CONFIG_SYSTEM",
|
|
|
|
.read = git_config_val_system,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "GIT_CONFIG_GLOBAL",
|
|
|
|
.read = git_config_val_global,
|
|
|
|
.multivalued = 1,
|
|
|
|
},
|
2023-06-27 16:18:58 +00:00
|
|
|
{
|
|
|
|
.name = "",
|
|
|
|
.read = NULL,
|
|
|
|
},
|
2005-07-15 00:55:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void list_vars(void)
|
|
|
|
{
|
|
|
|
struct git_var *ptr;
|
2023-06-27 16:18:59 +00:00
|
|
|
char *val;
|
2009-11-12 00:01:27 +00:00
|
|
|
|
2009-09-01 05:35:10 +00:00
|
|
|
for (ptr = git_vars; ptr->read; ptr++)
|
2023-06-27 16:18:59 +00:00
|
|
|
if ((val = ptr->read(0))) {
|
var: add config file locations
Much like with attributes files, sometimes programs would like to know
the location of configuration files at the global or system levels.
However, it isn't always clear where these may live, especially for the
system file, which may have been hard-coded at compile time or computed
dynamically based on the runtime prefix.
Since other parties cannot intuitively know how Git was compiled and
where it looks for these files, help them by providing variables that
can be queried. Because we have multiple paths for global config
values, print them in order from highest to lowest priority, and be sure
to split on newlines so that "git var -l" produces two entries for the
global value.
However, be careful not to split all values on newlines, since our
editor values could well contain such characters, and we don't want to
split them in such a case.
Note in the documentation that some values may contain multiple paths
and that callers should be prepared for that fact. This helps people
write code that will continue to work in the event we allow multiple
items elsewhere in the future.
Signed-off-by: brian m. carlson <bk2204@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-27 16:19:02 +00:00
|
|
|
if (ptr->multivalued && *val) {
|
|
|
|
struct string_list list = STRING_LIST_INIT_DUP;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
string_list_split(&list, val, '\n', -1);
|
|
|
|
for (i = 0; i < list.nr; i++)
|
|
|
|
printf("%s=%s\n", ptr->name, list.items[i].string);
|
|
|
|
string_list_clear(&list, 0);
|
|
|
|
} else {
|
|
|
|
printf("%s=%s\n", ptr->name, val);
|
|
|
|
}
|
2023-06-27 16:18:59 +00:00
|
|
|
free(val);
|
|
|
|
}
|
2005-07-15 00:55:09 +00:00
|
|
|
}
|
|
|
|
|
2022-11-26 14:17:56 +00:00
|
|
|
static const struct git_var *get_git_var(const char *var)
|
2005-07-15 00:55:09 +00:00
|
|
|
{
|
|
|
|
struct git_var *ptr;
|
2009-09-01 05:35:10 +00:00
|
|
|
for (ptr = git_vars; ptr->read; ptr++) {
|
2005-07-15 00:55:09 +00:00
|
|
|
if (strcmp(var, ptr->name) == 0) {
|
2022-11-26 14:17:56 +00:00
|
|
|
return ptr;
|
2005-07-15 00:55:09 +00:00
|
|
|
}
|
|
|
|
}
|
2022-11-26 14:17:56 +00:00
|
|
|
return NULL;
|
2005-07-15 00:55:09 +00:00
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int show_config(const char *var, const char *value, void *cb)
|
2005-10-12 01:47:34 +00:00
|
|
|
{
|
|
|
|
if (value)
|
|
|
|
printf("%s=%s\n", var, value);
|
|
|
|
else
|
|
|
|
printf("%s\n", var);
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2005-10-12 01:47:34 +00:00
|
|
|
}
|
|
|
|
|
builtins: mark unused prefix parameters
All builtins receive a "prefix" parameter, but it is only useful if they
need to adjust filenames given by the user on the command line. For
builtins that do not even call parse_options(), they often don't look at
the prefix at all, and -Wunused-parameter complains.
Let's annotate those to silence the compiler warning. I gave a quick
scan of each of these cases, and it seems like they don't have anything
they _should_ be using the prefix for (i.e., there is no hidden bug that
we are missing). The only questionable cases I saw were:
- in git-unpack-file, we create a tempfile which will always be at the
root of the repository, even if the command is run from a subdir.
Arguably this should be created in the subdir from which we're run
(as we report the path only as a relative name). However, nobody has
complained, and I'm hesitant to change something that is deep
plumbing going back to April 2005 (though I think within our
scripts, the sole caller in git-merge-one-file would be OK, as it
moves to the toplevel itself).
- in fetch-pack, local-filesystem remotes are taken as relative to the
project root, not the current directory. So:
git init server.git
[...put stuff in server.git...]
git init client.git
cd client.git
mkdir subdir
cd subdir
git fetch-pack ../../server.git ...
won't work, as we quietly move to the top of the repository before
interpreting the path (so "../server.git" would work). This is
weird, but again, nobody has complained and this is how it has
always worked. And this is how "git fetch" works, too. Plus it
raises questions about how a configured remote like:
git config remote.origin.url ../server.git
should behave. I can certainly come up with a reasonable set of
behavior, but it may not be worth stirring up complications in a
plumbing tool.
So I've left the behavior untouched in both of those cases. If anybody
really wants to revisit them, it's easy enough to drop the UNUSED
marker. This commit is just about removing them as obstacles to turning
on -Wunused-parameter all the time.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-03-28 20:56:55 +00:00
|
|
|
int cmd_var(int argc, const char **argv, const char *prefix UNUSED)
|
2005-07-15 00:55:09 +00:00
|
|
|
{
|
2022-11-26 14:17:56 +00:00
|
|
|
const struct git_var *git_var;
|
2023-06-27 16:18:59 +00:00
|
|
|
char *val;
|
2022-11-26 14:17:56 +00:00
|
|
|
|
2010-08-06 03:21:40 +00:00
|
|
|
if (argc != 2)
|
2005-07-15 00:55:09 +00:00
|
|
|
usage(var_usage);
|
|
|
|
|
|
|
|
if (strcmp(argv[1], "-l") == 0) {
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(show_config, NULL);
|
2005-07-15 00:55:09 +00:00
|
|
|
list_vars();
|
|
|
|
return 0;
|
|
|
|
}
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2022-11-26 14:17:56 +00:00
|
|
|
|
|
|
|
git_var = get_git_var(argv[1]);
|
|
|
|
if (!git_var)
|
2005-07-15 00:55:09 +00:00
|
|
|
usage(var_usage);
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2022-11-26 14:17:56 +00:00
|
|
|
val = git_var->read(IDENT_STRICT);
|
|
|
|
if (!val)
|
|
|
|
return 1;
|
|
|
|
|
2005-07-15 00:55:09 +00:00
|
|
|
printf("%s\n", val);
|
2023-06-27 16:18:59 +00:00
|
|
|
free(val);
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2005-07-15 00:55:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|