~ubuntu-branches/ubuntu/maverick/texinfo/maverick

« back to all changes in this revision

Viewing changes to depcomp

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Preining
  • Date: 2005-10-28 15:10:30 UTC
  • mto: (2.1.1 dapper) (3.1.4 hardy)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20051028151030-9nsf2s2k2z3fktjt
Tags: upstream-4.8
ImportĀ upstreamĀ versionĀ 4.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
 
 
3
2
# depcomp - compile a program generating dependencies as side-effects
4
 
# Copyright 1999, 2000 Free Software Foundation, Inc.
 
3
 
 
4
scriptversion=2004-05-31.23
 
5
 
 
6
# Copyright (C) 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
5
7
 
6
8
# This program is free software; you can redistribute it and/or modify
7
9
# it under the terms of the GNU General Public License as published by
25
27
 
26
28
# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
27
29
 
 
30
case $1 in
 
31
  '')
 
32
     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2
 
33
     exit 1;
 
34
     ;;
 
35
  -h | --h*)
 
36
    cat <<\EOF
 
37
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
 
38
 
 
39
Run PROGRAMS ARGS to compile a file, generating dependencies
 
40
as side-effects.
 
41
 
 
42
Environment variables:
 
43
  depmode     Dependency tracking mode.
 
44
  source      Source file read by `PROGRAMS ARGS'.
 
45
  object      Object file output by `PROGRAMS ARGS'.
 
46
  DEPDIR      directory where to store dependencies.
 
47
  depfile     Dependency file to output.
 
48
  tmpdepfile  Temporary file to use when outputing dependencies.
 
49
  libtool     Whether libtool is used (yes/no).
 
50
 
 
51
Report bugs to <bug-automake@gnu.org>.
 
52
EOF
 
53
    exit 0
 
54
    ;;
 
55
  -v | --v*)
 
56
    echo "depcomp $scriptversion"
 
57
    exit 0
 
58
    ;;
 
59
esac
 
60
 
28
61
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
29
62
  echo "depcomp: Variables source, object and depmode must be set" 1>&2
30
63
  exit 1
31
64
fi
32
 
# `libtool' can also be set to `yes' or `no'.
33
65
 
34
 
depfile=${depfile-`echo "$object" | sed 's,\([^/]*\)$,.deps/\1,;s/\.\([^.]*\)$/.P\1/'`}
 
66
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
 
67
depfile=${depfile-`echo "$object" |
 
68
  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
35
69
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
36
70
 
37
71
rm -f "$tmpdepfile"
163
197
 
164
198
aix)
165
199
  # The C for AIX Compiler uses -M and outputs the dependencies
166
 
  # in a .u file.  This file always lives in the current directory.
167
 
  # Also, the AIX compiler puts `$object:' at the start of each line;
168
 
  # $object doesn't have directory information.
169
 
  stripped=`echo "$object" | sed -e 's,^.*/,,' -e 's/\(.*\)\..*$/\1/'`
 
200
  # in a .u file.  In older versions, this file always lives in the
 
201
  # current directory.  Also, the AIX compiler puts `$object:' at the
 
202
  # start of each line; $object doesn't have directory information.
 
203
  # Version 6 uses the directory in both cases.
 
204
  stripped=`echo "$object" | sed 's/\(.*\)\..*$/\1/'`
170
205
  tmpdepfile="$stripped.u"
171
 
  outname="$stripped.o"
172
206
  if test "$libtool" = yes; then
173
207
    "$@" -Wc,-M
174
208
  else
175
209
    "$@" -M
176
210
  fi
177
 
 
178
211
  stat=$?
 
212
 
 
213
  if test -f "$tmpdepfile"; then :
 
214
  else
 
215
    stripped=`echo "$stripped" | sed 's,^.*/,,'`
 
216
    tmpdepfile="$stripped.u"
 
217
  fi
 
218
 
179
219
  if test $stat -eq 0; then :
180
220
  else
181
221
    rm -f "$tmpdepfile"
183
223
  fi
184
224
 
185
225
  if test -f "$tmpdepfile"; then
 
226
    outname="$stripped.o"
186
227
    # Each line is of the form `foo.o: dependent.h'.
187
228
    # Do two passes, one to just change these to
188
229
    # `$object: dependent.h' and one to simply `dependent.h:'.
197
238
  rm -f "$tmpdepfile"
198
239
  ;;
199
240
 
 
241
icc)
 
242
  # Intel's C compiler understands `-MD -MF file'.  However on
 
243
  #    icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
 
