lib/depcomp

   1 #! /bin/sh
   2 # depcomp - compile a program generating dependencies as side-effects
   3
   4 scriptversion=2012-10-18.11; # UTC
   5
   6 # Copyright (C) 1999-2012 Free Software Foundation, Inc.
   7
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2, or (at your option)
  11 # any later version.
  12
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 # As a special exception to the GNU General Public License, if you
  22 # distribute this file as part of a program that contains a
  23 # configuration script generated by Autoconf, you may include it under
  24 # the same distribution terms that you use for the rest of that program.
  25
  26 # Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
  27
  28 case $1 in
  29   '')
  30      echo "$0: No command.  Try '$0 --help' for more information." 1>&2
  31      exit 1;
  32      ;;
  33   -h | --h*)
  34     cat <<\EOF
  35 Usage: depcomp [--help] [--version] PROGRAM [ARGS]
  36
  37 Run PROGRAMS ARGS to compile a file, generating dependencies
  38 as side-effects.
  39
  40 Environment variables:
  41   depmode     Dependency tracking mode.
  42   source      Source file read by 'PROGRAMS ARGS'.
  43   object      Object file output by 'PROGRAMS ARGS'.
  44   DEPDIR      directory where to store dependencies.
  45   depfile     Dependency file to output.
  46   tmpdepfile  Temporary file to use when outputting dependencies.
  47   libtool     Whether libtool is used (yes/no).
  48
  49 Report bugs to <bug-automake@gnu.org>.
  50 EOF
  51     exit $?
  52     ;;
  53   -v | --v*)
  54     echo "depcomp $scriptversion"
  55     exit $?
  56     ;;
  57 esac
  58
  59 # A tabulation character.
  60 tab='   '
  61 # A newline character.
  62 nl='
  63 '
  64
  65 if test -z "$depmode" || test -z "$source" || test -z "$object"; then
  66   echo "depcomp: Variables source, object and depmode must be set" 1>&2
  67   exit 1
  68 fi
  69
  70 # Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
  71 depfile=${depfile-`echo "$object" |
  72   sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
  73 tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
  74
  75 rm -f "$tmpdepfile"
  76
  77 # Avoid interferences from the environment.
  78 gccflag= dashmflag=
  79
  80 # Some modes work just like other modes, but use different flags.  We
  81 # parameterize here, but still list the modes in the big case below,
  82 # to make depend.m4 easier to write.  Note that we *cannot* use a case
  83 # here, because this file can only contain one case statement.
  84 if test "$depmode" = hp; then
  85   # HP compiler uses -M and no extra arg.
  86   gccflag=-M
  87   depmode=gcc
  88 fi
  89
  90 if test "$depmode" = dashXmstdout; then
  91    # This is just like dashmstdout with a different argument.
  92    dashmflag=-xM
  93    depmode=dashmstdout
  94 fi
  95
  96 cygpath_u="cygpath -u -f -"
  97 if test "$depmode" = msvcmsys; then
  98    # This is just like msvisualcpp but w/o cygpath translation.
  99    # Just convert the backslash-escaped backslashes to single forward
 100    # slashes to satisfy depend.m4
 101    cygpath_u='sed s,\\\\,/,g'
 102    depmode=msvisualcpp
 103 fi
 104
 105 if test "$depmode" = msvc7msys; then
 106    # This is just like msvc7 but w/o cygpath translation.
 107    # Just convert the backslash-escaped backslashes to single forward
 108    # slashes to satisfy depend.m4
 109    cygpath_u='sed s,\\\\,/,g'
 110    depmode=msvc7
 111 fi
 112
 113 if test "$depmode" = xlc; then
 114    # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
 115    gccflag=-qmakedep=gcc,-MF
 116    depmode=gcc
 117 fi
 118
 119 case "$depmode" in
 120 gcc3)
 121 ## gcc 3 implements dependency tracking that does exactly what
 122 ## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
 123 ## it if -MD -MP comes after the -MF stuff.  Hmm.
 124 ## Unfortunately, FreeBSD c89 acceptance of flags depends upon
 125 ## the command line argument order; so add the flags where they
 126 ## appear in depend2.am.  Note that the slowdown incurred here
 127 ## affects only configure: in makefiles, %FASTDEP% shortcuts this.
 128   for arg
 129   do
 130     case $arg in
 131     -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
 132     *)  set fnord "$@" "$arg" ;;
 133     esac
 134     shift # fnord
 135     shift # $arg
 136   done
 137   "$@"
 138   stat=$?
 139   if test $stat -ne 0; then
 140     rm -f "$tmpdepfile"
 141     exit $stat
 142   fi
 143   mv "$tmpdepfile" "$depfile"
 144   ;;
 145
 146 gcc)
 147 ## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
 148 ## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
 149 ## (see the conditional assignment to $gccflag above).
 150 ## There are various ways to get dependency output from gcc.  Here's
 151 ## why we pick this rather obscure method:
 152 ## - Don't want to use -MD because we'd like the dependencies to end
 153 ##   up in a subdir.  Having to rename by hand is ugly.
 154 ##   (We might end up doing this anyway to support other compilers.)
 155 ## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
 156 ##   -MM, not -M (despite what the docs say).  Also, it might not be
 157 ##   supported by the other compilers which use the 'gcc' depmode.
 158 ## - Using -M directly means running the compiler twice (even worse
 159 ##   than renaming).
 160   if test -z "$gccflag"; then
 161     gccflag=-MD,
 162   fi
 163   "$@" -Wp,"$gccflag$tmpdepfile"
 164   stat=$?
 165   if test $stat -ne 0; then
 166     rm -f "$tmpdepfile"
 167     exit $stat
 168   fi
 169   rm -f "$depfile"
 170   echo "$object : \\" > "$depfile"
 171   alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
 172 ## The second -e expression handles DOS-style file names with drive letters.
 173   sed -e 's/^[^:]*: / /' \
 174       -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
 175 ## This next piece of magic avoids the "deleted header file" problem.
 176 ## The problem is that when a header file which appears in a .P file
 177 ## is deleted, the dependency causes make to die (because there is
 178 ## typically no way to rebuild the header).  We avoid this by adding
 179 ## dummy dependencies for each header file.  Too bad gcc doesn't do
 180 ## this for us directly.
 181   tr ' ' "$nl" < "$tmpdepfile" |
 182 ## Some versions of gcc put a space before the ':'.  On the theory
 183 ## that the space means something, we add a space to the output as
 184 ## well.  hp depmode also adds that space, but also prefixes the VPATH
 185 ## to the object.  Take care to not repeat it in the output.
 186 ## Some versions of the HPUX 10.20 sed can't process this invocation
 187 ## correctly.  Breaking it into two sed invocations is a workaround.
 188     sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
 189       | sed -e 's/$/ :/' >> "$depfile"
 190   rm -f "$tmpdepfile"
 191   ;;
 192
 193 hp)
 194   # This case exists only to let depend.m4 do its work.  It works by
 195   # looking at the text of this script.  This case will never be run,
 196   # since it is checked for above.
 197   exit 1
 198   ;;
 199
 200 sgi)
 201   if test "$libtool" = yes; then
 202     "$@" "-Wp,-MDupdate,$tmpdepfile"
 203   else
 204     "$@" -MDupdate "$tmpdepfile"
 205   fi
 206   stat=$?
 207   if test $stat -ne 0; then
 208     rm -f "$tmpdepfile"
 209     exit $stat
 210   fi
 211   rm -f "$depfile"
 212
 213   if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
 214     echo "$object : \\" > "$depfile"
 215
 216     # Clip off the initial element (the dependent).  Don't try to be
 217     # clever and replace this with sed code, as IRIX sed won't handle
 218     # lines with more than a fixed number of characters (4096 in
 219     # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
 220     # the IRIX cc adds comments like '#:fec' to the end of the
 221     # dependency line.
 222     tr ' ' "$nl" < "$tmpdepfile" \
 223     | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
 224     tr "$nl" ' ' >> "$depfile"
 225     echo >> "$depfile"
 226
 227     # The second pass generates a dummy entry for each header file.
 228     tr ' ' "$nl" < "$tmpdepfile" \
 229    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
 230    >> "$depfile"
 231   else
 232     # The sourcefile does not contain any dependencies, so just
 233     # store a dummy comment line, to avoid errors with the Makefile
 234     # "include basename.Plo" scheme.
 235     echo "#dummy" > "$depfile"
 236   fi
 237   rm -f "$tmpdepfile"
 238   ;;
 239
 240 xlc)
 241   # This case exists only to let depend.m4 do its work.  It works by
 242   # looking at the text of this script.  This case will never be run,
 243   # since it is checked for above.
 244   exit 1
 245   ;;
 246
 247 aix)
 248   # The C for AIX Compiler uses -M and outputs the dependencies
 249   # in a .u file.  In older versions, this file always lives in the
 250   # current directory.  Also, the AIX compiler puts '$object:' at the
 251   # start of each line; $object doesn't have directory information.
 252   # Version 6 uses the directory in both cases.
 253   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
 254   test "x$dir" = "x$object" && dir=
 255   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
 256   if test "$libtool" = yes; then
 257     tmpdepfile1=$dir$base.u
 258     tmpdepfile2=$base.u
 259     tmpdepfile3=$dir.libs/$base.u
 260     "$@" -Wc,-M
 261   else
 262     tmpdepfile1=$dir$base.u
 263     tmpdepfile2=$dir$base.u
 264     tmpdepfile3=$dir$base.u
 265     "$@" -M
 266   fi
 267   stat=$?
 268
 269   if test $stat -ne 0; then
 270     rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
 271     exit $stat
 272   fi
 273
 274   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
 275   do
 276     test -f "$tmpdepfile" && break
 277   done
 278   if test -f "$tmpdepfile"; then
 279     # Each line is of the form 'foo.o: dependent.h'.
 280     # Do two passes, one to just change these to
 281     # '$object: dependent.h' and one to simply 'dependent.h:'.
 282     sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
 283     sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
 284   else
 285     # The sourcefile does not contain any dependencies, so just
 286     # store a dummy comment line, to avoid errors with the Makefile
 287     # "include basename.Plo" scheme.
 288     echo "#dummy" > "$depfile"
 289   fi
 290   rm -f "$tmpdepfile"
 291   ;;
 292
 293 icc)
 294   # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'.
 295   # However on
 296   #    $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c
 297   # ICC 7.0 will fill foo.d with something like
 298   #    foo.o: sub/foo.c
 299   #    foo.o: sub/foo.h
 300   # which is wrong.  We want
 301   #    sub/foo.o: sub/foo.c
 302   #    sub/foo.o: sub/foo.h
 303   #    sub/foo.c:
 304   #    sub/foo.h:
 305   # ICC 7.1 will output
 306   #    foo.o: sub/foo.c sub/foo.h
 307   # and will wrap long lines using '\':
 308   #    foo.o: sub/foo.c ... \
 309   #     sub/foo.h ... \
 310   #     ...
 311   # tcc 0.9.26 (FIXME still under development at the moment of writing)
 312   # will emit a similar output, but also prepend the continuation lines
 313   # with horizontal tabulation characters.
 314   "$@" -MD -MF "$tmpdepfile"
 315   stat=$?
 316   if test $stat -ne 0; then
 317     rm -f "$tmpdepfile"
 318     exit $stat
 319   fi
 320   rm -f "$depfile"
 321   # Each line is of the form 'foo.o: dependent.h',
 322   # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'.
 323   # Do two passes, one to just change these to
 324   # '$object: dependent.h' and one to simply 'dependent.h:'.
 325   sed -e "s/^[ $tab][ $tab]*/  /" -e "s,^[^:]*:,$object :," \
 326     < "$tmpdepfile" > "$depfile"
 327   sed '
 328     s/[ '"$tab"'][ '"$tab"']*/ /g
 329     s/^ *//
 330     s/ *\\*$//
 331     s/^[^:]*: *//
 332     /^$/d
 333     /:$/d
 334     s/$/ :/
 335   ' < "$tmpdepfile" >> "$depfile"
 336   rm -f "$tmpdepfile"
 337   ;;
 338
 339 ## The order of this option in the case statement is important, since the
 340 ## shell code in configure will try each of these formats in the order
 341 ## listed in this file.  A plain '-MD' option would be understood by many
 342 ## compilers, so we must ensure this comes after the gcc and icc options.
 343 pgcc)
 344   # Portland's C compiler understands '-MD'.
 345   # Will always output deps to 'file.d' where file is the root name of the
 346   # source file under compilation, even if file resides in a subdirectory.
 347   # The object file name does not affect the name of the '.d' file.
 348   # pgcc 10.2 will output
 349   #    foo.o: sub/foo.c sub/foo.h
 350   # and will wrap long lines using '\' :
 351   #    foo.o: sub/foo.c ... \
 352   #     sub/foo.h ... \
 353   #     ...
 354   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
 355   test "x$dir" = "x$object" && dir=
 356   # Use the source, not the object, to determine the base name, since
 357   # that's sadly what pgcc will do too.
 358   base=`echo "$source" | sed -e 's|^.*/||' -e 's/\.[-_a-zA-Z0-9]*$//'`
 359   tmpdepfile=$base.d
 360
 361   # For projects that build the same source file twice into different object
 362   # files, the pgcc approach of using the *source* file root name can cause
 363   # problems in parallel builds.  Use a locking strategy to avoid stomping on
 364   # the same $tmpdepfile.
 365   lockdir=$base.d-lock
 366   trap "
 367     echo '$0: caught signal, cleaning up...' >&2
 368     rmdir $lockdir
 369     exit 1
 370   " 1 2 13 15
 371   numtries=100
 372   i=$numtries
 373   while test $i -gt 0 ; do
 374     # mkdir is a portable test-and-set.
 375     if mkdir $lockdir 2>/dev/null; then
 376       # This process acquired the lock.
 377       "$@" -MD
 378       stat=$?
 379       # Release the lock.
 380       rmdir $lockdir
 381       break
 382     else
 383       ## the lock is being held by a different process,
 384       ## wait until the winning process is done or we timeout
 385       while test -d $lockdir && test $i -gt 0; do
 386         sleep 1
 387         i=`expr $i - 1`
 388       done
 389     fi
 390     i=`expr $i - 1`
 391   done
 392   trap - 1 2 13 15
 393   if test $i -le 0; then
 394     echo "$0: failed to acquire lock after $numtries attempts" >&2
 395     echo "$0: check lockdir '$lockdir'" >&2
 396     exit 1
 397   fi
 398
 399   if test $stat -ne 0; then
 400     rm -f "$tmpdepfile"
 401     exit $stat
 402   fi
 403   rm -f "$depfile"
 404   # Each line is of the form `foo.o: dependent.h',
 405   # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
 406   # Do two passes, one to just change these to
 407   # `$object: dependent.h' and one to simply `dependent.h:'.
 408   sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
 409   # Some versions of the HPUX 10.20 sed can't process this invocation
 410   # correctly.  Breaking it into two sed invocations is a workaround.
 411   sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
 412     sed -e 's/$/ :/' >> "$depfile"
 413   rm -f "$tmpdepfile"
 414   ;;
 415
 416 hp2)
 417   # The "hp" stanza above does not work with aCC (C++) and HP's ia64
 418   # compilers, which have integrated preprocessors.  The correct option
 419   # to use with these is +Maked; it writes dependencies to a file named
 420   # 'foo.d', which lands next to the object file, wherever that
 421   # happens to be.
 422   # Much of this is similar to the tru64 case; see comments there.
 423   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
 424   test "x$dir" = "x$object" && dir=
 425   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
 426   if test "$libtool" = yes; then
 427     tmpdepfile1=$dir$base.d
 428     tmpdepfile2=$dir.libs/$base.d
 429     "$@" -Wc,+Maked
 430   else
 431     tmpdepfile1=$dir$base.d
 432     tmpdepfile2=$dir$base.d
 433     "$@" +Maked
 434   fi
 435   stat=$?
 436   if test $stat -ne 0; then
 437      rm -f "$tmpdepfile1" "$tmpdepfile2"
 438      exit $stat
 439   fi
 440
 441   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
 442   do
 443     test -f "$tmpdepfile" && break
 444   done
 445   if test -f "$tmpdepfile"; then
 446     sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
 447     # Add 'dependent.h:' lines.
 448     sed -ne '2,${
 449                s/^ *//
 450                s/ \\*$//
 451                s/$/:/
 452                p
 453              }' "$tmpdepfile" >> "$depfile"
 454   else
 455     echo "#dummy" > "$depfile"
 456   fi
 457   rm -f "$tmpdepfile" "$tmpdepfile2"
 458   ;;
 459
 460 tru64)
 461    # The Tru64 compiler uses -MD to generate dependencies as a side
 462    # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
 463    # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
 464    # dependencies in 'foo.d' instead, so we check for that too.
 465    # Subdirectories are respected.
 466    dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
 467    test "x$dir" = "x$object" && dir=
 468    base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
 469
 470    if test "$libtool" = yes; then
 471       # With Tru64 cc, shared objects can also be used to make a
 472       # static library.  This mechanism is used in libtool 1.4 series to
 473       # handle both shared and static libraries in a single compilation.
 474       # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
 475       #
 476       # With libtool 1.5 this exception was removed, and libtool now
 477       # generates 2 separate objects for the 2 libraries.  These two
 478       # compilations output dependencies in $dir.libs/$base.o.d and
 479       # in $dir$base.o.d.  We have to check for both files, because
 480       # one of the two compilations can be disabled.  We should prefer
 481       # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
 482       # automatically cleaned when .libs/ is deleted, while ignoring
 483       # the former would cause a distcleancheck panic.
 484       tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
 485       tmpdepfile2=$dir$base.o.d          # libtool 1.5
 486       tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
 487       tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
 488       "$@" -Wc,-MD
 489    else
 490       tmpdepfile1=$dir$base.o.d
 491       tmpdepfile2=$dir$base.d
 492       tmpdepfile3=$dir$base.d
 493       tmpdepfile4=$dir$base.d
 494       "$@" -MD
 495    fi
 496
 497    stat=$?
 498    if test $stat -ne 0; then
 499       rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
 500       exit $stat
 501    fi
 502
 503    for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
 504    do
 505      test -f "$tmpdepfile" && break
 506    done
 507    if test -f "$tmpdepfile"; then
 508       sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
 509       sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
 510    else
 511       echo "#dummy" > "$depfile"
 512    fi
 513    rm -f "$tmpdepfile"
 514    ;;
 515
 516 msvc7)
 517   if test "$libtool" = yes; then
 518     showIncludes=-Wc,-showIncludes
 519   else
 520     showIncludes=-showIncludes
 521   fi
 522   "$@" $showIncludes > "$tmpdepfile"
 523   stat=$?
 524   grep -v '^Note: including file: ' "$tmpdepfile"
 525   if test $stat -ne 0; then
 526     rm -f "$tmpdepfile"
 527     exit $stat
 528   fi
 529   rm -f "$depfile"
 530   echo "$object : \\" > "$depfile"
 531   # The first sed program below extracts the file names and escapes
 532   # backslashes for cygpath.  The second sed program outputs the file
 533   # name when reading, but also accumulates all include files in the
 534   # hold buffer in order to output them again at the end.  This only
 535   # works with sed implementations that can handle large buffers.
 536   sed < "$tmpdepfile" -n '
 537 /^Note: including file:  *\(.*\)/ {
 538   s//\1/
 539   s/\\/\\\\/g
 540   p
 541 }' | $cygpath_u | sort -u | sed -n '
 542 s/ /\\ /g
 543 s/\(.*\)/'"$tab"'\1 \\/p
 544 s/.\(.*\) \\/\1:/
 545 H
 546 $ {
 547   s/.*/'"$tab"'/
 548   G
 549   p
 550 }' >> "$depfile"
 551   rm -f "$tmpdepfile"
 552   ;;
 553
 554 msvc7msys)
 555   # This case exists only to let depend.m4 do its work.  It works by
 556   # looking at the text of this script.  This case will never be run,
 557   # since it is checked for above.
 558   exit 1
 559   ;;
 560
 561 #nosideeffect)
 562   # This comment above is used by automake to tell side-effect
 563   # dependency tracking mechanisms from slower ones.
 564
 565 dashmstdout)
 566   # Important note: in order to support this mode, a compiler *must*
 567   # always write the preprocessed file to stdout, regardless of -o.
 568   "$@" || exit $?
 569
 570   # Remove the call to Libtool.
 571   if test "$libtool" = yes; then
 572     while test "X$1" != 'X--mode=compile'; do
 573       shift
 574     done
 575     shift
 576   fi
 577
 578   # Remove '-o $object'.
 579   IFS=" "
 580   for arg
 581   do
 582     case $arg in
 583     -o)
 584       shift
 585       ;;
 586     $object)
 587       shift
 588       ;;
 589     *)
 590       set fnord "$@" "$arg"
 591       shift # fnord
 592       shift # $arg
 593       ;;
 594     esac
 595   done
 596
 597   test -z "$dashmflag" && dashmflag=-M
 598   # Require at least two characters before searching for ':'
 599   # in the target name.  This is to cope with DOS-style filenames:
 600   # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
 601   "$@" $dashmflag |
 602     sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile"
 603   rm -f "$depfile"
 604   cat < "$tmpdepfile" > "$depfile"
 605   tr ' ' "$nl" < "$tmpdepfile" | \
 606 ## Some versions of the HPUX 10.20 sed can't process this invocation
 607 ## correctly.  Breaking it into two sed invocations is a workaround.
 608     sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
 609   rm -f "$tmpdepfile"
 610   ;;
 611
 612 dashXmstdout)
 613   # This case only exists to satisfy depend.m4.  It is never actually
 614   # run, as this mode is specially recognized in the preamble.
 615   exit 1
 616   ;;
 617
 618 makedepend)
 619   "$@" || exit $?
 620   # Remove any Libtool call
 621   if test "$libtool" = yes; then
 622     while test "X$1" != 'X--mode=compile'; do
 623       shift
 624     done
 625     shift
 626   fi
 627   # X makedepend
 628   shift
 629   cleared=no eat=no
 630   for arg
 631   do
 632     case $cleared in
 633     no)
 634       set ""; shift
 635       cleared=yes ;;
 636     esac
 637     if test $eat = yes; then
 638       eat=no
 639       continue
 640     fi
 641     case "$arg" in
 642     -D*|-I*)
 643       set fnord "$@" "$arg"; shift ;;
 644     # Strip any option that makedepend may not understand.  Remove
 645     # the object too, otherwise makedepend will parse it as a source file.
 646     -arch)
 647       eat=yes ;;
 648     -*|$object)
 649       ;;
 650     *)
 651       set fnord "$@" "$arg"; shift ;;
 652     esac
 653   done
 654   obj_suffix=`echo "$object" | sed 's/^.*\././'`
 655   touch "$tmpdepfile"
 656   ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
 657   rm -f "$depfile"
 658   # makedepend may prepend the VPATH from the source file name to the object.
 659   # No need to regex-escape $object, excess matching of '.' is harmless.
 660   sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
 661   sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \
 662 ## Some versions of the HPUX 10.20 sed can't process this invocation
 663 ## correctly.  Breaking it into two sed invocations is a workaround.
 664     sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
 665   rm -f "$tmpdepfile" "$tmpdepfile".bak
 666   ;;
 667
 668 cpp)
 669   # Important note: in order to support this mode, a compiler *must*
 670   # always write the preprocessed file to stdout.
 671   "$@" || exit $?
 672
 673   # Remove the call to Libtool.
 674   if test "$libtool" = yes; then
 675     while test "X$1" != 'X--mode=compile'; do
 676       shift
 677     done
 678     shift
 679   fi
 680
 681   # Remove '-o $object'.
 682   IFS=" "
 683   for arg
 684   do
 685     case $arg in
 686     -o)
 687       shift
 688       ;;
 689     $object)
 690       shift
 691       ;;
 692     *)
 693       set fnord "$@" "$arg"
 694       shift # fnord
 695       shift # $arg
 696       ;;
 697     esac
 698   done
 699
 700   "$@" -E |
 701     sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
 702        -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
 703     sed '$ s: \\$::' > "$tmpdepfile"
 704   rm -f "$depfile"
 705   echo "$object : \\" > "$depfile"
 706   cat < "$tmpdepfile" >> "$depfile"
 707   sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
 708   rm -f "$tmpdepfile"
 709   ;;
 710
 711 msvisualcpp)
 712   # Important note: in order to support this mode, a compiler *must*
 713   # always write the preprocessed file to stdout.
 714   "$@" || exit $?
 715
 716   # Remove the call to Libtool.
 717   if test "$libtool" = yes; then
 718     while test "X$1" != 'X--mode=compile'; do
 719       shift
 720     done
 721     shift
 722   fi
 723
 724   IFS=" "
 725   for arg
 726   do
 727     case "$arg" in
 728     -o)
 729       shift
 730       ;;
 731     $object)
 732       shift
 733       ;;
 734     "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
 735         set fnord "$@"
 736         shift
 737         shift
 738         ;;
 739     *)
 740         set fnord "$@" "$arg"
 741         shift
 742         shift
 743         ;;
 744     esac
 745   done
 746   "$@" -E 2>/dev/null |
 747   sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
 748   rm -f "$depfile"
 749   echo "$object : \\" > "$depfile"
 750   sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
 751   echo "$tab" >> "$depfile"
 752   sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
 753   rm -f "$tmpdepfile"
 754   ;;
 755
 756 msvcmsys)
 757   # This case exists only to let depend.m4 do its work.  It works by
 758   # looking at the text of this script.  This case will never be run,
 759   # since it is checked for above.
 760   exit 1
 761   ;;
 762
 763 none)
 764   exec "$@"
 765   ;;
 766
 767 *)
 768   echo "Unknown depmode $depmode" 1>&2
 769   exit 1
 770   ;;
 771 esac
 772
 773 exit 0
 774
 775 # Local Variables:
 776 # mode: shell-script
 777 # sh-indentation: 2
 778 # eval: (add-hook 'write-file-hooks 'time-stamp)
 779 # time-stamp-start: "scriptversion="
 780 # time-stamp-format: "%:y-%02m-%02d.%02H"
 781 # time-stamp-time-zone: "UTC"
 782 # time-stamp-end: "; # UTC"
 783 # End: