+# Avoid unnecessary builds. Unlike the main CI jobs, these are not

+# ci-configurable (but could be).

+concurrency:

+ group: ${{ github.workflow }}-${{ github.ref }}

+ cancel-in-progress: true

+

+ - uses: actions/checkout@v3

+ baseSha=${{github.event.pull_request.base.sha}}

+ problems=()

+ commitText=

+ commitTextmd=

+ goodparent=

+ while read dash sha etc

+ if test -z "${commit}"

+ then

+ goodparent=${sha}

+ fi

+ commit="${sha}"

+ commitText="${sha} ${etc}"

+ commitTextmd="[${sha}](https://github.com/${{ github.repository }}/commit/${sha}) ${etc}"

+ problems+=("1) --- ${commitTextmd}")

+ echo "--- ${commitText}"

+ commit=

+ case "${dash}" in

+ *:[1-9]*:) # contains file and line number information

+ dashend=${dash#*:}

+ problems+=("[${dash}](https://github.com/${{ github.repository }}/blob/${{github.event.pull_request.head.ref}}/${dash%%:*}#L${dashend%:}) ${sha} ${etc}")

+ ;;

+ *)

+ problems+=("\`${dash} ${sha} ${etc}\`")

+ ;;

+ esac

+ echo "${dash} ${sha} ${etc}"

+ done <<< $(git log --check --pretty=format:"---% h% s" ${baseSha}..)

