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