# double b = 3.14;

AlignConsecutiveDeclarations: false

# Align escaped newlines as far left as possible

# #define A \

# int aaaa; \

# Penalties

# This decides what order things should be done if a line is too long

PenaltyBreakFirstLessLess: 0

# Don't sort #include's

SortIncludes: false

- jobname: linux-musl

image: alpine

distro: alpine-latest

- jobname: linux32

image: i386/ubuntu:focal

distro: ubuntu32-20.04

- jobname: pedantic

image: fedora

distro: fedora-latest

env:

jobname: ${{matrix.vector.jobname}}

distro: ${{matrix.vector.distro}}

parallel:

matrix:

- jobname: linux-old

CC: gcc

- jobname: linux-sha256

image: ubuntu:latest

- `S_free()` releases a structure's contents and frees the

structure.

For Perl programs:

- Most of the C guidelines above apply.

Error Messages

- Do not capitalize the first word, only because it is the first word

"SHA-3 not supported" is fine, because the reason the first word is

capitalized is not because it is at the beginning of the sentence,

but because the word would be spelled in capital letters even when

it appeared in the middle of the sentence.

Externally Visible Names

* Teach 'git notes add' and 'git notes append' a new '-e' flag,

instructing them to open the note in $GIT_EDITOR before saving.

Performance, Internal Implementation, Development Support etc.

--------------------------------------------------------------

* Document "amlog" notes.

* The way AsciiDoc is used for SYNOPSIS part of the manual pages has

been revamped. The sources, at least for the simple cases, got

* Documentation updates to 'git-update-ref(1)'.

Fixes since v2.47

-----------------

* Doc update to clarify how periodical maintenance are scheduled,

spread across time to avoid thundering hurds.

* Use after free and double freeing at the end in "git log -L... -p"

had been identified and fixed.

* On macOS, fsmonitor can fall into a race condition that results in

a client waiting forever to be notified for an event that have

already happened. This problem has been corrected.

* "git maintenance start" crashed due to an uninitialized variable

reference, which has been corrected.

* Fail gracefully instead of crashing when attempting to write the

contents of a corrupt in-core index as a tree object.

* A "git fetch" from the superproject going down to a submodule used

a wrong remote when the default remote names are set differently

between them.

* Fixes compile time warnings with 64-bit MSVC.

* Teaches 'shortlog' to explicitly use SHA-1 when operating outside

of a repository.

* Fix 'git grep' regression on macOS by disabling lookahead when

encountering invalid UTF-8 byte sequences.

* The dumb-http code regressed when the result of re-indexing a pack

yielded an *.idx file that differs in content from the *.idx file

it downloaded from the remote. This has been corrected by no longer

relying on: the *.idx file we got from the remote.

* Other code cleanup, docfix, build fix, etc.

(merge 77af53f56f aa/t7300-modernize later to maint).

(merge dcd590a39d bf/t-readme-mention-reftable later to maint).

core.repositoryFormatVersion::

Internal variable identifying the repository format and layout

core.sharedRepository::

When 'group' (or 'true'), the repository is made shareable between

files, do not consider stat-only changes as changed.

Instead, silently run `git update-index --refresh` to

update the cached stat information for paths whose

contents in the work tree match the contents in the

A comma separated list of `--dirstat` parameters specifying the

default behavior of the `--dirstat` option to linkgit:git-diff[1]

(when not changed by `diff.dirstat`) are `changes,noncumulative,3`.

The following parameters are available:

+

Note that when using `cumulative`, the sum of the percentages

reported may exceed 100%. The default (non-cumulative) behavior can

be specified with the `noncumulative` parameter.

An integer parameter specifies a cut-off percent (3% by default).

Directories contributing less than this percentage of the changes

are not shown in the output.

and accumulating child directory counts in the parent directories:

`files,10,cumulative`.

Show the context between diff hunks, up to the specified number

of lines, thereby fusing the hunks that are close to each other.

This value serves as the default for the `--inter-hunk-context`

command line option.

If this config variable is set, diff generation is not

performed using the internal diff machinery, but using the

environment variable. The command is called with parameters

as described under "git Diffs" in linkgit:git[1]. Note: if

you want to use an external diff program only on a subset of

your files, you might want to use linkgit:gitattributes[5] instead.

`diff.external` command is expected to return exit code

0 if it considers the input files to be equal or 1 if it

Any other exit code causes Git to report a fatal error.

this setting when reporting uncommitted changes. Setting it to

By default this is set to untracked so that any untracked

submodules are ignored.

this configuration is in effect, reverse diff output also swaps

the order of the prefixes:

`git diff`;;

compares a (c)ommit and the (w)ork tree;

`git diff --cached`;;

compares a (c)ommit and the (i)ndex;

compares an (o)bject and a (w)ork tree entity;

and show pathnames relative to the current directory.

File indicating how to order files within a diff.

If `diff.orderFile` is a relative pathname, it is treated as

relative to the top of the working tree.

The number of files to consider in the exhaustive portion of

`-l`. If not set, the default value is currently 1000. This

setting has no effect if rename detection is turned off.

linkgit:git-log[1], and not lower level commands such as

linkgit:git-diff-files[1].

A boolean to inhibit the standard behavior of printing a space

Specify the format in which differences in submodules are

the commits in the range like linkgit:git-submodule[1] `summary`

A POSIX Extended Regular Expression used to determine what is a "word"

when performing word-by-word difference calculations. Character

sequences that match the regular expression are "words", all other

characters are *ignorable* whitespace.

The custom diff driver command. See linkgit:gitattributes[5]

for details.

`diff.<driver>.command` command is expected to return exit code

0 if it considers the input files to be equal or 1 if it

is expected to return exit code 0 regardless of equality.

Any other exit code causes Git to report a fatal error.

The regular expression that the diff driver should use to

recognize the hunk header. A built-in pattern may also be used.

See linkgit:gitattributes[5] for details.

binary. See linkgit:gitattributes[5] for details.

The command that the diff driver should call to generate the

text-converted version of a file. The result of the

conversion is used to generate a human-readable diff. See

linkgit:gitattributes[5] for details.

The regular expression that the diff driver should use to

split words in a line. See linkgit:gitattributes[5] for

details.

conversion outputs. See linkgit:gitattributes[5] for details.

include::../mergetools-diff.txt[]

Set this option to `false` to disable the default heuristics

that shift diff hunk boundaries to make patches easier to read.

Choose a diff algorithm. The variants are as follows:

+

--

The basic greedy diff algorithm. Currently, this is the default.

`minimal`;;

Spend extra time to make sure the smallest possible diff is

--

+

Highlight whitespace errors in the `context`, `old` or `new`

lines of the diff. Multiple values are separated by comma,

`none` resets previous values, `default` reset the list to

The command line option `--ws-error-highlight=<kind>`

overrides this setting.

When moved lines are colored using e.g. the `diff.colorMoved` setting,

+

Specify a compatibility hash algorithm to use. The acceptable values