244
  # ICC 7.0 will fill foo.d with something like
 
245
  #    foo.o: sub/foo.c
 
246
  #    foo.o: sub/foo.h
 
247
  # which is wrong.  We want:
 
248
  #    sub/foo.o: sub/foo.c
 
249
  #    sub/foo.o: sub/foo.h
 
250
  #    sub/foo.c:
 
251
  #    sub/foo.h:
 
252
  # ICC 7.1 will output
 
253
  #    foo.o: sub/foo.c sub/foo.h
 
254
  # and will wrap long lines using \ :
 
255
  #    foo.o: sub/foo.c ... \
 
256
  #     sub/foo.h ... \
 
257
  #     ...
 
258
 
 
259
  "$@" -MD -MF "$tmpdepfile"
 
260
  stat=$?
 
261
  if test $stat -eq 0; then :
 
262
  else
 
263
    rm -f "$tmpdepfile"
 
264
    exit $stat
 
265
  fi
 
266
  rm -f "$depfile"
 
267
  # Each line is of the form `foo.o: dependent.h',
 
268
  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
 
269
  # Do two passes, one to just change these to
 
270
  # `$object: dependent.h' and one to simply `dependent.h:'.
 
271
  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
 
272
  # Some versions of the HPUX 10.20 sed can't process this invocation
 
273
  # correctly.  Breaking it into two sed invocations is a workaround.
 
274
  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
 
275
    sed -e 's/$/ :/' >> "$depfile"
 
276
  rm -f "$tmpdepfile"
 
277
  ;;
 
278
 
200
279
tru64)
201
 
   # The Tru64 AIX compiler uses -MD to generate dependencies as a side
 
280
   # The Tru64 compiler uses -MD to generate dependencies as a side
202
281
   # effect.  `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
203
 
   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put 
 
282
   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
204
283
   # dependencies in `foo.d' instead, so we check for that too.
205
284
   # Subdirectories are respected.
 
285
   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
 
286
   test "x$dir" = "x$object" && dir=
 
287
   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
206
288
 
207
 
   tmpdepfile1="$object.d"
208
 
   tmpdepfile2=`echo "$object" | sed -e 's/.o$/.d/'` 
209
289
   if test "$libtool" = yes; then
 
290
      # Dependencies are output in .lo.d with libtool 1.4.
 
291
      # With libtool 1.5 they are output both in $dir.libs/$base.o.d
 
292
      # and in $dir.libs/$base.o.d and $dir$base.o.d.  We process the
 
293
      # latter, because the former will be cleaned when $dir.libs is
 
294
      # erased.
 
295
      tmpdepfile1="$dir.libs/$base.lo.d"
 
296
      tmpdepfile2="$dir$base.o.d"
 
297
      tmpdepfile3="$dir.libs/$base.d"
210
298
      "$@" -Wc,-MD
211
299
   else
 
300
      tmpdepfile1="$dir$base.o.d"
 
301
      tmpdepfile2="$dir$base.d"
 
302
      tmpdepfile3="$dir$base.d"
212
303
      "$@" -MD
213
304
   fi
214
305
 
215
306
   stat=$?
216
307
   if test $stat -eq 0; then :
217
308
   else
218
 
      rm -f "$tmpdepfile1" "$tmpdepfile2"
 
309
      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
219
310
      exit $stat
220
311
   fi
221
312
 
222
313
   if test -f "$tmpdepfile1"; then
223
314
      tmpdepfile="$tmpdepfile1"
224
 
   else
 
315
   elif test -f "$tmpdepfile2"; then
225
316
      tmpdepfile="$tmpdepfile2"
 
317
   else
 
318
      tmpdepfile="$tmpdepfile3"
226
319
   fi
227
320
   if test -f "$tmpdepfile"; then
228
321
      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
229
 
      # That's a space and a tab in the [].
230
 
      sed -e 's,^.*\.[a-z]*:[   ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
 
322
      # That's a tab and a space in the [].
 
323
      sed -e 's,^.*\.[a-z]*:[    ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
231
324
   else
232
325
      echo "#dummy" > "$depfile"
233
326
   fi
240
333
 
241
334
dashmstdout)
242
335
  # Important note: in order to support this mode, a compiler *must*
243
 
  # always write the proprocessed file to stdout, regardless of -o,
244
 
  # because we must use -o when running libtool.
 
336
  # always write the preprocessed file to stdout, regardless of -o.
 
337
  "$@" || exit $?
 
338
 
 
339
  # Remove the call to Libtool.
 
