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