are `sha1` and `sha256`. The value specified must be different from the

interoperability between git repositories whose objectFormat matches

this compatObjectFormat. In particular when fully implemented the

pushes and pulls from a repository in whose objectFormat matches

compatObjectFormat in addition to oids encoded with objectFormat to

locally specify objects.

Specify the ref storage format to use. The acceptable values are:

+

include::../ref-storage-format.txt[]

+

Note that this setting should only be set by linkgit:git-init[1] or

linkgit:git-clone[1]. Trying to change it after initialization will not

work and will produce hard-to-diagnose issues.

If enabled, then worktrees will load config settings from the

`$GIT_DIR/config.worktree` file in addition to the

`$GIT_COMMON_DIR/config` file. Note that `$GIT_COMMON_DIR` and

`config.worktree` file will override settings from any other

config files.

+

certain values from the common config file to the main working tree's

`config.worktree` file, if present:

+

`$GIT_COMMON_DIR/config.worktree`.

* If `core.bare` is true, then it must be moved from `$GIT_COMMON_DIR/config`

to `$GIT_COMMON_DIR/config.worktree`.

+

It may also be beneficial to adjust the locations of `core.sparseCheckout`

and `core.sparseCheckoutCone` depending on your desire for customizable

sparse-checkout settings for each worktree. By default, the `git

these config values on a per-worktree basis, and uses the

`$GIT_DIR/info/sparse-checkout` file to specify the sparsity for each

worktree independently. See linkgit:git-sparse-checkout[1] for more

details.

+

such a branch exists, it is checked out and set as "upstream"

for the new branch. If no such match can be found, it falls

back to creating a new branch from the current HEAD.

Raw output format

-----------------

These commands all compare two sets of things; what is

compared differs:

compares the trees named by the two arguments.

compares the index and the files on the filesystem.

what is being compared. After that, all the commands print one output

line per changed file.

Possible status letters are:

be committed)

percentage of similarity between the source and target of the move or

percentage of dissimilarity) for file rewrites.

The sha1 for "dst" is shown as all 0's if a file on the filesystem

diff format for merges

----------------------

can take `-c` or `--cc` option

to generate diff output also for merge commits. The output differs

from the format described above in the following way:

------------------

The `--summary` option describes newly added, deleted, renamed and

output. These options can be combined with other options, such as

`-p`, and are meant for human consumption.

`GIT_EXTERNAL_DIFF` and the `GIT_DIFF_OPTS` environment variables

(see linkgit:git[1]), and the `diff` attribute (see linkgit:gitattributes[5]).

diff format:

1. It is preceded by a "git diff" header that looks like this:

the file that the rename/copy produces, respectively.

2. It is followed by one or more extended header lines:

+

and file permission bits.

+

Path names in extended headers do not include the `a/` and `b/` prefixes.

file made it into the new one.

+

The index line includes the blob object names before and after the change.

separate lines indicate the old and the new mode.

3. Pathnames with "unusual" characters are quoted as explained for

2. It is followed by one or more extended header lines

(this example shows a merge with two parents):

+

The `mode <mode>,<mode>..<mode>` line appears only if at least one of

the <mode> is different from the rest. Extended headers with

information about detected content movement (renames and

copying detection) are designed to work with the diff of two

3. It is followed by a two-line from-file/to-file header:

endif::git-format-patch[]

ifndef::git-format-patch[]

Generate patch (see <<generate_patch_text_with_p>>).

ifdef::git-diff[]

This is the default.

endif::git-diff[]

Suppress all output from the diff machinery. Useful for

commands like `git show` that show the patch by default to

squelch their output, or to cancel the effect of options like

ifdef::git-log[]

-m::

Show diffs for merge commits in the default format. This is

produce no output unless `-p` is given as well.

-c::

Produce combined diff output for merge commits.

--cc::

Produce dense combined diff output for merge commits.

--dd::

Produce diff with respect to first parent for both merge and

regular commits.

--remerge-diff::

Produce remerge-diff output for merge commits.

--no-diff-merges::

--diff-merges=<format>::

Specify diff format to be used for merge commits. Default is

off, none::

Disable output of diffs for merge commits. Useful to override

implied value.

on, m::

Make diff output for merge commits to be shown in the default

format. The default format can be changed using

`log.diffMerges` configuration variable, whose default value

is `separate`.

first-parent, 1::

Show full diff with respect to first parent. This is the same

format as `--patch` produces for non-merge commits.

separate::

Show full diff with respect to each of parents.

Separate log entry and diff is generated for each parent.

combined, c::

Show differences from each of the parents to the merge

result simultaneously instead of showing pairwise diff between

a parent and the result one at a time. Furthermore, it lists

only files which were modified from all parents.

dense-combined, cc::

Further compress output produced by `--diff-merges=combined`

by omitting uninteresting hunks whose contents in the parents

have only two variants and the merge result picks one of them

without modification.

remerge, r::

Remerge two-parent merge commits to create a temporary tree

object--potentially containing files with conflict markers

--

--combined-all-paths::

list the name of the file from all parents. It thus only has

effect when `--diff-merges=[dense-]combined` is in use, and

is likely only useful if filename changes are detected (i.e.

when either rename or copy detection have been requested).

endif::git-log[]

the usual three.

ifndef::git-format-patch[]

Implies `--patch`.

endif::git-format-patch[]

Output to a specific file instead of stdout.

Specify the character used to indicate new, old or context

' ' respectively.

ifndef::git-format-patch[]

ifndef::git-log[]

Generate the diff in raw format.

ifdef::git-diff-core[]

endif::git-format-patch[]

ifndef::git-format-patch[]

Synonym for `-p --raw`.

endif::git-format-patch[]

ifdef::git-log[]

Show the tree objects in the diff output.

endif::git-log[]

Enable the heuristic that shifts diff hunk boundaries to make patches

easier to read. This is the default.

Disable the indent heuristic.

Spend extra time to make sure the smallest possible

diff is produced.

Generate a diff using the "patience diff" algorithm.

Generate a diff using the "histogram diff" algorithm.

Generate a diff using the "anchored diff" algorithm.

+

This option may be specified more than once.

+

If a line exists in both the source and destination, exists only once,

appearing as a deletion or addition in the output. It uses the "patience

diff" algorithm internally.

Choose a diff algorithm. The variants are as follows:

+

--

The basic greedy diff algorithm. Currently, this is the default.

Spend extra time to make sure the smallest possible diff is

produced.

Use "patience diff" algorithm when generating patches.

This algorithm extends the patience algorithm to "support

low-occurrence common elements".

--

non-default value and want to use the default one, then you

have to use `--diff-algorithm=default` option.

Generate a diffstat. By default, as much space as necessary

will be used for the filename part, and the rest for the graph

part. Maximum width defaults to terminal width, or 80 columns

if not connected to a terminal, and can be overridden by

`--stat-graph-width` affects all commands generating a stat graph,

while setting `diff.statNameWidth` or `diff.statGraphWidth`

does not affect `git format-patch`.

+

These parameters can also be set individually with `--stat-width=<width>`,

`--stat-name-width=<name-width>` and `--stat-count=<count>`.

Output a condensed summary of extended header information such

or removing executable bit respectively) in diffstat. The

information is put between the filename part and the graph

part. Implies `--stat`.

Similar to `--stat`, but shows number of added and

deleted lines in decimal notation and pathname without

abbreviation, to make it more machine friendly. For

binary files, outputs two `-` instead of saying

`0 0`.

Output only the last line of the `--stat` format containing total

number of modified files, as well as number of added and deleted

lines.

Output the distribution of relative amount of changes for each

sub-directory. The behavior of `--dirstat` can be customized by

passing it a comma separated list of parameters.

Note that when using `cumulative`, the sum of the percentages

reported may exceed 100%. The default (non-cumulative) behavior can

be specified with the `noncumulative` parameter.

An integer parameter specifies a cut-off percent (3% by default).

Directories contributing less than this percentage of the changes

are not shown in the output.

and accumulating child directory counts in the parent directories:

`--dirstat=files,10,cumulative`.

Output a condensed summary of extended header information

such as creations, renames and mode changes.

ifndef::git-format-patch[]

Synonym for `-p --stat`.

endif::git-format-patch[]

ifndef::git-format-patch[]

ifdef::git-log[]

+

Also, when `--raw` or `--numstat` has been given, do not munge

endif::git-log[]

ifndef::git-log[]

When `--raw`, `--numstat`, `--name-only` or `--name-status` has been

explained for the configuration variable `core.quotePath` (see

linkgit:git-config[1]).

Show only the name of each changed file in the post-image tree.

The file names are often encoded in UTF-8.

For more information see the discussion about encoding in the linkgit:git-log[1]

manual page.

Show only the name(s) and status of each changed file. See the description

of the `--diff-filter` option on what the status letters mean.

Just like `--name-only` the file names are often encoded in UTF-8.

Specify how differences in submodules are shown. When specifying

shows the names of the commits at the beginning and end of the range.

format is used. This format lists the commits in the range like

linkgit:git-submodule[1] `summary` does. When `--submodule=diff`

inline diff of the changes in the submodule contents between the

if the config option is unset.

Show colored diff.

ifdef::git-diff[]

It can be changed by the `color.ui` and `color.diff`

configuration settings.

endif::git-diff[]

Turn off colored diff.

ifdef::git-diff[]

This can be used to override configuration settings.

endif::git-diff[]

It is the same as `--color=never`.

Moved lines of code are colored differently.

ifdef::git-diff[]

It can be changed by the `diff.colorMoved` configuration setting.

endif::git-diff[]

The mode must be one of:

+

--

Moved lines are not highlighted.

Is a synonym for `zebra`. This may change to a more sensible mode

in the future.

Any line that is added in one location and was removed

that are added somewhere else in the diff. This mode picks up any

moved line, but it is not very useful in a review to determine

if a block of code was moved without permutation.

Blocks of moved text of at least 20 alphanumeric characters

are detected greedily. The detected blocks are

Adjacent blocks cannot be told apart.

the two colors indicates that a new block was detected.

of moved code is performed. The bordering lines of two adjacent

blocks are considered interesting, the rest is uninteresting.

`dimmed_zebra` is a deprecated synonym.

--

Turn off move detection. This can be used to override configuration

settings. It is the same as `--color-moved=no`.

This configures how whitespace is ignored when performing the

move detection for `--color-moved`.

ifdef::git-diff[]

These modes can be given as a comma separated list:

+

--

Do not ignore whitespace when performing move detection.

Ignore changes in whitespace at EOL.

Ignore changes in amount of whitespace. This ignores whitespace

at line end, and considers all other sequences of one or

more whitespace characters to be equivalent.

Ignore whitespace when comparing lines. This ignores differences

even if one line has whitespace where the other line has none.

Initially ignore any whitespace in the move detection, then

group the moved code blocks only into a block if the change in

whitespace is the same per line. This is incompatible with the

other modes.

--

Do not ignore whitespace when performing move detection. This can be

used to override configuration settings. It is the same as

`--color-moved-ws=no`.

By default, words are delimited by whitespace; see

must be one of:

+

--

Highlight changed words using only colors. Implies `--color`.

attempts to escape the delimiters if they appear in the input,

so the output may be ambiguous.

Use a special line-based format intended for script

consumption. Added/removed/unchanged runs are printed in the

usual unified diff format, starting with a `+`/`-`/` `

character at the beginning of the line and extending to the

end of the line. Newlines in the input are represented by a

tilde `~` on a line of its own.

Disable word diff again.

--

+

Note that despite the name of the first mode, color is used to

highlight the changed parts in all modes if enabled.

runs of non-whitespace to be a word. Also implies

`--word-diff` unless it was already enabled.

+

Every non-overlapping match of the

considered whitespace and ignored(!) for the purposes of finding

differences. You may want to append `|[^[:space:]]` to your regular

expression to make sure that it matches all non-whitespace characters.

overrides any diff driver or configuration setting. Diff drivers

override configuration settings.

Equivalent to `--word-diff=color` plus (if a regex was

specified) `--word-diff-regex=<regex>`.

endif::git-format-patch[]

Turn off rename detection, even when the configuration

file gives the default to do so.

Whether to use empty blobs as rename source.

ifndef::git-format-patch[]

Warn if changes introduce conflict markers or whitespace errors.

What are considered whitespace errors is controlled by `core.whitespace`

configuration. By default, trailing whitespaces (including

that is immediately followed by a tab character inside the

initial indent of the line are considered whitespace errors.

Exits with non-zero status if problems are found. Not compatible

Highlight whitespace errors in the `context`, `old` or `new`

lines of the diff. Multiple values are separated by comma,

`none` resets previous values, `default` reset the list to

endif::git-format-patch[]

Instead of the first handful of characters, show the full

pre- and post-image blob object names on the "index"

line when generating patch format output.

In addition to `--full-index`, output a binary diff that

can be applied with `git-apply`.

ifndef::git-format-patch[]

Implies `--patch`.

endif::git-format-patch[]

Instead of showing the full 40-byte hexadecimal object

name in diff-raw format output and diff-tree header

hexdigits long that uniquely refers the object.

In diff-patch output format, `--full-index` takes higher

precedence, i.e. if `--full-index` is specified, full blob

names will be shown regardless of `--abbrev`.

Non default number of digits can be specified with `--abbrev=<n>`.

Break complete rewrite changes into pairs of delete and

create. This serves two purposes:

+

not as a series of deletion and insertion mixed together with a very

few lines that happen to match textually as the context, but as a

single deletion of everything old followed by a single insertion of

option (defaults to 60%). `-B/70%` specifies that less than 30% of the

original should remain in the result for Git to consider it a total

rewrite (i.e. otherwise the resulting patch will be a series of

deletion and insertion mixed together with context lines).

+

addition and deletion compared to 20% or more of the file's size are

eligible for being picked up as a possible source of a rename to

another file.

ifndef::git-log[]

Detect renames.

endif::git-log[]

For following files across renames while traversing history, see

`--follow`.

endif::git-log[]

index (i.e. amount of addition/deletions compared to the

file's size). For example, `-M90%` means Git should consider a

delete/add pair to be a rename if more than 90% of the file

the same as `-M5%`. To limit detection to exact renames, use

`-M100%`. The default similarity index is 50%.

Detect copies as well as renames. See also `--find-copies-harder`.

For performance reasons, by default, `-C` option finds copies only

if the original file of the copy was modified in the same

changeset. This flag makes the command

projects, so use it with caution. Giving more than one

`-C` option has the same effect.

Omit the preimage for deletes, i.e. print only the header but not

the diff between the preimage and `/dev/null`. The resulting patch

is not meant to be applied with `patch` or `git apply`; this is

When used together with `-B`, omit also the preimage in the deletion part

of a delete/create pair.

The `-M` and `-C` options involve some preliminary steps that

can detect subsets of renames/copies cheaply, followed by an

exhaustive fallback portion that compares all remaining

destinations, this exhaustive check is O(N^2). This option

prevents the exhaustive portion of rename/copy detection from

running if the number of source/destination files involved

Note that a value of 0 is treated as unlimited.

ifndef::git-format-patch[]

Select only files that are Added (`A`), Copied (`C`),

Deleted (`D`), Modified (`M`), Renamed (`R`), have their

type (i.e. regular file, symlink, submodule, ...) changed (`T`),

Note that not all diffs can feature all types. For instance, copied and

renamed entries cannot appear if detection for those types is disabled.

Look for differences that change the number of occurrences of

Intended for the scripter's use.

+

It is useful when you're looking for an exact block of code (like a

+

Binary files are searched as well.

Look for differences whose patch text contains added/removed

+

`-G<regex>`, consider a commit with the following diff in the same

file:

+

See the 'pickaxe' entry in linkgit:gitdiffcore[7] for more

information.

Look for differences that change the number of occurrences of

the specified object. Similar to `-S`, just the argument is different

in that it doesn't search for a specific string but for a specific

The object can be a blob or a submodule commit. It implies the `-t` option in

`git-log` to also find trees.

When `-S` or `-G` finds a change, show all the changes in that

changeset, not just the files that contain the change

expression to match.

endif::git-format-patch[]

Control the order in which files appear in the output.

This overrides the `diff.orderFile` configuration variable

(see linkgit:git-config[1]). To cancel `diff.orderFile`,

use `-O/dev/null`.

+

The output order is determined by the order of glob patterns in

All files with pathnames that match the first pattern are output

first, all files with pathnames that match the second pattern (but not

the first) are output next, and so on.

but no earlier patterns), their output order relative to each other is

the normal order.

+

+

--

- Blank lines are ignored, so they can be used as separators for

--

+

Patterns have the same syntax and semantics as patterns used for

matches a pattern if removing any number of the final pathname

components matches the pattern. For example, the pattern "`foo*bar`"

matches "`fooasdfbar`" and "`foo/bar/baz/asdf`" but not "`foobarx`".

(i.e. 'skip to'), or move them to the end of the output

(i.e. 'rotate to'). These options were invented primarily for the use

of the `git difftool` command, and may not be very useful

otherwise.

ifndef::git-format-patch[]

Swap two inputs; that is, show differences from index or

on-disk file to tree contents.

endif::git-format-patch[]

When run from a subdirectory of the project, it can be

told to exclude changes outside the directory and show

pathnames relative to it with this option. When you are

not in a subdirectory (e.g. in a bare repository), you

can name which subdirectory to make the output relative

`--no-relative` can be used to countermand both `diff.relative` config

option and previous `--relative`.

Treat all files as text.

Ignore carriage-return at the end of line when doing a comparison.

Ignore changes in whitespace at EOL.

Ignore changes in amount of whitespace. This ignores whitespace

at line end, and considers all other sequences of one or

more whitespace characters to be equivalent.

Ignore whitespace when comparing lines. This ignores

differences even if one line has whitespace where the other

line has none.

Ignore changes whose lines are all blank.

be specified more than once.

of lines, thereby fusing hunks that are close to each other.

Defaults to `diff.interHunkContext` or 0 if the config option

is unset.

Show whole function as context lines for each change.

The function names are determined in the same way as

ifndef::git-format-patch[]

ifndef::git-log[]

That is, it exits with 1 if there were differences and

0 means no differences.

Disable all output of the program. Implies `--exit-code`.

Disables execution of external diff helpers whose exit code

is not trusted, i.e. their respective configuration option

environment variable `GIT_EXTERNAL_DIFF_TRUST_EXIT_CODE` is

false.

endif::git-log[]

endif::git-format-patch[]

Allow an external diff helper to be executed. If you set an

external diff driver with linkgit:gitattributes[5], you need

to use this option with linkgit:git-log[1] and friends.

Disallow external diff drivers.

Allow (or disallow) external text conversion filters to be run

when comparing binary files. See linkgit:gitattributes[5] for

details. Because textconv filters are typically a one-way

linkgit:git-log[1], but not for linkgit:git-format-patch[1] or

diff plumbing commands.

in the superproject and can be used to override any settings of the

contain untracked content (but they are still scanned for modified

only changes to the commits stored in the superproject are shown (this was

Do not show any source or destination prefix.

Use the default source and destination prefixes ("a/" and "b/").

This overrides configuration variables such as `diff.noprefix`,

`diff.srcPrefix`, `diff.dstPrefix`, and `diff.mnemonicPrefix`

reverted with `--ita-visible-in-index`. Both options are

experimental and could be removed in future.

Deepen or shorten the history of a shallow repository to

include all reachable commits after <date>.

Deepen or shorten the history of a shallow repository to

exclude commits reachable from a specified remote branch or tag.

This option can be specified multiple times.

`badParentSha1`::

(ERROR) A commit object has a bad parent sha1.

`badRefFiletype`::

(ERROR) A ref has a bad file type.

`badRefName`::

(ERROR) A ref has an invalid format.

`badTagName`::

(INFO) A tag has an invalid format.

`nullSha1`::

(WARN) Tree contains entries pointing to a null sha1.

`treeNotSorted`::

(ERROR) A tree is not properly sorted.

SYNOPSIS

--------

DESCRIPTION

-----------

ignored files were explicitly specified on the command line, `git add`

will fail with a list of ignored files. Ignored files reached by

directory recursion or filename globbing performed by Git (quote your

be used to add ignored files with the `-f` (force) option.

Please see linkgit:git-commit[1] for alternative ways to add content to a

OPTIONS

-------

Files to add content from. Fileglobs (e.g. `*.c`) can

be given to add all matching files. Also a

leading directory name (e.g. `dir` to add `dir/file1`

For more details about the _<pathspec>_ syntax, see the 'pathspec' entry

in linkgit:gitglossary[7].

Don't actually add the file(s), just show if they exist and/or will

be ignored.

Be verbose.

Allow adding otherwise ignored files.

Allow updating index entries outside of the sparse-checkout cone.

Normally, `git add` refuses to update index entries whose paths do

not fit within the sparse-checkout cone, since those files might

be removed from the working tree without warning. See

linkgit:git-sparse-checkout[1] for more details.

Add modified contents in the working tree interactively to

the index. Optional path arguments may be supplied to limit

operation to a subset of the working tree. See ``Interactive

mode'' for details.

Interactively choose hunks of patch between the index and the

work tree and add them to the index. This gives the user a chance

to review the difference before adding modified contents to the

initial command menu and directly jumps to the `patch` subcommand.

See ``Interactive mode'' for details.

Open the diff vs. the index in an editor and let the user

edit it. After the editor was closed, adjust the hunk headers

and apply the patch to the index.

However, it is easy to confuse oneself and create a patch that does not

apply to the index. See EDITING PATCHES below.

Update the index just where it already has an entry matching

_<pathspec>_. This removes as well as modifies index entries to

match the working tree, but adds no new files.

of Git used to limit the update to the current directory and its

subdirectories).

Update the index not only where the working tree has a file

matching _<pathspec>_ but also where the index already has an

entry. This adds, modifies, and removes index entries to

of Git used to limit the update to the current directory and its

subdirectories).

Update the index by adding new files that are unknown to the

index and files modified in the working tree, but ignore

files that have been removed from the working tree. This

option is a no-op when no _<pathspec>_ is used.

+

This option is primarily to help users who are used to older

Record only the fact that the path will be added later. An entry

for the path is placed in the index with no content. This is

useful for, among other things, showing the unstaged content of

such files with `git diff` and committing them with `git commit