340
  if test "$libtool" = yes; then
 
341
    while test $1 != '--mode=compile'; do
 
342
      shift
 
343
    done
 
344
    shift
 
345
  fi
 
346
 
 
347
  # Remove `-o $object'.
 
348
  IFS=" "
 
349
  for arg
 
350
  do
 
351
    case $arg in
 
352
    -o)
 
353
      shift
 
354
      ;;
 
355
    $object)
 
356
      shift
 
357
      ;;
 
358
    *)
 
359
      set fnord "$@" "$arg"
 
360
      shift # fnord
 
361
      shift # $arg
 
362
      ;;
 
363
    esac
 
364
  done
 
365
 
245
366
  test -z "$dashmflag" && dashmflag=-M
246
 
  ( IFS=" "
247
 
    case " $* " in
248
 
    *" --mode=compile "*) # this is libtool, let us make it quiet
249
 
      for arg
250
 
      do # cycle over the arguments
251
 
        case "$arg" in
252
 
        "--mode=compile")
253
 
          # insert --quiet before "--mode=compile"
254
 
          set fnord "$@" --quiet
255
 
          shift # fnord
256
 
          ;;
257
 
        esac
258
 
        set fnord "$@" "$arg"
259
 
        shift # fnord
260
 
        shift # "$arg"
261
 
      done
262
 
      ;;
263
 
    esac
264
 
    "$@" $dashmflag | sed 's:^[^:]*\:[  ]*:'"$object"'\: :' > "$tmpdepfile"
265
 
  ) &
266
 
  proc=$!
267
 
  "$@"
268
 
  stat=$?
269
 
  wait "$proc"
270
 
  if test "$stat" != 0; then exit $stat; fi
 
367
  # Require at least two characters before searching for `:'
 
368
  # in the target name.  This is to cope with DOS-style filenames:
 
369
  # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
 
370
  "$@" $dashmflag |
 
371
    sed 's:^[  ]*[^: ][^:][^:]*\:[    ]*:'"$object"'\: :' > "$tmpdepfile"
271
372
  rm -f "$depfile"
272
373
  cat < "$tmpdepfile" > "$depfile"
273
374
  tr ' ' '
285
386
  ;;
286
387
 
287
388
makedepend)
 
389
  "$@" || exit $?
 
390
  # Remove any Libtool call
 
391
  if test "$libtool" = yes; then
 
392
    while test $1 != '--mode=compile'; do
 
393
      shift
 
394
    done
 
395
    shift
 
396
  fi
288
397
  # X makedepend
289
 
  (
290
 
    shift
291
 
    cleared=no
292
 
    for arg in "$@"; do
293
 
      case $cleared in no)
294
 
        set ""; shift
295
 
        cleared=yes
296
 
      esac
297
 
      case "$arg" in
298
 
        -D*|-I*)
299
 
          set fnord "$@" "$arg"; shift;;
300
 
        -*)
301
 
          ;;
302
 
        *)
303
 
          set fnord "$@" "$arg"; shift;;
304
 
      esac
305
 
    done
306
 
    obj_suffix="`echo $object | sed 's/^.*\././'`"
307
 
    touch "$tmpdepfile"
308
 
    ${MAKEDEPEND-makedepend} 2>/dev/null -o"$obj_suffix" -f"$tmpdepfile" "$@"
309
 
  ) &
310
 
  proc=$!
311
 
  "$@"
312
 
  stat=$?
313
 
  wait "$proc"
314
 
  if test "$stat" != 0; then exit $stat; fi
 
398
  shift
 
399
  cleared=no
 
400
  for arg in "$@"; do
 
401
    case $cleared in
 
402
    no)
 
403
      set ""; shift
 
404
      cleared=yes ;;
 
405
    esac
 
406
    case "$arg" in
 
407
    -D*|-I*)
 
408
      set fnord "$@" "$arg"; shift ;;
 
409
    # Strip any option that makedepend may not understand.  Remove
 
410
    # the object too, otherwise makedepend will parse it as a source file.
 
411
    -*|$object)
 
412
      ;;
 
413
    *)
 
414
      set fnord "$@" "$arg"; shift ;;
 
415
    esac
 
416
  done
 
417
  obj_suffix="`echo $object | sed 's/^.*\././'`"
 
418
  touch "$tmpdepfile"
 
419
  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
315
420
  rm -f "$depfile"
316
421
  cat < "$tmpdepfile" > "$depfile"
317
 
  tail +3 "$tmpdepfile" | tr ' ' '
 