+ if test ${#problems[*]} -gt 0

+ if test -z "${commit}"

+ then

+ goodparent=${baseSha: 0:7}

+ fi

+ echo "🛑 Please review the Summary output for further information."

+ echo "### :x: A whitespace issue was found in one or more of the commits." >$GITHUB_STEP_SUMMARY

+ echo "" >>$GITHUB_STEP_SUMMARY

+ echo "Run these commands to correct the problem:" >>$GITHUB_STEP_SUMMARY

+ echo "1. \`git rebase --whitespace=fix ${goodparent}\`" >>$GITHUB_STEP_SUMMARY

+ echo "1. \`git push --force\`" >>$GITHUB_STEP_SUMMARY

+ echo " " >>$GITHUB_STEP_SUMMARY

+ echo "Errors:" >>$GITHUB_STEP_SUMMARY

+ for i in "${problems[@]}"

+ do

+ echo "${i}" >>$GITHUB_STEP_SUMMARY

+ done

+

+# Avoid unnecessary builds. Unlike the main CI jobs, these are not

+# ci-configurable (but could be).

+concurrency:

+ group: ${{ github.workflow }}-${{ github.ref }}

+ cancel-in-progress: true

+

+ skip_concurrent: ${{ steps.check-ref.outputs.skip_concurrent }}

+

+ skip_concurrent=yes

+ if test -x config-repo/ci/config/skip-concurrent &&

+ ! config-repo/ci/config/skip-concurrent '${{ github.ref }}'

+ then

+ skip_concurrent=no

+ fi

+ echo "skip_concurrent=$skip_concurrent" >>$GITHUB_OUTPUT

+ concurrency:

+ group: windows-build-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ needs: [ci-config, windows-build]

+ concurrency:

+ group: windows-test-${{ matrix.nr }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ if: github.event.repository.owner.login == 'git-for-windows' && needs.ci-config.outputs.enabled == 'yes'

+ concurrency:

+ group: vs-build-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ needs: [ci-config, vs-build]

+ concurrency:

+ group: vs-test-${{ matrix.nr }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: ${{ matrix.vector.jobname }}-${{ matrix.vector.pool }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ - name: print test failures

+ run: ci/print-test-failures.sh

+ concurrency:

+ group: dockerized-${{ matrix.vector.jobname }}-${{ matrix.vector.image }}-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ - name: print test failures

+ run: ci/print-test-failures.sh

+ concurrency:

+ group: static-analysis-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: sparse-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ concurrency:

+ group: documentation-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+Git v2.30.7 Release Notes

+=========================

+

+This release addresses the security issues CVE-2022-41903 and

+CVE-2022-23521.

+

+

+Fixes since v2.30.6

+-------------------

+

+ * CVE-2022-41903:

+

+ git log has the ability to display commits using an arbitrary

+ format with its --format specifiers. This functionality is also

+ exposed to git archive via the export-subst gitattribute.

+

+ When processing the padding operators (e.g., %<(, %<|(, %>(,

+ %>>(, or %><( ), an integer overflow can occur in

+ pretty.c::format_and_pad_commit() where a size_t is improperly

+ stored as an int, and then added as an offset to a subsequent

+ memcpy() call.

+

+ This overflow can be triggered directly by a user running a

+ command which invokes the commit formatting machinery (e.g., git

+ log --format=...). It may also be triggered indirectly through

+ git archive via the export-subst mechanism, which expands format

+ specifiers inside of files within the repository during a git

+ archive.

+

+ This integer overflow can result in arbitrary heap writes, which

+ may result in remote code execution.

+

+* CVE-2022-23521:

+

+ gitattributes are a mechanism to allow defining attributes for

+ paths. These attributes can be defined by adding a `.gitattributes`

+ file to the repository, which contains a set of file patterns and

+ the attributes that should be set for paths matching this pattern.

+

+ When parsing gitattributes, multiple integer overflows can occur

+ when there is a huge number of path patterns, a huge number of

+ attributes for a single pattern, or when the declared attribute

+ names are huge.

+

+ These overflows can be triggered via a crafted `.gitattributes` file

+ that may be part of the commit history. Git silently splits lines

+ longer than 2KB when parsing gitattributes from a file, but not when

+ parsing them from the index. Consequentially, the failure mode

+ depends on whether the file exists in the working tree, the index or

+ both.

+

+ This integer overflow can result in arbitrary heap reads and writes,

+ which may result in remote code execution.

+

+Credit for finding CVE-2022-41903 goes to Joern Schneeweisz of GitLab.

+An initial fix was authored by Markus Vervier of X41 D-Sec. Credit for

+finding CVE-2022-23521 goes to Markus Vervier and Eric Sesterhenn of X41

+D-Sec. This work was sponsored by OSTIF.

+

+The proposed fixes have been polished and extended to cover additional

+findings by Patrick Steinhardt of GitLab, with help from others on the

+Git security mailing list.

+

+Patrick Steinhardt (21):

+ attr: fix overflow when upserting attribute with overly long name

+ attr: fix out-of-bounds read with huge attribute names

+ attr: fix integer overflow when parsing huge attribute names

+ attr: fix out-of-bounds write when parsing huge number of attributes

+ attr: fix out-of-bounds read with unreasonable amount of patterns

+ attr: fix integer overflow with more than INT_MAX macros

+ attr: harden allocation against integer overflows

+ attr: fix silently splitting up lines longer than 2048 bytes

+ attr: ignore attribute lines exceeding 2048 bytes

+ attr: ignore overly large gitattributes files

+ pretty: fix out-of-bounds write caused by integer overflow

+ pretty: fix out-of-bounds read when left-flushing with stealing

+ pretty: fix out-of-bounds read when parsing invalid padding format

+ pretty: fix adding linefeed when placeholder is not expanded

+ pretty: fix integer overflow in wrapping format

+ utf8: fix truncated string lengths in `utf8_strnwidth()`

+ utf8: fix returning negative string width

+ utf8: fix overflow when returning string width

+ utf8: fix checking for glyph width in `strbuf_utf8_replace()`

+ utf8: refactor `strbuf_utf8_replace` to not rely on preallocated buffer

+ pretty: restrict input lengths for padding and wrapping formats

+

+Git v2.31.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.32.5 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+

+In addition, included are additional code for "git fsck" to check

+for questionable .gitattributes files.

+Git v2.33.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.34.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.35.6 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.36.4 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.37.5 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.38.3 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.39.1 Release Notes

+=========================

+

+This release merges the security fix that appears in v2.30.7; see

+the release notes for that version for details.

+Git v2.40 Release Notes

+=======================

+

+UI, Workflows & Features

+

+ * "merge-tree" learns a new `--merge-base` option.

+

+ * "git jump" (in contrib/) learned to present the "quickfix list" to

+ its standard output (instead of letting it consumed by the editor

+ it invokes), and learned to also drive emacs/emacsclient.

+

+ * "git var UNKNOWN_VARIABLE" and "git var VARIABLE" with the variable

+ given an empty value used to behave identically. Now the latter

+ just gives an empty output, while the former still gives an error

+ message.

+

+ * Introduce a case insensitive mode to the Bash completion helpers.

+

+ * The advice message given by "git status" when it takes long time to

+ enumerate untracked paths has been updated.

+

+ * Just like "git var GIT_EDITOR" abstracts the complex logic to

+ choose which editor gets used behind it, "git var" now give support

+ to GIT_SEQUENCE_EDITOR.

+

+ * "git format-patch" learned to honor format.mboxrd even when sending

+ patches to the standard output stream,

+

+ * 'cat-file' gains mailmap support for its '--batch-check' and '-s'

+ options.

+

+ * Conditionally skip the pre-applypatch and applypatch-msg hooks when

+ applying patches with 'git am'.

+

+ * Introduce an optional configuration to allow the trailing hash that

+ protects the index file from bit flipping.

+

+

+Performance, Internal Implementation, Development Support etc.

+

+ * `git bisect` becomes a builtin.

+

+ * The pack-bitmap machinery is taught to log the paths of redundant

+ bitmap(s) to trace2 instead of stderr.

+

+ * Use the SHA1DC implementation on macOS, just like other platforms,

+ by default.

+

+ * Even in a repository with promisor remote, it is useless to

+ attempt to lazily attempt fetching an object that is expected to be

+ commit, because no "filter" mode omits commit objects. Take

+ advantage of this assumption to fail fast on errors.

+

+ * Stop using "git --super-prefix" and narrow the scope of its use to

+ the submodule--helper.

+

+ * Stop running win+VS build by default.

+ (merge a0da6deeec js/ci-disable-cmake-by-default later to maint).

+

+ * CI updates. We probably want a clean-up to move the long shell

+ script embedded in yaml file into a separate file, but that can

+ come later.

+ (merge 4542582e59 cw/ci-whitespace later to maint).

+

+ * Use `git diff --no-index` as a test_cmp on Windows.

+

+ We'd probably need to revisit "do we really want to, and have to,

+ lose CRLF vs LF?" later, at which time we may be able to further

+ clean this up by replacing "git diff --no-index" with "diff -u".

+

+ * Avoid unnecessary builds in CI, with settings configured in

+ ci-config.

+ (merge eb5b03a9c0 tb/ci-concurrency later to maint).

+

+

+Fixes since v2.39

+-----------------

+

+ * Various leak fixes.

+ (merge ac95f5d36a ab/various-leak-fixes later to maint).

+

+ * Fix a bug where `pack-objects` would not respect multiple `--filter`

+ arguments when invoked directly.

+ (merge d4f7036887 rs/multi-filter-args later to maint).

+

+ * Make fsmonitor more robust to avoid the flakiness seen in t7527.

+ (merge 6692d45477 jh/t7527-unflake-by-forcing-cookie later to maint).

+

+ * Stop using deprecated macOS API in fsmonitor.

+ (merge b0226007f0 jh/fsmonitor-darwin-modernize later to maint).

+

+ * Redefining system functions for a few functions did not follow our

+ usual "implement git_foo() and #define foo(args) git_foo(args)"

+ pattern, which has broken build for some folks.

+ (merge e1a95b78d8 jk/avoid-redef-system-functions-2.30 later to maint).

+ (merge 395bec6b39 jk/avoid-redef-system-functions later to maint).

+

+ * The way the diff machinery prepares the options array for the

+ parse_options API has been refactored to avoid resource leaks.

+ (merge 189e97bc4b rs/diff-parseopts later to maint).

+

+ * Correct pthread API usage.

+ (merge 786e67611d sx/pthread-error-check-fix later to maint).

+

+ * The code to auto-correct a misspelt subcommand unnecessarily called

+ into git_default_config() from the early config codepath, which was

+ a no-no. This has bee corrected.

+ (merge 0918d08887 sg/help-autocorrect-config-fix later to maint).

+

+ * "git http-fetch" (which is rarely used) forgot to identify itself

+ in the trace2 output.

+ (merge 7abb43cbc8 jt/http-fetch-trace2-report-name later to maint).

+

+ * The output from "git diff --stat" on an unmerged path lost the

+ terminating LF in Git 2.39, which has been corrected.

+ (merge 209d9cb011 pg/diff-stat-unmerged-regression-fix later to maint).

+

+ * "git pull -v --recurse-submodules" attempted to pass "-v" down to

+ underlying "git submodule update", which did not understand the

+ request and barfed, which has been corrected.

+ (merge 6f65f84766 ss/pull-v-recurse-fix later to maint).

+

+ * When given a pattern that matches an empty string at the end of a

+ line, the code to parse the "git diff" line-ranges fell into an

+ infinite loop, which has been corrected.

+ (merge 4e57c88e02 lk/line-range-parsing-fix later to maint).

+

+ * Fix the sequence to fsync $GIT_DIR/packed-refs file that forgot to

+ flush its output to the disk..

+ (merge ce54672f9b ps/fsync-refs-fix later to maint).

+

+ * Fix to a small regression in 2.38 days.

+ (merge 6d5e9e53aa ab/bundle-wo-args later to maint).

+

+ * "git diff --relative" did not mix well with "git diff --ext-diff",

+ which has been corrected.

+ (merge f034bb1cad jk/ext-diff-with-relative later to maint).

+

+ * The logic to see if we are using the "cone" mode by checking the

+ sparsity patterns has been tightened to avoid mistaking a pattern

+ that names a single file as specifying a cone.

+ (merge 5842710dc2 ws/single-file-cone later to maint).

+

+ * Deal with a few deprecation warning from cURL library.

+ (merge 6c065f72b8 jk/curl-avoid-deprecated-api later to maint).

+

+ * Doc update for environment variables set when hooks are invoked.

+ (merge 772f8ff826 es/hooks-and-local-env later to maint).

+

+ * Document ORIG_HEAD a bit more.

+ (merge f1c9243fc5 pb/doc-orig-head later to maint).

+

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

+ (merge 77e04b2ed4 rs/t4205-do-not-exit-in-test-script later to maint).

+ (merge faebba436e rs/plug-pattern-list-leak-in-lof later to maint).

+ (merge 243caa8982 ab/t5314-avoid-losing-exit-status later to maint).

+ (merge 4d81ce1b99 ab/t7600-avoid-losing-exit-status-of-git later to maint).

+ (merge 5f3bfdc4f3 ab/t4023-avoid-losing-exit-status-of-diff later to maint).

+ (merge 500317ae03 js/t3920-shell-and-or-fix later to maint).

+ (merge 86325d36e6 rs/t3920-crlf-eating-grep-fix later to maint).

+ (merge cfbd173ccb rj/branch-copy-and-rename later to maint).

+ (merge c25d9e529d jk/unused-post-2.39 later to maint).

+ (merge a31cfe3283 jk/server-supports-v2-cleanup later to maint).

+ (merge a658e881c1 rs/am-parse-options-cleanup later to maint).

+ (merge 4cb39fcf19 rs/clear-commit-marks-cleanup later to maint).

+ (merge b07a819c05 rs/reflog-expiry-cleanup later to maint).

+ (merge d422d06167 rs/clarify-error-in-write-loose-object later to maint).

+ (merge 92cb135855 sk/remove-duplicate-includes later to maint).

+ (merge 4eb1ccecd4 dh/mingw-ownership-check-typofix later to maint).

+ (merge f95526419b ar/typofix-gitattributes-doc later to maint).

+ (merge 27875aeec9 km/doc-branch-start-point later to maint).

+ (merge 35c194dc57 es/t1509-root-fixes later to maint).

+ (merge 7b341645e3 pw/ci-print-failure-name-fix later to maint).

+ (merge bcb71d45bf jx/t1301-updates later to maint).

+ (merge ebdc46c242 jc/doc-diff-patch.txt later to maint).

+ (merge a87a20cbb4 ar/test-cleanup later to maint).

+ (merge f5156f1885 ar/bisect-doc-update later to maint).

+ (merge fca2d86c97 jk/interop-error later to maint).

+ (merge cf4936ed74 tl/ls-tree-code-clean-up later to maint).

+* `index.skipHash=true` speeds up index writes by not computing a trailing

+ checksum. Note that this will cause Git versions earlier than 2.13.0 to

+ refuse to parse the index and Git versions earlier than 2.40.0 will report

+ a corrupted index during `git fsck`.

++

+

+format.mboxrd::

+ A boolean value which enables the robust "mboxrd" format when

+ `--stdout` is in use to escape "^>+From " lines.

+

+index.skipHash::

+ When enabled, do not compute the trailing hash for the index file.

+ This accelerates Git commands that manipulate the index, such as

+ `git add`, `git commit`, or `git status`. Instead of storing the

+ checksum, write a trailing set of bytes with value zero, indicating

+ that the computation was skipped.

++

+If you enable `index.skipHash`, then Git clients older than 2.13.0 will

+refuse to parse the index and Git clients older than 2.40.0 will report an

+error during `git fsck`.

+

+transfer.bundleURI::

+ When `true`, local `git clone` commands will request bundle

+ information from the remote server (if advertised) and download

+ bundles before continuing the clone through the Git protocol.

+ Defaults to `false`.

+[[generate_patch_text_with_p]]

+ Generate patch (see section titled

+ifdef::git-log[]

+<<generate_patch_text_with_p, "Generating patch text with -p">>).

+endif::git-log[]

+ifndef::git-log[]

+"Generating patch text with -p").

+endif::git-log[]

+`gitattributesBlob`::

+ (ERROR) A non-blob found at `.gitattributes`.

+

+`gitattributesLarge`::

+ (ERROR) The `.gitattributes` blob is too large.

+

+`gitattributesLineLength`::

+ (ERROR) The `.gitattributes` blob contains too long lines.

+

+`gitattributesMissing`::

+ (ERROR) Unable to read `.gitattributes` blob.

+

+'git am' [--signoff] [--keep] [--[no-]keep-cr] [--[no-]utf8] [--no-verify]

+-n::

+--no-verify::

+ By default, the pre-applypatch and applypatch-msg hooks are run.

+ When any of `--no-verify` or `-n` is given, these are bypassed.

+ See also linkgit:githooks[5].

+

+- [[[1]]] https://web.archive.org/web/20091206032101/http://www.nist.gov/public_affairs/releases/n02-10.htm['Software Errors Cost U.S. Economy $59.5 Billion Annually'. Nist News Release.] See also https://www.nist.gov/system/files/documents/director/planning/report02-3.pdf['The Economic Impacts of Inadequate Infratructure for Software Testing'. Nist Planning Report 02-3], Executive Summary and Chapter 8.

+- [[[2]]] https://www.oracle.com/java/technologies/javase/codeconventions-introduction.html['Code Conventions for the Java Programming Language: 1. Introduction'. Sun Microsystems.]

+ Reset <branchname> to <start-point>, even if <branchname> exists

+ `<object>`. If used with `--use-mailmap` option, will show

+ the size of updated object after replacing idents using the

+ mailmap mechanism.

+ on stdin. May not be combined with any other options or arguments

+ except `--textconv`, `--filters`, or `--use-mailmap`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines

+ must specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ contents part of the output shows the identities replaced using the

+ mailmap mechanism, while the information part of the output shows

+ the size of the object as if it actually recorded the replacement

+ identities.

+ Print object information for each object provided on stdin. May not be

+ combined with any other options or arguments except `--textconv`, `--filters`

+ or `--use-mailmap`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines must

+ specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ printed object information shows the size of the object as if the

+ identities recorded in it were replaced by the mailmap mechanism.

+ only be combined with `--buffer`, `--textconv`, `--use-mailmap` or

+ `--filters`.

+ +

+ * When used with `--textconv` or `--filters`, the input lines must

+ specify the path, separated by whitespace. See the section

+ `BATCH OUTPUT` below for details.

+ +

+ * When used with `--use-mailmap`, for commit and tag objects, the

+ `contents` command shows the identities replaced using the

+ mailmap mechanism, while the `info` command shows the size

+ of the object as if it actually recorded the replacement

+ identities.

+

+'git check-attr' [--source <tree-ish>] [-a | --all | <attr>...] [--] <pathname>...

+'git check-attr' --stdin [-z] [--source <tree-ish>] [-a | --all | <attr>...]

+--source=<tree-ish>::

+ Check attributes against the specified tree-ish. It is common to

+ specify the source tree by naming a commit, branch or tag associated

+ with it.

+

+$ git checkout -b foo # or "git switch -c foo" <1>

+$ git branch foo <2>

+$ git tag foo <3>

+$ git cherry-pick --abort <3>

+The above command copies all branches from the remote `refs/heads/`

+namespace and stores them to the local `refs/remotes/origin/` namespace,

+unless the `remote.<repository>.fetch` option is used to specify a

+non-default refspec.

+--merge-base=<commit>::

+ Instead of finding the merge-bases for <branch1> and <branch2>,

+ specify a merge-base for the merge, and specifying multiple bases is

+ currently not supported. This option is incompatible with `--stdin`.

+

+INPUT FORMAT

+------------

+'git merge-tree --stdin' input format is fully text based. Each line

+has this format:

+

+ [<base-commit> -- ]<branch1> <branch2>

+

+If one line is separated by `--`, the string before the separator is

+used for specifying a merge-base for the merge and the string after

+the separator describes the branches to be merged.

+

+a log message from the user describing the changes. Before the operation,

+`ORIG_HEAD` is set to the tip of the current branch (`C`).

+[NOTE]

+`ORIG_HEAD` is not guaranteed to still point to the previous branch tip

+at the end of the rebase if other commands that write that pseudo-ref

+(e.g. `git reset`) are used during the rebase. The previous branch tip,

+however, is accessible using the reflog of the current branch

+(i.e. `@{1}`, see linkgit:gitrevisions[7]).

+

+ the working tree depending on `<mode>`. Before the operation, `ORIG_HEAD`

+ is set to the tip of the current branch. If `<mode>` is omitted,

+UNTRACKED FILES AND PERFORMANCE

+-------------------------------

+

+`git status` can be very slow in large worktrees if/when it

+needs to search for untracked files and directories. There are

+many configuration options available to speed this up by either

+avoiding the work or making use of cached results from previous

+Git commands. There is no single optimum set of settings right

+for everyone. We'll list a summary of the relevant options to help

+you, but before going into the list, you may want to run `git status`

+again, because your configuration may already be caching `git status`

+results, so it could be faster on subsequent runs.

+

+* The `--untracked-files=no` flag or the

+ `status.showUntrackedfiles=false` config (see above for both):

+ indicate that `git status` should not report untracked

+ files. This is the fastest option. `git status` will not list

+ the untracked files, so you need to be careful to remember if

+ you create any new files and manually `git add` them.

+

+* `advice.statusUoption=false` (see linkgit:git-config[1]):

+ setting this variable to `false` disables the warning message

+ given when enumerating untracked files takes more than 2

+ seconds. In a large project, it may take longer and the user

+ may have already accepted the trade off (e.g. using "-uno" may

+ not be an acceptable option for the user), in which case, there

+ is no point issuing the warning message, and in such a case,

+ disabling the warning may be the best.

+

+* `core.untrackedCache=true` (see linkgit:git-update-index[1]):

+ enable the untracked cache feature and only search directories

+ that have been modified since the previous `git status` command.

+ Git remembers the set of untracked files within each directory

+ and assumes that if a directory has not been modified, then

+ the set of untracked files within has not changed. This is much

+ faster than enumerating the contents of every directory, but still

+ not without cost, because Git still has to search for the set of

+ modified directories. The untracked cache is stored in the

+ `.git/index` file. The reduced cost of searching for untracked

+ files is offset slightly by the increased size of the index and

+ the cost of keeping it up-to-date. That reduced search time is

+ usually worth the additional size.

+

+* `core.untrackedCache=true` and `core.fsmonitor=true` or

+ `core.fsmonitor=<hook_command_pathname>` (see

+ linkgit:git-update-index[1]): enable both the untracked cache

+ and FSMonitor features and only search directories that have

+ been modified since the previous `git status` command. This

+ is faster than using just the untracked cache alone because

+ Git can also avoid searching for modified directories. Git

+ only has to enumerate the exact set of directories that have

+ changed recently. While the FSMonitor feature can be enabled

+ without the untracked cache, the benefits are greatly reduced

+ in that case.

+

+Note that after you turn on the untracked cache and/or FSMonitor

+features it may take a few `git status` commands for the various

+caches to warm up before you see improved command times. This is

+normal.

+

+Prints a Git logical variable. Exits with code 1 if the variable has

+no value.

+GIT_SEQUENCE_EDITOR::

+ Text editor used to edit the 'todo' file while running `git rebase

+ -i`. Like `GIT_EDITOR`, the value is meant to be interpreted by

+ the shell when it is used. The order of preference is the

+ `$GIT_SEQUENCE_EDITOR` environment variable, then

+ `sequence.editor` configuration, and then the value of `git var

+ GIT_EDITOR`.

+

+ [--config-env=<name>=<envvar>] <command> [<args>]

+ Specify a comma separated list of common whitespace problems to

+Environment variables, such as `GIT_DIR`, `GIT_WORK_TREE`, etc., are exported

+so that Git commands run by the hook can correctly locate the repository. If

+your hook needs to invoke Git commands in a foreign repository or in a

+different working tree of the same repository, then it should clear these

+environment variables so they do not interfere with Git operations at the

+foreign location. For example:

+

+------------

+local_desc=$(git describe)

+foreign_desc=$(unset $(git rev-parse --local-env-vars); git -C ../foreign-repo describe)

+------------

+

+bundle-uri

+~~~~~~~~~~

+

+If the 'bundle-uri' capability is advertised, the server supports the

+`bundle-uri' command.

+

+The capability is currently advertised with no value (i.e. not

+"bundle-uri=somevalue"), a value may be added in the future for

+supporting command-wide extensions. Clients MUST ignore any unknown

+capability values and proceed with the 'bundle-uri` dialog they

+support.

+

+The 'bundle-uri' command is intended to be issued before `fetch` to

+get URIs to bundle files (see linkgit:git-bundle[1]) to "seed" and

+inform the subsequent `fetch` command.

+

+The client CAN issue `bundle-uri` before or after any other valid

+command. To be useful to clients it's expected that it'll be issued

+after an `ls-refs` and before `fetch`, but CAN be issued at any time

+in the dialog.

+

+DISCUSSION of bundle-uri

+^^^^^^^^^^^^^^^^^^^^^^^^

+

+The intent of the feature is optimize for server resource consumption

+in the common case by changing the common case of fetching a very

+large PACK during linkgit:git-clone[1] into a smaller incremental

+fetch.

+

+It also allows servers to achieve better caching in combination with

+an `uploadpack.packObjectsHook` (see linkgit:git-config[1]).

+

+By having new clones or fetches be a more predictable and common

+negotiation against the tips of recently produces *.bundle file(s).

+Servers might even pre-generate the results of such negotiations for

+the `uploadpack.packObjectsHook` as new pushes come in.

+

+One way that servers could take advantage of these bundles is that the

+server would anticipate that fresh clones will download a known bundle,

+followed by catching up to the current state of the repository using ref

+tips found in that bundle (or bundles).

+

+PROTOCOL for bundle-uri

+^^^^^^^^^^^^^^^^^^^^^^^

+

+A `bundle-uri` request takes no arguments, and as noted above does not

+currently advertise a capability value. Both may be added in the

+future.

+

+When the client issues a `command=bundle-uri` request, the response is a

+list of key-value pairs provided as packet lines with value

+`<key>=<value>`. Each `<key>` should be interpreted as a config key from

+the `bundle.*` namespace to construct a list of bundles. These keys are

+grouped by a `bundle.<id>.` subsection, where each key corresponding to a

+given `<id>` contributes attributes to the bundle defined by that `<id>`.

+See linkgit:git-config[1] for the specific details of these keys and how

+the Git client will interpret their values.

+

+Clients MUST parse the line according to the above format, lines that do

+not conform to the format SHOULD be discarded. The user MAY be warned in

+such a case.

+

+bundle-uri CLIENT AND SERVER EXPECTATIONS

+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+

+URI CONTENTS::

+The content at the advertised URIs MUST be one of two types.

++

+The advertised URI may contain a bundle file that `git bundle verify`

+would accept. I.e. they MUST contain one or more reference tips for

+use by the client, MUST indicate prerequisites (in any) with standard

+"-" prefixes, and MUST indicate their "object-format", if

+applicable.

++

+The advertised URI may alternatively contain a plaintext file that `git

+config --list` would accept (with the `--file` option). The key-value

+pairs in this list are in the `bundle.*` namespace (see

+linkgit:git-config[1]).

+

+bundle-uri CLIENT ERROR RECOVERY::

+A client MUST above all gracefully degrade on errors, whether that

+error is because of bad missing/data in the bundle URI(s), because

+that client is too dumb to e.g. understand and fully parse out bundle

+headers and their prerequisite relationships, or something else.

++

+Server operators should feel confident in turning on "bundle-uri" and

+not worry if e.g. their CDN goes down that clones or fetches will run

+into hard failures. Even if the server bundle(s) are

+incomplete, or bad in some way the client should still end up with a

+functioning repository, just as if it had chosen not to use this

+protocol extension.

++

+All subsequent discussion on client and server interaction MUST keep

+this in mind.

+

+bundle-uri SERVER TO CLIENT::

+The ordering of the returned bundle uris is not significant. Clients

+MUST parse their headers to discover their contained OIDS and

+prerequisites. A client MUST consider the content of the bundle(s)

+themselves and their header as the ultimate source of truth.

++

+A server MAY even return bundle(s) that don't have any direct

+relationship to the repository being cloned (either through accident,

+or intentional "clever" configuration), and expect a client to sort

+out what data they'd like from the bundle(s), if any.

+

+bundle-uri CLIENT TO SERVER::

+The client SHOULD provide reference tips found in the bundle header(s)

+as 'have' lines in any subsequent `fetch` request. A client MAY also

+ignore the bundle(s) entirely if doing so is deemed worse for some

+reason, e.g. if the bundles can't be downloaded, it doesn't like the

+tips it finds etc.

+

+WHEN ADVERTISED BUNDLE(S) REQUIRE NO FURTHER NEGOTIATION::

+If after issuing `bundle-uri` and `ls-refs`, and getting the header(s)

+of the bundle(s) the client finds that the ref tips it wants can be

+retrieved entirely from advertised bundle(s), the client MAY disconnect

+from the Git server. The results of such a 'clone' or 'fetch' should be

+indistinguishable from the state attained without using bundle-uri.

+

+EARLY CLIENT DISCONNECTIONS AND ERROR RECOVERY::

+A client MAY perform an early disconnect while still downloading the

+bundle(s) (having streamed and parsed their headers). In such a case

+the client MUST gracefully recover from any errors related to

+finishing the download and validation of the bundle(s).

++

+I.e. a client might need to re-connect and issue a 'fetch' command,

+and possibly fall back to not making use of 'bundle-uri' at all.

++

+This "MAY" behavior is specified as such (and not a "SHOULD") on the

+assumption that a server advertising bundle uris is more likely than

+not to be serving up a relatively large repository, and to be pointing

+to URIs that have a good chance of being in working order. A client

+MAY e.g. look at the payload size of the bundles as a heuristic to see

+if an early disconnect is worth it, should falling back on a full

+"fetch" dialog be necessary.

+

+WHEN ADVERTISED BUNDLE(S) REQUIRE FURTHER NEGOTIATION::

+A client SHOULD commence a negotiation of a PACK from the server via

+the "fetch" command using the OID tips found in advertised bundles,

+even if's still in the process of downloading those bundle(s).

++

+This allows for aggressive early disconnects from any interactive

+server dialog. The client blindly trusts that the advertised OID tips

+are relevant, and issues them as 'have' lines, it then requests any

+tips it would like (usually from the "ls-refs" advertisement) via

+'want' lines. The server will then compute a (hopefully small) PACK

+with the expected difference between the tips from the bundle(s) and

+the data requested.

++

+The only connection the client then needs to keep active is to the

+concurrently downloading static bundle(s), when those and the

+incremental PACK are retrieved they should be inflated and

+validated. Any errors at this point should be gracefully recovered

+from, see above.

+

+bundle-uri PROTOCOL FEATURES

+^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+

+The client constructs a bundle list from the `<key>=<value>` pairs

+provided by the server. These pairs are part of the `bundle.*` namespace

+as documented in linkgit:git-config[1]. In this section, we discuss some

+of these keys and describe the actions the client will do in response to

+this information.

+

+In particular, the `bundle.version` key specifies an integer value. The

+only accepted value at the moment is `1`, but if the client sees an

+unexpected value here then the client MUST ignore the bundle list.

+

+As long as `bundle.version` is understood, all other unknown keys MAY be

+ignored by the client. The server will guarantee compatibility with older

+clients, though newer clients may be better able to use the extra keys to

+minimize downloads.

+

+Any backwards-incompatible addition of pre-URI key-value will be

+guarded by a new `bundle.version` value or values in 'bundle-uri'

+capability advertisement itself, and/or by new future `bundle-uri`

+request arguments.

+

+Some example key-value pairs that are not currently implemented but could

+be implemented in the future include:

+

+ * Add a "hash=<val>" or "size=<bytes>" advertise the expected hash or

+ size of the bundle file.

+

+ * Advertise that one or more bundle files are the same (to e.g. have

+ clients round-robin or otherwise choose one of N possible files).

+

+ * A "oid=<OID>" shortcut and "prerequisite=<OID>" shortcut. For

+ expressing the common case of a bundle with one tip and no

+ prerequisites, or one tip and one prerequisite.

++

+This would allow for optimizing the common case of servers who'd like

+to provide one "big bundle" containing only their "main" branch,

+and/or incremental updates thereof.

++

+A client receiving such a a response MAY assume that they can skip

+retrieving the header from a bundle at the indicated URI, and thus

+save themselves and the server(s) the request(s) needed to inspect the

+headers of that bundle or bundles.

+

+way (`git am`, `git merge`, `git rebase`, `git reset`),

+to record the position of the `HEAD` before their operation, so that

+DEF_VER=v2.39.GIT

+ Git requires version "7.19.5" or later of "libcurl" to build

+# Define APPLE_COMMON_CRYPTO_SHA1 to use Apple's CommonCrypto for

+# SHA-1.

+TEST_BUILTINS_OBJS += test-env-helper.o

+BUILTIN_OBJS += builtin/bisect.o

+ifdef APPLE_COMMON_CRYPTO_SHA1

+ifdef APPLE_COMMON_CRYPTO_SHA1

+Documentation/RelNotes/2.40.0.txt \ No newline at end of file

+ struct diff_options *opt, void *data UNUSED)

+ ws_blank_line(patch + 1, plen))

+ ws_blank_line(patch + 1, plen))

+ struct index_state result = INDEX_STATE_INIT;

+ git_check_attr(istate, NULL, path, check);

+#include "revision.h"

+#include "object-store.h"

+ unsigned int attr_nr; /* unique attribute number */

+static const struct git_attr *git_attr_internal(const char *name, size_t namelen)

+ if (a->attr_nr != hashmap_get_size(&g_attr_hashmap.map) - 1)

+ die(_("unable to add additional attribute"));

+ size_t num_attr;

+ size_t len;

+ size_t namelen, num_attr, i;

+ if (strlen(line) >= ATTR_MAX_LINE_LENGTH) {

+ warning(_("ignoring overly long attributes line %d"), lineno);

+ return NULL;

+ }

+

+ res = xcalloc(1, st_add3(sizeof(*res),

+ st_mult(sizeof(struct attr_state), num_attr),

+ is_macro ? 0 : namelen + 1));

+ unsigned i;

+ size_t j;

+

+ DUP_ARRAY(ret->items, check->items, ret->nr);

+ ALLOC_GROW_BY(res->attrs, res->num_matches, 1, res->alloc);

+ res->attrs[res->num_matches - 1] = a;

+ struct strbuf buf = STRBUF_INIT;

+ struct stat st;

+ if (fstat(fd, &st)) {

+ warning_errno(_("cannot fstat gitattributes file '%s'"), path);

+ fclose(fp);

+ return NULL;

+ }

+ if (st.st_size >= ATTR_MAX_FILE_SIZE) {

+ warning(_("ignoring overly large gitattributes file '%s'"), path);

+ fclose(fp);

+ return NULL;

+ }

+ while (strbuf_getline(&buf, fp) != EOF) {

+ if (!lineno && starts_with(buf.buf, utf8_bom))

+ strbuf_remove(&buf, 0, strlen(utf8_bom));

+ handle_attr_line(res, buf.buf, path, ++lineno, flags);

+

+ strbuf_release(&buf);

+static struct attr_stack *read_attr_from_buf(char *buf, const char *path,

+ unsigned flags)

+ char *sp;

+ if (!buf)

+ return NULL;

+

+ CALLOC_ARRAY(res, 1);

+ for (sp = buf; *sp;) {

+ char *ep;

+ int more;

+

+ ep = strchrnul(sp, '\n');

+ more = (*ep == '\n');

+ *ep = '\0';

+ handle_attr_line(res, sp, path, ++lineno, flags);

+ sp = ep + more;

+ }

+ free(buf);

+

+ return res;

+}

+

+static struct attr_stack *read_attr_from_blob(struct index_state *istate,

+ const struct object_id *tree_oid,

+ const char *path, unsigned flags)

+{

+ struct object_id oid;

+ unsigned long sz;

+ enum object_type type;

+ void *buf;

+ unsigned short mode;

+

+ if (!tree_oid)

+ return NULL;

+

+ if (get_tree_entry(istate->repo, tree_oid, path, &oid, &mode))

+ return NULL;

+

+ buf = repo_read_object_file(istate->repo, &oid, &type, &sz);

+ if (!buf || type != OBJ_BLOB) {

+ free(buf);

+ return NULL;

+ }

+

+ return read_attr_from_buf(buf, path, flags);

+}

+

+static struct attr_stack *read_attr_from_index(struct index_state *istate,

+ const char *path, unsigned flags)

+{

+ char *buf;

+ unsigned long size;

+

+ buf = read_blob_data_from_index(istate, path, &size);

+ if (size >= ATTR_MAX_FILE_SIZE) {

+ warning(_("ignoring overly large gitattributes blob '%s'"), path);

+ return NULL;

+

+ return read_attr_from_buf(buf, path, flags);

+ const struct object_id *tree_oid,

+ } else if (tree_oid) {

+ res = read_attr_from_blob(istate, tree_oid, path, flags);

+ const struct object_id *tree_oid,

+ e = read_attr(istate, tree_oid, GITATTRIBUTES_FILE, flags | READ_ATTR_NOFOLLOW);

+ const struct object_id *tree_oid,

+ bootstrap_attr_stack(istate, tree_oid, stack);

+ next = read_attr(istate, tree_oid, pathbuf.buf, READ_ATTR_NOFOLLOW);

+ size_t i;

+ for (i = a->num_attr; rem > 0 && i > 0; i--) {

+ const struct git_attr *attr = a->state[i - 1].attr;

+ const char *v = a->state[i - 1].setto;

+ unsigned i;

+ for (i = stack->num_matches; 0 < rem && 0 < i; i--) {

+ const struct match_attr *a = stack->attrs[i - 1];

+ unsigned i;

+ for (i = stack->num_matches; i > 0; i--) {

+ const struct match_attr *ma = stack->attrs[i - 1];

+ unsigned int n = ma->u.attr->attr_nr;

+ const struct object_id *tree_oid,

+ const char *path, struct attr_check *check)

+ prepare_attr_stack(istate, tree_oid, path, dirlen, &check->stack);

+ const struct object_id *tree_oid, const char *path,

+ collect_some_attrs(istate, tree_oid, path, check);

+ unsigned int n = check->items[i].attr->attr_nr;

+void git_all_attrs(struct index_state *istate, const struct object_id *tree_oid,

+ collect_some_attrs(istate, tree_oid, path, check);

+/**

+ * The maximum line length for a gitattributes file. If the line exceeds this

+ * length we will ignore it.

+ */

+#define ATTR_MAX_LINE_LENGTH 2048

+

+ /**

+ * The maximum size of the giattributes file. If the file exceeds this size we

+ * will ignore it.

+ */

+#define ATTR_MAX_FILE_SIZE (100 * 1024 * 1024)

+

+struct object_id;

+ const struct object_id *tree_oid, const char *path,

+ struct attr_check *check);

+void git_all_attrs(struct index_state *istate, const struct object_id *tree_oid,

+void parse_blob_buffer(struct blob *item)

+void parse_blob_buffer(struct blob *item);

+int cmd_bisect(int argc, const char **argv, const char *prefix);

+ struct diff_options *opt UNUSED, void *cbdata)

+ clear_pathspec(&pathspec);

+ int no_verify;

+ int ret = 0;

+

+ if (!state->no_verify)

+ ret = run_hooks_l("applypatch-msg", am_path(state, "final-commit"), NULL);

+ const char **apply_argv;

+ /*

+ * Build a copy that apply_parse_options() can rearrange.

+ * apply_opts.v keeps referencing the allocated strings for

+ * strvec_clear() to release.

+ */

+ DUP_ARRAY(apply_argv, apply_opts.v, apply_opts.nr);

+

+ opts_left = apply_parse_options(apply_opts.nr, apply_argv,

+ free(apply_argv);

+ if (!state->no_verify && run_hooks("pre-applypatch"))

+ OPT_BOOL('n', "no-verify", &state.no_verify,

+ N_("bypass pre-applypatch and applypatch-msg hooks")),

+#define BUILTIN_GIT_BISECT_START_USAGE \

+ N_("git bisect start [--term-{new,bad}=<term> --term-{old,good}=<term>]" \

+ " [--no-checkout] [--first-parent] [<bad> [<good>...]] [--]" \

+ " [<pathspec>...]")

+#define BUILTIN_GIT_BISECT_STATE_USAGE \

+ N_("git bisect (good|bad) [<rev>...]")

+#define BUILTIN_GIT_BISECT_TERMS_USAGE \

+ "git bisect terms [--term-good | --term-bad]"

+#define BUILTIN_GIT_BISECT_SKIP_USAGE \

+ N_("git bisect skip [(<rev>|<range>)...]")

+#define BUILTIN_GIT_BISECT_NEXT_USAGE \

+ "git bisect next"

+#define BUILTIN_GIT_BISECT_RESET_USAGE \

+ N_("git bisect reset [<commit>]")

+#define BUILTIN_GIT_BISECT_VISUALIZE_USAGE \

+ "git bisect visualize"

+#define BUILTIN_GIT_BISECT_REPLAY_USAGE \

+ N_("git bisect replay <logfile>")

+#define BUILTIN_GIT_BISECT_LOG_USAGE \

+ "git bisect log"

+#define BUILTIN_GIT_BISECT_RUN_USAGE \

+ N_("git bisect run <cmd>...")

+

+static const char * const git_bisect_usage[] = {

+ BUILTIN_GIT_BISECT_START_USAGE,

+ BUILTIN_GIT_BISECT_STATE_USAGE,

+ BUILTIN_GIT_BISECT_TERMS_USAGE,

+ BUILTIN_GIT_BISECT_SKIP_USAGE,

+ BUILTIN_GIT_BISECT_NEXT_USAGE,

+ BUILTIN_GIT_BISECT_RESET_USAGE,

+ BUILTIN_GIT_BISECT_VISUALIZE_USAGE,

+ BUILTIN_GIT_BISECT_REPLAY_USAGE,

+ BUILTIN_GIT_BISECT_LOG_USAGE,

+ BUILTIN_GIT_BISECT_RUN_USAGE,

+static enum bisect_error bisect_start(struct bisect_terms *terms, int argc,

+ const char **argv)

+ -1 : bisect_start(terms, 0, empty_strvec);

+static enum bisect_error bisect_state(struct bisect_terms *terms, int argc,

+ const char **argv)

+ res = bisect_start(terms, argv.nr, argv.v);

+static enum bisect_error bisect_skip(struct bisect_terms *terms, int argc,

+ const char **argv)

+ res = bisect_state(terms, argv_state.nr, argv_state.v);

+static int bisect_visualize(struct bisect_terms *terms, int argc,

+ const char **argv)

+static int bisect_run(struct bisect_terms *terms, int argc, const char **argv)

+ if (!argc) {

+ sq_quote_argv(&command, argv);

+ strbuf_ltrim(&command);

+ if (rc < 0 || 128 <= rc) {

+ error(_("unable to verify %s on good"

+ " %s is < 0 or >= 128"), res, command.buf);

+ res = bisect_state(terms, 1, &new_state);

+ puts(_("bisect run success"));

+ puts(_("bisect found first bad commit"));

+ error(_("bisect run failed: 'git bisect %s'"

+ " exited with error code %d"), new_state, res);

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

+ "git bisect reset");

+ return error(_("'%s' requires 0 or 1 argument"),

+ "git bisect terms");

+ res = bisect_start(&terms, argc, argv);

+ return error(_("'%s' requires 0 arguments"),

+ "git bisect next");

+static int cmd_bisect__log(int argc UNUSED, const char **argv UNUSED, const char *prefix UNUSED)

+ res = bisect_skip(&terms, argc, argv);

+ res = bisect_visualize(&terms, argc, argv);

+ return error(_("'%s' failed: no command provided."), "git bisect run");

+ res = bisect_run(&terms, argc, argv);

+int cmd_bisect(int argc, const char **argv, const char *prefix)

+ argc = parse_options(argc, argv, prefix, options, git_bisect_usage,

+ PARSE_OPT_SUBCOMMAND_OPTIONAL);

+

+ if (!fn) {

+ struct bisect_terms terms = { 0 };

+

+ if (!argc)

+ usage_msg_opt(_("need a command"), git_bisect_usage, options);

+

+ set_terms(&terms, "bad", "good");

+ get_terms(&terms);

+ if (check_and_set_terms(&terms, argv[0]))

+ usage_msg_optf(_("unknown command: '%s'"), git_bisect_usage,

+ options, argv[0]);

+ res = bisect_state(&terms, argc, argv);

+ free_terms(&terms);

+ } else {

+ argc--;

+ argv++;

+ res = fn(argc, argv, prefix);

+ }

+ return is_bisect_success(res) ? 0 : -res;

+ if (copy && strcmp(interpreted_oldname, interpreted_newname) && git_config_copy_section(oldsection.buf, newsection.buf) < 0)

+ strbuf_release(&oldref);

+ strbuf_release(&newref);

+ int ret;

+ strbuf_release(&buffer);

+

+ ret = !!launch_editor(report_path.buf, NULL, NULL);

+ strbuf_release(&report_path);

+ return ret;

+ argc = parse_options(argc, argv, NULL, options, usagestr,

+ if (!argc)

+ usage_msg_opt(_("need a <file> argument"), usagestr, options);

+ return argc;

+

+ if (use_mailmap) {

+ oi.typep = &type;

+ oi.contentp = (void**)&buf;

+ }

+

+

+ if (use_mailmap && (type == OBJ_COMMIT || type == OBJ_TAG)) {

+ size_t s = size;

+ buf = replace_idents_using_mailmap(buf, &s);

+ size = cast_size_t_to_ulong(s);

+ }

+

+ if (use_mailmap)

+ data->info.typep = &data->type;

+

+

+ if (use_mailmap && (data->type == OBJ_COMMIT || data->type == OBJ_TAG)) {

+ size_t s = data->size;

+ char *buf = NULL;

+

+ buf = repo_read_object_file(the_repository, &data->oid, &data->type,

+ &data->size);

+ buf = replace_idents_using_mailmap(buf, &s);

+ data->size = cast_size_t_to_ulong(s);

+

+ free(buf);

+ }

+static char *source;

+N_("git check-attr [--source <tree-ish>] [-a | --all | <attr>...] [--] <pathname>..."),

+N_("git check-attr --stdin [-z] [--source <tree-ish>] [-a | --all | <attr>...]"),

+ OPT_STRING(0, "source", &source, N_("<tree-ish>"), N_("which tree-ish to check attributes at")),

+static void check_attr(const char *prefix, struct attr_check *check,

+ const struct object_id *tree_oid, int collect_all,

+

+ git_all_attrs(&the_index, tree_oid, full_path, check);

+ git_check_attr(&the_index, tree_oid, full_path, check);

+static void check_attr_stdin_paths(const char *prefix, struct attr_check *check,

+ const struct object_id *tree_oid, int collect_all)

+ check_attr(prefix, check, tree_oid, collect_all, buf.buf);

+ struct object_id *tree_oid = NULL;

+ struct object_id initialized_oid;

+ if (source) {

+ if (repo_get_oid_tree(the_repository, source, &initialized_oid))

+ die("%s: not a valid tree-ish source", source);

+ tree_oid = &initialized_oid;

+ }

+

+ check_attr_stdin_paths(prefix, check, tree_oid, all_attrs);

+ check_attr(prefix, check, tree_oid, all_attrs, argv[i]);

+ unlink_entry(ce, NULL);

+ * or <something> is not a path, no -t or -b was given,

+

+ wt_status_state_free_buffers(&state);

+ if (!bundle_uri) {

+ /*

+ * Populate transport->got_remote_bundle_uri and

+ * transport->bundle_uri. We might get nothing.

+ */

+ transport_get_remote_bundle_uri(transport);

+

+ if (transport->bundles &&

+ hashmap_get_size(&transport->bundles->bundles)) {

+ /* At this point, we need the_repository to match the cloned repo. */

+ if (repo_init(the_repository, git_dir, work_tree))

+ warning(_("failed to initialize the repo, skipping bundle URI"));

+ else if (fetch_bundle_list(the_repository,

+ transport->bundles))

+ warning(_("failed to fetch advertised bundles"));

+ } else {

+ clear_bundle_list(transport->bundles);

+ FREE_AND_NULL(transport->bundles);

+ }

+ }

+

+ if (!active_nr) {

+ discard_cache();

+ if (read_cache() < 0)

+ die(_("Cannot read index"));

+ }

+ strbuf_release(&author_ident);

+ strbuf_release(&err);

+ strbuf_release(&sb);

+ char *value = NULL;

+ int ret = 0;

+ ret = git_config_set_multivar_in_file_gently(given_config_source.file,

+ argv[0], value, argv[2],

+ flags);

+ ret = git_config_set_multivar_in_file_gently(given_config_source.file,

+ argv[0], value,

+ CONFIG_REGEX_NONE,

+ flags);

+ ret = git_config_set_multivar_in_file_gently(given_config_source.file,

+ argv[0], value, argv[2],

+ flags | CONFIG_FLAGS_MULTI_REPLACE);

+ else if (!ret)

+ else

+ ret = 0;

+ else if (!ret)

+ else

+ ret = 0;

+ free(value);

+ return ret;

+ object_array_clear(&ent);

+ struct index_state wtindex = INDEX_STATE_INIT;

+ struct diff_options *options UNUSED, void *data)

+ do_cookie = 1;

+ do_cookie = 1;

+ fsm_listen__thread_proc, state)) {

+ fsm_health__thread_proc, state)) {

+static int stdout_mboxrd;

+ if (!strcmp(var, "format.mboxrd")) {

+ stdout_mboxrd = git_config_bool(var, value);

+ return 0;

+ }

+ if (use_stdout && stdout_mboxrd)

+ rev.commit_format = CMIT_FMT_MBOXRD;

+

+ clear_pathspec(&pathspec);

+static const char * const ls_tree_usage[] = {

+struct ls_tree_options {

+ unsigned null_termination:1;

+ int abbrev;

+ enum ls_tree_path_options {

+ LS_RECURSIVE = 1 << 0,

+ LS_TREE_ONLY = 1 << 1,

+ LS_SHOW_TREES = 1 << 2,

+ } ls_options;

+ struct pathspec pathspec;

+ int chomp_prefix;

+ const char *ls_tree_prefix;

+ const char *format;

+};

+

+struct show_tree_data {

+ struct ls_tree_options *options;

+ unsigned mode;

+ enum object_type type;

+ const struct object_id *oid;

+ const char *pathname;

+ struct strbuf *base;

+};

+

+ struct ls_tree_options *options = data->options;

+ strbuf_add_unique_abbrev(sb, data->oid, options->abbrev);

+ const char *prefix = options->chomp_prefix ? options->ls_tree_prefix : NULL;

+ size_t baselen = data->base->len;

+

+ quote_c_style(name, sb, NULL, 0);

+ strbuf_setlen(data->base, baselen);

+static int show_recursive(struct ls_tree_options *options, const char *base,

+ size_t baselen, const char *pathname)

+ if (options->ls_options & LS_RECURSIVE)

+ if (!options->pathspec.nr)

+ for (i = 0; i < options->pathspec.nr; i++) {

+ const char *spec = options->pathspec.items[i].match;

+ const char *pathname, unsigned mode, void *context)

+ struct ls_tree_options *options = context;

+ struct show_tree_data cb_data = {

+ .options = options,

+ if (type == OBJ_TREE && show_recursive(options, base->buf, base->len, pathname))

+ if (type == OBJ_TREE && recurse && !(options->ls_options & LS_SHOW_TREES))

+ if (type == OBJ_BLOB && (options->ls_options & LS_TREE_ONLY))

+ strbuf_expand(&sb, options->format, expand_show_tree, &cb_data);

+ strbuf_addch(&sb, options->null_termination ? '\0' : '\n');

+static int show_tree_common(struct ls_tree_options *options, int *recurse,

+ struct strbuf *base, const char *pathname,

+ enum object_type type)

+ if (options->ls_options & LS_TREE_ONLY)

+ show_recursive(options, base->buf, base->len, pathname)) {

+ if (!(options->ls_options & LS_SHOW_TREES))

+static void show_tree_common_default_long(struct ls_tree_options *options,

+ struct strbuf *base,

+ const char *prefix = options->chomp_prefix ? options->ls_tree_prefix : NULL;

+

+

+ if (options->null_termination) {

+ struct strbuf sb = STRBUF_INIT;

+ const char *name = relative_path(base->buf, prefix, &sb);

+

+ fputs(name, stdout);

+ fputc('\0', stdout);

+

+ strbuf_release(&sb);

+ } else {

+ write_name_quoted_relative(base->buf, prefix, stdout, '\n');

+ }

+

+ void *context)

+ struct ls_tree_options *options = context;

+ enum object_type type = object_type(mode);

+ early = show_tree_common(options, &recurse, base, pathname, type);

+ printf("%06o %s %s\t", mode, type_name(object_type(mode)),

+ find_unique_abbrev(oid, options->abbrev));

+ show_tree_common_default_long(options, base, pathname, base->len);

+ void *context)

+ struct ls_tree_options *options = context;

+ enum object_type type = object_type(mode);

+ early = show_tree_common(options, &recurse, base, pathname, type);

+ if (type == OBJ_BLOB) {

+ if (oid_object_info(the_repository, oid, &size) == OBJ_BAD)

+ printf("%06o %s %s %7s\t", mode, type_name(type),

+ find_unique_abbrev(oid, options->abbrev), size_text);

+ show_tree_common_default_long(options, base, pathname, base->len);

+ void *context)

+ struct ls_tree_options *options = context;

+ enum object_type type = object_type(mode);

+ const char *prefix;

+ early = show_tree_common(options, &recurse, base, pathname, type);

+ prefix = options->chomp_prefix ? options->ls_tree_prefix : NULL;

+ if (options->null_termination) {

+ struct strbuf sb = STRBUF_INIT;

+ const char *name = relative_path(base->buf, prefix, &sb);

+

+ fputs(name, stdout);

+ fputc('\0', stdout);

+

+ strbuf_release(&sb);

+ } else {

+ write_name_quoted_relative(base->buf, prefix, stdout, '\n');

+ }

+ void *context)

+ struct ls_tree_options *options = context;

+ enum object_type type = object_type(mode);

+ const char *str;

+ early = show_tree_common(options, &recurse, base, pathname, type);

+ str = find_unique_abbrev(oid, options->abbrev);

+ if (options->null_termination) {

+ fputs(str, stdout);

+ fputc('\0', stdout);

+ } else {

+ puts(str);

+ }

+enum ls_tree_cmdmode {

+ MODE_DEFAULT = 0,

+ MODE_LONG,

+ MODE_NAME_ONLY,

+ MODE_NAME_STATUS,

+ MODE_OBJECT_ONLY,

+};

+

+ enum ls_tree_cmdmode cmdmode = MODE_DEFAULT;

+ int null_termination = 0;

+ struct ls_tree_options options = { 0 };

+ OPT_BIT('d', NULL, &options.ls_options, N_("only show trees"),

+ OPT_BIT('r', NULL, &options.ls_options, N_("recurse into subtrees"),

+ OPT_BIT('t', NULL, &options.ls_options, N_("show trees when recursing"),

+ OPT_BOOL('z', NULL, &null_termination,

+ N_("terminate entries with NUL byte")),

+ OPT_SET_INT(0, "full-name", &options.chomp_prefix,

+ OPT_STRING_F(0, "format", &options.format, N_("format"),

+ OPT__ABBREV(&options.abbrev),

+ int ret;

+ options.ls_tree_prefix = prefix;

+ options.chomp_prefix = strlen(prefix);

+ options.null_termination = null_termination;

+

+ options.ls_tree_prefix = prefix = NULL;

+ options.chomp_prefix = 0;

+ ((LS_TREE_ONLY|LS_RECURSIVE) & options.ls_options))

+ options.ls_options |= LS_SHOW_TREES;

+ if (options.format && cmdmode)

+ parse_pathspec(&options.pathspec, PATHSPEC_ALL_MAGIC &

+ ~(PATHSPEC_FROMTOP | PATHSPEC_LITERAL),

+ for (i = 0; i < options.pathspec.nr; i++)

+ options.pathspec.items[i].nowildcard_len = options.pathspec.items[i].len;

+ options.pathspec.has_wildcard = 0;

+ fn = options.format ? show_tree_fmt : show_tree_default;

+ } else if (options.format && !strcmp(options.format, m2f->fmt)) {

+ } else if (!options.format && cmdmode == m2f->mode) {

+ ret = !!read_tree(the_repository, tree, &options.pathspec, fn, &options);

+ clear_pathspec(&options.pathspec);

+ return ret;

+#include "commit.h"

+static int show_outf(void *priv UNUSED, mmbuffer_t *mb, int nbuf)

+ const char *merge_base,

+ if (merge_base) {

+ struct commit *base_commit;

+ struct tree *base_tree, *parent1_tree, *parent2_tree;

+

+ base_commit = lookup_commit_reference_by_name(merge_base);

+ if (!base_commit)

+ die(_("could not lookup commit %s"), merge_base);

+

+ opt.ancestor = merge_base;

+ base_tree = get_commit_tree(base_commit);

+ parent1_tree = get_commit_tree(parent1);

+ parent2_tree = get_commit_tree(parent2);

+ merge_incore_nonrecursive(&opt, base_tree, parent1_tree, parent2_tree, &result);

+ } else {

+ /*

+ * Get the merge bases, in reverse order; see comment above

+ * merge_incore_recursive in merge-ort.h

+ */

+ merge_bases = get_merge_bases(parent1, parent2);

+ if (!merge_bases && !o->allow_unrelated_histories)

+ die(_("refusing to merge unrelated histories"));

+ merge_bases = reverse_commit_list(merge_bases);

+ merge_incore_recursive(&opt, merge_bases, parent1, parent2, &result);

+ }

+ const char *merge_base = NULL;

+ OPT_STRING(0, "merge-base",

+ &merge_base,

+ N_("commit"),

+ N_("specify a merge-base for the merge")),

+ if (merge_base)

+ die(_("--merge-base is incompatible with --stdin"));

+ const char *input_merge_base = NULL;

+ if (!split[0] || !split[1])

+ strbuf_rtrim(split[1]);

+

+ /* parse the merge-base */

+ if (!strcmp(split[1]->buf, "--")) {

+ input_merge_base = split[0]->buf;

+ }

+

+ if (input_merge_base && split[2] && split[3] && !split[4]) {

+ strbuf_rtrim(split[2]);

+ strbuf_rtrim(split[3]);

+ result = real_merge(&o, input_merge_base, split[2]->buf, split[3]->buf, prefix);

+ } else if (!input_merge_base && !split[2]) {

+ result = real_merge(&o, NULL, split[0]->buf, split[1]->buf, prefix);

+ } else {

+ die(_("malformed input line: '%s'."), buf.buf);

+ }

+

+ return real_merge(&o, merge_base, argv[0], argv[1], prefix);

+ for (j = 0; !found && j < ARRAY_SIZE(all_strategy); j++)

+ struct diff_options *opt UNUSED, void *data)

+ discard_index(&the_index);

+ git_check_attr(the_repository->index, NULL, path, check);

+ struct list_objects_filter_options filter_options =

+ LIST_OBJECTS_FILTER_INIT;

+ OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),

+ if (filter_options.choice) {

+ list_objects_filter_copy(&revs.filter, &filter_options);

+ list_objects_filter_release(&filter_options);

+ options = add_diff_options(range_diff_options, &diffopt);

+ OPT__SUPER_PREFIX(&opts.super_prefix),

+ struct string_list exec;

+ .exec = STRING_LIST_INIT_NODUP, \

+ &opts->orig_head->object.oid, &opts->exec,

+ OPT_STRING_LIST('x', "exec", &options.exec, N_("exec"),