816ab3d95f4a9e85c81ad1bd92d1acda02104e33
   1#!/bin/sh
   2#
   3# git-submodules.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] [--reference <repository>] [--] <repository> [<path>]
   9   or: $dashless [--quiet] status [--cached] [--recursive] [--] [<path>...]
  10   or: $dashless [--quiet] init [--] [<path>...]
  11   or: $dashless [--quiet] update [--init] [-N|--no-fetch] [-f|--force] [--rebase] [--reference <repository>] [--merge] [--recursive] [--] [<path>...]
  12   or: $dashless [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]
  13   or: $dashless [--quiet] foreach [--recursive] <command>
  14   or: $dashless [--quiet] sync [--] [<path>...]"
  15OPTIONS_SPEC=
  16. git-sh-setup
  17. git-sh-i18n
  18. git-parse-remote
  19require_work_tree
  20
  21command=
  22branch=
  23force=
  24reference=
  25cached=
  26recursive=
  27init=
  28files=
  29nofetch=
  30update=
  31prefix=
  32
  33# Resolve relative url by appending to parent's url
  34resolve_relative_url ()
  35{
  36        remote=$(get_default_remote)
  37        remoteurl=$(git config "remote.$remote.url") ||
  38                die "remote ($remote) does not have a url defined in .git/config"
  39        url="$1"
  40        remoteurl=${remoteurl%/}
  41        sep=/
  42        while test -n "$url"
  43        do
  44                case "$url" in
  45                ../*)
  46                        url="${url#../}"
  47                        case "$remoteurl" in
  48                        */*)
  49                                remoteurl="${remoteurl%/*}"
  50                                ;;
  51                        *:*)
  52                                remoteurl="${remoteurl%:*}"
  53                                sep=:
  54                                ;;
  55                        *)
  56                                die "cannot strip one component off url '$remoteurl'"
  57                                ;;
  58                        esac
  59                        ;;
  60                ./*)
  61                        url="${url#./}"
  62                        ;;
  63                *)
  64                        break;;
  65                esac
  66        done
  67        echo "$remoteurl$sep${url%/}"
  68}
  69
  70#
  71# Get submodule info for registered submodules
  72# $@ = path to limit submodule list
  73#
  74module_list()
  75{
  76        git ls-files --error-unmatch --stage -- "$@" |
  77        perl -e '
  78        my %unmerged = ();
  79        my ($null_sha1) = ("0" x 40);
  80        while (<STDIN>) {
  81                chomp;
  82                my ($mode, $sha1, $stage, $path) =
  83                        /^([0-7]+) ([0-9a-f]{40}) ([0-3])\t(.*)$/;
  84                next unless $mode eq "160000";
  85                if ($stage ne "0") {
  86                        if (!$unmerged{$path}++) {
  87                                print "$mode $null_sha1 U\t$path\n";
  88                        }
  89                        next;
  90                }
  91                print "$_\n";
  92        }
  93        '
  94}
  95
  96#
  97# Map submodule path to submodule name
  98#
  99# $1 = path
 100#
 101module_name()
 102{
 103        # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
 104        re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
 105        name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
 106                sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
 107       test -z "$name" &&
 108       die "No submodule mapping found in .gitmodules for path '$path'"
 109       echo "$name"
 110}
 111
 112#
 113# Clone a submodule
 114#
 115# Prior to calling, cmd_update checks that a possibly existing
 116# path is not a git repository.
 117# Likewise, cmd_add checks that path does not exist at all,
 118# since it is the location of a new submodule.
 119#
 120module_clone()
 121{
 122        path=$1
 123        url=$2
 124        reference="$3"
 125
 126        if test -n "$reference"
 127        then
 128                git-clone "$reference" -n "$url" "$path"
 129        else
 130                git-clone -n "$url" "$path"
 131        fi ||
 132        die "Clone of '$url' into submodule path '$path' failed"
 133}
 134
 135#
 136# Add a new submodule to the working tree, .gitmodules and the index
 137#
 138# $@ = repo path
 139#
 140# optional branch is stored in global branch variable
 141#
 142cmd_add()
 143{
 144        # parse $args after "submodule ... add".
 145        while test $# -ne 0
 146        do
 147                case "$1" in
 148                -b | --branch)
 149                        case "$2" in '') usage ;; esac
 150                        branch=$2
 151                        shift
 152                        ;;
 153                -f | --force)
 154                        force=$1
 155                        ;;
 156                -q|--quiet)
 157                        GIT_QUIET=1
 158                        ;;
 159                --reference)
 160                        case "$2" in '') usage ;; esac
 161                        reference="--reference=$2"
 162                        shift
 163                        ;;
 164                --reference=*)
 165                        reference="$1"
 166                        shift
 167                        ;;
 168                --)
 169                        shift
 170                        break
 171                        ;;
 172                -*)
 173                        usage
 174                        ;;
 175                *)
 176                        break
 177                        ;;
 178                esac
 179                shift
 180        done
 181
 182        repo=$1
 183        path=$2
 184
 185        if test -z "$path"; then
 186                path=$(echo "$repo" |
 187                        sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
 188        fi
 189
 190        if test -z "$repo" -o -z "$path"; then
 191                usage
 192        fi
 193
 194        # assure repo is absolute or relative to parent
 195        case "$repo" in
 196        ./*|../*)
 197                # dereference source url relative to parent's url
 198                realrepo=$(resolve_relative_url "$repo") || exit
 199                ;;
 200        *:*|/*)
 201                # absolute url
 202                realrepo=$repo
 203                ;;
 204        *)
 205                die "repo URL: '$repo' must be absolute or begin with ./|../"
 206        ;;
 207        esac
 208
 209        # normalize path:
 210        # multiple //; leading ./; /./; /../; trailing /
 211        path=$(printf '%s/\n' "$path" |
 212                sed -e '
 213                        s|//*|/|g
 214                        s|^\(\./\)*||
 215                        s|/\./|/|g
 216                        :start
 217                        s|\([^/]*\)/\.\./||
 218                        tstart
 219                        s|/*$||
 220                ')
 221        git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
 222        die "'$path' already exists in the index"
 223
 224        if test -z "$force" && ! git add --dry-run --ignore-missing "$path" > /dev/null 2>&1
 225        then
 226                echo >&2 "The following path is ignored by one of your .gitignore files:" &&
 227                echo >&2 $path &&
 228                echo >&2 "Use -f if you really want to add it."
 229                exit 1
 230        fi
 231
 232        # perhaps the path exists and is already a git repo, else clone it
 233        if test -e "$path"
 234        then
 235                if test -d "$path"/.git -o -f "$path"/.git
 236                then
 237                        echo "Adding existing repo at '$path' to the index"
 238                else
 239                        die "'$path' already exists and is not a valid git repo"
 240                fi
 241
 242                case "$repo" in
 243                ./*|../*)
 244                        url=$(resolve_relative_url "$repo") || exit
 245                    ;;
 246                *)
 247                        url="$repo"
 248                        ;;
 249                esac
 250                git config submodule."$path".url "$url"
 251        else
 252
 253                module_clone "$path" "$realrepo" "$reference" || exit
 254                (
 255                        clear_local_git_env
 256                        cd "$path" &&
 257                        # ash fails to wordsplit ${branch:+-b "$branch"...}
 258                        case "$branch" in
 259                        '') git checkout -f -q ;;
 260                        ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
 261                        esac
 262                ) || die "Unable to checkout submodule '$path'"
 263        fi
 264
 265        git add $force "$path" ||
 266        die "Failed to add submodule '$path'"
 267
 268        git config -f .gitmodules submodule."$path".path "$path" &&
 269        git config -f .gitmodules submodule."$path".url "$repo" &&
 270        git add --force .gitmodules ||
 271        die "Failed to register submodule '$path'"
 272}
 273
 274#
 275# Execute an arbitrary command sequence in each checked out
 276# submodule
 277#
 278# $@ = command to execute
 279#
 280cmd_foreach()
 281{
 282        # parse $args after "submodule ... foreach".
 283        while test $# -ne 0
 284        do
 285                case "$1" in
 286                -q|--quiet)
 287                        GIT_QUIET=1
 288                        ;;
 289                --recursive)
 290                        recursive=1
 291                        ;;
 292                -*)
 293                        usage
 294                        ;;
 295                *)
 296                        break
 297                        ;;
 298                esac
 299                shift
 300        done
 301
 302        toplevel=$(pwd)
 303
 304        module_list |
 305        while read mode sha1 stage path
 306        do
 307                if test -e "$path"/.git
 308                then
 309                        say "Entering '$prefix$path'"
 310                        name=$(module_name "$path")
 311                        (
 312                                prefix="$prefix$path/"
 313                                clear_local_git_env
 314                                cd "$path" &&
 315                                eval "$@" &&
 316                                if test -n "$recursive"
 317                                then
 318                                        cmd_foreach "--recursive" "$@"
 319                                fi
 320                        ) ||
 321                        die "Stopping at '$path'; script returned non-zero status."
 322                fi
 323        done
 324}
 325
 326#
 327# Register submodules in .git/config
 328#
 329# $@ = requested paths (default to all)
 330#
 331cmd_init()
 332{
 333        # parse $args after "submodule ... init".
 334        while test $# -ne 0
 335        do
 336                case "$1" in
 337                -q|--quiet)
 338                        GIT_QUIET=1
 339                        ;;
 340                --)
 341                        shift
 342                        break
 343                        ;;
 344                -*)
 345                        usage
 346                        ;;
 347                *)
 348                        break
 349                        ;;
 350                esac
 351                shift
 352        done
 353
 354        module_list "$@" |
 355        while read mode sha1 stage path
 356        do
 357                # Skip already registered paths
 358                name=$(module_name "$path") || exit
 359                url=$(git config submodule."$name".url)
 360                test -z "$url" || continue
 361
 362                url=$(git config -f .gitmodules submodule."$name".url)
 363                test -z "$url" &&
 364                die "No url found for submodule path '$path' in .gitmodules"
 365
 366                # Possibly a url relative to parent
 367                case "$url" in
 368                ./*|../*)
 369                        url=$(resolve_relative_url "$url") || exit
 370                        ;;
 371                esac
 372
 373                git config submodule."$name".url "$url" ||
 374                die "Failed to register url for submodule path '$path'"
 375
 376                upd="$(git config -f .gitmodules submodule."$name".update)"
 377                test -z "$upd" ||
 378                git config submodule."$name".update "$upd" ||
 379                die "Failed to register update mode for submodule path '$path'"
 380
 381                say "Submodule '$name' ($url) registered for path '$path'"
 382        done
 383}
 384
 385#
 386# Update each submodule path to correct revision, using clone and checkout as needed
 387#
 388# $@ = requested paths (default to all)
 389#
 390cmd_update()
 391{
 392        # parse $args after "submodule ... update".
 393        orig_flags=
 394        while test $# -ne 0
 395        do
 396                case "$1" in
 397                -q|--quiet)
 398                        GIT_QUIET=1
 399                        ;;
 400                -i|--init)
 401                        init=1
 402                        ;;
 403                -N|--no-fetch)
 404                        nofetch=1
 405                        ;;
 406                -f|--force)
 407                        force=$1
 408                        ;;
 409                -r|--rebase)
 410                        update="rebase"
 411                        ;;
 412                --reference)
 413                        case "$2" in '') usage ;; esac
 414                        reference="--reference=$2"
 415                        orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
 416                        shift
 417                        ;;
 418                --reference=*)
 419                        reference="$1"
 420                        ;;
 421                -m|--merge)
 422                        update="merge"
 423                        ;;
 424                --recursive)
 425                        recursive=1
 426                        ;;
 427                --)
 428                        shift
 429                        break
 430                        ;;
 431                -*)
 432                        usage
 433                        ;;
 434                *)
 435                        break
 436                        ;;
 437                esac
 438                orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
 439                shift
 440        done
 441
 442        if test -n "$init"
 443        then
 444                cmd_init "--" "$@" || return
 445        fi
 446
 447        cloned_modules=
 448        module_list "$@" |
 449        while read mode sha1 stage path
 450        do
 451                if test "$stage" = U
 452                then
 453                        echo >&2 "Skipping unmerged submodule $path"
 454                        continue
 455                fi
 456                name=$(module_name "$path") || exit
 457                url=$(git config submodule."$name".url)
 458                update_module=$(git config submodule."$name".update)
 459                if test -z "$url"
 460                then
 461                        # Only mention uninitialized submodules when its
 462                        # path have been specified
 463                        test "$#" != "0" &&
 464                        say "Submodule path '$path' not initialized" &&
 465                        say "Maybe you want to use 'update --init'?"
 466                        continue
 467                fi
 468
 469                if ! test -d "$path"/.git -o -f "$path"/.git
 470                then
 471                        module_clone "$path" "$url" "$reference"|| exit
 472                        cloned_modules="$cloned_modules;$name"
 473                        subsha1=
 474                else
 475                        subsha1=$(clear_local_git_env; cd "$path" &&
 476                                git rev-parse --verify HEAD) ||
 477                        die "Unable to find current revision in submodule path '$path'"
 478                fi
 479
 480                if ! test -z "$update"
 481                then
 482                        update_module=$update
 483                fi
 484
 485                if test "$subsha1" != "$sha1"
 486                then
 487                        subforce=$force
 488                        # If we don't already have a -f flag and the submodule has never been checked out
 489                        if test -z "$subsha1" -a -z "$force"
 490                        then
 491                                subforce="-f"
 492                        fi
 493
 494                        if test -z "$nofetch"
 495                        then
 496                                # Run fetch only if $sha1 isn't present or it
 497                                # is not reachable from a ref.
 498                                (clear_local_git_env; cd "$path" &&
 499                                        ((rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) &&
 500                                         test -z "$rev") || git-fetch)) ||
 501                                die "Unable to fetch in submodule path '$path'"
 502                        fi
 503
 504                        # Is this something we just cloned?
 505                        case ";$cloned_modules;" in
 506                        *";$name;"*)
 507                                # then there is no local change to integrate
 508                                update_module= ;;
 509                        esac
 510
 511                        case "$update_module" in
 512                        rebase)
 513                                command="git rebase"
 514                                action="rebase"
 515                                msg="rebased onto"
 516                                ;;
 517                        merge)
 518                                command="git merge"
 519                                action="merge"
 520                                msg="merged in"
 521                                ;;
 522                        *)
 523                                command="git checkout $subforce -q"
 524                                action="checkout"
 525                                msg="checked out"
 526                                ;;
 527                        esac
 528
 529                        (clear_local_git_env; cd "$path" && $command "$sha1") ||
 530                        die "Unable to $action '$sha1' in submodule path '$path'"
 531                        say "Submodule path '$path': $msg '$sha1'"
 532                fi
 533
 534                if test -n "$recursive"
 535                then
 536                        (clear_local_git_env; cd "$path" && eval cmd_update "$orig_flags") ||
 537                        die "Failed to recurse into submodule path '$path'"
 538                fi
 539        done
 540}
 541
 542set_name_rev () {
 543        revname=$( (
 544                clear_local_git_env
 545                cd "$1" && {
 546                        git describe "$2" 2>/dev/null ||
 547                        git describe --tags "$2" 2>/dev/null ||
 548                        git describe --contains "$2" 2>/dev/null ||
 549                        git describe --all --always "$2"
 550                }
 551        ) )
 552        test -z "$revname" || revname=" ($revname)"
 553}
 554#
 555# Show commit summary for submodules in index or working tree
 556#
 557# If '--cached' is given, show summary between index and given commit,
 558# or between working tree and given commit
 559#
 560# $@ = [commit (default 'HEAD'),] requested paths (default all)
 561#
 562cmd_summary() {
 563        summary_limit=-1
 564        for_status=
 565        diff_cmd=diff-index
 566
 567        # parse $args after "submodule ... summary".
 568        while test $# -ne 0
 569        do
 570                case "$1" in
 571                --cached)
 572                        cached="$1"
 573                        ;;
 574                --files)
 575                        files="$1"
 576                        ;;
 577                --for-status)
 578                        for_status="$1"
 579                        ;;
 580                -n|--summary-limit)
 581                        if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
 582                        then
 583                                :
 584                        else
 585                                usage
 586                        fi
 587                        shift
 588                        ;;
 589                --)
 590                        shift
 591                        break
 592                        ;;
 593                -*)
 594                        usage
 595                        ;;
 596                *)
 597                        break
 598                        ;;
 599                esac
 600                shift
 601        done
 602
 603        test $summary_limit = 0 && return
 604
 605        if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
 606        then
 607                head=$rev
 608                test $# = 0 || shift
 609        elif test -z "$1" -o "$1" = "HEAD"
 610        then
 611                # before the first commit: compare with an empty tree
 612                head=$(git hash-object -w -t tree --stdin </dev/null)
 613                test -z "$1" || shift
 614        else
 615                head="HEAD"
 616        fi
 617
 618        if [ -n "$files" ]
 619        then
 620                test -n "$cached" &&
 621                die "--cached cannot be used with --files"
 622                diff_cmd=diff-files
 623                head=
 624        fi
 625
 626        cd_to_toplevel
 627        # Get modified modules cared by user
 628        modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
 629                sane_egrep '^:([0-7]* )?160000' |
 630                while read mod_src mod_dst sha1_src sha1_dst status name
 631                do
 632                        # Always show modules deleted or type-changed (blob<->module)
 633                        test $status = D -o $status = T && echo "$name" && continue
 634                        # Also show added or modified modules which are checked out
 635                        GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
 636                        echo "$name"
 637                done
 638        )
 639
 640        test -z "$modules" && return
 641
 642        git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
 643        sane_egrep '^:([0-7]* )?160000' |
 644        cut -c2- |
 645        while read mod_src mod_dst sha1_src sha1_dst status name
 646        do
 647                if test -z "$cached" &&
 648                        test $sha1_dst = 0000000000000000000000000000000000000000
 649                then
 650                        case "$mod_dst" in
 651                        160000)
 652                                sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
 653                                ;;
 654                        100644 | 100755 | 120000)
 655                                sha1_dst=$(git hash-object $name)
 656                                ;;
 657                        000000)
 658                                ;; # removed
 659                        *)
 660                                # unexpected type
 661                                echo >&2 "unexpected mode $mod_dst"
 662                                continue ;;
 663                        esac
 664                fi
 665                missing_src=
 666                missing_dst=
 667
 668                test $mod_src = 160000 &&
 669                ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
 670                missing_src=t
 671
 672                test $mod_dst = 160000 &&
 673                ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
 674                missing_dst=t
 675
 676                total_commits=
 677                case "$missing_src,$missing_dst" in
 678                t,)
 679                        errmsg="  Warn: $name doesn't contain commit $sha1_src"
 680                        ;;
 681                ,t)
 682                        errmsg="  Warn: $name doesn't contain commit $sha1_dst"
 683                        ;;
 684                t,t)
 685                        errmsg="  Warn: $name doesn't contain commits $sha1_src and $sha1_dst"
 686                        ;;
 687                *)
 688                        errmsg=
 689                        total_commits=$(
 690                        if test $mod_src = 160000 -a $mod_dst = 160000
 691                        then
 692                                range="$sha1_src...$sha1_dst"
 693                        elif test $mod_src = 160000
 694                        then
 695                                range=$sha1_src
 696                        else
 697                                range=$sha1_dst
 698                        fi
 699                        GIT_DIR="$name/.git" \
 700                        git rev-list --first-parent $range -- | wc -l
 701                        )
 702                        total_commits=" ($(($total_commits + 0)))"
 703                        ;;
 704                esac
 705
 706                sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
 707                sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
 708                if test $status = T
 709                then
 710                        if test $mod_dst = 160000
 711                        then
 712                                echo "* $name $sha1_abbr_src(blob)->$sha1_abbr_dst(submodule)$total_commits:"
 713                        else
 714                                echo "* $name $sha1_abbr_src(submodule)->$sha1_abbr_dst(blob)$total_commits:"
 715                        fi
 716                else
 717                        echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
 718                fi
 719                if test -n "$errmsg"
 720                then
 721                        # Don't give error msg for modification whose dst is not submodule
 722                        # i.e. deleted or changed to blob
 723                        test $mod_dst = 160000 && echo "$errmsg"
 724                else
 725                        if test $mod_src = 160000 -a $mod_dst = 160000
 726                        then
 727                                limit=
 728                                test $summary_limit -gt 0 && limit="-$summary_limit"
 729                                GIT_DIR="$name/.git" \
 730                                git log $limit --pretty='format:  %m %s' \
 731                                --first-parent $sha1_src...$sha1_dst
 732                        elif test $mod_dst = 160000
 733                        then
 734                                GIT_DIR="$name/.git" \
 735                                git log --pretty='format:  > %s' -1 $sha1_dst
 736                        else
 737                                GIT_DIR="$name/.git" \
 738                                git log --pretty='format:  < %s' -1 $sha1_src
 739                        fi
 740                        echo
 741                fi
 742                echo
 743        done |
 744        if test -n "$for_status"; then
 745                if [ -n "$files" ]; then
 746                        echo "# Submodules changed but not updated:"
 747                else
 748                        echo "# Submodule changes to be committed:"
 749                fi
 750                echo "#"
 751                sed -e 's|^|# |' -e 's|^# $|#|'
 752        else
 753                cat
 754        fi
 755}
 756#
 757# List all submodules, prefixed with:
 758#  - submodule not initialized
 759#  + different revision checked out
 760#
 761# If --cached was specified the revision in the index will be printed
 762# instead of the currently checked out revision.
 763#
 764# $@ = requested paths (default to all)
 765#
 766cmd_status()
 767{
 768        # parse $args after "submodule ... status".
 769        orig_flags=
 770        while test $# -ne 0
 771        do
 772                case "$1" in
 773                -q|--quiet)
 774                        GIT_QUIET=1
 775                        ;;
 776                --cached)
 777                        cached=1
 778                        ;;
 779                --recursive)
 780                        recursive=1
 781                        ;;
 782                --)
 783                        shift
 784                        break
 785                        ;;
 786                -*)
 787                        usage
 788                        ;;
 789                *)
 790                        break
 791                        ;;
 792                esac
 793                orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
 794                shift
 795        done
 796
 797        module_list "$@" |
 798        while read mode sha1 stage path
 799        do
 800                name=$(module_name "$path") || exit
 801                url=$(git config submodule."$name".url)
 802                displaypath="$prefix$path"
 803                if test "$stage" = U
 804                then
 805                        say "U$sha1 $displaypath"
 806                        continue
 807                fi
 808                if test -z "$url" || ! test -d "$path"/.git -o -f "$path"/.git
 809                then
 810                        say "-$sha1 $displaypath"
 811                        continue;
 812                fi
 813                set_name_rev "$path" "$sha1"
 814                if git diff-files --ignore-submodules=dirty --quiet -- "$path"
 815                then
 816                        say " $sha1 $displaypath$revname"
 817                else
 818                        if test -z "$cached"
 819                        then
 820                                sha1=$(clear_local_git_env; cd "$path" && git rev-parse --verify HEAD)
 821                                set_name_rev "$path" "$sha1"
 822                        fi
 823                        say "+$sha1 $displaypath$revname"
 824                fi
 825
 826                if test -n "$recursive"
 827                then
 828                        (
 829                                prefix="$displaypath/"
 830                                clear_local_git_env
 831                                cd "$path" &&
 832                                eval cmd_status "$orig_args"
 833                        ) ||
 834                        die "Failed to recurse into submodule path '$path'"
 835                fi
 836        done
 837}
 838#
 839# Sync remote urls for submodules
 840# This makes the value for remote.$remote.url match the value
 841# specified in .gitmodules.
 842#
 843cmd_sync()
 844{
 845        while test $# -ne 0
 846        do
 847                case "$1" in
 848                -q|--quiet)
 849                        GIT_QUIET=1
 850                        shift
 851                        ;;
 852                --)
 853                        shift
 854                        break
 855                        ;;
 856                -*)
 857                        usage
 858                        ;;
 859                *)
 860                        break
 861                        ;;
 862                esac
 863        done
 864        cd_to_toplevel
 865        module_list "$@" |
 866        while read mode sha1 stage path
 867        do
 868                name=$(module_name "$path")
 869                url=$(git config -f .gitmodules --get submodule."$name".url)
 870
 871                # Possibly a url relative to parent
 872                case "$url" in
 873                ./*|../*)
 874                        url=$(resolve_relative_url "$url") || exit
 875                        ;;
 876                esac
 877
 878                say "Synchronizing submodule url for '$name'"
 879                git config submodule."$name".url "$url"
 880
 881                if test -e "$path"/.git
 882                then
 883                (
 884                        clear_local_git_env
 885                        cd "$path"
 886                        remote=$(get_default_remote)
 887                        git config remote."$remote".url "$url"
 888                )
 889                fi
 890        done
 891}
 892
 893# This loop parses the command line arguments to find the
 894# subcommand name to dispatch.  Parsing of the subcommand specific
 895# options are primarily done by the subcommand implementations.
 896# Subcommand specific options such as --branch and --cached are
 897# parsed here as well, for backward compatibility.
 898
 899while test $# != 0 && test -z "$command"
 900do
 901        case "$1" in
 902        add | foreach | init | update | status | summary | sync)
 903                command=$1
 904                ;;
 905        -q|--quiet)
 906                GIT_QUIET=1
 907                ;;
 908        -b|--branch)
 909                case "$2" in
 910                '')
 911                        usage
 912                        ;;
 913                esac
 914                branch="$2"; shift
 915                ;;
 916        --cached)
 917                cached="$1"
 918                ;;
 919        --)
 920                break
 921                ;;
 922        -*)
 923                usage
 924                ;;
 925        *)
 926                break
 927                ;;
 928        esac
 929        shift
 930done
 931
 932# No command word defaults to "status"
 933test -n "$command" || command=status
 934
 935# "-b branch" is accepted only by "add"
 936if test -n "$branch" && test "$command" != add
 937then
 938        usage
 939fi
 940
 941# "--cached" is accepted only by "status" and "summary"
 942if test -n "$cached" && test "$command" != status -a "$command" != summary
 943then
 944        usage
 945fi
 946
 947"cmd_$command" "$@"