-a`.

Don't add the file(s), but only refresh their stat()

information in the index.

If some files could not be added because of errors indexing

them, do not abort the operation, but continue adding the

others. The command shall still exit with non-zero status.

The configuration variable `add.ignoreErrors` can be set to

true to make this the default behaviour.

this option the user can check if any of the given files would

be ignored, no matter if they are already present in the work

tree or not.

By default, `git add` will warn when adding an embedded

repository to the index without using `git submodule add` to

create an entry in `.gitmodules`. This option will suppress the

warning (e.g., if you are manually performing operations on

submodules).

Apply the "clean" process freshly to all tracked files to

forcibly add them again to the index. This is useful after

changing `core.autocrlf` configuration or the `text` attribute

This option implies `-u`. Lone CR characters are untouched, thus

Override the executable bit of the added files. The executable

bit is only changed in the index, the files on disk are left

unchanged.

Pathspec is passed in _<file>_ instead of commandline args. If

_<file>_ is exactly `-` then standard input is used. Pathspec

quoted as explained for the configuration variable `core.quotePath`

(see linkgit:git-config[1]). See also `--pathspec-file-nul` and

global `--literal-pathspecs`.

Only meaningful with `--pathspec-from-file`. Pathspec elements are

literally (including newlines and quotes).

This option can be used to separate command-line options from

the list of files, (useful when filenames might be mistaken

for command-line options).

EXAMPLES

--------

and its subdirectories:

+

------------

$ git add Documentation/\*.txt

------------

+

example; this lets the command include the files from

subdirectories of `Documentation/` directory.

+

------------

$ git add git-*.sh

status::

committed if you say `git commit`), and between index and

working tree files (i.e. what you could stage further before

`git commit` using `git add`) for each path. A sample output

2: +403/-35 +1/-1 add-interactive.c

------------

+

binary so line count cannot be shown) and there is no

difference between indexed copy and the working tree

version (if the working tree version were also different,

'binary' would have been shown in place of 'nothing'). The

and 35 lines deleted if you commit what is in the index, but

working tree file has further modifications (one addition and

one deletion).

diff::

This lets you review what will be committed (i.e. between

EDITING PATCHES

that because the patch is applied only to the index and not the working

tree, the working tree will appear to "undo" the change in the index.

For example, introducing a new line into the index that is in neither

the line will appear to be reverted in the working tree.

Avoid using these constructs, or do so with extreme caution.

include::includes/cmd-config-section-all.txt[]

include::config/add.txt[]

SEE ALSO

sitting on the other side of the network connection.

They can be used to create both incremental and full backups of a

Git commands that fetch or otherwise "read" via protocols such as

`ssh://` and `https://` can also operate on bundle files. It is