422
  sed '1,2d' "$tmpdepfile" | tr ' ' '
318
423
' | \
319
424
## Some versions of the HPUX 10.20 sed can't process this invocation
320
425
## correctly.  Breaking it into two sed invocations is a workaround.
324
429
 
325
430
cpp)
326
431
  # Important note: in order to support this mode, a compiler *must*
327
 
  # always write the proprocessed file to stdout, regardless of -o,
328
 
  # because we must use -o when running libtool.
329
 
  ( IFS=" "
330
 
    case " $* " in
331
 
    *" --mode=compile "*)
332
 
      for arg
333
 
      do # cycle over the arguments
334
 
        case $arg in
335
 
        "--mode=compile")
336
 
          # insert --quiet before "--mode=compile"
337
 
          set fnord "$@" --quiet
338
 
          shift # fnord
339
 
          ;;
340
 
        esac
341
 
        set fnord "$@" "$arg"
342
 
        shift # fnord
343
 
        shift # "$arg"
344
 
      done
 
432
  # always write the preprocessed file to stdout.
 
433
  "$@" || exit $?
 
434
 
 
435
  # Remove the call to Libtool.
 
436
  if test "$libtool" = yes; then
 
437
    while test $1 != '--mode=compile'; do
 
438
      shift
 
439
    done
 
440
    shift
 
441
  fi
 
442
 
 
443
  # Remove `-o $object'.
 
444
  IFS=" "
 
445
  for arg
 
446
  do
 
447
    case $arg in
 
448
    -o)
 
449
      shift
 
450
      ;;
 
451
    $object)
 
452
      shift
 
453
      ;;
 
454
    *)
 
455
      set fnord "$@" "$arg"
 
456
      shift # fnord
 
457
      shift # $arg
345
458
      ;;
346
459
    esac
347
 
    "$@" -E |
 
460
  done
 
461
 
 
462
  "$@" -E |
348
463
    sed -n '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
349
464
    sed '$ s: \\$::' > "$tmpdepfile"
350
 
  ) &
351
 
  proc=$!
352
 
  "$@"
353
 
  stat=$?
354
 
  wait "$proc"
355
 
  if test "$stat" != 0; then exit $stat; fi
356
465
  rm -f "$depfile"
357
466
  echo "$object : \\" > "$depfile"
358
467
  cat < "$tmpdepfile" >> "$depfile"
362
471
 
363
472
msvisualcpp)
364
473
  # Important note: in order to support this mode, a compiler *must*
365
 
  # always write the proprocessed file to stdout, regardless of -o,
 
474
  # always write the preprocessed file to stdout, regardless of -o,
366
475
  # because we must use -o when running libtool.
367
 
  ( IFS=" "
368
 
    case " $* " in
369
 
    *" --mode=compile "*)
370
 
      for arg
371
 
      do # cycle over the arguments
372
 
        case $arg in
373
 
        "--mode=compile")
374
 
          # insert --quiet before "--mode=compile"
375
 
          set fnord "$@" --quiet
376
 
          shift # fnord
377
 
          ;;
378
 
        esac
 
476
  "$@" || exit $?
 
477
  IFS=" "
 
478
  for arg
 
479
  do
 
480
    case "$arg" in
 
481
    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
 
482
        set fnord "$@"
 
483
        shift
 
484
        shift
 
485
        ;;
 
486
    *)
379
487
        set fnord "$@" "$arg"
380
 
        shift # fnord
381
 
        shift # "$arg"
382
 
      done
383
 
      ;;
 
488
        shift
 
489
        shift
 
490
        ;;
384
491
    esac
385
 
    "$@" -E |
386
 
    sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"
387
 
  ) &
388
 
  proc=$!
389
 
  "$@"
390
 
  stat=$?
391
 
  wait "$proc"
392
 
  if test "$stat" != 0; then exit $stat; fi
 
492
  done
 
493
  "$@" -E |
 
494
  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"
393
495
  rm -f "$depfile"
394
496
  echo "$object : \\" > "$depfile"
395
497
  . "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::    \1 \\:p' >> "$depfile"
409
511
esac
410
512
 
411
513
exit 0
 
514
 
 
515
# Local Variables:
 
516
# mode: shell-script
 
517
# sh-indentation: 2
 
518
# eval: (add-hook 'write-file-hooks 'time-stamp)
 
519
# time-stamp-start: "scriptversion="
 
520
# time-stamp-format: "%:y-%02m-%02d.%02H"
 
521
# time-stamp-end: "$"
 
522
# End: