~elementary-os/elementaryos/os-patch-network-manager-applet-bionic

« back to all changes in this revision

Viewing changes to depcomp

  • Committer: RabbitBot
  • Date: 2018-02-05 14:05:13 UTC
  • Revision ID: rabbitbot@elementary.io-20180205140513-3yr81c4ly6dt6rxa
Initial import, version 1.8.10-2ubuntu1

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