possible linkgit:git-clone[1] a new repository from a bundle, to use

linkgit:git-fetch[1] to fetch from one, and to list the references

contained within it with linkgit:git-ls-remote[1]. There's no

supported.

BUNDLE FORMAT

-------------

---------------------

Revisions must be accompanied by reference names to be packaged in a

More than one reference may be packaged, and more than one set of prerequisite objects can

be specified. The objects packaged are those not contained in the

to contain objects already in the destination, as these are ignored

when unpacking at the destination.

If you want to provide the same set of refs that a clone directly

from the source repository would get, use `--branches --tags` for

the `<git-rev-list-args>`.

EXAMPLES

--------

For whatever reason, direct connection between A and B is not allowed,

but we can move data from A to B via some mechanism (CD, email, etc.).

We want to update R2 with development made on the branch master in R1.

$ git ls-remote mybundle

----------------

FILE FORMAT

-----------

prevent the unintentional copying of files by dereferencing the symbolic

links.

+

*NOTE*: this operation can race with concurrent modification to the

source repository, similar to running `cp -r <src> <dst>` while modifying

_<src>_.

`--shallow-since=<date>`::

Create a shallow clone with a history after the specified time.

Create a shallow clone with a history, excluding commits

reachable from a specified remote branch or tag. This option

