39c241a1d898f2de2c3b09da9a5cf128ee14e5f8
   1#!/bin/sh
   2#
   3# git-submodule.sh: add, init, update or list git submodules
   4#
   5# Copyright (c) 2007 Lars Hjemli
   6
   7dashless=$(basename "$0" | sed -e 's/-/ /')
   8USAGE="[--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]
   9   or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...]
  10   or: $dashless [--quiet] init [--] [<path>...]
  11   or: $dashless [--quiet] deinit [-f|--force] (--all| [--] <path>...)
  12   or: $dashless [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--] [<path>...]
  13   or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]
  14   or: $dashless [--quiet] foreach [--recursive] <command>
  15   or: $dashless [--quiet] sync [--recursive] [--] [<path>...]
  16   or: $dashless [--quiet] absorbgitdirs [--] [<path>...]"
  17OPTIONS_SPEC=
  18SUBDIRECTORY_OK=Yes
  19. git-sh-setup
  20. git-parse-remote
  21require_work_tree
  22wt_prefix=$(git rev-parse --show-prefix)
  23cd_to_toplevel
  24
  25# Tell the rest of git that any URLs we get don't come
  26# directly from the user, so it can apply policy as appropriate.
  27GIT_PROTOCOL_FROM_USER=0
  28export GIT_PROTOCOL_FROM_USER
  29
  30command=
  31branch=
  32force=
  33reference=
  34cached=
  35recursive=
  36init=
  37files=
  38remote=
  39nofetch=
  40update=
  41prefix=
  42custom_name=
  43depth=
  44progress=
  45
  46die_if_unmatched ()
  47{
  48        if test "$1" = "#unmatched"
  49        then
  50                exit ${2:-1}
  51        fi
  52}
  53
  54#
  55# Print a submodule configuration setting
  56#
  57# $1 = submodule name
  58# $2 = option name
  59# $3 = default value
  60#
  61# Checks in the usual git-config places first (for overrides),
  62# otherwise it falls back on .gitmodules.  This allows you to
  63# distribute project-wide defaults in .gitmodules, while still
  64# customizing individual repositories if necessary.  If the option is
  65# not in .gitmodules either, print a default value.
  66#
  67get_submodule_config () {
  68        name="$1"
  69        option="$2"
  70        default="$3"
  71        value=$(git config submodule."$name"."$option")
  72        if test -z "$value"
  73        then
  74                value=$(git config -f .gitmodules submodule."$name"."$option")
  75        fi
  76        printf '%s' "${value:-$default}"
  77}
  78
  79isnumber()
  80{
  81        n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
  82}
  83
  84# Sanitize the local git environment for use within a submodule. We
  85# can't simply use clear_local_git_env since we want to preserve some
  86# of the settings from GIT_CONFIG_PARAMETERS.
  87sanitize_submodule_env()
  88{
  89        save_config=$GIT_CONFIG_PARAMETERS
  90        clear_local_git_env
  91        GIT_CONFIG_PARAMETERS=$save_config
  92        export GIT_CONFIG_PARAMETERS
  93}
  94
  95#
  96# Add a new submodule to the working tree, .gitmodules and the index
  97#
  98# $@ = repo path
  99#
 100# optional branch is stored in global branch variable
 101#
 102cmd_add()
 103{
 104        # parse $args after "submodule ... add".
 105        reference_path=
 106        while test $# -ne 0
 107        do
 108                case "$1" in
 109                -b | --branch)
 110                        case "$2" in '') usage ;; esac
 111                        branch=$2
 112                        shift
 113                        ;;
 114                -f | --force)
 115                        force=$1
 116                        ;;
 117                -q|--quiet)
 118                        GIT_QUIET=1
 119                        ;;
 120                --progress)
 121                        progress=1
 122                        ;;
 123                --reference)
 124                        case "$2" in '') usage ;; esac
 125                        reference_path=$2
 126                        shift
 127                        ;;
 128                --reference=*)
 129                        reference_path="${1#--reference=}"
 130                        ;;
 131                --name)
 132                        case "$2" in '') usage ;; esac
 133                        custom_name=$2
 134                        shift
 135                        ;;
 136                --depth)
 137                        case "$2" in '') usage ;; esac
 138                        depth="--depth=$2"
 139                        shift
 140                        ;;
 141                --depth=*)
 142                        depth=$1
 143                        ;;
 144                --)
 145                        shift
 146                        break
 147                        ;;
 148                -*)
 149                        usage
 150                        ;;
 151                *)
 152                        break
 153                        ;;
 154                esac
 155                shift
 156        done
 157
 158        if test -n "$reference_path"
 159        then
 160                is_absolute_path "$reference_path" ||
 161                reference_path="$wt_prefix$reference_path"
 162
 163                reference="--reference=$reference_path"
 164        fi
 165
 166        repo=$1
 167        sm_path=$2
 168
 169        if test -z "$sm_path"; then
 170                sm_path=$(printf '%s\n' "$repo" |
 171                        sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
 172        fi
 173
 174        if test -z "$repo" || test -z "$sm_path"; then
 175                usage
 176        fi
 177
 178        is_absolute_path "$sm_path" || sm_path="$wt_prefix$sm_path"
 179
 180        # assure repo is absolute or relative to parent
 181        case "$repo" in
 182        ./*|../*)
 183                test -z "$wt_prefix" ||
 184                die "$(gettext "Relative path can only be used from the toplevel of the working tree")"
 185
 186                # dereference source url relative to parent's url
 187                realrepo=$(git submodule--helper resolve-relative-url "$repo") || exit
 188                ;;
 189        *:*|/*)
 190                # absolute url
 191                realrepo=$repo
 192                ;;
 193        *)
 194                die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
 195        ;;
 196        esac
 197
 198        # normalize path:
 199        # multiple //; leading ./; /./; /../; trailing /
 200        sm_path=$(printf '%s/\n' "$sm_path" |
 201                sed -e '
 202                        s|//*|/|g
 203                        s|^\(\./\)*||
 204                        s|/\(\./\)*|/|g
 205                        :start
 206                        s|\([^/]*\)/\.\./||
 207                        tstart
 208                        s|/*$||
 209                ')
 210        if test -z "$force"
 211        then
 212                git ls-files --error-unmatch "$sm_path" > /dev/null 2>&1 &&
 213                die "$(eval_gettext "'\$sm_path' already exists in the index")"
 214        else
 215                git ls-files -s "$sm_path" | sane_grep -v "^160000" > /dev/null 2>&1 &&
 216                die "$(eval_gettext "'\$sm_path' already exists in the index and is not a submodule")"
 217        fi
 218
 219        if test -z "$force" &&
 220                ! git add --dry-run --ignore-missing --no-warn-embedded-repo "$sm_path" > /dev/null 2>&1
 221        then
 222                eval_gettextln "The following path is ignored by one of your .gitignore files:
 223\$sm_path
 224Use -f if you really want to add it." >&2
 225                exit 1
 226        fi
 227
 228        if test -n "$custom_name"
 229        then
 230                sm_name="$custom_name"
 231        else
 232                sm_name="$sm_path"
 233        fi
 234
 235        # perhaps the path exists and is already a git repo, else clone it
 236        if test -e "$sm_path"
 237        then
 238                if test -d "$sm_path"/.git || test -f "$sm_path"/.git
 239                then
 240                        eval_gettextln "Adding existing repo at '\$sm_path' to the index"
 241                else
 242                        die "$(eval_gettext "'\$sm_path' already exists and is not a valid git repo")"
 243                fi
 244
 245        else
 246                if test -d ".git/modules/$sm_name"
 247                then
 248                        if test -z "$force"
 249                        then
 250                                eval_gettextln >&2 "A git directory for '\$sm_name' is found locally with remote(s):"
 251                                GIT_DIR=".git/modules/$sm_name" GIT_WORK_TREE=. git remote -v | grep '(fetch)' | sed -e s,^,"  ", -e s,' (fetch)',, >&2
 252                                die "$(eval_gettextln "\
 253If you want to reuse this local git directory instead of cloning again from
 254  \$realrepo
 255use the '--force' option. If the local git directory is not the correct repo
 256or you are unsure what this means choose another name with the '--name' option.")"
 257                        else
 258                                eval_gettextln "Reactivating local git directory for submodule '\$sm_name'."
 259                        fi
 260                fi
 261                git submodule--helper clone ${GIT_QUIET:+--quiet} ${progress:+"--progress"} --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" ${reference:+"$reference"} ${depth:+"$depth"} || exit
 262                (
 263                        sanitize_submodule_env
 264                        cd "$sm_path" &&
 265                        # ash fails to wordsplit ${branch:+-b "$branch"...}
 266                        case "$branch" in
 267                        '') git checkout -f -q ;;
 268                        ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
 269                        esac
 270                ) || die "$(eval_gettext "Unable to checkout submodule '\$sm_path'")"
 271        fi
 272        git config submodule."$sm_name".url "$realrepo"
 273
 274        git add --no-warn-embedded-repo $force "$sm_path" ||
 275        die "$(eval_gettext "Failed to add submodule '\$sm_path'")"
 276
 277        git config -f .gitmodules submodule."$sm_name".path "$sm_path" &&
 278        git config -f .gitmodules submodule."$sm_name".url "$repo" &&
 279        if test -n "$branch"
 280        then
 281                git config -f .gitmodules submodule."$sm_name".branch "$branch"
 282        fi &&
 283        git add --force .gitmodules ||
 284        die "$(eval_gettext "Failed to register submodule '\$sm_path'")"
 285
 286        # NEEDSWORK: In a multi-working-tree world, this needs to be
 287        # set in the per-worktree config.
 288        if git config --get submodule.active >/dev/null
 289        then
 290                # If the submodule being adding isn't already covered by the
 291                # current configured pathspec, set the submodule's active flag
 292                if ! git submodule--helper is-active "$sm_path"
 293                then
 294                        git config submodule."$sm_name".active "true"
 295                fi
 296        else
 297                git config submodule."$sm_name".active "true"
 298        fi
 299}
 300
 301#
 302# Execute an arbitrary command sequence in each checked out
 303# submodule
 304#
 305# $@ = command to execute
 306#
 307cmd_foreach()
 308{
 309        # parse $args after "submodule ... foreach".
 310        while test $# -ne 0
 311        do
 312                case "$1" in
 313                -q|--quiet)
 314                        GIT_QUIET=1
 315                        ;;
 316                --recursive)
 317                        recursive=1
 318                        ;;
 319                -*)
 320                        usage
 321                        ;;
 322                *)
 323                        break
 324                        ;;
 325                esac
 326                shift
 327        done
 328
 329        toplevel=$(pwd)
 330
 331        # dup stdin so that it can be restored when running the external
 332        # command in the subshell (and a recursive call to this function)
 333        exec 3<&0
 334
 335        {
 336                git submodule--helper list --prefix "$wt_prefix" ||
 337                echo "#unmatched" $?
 338        } |
 339        while read -r mode sha1 stage sm_path
 340        do
 341                die_if_unmatched "$mode" "$sha1"
 342                if test -e "$sm_path"/.git
 343                then
 344                        displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
 345                        say "$(eval_gettext "Entering '\$displaypath'")"
 346                        name=$(git submodule--helper name "$sm_path")
 347                        (
 348                                prefix="$prefix$sm_path/"
 349                                sanitize_submodule_env
 350                                cd "$sm_path" &&
 351                                sm_path=$(git submodule--helper relative-path "$sm_path" "$wt_prefix") &&
 352                                # we make $path available to scripts ...
 353                                path=$sm_path &&
 354                                if test $# -eq 1
 355                                then
 356                                        eval "$1"
 357                                else
 358                                        "$@"
 359                                fi &&
 360                                if test -n "$recursive"
 361                                then
 362                                        cmd_foreach "--recursive" "$@"
 363                                fi
 364                        ) <&3 3<&- ||
 365                        die "$(eval_gettext "Stopping at '\$displaypath'; script returned non-zero status.")"
 366                fi
 367        done
 368}
 369
 370#
 371# Register submodules in .git/config
 372#
 373# $@ = requested paths (default to all)
 374#
 375cmd_init()
 376{
 377        # parse $args after "submodule ... init".
 378        while test $# -ne 0
 379        do
 380                case "$1" in
 381                -q|--quiet)
 382                        GIT_QUIET=1
 383                        ;;
 384                --)
 385                        shift
 386                        break
 387                        ;;
 388                -*)
 389                        usage
 390                        ;;
 391                *)
 392                        break
 393                        ;;
 394                esac
 395                shift
 396        done
 397
 398        git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper init ${GIT_QUIET:+--quiet}  "$@"
 399}
 400
 401#
 402# Unregister submodules from .git/config and remove their work tree
 403#
 404cmd_deinit()
 405{
 406        # parse $args after "submodule ... deinit".
 407        deinit_all=
 408        while test $# -ne 0
 409        do
 410                case "$1" in
 411                -f|--force)
 412                        force=$1
 413                        ;;
 414                -q|--quiet)
 415                        GIT_QUIET=1
 416                        ;;
 417                --all)
 418                        deinit_all=t
 419                        ;;
 420                --)
 421                        shift
 422                        break
 423                        ;;
 424                -*)
 425                        usage
 426                        ;;
 427                *)
 428                        break
 429                        ;;
 430                esac
 431                shift
 432        done
 433
 434        git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit ${GIT_QUIET:+--quiet} ${prefix:+--prefix "$prefix"} ${force:+--force} ${deinit_all:+--all} "$@"
 435}
 436
 437is_tip_reachable () (
 438        sanitize_submodule_env &&
 439        cd "$1" &&
 440        rev=$(git rev-list -n 1 "$2" --not --all 2>/dev/null) &&
 441        test -z "$rev"
 442)
 443
 444fetch_in_submodule () (
 445        sanitize_submodule_env &&
 446        cd "$1" &&
 447        case "$2" in
 448        '')
 449                git fetch ;;
 450        *)
 451                shift
 452                git fetch $(get_default_remote) "$@" ;;
 453        esac
 454)
 455
 456#
 457# Update each submodule path to correct revision, using clone and checkout as needed
 458#
 459# $@ = requested paths (default to all)
 460#
 461cmd_update()
 462{
 463        # parse $args after "submodule ... update".
 464        while test $# -ne 0
 465        do
 466                case "$1" in
 467                -q|--quiet)
 468                        GIT_QUIET=1
 469                        ;;
 470                --progress)
 471                        progress=1
 472                        ;;
 473                -i|--init)
 474                        init=1
 475                        ;;
 476                --remote)
 477                        remote=1
 478                        ;;
 479                -N|--no-fetch)
 480                        nofetch=1
 481                        ;;
 482                -f|--force)
 483                        force=$1
 484                        ;;
 485                -r|--rebase)
 486                        update="rebase"
 487                        ;;
 488                --reference)
 489                        case "$2" in '') usage ;; esac
 490                        reference="--reference=$2"
 491                        shift
 492                        ;;
 493                --reference=*)
 494                        reference="$1"
 495                        ;;
 496                -m|--merge)
 497                        update="merge"
 498                        ;;
 499                --recursive)
 500                        recursive=1
 501                        ;;
 502                --checkout)
 503                        update="checkout"
 504                        ;;
 505                --recommend-shallow)
 506                        recommend_shallow="--recommend-shallow"
 507                        ;;
 508                --no-recommend-shallow)
 509                        recommend_shallow="--no-recommend-shallow"
 510                        ;;
 511                --depth)
 512                        case "$2" in '') usage ;; esac
 513                        depth="--depth=$2"
 514                        shift
 515                        ;;
 516                --depth=*)
 517                        depth=$1
 518                        ;;
 519                -j|--jobs)
 520                        case "$2" in '') usage ;; esac
 521                        jobs="--jobs=$2"
 522                        shift
 523                        ;;
 524                --jobs=*)
 525                        jobs=$1
 526                        ;;
 527                --)
 528                        shift
 529                        break
 530                        ;;
 531                -*)
 532                        usage
 533                        ;;
 534                *)
 535                        break
 536                        ;;
 537                esac
 538                shift
 539        done
 540
 541        if test -n "$init"
 542        then
 543                cmd_init "--" "$@" || return
 544        fi
 545
 546        {
 547        git submodule--helper update-clone ${GIT_QUIET:+--quiet} \
 548                ${progress:+"--progress"} \
 549                ${wt_prefix:+--prefix "$wt_prefix"} \
 550                ${prefix:+--recursive-prefix "$prefix"} \
 551                ${update:+--update "$update"} \
 552                ${reference:+"$reference"} \
 553                ${depth:+--depth "$depth"} \
 554                $recommend_shallow \
 555                $jobs \
 556                "$@" || echo "#unmatched" $?
 557        } | {
 558        err=
 559        while read -r mode sha1 stage just_cloned sm_path
 560        do
 561                die_if_unmatched "$mode" "$sha1"
 562
 563                name=$(git submodule--helper name "$sm_path") || exit
 564                if ! test -z "$update"
 565                then
 566                        update_module=$update
 567                else
 568                        update_module=$(git config submodule."$name".update)
 569                        if test -z "$update_module"
 570                        then
 571                                update_module="checkout"
 572                        fi
 573                fi
 574
 575                displaypath=$(git submodule--helper relative-path "$prefix$sm_path" "$wt_prefix")
 576
 577                if test $just_cloned -eq 1
 578                then
 579                        subsha1=
 580                        case "$update_module" in
 581                        merge | rebase | none)
 582                                update_module=checkout ;;
 583                        esac
 584                else
 585                        subsha1=$(sanitize_submodule_env; cd "$sm_path" &&
 586                                git rev-parse --verify HEAD) ||
 587                        die "$(eval_gettext "Unable to find current revision in submodule path '\$displaypath'")"
 588                fi
 589
 590                if test -n "$remote"
 591                then
 592                        branch=$(git submodule--helper remote-branch "$sm_path")
 593                        if test -z "$nofetch"
 594                        then
 595                                # Fetch remote before determining tracking $sha1
 596                                fetch_in_submodule "$sm_path" $depth ||
 597                                die "$(eval_gettext "Unable to fetch in submodule path '\$sm_path'")"
 598                        fi
 599                        remote_name=$(sanitize_submodule_env; cd "$sm_path" && get_default_remote)
 600                        sha1=$(sanitize_submodule_env; cd "$sm_path" &&
 601                                git rev-parse --verify "${remote_name}/${branch}") ||
 602                        die "$(eval_gettext "Unable to find current \${remote_name}/\${branch} revision in submodule path '\$sm_path'")"
 603                fi
 604
 605                if test "$subsha1" != "$sha1" || test -n "$force"
 606                then
 607                        subforce=$force
 608                        # If we don't already have a -f flag and the submodule has never been checked out
 609                        if test -z "$subsha1" && test -z "$force"
 610                        then
 611                                subforce="-f"
 612                        fi
 613
 614                        if test -z "$nofetch"
 615                        then
 616                                # Run fetch only if $sha1 isn't present or it
 617                                # is not reachable from a ref.
 618                                is_tip_reachable "$sm_path" "$sha1" ||
 619                                fetch_in_submodule "$sm_path" $depth ||
 620                                die "$(eval_gettext "Unable to fetch in submodule path '\$displaypath'")"
 621
 622                                # Now we tried the usual fetch, but $sha1 may
 623                                # not be reachable from any of the refs
 624                                is_tip_reachable "$sm_path" "$sha1" ||
 625                                fetch_in_submodule "$sm_path" $depth "$sha1" ||
 626                                die "$(eval_gettext "Fetched in submodule path '\$displaypath', but it did not contain \$sha1. Direct fetching of that commit failed.")"
 627                        fi
 628
 629                        must_die_on_failure=
 630                        case "$update_module" in
 631                        checkout)
 632                                command="git checkout $subforce -q"
 633                                die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$displaypath'")"
 634                                say_msg="$(eval_gettext "Submodule path '\$displaypath': checked out '\$sha1'")"
 635                                ;;
 636                        rebase)
 637                                command="git rebase"
 638                                die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$displaypath'")"
 639                                say_msg="$(eval_gettext "Submodule path '\$displaypath': rebased into '\$sha1'")"
 640                                must_die_on_failure=yes
 641                                ;;
 642                        merge)
 643                                command="git merge"
 644                                die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$displaypath'")"
 645                                say_msg="$(eval_gettext "Submodule path '\$displaypath': merged in '\$sha1'")"
 646                                must_die_on_failure=yes
 647                                ;;
 648                        !*)
 649                                command="${update_module#!}"
 650                                die_msg="$(eval_gettext "Execution of '\$command \$sha1' failed in submodule path '\$displaypath'")"
 651                                say_msg="$(eval_gettext "Submodule path '\$displaypath': '\$command \$sha1'")"
 652                                must_die_on_failure=yes
 653                                ;;
 654                        *)
 655                                die "$(eval_gettext "Invalid update mode '$update_module' for submodule '$name'")"
 656                        esac
 657
 658                        if (sanitize_submodule_env; cd "$sm_path" && $command "$sha1")
 659                        then
 660                                say "$say_msg"
 661                        elif test -n "$must_die_on_failure"
 662                        then
 663                                die_with_status 2 "$die_msg"
 664                        else
 665                                err="${err};$die_msg"
 666                                continue
 667                        fi
 668                fi
 669
 670                if test -n "$recursive"
 671                then
 672                        (
 673                                prefix=$(git submodule--helper relative-path "$prefix$sm_path/" "$wt_prefix")
 674                                wt_prefix=
 675                                sanitize_submodule_env
 676                                cd "$sm_path" &&
 677                                eval cmd_update
 678                        )
 679                        res=$?
 680                        if test $res -gt 0
 681                        then
 682                                die_msg="$(eval_gettext "Failed to recurse into submodule path '\$displaypath'")"
 683                                if test $res -ne 2
 684                                then
 685                                        err="${err};$die_msg"
 686                                        continue
 687                                else
 688                                        die_with_status $res "$die_msg"
 689                                fi
 690                        fi
 691                fi
 692        done
 693
 694        if test -n "$err"
 695        then
 696                OIFS=$IFS
 697                IFS=';'
 698                for e in $err
 699                do
 700                        if test -n "$e"
 701                        then
 702                                echo >&2 "$e"
 703                        fi
 704                done
 705                IFS=$OIFS
 706                exit 1
 707        fi
 708        }
 709}
 710
 711#
 712# Show commit summary for submodules in index or working tree
 713#
 714# If '--cached' is given, show summary between index and given commit,
 715# or between working tree and given commit
 716#
 717# $@ = [commit (default 'HEAD'),] requested paths (default all)
 718#
 719cmd_summary() {
 720        summary_limit=-1
 721        for_status=
 722        diff_cmd=diff-index
 723
 724        # parse $args after "submodule ... summary".
 725        while test $# -ne 0
 726        do
 727                case "$1" in
 728                --cached)
 729                        cached="$1"
 730                        ;;
 731                --files)
 732                        files="$1"
 733                        ;;
 734                --for-status)
 735                        for_status="$1"
 736                        ;;
 737                -n|--summary-limit)
 738                        summary_limit="$2"
 739                        isnumber "$summary_limit" || usage
 740                        shift
 741                        ;;
 742                --summary-limit=*)
 743                        summary_limit="${1#--summary-limit=}"
 744                        isnumber "$summary_limit" || usage
 745                        ;;
 746                --)
 747                        shift
 748                        break
 749                        ;;
 750                -*)
 751                        usage
 752                        ;;
 753                *)
 754                        break
 755                        ;;
 756                esac
 757                shift
 758        done
 759
 760        test $summary_limit = 0 && return
 761
 762        if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
 763        then
 764                head=$rev
 765                test $# = 0 || shift
 766        elif test -z "$1" || test "$1" = "HEAD"
 767        then
 768                # before the first commit: compare with an empty tree
 769                head=$(git hash-object -w -t tree --stdin </dev/null)
 770                test -z "$1" || shift
 771        else
 772                head="HEAD"
 773        fi
 774
 775        if [ -n "$files" ]
 776        then
 777                test -n "$cached" &&
 778                die "$(gettext "The --cached option cannot be used with the --files option")"
 779                diff_cmd=diff-files
 780                head=
 781        fi
 782
 783        cd_to_toplevel
 784        eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
 785        # Get modified modules cared by user
 786        modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
 787                sane_egrep '^:([0-7]* )?160000' |
 788                while read -r mod_src mod_dst sha1_src sha1_dst status sm_path
 789                do
 790                        # Always show modules deleted or type-changed (blob<->module)
 791                        if test "$status" = D || test "$status" = T
 792                        then
 793                                printf '%s\n' "$sm_path"
 794                                continue
 795                        fi
 796                        # Respect the ignore setting for --for-status.
 797                        if test -n "$for_status"
 798                        then
 799                                name=$(git submodule--helper name "$sm_path")
 800                                ignore_config=$(get_submodule_config "$name" ignore none)
 801                                test $status != A && test $ignore_config = all && continue
 802                        fi
 803                        # Also show added or modified modules which are checked out
 804                        GIT_DIR="$sm_path/.git" git rev-parse --git-dir >/dev/null 2>&1 &&
 805                        printf '%s\n' "$sm_path"
 806                done
 807        )
 808
 809        test -z "$modules" && return
 810
 811        git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
 812        sane_egrep '^:([0-7]* )?160000' |
 813        cut -c2- |
 814        while read -r mod_src mod_dst sha1_src sha1_dst status name
 815        do
 816                if test -z "$cached" &&
 817                        test $sha1_dst = 0000000000000000000000000000000000000000
 818                then
 819                        case "$mod_dst" in
 820                        160000)
 821                                sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
 822                                ;;
 823                        100644 | 100755 | 120000)
 824                                sha1_dst=$(git hash-object $name)
 825                                ;;
 826                        000000)
 827                                ;; # removed
 828                        *)
 829                                # unexpected type
 830                                eval_gettextln "unexpected mode \$mod_dst" >&2
 831                                continue ;;
 832                        esac
 833                fi
 834                missing_src=
 835                missing_dst=
 836
 837                test $mod_src = 160000 &&
 838                ! GIT_DIR="$name/.git" git rev-parse -q --verify $sha1_src^0 >/dev/null &&
 839                missing_src=t
 840
 841                test $mod_dst = 160000 &&
 842                ! GIT_DIR="$name/.git" git rev-parse -q --verify $sha1_dst^0 >/dev/null &&
 843                missing_dst=t
 844
 845                display_name=$(git submodule--helper relative-path "$name" "$wt_prefix")
 846
 847                total_commits=
 848                case "$missing_src,$missing_dst" in
 849                t,)
 850                        errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commit \$sha1_src")"
 851                        ;;
 852                ,t)
 853                        errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commit \$sha1_dst")"
 854                        ;;
 855                t,t)
 856                        errmsg="$(eval_gettext "  Warn: \$display_name doesn't contain commits \$sha1_src and \$sha1_dst")"
 857                        ;;
 858                *)
 859                        errmsg=
 860                        total_commits=$(
 861                        if test $mod_src = 160000 && test $mod_dst = 160000
 862                        then
 863                                range="$sha1_src...$sha1_dst"
 864                        elif test $mod_src = 160000
 865                        then
 866                                range=$sha1_src
 867                        else
 868                                range=$sha1_dst
 869                        fi
 870                        GIT_DIR="$name/.git" \
 871                        git rev-list --first-parent $range -- | wc -l
 872                        )
 873                        total_commits=" ($(($total_commits + 0)))"
 874                        ;;
 875                esac
 876
 877                sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
 878                sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
 879                if test $status = T
 880                then
 881                        blob="$(gettext "blob")"
 882                        submodule="$(gettext "submodule")"
 883                        if test $mod_dst = 160000
 884                        then
 885                                echo "* $display_name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
 886                        else
 887                                echo "* $display_name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
 888                        fi
 889                else
 890                        echo "* $display_name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
 891                fi
 892                if test -n "$errmsg"
 893                then
 894                        # Don't give error msg for modification whose dst is not submodule
 895                        # i.e. deleted or changed to blob
 896                        test $mod_dst = 160000 && echo "$errmsg"
 897                else
 898                        if test $mod_src = 160000 && test $mod_dst = 160000
 899                        then
 900                                limit=
 901                                test $summary_limit -gt 0 && limit="-$summary_limit"
 902                                GIT_DIR="$name/.git" \
 903                                git log $limit --pretty='format:  %m %s' \
 904                                --first-parent $sha1_src...$sha1_dst
 905                        elif test $mod_dst = 160000
 906                        then
 907                                GIT_DIR="$name/.git" \
 908                                git log --pretty='format:  > %s' -1 $sha1_dst
 909                        else
 910                                GIT_DIR="$name/.git" \
 911                                git log --pretty='format:  < %s' -1 $sha1_src
 912                        fi
 913                        echo
 914                fi
 915                echo
 916        done
 917}
 918#
 919# List all submodules, prefixed with:
 920#  - submodule not initialized
 921#  + different revision checked out
 922#
 923# If --cached was specified the revision in the index will be printed
 924# instead of the currently checked out revision.
 925#
 926# $@ = requested paths (default to all)
 927#
 928cmd_status()
 929{
 930        # parse $args after "submodule ... status".
 931        while test $# -ne 0
 932        do
 933                case "$1" in
 934                -q|--quiet)
 935                        GIT_QUIET=1
 936                        ;;
 937                --cached)
 938                        cached=1
 939                        ;;
 940                --recursive)
 941                        recursive=1
 942                        ;;
 943                --)
 944                        shift
 945                        break
 946                        ;;
 947                -*)
 948                        usage
 949                        ;;
 950                *)
 951                        break
 952                        ;;
 953                esac
 954                shift
 955        done
 956
 957        git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper status ${GIT_QUIET:+--quiet} ${cached:+--cached} ${recursive:+--recursive} "$@"
 958}
 959#
 960# Sync remote urls for submodules
 961# This makes the value for remote.$remote.url match the value
 962# specified in .gitmodules.
 963#
 964cmd_sync()
 965{
 966        while test $# -ne 0
 967        do
 968                case "$1" in
 969                -q|--quiet)
 970                        GIT_QUIET=1
 971                        shift
 972                        ;;
 973                --recursive)
 974                        recursive=1
 975                        shift
 976                        ;;
 977                --)
 978                        shift
 979                        break
 980                        ;;
 981                -*)
 982                        usage
 983                        ;;
 984                *)
 985                        break
 986                        ;;
 987                esac
 988        done
 989
 990        git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper sync ${GIT_QUIET:+--quiet} ${recursive:+--recursive} "$@"
 991}
 992
 993cmd_absorbgitdirs()
 994{
 995        git submodule--helper absorb-git-dirs --prefix "$wt_prefix" "$@"
 996}
 997
 998# This loop parses the command line arguments to find the
 999# subcommand name to dispatch.  Parsing of the subcommand specific
1000# options are primarily done by the subcommand implementations.
1001# Subcommand specific options such as --branch and --cached are
1002# parsed here as well, for backward compatibility.
1003
1004while test $# != 0 && test -z "$command"
1005do
1006        case "$1" in
1007        add | foreach | init | deinit | update | status | summary | sync | absorbgitdirs)
1008                command=$1
1009                ;;
1010        -q|--quiet)
1011                GIT_QUIET=1
1012                ;;
1013        -b|--branch)
1014                case "$2" in
1015                '')
1016                        usage
1017                        ;;
1018                esac
1019                branch="$2"; shift
1020                ;;
1021        --cached)
1022                cached="$1"
1023                ;;
1024        --)
1025                break
1026                ;;
1027        -*)
1028                usage
1029                ;;
1030        *)
1031                break
1032                ;;
1033        esac
1034        shift
1035done
1036
1037# No command word defaults to "status"
1038if test -z "$command"
1039then
1040    if test $# = 0
1041    then
1042        command=status
1043    else
1044        usage
1045    fi
1046fi
1047
1048# "-b branch" is accepted only by "add"
1049if test -n "$branch" && test "$command" != add
1050then
1051        usage
1052fi
1053
1054# "--cached" is accepted only by "status" and "summary"
1055if test -n "$cached" && test "$command" != status && test "$command" != summary
1056then
1057        usage
1058fi
1059
1060"cmd_$command" "$@"