~neutrinodevs/neutrino/trunk

« back to all changes in this revision

Viewing changes to depcomp

  • Committer: Raphael Isemann
  • Date: 2012-10-17 21:33:51 UTC
  • Revision ID: teemperor@googlemail.com-20121017213351-ifiolp4tzbqze6fc
first implementation

Show diffs side-by-side

added added

removed removed

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