can be specified multiple times.

$ git clone --bare -l /home/proj/.git /pub/scm/proj.git

------------

CONFIGURATION

-------------

SYNOPSIS

--------

DESCRIPTION

-----------

from a merge, changes between two blob objects, or changes between two

files on disk.

This form is to view the changes you made relative to

the index (staging area for the next commit). In other

further add to the index but you still haven't. You can

stage these changes by using linkgit:git-add[1].

This form is to compare the given two paths on the

filesystem. You can omit the `--no-index` option when

or when running the command outside a working tree

controlled by Git. This form implies `--exit-code`.

This form is to view the changes you staged for the next

would want comparison with the latest commit, so if you

+

`git diff --cached $(git merge-base A HEAD)`.

This form is to view the changes you have in your

branch name to compare with the tip of a different

branch.

+

`git diff $(git merge-base A HEAD)`.

This is to view the changes between two arbitrary

+

"before" side. `git diff --merge-base A B` is equivalent to

`git diff $(git merge-base A B) B`.

This form is to view the results of a merge commit. The first

more commits should be its parents. Convenient ways to produce

`git diff A^!` and `git show A` all give the same combined diff.

This is synonymous to the earlier form (without the `..`) for

one side is omitted, it will have the same effect as

This form is to view the changes on the branch containing

`git diff $(git merge-base A B) B`. You can omit any one

Just in case you are doing something exotic, it should be

in the `--merge-base` case and in the last two forms that use `..`

strategy upon hitting merge conflicts (see linkgit:git-merge[1]).

Comparing the working tree with `AUTO_MERGE` shows changes you've made

so far to resolve textual conflicts (see the examples below).

"SPECIFYING REVISIONS" section in linkgit:gitrevisions[7].

"SPECIFYING RANGES" section in linkgit:gitrevisions[7].

This form is to view the differences between the raw

contents of two blob objects.

:git-diff: 1

include::diff-options.txt[]

Omit diff output for unmerged entries and just show

"Unmerged". Can be used only when comparing the working tree

with the index.

the diff to the named paths (you can give directory

names and get diff for all files under them).

include::includes/cmd-config-section-all.txt[]

include::config/diff.txt[]

SEE ALSO

--------

linkgit:git-difftool[1],

linkgit:git-log[1],

linkgit:gitdiffcore[7],

Deepen or shorten the history of a shallow repository to

include all reachable commits after <date>.

Deepen or shorten the history of a shallow repository to

exclude commits reachable from a specified remote branch or tag.

This option can be specified multiple times.

written. If a `<message>` is provided, then that content will be

written to the .promisor file for future reference. See

link:technical/partial-clone.html[partial clone] for more information.

NOTES

-----

ref does not exist before the update.

create::

exist. The given <new-oid> may not be zero.

delete::

given. If given, <old-oid> may not be zero.

symref-update::

<old-oid> is zero or missing, the ref must not exist.

symref-create:

it does not exist.

symref-delete::

symref-verify::

Verify symbolic <ref> against <old-target> but do not change it.

This can also be set up as the default behaviour by using the

`worktree.guessRemote` config option.

--[no-]track::

When creating a new branch, if `<commit-ish>` is a branch,

mark it as "upstream" from the new branch. This is the

for long options. An option that takes optional option-argument must be

written in the 'stuck' form.

* When you give a revision parameter to a command, make sure the parameter is

not ambiguous with a name of a file in the work tree. E.g. do not write

`git log -1 HEAD` but write `git log -1 HEAD --`; the former will not work

[credential]

helper = "foo --bar='whitespace arg'"

# you can also use an absolute path, which will not use the git wrapper

[credential]

helper = "/path/to/my/helper --with-arguments"

--------

linkgit:git-init[1],

linkgit:git-clone[1],

linkgit:git-fetch[1],

linkgit:git-pack-refs[1],

linkgit:git-gc[1],

that each contain very well defined concepts or small incremental yet

related changes.

[[def_tree]]tree::

Either a <<def_working_tree,working tree>>, or a <<def_tree_object,tree

object>> together with the dependent <<def_blob_object,blob>> and tree objects

--ancestry-path[=<commit>]::

When given a range of commits to display (e.g. 'commit1..commit2'

that are ancestors of <commit>, descendants of <commit>, or

<commit> itself. If no commit is specified, use 'commit1' (the

excluded part of the range) as <commit>. Can be passed multiple

Repository format extension

~~~~~~~~~~~~~~~~~~~~~~~~~~~

A SHA-256 repository uses repository format version `1` (see

[core]

repositoryFormatVersion = 1

- On the client a repository extension is added to the local config to

prevent older versions of git from failing mid-operation because of

missing objects that they cannot handle.

Handling Missing Objects

provides no benefit, and makes the repository incompatible with older

implementations of git).

- A POSIX-compliant shell is required to run some scripts needed

for everyday use (e.g. "bisect", "request-pull").

features (e.g. sending patches using "git send-email",

interacting with svn repositories with "git svn"). If you can

live without these, use NO_PERL. Note that recent releases of

itself, e.g. Digest::MD5, File::Spec, File::Temp, Net::Domain,

Net::SMTP, and Time::HiRes.

- "libcurl" library is used for fetching and pushing

repositories over http:// or https://, as well as by

without NO_CURL. This version requirement may be bumped in

the future.

FUZZ_OBJS += oss-fuzz/dummy-cmd-main.o

FUZZ_OBJS += oss-fuzz/fuzz-commit-graph.o

FUZZ_OBJS += oss-fuzz/fuzz-config.o

FUZZ_OBJS += oss-fuzz/fuzz-date.o

FUZZ_OBJS += oss-fuzz/fuzz-pack-headers.o

FUZZ_OBJS += oss-fuzz/fuzz-pack-idx.o

.PHONY: fuzz-objs

fuzz-objs: $(FUZZ_OBJS)

REFTABLE_OBJS += reftable/reader.o

REFTABLE_OBJS += reftable/record.o

REFTABLE_OBJS += reftable/stack.o

REFTABLE_OBJS += reftable/tree.o

REFTABLE_OBJS += reftable/writer.o

echo "$$FLAGS" >GIT-TEST-SUITES; \

fi

$(UNIT_TEST_DIR)/clar/clar.o: $(UNIT_TEST_DIR)/clar.suite

$(CLAR_TEST_OBJS): $(UNIT_TEST_DIR)/clar-decls.h

$(CLAR_TEST_OBJS): EXTRA_CPPFLAGS = -I$(UNIT_TEST_DIR)

static const char turn_off_instructions[] =

N_("\n"

static void vadvise(const char *advice, int display_instructions,

const char *key, va_list params)

return git_attr_internal(name, strlen(name));

}

static const char blank[] = " \t\r\n";

/* Flags usable in read_attr() and parse_attr_line() family of functions. */

return ep + strspn(ep, blank);

}

{

size_t namelen, num_attr, i;

const char *cp, *name, *states;

extern char *git_attr_tree;

#endif /* ATTR_H */

best->next = NULL;

}

*reaches = weight(best);

}

*commit_list = best;

*/

int validate_branchname(const char *name, struct strbuf *ref)

