2005-07-15 00:55:09 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Eric Biederman, 2005
|
|
|
|
*/
|
2024-09-13 21:16:15 +00:00
|
|
|
#define USE_THE_REPOSITORY_VARIABLE
|
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"
|
2024-09-13 21:16:15 +00:00
|
|
|
|
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"
|
var(win32): do report the GIT_SHELL_PATH that is actually used
On Windows, Unix-like paths like `/bin/sh` make very little sense. In
the best case, they simply don't work, in the worst case they are
misinterpreted as absolute paths that are relative to the drive
associated with the current directory.
To that end, Git does not actually use the path `/bin/sh` that is
recorded e.g. when `run_command()` is called with a Unix shell
command-line. Instead, as of 776297548e (Do not use SHELL_PATH from
build system in prepare_shell_cmd on Windows, 2012-04-17), it
re-interprets `/bin/sh` as "look up `sh` on the `PATH` and use the
result instead".
This is the logic users expect to be followed when running `git var
GIT_SHELL_PATH`.
However, when 1e65721227 (var: add support for listing the shell,
2023-06-27) introduced support for `git var GIT_SHELL_PATH`, Windows was
not special-cased as above, which is why it outputs `/bin/sh` even
though that disagrees with what Git actually uses.
Let's fix this by using the exact same logic as `prepare_shell_cmd()`,
adjusting the Windows-specific `git var GIT_SHELL_PATH` test case to
verify that it actually finds a working executable.
Reported-by: Phillip Wood <phillip.wood123@gmail.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-07-13 21:08:24 +00:00
|
|
|
#include "run-command.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
|
|
|
{
|
2024-05-17 08:19:09 +00:00
|
|
|
return repo_default_branch_name(the_repository, 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
|
|
|
{
|
var(win32): do report the GIT_SHELL_PATH that is actually used
On Windows, Unix-like paths like `/bin/sh` make very little sense. In
the best case, they simply don't work, in the worst case they are
misinterpreted as absolute paths that are relative to the drive
associated with the current directory.
To that end, Git does not actually use the path `/bin/sh` that is
recorded e.g. when `run_command()` is called with a Unix shell
command-line. Instead, as of 776297548e (Do not use SHELL_PATH from
build system in prepare_shell_cmd on Windows, 2012-04-17), it
re-interprets `/bin/sh` as "look up `sh` on the `PATH` and use the
result instead".
This is the logic users expect to be followed when running `git var
GIT_SHELL_PATH`.
However, when 1e65721227 (var: add support for listing the shell,
2023-06-27) introduced support for `git var GIT_SHELL_PATH`, Windows was
not special-cased as above, which is why it outputs `/bin/sh` even
though that disagrees with what Git actually uses.
Let's fix this by using the exact same logic as `prepare_shell_cmd()`,
adjusting the Windows-specific `git var GIT_SHELL_PATH` test case to
verify that it actually finds a working executable.
Reported-by: Phillip Wood <phillip.wood123@gmail.com>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-07-13 21:08:24 +00:00
|
|
|
return git_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)
|
|
|
|
{
|
2023-09-04 06:21:26 +00:00
|
|
|
char *file = xstrdup_or_null(git_attr_global_file());
|
2023-06-27 16:19:01 +00:00
|
|
|
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;
|
|
|
|
|
2024-01-18 16:12:50 +00:00
|
|
|
git_global_config_paths(&user, &xdg);
|
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 (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
|
|
|
}
|
|
|
|
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 19:26:22 +00:00
|
|
|
static int show_config(const char *var, const char *value,
|
|
|
|
const struct config_context *ctx, void *cb)
|
2005-10-12 01:47:34 +00:00
|
|
|
{
|
|
|
|
if (value)
|
|
|
|
printf("%s=%s\n", var, value);
|
|
|
|
else
|
|
|
|
printf("%s\n", var);
|
config: add ctx arg to config_fn_t
Add a new "const struct config_context *ctx" arg to config_fn_t to hold
additional information about the config iteration operation.
config_context has a "struct key_value_info kvi" member that holds
metadata about the config source being read (e.g. what kind of config
source it is, the filename, etc). In this series, we're only interested
in .kvi, so we could have just used "struct key_value_info" as an arg,
but config_context makes it possible to add/adjust members in the future
without changing the config_fn_t signature. We could also consider other
ways of organizing the args (e.g. moving the config name and value into
config_context or key_value_info), but in my experiments, the
incremental benefit doesn't justify the added complexity (e.g. a
config_fn_t will sometimes invoke another config_fn_t but with a
different config value).
In subsequent commits, the .kvi member will replace the global "struct
config_reader" in config.c, making config iteration a global-free
operation. It requires much more work for the machinery to provide
meaningful values of .kvi, so for now, merely change the signature and
call sites, pass NULL as a placeholder value, and don't rely on the arg
in any meaningful way.
Most of the changes are performed by
contrib/coccinelle/config_fn_ctx.pending.cocci, which, for every
config_fn_t:
- Modifies the signature to accept "const struct config_context *ctx"
- Passes "ctx" to any inner config_fn_t, if needed
- Adds UNUSED attributes to "ctx", if needed
Most config_fn_t instances are easily identified by seeing if they are
called by the various config functions. Most of the remaining ones are
manually named in the .cocci patch. Manual cleanups are still needed,
but the majority of it is trivial; it's either adjusting config_fn_t
that the .cocci patch didn't catch, or adding forward declarations of
"struct config_context ctx" to make the signatures make sense.
The non-trivial changes are in cases where we are invoking a config_fn_t
outside of config machinery, and we now need to decide what value of
"ctx" to pass. These cases are:
- trace2/tr2_cfg.c:tr2_cfg_set_fl()
This is indirectly called by git_config_set() so that the trace2
machinery can notice the new config values and update its settings
using the tr2 config parsing function, i.e. tr2_cfg_cb().
- builtin/checkout.c:checkout_main()
This calls git_xmerge_config() as a shorthand for parsing a CLI arg.
This might be worth refactoring away in the future, since
git_xmerge_config() can call git_default_config(), which can do much
more than just parsing.
Handle them by creating a KVI_INIT macro that initializes "struct
key_value_info" to a reasonable default, and use that to construct the
"ctx" arg.
Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-06-28 19:26:22 +00:00
|
|
|
return git_default_config(var, value, ctx, cb);
|
2005-10-12 01:47:34 +00:00
|
|
|
}
|
|
|
|
|
2024-09-13 21:16:14 +00:00
|
|
|
int cmd_var(int argc,
|
|
|
|
const char **argv,
|
|
|
|
const char *prefix UNUSED,
|
|
|
|
struct repository *repo 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;
|
|
|
|
}
|