~ubuntu-branches/ubuntu/trusty/nbdkit/trusty-proposed

« back to all changes in this revision

Viewing changes to depcomp

  • Committer: Package Import Robot
  • Author(s): Hilko Bengen
  • Date: 2013-08-02 22:09:57 UTC
  • Revision ID: package-import@ubuntu.com-20130802220957-ccjs88t5jka0zqkl
Tags: upstream-1.1.2
ImportĀ upstreamĀ versionĀ 1.1.2

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