{

int code = die_message(_("'%s' is not a valid branch name"), name);

advise_if_enabled(ADVICE_REF_SYNTAX,

_("See `man git check-ref-format`"));

else

msg = xstrfmt("branch: Created from %s", start_name);

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction ||

ref_transaction_update(transaction, ref.buf,

&oid, forcing ? NULL : null_oid(),

return res;

}

{

if (argc > 1)

return error(_("'%s' requires either no argument or a commit"),

return bisect_reset(argc ? argv[0] : NULL);

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

return bisect_log();

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

return res;

}

{

int res;

struct bisect_terms terms = { 0 };

int cmd_bisect(int argc,

const char **argv,

const char *prefix,

{

int res = 0;

parse_opt_subcommand_fn *fn = NULL;

} else {

argc--;

argv++;

}

return is_bisect_success(res) ? 0 : -res;

char *target = NULL;

int flags = 0;

free(name);

name = mkpathdup(fmt, bname.buf);

int recovery = 0, oldref_usage = 0;

struct worktree **worktrees = get_worktrees();

/*

* Bad name --- this could be an attempt to rename a

* ref that we used to allow to be created by accident.

die(_("cannot give description to detached HEAD"));

branch_name = head;

} else if (argc == 1) {

branch_name = buf.buf;

} else {

die(_("cannot edit description of more than one branch"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to set new upstream"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to unset upstream"));

return argc;

}

struct strvec pack_opts = STRVEC_INIT;

int version = -1;

int ret;

return read_bundle_header(path, header);

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int quiet = 0;

return ret;

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int ret;

return ret;

}

struct bundle_header header = BUNDLE_HEADER_INIT;

int bundle_fd = -1;

int ret;

strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",

_("Unbundling objects"), NULL);

ret = !!unbundle(the_repository, &header, bundle_fd,

list_bundle_refs(&header, argc, argv);

bundle_header_release(&header);

int cmd_bundle(int argc,

const char **argv,

const char *prefix,

{

parse_opt_subcommand_fn *fn = NULL;

struct option options[] = {

packet_trace_identity("bundle");

}

cb.seen = &seen;

for_each_loose_object(batch_unordered_loose, &cb, 0);

oidset_clear(&seen);

} else {

struct oid_array sa = OID_ARRAY_INIT;

for_each_loose_object(collect_loose_object, &sa, 0);

oid_array_for_each_unique(&sa, batch_object_cb, &cb);

int nongit;

setup_git_directory_gently(&nongit);

!skip_prefix(sb.buf, "refs/heads/", &name))

die("'%s' is not a valid branch name", arg);

printf("%s\n", name);

&branch->oid, &branch->refname, 0))

repo_get_oid_committish(the_repository, branch->name, &branch->oid);

if (strcmp(buf.buf, branch->name)) {

free(branch->name);

branch->name = xstrdup(buf.buf);

N_("create a shallow clone of that depth")),

OPT_STRING(0, "shallow-since", &option_since, N_("time"),

N_("create a shallow clone since a specific time")),

OPT_BOOL(0, "single-branch", &option_single_branch,

N_("clone only one branch, HEAD or --branch")),

OPT_BOOL(0, "no-tags", &option_no_tags,

struct strbuf err = STRBUF_INIT;

t = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!t)

die("%s", err.buf);

die("%s", err.buf);

}

die("%s", err.buf);

strbuf_release(&err);

return parse_options_concat(common_opts, to);

}

{

struct commit_graph *graph = NULL;

struct object_directory *odb = NULL;

return 0;

}

{

struct string_list pack_indexes = STRING_LIST_INIT_DUP;

struct strbuf buf = STRBUF_INIT;

int cmd_commit_graph(int argc,

const char **argv,

const char *prefix,

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_commit_graph_options[] = {

builtin_commit_graph_usage, 0);

FREE_AND_NULL(options);

}

}

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

return 0;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

const char *value_pattern = NULL, *comment_arg = NULL;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

const char *value_pattern = NULL;

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

return ret;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

return 0;

}

{

struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

struct option opts[] = {

int cmd_config(int argc,

const char **argv,

const char *prefix,

{

parse_opt_subcommand_fn *subcommand = NULL;

struct option subcommand_opts[] = {

if (subcommand) {

argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,

PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_UNKNOWN_OPT);

}

return cmd_config_actions(argc, argv, prefix);

else {

loose_size += on_disk_bytes(st);

loose++;

packed_loose++;

}

return 0;

struct commit_name **slot;

seen_commits++;

slot = commit_names_peek(&commit_names, c);

n = slot ? *slot : NULL;

if (n) {

if (n->prio == 2)

annotated_cnt++;

}

}

for (cur_match = 0; cur_match < match_cnt; cur_match++) {

struct possible_tag *t = &all_matches[cur_match];

fprintf(stderr, _("traversed %lu commits\n"), seen_commits);

if (gave_up_on) {

fprintf(stderr,

oid_to_hex(&gave_up_on->object.oid));

}

}

struct checkout lstate, rstate;

int err = 0;

struct child_process cmd = CHILD_PROCESS_INIT;

int indices_loaded = 0;

workdir = repo_get_work_tree(the_repository);

* in the common case of --symlinks and the difftool updating

* files through the symlink.

*/

for (i = 0; i < wtindex.cache_nr; i++) {

struct hashmap_entry dummy;

const char *name = wtindex.cache[i]->name;

#include "delta.h"

#include "pack.h"

#include "path.h"

#include "refs.h"

#include "csum-file.h"

#include "quote.h"

static int failure;

static FILE *pack_edges;

static unsigned int show_stats = 1;

static int global_argc;

static const char **global_argv;

static const char *global_prefix;

p->pack_fd = pack_fd;

p->do_not_close = 1;

pack_file = hashfd(pack_fd, p->pack_name);

pack_data = p;

struct strbuf name = STRBUF_INIT;

int keep_fd;

keep_fd = odb_pack_keep(name.buf);

if (keep_fd < 0)

die_errno("cannot create keep file");

if (close(keep_fd))

die_errno("failed to write keep file");

if (finalize_object_file(pack_data->pack_name, name.buf))

die("cannot store pack file");

if (finalize_object_file(curr_index_name, name.buf))

die("cannot store index file");

free((void *)curr_index_name);

for (k = 0; k < pack_id; k++) {

struct packed_git *p = all_packs[k];

unlink_or_warn(name.buf);

}

strbuf_release(&name);

idx_name = keep_pack(create_index());

/* Register the packfile with core git's machinery. */

if (!new_p)

die("core git rejected index %s", idx_name);

all_packs[pack_id] = new_p;

struct ref_transaction *transaction;

struct object_id old_oid;

struct strbuf err = STRBUF_INIT;

if (is_null_oid(&b->oid)) {

if (b->delete)

refs_delete_ref(get_main_ref_store(the_repository),

}

}

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction ||

ref_transaction_update(transaction, b->name, &b->oid, &old_oid,

NULL, NULL, 0, msg, &err) ||

struct ref_transaction *transaction;

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

failure |= error("%s", err.buf);

goto cleanup;

tree_content_replace(&b->branch_tree, &oid, mode, NULL);

return;

}

tree_content_set(&b->branch_tree, path.buf, &oid, mode, NULL);

}

leaf.tree);

return;

}

tree_content_set(&b->branch_tree, dest.buf,

&leaf.versions[1].oid,

leaf.versions[1].mode,

option_export_pack_edges(option);

} else if (!strcmp(option, "quiet")) {

show_stats = 0;

} else if (!strcmp(option, "stats")) {

show_stats = 1;

} else if (!strcmp(option, "allow-unsafe-features")) {

int cmd_fast_import(int argc,

const char **argv,

const char *prefix,

{

unsigned int i;

fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)((tree_entry_allocd + fi_mem_pool.pool_alloc) /1024));

fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "\n");

}

