submodule: Fix t7400, t7405, t7406 for msysGit
[git/dscho.git] / git-submodule.sh
blobde06bc1471273640fed0b4bff9fc7f4214eef439
1 #!/bin/sh
3 # git-submodules.sh: add, init, update or list git submodules
5 # Copyright (c) 2007 Lars Hjemli
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
21 command=
22 branch=
23 force=
24 reference=
25 cached=
26 recursive=
27 init=
28 files=
29 nofetch=
30 update=
31 prefix=
33 # Resolve relative url by appending to parent's url
34 resolve_relative_url ()
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"
44 case "$url" in
45 ../*)
46 url="${url#../}"
47 case "$remoteurl" in
48 */*)
49 remoteurl="${remoteurl%/*}"
51 *:*)
52 remoteurl="${remoteurl%:*}"
53 sep=:
56 die "$(eval_gettext "cannot strip one component off url '\$remoteurl'")"
58 esac
60 ./*)
61 url="${url#./}"
64 break;;
65 esac
66 done
67 echo "$remoteurl$sep${url%/}"
71 # Get submodule info for registered submodules
72 # $@ = path to limit submodule list
74 module_list()
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";
89 next;
91 print "$_\n";
97 # Map submodule path to submodule name
99 # $1 = path
101 module_name()
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"
113 # Clone a submodule
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.
120 module_clone()
122 path=$1
123 url=$2
124 reference="$3"
125 quiet=
126 if test -n "$GIT_QUIET"
127 then
128 quiet=-q
131 gitdir=
132 gitdir_base=
133 name=$(module_name "$path" 2>/dev/null)
134 base_path=$(dirname "$path")
136 gitdir=$(git rev-parse --git-dir)
137 gitdir_base="$gitdir/modules/$base_path"
138 gitdir="$gitdir/modules/$path"
140 case $gitdir in
142 a="$(cd_to_toplevel && pwd)/"
143 b=$gitdir
144 while [ "$b" ] && [ "${a%%/*}" = "${b%%/*}" ]
146 a=${a#*/} b=${b#*/};
147 done
149 rel="$a$name"
150 rel=`echo $rel | sed -e 's|[^/]*|..|g'`
151 rel_gitdir="$rel/$b"
154 rel=`echo $name | sed -e 's|[^/]*|..|g'`
155 rel_gitdir="$rel/$gitdir"
157 esac
159 if test -d "$gitdir"
160 then
161 mkdir -p "$path"
162 echo "gitdir: $rel_gitdir" >"$path/.git"
163 rm -f "$gitdir/index"
164 else
165 mkdir -p "$gitdir_base"
166 if test -n "$reference"
167 then
168 git-clone $quiet "$reference" -n "$url" "$path" --separate-git-dir "$gitdir"
169 else
170 git-clone $quiet -n "$url" "$path" --separate-git-dir "$gitdir"
171 fi ||
172 die "$(eval_gettext "Clone of '\$url' into submodule path '\$path' failed")"
177 # Add a new submodule to the working tree, .gitmodules and the index
179 # $@ = repo path
181 # optional branch is stored in global branch variable
183 cmd_add()
185 # parse $args after "submodule ... add".
186 while test $# -ne 0
188 case "$1" in
189 -b | --branch)
190 case "$2" in '') usage ;; esac
191 branch=$2
192 shift
194 -f | --force)
195 force=$1
197 -q|--quiet)
198 GIT_QUIET=1
200 --reference)
201 case "$2" in '') usage ;; esac
202 reference="--reference=$2"
203 shift
205 --reference=*)
206 reference="$1"
207 shift
210 shift
211 break
214 usage
217 break
219 esac
220 shift
221 done
223 repo=$1
224 path=$2
226 if test -z "$path"; then
227 path=$(echo "$repo" |
228 sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
231 if test -z "$repo" -o -z "$path"; then
232 usage
235 # assure repo is absolute or relative to parent
236 case "$repo" in
237 ./*|../*)
238 # dereference source url relative to parent's url
239 realrepo=$(resolve_relative_url "$repo") || exit
241 *:*|/*)
242 # absolute url
243 realrepo=$repo
246 die "$(eval_gettext "repo URL: '\$repo' must be absolute or begin with ./|../")"
248 esac
250 # normalize path:
251 # multiple //; leading ./; /./; /../; trailing /
252 path=$(printf '%s/\n' "$path" |
253 sed -e '
254 s|//*|/|g
255 s|^\(\./\)*||
256 s|/\./|/|g
257 :start
258 s|\([^/]*\)/\.\./||
259 tstart
260 s|/*$||
262 git ls-files --error-unmatch "$path" > /dev/null 2>&1 &&
263 die "$(eval_gettext "'\$path' already exists in the index")"
265 if test -z "$force" && ! git add --dry-run --ignore-missing "$path" > /dev/null 2>&1
266 then
267 cat >&2 <<EOF
268 The following path is ignored by one of your .gitignore files:
269 $(eval_gettextln $path)
270 Use -f if you really want to add it.
272 exit 1
275 # perhaps the path exists and is already a git repo, else clone it
276 if test -e "$path"
277 then
278 if test -d "$path"/.git -o -f "$path"/.git
279 then
280 eval_gettextln "Adding existing repo at '\$path' to the index"
281 else
282 die "$(eval_gettext "'\$path' already exists and is not a valid git repo")"
285 else
287 module_clone "$path" "$realrepo" "$reference" || exit
289 clear_local_git_env
290 cd "$path" &&
291 # ash fails to wordsplit ${branch:+-b "$branch"...}
292 case "$branch" in
293 '') git checkout -f -q ;;
294 ?*) git checkout -f -q -B "$branch" "origin/$branch" ;;
295 esac
296 ) || die "$(eval_gettext "Unable to checkout submodule '\$path'")"
298 git config submodule."$path".url "$realrepo"
300 git add $force "$path" ||
301 die "$(eval_gettext "Failed to add submodule '\$path'")"
303 git config -f .gitmodules submodule."$path".path "$path" &&
304 git config -f .gitmodules submodule."$path".url "$repo" &&
305 git add --force .gitmodules ||
306 die "$(eval_gettext "Failed to register submodule '\$path'")"
310 # Execute an arbitrary command sequence in each checked out
311 # submodule
313 # $@ = command to execute
315 cmd_foreach()
317 # parse $args after "submodule ... foreach".
318 while test $# -ne 0
320 case "$1" in
321 -q|--quiet)
322 GIT_QUIET=1
324 --recursive)
325 recursive=1
328 usage
331 break
333 esac
334 shift
335 done
337 toplevel=$(pwd)
339 # dup stdin so that it can be restored when running the external
340 # command in the subshell (and a recursive call to this function)
341 exec 3<&0
343 module_list |
344 while read mode sha1 stage path
346 if test -e "$path"/.git
347 then
348 say "$(eval_gettext "Entering '\$prefix\$path'")"
349 name=$(module_name "$path")
351 prefix="$prefix$path/"
352 clear_local_git_env
353 cd "$path" &&
354 eval "$@" &&
355 if test -n "$recursive"
356 then
357 cmd_foreach "--recursive" "$@"
359 ) <&3 3<&- ||
360 die "$(eval_gettext "Stopping at '\$path'; script returned non-zero status.")"
362 done
366 # Register submodules in .git/config
368 # $@ = requested paths (default to all)
370 cmd_init()
372 # parse $args after "submodule ... init".
373 while test $# -ne 0
375 case "$1" in
376 -q|--quiet)
377 GIT_QUIET=1
380 shift
381 break
384 usage
387 break
389 esac
390 shift
391 done
393 module_list "$@" |
394 while read mode sha1 stage path
396 # Skip already registered paths
397 name=$(module_name "$path") || exit
398 if test -z "$(git config "submodule.$name.url")"
399 then
400 url=$(git config -f .gitmodules submodule."$name".url)
401 test -z "$url" &&
402 die "$(eval_gettext "No url found for submodule path '\$path' in .gitmodules")"
404 # Possibly a url relative to parent
405 case "$url" in
406 ./*|../*)
407 url=$(resolve_relative_url "$url") || exit
409 esac
410 git config submodule."$name".url "$url" ||
411 die "$(eval_gettext "Failed to register url for submodule path '\$path'")"
414 # Copy "update" setting when it is not set yet
415 upd="$(git config -f .gitmodules submodule."$name".update)"
416 test -z "$upd" ||
417 test -n "$(git config submodule."$name".update)" ||
418 git config submodule."$name".update "$upd" ||
419 die "$(eval_gettext "Failed to register update mode for submodule path '\$path'")"
421 say "$(eval_gettext "Submodule '\$name' (\$url) registered for path '\$path'")"
422 done
426 # Update each submodule path to correct revision, using clone and checkout as needed
428 # $@ = requested paths (default to all)
430 cmd_update()
432 # parse $args after "submodule ... update".
433 orig_flags=
434 while test $# -ne 0
436 case "$1" in
437 -q|--quiet)
438 GIT_QUIET=1
440 -i|--init)
441 init=1
443 -N|--no-fetch)
444 nofetch=1
446 -f|--force)
447 force=$1
449 -r|--rebase)
450 update="rebase"
452 --reference)
453 case "$2" in '') usage ;; esac
454 reference="--reference=$2"
455 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
456 shift
458 --reference=*)
459 reference="$1"
461 -m|--merge)
462 update="merge"
464 --recursive)
465 recursive=1
467 --checkout)
468 update="checkout"
471 shift
472 break
475 usage
478 break
480 esac
481 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
482 shift
483 done
485 if test -n "$init"
486 then
487 cmd_init "--" "$@" || return
490 cloned_modules=
491 module_list "$@" | {
492 err=
493 while read mode sha1 stage path
495 if test "$stage" = U
496 then
497 echo >&2 "Skipping unmerged submodule $path"
498 continue
500 name=$(module_name "$path") || exit
501 url=$(git config submodule."$name".url)
502 if ! test -z "$update"
503 then
504 update_module=$update
505 else
506 update_module=$(git config submodule."$name".update)
509 if test "$update_module" = "none"
510 then
511 echo "Skipping submodule '$path'"
512 continue
515 if test -z "$url"
516 then
517 # Only mention uninitialized submodules when its
518 # path have been specified
519 test "$#" != "0" &&
520 say "$(eval_gettext "Submodule path '\$path' not initialized
521 Maybe you want to use 'update --init'?")"
522 continue
525 if ! test -d "$path"/.git -o -f "$path"/.git
526 then
527 module_clone "$path" "$url" "$reference"|| exit
528 cloned_modules="$cloned_modules;$name"
529 subsha1=
530 else
531 subsha1=$(clear_local_git_env; cd "$path" &&
532 git rev-parse --verify HEAD) ||
533 die "$(eval_gettext "Unable to find current revision in submodule path '\$path'")"
536 if test "$subsha1" != "$sha1"
537 then
538 subforce=$force
539 # If we don't already have a -f flag and the submodule has never been checked out
540 if test -z "$subsha1" -a -z "$force"
541 then
542 subforce="-f"
545 if test -z "$nofetch"
546 then
547 # Run fetch only if $sha1 isn't present or it
548 # is not reachable from a ref.
549 (clear_local_git_env; cd "$path" &&
550 ( (rev=$(git rev-list -n 1 $sha1 --not --all 2>/dev/null) &&
551 test -z "$rev") || git-fetch)) ||
552 die "$(eval_gettext "Unable to fetch in submodule path '\$path'")"
555 # Is this something we just cloned?
556 case ";$cloned_modules;" in
557 *";$name;"*)
558 # then there is no local change to integrate
559 update_module= ;;
560 esac
562 must_die_on_failure=
563 case "$update_module" in
564 rebase)
565 command="git rebase"
566 die_msg="$(eval_gettext "Unable to rebase '\$sha1' in submodule path '\$path'")"
567 say_msg="$(eval_gettext "Submodule path '\$path': rebased into '\$sha1'")"
568 must_die_on_failure=yes
570 merge)
571 command="git merge"
572 die_msg="$(eval_gettext "Unable to merge '\$sha1' in submodule path '\$path'")"
573 say_msg="$(eval_gettext "Submodule path '\$path': merged in '\$sha1'")"
574 must_die_on_failure=yes
577 command="git checkout $subforce -q"
578 die_msg="$(eval_gettext "Unable to checkout '\$sha1' in submodule path '\$path'")"
579 say_msg="$(eval_gettext "Submodule path '\$path': checked out '\$sha1'")"
581 esac
583 if (clear_local_git_env; cd "$path" && $command "$sha1")
584 then
585 say "$say_msg"
586 elif test -n "$must_die_on_failure"
587 then
588 die_with_status 2 "$die_msg"
589 else
590 err="${err};$die_msg"
591 continue
595 if test -n "$recursive"
596 then
597 (clear_local_git_env; cd "$path" && eval cmd_update "$orig_flags")
598 res=$?
599 if test $res -gt 0
600 then
601 die_msg="$(eval_gettext "Failed to recurse into submodule path '\$path'")"
602 if test $res -eq 1
603 then
604 err="${err};$die_msg"
605 continue
606 else
607 die_with_status $res "$die_msg"
611 done
613 if test -n "$err"
614 then
615 OIFS=$IFS
616 IFS=';'
617 for e in $err
619 if test -n "$e"
620 then
621 echo >&2 "$e"
623 done
624 IFS=$OIFS
625 exit 1
630 set_name_rev () {
631 revname=$( (
632 clear_local_git_env
633 cd "$1" && {
634 git describe "$2" 2>/dev/null ||
635 git describe --tags "$2" 2>/dev/null ||
636 git describe --contains "$2" 2>/dev/null ||
637 git describe --all --always "$2"
640 test -z "$revname" || revname=" ($revname)"
643 # Show commit summary for submodules in index or working tree
645 # If '--cached' is given, show summary between index and given commit,
646 # or between working tree and given commit
648 # $@ = [commit (default 'HEAD'),] requested paths (default all)
650 cmd_summary() {
651 summary_limit=-1
652 for_status=
653 diff_cmd=diff-index
655 # parse $args after "submodule ... summary".
656 while test $# -ne 0
658 case "$1" in
659 --cached)
660 cached="$1"
662 --files)
663 files="$1"
665 --for-status)
666 for_status="$1"
668 -n|--summary-limit)
669 if summary_limit=$(($2 + 0)) 2>/dev/null && test "$summary_limit" = "$2"
670 then
672 else
673 usage
675 shift
678 shift
679 break
682 usage
685 break
687 esac
688 shift
689 done
691 test $summary_limit = 0 && return
693 if rev=$(git rev-parse -q --verify --default HEAD ${1+"$1"})
694 then
695 head=$rev
696 test $# = 0 || shift
697 elif test -z "$1" -o "$1" = "HEAD"
698 then
699 # before the first commit: compare with an empty tree
700 head=$(git hash-object -w -t tree --stdin </dev/null)
701 test -z "$1" || shift
702 else
703 head="HEAD"
706 if [ -n "$files" ]
707 then
708 test -n "$cached" &&
709 die "$(gettext -- "--cached cannot be used with --files")"
710 diff_cmd=diff-files
711 head=
714 cd_to_toplevel
715 # Get modified modules cared by user
716 modules=$(git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- "$@" |
717 sane_egrep '^:([0-7]* )?160000' |
718 while read mod_src mod_dst sha1_src sha1_dst status name
720 # Always show modules deleted or type-changed (blob<->module)
721 test $status = D -o $status = T && echo "$name" && continue
722 # Also show added or modified modules which are checked out
723 GIT_DIR="$name/.git" git-rev-parse --git-dir >/dev/null 2>&1 &&
724 echo "$name"
725 done
728 test -z "$modules" && return
730 git $diff_cmd $cached --ignore-submodules=dirty --raw $head -- $modules |
731 sane_egrep '^:([0-7]* )?160000' |
732 cut -c2- |
733 while read mod_src mod_dst sha1_src sha1_dst status name
735 if test -z "$cached" &&
736 test $sha1_dst = 0000000000000000000000000000000000000000
737 then
738 case "$mod_dst" in
739 160000)
740 sha1_dst=$(GIT_DIR="$name/.git" git rev-parse HEAD)
742 100644 | 100755 | 120000)
743 sha1_dst=$(git hash-object $name)
745 000000)
746 ;; # removed
748 # unexpected type
749 eval_gettextln "unexpected mode \$mod_dst" >&2
750 continue ;;
751 esac
753 missing_src=
754 missing_dst=
756 test $mod_src = 160000 &&
757 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_src^0 >/dev/null &&
758 missing_src=t
760 test $mod_dst = 160000 &&
761 ! GIT_DIR="$name/.git" git-rev-parse -q --verify $sha1_dst^0 >/dev/null &&
762 missing_dst=t
764 total_commits=
765 case "$missing_src,$missing_dst" in
767 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_src")"
770 errmsg="$(eval_gettext " Warn: \$name doesn't contain commit \$sha1_dst")"
772 t,t)
773 errmsg="$(eval_gettext " Warn: \$name doesn't contain commits \$sha1_src and \$sha1_dst")"
776 errmsg=
777 total_commits=$(
778 if test $mod_src = 160000 -a $mod_dst = 160000
779 then
780 range="$sha1_src...$sha1_dst"
781 elif test $mod_src = 160000
782 then
783 range=$sha1_src
784 else
785 range=$sha1_dst
787 GIT_DIR="$name/.git" \
788 git rev-list --first-parent $range -- | wc -l
790 total_commits=" ($(($total_commits + 0)))"
792 esac
794 sha1_abbr_src=$(echo $sha1_src | cut -c1-7)
795 sha1_abbr_dst=$(echo $sha1_dst | cut -c1-7)
796 if test $status = T
797 then
798 blob="$(gettext "blob")"
799 submodule="$(gettext "submodule")"
800 if test $mod_dst = 160000
801 then
802 echo "* $name $sha1_abbr_src($blob)->$sha1_abbr_dst($submodule)$total_commits:"
803 else
804 echo "* $name $sha1_abbr_src($submodule)->$sha1_abbr_dst($blob)$total_commits:"
806 else
807 echo "* $name $sha1_abbr_src...$sha1_abbr_dst$total_commits:"
809 if test -n "$errmsg"
810 then
811 # Don't give error msg for modification whose dst is not submodule
812 # i.e. deleted or changed to blob
813 test $mod_dst = 160000 && echo "$errmsg"
814 else
815 if test $mod_src = 160000 -a $mod_dst = 160000
816 then
817 limit=
818 test $summary_limit -gt 0 && limit="-$summary_limit"
819 GIT_DIR="$name/.git" \
820 git log $limit --pretty='format: %m %s' \
821 --first-parent $sha1_src...$sha1_dst
822 elif test $mod_dst = 160000
823 then
824 GIT_DIR="$name/.git" \
825 git log --pretty='format: > %s' -1 $sha1_dst
826 else
827 GIT_DIR="$name/.git" \
828 git log --pretty='format: < %s' -1 $sha1_src
830 echo
832 echo
833 done |
834 if test -n "$for_status"; then
835 if [ -n "$files" ]; then
836 status_msg="$(gettextln "# Submodules changed but not updated:")"
837 else
838 status_msg="$(gettextln "# Submodule changes to be committed:")"
840 status_sed=$(sed -e 's|^|# |' -e 's|^# $|#|')
841 cat <<EOF
842 $status_msg
844 $status_sed
846 else
851 # List all submodules, prefixed with:
852 # - submodule not initialized
853 # + different revision checked out
855 # If --cached was specified the revision in the index will be printed
856 # instead of the currently checked out revision.
858 # $@ = requested paths (default to all)
860 cmd_status()
862 # parse $args after "submodule ... status".
863 orig_flags=
864 while test $# -ne 0
866 case "$1" in
867 -q|--quiet)
868 GIT_QUIET=1
870 --cached)
871 cached=1
873 --recursive)
874 recursive=1
877 shift
878 break
881 usage
884 break
886 esac
887 orig_flags="$orig_flags $(git rev-parse --sq-quote "$1")"
888 shift
889 done
891 module_list "$@" |
892 while read mode sha1 stage path
894 name=$(module_name "$path") || exit
895 url=$(git config submodule."$name".url)
896 displaypath="$prefix$path"
897 if test "$stage" = U
898 then
899 say "U$sha1 $displaypath"
900 continue
902 if test -z "$url" || ! test -d "$path"/.git -o -f "$path"/.git
903 then
904 say "-$sha1 $displaypath"
905 continue;
907 set_name_rev "$path" "$sha1"
908 if git diff-files --ignore-submodules=dirty --quiet -- "$path"
909 then
910 say " $sha1 $displaypath$revname"
911 else
912 if test -z "$cached"
913 then
914 sha1=$(clear_local_git_env; cd "$path" && git rev-parse --verify HEAD)
915 set_name_rev "$path" "$sha1"
917 say "+$sha1 $displaypath$revname"
920 if test -n "$recursive"
921 then
923 prefix="$displaypath/"
924 clear_local_git_env
925 cd "$path" &&
926 eval cmd_status "$orig_args"
927 ) ||
928 die "$(eval_gettext "Failed to recurse into submodule path '\$path'")"
930 done
933 # Sync remote urls for submodules
934 # This makes the value for remote.$remote.url match the value
935 # specified in .gitmodules.
937 cmd_sync()
939 while test $# -ne 0
941 case "$1" in
942 -q|--quiet)
943 GIT_QUIET=1
944 shift
947 shift
948 break
951 usage
954 break
956 esac
957 done
958 cd_to_toplevel
959 module_list "$@" |
960 while read mode sha1 stage path
962 name=$(module_name "$path")
963 url=$(git config -f .gitmodules --get submodule."$name".url)
965 # Possibly a url relative to parent
966 case "$url" in
967 ./*|../*)
968 url=$(resolve_relative_url "$url") || exit
970 esac
972 if git config "submodule.$name.url" >/dev/null 2>/dev/null
973 then
974 say "$(eval_gettext "Synchronizing submodule url for '\$name'")"
975 git config submodule."$name".url "$url"
977 if test -e "$path"/.git
978 then
980 clear_local_git_env
981 cd "$path"
982 remote=$(get_default_remote)
983 git config remote."$remote".url "$url"
987 done
990 # This loop parses the command line arguments to find the
991 # subcommand name to dispatch. Parsing of the subcommand specific
992 # options are primarily done by the subcommand implementations.
993 # Subcommand specific options such as --branch and --cached are
994 # parsed here as well, for backward compatibility.
996 while test $# != 0 && test -z "$command"
998 case "$1" in
999 add | foreach | init | update | status | summary | sync)
1000 command=$1
1002 -q|--quiet)
1003 GIT_QUIET=1
1005 -b|--branch)
1006 case "$2" in
1008 usage
1010 esac
1011 branch="$2"; shift
1013 --cached)
1014 cached="$1"
1017 break
1020 usage
1023 break
1025 esac
1026 shift
1027 done
1029 # No command word defaults to "status"
1030 test -n "$command" || command=status
1032 # "-b branch" is accepted only by "add"
1033 if test -n "$branch" && test "$command" != add
1034 then
1035 usage
1038 # "--cached" is accepted only by "status" and "summary"
1039 if test -n "$cached" && test "$command" != status -a "$command" != summary
1040 then
1041 usage
1044 "cmd_$command" "$@"