ref_namespace[NAMESPACE_TAGS].ref))) {

int j;

rs->items[j - 1] = rs->items[j];

rs->nr--;

i--;

continue;

*/

if (!transaction) {

transaction = our_transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

ret = STORE_REF_ERROR_OTHER;

goto out;

if (atomic_fetch) {

transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),

if (!transaction) {

retcode = -1;

goto cleanup;

N_("deepen history of shallow clone")),

OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),

N_("deepen history of shallow repository based on time")),

OPT_INTEGER(0, "deepen", &deepen_relative,

N_("deepen history of shallow clone")),

OPT_SET_INT_F(0, "unshallow", &unshallow,

return 0;

obj->flags |= REACHABLE;

/*

* Further recursion does not need to be performed on this

* object since it is a promisor object (so it does not need to

* do a full fsck

*/

if (!(obj->flags & HAS_OBJ)) {

return;

return; /* it is in pack - forget about it */

printf_ln(_("missing %s %s"),

printable_type(&obj->oid, obj->type),

* traversal.

*/

for_each_loose_object(mark_loose_unreachable_referents, NULL, 0);

}

/* Look up all the requirements, warn about missing objects.. */

refname, timestamp);

obj->flags |= USED;

mark_object_reachable(obj);

error(_("%s: invalid reflog entry %s"),

refname, oid_to_hex(oid));

errors_found |= ERROR_REACHABLE;

obj = parse_object(the_repository, oid);

if (!obj) {

/*

* Increment default_refs anyway, because this is a

* valid ref.

if (connectivity_only) {

for_each_loose_object(mark_loose_for_connectivity, NULL, 0);

} else {

prepare_alt_odb(the_repository);

for (odb = the_repository->objects->odb; odb; odb = odb->next)

&oid);

if (!obj || !(obj->flags & HAS_OBJ)) {

continue;

error(_("%s: object missing"), oid_to_hex(&oid));

errors_found |= ERROR_OBJECT;

char *repack_filter_to;

unsigned long big_pack_threshold;

unsigned long max_delta_cache_size;

};

#define GC_CONFIG_INIT { \

.prune_expire = xstrdup("2.weeks.ago"), \

.prune_worktrees_expire = xstrdup("3.months.ago"), \

.max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE, \

}

static void gc_config_release(struct gc_config *cfg)

{

const char *value;

char *owned = NULL;

if (!git_config_get_value("gc.packrefs", &value)) {

if (value && !strcmp(value, "notbare"))

git_config_get_ulong("gc.bigpackthreshold", &cfg->big_pack_threshold);

git_config_get_ulong("pack.deltacachesize", &cfg->max_delta_cache_size);

if (!git_config_get_string("gc.repackfilter", &owned)) {

free(cfg->repack_filter);

cfg->repack_filter = owned;

* read_sha1_file() (either at delta calculation phase, or

* writing phase) also fills up the delta base cache

*/

/* and of course pack-objects has its own delta cache */

heap += cfg->max_delta_cache_size;

return 0;

}

{

int i;

struct maintenance_run_opts opts = MAINTENANCE_RUN_OPTS_INIT;

NULL

};

{

char *config_file = NULL;

struct option options[] = {

NULL

};

{

int force = 0;

char *config_file = NULL;

char *lock_path = xstrfmt("%s/schedule", the_repository->objects->odb->path);

if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

free(lock_path);

}

for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) {

NULL

};

{

struct maintenance_start_opts opts = { 0 };

struct option options[] = {

if (update_background_schedule(&opts, 1))

die(_("failed to set up maintenance schedule"));

warning(_("failed to add repo to global config"));

return 0;

}

NULL

};

{

struct option options[] = {

OPT_END()

int cmd_maintenance(int argc,

const char **argv,

const char *prefix,

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_maintenance_options[] = {

argc = parse_options(argc, argv, prefix, builtin_maintenance_options,

builtin_maintenance_usage, 0);

}

NULL

};

{

int i;

struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;

int cmd_hook(int argc,

const char **argv,

const char *prefix,

{

parse_opt_subcommand_fn *fn = NULL;

struct option builtin_hook_options[] = {

argc = parse_options(argc, argv, NULL, builtin_hook_options,

builtin_hook_usage, 0);

}

#include "csum-file.h"

#include "blob.h"

#include "commit.h"

#include "tree.h"

#include "progress.h"

#include "fsck.h"

#include "object-file.h"

#include "object-store-ll.h"

#include "oid-array.h"

#include "replace-object.h"

#include "promisor-remote.h"

#include "setup.h"

static const char index_pack_usage[] =

"git index-pack [-v] [-o <index-file>] [--keep | --keep=<msg>] [--[no-]rev-index] [--verify] [--strict[=<msg-id>=<severity>...]] [--fsck-objects[=<msg-id>=<severity>...]] (<pack-file> | --stdin [--fix-thin] [<pack-file>])";

static size_t base_cache_used;

static size_t base_cache_limit;

pthread_t thread;

int pack_fd;

};

static struct object_stat *obj_stat;

static struct ofs_delta_entry *ofs_deltas;

static struct ref_delta_entry *ref_deltas;

static int nr_objects;

static int nr_ofs_deltas;

static int nr_ref_deltas;

static int input_fd, output_fd;

static const char *curr_pack;

static int nr_dispatched;

static int threads_active;

(uintmax_t)offset, buf);

}

{

if (HAVE_THREADS) {

if (threads_active)

return &nothread_data;

}

{

if (threads_active)

pthread_setspecific(key, data);

return 0;

}

static void sha1_object(const void *data, struct object_entry *obj_entry,

unsigned long size, enum object_type type,

const struct object_id *oid)

free(has_data);

}

read_lock();

if (type == OBJ_BLOB) {

struct blob *blob = lookup_blob(the_repository, oid);

die(_("fsck error in packed object"));

if (strict && fsck_walk(obj, NULL, &fsck_options))

die(_("Not all child objects of %s are reachable"), oid_to_hex(&obj->oid));

if (obj->type == OBJ_TREE) {

struct tree *item = (struct tree *) obj;

* recursively checking if the resulting object is used as a base

* for some more deltas.

*/

{

int i;

nr_ref_deltas + nr_ofs_deltas);

nr_dispatched = 0;

if (nr_threads > 1 || getenv("GIT_FORCE_THREADS")) {

init_thread();

work_lock();

if (pack_name)

filename = derive_filename(pack_name, "pack", suffix, &name_buf);

else

fd = odb_pack_keep(filename);

if (fd < 0) {

{

if (!*final_name || strcmp(*final_name, curr_name)) {

if (!*final_name)

if (finalize_object_file(curr_name, *final_name))

die(_("unable to rename temporary '*.%s' file to '%s'"),

ext, *final_name);

if (do_fsck_object) {

struct packed_git *p;

if (p)

install_packed_git(the_repository, p);

}

else

opts->flags &= ~WRITE_REV;

}

return git_default_config(k, v, ctx, cb);

}

static void read_idx_option(struct pack_idx_option *opts, const char *pack_name)

{

if (!p)

die(_("Cannot open existing pack file '%s'"), pack_name);

free(chain_histogram);

}